@saasontools/strauss-kb 0.1.19 → 0.1.20

package/dist/{chunk-MNQNHYWL.js → chunk-QQLPJO4R.js}

@@ -16,9 +16,24 @@ var kbVerifiedEventSchema = kbActorStampSchema.extend({
     message: "note must say what the check found"
   })
 });
+var kbAnchorSpanSchema = z.object({
+  start: z.number().int().positive(),
+  end: z.number().int().positive()
+}).strict();
 var kbAnchorSchema = z.object({
   file: z.string().min(1),
   symbol: 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: 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
@@ -57,8 +72,38 @@ var kbAnchorSchema = 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: z.enum(["tree-sitter", "regex"]).optional()
+  resolver: z.enum(["tree-sitter", "regex", "span"]).optional()
 }).strict();
+var kbAnchorWriteSchema = kbAnchorSchema.superRefine((anchor, ctx) => {
+  if (anchor.span && anchor.symbol) {
+    ctx.addIssue({
+      code: 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: z.ZodIssueCode.custom,
+      path: ["span", "end"],
+      message: "span end must not precede start"
+    });
+  }
+  if (anchor.span && anchor.hash_kind === "ast") {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["hash_kind"],
+      message: "a span is hashed raw, never ast"
+    });
+  }
+  if (anchor.side === "old" && !anchor.ref) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["ref"],
+      message: 'side: "old" needs a ref \u2014 committed code has no other address'
+    });
+  }
+});
 var kbLinkSchema = z.object({
   target: z.string().min(1),
   rel: z.string().min(1)
@@ -275,7 +320,7 @@ var composeInputSchema = z2.object({
   why: z2.string().min(1),
   /** Keyed by section heading from the type's spec. Unknown keys rejected. */
   sections: z2.record(z2.string(), z2.string().min(1)).optional(),
-  anchors: z2.array(kbAnchorSchema).optional(),
+  anchors: z2.array(kbAnchorWriteSchema).optional(),
   sources: z2.array(kbSourceSchema).optional(),
   /** No source exists, as a claim rather than a sentinel in `sources`. */
   assumption: z2.boolean().optional(),
@@ -622,7 +667,9 @@ function transportReason(stderr) {
 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);
@@ -639,6 +686,11 @@ function refShapeIsSafe(ref) {
   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]);
@@ -694,10 +746,10 @@ async function readRemoteAnchors(wants, options = {}) {
   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: [] };
+    const key2 = normalizeRepoUrl(want.repo);
+    const group2 = byRepo.get(key2) ?? { url: want.repo.trim(), wants: [] };
     group2.wants.push(want);
-    byRepo.set(key, group2);
+    byRepo.set(key2, group2);
   }
   const groups = [...byRepo.entries()];
   const results = await mapLimit(
@@ -710,7 +762,7 @@ async function readRemoteAnchors(wants, options = {}) {
     })
   );
   for (const result of results) {
-    for (const [key, read] of result) out.set(key, read);
+    for (const [key2, read] of result) out.set(key2, read);
   }
   return out;
 }
@@ -952,6 +1004,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;
@@ -1128,7 +1181,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/index.ts
@@ -1144,8 +1197,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(
@@ -1169,9 +1222,9 @@ ${lf(await readFile3(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) {
@@ -1469,8 +1522,8 @@ var TreeSitterResolver = class {
   }
   /** Parsed trees are keyed by content hash, so an unchanged file parses once. */
   parse(language, loaded, source) {
-    const key = `${language}:${createHash2("sha256").update(source).digest("hex")}`;
-    const cached2 = this.trees.get(key);
+    const key2 = `${language}:${createHash2("sha256").update(source).digest("hex")}`;
+    const cached2 = this.trees.get(key2);
     if (cached2) {
       this.stats.cacheHits += 1;
       return cached2;
@@ -1494,7 +1547,7 @@ var TreeSitterResolver = class {
         this.trees.delete(oldest.value);
       }
     }
-    this.trees.set(key, parsed);
+    this.trees.set(key2, parsed);
     return parsed;
   }
   /**
@@ -1655,8 +1708,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();
@@ -1677,42 +1730,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) {
@@ -1734,6 +1800,7 @@ function resolveAnchor(source, anchor, resolver = regexResolver) {
 }
 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();
@@ -1746,11 +1813,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);
@@ -1763,12 +1836,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);
@@ -1787,11 +1876,150 @@ 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" };
 }
 
+// src/drift/git.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
+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 execFileAsync3("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/anchor-resolver/drift.ts
 async function detectAnchorDrift(records, options = {}) {
   const repoRoot = options.repoRoot ?? process.cwd();
@@ -1820,37 +2048,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 }];
@@ -1861,6 +2112,7 @@ function base(anchor) {
   return {
     file: anchor.file,
     ...anchor.symbol ? { symbol: anchor.symbol } : {},
+    ...anchor.side === "old" ? { side: "old" } : {},
     storedHash: anchor.hash
   };
 }
@@ -1874,9 +2126,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;
 }
@@ -1928,9 +2186,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);
@@ -1945,6 +2203,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, {
@@ -1969,9 +2234,15 @@ var Fault = /* @__PURE__ */ ((Fault2) => {
 })(Fault || {});
 var ErrorTypes = /* @__PURE__ */ ((ErrorTypes2) => {
   ErrorTypes2["KbRecordAlreadyExists"] = "KbRecordAlreadyExists";
+  ErrorTypes2["KbClassifyInput"] = "KbClassifyInput";
   ErrorTypes2["KbInvalidConceptId"] = "KbInvalidConceptId";
+  ErrorTypes2["KbMatchInput"] = "KbMatchInput";
   ErrorTypes2["KbMissingFlagValue"] = "KbMissingFlagValue";
   ErrorTypes2["KbPackBudgetExceeded"] = "KbPackBudgetExceeded";
+  ErrorTypes2["KbPromoteCollision"] = "KbPromoteCollision";
+  ErrorTypes2["KbPromoteSelf"] = "KbPromoteSelf";
+  ErrorTypes2["KbPromoteStanding"] = "KbPromoteStanding";
+  ErrorTypes2["KbPromoteStopped"] = "KbPromoteStopped";
   ErrorTypes2["KbRecordNotFound"] = "KbRecordNotFound";
   ErrorTypes2["KbSelfVerification"] = "KbSelfVerification";
   ErrorTypes2["KbStampBaselineUnreadable"] = "KbStampBaselineUnreadable";
@@ -2117,6 +2388,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({
@@ -2165,8 +2519,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);
@@ -2598,14 +2952,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
   };
 }
@@ -2626,336 +2980,285 @@ function renderCatalogLine(entry) {
   return `- ${parts.join(" \xB7 ")}`;
 }
 
-// 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")}
-`;
+// 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 indexIsStale(stored, expected) {
-  return stored !== expected;
+function asIndex(ranges) {
+  return isIndex(ranges) ? ranges : symbolRangeIndex(ranges);
 }
-
-// src/kb-context.ts
-import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
-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 isIndex(ranges) {
+  return !Array.isArray(ranges);
 }
-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");
+function anchorOnHunk(record, filePath, hunk, symbolRanges = []) {
+  return placeOnHunk(record, filePath, hunk, symbolRanges).anchor;
 }
-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."
-    };
+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 };
+    }
   }
-  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 } : {}
-  };
+  return fallback;
 }
-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"
+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
   };
-  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 = 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");
-    return {
-      block: refusal,
-      refused: true,
-      approxTokens: total,
-      budgetTokens,
-      bases
-    };
+  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 { block, refused: false, approxTokens: total, budgetTokens, bases };
+  return byKey;
 }
-function toHookJson(block, event) {
-  return JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: event,
-      additionalContext: block
-    }
-  });
+function key(file, symbol, at2) {
+  return `${normalize(file)}#${symbol}#${at2}`;
 }
-var CONTEXT_BEGIN = "<!-- strauss-kb:begin -->";
-var CONTEXT_END = "<!-- strauss-kb:end -->";
-async function syncInstructions(file, block) {
-  const existing = await readFile5(file, "utf8").catch(() => null);
-  const region = block ? `${CONTEXT_BEGIN}
-${block.trim()}
-${CONTEXT_END}` : null;
-  if (existing === null) {
-    if (!region) return { file, action: "unchanged" };
-    await writeFile3(file, `${region}
-`, "utf8");
-    return { file, action: "created" };
+function normalize(path) {
+  return path.replace(/^\.\//, "");
+}
+
+// src/classify/model.ts
+var KB_CLASSES = [
+  "test",
+  "config",
+  "ci",
+  "docs",
+  "lockfile",
+  "generated",
+  "boilerplate",
+  "rename",
+  "source"
+];
+var DEFAULT_THRESHOLDS = {
+  boilerplate: 0.8,
+  rename: 90
+};
+
+// 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 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 writeFile3(file, next, "utf8");
-    return { file, action: region ? "replaced" : "removed" };
+];
+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", "");
   }
-  if (!region) return { file, action: "unchanged" };
-  await writeFile3(
-    file,
-    `${existing.replace(/\n*$/, "\n\n")}${region}
-`,
-    "utf8"
-  );
-  return { file, action: "appended" };
+  return void 0;
+}
+function isBoilerplateLine(line) {
+  return BOILERPLATE_SHAPES.some((shape) => shape.test.test(line));
 }
 
-// src/drift/git.ts
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-var execFileAsync3 = promisify3(execFile3);
-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 };
-  }
+// 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 {
+    filePath: file.filePath,
+    ...verdict,
+    ...file.renamedFrom ? { renamedFrom: file.renamedFrom } : {},
+    ...hunks.some((hunk) => hunk.class !== verdict.class) ? { hunks } : {}
+  };
 }
-async function listRepoFiles(repoRoot) {
-  const result = await git2(repoRoot, ["ls-files", "-z", "--cached"]);
-  if (!result.ok) return [];
-  return result.stdout.split("\0").filter(Boolean);
+function verdictOf(override) {
+  return {
+    class: override.class,
+    reason: `kb-override ${override.record.conceptId}`
+  };
 }
-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" };
+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 {
+      class: "boilerplate",
+      reason: `boilerplate ${Math.round(share * 100)}%`
+    };
   }
-  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 } };
+  return { class: "source", reason: "default" };
 }
-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;
+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) : []
+  );
+}
+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
@@ -2976,6 +3279,7 @@ function movedSearch(repoRoot, options = {}) {
     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);
@@ -3073,6 +3377,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({
@@ -3146,8 +3455,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 };
 }
@@ -3207,12 +3516,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;
@@ -3258,32 +3567,293 @@ function anchorPacket(found, withDiff, maxLines) {
   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
+  return {
+    ...base2,
+    diff: {
+      status: "ok",
+      source: found.oldOrigin.kind,
+      ref: found.oldOrigin.ref,
+      unified: rendered.text,
+      added: rendered.added,
+      removed: rendered.removed,
+      truncated: rendered.truncated
+    }
+  };
+}
+function claimOf(record) {
+  const type = record.frontmatter.type;
+  const section = isKbRecordType(type) ? RECORD_TYPES[type].sections[0] : void 0;
+  if (!section) return null;
+  const lines = record.body.replace(/\r\n/g, "\n").split("\n");
+  const start = lines.findIndex(
+    (line) => line.trim().toLowerCase() === `## ${section}`.toLowerCase()
+  );
+  if (start < 0) return null;
+  const rest = lines.slice(start + 1);
+  const end = rest.findIndex((line) => line.startsWith("## "));
+  const text = (end < 0 ? rest : rest.slice(0, end)).join("\n").trim();
+  return text ? { section, text } : null;
+}
+
+// src/kb-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
+import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+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 = 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");
+    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 readFile5(file, "utf8").catch(() => null);
+  const region = block ? `${CONTEXT_BEGIN}
+${block.trim()}
+${CONTEXT_END}` : null;
+  if (existing === null) {
+    if (!region) return { file, action: "unchanged" };
+    await writeFile3(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 writeFile3(file, next, "utf8");
+    return { file, action: region ? "replaced" : "removed" };
+  }
+  if (!region) return { file, action: "unchanged" };
+  await writeFile3(
+    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/kb-edges.ts
@@ -3438,6 +4008,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",
@@ -3484,14 +4082,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 = {
@@ -3501,7 +4104,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(
@@ -3514,7 +4117,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))
   ];
@@ -3589,20 +4192,153 @@ function unverified(hits, now, olderThanDays) {
     findings.push(
       finding(hit.record, `never verified, written ${age} days ago`)
     );
-  }
-  return findings;
-}
-function aging(hits, now, olderThanDays) {
-  const findings = [];
-  for (const hit of hits) {
-    const status = hit.record.frontmatter.strauss_status;
-    if (status !== "open" && status !== "proposed") continue;
-    const age = ageInDays(hit.record, now);
-    if (age === null || age <= olderThanDays) continue;
+  }
+  return findings;
+}
+function aging(hits, now, olderThanDays) {
+  const findings = [];
+  for (const hit of hits) {
+    const status = hit.record.frontmatter.strauss_status;
+    if (status !== "open" && status !== "proposed") continue;
+    const age = ageInDays(hit.record, now);
+    if (age === null || age <= olderThanDays) continue;
+    findings.push(
+      finding(
+        hit.record,
+        status === "open" ? `open for ${age} days` : `proposed ${age} days ago and still unsettled`
+      )
+    );
+  }
+  return findings.sort(
+    (left, right) => left.conceptId.localeCompare(right.conceptId)
+  );
+}
+function orphaned(bundle) {
+  const present = new Set(bundle.map((record) => record.conceptId));
+  const referenced = /* @__PURE__ */ new Set();
+  for (const record of bundle) {
+    for (const neighbour of edgeNeighbours(record, bundle, "body-link")) {
+      referenced.add(neighbour.conceptId);
+    }
+    for (const replaced of record.frontmatter.strauss_supersedes ?? []) {
+      referenced.add(replaced);
+    }
+    const replacement = record.frontmatter.strauss_superseded_by;
+    if (replacement && present.has(replacement)) {
+      referenced.add(record.conceptId);
+    }
+  }
+  return bundle.filter((record) => !referenced.has(record.conceptId)).map((record) => finding(record, "no other record links to it"));
+}
+var SUPERSESSION_CHECKS = /* @__PURE__ */ new Set([
+  "superseded_by",
+  "supersedes",
+  "backlink"
+]);
+function brokenSupersession(bundle, adjudicated) {
+  const byId = new Map(bundle.map((record) => [record.conceptId, record]));
+  const findings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (record, note) => {
+    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)) {
+    if (!SUPERSESSION_CHECKS.has(problem.check)) continue;
+    const record = byId.get(problem.conceptId);
+    if (record) add(record, problem.note);
+  }
+  for (const record of bundle) {
+    const replacement = record.frontmatter.strauss_superseded_by;
+    if (!replacement) continue;
+    if (!byId.has(replacement)) {
+      add(record, `replacement ${replacement} is missing`);
+    } else if (record.frontmatter.strauss_status !== "superseded") {
+      add(
+        record,
+        `names ${replacement} as its replacement but is not marked superseded`
+      );
+    }
+  }
+  for (const hit of adjudicated) {
+    for (const warning of hit.warnings) {
+      if (warning.kind === "broken-chain") {
+        add(hit.record, `replacement ${warning.missing} is missing`);
+      } else if (warning.kind === "chain-cycle") {
+        add(
+          hit.record,
+          `supersession chain cycles through ${warning.through.join(" \u2192 ")}`
+        );
+      } else if (warning.kind === "forked-chain") {
+        add(
+          hit.record,
+          `two records claim to replace it: ${warning.heads.join(", ")}`
+        );
+      }
+    }
+  }
+  return findings.sort(
+    (left, right) => left.conceptId.localeCompare(right.conceptId)
+  );
+}
+function supersededButCited(bundle, standings2) {
+  const byId = new Map(bundle.map((record) => [record.conceptId, record]));
+  const findings = [];
+  for (const record of bundle) {
+    const standing = standings2.get(record.conceptId);
+    if (standing === "superseded" || standing === "rejected") continue;
+    for (const target of edgeNeighbours(record, bundle, "body-link")) {
+      const targetStanding = standings2.get(target.conceptId);
+      if (targetStanding !== "superseded" && targetStanding !== "rejected") {
+        continue;
+      }
+      if (replaces(record, target)) continue;
+      const replacement = target.frontmatter.strauss_superseded_by;
+      findings.push(
+        finding(
+          record,
+          `cites ${targetStanding} ${target.conceptId}${targetStanding === "superseded" && replacement && byId.has(replacement) ? ` \u2014 replaced by ${replacement}` : ""}`
+        )
+      );
+    }
+  }
+  return findings;
+}
+function drifted(hits) {
+  return anchorFindings(
+    hits,
+    "drifted",
+    (count2) => count2 === 1 ? "anchor no longer matches" : "anchors no longer match"
+  );
+}
+function unchecked(hits) {
+  return anchorFindings(
+    hits,
+    "unchecked",
+    (count2) => count2 === 1 ? "anchor was not checked" : "anchors were not checked"
+  );
+}
+function anchorFindings(hits, kind, headline) {
+  const findings = [];
+  for (const hit of hits) {
+    const warning = hit.warnings.find(
+      (entry) => entry.kind === kind
+    );
+    if (!warning) continue;
+    const byRepo = /* @__PURE__ */ new Map();
+    for (const anchor of warning.anchors) {
+      const repo = anchor.repo ?? "";
+      byRepo.set(repo, [...byRepo.get(repo) ?? [], describeAnchor(anchor)]);
+    }
+    const detail = [...byRepo.entries()].map(
+      ([repo, entries]) => repo ? `${repo}: ${entries.join(", ")}` : entries.join(", ")
+    );
     findings.push(
       finding(
         hit.record,
-        status === "open" ? `open for ${age} days` : `proposed ${age} days ago and still unsettled`
+        `${warning.anchors.length} ${headline(warning.anchors.length)}: ${detail.join("; ")}`
       )
     );
   }
@@ -3610,177 +4346,519 @@ function aging(hits, now, olderThanDays) {
     (left, right) => left.conceptId.localeCompare(right.conceptId)
   );
 }
-function orphaned(bundle) {
-  const present = new Set(bundle.map((record) => record.conceptId));
-  const referenced = /* @__PURE__ */ new Set();
+function describeAnchor(anchor) {
+  const at2 = anchor.symbol ? `${anchor.file}:${anchor.symbol}` : anchor.file;
+  if (anchor.class === "gone") {
+    return `${at2} gone${anchor.reason ? ` (${anchor.reason})` : ""}`;
+  }
+  if (anchor.reason) return `${at2} (${anchor.reason})`;
+  if (anchor.remoteState === "drifted-on-default") {
+    return `${at2} (matches ref, moved on the default branch)`;
+  }
+  if (anchor.diffSize === null) return `${at2} (changed, size unrecorded)`;
+  return anchor.diffSize === 0 ? `${at2} (content changed, same line count)` : `${at2} (${anchor.diffSize} line${anchor.diffSize === 1 ? "" : "s"} apart)`;
+}
+function replaces(later, earlier) {
+  return (later.frontmatter.strauss_supersedes ?? []).includes(earlier.conceptId) || earlier.frontmatter.strauss_superseded_by === later.conceptId;
+}
+function finding(record, note) {
+  return {
+    conceptId: record.conceptId,
+    title: record.frontmatter.title ?? null,
+    status: record.frontmatter.strauss_status,
+    note
+  };
+}
+function daysBetween(from, to) {
+  return Math.max(0, Math.floor((to - from) / DAY_MS));
+}
+function ageInDays(record, now) {
+  const at2 = record.frontmatter.generated?.at;
+  if (!at2) return null;
+  const written = Date.parse(at2);
+  if (Number.isNaN(written)) return null;
+  return daysBetween(written, now.getTime());
+}
+
+// src/commands/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 neighbour of edgeNeighbours(record, bundle, "body-link")) {
-      referenced.add(neighbour.conceptId);
-    }
-    for (const replaced of record.frontmatter.strauss_supersedes ?? []) {
-      referenced.add(replaced);
-    }
-    const replacement = record.frontmatter.strauss_superseded_by;
-    if (replacement && present.has(replacement)) {
-      referenced.add(record.conceptId);
+    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 bundle.filter((record) => !referenced.has(record.conceptId)).map((record) => finding(record, "no other record links to it"));
+  return byTarget;
 }
-var SUPERSESSION_CHECKS = /* @__PURE__ */ new Set([
-  "superseded_by",
-  "supersedes",
-  "backlink"
-]);
-function brokenSupersession(bundle, adjudicated) {
+
+// src/kb-links/backlinks.ts
+function backlinks(targetId, bundle) {
   const byId = new Map(bundle.map((record) => [record.conceptId, record]));
-  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);
-    findings.push(finding(record, note));
+  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)
+    )
   };
-  for (const problem of validateBundle(bundle)) {
-    if (!SUPERSESSION_CHECKS.has(problem.check)) continue;
-    const record = byId.get(problem.conceptId);
-    if (record) add(record, problem.note);
+}
+
+// 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
+import { z as z7 } from "zod";
+
+// src/commands/model.ts
+import { z as z6 } from "zod";
+var bundlePath = z6.string().min(1).describe("Absolute path to the knowledge base directory.");
+var conceptId = z6.string().min(1).describe("e.g. decision.cursor-v2");
+var TAGS = z6.array(z6.string().min(1)).optional().describe(
+  "Keep only records carrying every one of these frontmatter tags. Matched exactly."
+);
+var REPO_ROOT = z6.string().min(1).optional().describe(
+  "Where the anchored source lives, for the drift check. Defaults to the working directory."
+);
+function define(command) {
+  return command;
+}
+function argvFlag(argv, name) {
+  const joined = argv.find((arg) => arg.startsWith(`${name}=`));
+  if (joined !== void 0) {
+    const value2 = joined.slice(name.length + 1);
+    if (!value2) throw new KbMissingFlagValueError(name);
+    return value2;
   }
-  for (const record of bundle) {
-    const replacement = record.frontmatter.strauss_superseded_by;
-    if (!replacement) continue;
-    if (!byId.has(replacement)) {
-      add(record, `replacement ${replacement} is missing`);
-    } else if (record.frontmatter.strauss_status !== "superseded") {
-      add(
-        record,
-        `names ${replacement} as its replacement but is not marked superseded`
-      );
-    }
+  const at2 = argv.indexOf(name);
+  if (at2 === -1) return void 0;
+  const value = argv[at2 + 1];
+  if (value === void 0 || value.startsWith("--")) {
+    throw new KbMissingFlagValueError(name);
   }
-  for (const hit of adjudicated) {
-    for (const warning of hit.warnings) {
-      if (warning.kind === "broken-chain") {
-        add(hit.record, `replacement ${warning.missing} is missing`);
-      } else if (warning.kind === "chain-cycle") {
-        add(
-          hit.record,
-          `supersession chain cycles through ${warning.through.join(" \u2192 ")}`
-        );
-      } else if (warning.kind === "forked-chain") {
-        add(
-          hit.record,
-          `two records claim to replace it: ${warning.heads.join(", ")}`
-        );
+  return value;
+}
+function argvFlags(argv, name) {
+  const values = [];
+  for (const [at2, arg] of argv.entries()) {
+    if (arg.startsWith(`${name}=`)) {
+      const value = arg.slice(name.length + 1);
+      if (!value) throw new KbMissingFlagValueError(name);
+      values.push(value);
+    } else if (arg === name) {
+      const value = argv[at2 + 1];
+      if (value === void 0 || value.startsWith("--")) {
+        throw new KbMissingFlagValueError(name);
       }
+      values.push(value);
     }
   }
-  return findings.sort(
-    (left, right) => left.conceptId.localeCompare(right.conceptId)
-  );
+  return values;
 }
-function supersededButCited(bundle, standings) {
-  const byId = new Map(bundle.map((record) => [record.conceptId, record]));
-  const findings = [];
-  for (const record of bundle) {
-    const standing = standings.get(record.conceptId);
-    if (standing === "superseded" || standing === "rejected") continue;
-    for (const target of edgeNeighbours(record, bundle, "body-link")) {
-      const targetStanding = standings.get(target.conceptId);
-      if (targetStanding !== "superseded" && targetStanding !== "rejected") {
-        continue;
-      }
-      if (replaces(record, target)) continue;
-      const replacement = target.frontmatter.strauss_superseded_by;
-      findings.push(
-        finding(
-          record,
-          `cites ${targetStanding} ${target.conceptId}${targetStanding === "superseded" && replacement && byId.has(replacement) ? ` \u2014 replaced by ${replacement}` : ""}`
-        )
-      );
+function argvWithout(argv, ...names) {
+  const kept = [];
+  for (let at2 = 0; at2 < argv.length; at2 += 1) {
+    const arg = argv[at2];
+    if (names.some((name) => arg.startsWith(`${name}=`))) continue;
+    if (names.includes(arg)) {
+      at2 += 1;
+      continue;
     }
+    kept.push(arg);
   }
-  return findings;
-}
-function drifted(hits) {
-  return anchorFindings(
-    hits,
-    "drifted",
-    (count2) => count2 === 1 ? "anchor no longer matches" : "anchors no longer match"
-  );
+  return kept;
 }
-function unchecked(hits) {
-  return anchorFindings(
-    hits,
-    "unchecked",
-    (count2) => count2 === 1 ? "anchor was not checked" : "anchors were not checked"
+function argvPositional(argv, ...names) {
+  return argvWithout(argv.slice(1), ...names).find(
+    (arg) => !arg.startsWith("--")
   );
 }
-function anchorFindings(hits, kind, headline) {
-  const findings = [];
-  for (const hit of hits) {
-    const warning = hit.warnings.find(
-      (entry) => entry.kind === kind
-    );
-    if (!warning) continue;
-    const byRepo = /* @__PURE__ */ new Map();
-    for (const anchor of warning.anchors) {
-      const repo = anchor.repo ?? "";
-      byRepo.set(repo, [...byRepo.get(repo) ?? [], describeAnchor(anchor)]);
+
+// src/commands/promote/model.ts
+var promoteInputSchema = z7.object({
+  bundlePath,
+  conceptIds: z7.array(conceptId).max(64).optional().describe("Records to copy into the target base. Omit with `list`."),
+  to: z7.string().min(1).optional().describe("Absolute path to the base being promoted into."),
+  source: z7.string().min(1).optional().describe(
+    "Where the promotion came from, usually the pull request URL. Recorded on each copy as a source."
+  ),
+  force: z7.boolean().optional().describe("Overwrite a record the target base already holds."),
+  list: z7.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
+import { resolve as resolve5 } from "path";
+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 = resolve5(path);
+    const bundle = await store.list(from);
+    if (list) {
+      return { mode: "list", candidates: promoteCandidates(bundle) };
+    }
+    const target = resolve5(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 detail = [...byRepo.entries()].map(
-      ([repo, entries]) => repo ? `${repo}: ${entries.join(", ")}` : entries.join(", ")
-    );
-    findings.push(
-      finding(
-        hit.record,
-        `${warning.anchors.length} ${headline(warning.anchors.length)}: ${detail.join("; ")}`
-      )
+    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 findings.sort(
-    (left, right) => left.conceptId.localeCompare(right.conceptId)
-  );
+  return { conceptId: conceptId2, type, slug };
 }
-function describeAnchor(anchor) {
-  const at2 = anchor.symbol ? `${anchor.file}:${anchor.symbol}` : anchor.file;
-  if (anchor.class === "gone") {
-    return `${at2} gone${anchor.reason ? ` (${anchor.reason})` : ""}`;
+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");
   }
-  if (anchor.reason) return `${at2} (${anchor.reason})`;
-  if (anchor.remoteState === "drifted-on-default") {
-    return `${at2} (matches ref, moved on the default branch)`;
+  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)`
+      );
+    }
   }
-  if (anchor.diffSize === null) return `${at2} (changed, size unrecorded)`;
-  return anchor.diffSize === 0 ? `${at2} (content changed, same line count)` : `${at2} (${anchor.diffSize} line${anchor.diffSize === 1 ? "" : "s"} apart)`;
-}
-function replaces(later, earlier) {
-  return (later.frontmatter.strauss_supersedes ?? []).includes(earlier.conceptId) || earlier.frontmatter.strauss_superseded_by === later.conceptId;
-}
-function finding(record, note) {
-  return {
-    conceptId: record.conceptId,
-    title: record.frontmatter.title ?? null,
-    status: record.frontmatter.strauss_status,
-    note
-  };
-}
-function daysBetween(from, to) {
-  return Math.max(0, Math.floor((to - from) / DAY_MS));
-}
-function ageInDays(record, now) {
-  const at2 = record.frontmatter.generated?.at;
-  if (!at2) return null;
-  const written = Date.parse(at2);
-  if (Number.isNaN(written)) return null;
-  return daysBetween(written, now.getTime());
+  return lines.join("\n");
 }
 
 // src/kb-log.ts
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 var LOG_FILE = "log.jsonl";
-var kbLogEntrySchema = z6.object({
+var kbLogEntrySchema = z8.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
@@ -3789,23 +4867,32 @@ var kbLogEntrySchema = z6.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: z6.iso.datetime(),
-  by: z6.string().min(1),
-  operation: z6.string().min(1),
-  conceptId: z6.string().min(1),
-  /** Second concept id, where the operation relates two — supersession. */
-  target: z6.string().min(1).optional()
+  at: z8.iso.datetime(),
+  by: z8.string().min(1),
+  operation: z8.string().min(1),
+  conceptId: z8.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: z8.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);
@@ -3818,26 +4905,26 @@ 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
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 function kbJsonSchemas() {
   return {
-    recordFrontmatter: z7.toJSONSchema(kbRecordFrontmatterSchema, {
+    recordFrontmatter: z9.toJSONSchema(kbRecordFrontmatterSchema, {
       io: "input"
     }),
-    composeInput: z7.toJSONSchema(composeInputSchema, { io: "input" }),
-    logEntry: z7.toJSONSchema(kbLogEntrySchema, { io: "input" })
+    composeInput: z9.toJSONSchema(composeInputSchema, { io: "input" }),
+    logEntry: z9.toJSONSchema(kbLogEntrySchema, { io: "input" })
   };
 }
 
@@ -3890,73 +4977,7 @@ function byGeneratedAt(left, right) {
 }
 
 // src/commands/anchor-resolve.ts
-import { z as z9 } from "zod";
-
-// src/commands/model.ts
-import { z as z8 } from "zod";
-var bundlePath = z8.string().min(1).describe("Absolute path to the knowledge base directory.");
-var conceptId = z8.string().min(1).describe("e.g. decision.cursor-v2");
-var TAGS = z8.array(z8.string().min(1)).optional().describe(
-  "Keep only records carrying every one of these frontmatter tags. Matched exactly."
-);
-var REPO_ROOT = z8.string().min(1).optional().describe(
-  "Where the anchored source lives, for the drift check. Defaults to the working directory."
-);
-function define(command) {
-  return command;
-}
-function argvFlag(argv, name) {
-  const joined = argv.find((arg) => arg.startsWith(`${name}=`));
-  if (joined !== void 0) {
-    const value2 = joined.slice(name.length + 1);
-    if (!value2) throw new KbMissingFlagValueError(name);
-    return value2;
-  }
-  const at2 = argv.indexOf(name);
-  if (at2 === -1) return void 0;
-  const value = argv[at2 + 1];
-  if (value === void 0 || value.startsWith("--")) {
-    throw new KbMissingFlagValueError(name);
-  }
-  return value;
-}
-function argvFlags(argv, name) {
-  const values = [];
-  for (const [at2, arg] of argv.entries()) {
-    if (arg.startsWith(`${name}=`)) {
-      const value = arg.slice(name.length + 1);
-      if (!value) throw new KbMissingFlagValueError(name);
-      values.push(value);
-    } else if (arg === name) {
-      const value = argv[at2 + 1];
-      if (value === void 0 || value.startsWith("--")) {
-        throw new KbMissingFlagValueError(name);
-      }
-      values.push(value);
-    }
-  }
-  return values;
-}
-function argvWithout(argv, ...names) {
-  const kept = [];
-  for (let at2 = 0; at2 < argv.length; at2 += 1) {
-    const arg = argv[at2];
-    if (names.some((name) => arg.startsWith(`${name}=`))) continue;
-    if (names.includes(arg)) {
-      at2 += 1;
-      continue;
-    }
-    kept.push(arg);
-  }
-  return kept;
-}
-function argvPositional(argv, ...names) {
-  return argvWithout(argv.slice(1), ...names).find(
-    (arg) => !arg.startsWith("--")
-  );
-}
-
-// src/commands/anchor-resolve.ts
+import { z as z10 } from "zod";
 function resolverSummary(results) {
   const names = [
     ...new Set(
@@ -3970,17 +4991,17 @@ var anchorResolveCommand = define({
   tool: "kb_anchor_resolve",
   usage: "anchor-resolve <concept-id> [--repo-root <path>] [--offline] [--rebaseline] [--restamp]",
   description: "Resolve a record's anchors: stamp a hash onto anchors that lack one, report drift where the code moved. An anchor naming another repository is read from that remote through a bare cache; --offline uses the cache only. kb_verify's mechanical counterpart \u2014 reach for it when the question is whether the code still is what it was. Exits non-zero on drift.",
-  input: z9.object({
+  input: z10.object({
     bundlePath,
     conceptId,
-    repoRoot: z9.string().min(1).optional(),
-    offline: z9.boolean().optional().describe(
+    repoRoot: z10.string().min(1).optional(),
+    offline: z10.boolean().optional().describe(
       "Resolve foreign anchors from the local repo cache only, never fetching."
     ),
-    rebaseline: z9.boolean().optional().describe(
+    rebaseline: z10.boolean().optional().describe(
       "Accept the current code as the new baseline for anchors that drifted."
     ),
-    restamp: z9.boolean().optional().describe(
+    restamp: z10.boolean().optional().describe(
       "Refresh `resolved_at` on anchors that already match. Off by default, so a green run writes nothing."
     )
   }),
@@ -4018,6 +5039,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.
@@ -4194,12 +5216,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
   });
@@ -4211,11 +5239,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,
@@ -4235,13 +5270,13 @@ async function readSources(anchors, root, offline) {
 }
 
 // src/commands/answer.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var answerCommand = define({
   name: "answer",
   tool: "kb_answer",
   usage: "answer <concept-id> <answer...>",
   description: "Resolve an open question: set status, stamp who and when, append an Answer section. If the answer overturns a decision or assumption, supersede that record explicitly.",
-  input: z10.object({ bundlePath, conceptId, answer: z10.string().min(1) }),
+  input: z11.object({ bundlePath, conceptId, answer: z11.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -4255,27 +5290,27 @@ var answerCommand = define({
 });
 
 // src/commands/backlinks.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var backlinksCommand = define({
   name: "backlinks",
   tool: "kb_backlinks",
   usage: "backlinks <concept-id>",
   description: "Who points at this record: every inbound typed causal link (`strauss_links`), one hop, every rel including `related_to`, each with its rel and the standing of the record that made it. Use it when you need the exact edges \u2014 reviewing or renaming a record.",
-  input: z11.object({ bundlePath, conceptId }),
+  input: z12.object({ bundlePath, conceptId }),
   fromArgv: (argv, path) => ({ bundlePath: path, conceptId: argv[1] }),
   run: async ({ store }, { bundlePath: path, conceptId: id }) => store.backlinks(path, id)
 });
 
 // src/commands/catalog.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var catalogCommand = define({
   name: "catalog",
   tool: "kb_catalog",
   usage: "catalog [type] [--tag T]...",
   description: "Lists every record as one line \u2014 concept id, type, title, standing, and a stale flag \u2014 at roughly thirty tokens each. Pick this over kb_load once kb_load refuses: kb_catalog never refuses. Superseded records show only their replacement; fetch bodies with kb_load, kb_pack, kb_query, or kb_trace.",
-  input: z12.object({
+  input: z13.object({
     bundlePath,
-    type: z12.enum(KB_RECORD_TYPES).optional(),
+    type: z13.enum(KB_RECORD_TYPES).optional(),
     tags: TAGS
   }),
   fromArgv: (argv, path) => {
@@ -4343,30 +5378,559 @@ function count(value, noun) {
   return `${value} ${value === 1 ? noun : `${noun}s`}`;
 }
 
+// src/commands/classify.ts
+import { Buffer } from "buffer";
+import { open } from "fs/promises";
+import { join as join6 } from "path";
+import { z as z16 } from "zod";
+
+// src/commands/match/command.ts
+import { z as z15 } from "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
+import { z as z14 } from "zod";
+var diffHunkSchema = z14.object({
+  startLine: z14.number().int().positive(),
+  endLine: z14.number().int().positive(),
+  side: z14.enum(["old", "new"]).optional()
+}).passthrough();
+var diffFileSchema = z14.object({
+  filePath: z14.string().min(1).describe("Repo-relative, spelled the way anchors are."),
+  hunks: z14.array(diffHunkSchema)
+});
+var symbolRangeSchema = z14.object({
+  file: z14.string().min(1),
+  symbol: z14.string().min(1),
+  startLine: z14.number().int().positive(),
+  endLine: z14.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: z15.object({
+    bundlePath,
+    files: z15.array(diffFileSchema).describe("The changed files, each with its post-change line ranges."),
+    symbolRanges: z15.array(symbolRangeSchema).optional().describe(
+      "Symbol spans the caller already has. Resolved from repoRoot when omitted."
+    ),
+    repoRoot: REPO_ROOT,
+    offline: z15.boolean().optional().describe(
+      "Resolve symbol ranges from what is already on disk, never fetching a grammar."
+    ),
+    includeNonCurrent: z15.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: z16.array(
+    diffHunkSchema.extend({ lines: z16.array(z16.string()).optional() })
+  ),
+  renamedFrom: z16.string().min(1).optional().describe("Where `git diff -M` says the path came from."),
+  similarity: z16.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: z16.object({
+    bundlePath,
+    files: z16.array(classifyFileSchema).describe("The changed files, each with its line ranges."),
+    repoRoot: REPO_ROOT,
+    offline: z16.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 open(join6(root, file.filePath), "r");
+    const 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
-import { z as z13 } from "zod";
+import { z as z17 } from "zod";
 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: z13.object({
-    budgetTokens: z13.number().int().positive().optional().describe(
+  input: z17.object({
+    budgetTokens: z17.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: z13.number().int().positive().optional().describe(
+    fullUnderTokens: z17.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: z13.string().optional().describe(
+    profile: z17.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: z13.array(z13.string().min(1)).optional().describe(
+    excludeTags: z17.array(z17.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: z13.enum(["markdown", "json"]).optional().describe(
+    format: z17.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: z13.string().optional().describe(
+    event: z17.string().optional().describe(
       "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
     )
   }),
@@ -4405,20 +5969,20 @@ var contextCommand = define({
 });
 
 // src/commands/doctor.ts
-import { z as z15 } from "zod";
+import { z as z19 } from "zod";
 
 // src/commands/reassess.ts
-import { z as z14 } from "zod";
+import { z as z18 } from "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: z14.object({
+  input: z18.object({
     bundlePath,
     conceptId,
     repoRoot: REPO_ROOT,
-    withDiff: z14.boolean().optional().describe(
+    withDiff: z18.boolean().optional().describe(
       "Recover each anchor's committed span and render the diff. Reads git history."
     )
   }),
@@ -4461,7 +6025,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,
@@ -4560,13 +6127,13 @@ function at(file, symbol) {
 }
 
 // src/commands/doctor.ts
-var days = (what, fallback) => z15.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
+var days = (what, fallback) => z19.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: z15.object({
+  input: z19.object({
     bundlePath,
     repoRoot: REPO_ROOT,
     expiringDays: days(
@@ -4581,16 +6148,16 @@ var doctorCommand = define({
       "How long a record may stay `open` or `proposed` before `aging` reports it, in days.",
       DEFAULT_AGING_DAYS
     ),
-    offline: z15.boolean().optional().describe(
+    offline: z19.boolean().optional().describe(
       "Read foreign anchors from the local repo cache only, never fetching."
     ),
-    strict: z15.boolean().optional().describe(
+    strict: z19.boolean().optional().describe(
       "Turn an expired record into a non-zero exit for the CLI. No effect on the report itself."
     ),
-    drifted: z15.boolean().optional().describe(
+    drifted: z19.boolean().optional().describe(
       "Report only drift, as a reassessment packet per record: claim, per-anchor class, and what depends on it."
     ),
-    withDiff: z15.boolean().optional().describe(
+    withDiff: z19.boolean().optional().describe(
       "With `drifted`: recover each anchor's committed span and render the old-vs-new diff. Reads git history."
     )
   }),
@@ -4646,7 +6213,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
@@ -4660,7 +6227,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,
@@ -4697,15 +6264,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));
@@ -4730,6 +6298,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 = [
@@ -4755,20 +6331,162 @@ function renderPackets(result) {
   return lines.join("\n");
 }
 
+// src/commands/export.ts
+import {
+  mkdir as mkdir4,
+  readFile as readFile6,
+  readdir,
+  rename as rename2,
+  unlink,
+  writeFile as writeFile4
+} from "fs/promises";
+import { join as join7 } from "path";
+import { z as z20 } from "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: z20.object({
+    bundlePath,
+    format: z20.enum(["madr"]).describe("Output layout. `madr` is the only one so far."),
+    to: z20.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 mkdir4(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(join7(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 writeFile4(staging, contents, "utf8");
+  try {
+    await rename2(staging, target);
+  } catch (error) {
+    await unlink(staging).catch(() => void 0);
+    throw error;
+  }
+}
+async function existingFiles(to) {
+  const names = await 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 readFile6(join7(to, name), "utf8").catch(() => "");
+    taken.set(slug, {
+      file: name,
+      number: Number(number),
+      ours: text.includes(MARKER)
+    });
+  }
+  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
-import { z as z16 } from "zod";
+import { z as z21 } from "zod";
 var impactCommand = define({
   name: "impact",
   tool: "kb_impact",
   usage: "impact <concept-id> [--depth N] [--rels a,b]",
   description: "What breaks if this record changes: its transitive set of dependants, each with its standing. Each rel declares which of its ends depends on the other, and the walk follows each rel in its own direction. Naming `related_to` or an unknown rel in `rels` is an error. kb_backlinks gives one flat hop.",
-  input: z16.object({
+  input: z21.object({
     bundlePath,
     conceptId,
-    depth: z16.number().int().positive().optional().describe(
+    depth: z21.number().int().positive().optional().describe(
       "Hops out from the record. Unbounded when omitted; a walk this cuts reports truncated: true."
     ),
-    rels: z16.array(z16.enum(KB_CAUSAL_LINK_RELS)).optional().describe(
+    rels: z21.array(z21.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."
     )
   }),
@@ -4789,15 +6507,15 @@ var impactCommand = define({
 });
 
 // src/commands/list.ts
-import { z as z17 } from "zod";
+import { z as z22 } from "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: z17.object({
+  input: z22.object({
     bundlePath,
-    type: z17.enum(KB_RECORD_TYPES).optional(),
+    type: z22.enum(KB_RECORD_TYPES).optional(),
     tags: TAGS
   }),
   fromArgv: (argv, path) => {
@@ -4821,17 +6539,17 @@ var listCommand = define({
 });
 
 // src/commands/load.ts
-import { z as z18 } from "zod";
+import { z as z23 } from "zod";
 var loadCommand = define({
   name: "load",
   tool: "kb_load",
   usage: "load [type] [--budget N | --all] [--repo-root PATH]",
   description: "Load the whole base, each record with its standing \u2014 call it first, at the point of use, since compaction drops it. Superseded records arrive as stubs; kb_trace has the history. Over budget it refuses: kb_catalog, then kb_pack, or narrow with `type`; `all` bypasses. Never read record files directly \u2014 only kb_* tools resolve supersession. `digest` stamps the base's content, so hooks know when to reload.",
-  input: z18.object({
+  input: z23.object({
     bundlePath,
-    type: z18.enum(KB_RECORD_TYPES).optional(),
-    budgetTokens: z18.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
-    all: z18.boolean().optional().describe(
+    type: z23.enum(KB_RECORD_TYPES).optional(),
+    budgetTokens: z23.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
+    all: z23.boolean().optional().describe(
       "Loads the entire base regardless of size, bypassing the token budget; mutually exclusive with budgetTokens."
     ),
     repoRoot: REPO_ROOT
@@ -4873,25 +6591,25 @@ var loadCommand = define({
 });
 
 // src/commands/log.ts
-import { z as z19 } from "zod";
+import { z as z24 } from "zod";
 var logCommand = define({
   name: "log",
   tool: "kb_log",
   usage: "log",
   description: "Who touched what, and when. Append-only; malformed lines are reported, never repaired.",
-  input: z19.object({ bundlePath }),
+  input: z24.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readLog(path)
 });
 
 // src/commands/no-decision.ts
-import { z as z20 } from "zod";
+import { z as z25 } from "zod";
 var noDecisionCommand = define({
   name: "no-decision",
   tool: "kb_no_decision",
   usage: "no-decision <reason...>",
   description: "Record in one sentence that a piece of work had nothing to decide. Idempotent.",
-  input: z20.object({ bundlePath, reason: z20.string().min(1) }),
+  input: z25.object({ bundlePath, reason: z25.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     reason: argv.slice(1).join(" ").trim()
@@ -4908,20 +6626,20 @@ var noDecisionCommand = define({
 });
 
 // src/commands/pack.ts
-import { z as z21 } from "zod";
+import { z as z26 } from "zod";
 var packCommand = define({
   name: "pack",
   tool: "kb_pack",
   usage: "pack <conceptId> [--hops N] [--max-nodes N] [--budget N]",
   description: "Bounded neighbourhood around one record: within `hops`, ranked, cut to `maxNodes`, with every cut record named under Excluded. Use when the base is over kb_load's budget and the work centres on a record you can name. Refuses over budget rather than truncating. Everything below the header is byte-stable across runs. Resolves supersession like kb_load.",
-  input: z21.object({
+  input: z26.object({
     bundlePath,
     conceptId,
-    hops: z21.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
-    maxNodes: z21.number().int().positive().optional().describe(
+    hops: z26.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
+    maxNodes: z26.number().int().positive().optional().describe(
       "How many records the pack may hold, root included. Defaults to 20."
     ),
-    budgetTokens: z21.number().int().positive().optional().describe(
+    budgetTokens: z26.number().int().positive().optional().describe(
       "Approximate token ceiling over what is actually emitted. Defaults to 25000."
     )
   }),
@@ -5008,22 +6726,22 @@ function warningLabel(warning) {
 }
 
 // src/commands/pin.ts
-import { z as z22 } from "zod";
+import { z as z27 } from "zod";
 var pinCommand = define({
   name: "pin",
   tool: "kb_pin",
   usage: "pin [bundle-path] [--mode full|index] [--profiles a,b] [--local|--user] [--frozen|--unfreeze]",
   description: "Pin a base into a workspace manifest so kb_context surfaces it. Layers, nearest wins: project `.strauss/kb-pins.json` (default), `--local` (personal, gitignored), `--user` (`~/.strauss`). Idempotent; `--mode full|index`, `--profiles`, `--frozen`/`--unfreeze` update only those fields. A path with no records pins with a warning. Never touches the base itself.",
-  input: z22.object({
+  input: z27.object({
     bundlePath,
-    mode: z22.enum(["full", "index"]).optional().describe(
+    mode: z27.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: z22.array(z22.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
-    layer: z22.enum(["project", "local", "user"]).optional().describe(
+    profiles: z27.array(z27.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
+    layer: z27.enum(["project", "local", "user"]).optional().describe(
       "Which manifest to write: project (committed, default), local (personal, gitignored), user (~/.strauss, every workspace)."
     ),
-    frozen: z22.boolean().optional().describe(
+    frozen: z27.boolean().optional().describe(
       "true: the base is concluded \u2014 writes against it refuse while pinned. false: lift a freeze."
     )
   }),
@@ -5052,29 +6770,29 @@ var pinCommand = define({
 });
 
 // src/commands/pins.ts
-import { z as z23 } from "zod";
+import { z as z28 } from "zod";
 var pinsCommand = define({
   name: "pins",
   tool: "kb_pins",
   usage: "pins",
   description: "Every pinned base across the manifest layers, with its layer and whether it resolves to records. Takes no bundlePath.",
-  input: z23.object({}),
+  input: z28.object({}),
   fromArgv: () => ({}),
   run: ({ store }) => listPins(store, process.cwd())
 });
 
 // src/commands/query.ts
-import { z as z24 } from "zod";
+import { z as z29 } from "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: z24.object({
+  input: z29.object({
     bundlePath,
-    text: z24.string().optional(),
-    type: z24.enum(KB_RECORD_TYPES).optional(),
-    includeNonCurrent: z24.boolean().optional(),
+    text: z29.string().optional(),
+    type: z29.enum(KB_RECORD_TYPES).optional(),
+    includeNonCurrent: z29.boolean().optional(),
     tags: TAGS,
     repoRoot: REPO_ROOT
   }),
@@ -5108,43 +6826,43 @@ var queryCommand = define({
 });
 
 // src/commands/read-index.ts
-import { z as z25 } from "zod";
+import { z as z30 } from "zod";
 var readIndexCommand = define({
   name: "index",
   tool: "kb_index",
   usage: "index",
   description: "The index \u2014 title, type, status, description per record \u2014 rebuilt if stale. Cheapest re-orientation after compaction: call it (or kb_context) first, then kb_load or fetch by id.",
-  input: z25.object({ bundlePath }),
+  input: z30.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readIndex(path)
 });
 
 // src/commands/schema.ts
-import { z as z26 } from "zod";
+import { z as z31 } from "zod";
 var schemaCommand = define({
   name: "schema",
   tool: "kb_schema",
   usage: "schema",
   description: "JSON Schema for frontmatter, write input, and log entries, generated from the enforcing code.",
-  input: z26.object({}),
+  input: z31.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(kbJsonSchemas())
 });
 
 // src/commands/stamp.ts
-import { readFile as readFile6 } from "fs/promises";
-import { z as z27 } from "zod";
+import { readFile as readFile7 } from "fs/promises";
+import { z as z32 } from "zod";
 var DIGEST = /^[0-9a-f]{64}$/;
 var stampCommand = define({
   name: "stamp",
   tool: "kb_stamp",
   usage: "stamp [--bundle PATH] [--since DIGEST|FILE]",
   description: "Content stamp of a base \u2014 `load`'s digest, record counts, per-record digests, 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: z27.object({
-    bundlePath: z27.string().min(1).optional().describe(
+  input: z32.object({
+    bundlePath: z32.string().min(1).optional().describe(
       "Absolute path to one knowledge base. Omit to stamp every pinned base."
     ),
-    since: z27.string().min(1).optional().describe(
+    since: z32.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."
     )
   }),
@@ -5206,7 +6924,7 @@ async function readBaseline(since) {
   if (DIGEST.test(since)) return { digest: since, byPath: /* @__PURE__ */ new Map() };
   let parsed;
   try {
-    parsed = JSON.parse(await readFile6(since, "utf8"));
+    parsed = JSON.parse(await readFile7(since, "utf8"));
   } catch {
     throw new KbStampBaselineError(since);
   }
@@ -5230,16 +6948,16 @@ async function readBaseline(since) {
 }
 
 // src/commands/status.ts
-import { z as z28 } from "zod";
+import { z as z33 } from "zod";
 var statusCommand = define({
   name: "status",
   tool: "kb_status",
   usage: "status <concept-id> <status>",
   description: "Move a record's status. Compare-and-swap: a concurrent change fails instead of being overwritten.",
-  input: z28.object({
+  input: z33.object({
     bundlePath,
     conceptId,
-    status: z28.enum(KB_RECORD_STATUSES)
+    status: z33.enum(KB_RECORD_STATUSES)
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -5254,13 +6972,13 @@ var statusCommand = define({
 });
 
 // src/commands/supersede.ts
-import { z as z29 } from "zod";
+import { z as z34 } from "zod";
 var supersedeCommand = define({
   name: "supersede",
   tool: "kb_supersede",
   usage: "supersede <concept-id> <replacement-id>",
   description: "Mark a record superseded by another, linked in both directions. Use instead of editing a record whose meaning changed.",
-  input: z29.object({ bundlePath, conceptId, replacementId: conceptId }),
+  input: z34.object({ bundlePath, conceptId, replacementId: conceptId }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -5273,17 +6991,153 @@ var supersedeCommand = define({
   }
 });
 
+// src/commands/sweep.ts
+import { z as z35 } from "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: z35.object({
+    bundlePath,
+    tag: z35.string({ error: "sweep needs --tag: it never sweeps a whole base" }).min(1).describe("Only records carrying this tag are considered."),
+    terminal: z35.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: z35.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
-import { z as z30 } from "zod";
+import { z as z36 } from "zod";
 var syncInstructionsCommand = define({
   name: "sync-instructions",
   usage: "sync-instructions <file> [--profile NAME] [--budget N] [--full-under N]",
   description: "CLI-only: plant the kb_context block between sentinel comments in AGENTS.md or CLAUDE.md, idempotently.",
-  input: z30.object({
-    file: z30.string().min(1).describe("The instruction file to edit in place."),
-    budgetTokens: z30.number().int().positive().optional(),
-    fullUnderTokens: z30.number().int().positive().optional(),
-    profile: z30.string().optional()
+  input: z36.object({
+    file: z36.string().min(1).describe("The instruction file to edit in place."),
+    budgetTokens: z36.number().int().positive().optional(),
+    fullUnderTokens: z36.number().int().positive().optional(),
+    profile: z36.string().optional()
   }),
   fromArgv: (argv) => {
     const budget = argvFlag(argv, "--budget");
@@ -5309,17 +7163,17 @@ var syncInstructionsCommand = define({
 });
 
 // src/commands/trace.ts
-import { z as z31 } from "zod";
+import { z as z37 } from "zod";
 var traceCommand = define({
   name: "trace",
   tool: "kb_trace",
   usage: "trace <concept-id> [edges...]",
   description: 'Timeline of how a position was reached, ordered by write time, following supersession, shared anchors and shared sources. Includes rejected, draft and superseded records \u2014 in a history they are the content. For "why is it like this"; kb_load answers "what holds now".',
-  input: z31.object({
+  input: z37.object({
     bundlePath,
     conceptId,
-    edges: z31.array(z31.enum(TRACE_EDGES)).optional(),
-    depth: z31.number().int().positive().optional()
+    edges: z37.array(z37.enum(TRACE_EDGES)).optional(),
+    depth: z37.number().int().positive().optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -5341,37 +7195,37 @@ var traceCommand = define({
 });
 
 // src/commands/types.ts
-import { z as z32 } from "zod";
+import { z as z38 } from "zod";
 var typesCommand = define({
   name: "types",
   tool: "kb_types",
   usage: "types",
   description: "The twelve record types with their purpose, body sections, and starting status. Read this before writing rather than guessing headings \u2014 a section the type does not define is rejected.",
-  input: z32.object({}),
+  input: z38.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(RECORD_TYPES)
 });
 
 // src/commands/unpin.ts
-import { z as z33 } from "zod";
+import { z as z39 } from "zod";
 var unpinCommand = define({
   name: "unpin",
   tool: "kb_unpin",
   usage: "unpin [bundle-path]",
   description: "Remove a base from every manifest layer that holds it. Reports the layers touched.",
-  input: z33.object({ bundlePath }),
+  input: z39.object({ bundlePath }),
   fromArgv: (argv, path) => ({ bundlePath: argv[1] ?? path }),
   run: (_ctx, { bundlePath: path }) => unpinBase(process.cwd(), path)
 });
 
 // src/commands/validate.ts
-import { z as z34 } from "zod";
+import { z as z40 } from "zod";
 var validateCommand = define({
   name: "validate",
   tool: "kb_validate",
   usage: "validate",
   description: "Check pointers no single record can see: supersession links that disagree between the two records, typed causal links, and assumptions that cite sources. Each finding carries a severity: errors fail the exit code, warnings do not.",
-  input: z34.object({ bundlePath }),
+  input: z40.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.
@@ -5381,16 +7235,16 @@ var validateCommand = define({
 });
 
 // src/commands/verify.ts
-import { z as z35 } from "zod";
+import { z as z41 } from "zod";
 var verifyCommand = define({
   name: "verify",
   tool: "kb_verify",
   usage: "verify <concept-id> --note <text>",
   description: "Append a verified[] event: who checked, when, and what was found. Append-only. A record's own generator is refused unless the actor is `human:`-prefixed.",
-  input: z35.object({
+  input: z41.object({
     bundlePath,
     conceptId,
-    note: z35.string().refine((s) => s.trim().length > 0, {
+    note: z41.string().refine((s) => s.trim().length > 0, {
       message: "note must say what the check found"
     })
   }),
@@ -5410,15 +7264,15 @@ var verifyCommand = define({
 });
 
 // src/commands/write.ts
-import { z as z36 } from "zod";
+import { z as z42 } from "zod";
 var writeCommand = define({
   name: "write",
   tool: "kb_write",
   usage: "write <type> < record.json",
   description: "Write one record. Search first \u2014 a duplicate concept id is rejected, not overwritten; kb_types lists each type's sections. An unsourced claim is an `assumption` with assumption: true, never a vague `fact`. Conflicting records get a `risk`, `open-question`, or superseding `decision`. Prefer a new short record over overloading one. Never delete; supersede.",
-  input: z36.object({
+  input: z42.object({
     bundlePath,
-    type: z36.enum(KB_RECORD_TYPES),
+    type: z42.enum(KB_RECORD_TYPES),
     input: composeInputSchema
   }),
   fromArgv: async (argv, path, stdin) => ({
@@ -5442,13 +7296,13 @@ var writeCommand = define({
 });
 
 // src/commands/write-decision.ts
-import { z as z37 } from "zod";
+import { z as z43 } from "zod";
 var writeDecisionCommand = define({
   name: "write-decision",
   tool: "kb_write_decision",
   usage: "write-decision < decision.json",
   description: "Write a decision, with `alternative` (what was rejected and why) and `impact` as fields. Record one when a later reader would otherwise simplify the constraint away; skip when the diff already answers it. `sources` for material read, `anchors` for code, `relatedConceptIds` for records.",
-  input: z37.object({ bundlePath, input: decisionInputSchema }),
+  input: z43.object({ bundlePath, input: decisionInputSchema }),
   fromArgv: async (_argv, path, stdin) => ({
     bundlePath: path,
     input: JSON.parse(await stdin())
@@ -5479,19 +7333,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,
@@ -5531,7 +7390,7 @@ function parseMarkdownWithFrontmatter(text, schema) {
 
 // src/search-index.ts
 import { stat as stat3 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 var SEARCH_INDEX_FILE = ".index.sqlite";
 var COLLECTION = "kb";
 async function searchBase(bundlePath2, query, options = {}) {
@@ -5540,7 +7399,7 @@ async function searchBase(bundlePath2, query, options = {}) {
   let store = null;
   try {
     store = await qmd.createStore({
-      dbPath: join6(bundlePath2, SEARCH_INDEX_FILE),
+      dbPath: join8(bundlePath2, SEARCH_INDEX_FILE),
       config: {
         collections: {
           [COLLECTION]: {
@@ -5575,16 +7434,16 @@ async function searchBase(bundlePath2, query, options = {}) {
   }
 }
 async function isStale(bundlePath2) {
-  const indexAt = await stat3(join6(bundlePath2, SEARCH_INDEX_FILE)).then((s) => s.mtimeMs).catch(() => 0);
+  const indexAt = await stat3(join8(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 stat3(join6(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
+    const at2 = await stat3(join8(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
     if (at2 > indexAt) stale = true;
   });
   return stale;
@@ -5622,14 +7481,14 @@ async function loadQmd(logger) {
 import {
   appendFile,
   link,
-  mkdir as mkdir4,
-  readdir,
-  readFile as readFile7,
-  rename as rename2,
-  unlink,
-  writeFile as writeFile4
+  mkdir as mkdir5,
+  readdir as readdir2,
+  readFile as readFile8,
+  rename as rename3,
+  unlink as unlink2,
+  writeFile as writeFile5
 } from "fs/promises";
-import { join as join7, resolve as resolve5, sep as sep3 } from "path";
+import { join as join9, resolve as resolve6, sep as sep3 } from "path";
 
 // src/kb-stamp.ts
 import { createHash as createHash4 } from "crypto";
@@ -5663,144 +7522,13 @@ function bundleDigest(records, superseded) {
   return bundleStamp(records, superseded).digest;
 }
 
-// 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;
@@ -5808,23 +7536,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 = join7(".strauss", "kb");
-var STORE_OWNED = /* @__PURE__ */ new Set([INDEX_FILE, LOG_FILE, SEARCH_INDEX_FILE]);
+var KB_DIR = join9(".strauss", "kb");
+var STORE_OWNED = new Set(STORE_OWNED_FILES);
 var DEFAULT_LOAD_BUDGET = 25e3;
 var KbStore = class {
   constructor(logger = {}) {
@@ -5854,7 +7598,7 @@ var KbStore = class {
     const conceptId2 = `${input.type}.${input.slug}`;
     const root = this.root(bundlePath2);
     const target = this.recordPath(bundlePath2, conceptId2);
-    await mkdir4(root, { recursive: true });
+    await mkdir5(root, { recursive: true });
     await this.publish(
       target,
       stringifyMarkdownWithFrontmatter(input.body, frontmatter),
@@ -5893,7 +7637,7 @@ var KbStore = class {
     const target = this.recordPath(bundlePath2, conceptId2);
     let raw;
     try {
-      raw = await readFile7(target, "utf8");
+      raw = await readFile8(target, "utf8");
     } catch {
       return null;
     }
@@ -5913,7 +7657,7 @@ var KbStore = class {
     const root = this.root(bundlePath2);
     let names;
     try {
-      names = await readdir(root);
+      names = await readdir2(root);
     } catch {
       return [];
     }
@@ -5921,7 +7665,7 @@ var KbStore = class {
     const records = await mapLimit(
       wanted,
       DEFAULT_IO_CONCURRENCY,
-      async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await readFile7(join7(root, name), "utf8"))
+      async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await readFile8(join9(root, name), "utf8"))
     );
     return records.filter(
       (record) => record !== null && matchesTags(record, filter)
@@ -5951,12 +7695,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 }
     );
   }
@@ -6042,6 +7790,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 unlink2(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.
    *
@@ -6264,11 +8041,11 @@ ${answer}
   async readIndex(bundlePath2) {
     const root = this.root(bundlePath2);
     const expected = renderIndex(await this.list(bundlePath2));
-    const stored = await readFile7(join7(root, INDEX_FILE), "utf8").catch(
+    const stored = await readFile8(join9(root, INDEX_FILE), "utf8").catch(
       () => null
     );
     if (indexIsStale(stored, expected)) {
-      await this.publish(join7(root, INDEX_FILE), expected, true, INDEX_FILE);
+      await this.publish(join9(root, INDEX_FILE), expected, true, INDEX_FILE);
       this.logger.info?.({
         operation: "kb.index.repair",
         bundlePath: root,
@@ -6277,19 +8054,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 unlink2(join9(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 readFile7(
-      join7(this.root(bundlePath2), LOG_FILE),
+    const raw = await readFile8(
+      join9(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",
@@ -6299,6 +8096,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
@@ -6337,14 +8142,14 @@ ${answer}
   }
   async mutate(bundlePath2, conceptId2, change, entry, changeBody = (body) => body) {
     const target = this.recordPath(bundlePath2, conceptId2);
-    const before = await readFile7(target, "utf8").catch(() => null);
+    const before = await readFile8(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 readFile7(target, "utf8").catch(() => null);
+    const witness = await readFile8(target, "utf8").catch(() => null);
     if (witness === null || sha2563(witness) !== sha2563(before)) {
       throw new KbWriteConflictError(conceptId2);
     }
@@ -6370,10 +8175,10 @@ ${answer}
    */
   async publish(target, contents, overwrite, conceptId2) {
     const staging = `${target}.${process.pid}.tmp`;
-    await writeFile4(staging, contents, "utf8");
+    await writeFile5(staging, contents, "utf8");
     try {
       if (overwrite) {
-        await rename2(staging, target);
+        await rename3(staging, target);
         return;
       }
       await link(staging, target);
@@ -6383,13 +8188,14 @@ ${answer}
       }
       throw error;
     } finally {
-      await unlink(staging).catch(() => void 0);
+      await unlink2(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`/
@@ -6402,10 +8208,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`,
@@ -6416,29 +8221,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 = join7(root, GITATTRIBUTES_FILE);
+    const target = join9(root, GITATTRIBUTES_FILE);
     try {
       let existing;
       try {
-        existing = await readFile7(target, "utf8");
+        existing = await readFile8(target, "utf8");
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
         existing = null;
       }
       if (existing === null) {
         try {
-          await writeFile4(target, appendUnionMergeLine(""), {
+          await writeFile5(target, appendGitattributesLines(""), {
             encoding: "utf8",
             flag: "wx"
           });
@@ -6458,8 +8263,9 @@ ${answer}
         });
         return;
       }
-      if (!hasMergeDeclaration(existing)) {
-        await appendFile(target, appendUnionMergeLine(existing), "utf8");
+      const addition = appendGitattributesLines(existing);
+      if (addition) {
+        await appendFile(target, addition, "utf8");
         this.logger.info?.({
           operation: "kb.gitattributes.ensure",
           bundlePath: root,
@@ -6478,7 +8284,7 @@ ${answer}
   async record(root, entry) {
     await this.ensureGitattributes(root);
     const line = renderLogEntry({ at: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
-    await appendFile(join7(root, LOG_FILE), line, "utf8").catch((error) => {
+    await appendFile(join9(root, LOG_FILE), line, "utf8").catch((error) => {
       this.logger.warn?.({
         operation: "kb.log.append",
         outcome: "failed",
@@ -6504,7 +8310,7 @@ ${answer}
     };
   }
   root(bundlePath2) {
-    return resolve5(bundlePath2);
+    return resolve6(bundlePath2);
   }
   // Concept ids are `<type>.<slug>` and map to a single file directly under the
   // bundle root; anything carrying a separator would escape it.
@@ -6515,7 +8321,7 @@ ${answer}
         { conceptId: conceptId2 }
       );
     }
-    return join7(this.root(bundlePath2), `${conceptId2}.md`);
+    return join9(this.root(bundlePath2), `${conceptId2}.md`);
   }
 };
 function estimateTokens(record) {
@@ -6639,13 +8445,15 @@ function typeRank(record) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.1.19" : "0.0.0-dev";
+var VERSION = true ? "0.1.20" : "0.0.0-dev";
 
 export {
   kbSourceSchema,
   kbActorStampSchema,
   kbVerifiedEventSchema,
+  kbAnchorSpanSchema,
   kbAnchorSchema,
+  kbAnchorWriteSchema,
   kbLinkSchema,
   KB_RECORD_TYPES,
   KB_SLUG_PATTERN,
@@ -6699,6 +8507,11 @@ export {
   KbPackBudgetExceededError,
   KbUnknownLinkRelError,
   KbMissingFlagValueError,
+  KbClassifyInputError,
+  KbPromoteCollisionError,
+  KbPromoteStandingError,
+  KbPromoteSelfError,
+  KbPromoteStoppedError,
   KbInvalidConceptIdError,
   contextProfileBudgets,
   mergedContextBudgets,
@@ -6719,6 +8532,15 @@ export {
   matchesTags,
   catalog,
   renderCatalogLine,
+  matchToDiff,
+  anchorOnHunk,
+  symbolRangeIndex,
+  KB_CLASSES,
+  DEFAULT_THRESHOLDS,
+  classifyDiff,
+  classifyDrift,
+  unifiedDiff,
+  reassessPacket,
   INDEX_FILE,
   renderIndex,
   renderIndexLine,
@@ -6729,9 +8551,6 @@ export {
   CONTEXT_BEGIN,
   CONTEXT_END,
   syncInstructions,
-  classifyDrift,
-  unifiedDiff,
-  reassessPacket,
   KB_EDGE_KINDS,
   DEFAULT_TYPED_LINK_RELS,
   neighbours,
@@ -6742,6 +8561,14 @@ export {
   DEFAULT_AGING_DAYS,
   KB_DOCTOR_CHECKS,
   doctor,
+  PROMOTION_SOURCE_ID,
+  carry,
+  isReviewTag,
+  inboundIndex,
+  backlinks,
+  impact,
+  promoteCandidates,
+  promoteInputSchema,
   LOG_FILE,
   kbLogEntrySchema,
   renderLogEntry,
@@ -6761,12 +8588,9 @@ export {
   DEFAULT_PACK_HOPS,
   DEFAULT_PACK_MAX_NODES,
   pack,
-  inboundIndex,
-  backlinks,
-  impact,
   KB_DIR,
   DEFAULT_LOAD_BUDGET,
   KbStore,
   VERSION
 };
-//# sourceMappingURL=chunk-MNQNHYWL.js.map
+//# sourceMappingURL=chunk-QQLPJO4R.js.map