@saasontools/strauss-kb 0.1.19 → 0.1.20

package/dist/index.cjs

@@ -40,12 +40,14 @@ __export(index_exports, {
   DEFAULT_LOAD_BUDGET: () => DEFAULT_LOAD_BUDGET,
   DEFAULT_PACK_HOPS: () => DEFAULT_PACK_HOPS,
   DEFAULT_PACK_MAX_NODES: () => DEFAULT_PACK_MAX_NODES,
+  DEFAULT_THRESHOLDS: () => DEFAULT_THRESHOLDS,
   DEFAULT_TYPED_LINK_RELS: () => DEFAULT_TYPED_LINK_RELS,
   DEFAULT_UNVERIFIED_DAYS: () => DEFAULT_UNVERIFIED_DAYS,
   ErrorTypes: () => ErrorTypes,
   Fault: () => Fault,
   INDEX_FILE: () => INDEX_FILE,
   KB_CAUSAL_LINK_RELS: () => KB_CAUSAL_LINK_RELS,
+  KB_CLASSES: () => KB_CLASSES,
   KB_COMMANDS: () => KB_COMMANDS,
   KB_COMMANDS_BY_NAME: () => KB_COMMANDS_BY_NAME,
   KB_CONCEPT_ID_PATTERN: () => KB_CONCEPT_ID_PATTERN,
@@ -59,10 +61,15 @@ __export(index_exports, {
   KB_RECORD_TYPES: () => KB_RECORD_TYPES,
   KB_SLUG_PATTERN: () => KB_SLUG_PATTERN,
   KbBaseFrozenError: () => KbBaseFrozenError,
+  KbClassifyInputError: () => KbClassifyInputError,
   KbInvalidConceptIdError: () => KbInvalidConceptIdError,
   KbMissingFlagValueError: () => KbMissingFlagValueError,
   KbPackBudgetExceededError: () => KbPackBudgetExceededError,
   KbPinsMalformedError: () => KbPinsMalformedError,
+  KbPromoteCollisionError: () => KbPromoteCollisionError,
+  KbPromoteSelfError: () => KbPromoteSelfError,
+  KbPromoteStandingError: () => KbPromoteStandingError,
+  KbPromoteStoppedError: () => KbPromoteStoppedError,
   KbRecordAlreadyExistsError: () => KbRecordAlreadyExistsError,
   KbRecordNotFoundError: () => KbRecordNotFoundError,
   KbSelfVerificationError: () => KbSelfVerificationError,
@@ -75,16 +82,20 @@ __export(index_exports, {
   PINS_FILE: () => PINS_FILE,
   PINS_LOCAL_FILE: () => PINS_LOCAL_FILE,
   PIN_LAYERS: () => PIN_LAYERS,
+  PROMOTION_SOURCE_ID: () => PROMOTION_SOURCE_ID,
   RECORD_TYPES: () => RECORD_TYPES,
   SEARCH_INDEX_FILE: () => SEARCH_INDEX_FILE,
   TRACE_EDGES: () => TRACE_EDGES,
   TreeSitterResolver: () => TreeSitterResolver,
   adjudicate: () => adjudicate,
   anchorFilePath: () => anchorFilePath,
+  anchorOnHunk: () => anchorOnHunk,
   assertBaseNotFrozen: () => assertBaseNotFrozen,
   backlinks: () => backlinks,
   buildContext: () => buildContext,
+  carry: () => carry,
   catalog: () => catalog,
+  classifyDiff: () => classifyDiff,
   classifyDrift: () => classifyDrift,
   composeDecisionRecord: () => composeDecisionRecord,
   composeInputSchema: () => composeInputSchema,
@@ -110,8 +121,11 @@ __export(index_exports, {
   isKbLinkRel: () => isKbLinkRel,
   isKbRecordType: () => isKbRecordType,
   isNoDecisionRecord: () => isNoDecisionRecord,
+  isReviewTag: () => isReviewTag,
   kbActorStampSchema: () => kbActorStampSchema,
   kbAnchorSchema: () => kbAnchorSchema,
+  kbAnchorSpanSchema: () => kbAnchorSpanSchema,
+  kbAnchorWriteSchema: () => kbAnchorWriteSchema,
   kbConceptIdSchema: () => kbConceptIdSchema,
   kbJsonSchemas: () => kbJsonSchemas,
   kbLinkSchema: () => kbLinkSchema,
@@ -131,6 +145,8 @@ __export(index_exports, {
   parseMarkdownWithFrontmatter: () => parseMarkdownWithFrontmatter,
   pinBase: () => pinBase,
   prepareResolvers: () => prepareResolvers,
+  promoteCandidates: () => promoteCandidates,
+  promoteInputSchema: () => promoteInputSchema,
   readMergedPins: () => readMergedPins,
   readPinsLayer: () => readPinsLayer,
   readRemoteAnchors: () => readRemoteAnchors,
@@ -152,6 +168,7 @@ __export(index_exports, {
   selectDecisions: () => selectDecisions,
   splitMarkdownFrontmatter: () => splitMarkdownFrontmatter,
   stringifyMarkdownWithFrontmatter: () => stringifyMarkdownWithFrontmatter,
+  symbolRangeIndex: () => symbolRangeIndex,
   syncInstructions: () => syncInstructions,
   toHookJson: () => toHookJson,
   trace: () => trace,
@@ -242,9 +259,24 @@ var kbVerifiedEventSchema = kbActorStampSchema.extend({
     message: "note must say what the check found"
   })
 });
+var kbAnchorSpanSchema = import_zod.z.object({
+  start: import_zod.z.number().int().positive(),
+  end: import_zod.z.number().int().positive()
+}).strict();
 var kbAnchorSchema = import_zod.z.object({
   file: import_zod.z.string().min(1),
   symbol: import_zod.z.string().min(1).optional(),
+  /**
+   * The lines the concept names, when no symbol covers them — deleted code,
+   * YAML, SQL, Markdown. Alternative to `symbol`, never a refinement of it.
+   */
+  span: kbAnchorSpanSchema.optional(),
+  /**
+   * Which side of the change the anchor describes. `old` is code as it was
+   * committed at `ref`, which is the only way to anchor something deleted;
+   * absent means the working tree.
+   */
+  side: import_zod.z.enum(["old", "new"]).optional(),
   /**
    * Which repository the file lives in — a remote URL
    * (`https://github.com/org/name`) or a short name. Absent means the base's
@@ -283,8 +315,38 @@ var kbAnchorSchema = import_zod.z.object({
    * before resolvers were named, which is read as `regex` — the only one
    * there was. A hash from a different resolver is drift, not a match.
    */
-  resolver: import_zod.z.enum(["tree-sitter", "regex"]).optional()
+  resolver: import_zod.z.enum(["tree-sitter", "regex", "span"]).optional()
 }).strict();
+var kbAnchorWriteSchema = kbAnchorSchema.superRefine((anchor, ctx) => {
+  if (anchor.span && anchor.symbol) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["span"],
+      message: "an anchor names a symbol or a span, not both"
+    });
+  }
+  if (anchor.span && anchor.span.end < anchor.span.start) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["span", "end"],
+      message: "span end must not precede start"
+    });
+  }
+  if (anchor.span && anchor.hash_kind === "ast") {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["hash_kind"],
+      message: "a span is hashed raw, never ast"
+    });
+  }
+  if (anchor.side === "old" && !anchor.ref) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["ref"],
+      message: 'side: "old" needs a ref \u2014 committed code has no other address'
+    });
+  }
+});
 var kbLinkSchema = import_zod.z.object({
   target: import_zod.z.string().min(1),
   rel: import_zod.z.string().min(1)
@@ -371,9 +433,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";
@@ -519,6 +587,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({
@@ -698,7 +849,9 @@ function revRef(rev) {
 var UNCHECKED_REASONS = [
   "remote-unreachable",
   "repo-unauthorized",
-  "default-branch-unknown"
+  "default-branch-unknown",
+  /** Local, but the same finding: a shallow clone has no rev to read. */
+  "ref-unavailable"
 ];
 function isUncheckedReason(reason) {
   return reason !== void 0 && UNCHECKED_REASONS.includes(reason);
@@ -766,6 +919,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]);
@@ -1164,6 +1322,142 @@ function bundleDigest(records, superseded) {
   return bundleStamp(records, superseded).digest;
 }
 
+// src/drift/git.ts
+var import_node_child_process3 = require("child_process");
+var import_node_util3 = require("util");
+var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
+var MAX_GIT_OUTPUT_BYTES = 1048576;
+var 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/read.ts
 var import_promises2 = require("fs/promises");
 var import_node_path2 = require("path");
@@ -1229,6 +1523,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;
@@ -1364,7 +1659,7 @@ function size(bytes) {
   return bytes >= 1024 * 1024 ? `${(bytes / (1024 * 1024)).toFixed(1)} MB` : `${Math.round(bytes / 1024)} KB`;
 }
 function pause(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 
 // src/grammars/manifest.ts
@@ -1936,8 +2231,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();
@@ -1958,42 +2253,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) {
@@ -2015,6 +2323,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();
@@ -2027,11 +2336,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);
@@ -2044,12 +2359,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);
@@ -2068,6 +2399,9 @@ function resolverChanged(source, anchor, produced) {
   return before !== null && hashAnchorText(before.text) === anchor.hash;
 }
 function anchorHashOf(anchor, outcome) {
+  if (outcome.resolver === "span") {
+    return { hash: hashAnchorText(outcome.span.text), kind: "raw" };
+  }
   const stored = anchor.hash ? anchor.hash_kind ?? "raw" : void 0;
   const wanted = stored ?? (outcome.normalized ? "ast" : "raw");
   return wanted === "ast" && outcome.normalized ? { hash: hashAnchorText(outcome.normalized), kind: "ast" } : { hash: hashAnchorText(outcome.span.text), kind: "raw" };
@@ -2101,37 +2435,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 }];
@@ -2142,6 +2499,7 @@ function base(anchor) {
   return {
     file: anchor.file,
     ...anchor.symbol ? { symbol: anchor.symbol } : {},
+    ...anchor.side === "old" ? { side: "old" } : {},
     storedHash: anchor.hash
   };
 }
@@ -2155,9 +2513,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;
 }
@@ -2226,6 +2590,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, {
@@ -2261,19 +2632,28 @@ var kbLogEntrySchema = import_zod3.z.object({
   by: import_zod3.z.string().min(1),
   operation: import_zod3.z.string().min(1),
   conceptId: import_zod3.z.string().min(1),
-  /** Second concept id, where the operation relates two — supersession. */
+  /**
+   * The operation's other end, where it has one: a second concept id for
+   * supersession, the other base's path for promotion.
+   */
   target: import_zod3.z.string().min(1).optional()
 }).strict();
 function renderLogEntry(entry) {
   return `${JSON.stringify(kbLogEntrySchema.parse(entry))}
 `;
 }
+var CONFLICT_MARKER = /^(<{7}|\|{7}|={7}|>{7})/;
 function parseLog(raw) {
   const entries = [];
   const malformed = [];
   const seen = /* @__PURE__ */ new Set();
+  let conflicted = false;
   raw.split("\n").forEach((text, index2) => {
     if (!text.trim()) return;
+    if (CONFLICT_MARKER.test(text)) {
+      conflicted = true;
+      return;
+    }
     let value;
     try {
       value = JSON.parse(text);
@@ -2294,7 +2674,7 @@ function parseLog(raw) {
   entries.sort(
     (left, right) => left.at < right.at ? -1 : left.at > right.at ? 1 : 0
   );
-  return { entries, malformed };
+  return { entries, malformed, conflicted };
 }
 
 // src/search-index.ts
@@ -2343,8 +2723,8 @@ async function searchBase(bundlePath2, query, options = {}) {
 async function isStale(bundlePath2) {
   const indexAt = await (0, import_promises5.stat)((0, import_node_path6.join)(bundlePath2, SEARCH_INDEX_FILE)).then((s) => s.mtimeMs).catch(() => 0);
   if (!indexAt) return true;
-  const { readdir: readdir2 } = await import("fs/promises");
-  const names = (await readdir2(bundlePath2).catch(() => [])).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;
@@ -2759,14 +3139,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
   };
 }
@@ -2922,9 +3302,13 @@ function hasEdge(edges, edge) {
   );
 }
 
+// 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;
@@ -2932,23 +3316,39 @@ function parseLine(line) {
   return pattern === void 0 ? null : { pattern, attrs };
 }
 function hasMergeDeclaration(contents) {
+  return declares(contents, LOG_FILE, "merge");
+}
+function declares(contents, pattern, attribute) {
   return contents.split("\n").some((line) => {
     const parsed = parseLine(line);
-    if (!parsed || parsed.pattern !== LOG_FILE) return false;
+    if (!parsed || parsed.pattern !== pattern) return false;
     return parsed.attrs.some(
-      (attr) => attr === "merge" || attr === "-merge" || attr.startsWith("merge=")
+      (attr) => attr === attribute || attr === `-${attribute}` || attr.startsWith(`${attribute}=`)
     );
   });
 }
-function appendUnionMergeLine(contents) {
+function missingGitattributesLines(contents) {
+  const needsMerge = !hasMergeDeclaration(contents);
+  const generated = STORE_OWNED_FILES.filter(
+    // The union-merge line carries the log's `linguist-generated` too, so the
+    // log needs its own line only where that line is already there without it.
+    (file) => !(needsMerge && file === LOG_FILE)
+  ).filter((file) => !declares(contents, file, GENERATED)).map((file) => `${file} ${GENERATED}=true`);
+  return needsMerge ? [UNION_MERGE_LINE, ...generated] : generated;
+}
+var GITATTRIBUTES_BLOCK = `${missingGitattributesLines("").join("\n")}
+`;
+function appendGitattributesLines(contents) {
+  const lines = missingGitattributesLines(contents);
+  if (lines.length === 0) return "";
   const separator = contents.length === 0 || contents.endsWith("\n") ? "" : "\n";
-  return `${separator}${UNION_MERGE_LINE}
+  return `${separator}${lines.join("\n")}
 `;
 }
 
 // src/kb-store.ts
 var KB_DIR = (0, import_node_path7.join)(".strauss", "kb");
-var STORE_OWNED = /* @__PURE__ */ new Set([INDEX_FILE, LOG_FILE, SEARCH_INDEX_FILE]);
+var STORE_OWNED = new Set(STORE_OWNED_FILES);
 var DEFAULT_LOAD_BUDGET = 25e3;
 var KbStore = class {
   constructor(logger = {}) {
@@ -3075,12 +3475,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 }
     );
   }
@@ -3166,6 +3570,35 @@ ${answer}
 `
     );
   }
+  /**
+   * Removes one record, logged as `sweep`. The only path in this store that
+   * deletes — see the specification for the scope that makes it safe.
+   *
+   * `expected` is re-read and re-checked immediately before the unlink, the
+   * compare-and-swap `mutate` makes: a record retagged or moved out of a
+   * terminal status since the caller listed it is reported, not removed.
+   */
+  async deleteRecord(bundlePath2, conceptId2, expected, actor = "unknown") {
+    const target = this.recordPath(bundlePath2, conceptId2);
+    const witness = await this.read(bundlePath2, conceptId2);
+    if (!witness) throw new KbRecordNotFoundError(conceptId2);
+    const { tags, strauss_status } = witness.frontmatter;
+    if (!(tags ?? []).includes(expected.tag) || !expected.statuses.includes(strauss_status)) {
+      return "changed-since-listing";
+    }
+    try {
+      await (0, import_promises6.unlink)(target);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      throw new KbRecordNotFoundError(conceptId2);
+    }
+    await this.record(this.root(bundlePath2), {
+      operation: "sweep",
+      by: actor,
+      conceptId: conceptId2
+    });
+    return "deleted";
+  }
   /**
    * Records matching a text query, each carrying its standing.
    *
@@ -3401,12 +3834,25 @@ ${answer}
     }
     return expected;
   }
+  /**
+   * Drops the derived search index, so the next search rebuilds it.
+   *
+   * `searchBase` re-indexes when a record is newer than the index, which no
+   * deletion makes true — a swept record would stay findable until some other
+   * record was written.
+   */
+  async dropSearchIndex(bundlePath2) {
+    await (0, import_promises6.unlink)((0, import_node_path7.join)(this.root(bundlePath2), SEARCH_INDEX_FILE)).catch(
+      () => void 0
+    );
+  }
   /**
    * The log, with unparseable lines reported rather than repaired.
    *
    * The log is the bundle's only artifact that cannot be reconstructed — the
    * records rebuild the index, and the code outlives both, but nothing else
    * knows which agent touched what. So a bad line is surfaced and left alone.
+   * Conflict markers are read past rather than reported per line.
    */
   async readLog(bundlePath2) {
     const raw = await (0, import_promises6.readFile)(
@@ -3414,6 +3860,13 @@ ${answer}
       "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",
@@ -3423,6 +3876,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
@@ -3513,7 +3974,8 @@ ${answer}
   /**
    * 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`/
@@ -3526,10 +3988,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`,
@@ -3540,12 +4001,12 @@ ${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.
@@ -3562,7 +4023,7 @@ ${answer}
       }
       if (existing === null) {
         try {
-          await (0, import_promises6.writeFile)(target, appendUnionMergeLine(""), {
+          await (0, import_promises6.writeFile)(target, appendGitattributesLines(""), {
             encoding: "utf8",
             flag: "wx"
           });
@@ -3582,8 +4043,9 @@ ${answer}
         });
         return;
       }
-      if (!hasMergeDeclaration(existing)) {
-        await (0, import_promises6.appendFile)(target, appendUnionMergeLine(existing), "utf8");
+      const addition = appendGitattributesLines(existing);
+      if (addition) {
+        await (0, import_promises6.appendFile)(target, addition, "utf8");
         this.logger.info?.({
           operation: "kb.gitattributes.ensure",
           bundlePath: root,
@@ -3692,7 +4154,7 @@ var composeInputSchema = import_zod4.z.object({
   why: import_zod4.z.string().min(1),
   /** Keyed by section heading from the type's spec. Unknown keys rejected. */
   sections: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string().min(1)).optional(),
-  anchors: import_zod4.z.array(kbAnchorSchema).optional(),
+  anchors: import_zod4.z.array(kbAnchorWriteSchema).optional(),
   sources: import_zod4.z.array(kbSourceSchema).optional(),
   /** No source exists, as a claim rather than a sentinel in `sources`. */
   assumption: import_zod4.z.boolean().optional(),
@@ -4352,7 +4814,7 @@ function kbJsonSchemas() {
 
 // src/match-diff.ts
 function matchToDiff(files, records, options = {}) {
-  const ranges = indexRanges(options.symbolRanges ?? []);
+  const ranges = symbolRangeIndex(options.symbolRanges ?? []);
   const anchored = records.filter(
     (record) => (record.frontmatter.strauss_anchors ?? []).length > 0
   );
@@ -4370,8 +4832,8 @@ function matchToDiff(files, records, options = {}) {
       let precision = "symbol";
       for (const { record, anchors } of candidates) {
         const placement = place(anchors, file.filePath, hunk, ranges);
-        if (placement === "miss") continue;
-        if (placement === "file") precision = "file";
+        if (placement.kind === "miss") continue;
+        if (placement.kind === "file") precision = "file";
         hits.push(record);
       }
       if (!hits.length) continue;
@@ -4385,19 +4847,51 @@ function matchToDiff(files, records, options = {}) {
   }
   return matches3;
 }
+function placeOnHunk(record, filePath, hunk, symbolRanges = []) {
+  const anchors = (record.frontmatter.strauss_anchors ?? []).filter(
+    (anchor) => normalize(anchor.file) === normalize(filePath)
+  );
+  return place(anchors, filePath, hunk, asIndex(symbolRanges));
+}
+function asIndex(ranges) {
+  return isIndex(ranges) ? ranges : symbolRangeIndex(ranges);
+}
+function isIndex(ranges) {
+  return !Array.isArray(ranges);
+}
+function anchorOnHunk(record, filePath, hunk, symbolRanges = []) {
+  return placeOnHunk(record, filePath, hunk, symbolRanges).anchor;
+}
 function place(anchors, filePath, hunk, ranges) {
-  let fallback = "miss";
+  let fallback = { kind: "miss" };
   for (const anchor of anchors) {
-    if (!anchor.symbol) return "file";
-    const resolved = ranges.get(key(filePath, anchor.symbol));
+    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) {
-      fallback = "file";
+      if (fallback.kind === "miss") fallback = { kind: "file", anchor };
       continue;
     }
-    if (resolved.some((range) => overlaps(range, hunk))) return "symbol";
+    if (resolved.some((range) => overlaps(range, hunk))) {
+      return { kind: "symbol", anchor };
+    }
   }
   return fallback;
 }
+function side(value) {
+  return value ?? "new";
+}
 function overlaps(range, hunk) {
   return range.startLine <= hunk.endLine && hunk.startLine <= range.endLine;
 }
@@ -4415,50 +4909,219 @@ function order(records) {
     )
   );
 }
-function indexRanges(ranges) {
+function symbolRangeIndex(ranges) {
   const byKey = /* @__PURE__ */ new Map();
   for (const range of ranges) {
-    const id = key(range.file, range.symbol);
+    const id = key(range.file, range.symbol, side(range.side));
     byKey.set(id, [...byKey.get(id) ?? [], range]);
   }
   return byKey;
 }
-function key(file, symbol) {
-  return `${normalize(file)}#${symbol}`;
+function key(file, symbol, at2) {
+  return `${normalize(file)}#${symbol}#${at2}`;
 }
 function normalize(path) {
   return path.replace(/^\.\//, "");
 }
 
-// src/validate.ts
-function validateBundle(records) {
-  const byId = new Map(records.map((record) => [record.conceptId, record]));
-  const problems = [];
-  const report = (check, conceptId2, note, severity = "error") => problems.push({ check, conceptId: conceptId2, note, severity });
-  for (const record of records) {
-    const { conceptId: conceptId2, frontmatter: fm } = record;
-    if (!isKbRecordType(fm.type)) {
-      report("type", conceptId2, `unrecognised type "${fm.type}"`);
-    }
-    if (fm.strauss_status === "superseded") {
-      const by = fm.strauss_superseded_by;
-      if (!by) {
-        report("superseded_by", conceptId2, "superseded with no replacement");
-      } else if (!byId.has(by)) {
-        report("superseded_by", conceptId2, `replacement ${by} is missing`);
-      } else if (!byId.get(by)?.frontmatter.strauss_supersedes?.includes(conceptId2)) {
-        report("backlink", by, `does not list ${conceptId2} in supersedes`);
-      }
-    }
-    for (const old of fm.strauss_supersedes ?? []) {
-      const previous = byId.get(old);
-      if (!previous) {
-        report("supersedes", conceptId2, `target ${old} is missing`);
-      } else if (previous.frontmatter.strauss_status !== "superseded") {
-        report("supersedes", conceptId2, `${old} is not marked superseded`);
-      }
-    }
-    for (const link2 of fm.strauss_links ?? []) {
+// 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)[^/]*$/
+  }
+];
+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", "");
+  }
+  return void 0;
+}
+function isBoilerplateLine(line) {
+  return BOILERPLATE_SHAPES.some((shape) => shape.test.test(line));
+}
+
+// src/classify/classify.ts
+function classifyDiff(files, options = {}) {
+  const overrides = currentOverrides(options.records ?? [], options.now);
+  const ranges = symbolRangeIndex(options.symbolRanges ?? []);
+  const thresholds = { ...DEFAULT_THRESHOLDS, ...options.thresholds };
+  return files.map((file) => classifyFile(file, overrides, ranges, thresholds));
+}
+var OVERRIDE_CLASS = /* @__PURE__ */ new Map([
+  ["review:generated", "generated"],
+  ["review:boilerplate", "boilerplate"],
+  ["review:move", "rename"]
+]);
+var WHOLE_FILE = {
+  startLine: 1,
+  endLine: Number.MAX_SAFE_INTEGER
+};
+function classifyFile(file, overrides, ranges, thresholds) {
+  const whole = overrides.find(
+    ({ record }) => placeOnHunk(record, file.filePath, WHOLE_FILE, ranges).kind === "file"
+  );
+  const verdict = whole ? verdictOf(whole) : heuristic(file, thresholds);
+  const hunks = file.hunks.map((hunk) => {
+    const hit = whole ?? overrides.find(
+      ({ record }) => placeOnHunk(record, file.filePath, hunk, ranges).kind !== "miss"
+    );
+    return {
+      startLine: hunk.startLine,
+      endLine: hunk.endLine,
+      ...hit ? verdictOf(hit) : verdict
+    };
+  });
+  return {
+    filePath: file.filePath,
+    ...verdict,
+    ...file.renamedFrom ? { renamedFrom: file.renamedFrom } : {},
+    ...hunks.some((hunk) => hunk.class !== verdict.class) ? { hunks } : {}
+  };
+}
+function verdictOf(override) {
+  return {
+    class: override.class,
+    reason: `kb-override ${override.record.conceptId}`
+  };
+}
+function heuristic(file, thresholds) {
+  const marker = generatedMarker(file.header ?? headOfDiff(file));
+  if (marker)
+    return { class: "generated", reason: `generated-header ${marker}` };
+  const rule = PATH_RULES.find((entry) => entry.test.test(file.filePath));
+  if (rule) return { class: rule.class, reason: rule.name };
+  if (file.renamedFrom && !file.hunks.length && (file.similarity ?? 100) >= thresholds.rename) {
+    return { class: "rename", reason: `rename ${file.renamedFrom}` };
+  }
+  const share = boilerplateShare(file);
+  if (share !== void 0 && share >= thresholds.boilerplate) {
+    return {
+      class: "boilerplate",
+      reason: `boilerplate ${Math.round(share * 100)}%`
+    };
+  }
+  return { class: "source", reason: "default" };
+}
+function headOfDiff(file) {
+  return file.hunks.flatMap(
+    (hunk) => (hunk.side ?? "new") === "new" && hunk.startLine <= HEADER_LINES ? (hunk.lines ?? []).slice(0, HEADER_LINES - hunk.startLine + 1) : []
+  );
+}
+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/validate.ts
+function validateBundle(records) {
+  const byId = new Map(records.map((record) => [record.conceptId, record]));
+  const problems = [];
+  const report = (check, conceptId2, note, severity = "error") => problems.push({ check, conceptId: conceptId2, note, severity });
+  for (const record of records) {
+    const { conceptId: conceptId2, frontmatter: fm } = record;
+    if (!isKbRecordType(fm.type)) {
+      report("type", conceptId2, `unrecognised type "${fm.type}"`);
+    }
+    if (fm.strauss_status === "superseded") {
+      const by = fm.strauss_superseded_by;
+      if (!by) {
+        report("superseded_by", conceptId2, "superseded with no replacement");
+      } else if (!byId.has(by)) {
+        report("superseded_by", conceptId2, `replacement ${by} is missing`);
+      } else if (!byId.get(by)?.frontmatter.strauss_supersedes?.includes(conceptId2)) {
+        report("backlink", by, `does not list ${conceptId2} in supersedes`);
+      }
+    }
+    for (const old of fm.strauss_supersedes ?? []) {
+      const previous = byId.get(old);
+      if (!previous) {
+        report("supersedes", conceptId2, `target ${old} is missing`);
+      } else if (previous.frontmatter.strauss_status !== "superseded") {
+        report("supersedes", conceptId2, `${old} is not marked superseded`);
+      }
+    }
+    for (const link2 of fm.strauss_links ?? []) {
       if (!isKbLinkRel(link2.rel)) {
         report(
           "link_rel",
@@ -4489,6 +5152,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",
@@ -4535,14 +5226,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 = {
@@ -4552,7 +5248,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(
@@ -4565,7 +5261,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))
   ];
@@ -4731,14 +5427,14 @@ function brokenSupersession(bundle, adjudicated) {
     (left, right) => left.conceptId.localeCompare(right.conceptId)
   );
 }
-function supersededButCited(bundle, standings) {
+function supersededButCited(bundle, standings2) {
   const byId = new Map(bundle.map((record) => [record.conceptId, record]));
   const findings = [];
   for (const record of bundle) {
-    const standing = standings.get(record.conceptId);
+    const standing = standings2.get(record.conceptId);
     if (standing === "superseded" || standing === "rejected") continue;
     for (const target of edgeNeighbours(record, bundle, "body-link")) {
-      const targetStanding = standings.get(target.conceptId);
+      const targetStanding = standings2.get(target.conceptId);
       if (targetStanding !== "superseded" && targetStanding !== "rejected") {
         continue;
       }
@@ -5004,6 +5700,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.
@@ -5180,12 +5877,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
   });
@@ -5197,6 +5900,13 @@ 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 key2 = normalizeRepoUrl(repo);
@@ -5329,141 +6039,12 @@ function count(value, noun) {
   return `${value} ${value === 1 ? noun : `${noun}s`}`;
 }
 
-// src/commands/context.ts
-var import_zod13 = require("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: import_zod13.z.object({
-    budgetTokens: import_zod13.z.number().int().positive().optional().describe(
-      "Ceiling on the whole emitted block; past it the command refuses with a list of bases rather than truncating. Defaults to 4000."
-    ),
-    fullUnderTokens: import_zod13.z.number().int().positive().optional().describe(
-      "Per-base rendering threshold, applied before the budget: a base whose complete load fits under this arrives as full records instead of index lines, and the whole block still answers to budgetTokens. Off by default \u2014 index-only is the safe default at a context birth, because injected bodies outlive the qualifiers on them; the session-start profile opts tiny bases in at 1500."
-    ),
-    profile: import_zod13.z.string().optional().describe(
-      "Named budget set: built-ins are session-start (full-under 1500), compact and turn (budget 2500); the manifests' `context` tables override per repo. Unknown names fall through to defaults rather than failing."
-    ),
-    excludeTags: import_zod13.z.array(import_zod13.z.string().min(1)).optional().describe(
-      "Frontmatter tags whose records stay out of the block. The base stays pinned and stays readable by tool; resolved like the budgets."
-    ),
-    format: import_zod13.z.enum(["markdown", "json"]).optional().describe(
-      "CLI envelope for hook protocols that require strict JSON on stdout. MCP callers omit this \u2014 the block itself is identical."
-    ),
-    event: import_zod13.z.string().optional().describe(
-      "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
-    )
-  }),
-  fromArgv: (argv) => {
-    const budget = argvFlag(argv, "--budget");
-    const fullUnder = argvFlag(argv, "--full-under");
-    const profile = argvFlag(argv, "--profile");
-    const format = argvFlag(argv, "--format");
-    const event = argvFlag(argv, "--event");
-    const excludeTags = argvFlags(argv, "--exclude-tag");
-    return {
-      ...budget ? { budgetTokens: Number(budget) } : {},
-      ...fullUnder ? { fullUnderTokens: Number(fullUnder) } : {},
-      ...profile ? { profile } : {},
-      ...excludeTags.length ? { excludeTags } : {},
-      ...format ? { format } : {},
-      ...event ? { event } : {}
-    };
-  },
-  run: async ({ store }, { budgetTokens, fullUnderTokens, profile, excludeTags, format, event }) => {
-    const result = await buildContext(store, process.cwd(), {
-      ...budgetTokens ? { budgetTokens } : {},
-      ...fullUnderTokens ? { fullUnderTokens } : {},
-      ...profile ? { profile } : {},
-      ...excludeTags ? { excludeTags } : {},
-      // Degradations — a full pin that could not fit, a refused block — go
-      // to stderr as well as into the block itself: stderr is diagnostics on
-      // both surfaces (hooks discard it, MCP logs it), so an operator can
-      // see budget pressure without reading injected context.
-      warn: (entry) => process.stderr.write(`${JSON.stringify(entry)}
-`)
-    });
-    if (!result.block) return "";
-    return format === "json" ? toHookJson(result.block, event ?? "SessionStart") : result.block;
-  }
-});
-
-// src/commands/doctor.ts
+// src/commands/classify.ts
+var import_node_buffer = require("buffer");
+var import_promises10 = require("fs/promises");
+var import_node_path12 = require("path");
 var import_zod15 = require("zod");
 
-// src/drift/git.ts
-var import_node_child_process3 = require("child_process");
-var import_node_util3 = require("util");
-var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
-var MAX_GIT_OUTPUT_BYTES = 1048576;
-var GIT_TIMEOUT_MS = 5e3;
-async function git2(cwd, args) {
-  const env = { ...process.env };
-  delete env["GIT_DIR"];
-  delete env["GIT_WORK_TREE"];
-  delete env["GIT_INDEX_FILE"];
-  try {
-    const { stdout } = await execFileAsync3("git", ["-C", cwd, ...args], {
-      timeout: GIT_TIMEOUT_MS,
-      maxBuffer: MAX_GIT_OUTPUT_BYTES,
-      env
-    });
-    return { ok: true, stdout };
-  } catch {
-    return { ok: false };
-  }
-}
-async function listRepoFiles(repoRoot) {
-  const result = await git2(repoRoot, ["ls-files", "-z", "--cached"]);
-  if (!result.ok) return [];
-  return result.stdout.split("\0").filter(Boolean);
-}
-async function readOldSource(repoRoot, anchor) {
-  if (!filePathIsSafe(anchor.file))
-    return { ok: false, reason: "unrecoverable" };
-  if (anchor.ref && refShapeIsSafe(anchor.ref)) {
-    const shown2 = await showFile(repoRoot, anchor.ref, anchor.file);
-    if (shown2 !== null) {
-      return {
-        ok: true,
-        source: shown2,
-        origin: { kind: "ref", ref: anchor.ref }
-      };
-    }
-  }
-  const at2 = anchor.resolved_at;
-  if (!at2 || Number.isNaN(Date.parse(at2))) {
-    return { ok: false, reason: "unrecoverable" };
-  }
-  const found = await git2(repoRoot, [
-    "log",
-    "-1",
-    "--format=%H",
-    `--before=${at2}`,
-    "--end-of-options",
-    "HEAD",
-    "--",
-    anchor.file
-  ]);
-  const sha = found.ok ? found.stdout.trim() : "";
-  if (!sha || !refShapeIsSafe(sha))
-    return { ok: false, reason: "unrecoverable" };
-  const shown = await showFile(repoRoot, sha, anchor.file);
-  if (shown === null) return { ok: false, reason: "unrecoverable" };
-  return { ok: true, source: shown, origin: { kind: "history", ref: sha } };
-}
-async function showFile(repoRoot, ref, file) {
-  const path = file.replace(/^\.\//, "");
-  const result = await git2(repoRoot, [
-    "show",
-    "--end-of-options",
-    `${ref}:${path}`
-  ]);
-  return result.ok ? result.stdout : null;
-}
-
 // src/drift/moved.ts
 var import_promises9 = require("fs/promises");
 var MAX_MOVED_SEARCH_FILES = 2e3;
@@ -5482,6 +6063,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);
@@ -5579,6 +6161,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({
@@ -5652,8 +6239,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 };
 }
@@ -5713,12 +6300,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;
@@ -5792,45 +6379,632 @@ function claimOf(record) {
   return text ? { section, text } : null;
 }
 
-// src/commands/reassess.ts
+// src/commands/match/command.ts
 var import_zod14 = require("zod");
-var reassessCommand = define({
-  name: "reassess",
-  tool: "kb_reassess",
-  usage: "reassess <concept-id> [--repo-root <path>] [--with-diff]",
-  description: "One drifted record, as something to judge: its claim, each anchor's drift class, the old-vs-new span diff, and the records that depend on it. Formatting-only drift is dropped. Empty when there is nothing to reassess. Writes: relocates moved anchors, keeping their hash; never verifies, supersedes, or changes standing.",
-  input: import_zod14.z.object({
-    bundlePath,
-    conceptId,
-    repoRoot: REPO_ROOT,
-    withDiff: import_zod14.z.boolean().optional().describe(
-      "Recover each anchor's committed span and render the diff. Reads git history."
-    )
-  }),
-  fromArgv: (argv, path) => {
-    const repoRoot = argvFlag(argv, "--repo-root");
-    return {
-      bundlePath: path,
-      conceptId: argv[1],
-      ...repoRoot !== void 0 ? { repoRoot } : {},
-      ...argv.includes("--with-diff") ? { withDiff: true } : {}
-    };
-  },
-  run: async ({ store, actor }, { bundlePath: path, conceptId: id, repoRoot, withDiff }) => {
-    const root = repoRoot ?? process.cwd();
-    const bundle = await store.list(path);
-    const record = bundle.find((entry) => entry.conceptId === id);
-    if (!record) throw new KbRecordNotFoundError(id);
-    const drift = await store.detectDrift([record], repoRoot);
-    const entries = drift?.get(id) ?? [];
-    if (!entries.some((entry) => entry.state !== "match")) {
-      return { conceptId: id, packet: null, rebaselined: [], cosmetic: 0 };
-    }
-    const standing = adjudicate(bundle, bundle).find(
-      (hit) => hit.record.conceptId === id
-    )?.standing;
-    const impact2 = await store.impact(path, id);
-    const { packet, classified } = await reassessPacket(root, record, entries, {
+
+// src/commands/match/errors.ts
+var KbMatchInputError = class extends BaseError {
+  constructor(reason) {
+    super({
+      message: `match: ${reason}`,
+      errorType: "KbMatchInput" /* KbMatchInput */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { reason }
+    });
+    this.reason = reason;
+  }
+  reason;
+};
+
+// src/commands/match/model.ts
+var import_zod13 = require("zod");
+var diffHunkSchema = import_zod13.z.object({
+  startLine: import_zod13.z.number().int().positive(),
+  endLine: import_zod13.z.number().int().positive(),
+  side: import_zod13.z.enum(["old", "new"]).optional()
+}).passthrough();
+var diffFileSchema = import_zod13.z.object({
+  filePath: import_zod13.z.string().min(1).describe("Repo-relative, spelled the way anchors are."),
+  hunks: import_zod13.z.array(diffHunkSchema)
+});
+var symbolRangeSchema = import_zod13.z.object({
+  file: import_zod13.z.string().min(1),
+  symbol: import_zod13.z.string().min(1),
+  startLine: import_zod13.z.number().int().positive(),
+  endLine: import_zod13.z.number().int().positive()
+});
+
+// src/commands/match/parse-unified-diff.ts
+var FILE_HEADER = /^diff --git (.+)$/;
+var HUNK = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+var SIMILARITY = /^similarity index (\d+)%$/;
+var KNOWN_PREFIX = /^[ab]\//;
+function parseUnifiedDiff(patch, options = {}) {
+  const files = [];
+  let current;
+  let listed = false;
+  let shared;
+  let oldPath;
+  let rename4 = {};
+  let inHeader = false;
+  let added;
+  let removed;
+  const list = () => {
+    if (!current || listed) return;
+    files.push(current);
+    listed = true;
+  };
+  const open2 = (filePath) => {
+    current = { filePath, hunks: [], ...rename4 };
+    listed = false;
+  };
+  const amend = () => {
+    if (current) Object.assign(current, rename4);
+  };
+  const close = () => {
+    if (options.keepEmpty) list();
+    current = void 0;
+    listed = false;
+    added = void 0;
+    removed = void 0;
+  };
+  for (const raw of patch.split("\n")) {
+    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+    const start = FILE_HEADER.exec(line);
+    if (start) {
+      close();
+      oldPath = void 0;
+      rename4 = {};
+      shared = sharedHeaderPath(start[1]);
+      inHeader = true;
+      if (shared) open2(shared);
+      continue;
+    }
+    if (inHeader) {
+      const similarity = SIMILARITY.exec(line);
+      if (similarity) {
+        rename4.similarity = Number(similarity[1]);
+        amend();
+        continue;
+      }
+      if (line.startsWith("rename from ")) {
+        rename4.renamedFrom = unquote(line.slice(12).trim());
+        amend();
+        continue;
+      }
+      if (line.startsWith("rename to ")) {
+        open2(unquote(line.slice(10).trim()));
+        continue;
+      }
+      if (line.startsWith("--- ")) {
+        oldPath = sidePath(line.slice(4), shared);
+        continue;
+      }
+      if (line.startsWith("+++ ")) {
+        const path = sidePath(line.slice(4), shared) ?? oldPath;
+        if (path) open2(path);
+        else current = void 0;
+        continue;
+      }
+    }
+    const hunk = HUNK.exec(line);
+    if (!hunk) {
+      if (!options.withLines || inHeader) continue;
+      if (line.startsWith("+")) added?.lines?.push(line.slice(1));
+      else if (line.startsWith("-")) removed?.lines?.push(line.slice(1));
+      continue;
+    }
+    inHeader = false;
+    added = void 0;
+    removed = void 0;
+    if (!current) continue;
+    const [next, before] = hunksOf(hunk, options.withLines === true);
+    added = next;
+    removed = before;
+    list();
+    current.hunks.push(...before ? [next, before] : [next]);
+  }
+  close();
+  return files;
+}
+function hunksOf(hunk, withLines) {
+  const oldStart = Number(hunk[1]);
+  const oldCount = hunk[2] === void 0 ? 1 : Number(hunk[2]);
+  const newStart = Number(hunk[3]);
+  const newCount = hunk[4] === void 0 ? 1 : Number(hunk[4]);
+  const lines = withLines ? { lines: [] } : {};
+  const added = newCount === 0 ? { ...point(newStart), ...lines } : { startLine: newStart, endLine: newStart + newCount - 1, ...lines };
+  if (oldCount === 0) return [added];
+  return [
+    added,
+    {
+      startLine: oldStart,
+      endLine: oldStart + oldCount - 1,
+      side: "old",
+      ...withLines ? { lines: [] } : {}
+    }
+  ];
+}
+function point(start) {
+  const at2 = Math.max(1, start);
+  return { startLine: at2, endLine: at2 };
+}
+function sidePath(raw, shared) {
+  const text = unquote(raw.replace(/\t.*$/, "").trim());
+  if (text === "/dev/null") return void 0;
+  if (KNOWN_PREFIX.test(text)) return text.slice(2);
+  return shared ?? text;
+}
+function sharedHeaderPath(rest) {
+  const pair = splitHeaderPair(rest);
+  if (!pair || pair[0] === pair[1]) return void 0;
+  const from = unquote(pair[0]).split("/");
+  const to = unquote(pair[1]).split("/");
+  const shared = [];
+  while (from.length > 1 && to.length > 1 && from.at(-1) === to.at(-1)) {
+    shared.unshift(from.pop());
+    to.pop();
+  }
+  return shared.length ? shared.join("/") : void 0;
+}
+function splitHeaderPair(rest) {
+  if (rest.startsWith('"')) {
+    const end = endOfQuoted(rest);
+    if (end < 0 || rest[end + 1] !== " ") return void 0;
+    return [rest.slice(0, end + 1), rest.slice(end + 2)];
+  }
+  const mid = (rest.length - 1) / 2;
+  if (Number.isInteger(mid) && rest[mid] === " ") {
+    return [rest.slice(0, mid), rest.slice(mid + 1)];
+  }
+  const at2 = rest.indexOf(" ");
+  return at2 === -1 ? void 0 : [rest.slice(0, at2), rest.slice(at2 + 1)];
+}
+function endOfQuoted(text) {
+  for (let at2 = 1; at2 < text.length; at2 += 1) {
+    if (text[at2] === "\\") {
+      at2 += 1;
+      continue;
+    }
+    if (text[at2] === '"') return at2;
+  }
+  return -1;
+}
+var ESCAPES = {
+  a: 7,
+  b: 8,
+  f: 12,
+  n: 10,
+  r: 13,
+  t: 9,
+  v: 11,
+  '"': 34,
+  "\\": 92
+};
+var OCTAL = /^[0-7]{3}/;
+var utf8 = new TextEncoder();
+function unquote(text) {
+  if (text.length < 2 || !text.startsWith('"') || !text.endsWith('"')) {
+    return text;
+  }
+  const body = text.slice(1, -1);
+  const bytes = [];
+  for (let at2 = 0; at2 < body.length; ) {
+    const slash = body.indexOf("\\", at2);
+    if (slash < 0) {
+      bytes.push(...utf8.encode(body.slice(at2)));
+      break;
+    }
+    if (slash > at2) bytes.push(...utf8.encode(body.slice(at2, slash)));
+    const octal = OCTAL.exec(body.slice(slash + 1, slash + 4));
+    if (octal) {
+      bytes.push(Number.parseInt(octal[0], 8));
+      at2 = slash + 4;
+      continue;
+    }
+    const next = body[slash + 1];
+    if (next === void 0) {
+      bytes.push(ESCAPES["\\"]);
+      break;
+    }
+    const mapped = ESCAPES[next];
+    if (mapped === void 0) bytes.push(...utf8.encode(next));
+    else bytes.push(mapped);
+    at2 = slash + 2;
+  }
+  return new TextDecoder().decode(Uint8Array.from(bytes));
+}
+
+// src/commands/match/symbol-ranges.ts
+async function resolveSymbolRanges(repoRoot, files, records, offline = false) {
+  const changed = new Set(files.map((file) => strip(file.filePath)));
+  const wanted = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    for (const anchor of record.frontmatter.strauss_anchors ?? []) {
+      if (!anchor.symbol || anchor.repo) continue;
+      if (!changed.has(strip(anchor.file))) continue;
+      const key2 = `${strip(anchor.file)}#${anchor.symbol}`;
+      if (seen.has(key2)) continue;
+      seen.add(key2);
+      wanted.push(anchor);
+    }
+  }
+  if (!wanted.length) return [];
+  const paths = [...new Set(wanted.map((anchor) => anchor.file))];
+  const sources = await readAnchorFiles(paths, anchorFileReader(repoRoot));
+  const resolvers = defaultAnchorResolvers({ offline });
+  await prepareResolvers(resolvers, paths);
+  const ranges = [];
+  for (const anchor of wanted) {
+    const read = sources.get(anchor.file);
+    if (!read?.ok) continue;
+    const outcome = resolveAnchorSpan(read.source, anchor, resolvers);
+    if (!outcome.ok) continue;
+    ranges.push({
+      file: anchor.file,
+      symbol: anchor.symbol,
+      startLine: outcome.span.startLine,
+      endLine: outcome.span.endLine
+    });
+  }
+  return ranges;
+}
+function strip(path) {
+  return path.replace(/^\.\//, "");
+}
+
+// src/commands/match/command.ts
+var matchCommand = define({
+  name: "match",
+  tool: "kb_match",
+  usage: "match --git <base>..<head> | --stdin [--repo-root <path>] [--offline] [--include-non-current]",
+  description: "Which records sit on each changed hunk: the anchored records per file range, current first, each with its standing and the anchor that matched. kb_load hands over a whole base; this narrows a diff. Symbol ranges resolve from repoRoot when omitted; non-current records need includeNonCurrent.",
+  input: import_zod14.z.object({
+    bundlePath,
+    files: import_zod14.z.array(diffFileSchema).describe("The changed files, each with its post-change line ranges."),
+    symbolRanges: import_zod14.z.array(symbolRangeSchema).optional().describe(
+      "Symbol spans the caller already has. Resolved from repoRoot when omitted."
+    ),
+    repoRoot: REPO_ROOT,
+    offline: import_zod14.z.boolean().optional().describe(
+      "Resolve symbol ranges from what is already on disk, never fetching a grammar."
+    ),
+    includeNonCurrent: import_zod14.z.boolean().optional().describe(
+      "Return superseded, rejected and unsettled records too, each carrying its standing."
+    )
+  }),
+  fromArgv: async (argv, path, stdin) => {
+    const repoRoot = argvFlag(argv, "--repo-root");
+    const range = argvFlag(argv, "--git");
+    const base2 = {
+      bundlePath: path,
+      ...repoRoot !== void 0 ? { repoRoot } : {},
+      ...argv.includes("--offline") ? { offline: true } : {},
+      ...argv.includes("--include-non-current") ? { includeNonCurrent: true } : {}
+    };
+    if (range !== void 0) {
+      const diff = await readRangeDiff(repoRoot ?? process.cwd(), range);
+      if (!diff.ok) {
+        throw new KbMatchInputError(`--git ${range} ${REFUSED[diff.reason]}`);
+      }
+      return { ...base2, files: parseUnifiedDiff(diff.text) };
+    }
+    if (!argv.includes("--stdin")) {
+      throw new KbMatchInputError(
+        "pass --git <base>..<head>, or --stdin with { files } as JSON"
+      );
+    }
+    return { ...base2, ...fromStdin(await stdin()) };
+  },
+  run: async ({ store }, {
+    bundlePath: path,
+    files,
+    symbolRanges,
+    repoRoot,
+    offline,
+    includeNonCurrent
+  }) => {
+    const records = await store.list(path);
+    const ranges = symbolRanges ?? await resolveSymbolRanges(
+      repoRoot ?? process.cwd(),
+      files,
+      records,
+      offline === true
+    );
+    const index2 = symbolRangeIndex(ranges);
+    return matchToDiff(files, records, { symbolRanges: ranges }).flatMap(
+      (match) => project(match, index2, includeNonCurrent === true)
+    );
+  }
+});
+var REFUSED = {
+  "bad-range": "is not a range git could read here \u2014 both halves of <base>..<head> are required",
+  "too-large": "diffs to a patch past the output cap \u2014 narrow the range",
+  timeout: "took longer to diff than the runner allows \u2014 narrow the range",
+  "git-missing": "needs git on PATH, and there is none"
+};
+function fromStdin(text) {
+  let payload;
+  try {
+    payload = JSON.parse(text);
+  } catch {
+    throw new KbMatchInputError("stdin is not JSON");
+  }
+  if (!Array.isArray(payload?.files)) {
+    throw new KbMatchInputError("stdin needs a files array");
+  }
+  return {
+    files: payload.files,
+    ...payload.symbolRanges !== void 0 ? { symbolRanges: payload.symbolRanges } : {}
+  };
+}
+function project(match, ranges, all) {
+  const kept = all ? match.records : match.records.filter((hit) => hit.standing === "current");
+  if (!kept.length) return [];
+  const placed = kept.map((hit) => ({
+    hit,
+    at: placeOnHunk(hit.record, match.filePath, match.hunk, ranges)
+  }));
+  return [
+    {
+      filePath: match.filePath,
+      hunk: match.hunk,
+      // Over the records returned, not the ones matched: a hunk holding only
+      // symbol-placed records is not `file` because a dropped one was.
+      precision: placed.every(({ at: at2 }) => at2.kind === "symbol") ? "symbol" : "file",
+      records: placed.map(({ hit, at: { anchor } }) => {
+        const { frontmatter } = hit.record;
+        return {
+          conceptId: hit.record.conceptId,
+          type: frontmatter.type,
+          title: frontmatter.title ?? null,
+          standing: hit.standing,
+          status: frontmatter.strauss_status,
+          supersededBy: hit.heads.map((head) => head.conceptId),
+          ...frontmatter.strauss_materiality ? { materiality: frontmatter.strauss_materiality } : {},
+          ...frontmatter.strauss_confidence ? { confidence: frontmatter.strauss_confidence } : {},
+          ...frontmatter.tags?.length ? { tags: frontmatter.tags } : {},
+          ...anchor ? { anchor } : {}
+        };
+      })
+    }
+  ];
+}
+
+// src/commands/classify.ts
+var classifyFileSchema = diffFileSchema.extend({
+  hunks: import_zod15.z.array(
+    diffHunkSchema.extend({ lines: import_zod15.z.array(import_zod15.z.string()).optional() })
+  ),
+  renamedFrom: import_zod15.z.string().min(1).optional().describe("Where `git diff -M` says the path came from."),
+  similarity: import_zod15.z.number().min(0).max(100).optional()
+});
+var classifyCommand = define({
+  name: "classify",
+  tool: "kb_classify",
+  usage: "classify --git <base>..<head> | --stdin [--repo-root <path>] [--offline]",
+  description: "What kind of change each file carries: test, config, ci, docs, lockfile, generated, boilerplate, rename or source, with the rule that decided it. Derived from the diff and never stored; a `review:generated`, `review:boilerplate` or `review:move` fact anchored on a file overrides the heuristic. kb_match says what sits on a hunk; this says whether to read it.",
+  input: import_zod15.z.object({
+    bundlePath,
+    files: import_zod15.z.array(classifyFileSchema).describe("The changed files, each with its line ranges."),
+    repoRoot: REPO_ROOT,
+    offline: import_zod15.z.boolean().optional().describe(
+      "Resolve symbol ranges from what is already on disk, never fetching a grammar."
+    )
+  }),
+  fromArgv: async (argv, path, stdin) => {
+    const repoRoot = argvFlag(argv, "--repo-root");
+    const range = argvFlag(argv, "--git");
+    const base2 = {
+      bundlePath: path,
+      ...repoRoot !== void 0 ? { repoRoot } : {},
+      ...argv.includes("--offline") ? { offline: true } : {}
+    };
+    if (range !== void 0) {
+      const diff = await readRangeDiff(repoRoot ?? process.cwd(), range);
+      if (!diff.ok) {
+        throw new KbClassifyInputError(
+          `--git ${range} ${REFUSED2[diff.reason]}`
+        );
+      }
+      return {
+        ...base2,
+        files: parseUnifiedDiff(diff.text, {
+          keepEmpty: true,
+          withLines: true
+        })
+      };
+    }
+    if (!argv.includes("--stdin")) {
+      throw new KbClassifyInputError(
+        "pass --git <base>..<head>, or --stdin with { files } as JSON"
+      );
+    }
+    return { ...base2, files: fromStdin2(await stdin()) };
+  },
+  run: async ({ store }, { bundlePath: path, files, repoRoot, offline }) => {
+    const records = await store.list(path);
+    const root = repoRoot ?? process.cwd();
+    const withHeaders = await mapLimit2(files, READERS, async (file) => ({
+      ...file,
+      header: await header(root, file)
+    }));
+    const symbolRanges = await resolveSymbolRanges(
+      root,
+      files,
+      records,
+      offline === true
+    );
+    return { files: classifyDiff(withHeaders, { records, symbolRanges }) };
+  },
+  render: (result) => renderClassify(result)
+});
+var HEADER_BYTES = 65536;
+var READERS = 16;
+async function header(root, file) {
+  if (!filePathIsSafe(file.filePath)) return void 0;
+  let handle;
+  try {
+    handle = await (0, import_promises10.open)((0, import_node_path12.join)(root, file.filePath), "r");
+    const buffer = import_node_buffer.Buffer.alloc(HEADER_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, HEADER_BYTES, 0);
+    return buffer.toString("utf8", 0, bytesRead).split("\n").slice(0, HEADER_LINES);
+  } catch {
+    return void 0;
+  } finally {
+    await handle?.close();
+  }
+}
+async function mapLimit2(items, limit, run) {
+  const out = Array.from({ length: items.length });
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const at2 = next;
+      next += 1;
+      out[at2] = await run(items[at2]);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, () => worker())
+  );
+  return out;
+}
+var REFUSED2 = {
+  "bad-range": "is not a range git could read here \u2014 both halves of <base>..<head> are required",
+  "too-large": "diffs to a patch past the output cap \u2014 narrow the range",
+  timeout: "took longer to diff than the runner allows \u2014 narrow the range",
+  "git-missing": "needs git on PATH, and there is none"
+};
+function fromStdin2(text) {
+  let payload;
+  try {
+    payload = JSON.parse(text);
+  } catch {
+    throw new KbClassifyInputError("stdin is not JSON");
+  }
+  if (!Array.isArray(payload?.files)) {
+    throw new KbClassifyInputError("stdin needs a files array");
+  }
+  return payload.files;
+}
+function renderClassify(result) {
+  const width2 = Math.max(
+    0,
+    ...result.files.map((file) => file.class.length)
+  );
+  return result.files.map(
+    (file) => `${file.class.padEnd(width2)}  ${file.filePath}  (${file.reason})`
+  ).join("\n");
+}
+
+// src/commands/context.ts
+var import_zod16 = require("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: import_zod16.z.object({
+    budgetTokens: import_zod16.z.number().int().positive().optional().describe(
+      "Ceiling on the whole emitted block; past it the command refuses with a list of bases rather than truncating. Defaults to 4000."
+    ),
+    fullUnderTokens: import_zod16.z.number().int().positive().optional().describe(
+      "Per-base rendering threshold, applied before the budget: a base whose complete load fits under this arrives as full records instead of index lines, and the whole block still answers to budgetTokens. Off by default \u2014 index-only is the safe default at a context birth, because injected bodies outlive the qualifiers on them; the session-start profile opts tiny bases in at 1500."
+    ),
+    profile: import_zod16.z.string().optional().describe(
+      "Named budget set: built-ins are session-start (full-under 1500), compact and turn (budget 2500); the manifests' `context` tables override per repo. Unknown names fall through to defaults rather than failing."
+    ),
+    excludeTags: import_zod16.z.array(import_zod16.z.string().min(1)).optional().describe(
+      "Frontmatter tags whose records stay out of the block. The base stays pinned and stays readable by tool; resolved like the budgets."
+    ),
+    format: import_zod16.z.enum(["markdown", "json"]).optional().describe(
+      "CLI envelope for hook protocols that require strict JSON on stdout. MCP callers omit this \u2014 the block itself is identical."
+    ),
+    event: import_zod16.z.string().optional().describe(
+      "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
+    )
+  }),
+  fromArgv: (argv) => {
+    const budget = argvFlag(argv, "--budget");
+    const fullUnder = argvFlag(argv, "--full-under");
+    const profile = argvFlag(argv, "--profile");
+    const format = argvFlag(argv, "--format");
+    const event = argvFlag(argv, "--event");
+    const excludeTags = argvFlags(argv, "--exclude-tag");
+    return {
+      ...budget ? { budgetTokens: Number(budget) } : {},
+      ...fullUnder ? { fullUnderTokens: Number(fullUnder) } : {},
+      ...profile ? { profile } : {},
+      ...excludeTags.length ? { excludeTags } : {},
+      ...format ? { format } : {},
+      ...event ? { event } : {}
+    };
+  },
+  run: async ({ store }, { budgetTokens, fullUnderTokens, profile, excludeTags, format, event }) => {
+    const result = await buildContext(store, process.cwd(), {
+      ...budgetTokens ? { budgetTokens } : {},
+      ...fullUnderTokens ? { fullUnderTokens } : {},
+      ...profile ? { profile } : {},
+      ...excludeTags ? { excludeTags } : {},
+      // Degradations — a full pin that could not fit, a refused block — go
+      // to stderr as well as into the block itself: stderr is diagnostics on
+      // both surfaces (hooks discard it, MCP logs it), so an operator can
+      // see budget pressure without reading injected context.
+      warn: (entry) => process.stderr.write(`${JSON.stringify(entry)}
+`)
+    });
+    if (!result.block) return "";
+    return format === "json" ? toHookJson(result.block, event ?? "SessionStart") : result.block;
+  }
+});
+
+// src/commands/doctor.ts
+var import_zod18 = require("zod");
+
+// src/commands/reassess.ts
+var import_zod17 = require("zod");
+var reassessCommand = define({
+  name: "reassess",
+  tool: "kb_reassess",
+  usage: "reassess <concept-id> [--repo-root <path>] [--with-diff]",
+  description: "One drifted record, as something to judge: its claim, each anchor's drift class, the old-vs-new span diff, and the records that depend on it. Formatting-only drift is dropped. Empty when there is nothing to reassess. Writes: relocates moved anchors, keeping their hash; never verifies, supersedes, or changes standing.",
+  input: import_zod17.z.object({
+    bundlePath,
+    conceptId,
+    repoRoot: REPO_ROOT,
+    withDiff: import_zod17.z.boolean().optional().describe(
+      "Recover each anchor's committed span and render the diff. Reads git history."
+    )
+  }),
+  fromArgv: (argv, path) => {
+    const repoRoot = argvFlag(argv, "--repo-root");
+    return {
+      bundlePath: path,
+      conceptId: argv[1],
+      ...repoRoot !== void 0 ? { repoRoot } : {},
+      ...argv.includes("--with-diff") ? { withDiff: true } : {}
+    };
+  },
+  run: async ({ store, actor }, { bundlePath: path, conceptId: id, repoRoot, withDiff }) => {
+    const root = repoRoot ?? process.cwd();
+    const bundle = await store.list(path);
+    const record = bundle.find((entry) => entry.conceptId === id);
+    if (!record) throw new KbRecordNotFoundError(id);
+    const drift = await store.detectDrift([record], repoRoot);
+    const entries = drift?.get(id) ?? [];
+    if (!entries.some((entry) => entry.state !== "match")) {
+      return { conceptId: id, packet: null, rebaselined: [], cosmetic: 0 };
+    }
+    const standing = adjudicate(bundle, bundle).find(
+      (hit) => hit.record.conceptId === id
+    )?.standing;
+    const impact2 = await store.impact(path, id);
+    const { packet, classified } = await reassessPacket(root, record, entries, {
       ...withDiff ? { withDiff: true } : {},
       impact: impact2,
       ...standing ? { standing } : {}
@@ -5846,7 +7020,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,
@@ -5945,13 +7122,13 @@ function at(file, symbol) {
 }
 
 // src/commands/doctor.ts
-var days = (what, fallback) => import_zod15.z.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
+var days = (what, fallback) => import_zod18.z.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
 var doctorCommand = define({
   name: "doctor",
   tool: "kb_doctor",
   usage: "doctor [--expiring-days N] [--unverified-days N] [--aging-days N] [--repo-root PATH] [--offline] [--strict] [--drifted [--with-diff]]",
   description: "Read-only health sweep: expired, expiring, unverified, aging, orphaned, broken-supersession, superseded-but-cited, drifted and unchecked anchors. Every group is reported even when empty; nothing is written or re-stamped. `drifted` narrows it to a reassessment packet per drifted record, `with_diff` adding each anchor's old-vs-new span.",
-  input: import_zod15.z.object({
+  input: import_zod18.z.object({
     bundlePath,
     repoRoot: REPO_ROOT,
     expiringDays: days(
@@ -5966,16 +7143,16 @@ var doctorCommand = define({
       "How long a record may stay `open` or `proposed` before `aging` reports it, in days.",
       DEFAULT_AGING_DAYS
     ),
-    offline: import_zod15.z.boolean().optional().describe(
+    offline: import_zod18.z.boolean().optional().describe(
       "Read foreign anchors from the local repo cache only, never fetching."
     ),
-    strict: import_zod15.z.boolean().optional().describe(
+    strict: import_zod18.z.boolean().optional().describe(
       "Turn an expired record into a non-zero exit for the CLI. No effect on the report itself."
     ),
-    drifted: import_zod15.z.boolean().optional().describe(
+    drifted: import_zod18.z.boolean().optional().describe(
       "Report only drift, as a reassessment packet per record: claim, per-anchor class, and what depends on it."
     ),
-    withDiff: import_zod15.z.boolean().optional().describe(
+    withDiff: import_zod18.z.boolean().optional().describe(
       "With `drifted`: recover each anchor's committed span and render the old-vs-new diff. Reads git history."
     )
   }),
@@ -6031,7 +7208,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
@@ -6045,7 +7222,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,
@@ -6082,15 +7259,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));
@@ -6115,6 +7293,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 = [
@@ -6140,20 +7326,155 @@ function renderPackets(result) {
   return lines.join("\n");
 }
 
+// src/commands/export.ts
+var import_promises11 = require("fs/promises");
+var import_node_path13 = require("path");
+var import_zod19 = require("zod");
+var NUMBERED = /^(\d{4})-(.+)\.md$/;
+var MARKER = "<!-- strauss-kb export: ";
+var exportCommand = define({
+  name: "export",
+  tool: "kb_export",
+  usage: "export --format madr --to <dir>",
+  description: "Write the base's decisions out as numbered MADR files, one per decision, for a repository that keeps ADRs of its own. Numbering is by slug, so a re-run rewrites its own files in place. A superseded decision is exported with what replaced it.",
+  input: import_zod19.z.object({
+    bundlePath,
+    format: import_zod19.z.enum(["madr"]).describe("Output layout. `madr` is the only one so far."),
+    to: import_zod19.z.string().min(1).describe("Directory the ADR files are written into.")
+  }),
+  fromArgv: (argv, path) => ({
+    bundlePath: path,
+    format: argvFlag(argv, "--format"),
+    to: argvFlag(argv, "--to")
+  }),
+  run: async ({ store }, { bundlePath: path, to }) => {
+    const bundle = await store.list(path);
+    const decisions = selectDecisions(bundle).sort(
+      (left, right) => left.conceptId.localeCompare(right.conceptId)
+    );
+    const adjudicated = new Map(
+      adjudicate(decisions, bundle).map((hit) => [hit.record.conceptId, hit])
+    );
+    await (0, import_promises11.mkdir)(to, { recursive: true });
+    const taken = await existingFiles(to);
+    let next = Math.max(0, ...[...taken.values()].map((row) => row.number)) + 1;
+    const exported = [];
+    const foreign = [];
+    for (const record of decisions) {
+      const slug = record.conceptId.slice(record.conceptId.indexOf(".") + 1);
+      const held = taken.get(slug);
+      if (held && !held.ours) {
+        foreign.push({ conceptId: record.conceptId, file: held.file });
+        continue;
+      }
+      const number = held?.number ?? next++;
+      const file = `${String(number).padStart(4, "0")}-${slug}.md`;
+      const status = statusLine(adjudicated.get(record.conceptId));
+      await publish((0, import_node_path13.join)(to, file), renderMadr(record, status));
+      exported.push({ conceptId: record.conceptId, file, status });
+    }
+    return { to, format: "madr", exported, foreign };
+  },
+  render: (result) => {
+    const { exported, foreign, to } = result;
+    return [
+      `Wrote ${exported.length} MADR file${exported.length === 1 ? "" : "s"} to ${to}.`,
+      ...exported.map(
+        (entry) => `- ${entry.file}  ${entry.conceptId} [${entry.status}]`
+      ),
+      ...foreign.map(
+        (entry) => `- skipped ${entry.conceptId}: ${entry.file} was not written by export`
+      )
+    ].join("\n");
+  }
+});
+async function publish(target, contents) {
+  const staging = `${target}.${process.pid}.tmp`;
+  await (0, import_promises11.writeFile)(staging, contents, "utf8");
+  try {
+    await (0, import_promises11.rename)(staging, target);
+  } catch (error) {
+    await (0, import_promises11.unlink)(staging).catch(() => void 0);
+    throw error;
+  }
+}
+async function existingFiles(to) {
+  const names = await (0, import_promises11.readdir)(to).catch(() => []);
+  const taken = /* @__PURE__ */ new Map();
+  for (const name of names.sort()) {
+    const [, number, slug] = NUMBERED.exec(name) ?? [];
+    if (!number || !slug) continue;
+    const text = await (0, import_promises11.readFile)((0, import_node_path13.join)(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
-var import_zod16 = require("zod");
+var import_zod20 = require("zod");
 var impactCommand = define({
   name: "impact",
   tool: "kb_impact",
   usage: "impact <concept-id> [--depth N] [--rels a,b]",
   description: "What breaks if this record changes: its transitive set of dependants, each with its standing. Each rel declares which of its ends depends on the other, and the walk follows each rel in its own direction. Naming `related_to` or an unknown rel in `rels` is an error. kb_backlinks gives one flat hop.",
-  input: import_zod16.z.object({
+  input: import_zod20.z.object({
     bundlePath,
     conceptId,
-    depth: import_zod16.z.number().int().positive().optional().describe(
+    depth: import_zod20.z.number().int().positive().optional().describe(
       "Hops out from the record. Unbounded when omitted; a walk this cuts reports truncated: true."
     ),
-    rels: import_zod16.z.array(import_zod16.z.enum(KB_CAUSAL_LINK_RELS)).optional().describe(
+    rels: import_zod20.z.array(import_zod20.z.enum(KB_CAUSAL_LINK_RELS)).optional().describe(
       "Narrow which rels the walk follows. Defaults to every rel that carries a dependence \u2014 all but related_to."
     )
   }),
@@ -6174,15 +7495,15 @@ var impactCommand = define({
 });
 
 // src/commands/list.ts
-var import_zod17 = require("zod");
+var import_zod21 = require("zod");
 var listCommand = define({
   name: "list",
   tool: "kb_list",
   usage: "list [type] [--tag T]...",
   description: "Every record, optionally one type or tag. For enumerating; use kb_query for a question.",
-  input: import_zod17.z.object({
+  input: import_zod21.z.object({
     bundlePath,
-    type: import_zod17.z.enum(KB_RECORD_TYPES).optional(),
+    type: import_zod21.z.enum(KB_RECORD_TYPES).optional(),
     tags: TAGS
   }),
   fromArgv: (argv, path) => {
@@ -6206,17 +7527,17 @@ var listCommand = define({
 });
 
 // src/commands/load.ts
-var import_zod18 = require("zod");
+var import_zod22 = require("zod");
 var loadCommand = define({
   name: "load",
   tool: "kb_load",
   usage: "load [type] [--budget N | --all] [--repo-root PATH]",
   description: "Load the whole base, each record with its standing \u2014 call it first, at the point of use, since compaction drops it. Superseded records arrive as stubs; kb_trace has the history. Over budget it refuses: kb_catalog, then kb_pack, or narrow with `type`; `all` bypasses. Never read record files directly \u2014 only kb_* tools resolve supersession. `digest` stamps the base's content, so hooks know when to reload.",
-  input: import_zod18.z.object({
+  input: import_zod22.z.object({
     bundlePath,
-    type: import_zod18.z.enum(KB_RECORD_TYPES).optional(),
-    budgetTokens: import_zod18.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
-    all: import_zod18.z.boolean().optional().describe(
+    type: import_zod22.z.enum(KB_RECORD_TYPES).optional(),
+    budgetTokens: import_zod22.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
+    all: import_zod22.z.boolean().optional().describe(
       "Loads the entire base regardless of size, bypassing the token budget; mutually exclusive with budgetTokens."
     ),
     repoRoot: REPO_ROOT
@@ -6258,25 +7579,25 @@ var loadCommand = define({
 });
 
 // src/commands/log.ts
-var import_zod19 = require("zod");
+var import_zod23 = require("zod");
 var logCommand = define({
   name: "log",
   tool: "kb_log",
   usage: "log",
   description: "Who touched what, and when. Append-only; malformed lines are reported, never repaired.",
-  input: import_zod19.z.object({ bundlePath }),
+  input: import_zod23.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readLog(path)
 });
 
 // src/commands/no-decision.ts
-var import_zod20 = require("zod");
+var import_zod24 = require("zod");
 var noDecisionCommand = define({
   name: "no-decision",
   tool: "kb_no_decision",
   usage: "no-decision <reason...>",
   description: "Record in one sentence that a piece of work had nothing to decide. Idempotent.",
-  input: import_zod20.z.object({ bundlePath, reason: import_zod20.z.string().min(1) }),
+  input: import_zod24.z.object({ bundlePath, reason: import_zod24.z.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     reason: argv.slice(1).join(" ").trim()
@@ -6293,20 +7614,20 @@ var noDecisionCommand = define({
 });
 
 // src/commands/pack.ts
-var import_zod21 = require("zod");
+var import_zod25 = require("zod");
 var packCommand = define({
   name: "pack",
   tool: "kb_pack",
   usage: "pack <conceptId> [--hops N] [--max-nodes N] [--budget N]",
   description: "Bounded neighbourhood around one record: within `hops`, ranked, cut to `maxNodes`, with every cut record named under Excluded. Use when the base is over kb_load's budget and the work centres on a record you can name. Refuses over budget rather than truncating. Everything below the header is byte-stable across runs. Resolves supersession like kb_load.",
-  input: import_zod21.z.object({
+  input: import_zod25.z.object({
     bundlePath,
     conceptId,
-    hops: import_zod21.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
-    maxNodes: import_zod21.z.number().int().positive().optional().describe(
+    hops: import_zod25.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
+    maxNodes: import_zod25.z.number().int().positive().optional().describe(
       "How many records the pack may hold, root included. Defaults to 20."
     ),
-    budgetTokens: import_zod21.z.number().int().positive().optional().describe(
+    budgetTokens: import_zod25.z.number().int().positive().optional().describe(
       "Approximate token ceiling over what is actually emitted. Defaults to 25000."
     )
   }),
@@ -6393,22 +7714,22 @@ function warningLabel(warning) {
 }
 
 // src/commands/pin.ts
-var import_zod22 = require("zod");
+var import_zod26 = require("zod");
 var pinCommand = define({
   name: "pin",
   tool: "kb_pin",
   usage: "pin [bundle-path] [--mode full|index] [--profiles a,b] [--local|--user] [--frozen|--unfreeze]",
   description: "Pin a base into a workspace manifest so kb_context surfaces it. Layers, nearest wins: project `.strauss/kb-pins.json` (default), `--local` (personal, gitignored), `--user` (`~/.strauss`). Idempotent; `--mode full|index`, `--profiles`, `--frozen`/`--unfreeze` update only those fields. A path with no records pins with a warning. Never touches the base itself.",
-  input: import_zod22.z.object({
+  input: import_zod26.z.object({
     bundlePath,
-    mode: import_zod22.z.enum(["full", "index"]).optional().describe(
+    mode: import_zod26.z.enum(["full", "index"]).optional().describe(
       "full: always emit this base's records whole (still under the block budget); index: never upgrade. Absent: the profile's full-under threshold decides."
     ),
-    profiles: import_zod22.z.array(import_zod22.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
-    layer: import_zod22.z.enum(["project", "local", "user"]).optional().describe(
+    profiles: import_zod26.z.array(import_zod26.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
+    layer: import_zod26.z.enum(["project", "local", "user"]).optional().describe(
       "Which manifest to write: project (committed, default), local (personal, gitignored), user (~/.strauss, every workspace)."
     ),
-    frozen: import_zod22.z.boolean().optional().describe(
+    frozen: import_zod26.z.boolean().optional().describe(
       "true: the base is concluded \u2014 writes against it refuse while pinned. false: lift a freeze."
     )
   }),
@@ -6437,29 +7758,305 @@ var pinCommand = define({
 });
 
 // src/commands/pins.ts
-var import_zod23 = require("zod");
+var import_zod27 = require("zod");
 var pinsCommand = define({
   name: "pins",
   tool: "kb_pins",
   usage: "pins",
   description: "Every pinned base across the manifest layers, with its layer and whether it resolves to records. Takes no bundlePath.",
-  input: import_zod23.z.object({}),
+  input: import_zod27.z.object({}),
   fromArgv: () => ({}),
   run: ({ store }) => listPins(store, process.cwd())
 });
 
+// src/commands/promote/command.ts
+var import_node_path14 = require("path");
+
+// src/commands/promote/carry.ts
+var PROMOTION_SOURCE_ID = "promoted";
+var CARRIED_STATUS = {
+  draft: "accepted",
+  proposed: "accepted",
+  accepted: "accepted",
+  open: "open",
+  resolved: "resolved",
+  rejected: "rejected",
+  superseded: "superseded"
+};
+function carry(record, promoted, source) {
+  const {
+    type: _type,
+    // Both name records in the source base, and supersession in the target is
+    // a separate question from whether this record belongs there at all.
+    strauss_supersedes: _supersedes,
+    strauss_superseded_by: _supersededBy,
+    // A check run against the source repository, which the target never saw.
+    verified: _verified,
+    ...rest
+  } = record.frontmatter;
+  const links = rest.strauss_links ?? [];
+  const kept = links.filter((link2) => promoted.has(link2.target));
+  const dropped = links.filter((link2) => !promoted.has(link2.target));
+  const tags = (rest.tags ?? []).filter((tag) => !isReviewTag(tag));
+  const frontmatter = {
+    ...rest,
+    strauss_status: CARRIED_STATUS[rest.strauss_status]
+  };
+  setOrDrop(frontmatter, "tags", tags);
+  setOrDrop(frontmatter, "strauss_links", kept);
+  let body = withoutLinkSentences(record.body, dropped);
+  if (source) {
+    frontmatter.sources = [
+      ...(rest.sources ?? []).filter(
+        (entry) => entry.id !== PROMOTION_SOURCE_ID
+      ),
+      { id: PROMOTION_SOURCE_ID, resource: source }
+    ];
+    body = `${stripFootnote(body).trimEnd()}
+
+[^${PROMOTION_SOURCE_ID}]: ${source}
+`;
+  }
+  return {
+    frontmatter,
+    body,
+    droppedLinks: dropped.map(({ target, rel }) => ({ target, rel }))
+  };
+}
+function isReviewTag(tag) {
+  return tag === "review" || tag.startsWith("review:");
+}
+function withoutLinkSentences(body, dropped) {
+  const sentences = new Set(
+    dropped.filter((link2) => isKbLinkRel(link2.rel)).map(
+      (link2) => `${LINK_RELS[link2.rel].phrase} [${link2.target}](${link2.target}.md).`
+    )
+  );
+  if (!sentences.size) return body;
+  return body.split("\n\n").filter((block) => !sentences.has(block.trim())).join("\n\n");
+}
+function stripFootnote(body) {
+  return body.split("\n").filter((line) => !line.startsWith(`[^${PROMOTION_SOURCE_ID}]: `)).join("\n");
+}
+function setOrDrop(frontmatter, key2, value) {
+  if (value.length) frontmatter[key2] = value;
+  else delete frontmatter[key2];
+}
+
+// src/commands/promote/standing.ts
+var WITHDRAWN = ["superseded", "rejected"];
+function standings(bundle) {
+  return new Map(
+    adjudicate(bundle, bundle).map((hit) => [
+      hit.record.conceptId,
+      hit.standing
+    ])
+  );
+}
+function isWithdrawn(standing) {
+  return standing !== void 0 && WITHDRAWN.includes(standing);
+}
+
+// src/commands/promote/candidates.ts
+var REVIEW_TAG = "review";
+var SETTLED = ["resolved"];
+function promoteCandidates(bundle) {
+  const inbound = inboundIndex(bundle);
+  const standing = standings(bundle);
+  const rows = [];
+  for (const record of bundle) {
+    if (isWithdrawn(standing.get(record.conceptId))) continue;
+    const why2 = candidateReason(record, inbound.get(record.conceptId) ?? []);
+    if (!why2) continue;
+    rows.push({
+      conceptId: record.conceptId,
+      type: recordType(record.conceptId),
+      title: record.frontmatter.title ?? null,
+      why: why2
+    });
+  }
+  return rows;
+}
+function candidateReason(record, inbound) {
+  const { strauss_status: status, tags } = record.frontmatter;
+  switch (recordType(record.conceptId)) {
+    case "decision":
+      if (isNoDecisionRecord(record)) return null;
+      return tags?.includes(REVIEW_TAG) ? null : "decision no longer under review";
+    case "constraint":
+      return status === "proposed" ? "constraint still proposed \u2014 the target base is where it settles" : null;
+    case "contract":
+      return "contract \u2014 it outlives the change that introduced it";
+    case "requirement":
+      return inbound.some((edge) => edge.rel === "satisfies") ? "requirement something in the base satisfies" : null;
+    case "risk":
+      return record.frontmatter.strauss_materiality === "blocking" && !SETTLED.includes(status) ? "blocking risk still open" : null;
+    default:
+      return null;
+  }
+}
+function recordType(conceptId2) {
+  return conceptId2.slice(0, conceptId2.indexOf("."));
+}
+
+// src/commands/promote/model.ts
+var import_zod28 = require("zod");
+var promoteInputSchema = import_zod28.z.object({
+  bundlePath,
+  conceptIds: import_zod28.z.array(conceptId).max(64).optional().describe("Records to copy into the target base. Omit with `list`."),
+  to: import_zod28.z.string().min(1).optional().describe("Absolute path to the base being promoted into."),
+  source: import_zod28.z.string().min(1).optional().describe(
+    "Where the promotion came from, usually the pull request URL. Recorded on each copy as a source."
+  ),
+  force: import_zod28.z.boolean().optional().describe("Overwrite a record the target base already holds."),
+  list: import_zod28.z.boolean().optional().describe("List the source base's candidates instead of promoting.")
+}).refine((input) => input.list === true || input.to !== void 0, {
+  message: "promote needs a target base \u2014 pass --to <bundle>, or --list",
+  path: ["to"]
+}).refine(
+  (input) => input.list === true || (input.conceptIds?.length ?? 0) > 0,
+  {
+    message: "name at least one concept id to promote, or pass --list",
+    path: ["conceptIds"]
+  }
+);
+
+// src/commands/promote/command.ts
+var promoteCommand = define({
+  name: "promote",
+  tool: "kb_promote",
+  usage: "promote <concept-id...> --to <bundle> [--source <url>] [--force] | --list",
+  description: "Copy records into another base at the same slug, with the review tags dropped and a source naming where the promotion came from. Use at merge, to lift what a review base settled into the base that outlives it. `list` names the candidates instead. The originals stay put.",
+  input: promoteInputSchema,
+  fromArgv: (argv, path) => {
+    const to = argvFlag(argv, "--to");
+    const source = argvFlag(argv, "--source");
+    const words = argv.slice(1);
+    for (const flag of ["--to", "--source"]) {
+      const at2 = words.indexOf(flag);
+      if (at2 !== -1) words.splice(at2, 2);
+    }
+    const conceptIds = words.filter((word) => !word.startsWith("--"));
+    return {
+      bundlePath: path,
+      ...conceptIds.length ? { conceptIds } : {},
+      ...to !== void 0 ? { to } : {},
+      ...source !== void 0 ? { source } : {},
+      ...argv.includes("--force") ? { force: true } : {},
+      ...argv.includes("--list") ? { list: true } : {}
+    };
+  },
+  run: async ({ store, actor }, { bundlePath: path, conceptIds, to, source, force, list }) => {
+    const from = (0, import_node_path14.resolve)(path);
+    const bundle = await store.list(from);
+    if (list) {
+      return { mode: "list", candidates: promoteCandidates(bundle) };
+    }
+    const target = (0, import_node_path14.resolve)(to);
+    if (target === from) throw new KbPromoteSelfError(target);
+    const named = (conceptIds ?? []).map(namedRecord);
+    const wanted = named.map(({ conceptId: conceptId2, type, slug }) => {
+      const record = bundle.find((entry) => entry.conceptId === conceptId2);
+      if (!record) throw new KbRecordNotFoundError(conceptId2);
+      return { record, type, slug };
+    });
+    await assertBaseNotFrozen(process.cwd(), from);
+    await assertBaseNotFrozen(process.cwd(), target);
+    const standing = standings(bundle);
+    for (const { record } of wanted) {
+      const where = standing.get(record.conceptId);
+      if (isWithdrawn(where)) {
+        throw new KbPromoteStandingError(record.conceptId, where);
+      }
+      if (!force && await store.read(target, record.conceptId)) {
+        throw new KbPromoteCollisionError(record.conceptId, target);
+      }
+    }
+    const promotedIds = new Set(wanted.map(({ record }) => record.conceptId));
+    const promoted = [];
+    for (const { record, type, slug } of wanted) {
+      const { frontmatter, body, droppedLinks } = carry(
+        record,
+        promotedIds,
+        source
+      );
+      try {
+        await store.write(
+          target,
+          { type, slug, frontmatter, body, overwrite: force === true },
+          actor
+        );
+      } catch (error) {
+        throw new KbPromoteStoppedError(
+          record.conceptId,
+          promoted.map((entry) => entry.conceptId),
+          error instanceof Error ? error.message : "unknown"
+        );
+      }
+      await store.note(target, {
+        by: actor,
+        operation: "promote-in",
+        conceptId: record.conceptId,
+        target: from
+      });
+      await store.note(from, {
+        by: actor,
+        operation: "promote-out",
+        conceptId: record.conceptId,
+        target
+      });
+      promoted.push({ conceptId: record.conceptId, droppedLinks });
+    }
+    return { mode: "promote", to: target, promoted };
+  },
+  render: (result) => renderPromote(result)
+});
+function namedRecord(conceptId2) {
+  const at2 = conceptId2.indexOf(".");
+  const type = at2 === -1 ? conceptId2 : conceptId2.slice(0, at2);
+  const slug = at2 === -1 ? "" : conceptId2.slice(at2 + 1);
+  if (!KB_SLUG_PATTERN.test(type) || !KB_SLUG_PATTERN.test(slug)) {
+    throw new KbInvalidConceptIdError(
+      "concept id must be <type>.<slug>, both kebab-case",
+      { conceptId: conceptId2 }
+    );
+  }
+  return { conceptId: conceptId2, type, slug };
+}
+function renderPromote(result) {
+  if (result.mode === "list") {
+    if (!result.candidates.length) return "No promotion candidates.";
+    return result.candidates.flatMap((candidate) => [
+      `${candidate.conceptId} [${candidate.type}]${candidate.title ? ` \u2014 ${candidate.title}` : ""}`,
+      `  ${candidate.why}`
+    ]).join("\n");
+  }
+  const lines = [
+    `Promoted ${result.promoted.length} record${result.promoted.length === 1 ? "" : "s"} into ${result.to}.`
+  ];
+  for (const entry of result.promoted) {
+    lines.push(`- ${entry.conceptId}`);
+    for (const link2 of entry.droppedLinks) {
+      lines.push(
+        `  dropped ${link2.rel} \u2192 ${link2.target} (not promoted in this run)`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/commands/query.ts
-var import_zod24 = require("zod");
+var import_zod29 = require("zod");
 var queryCommand = define({
   name: "query",
   tool: "kb_query",
   usage: "query <text...> [--tag T]... [--repo-root PATH]",
   description: "Search; every hit carries its standing. Flagged, never filtered: a superseded hit returns with its replacement, a rejected one is marked. Prefer kb_load when the base fits its budget \u2014 a full read beats search. Results are volatile: place them at the tail, not the cached prefix. Never read record files directly.",
-  input: import_zod24.z.object({
+  input: import_zod29.z.object({
     bundlePath,
-    text: import_zod24.z.string().optional(),
-    type: import_zod24.z.enum(KB_RECORD_TYPES).optional(),
-    includeNonCurrent: import_zod24.z.boolean().optional(),
+    text: import_zod29.z.string().optional(),
+    type: import_zod29.z.enum(KB_RECORD_TYPES).optional(),
+    includeNonCurrent: import_zod29.z.boolean().optional(),
     tags: TAGS,
     repoRoot: REPO_ROOT
   }),
@@ -6493,43 +8090,43 @@ var queryCommand = define({
 });
 
 // src/commands/read-index.ts
-var import_zod25 = require("zod");
+var import_zod30 = require("zod");
 var readIndexCommand = define({
   name: "index",
   tool: "kb_index",
   usage: "index",
   description: "The index \u2014 title, type, status, description per record \u2014 rebuilt if stale. Cheapest re-orientation after compaction: call it (or kb_context) first, then kb_load or fetch by id.",
-  input: import_zod25.z.object({ bundlePath }),
+  input: import_zod30.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readIndex(path)
 });
 
 // src/commands/schema.ts
-var import_zod26 = require("zod");
+var import_zod31 = require("zod");
 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: import_zod26.z.object({}),
+  input: import_zod31.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(kbJsonSchemas())
 });
 
 // src/commands/stamp.ts
-var import_promises10 = require("fs/promises");
-var import_zod27 = require("zod");
+var import_promises12 = require("fs/promises");
+var import_zod32 = require("zod");
 var DIGEST = /^[0-9a-f]{64}$/;
 var stampCommand = define({
   name: "stamp",
   tool: "kb_stamp",
   usage: "stamp [--bundle PATH] [--since DIGEST|FILE]",
   description: "Content stamp of a base \u2014 `load`'s digest, record counts, per-record digests, how many records have drifted anchors \u2014 without any bodies. Takes no bundlePath to stamp every pinned base. With `since`, reports only the bases that moved, naming the changed ids. Reads, never writes.",
-  input: import_zod27.z.object({
-    bundlePath: import_zod27.z.string().min(1).optional().describe(
+  input: import_zod32.z.object({
+    bundlePath: import_zod32.z.string().min(1).optional().describe(
       "Absolute path to one knowledge base. Omit to stamp every pinned base."
     ),
-    since: import_zod27.z.string().min(1).optional().describe(
+    since: import_zod32.z.string().min(1).optional().describe(
       "Prior digest, or path to a prior `stamp --json`; only moved bases return, with changed ids when the baseline is a file."
     )
   }),
@@ -6591,7 +8188,7 @@ async function readBaseline(since) {
   if (DIGEST.test(since)) return { digest: since, byPath: /* @__PURE__ */ new Map() };
   let parsed;
   try {
-    parsed = JSON.parse(await (0, import_promises10.readFile)(since, "utf8"));
+    parsed = JSON.parse(await (0, import_promises12.readFile)(since, "utf8"));
   } catch {
     throw new KbStampBaselineError(since);
   }
@@ -6615,16 +8212,16 @@ async function readBaseline(since) {
 }
 
 // src/commands/status.ts
-var import_zod28 = require("zod");
+var import_zod33 = require("zod");
 var statusCommand = define({
   name: "status",
   tool: "kb_status",
   usage: "status <concept-id> <status>",
   description: "Move a record's status. Compare-and-swap: a concurrent change fails instead of being overwritten.",
-  input: import_zod28.z.object({
+  input: import_zod33.z.object({
     bundlePath,
     conceptId,
-    status: import_zod28.z.enum(KB_RECORD_STATUSES)
+    status: import_zod33.z.enum(KB_RECORD_STATUSES)
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -6639,13 +8236,13 @@ var statusCommand = define({
 });
 
 // src/commands/supersede.ts
-var import_zod29 = require("zod");
+var import_zod34 = require("zod");
 var supersedeCommand = define({
   name: "supersede",
   tool: "kb_supersede",
   usage: "supersede <concept-id> <replacement-id>",
   description: "Mark a record superseded by another, linked in both directions. Use instead of editing a record whose meaning changed.",
-  input: import_zod29.z.object({ bundlePath, conceptId, replacementId: conceptId }),
+  input: import_zod34.z.object({ bundlePath, conceptId, replacementId: conceptId }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -6658,17 +8255,153 @@ var supersedeCommand = define({
   }
 });
 
+// src/commands/sweep.ts
+var import_zod35 = require("zod");
+var TERMINAL = [
+  "resolved",
+  "rejected",
+  "superseded"
+];
+var sweepCommand = define({
+  name: "sweep",
+  tool: "kb_sweep",
+  usage: "sweep --tag <tag> --terminal [--dry-run]",
+  description: "Delete tagged records that are resolved, rejected or superseded. Refuses without --tag, keeps any record a surviving record still points at, and logs each deletion.",
+  input: import_zod35.z.object({
+    bundlePath,
+    tag: import_zod35.z.string({ error: "sweep needs --tag: it never sweeps a whole base" }).min(1).describe("Only records carrying this tag are considered."),
+    terminal: import_zod35.z.literal(true, {
+      error: "sweep needs --terminal: it deletes only settled records"
+    }).describe(
+      "Required. Names the only scope sweep deletes: resolved, rejected and superseded records."
+    ),
+    dryRun: import_zod35.z.boolean().optional().describe("Report what would go, and delete nothing.")
+  }),
+  fromArgv: (argv, path) => ({
+    bundlePath: path,
+    tag: argvFlag(argv, "--tag"),
+    ...argv.includes("--terminal") ? { terminal: true } : {},
+    ...argv.includes("--dry-run") ? { dryRun: true } : {}
+  }),
+  run: async ({ store, actor }, { bundlePath: path, tag, dryRun }) => {
+    const bundle = await store.list(path);
+    const held = holderIndex(bundle);
+    const candidates = adjudicate(bundle, bundle).filter(
+      (hit) => sweepable(hit, tag)
+    );
+    const doomed = new Set(candidates.map((hit) => hit.record.conceptId));
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const conceptId2 of [...doomed]) {
+        if (survivorsHolding(conceptId2, held, doomed).length === 0) continue;
+        doomed.delete(conceptId2);
+        changed = true;
+      }
+    }
+    const skipped = candidates.filter((hit) => !doomed.has(hit.record.conceptId)).map((hit) => ({
+      conceptId: hit.record.conceptId,
+      heldBy: survivorsHolding(hit.record.conceptId, held, doomed)
+    }));
+    const ordered = [...doomed].sort();
+    if (dryRun) {
+      return {
+        tag,
+        dryRun: true,
+        deleted: [],
+        candidates: ordered,
+        skipped,
+        failed: []
+      };
+    }
+    await assertBaseNotFrozen(process.cwd(), path);
+    const deleted = [];
+    const failed = [];
+    try {
+      for (const conceptId2 of ordered) {
+        try {
+          const outcome = await store.deleteRecord(
+            path,
+            conceptId2,
+            { tag, statuses: TERMINAL },
+            actor
+          );
+          if (outcome === "deleted") deleted.push(conceptId2);
+          else failed.push({ conceptId: conceptId2, reason: outcome });
+        } catch (error) {
+          failed.push({
+            conceptId: conceptId2,
+            reason: error instanceof Error ? error.message : "unknown"
+          });
+        }
+      }
+    } finally {
+      await store.readIndex(path);
+      await store.dropSearchIndex(path);
+    }
+    return {
+      tag,
+      dryRun: false,
+      deleted,
+      candidates: ordered,
+      skipped,
+      failed
+    };
+  },
+  render: (result) => renderSweep(result)
+});
+function sweepable(hit, tag) {
+  const { tags, strauss_status } = hit.record.frontmatter;
+  return (tags ?? []).includes(tag) && // Supersession is a standing, settled against the whole base; the other
+  // two are the record's own word for itself.
+  (hit.standing === "superseded" || strauss_status === "resolved" || strauss_status === "rejected");
+}
+function holderIndex(bundle) {
+  const byTarget = /* @__PURE__ */ new Map();
+  const hold = (target, from) => {
+    if (target === from) return;
+    const holders = byTarget.get(target) ?? /* @__PURE__ */ new Set();
+    holders.add(from);
+    byTarget.set(target, holders);
+  };
+  for (const [target, edges] of inboundIndex(bundle)) {
+    for (const edge of edges) hold(target, edge.from);
+  }
+  for (const record of bundle) {
+    const { strauss_supersedes, strauss_superseded_by } = record.frontmatter;
+    for (const old of strauss_supersedes ?? []) hold(old, record.conceptId);
+    if (strauss_superseded_by) hold(strauss_superseded_by, record.conceptId);
+  }
+  return byTarget;
+}
+function survivorsHolding(conceptId2, held, doomed) {
+  return [...held.get(conceptId2) ?? []].filter((from) => !doomed.has(from)).sort();
+}
+function renderSweep(result) {
+  const shown = result.dryRun ? result.candidates : result.deleted;
+  const verb = result.dryRun ? "would delete" : "deleted";
+  const lines = [`${verb} ${shown.length} (tag: ${result.tag})`];
+  for (const conceptId2 of shown) lines.push(`- ${conceptId2}`);
+  for (const skip of result.skipped) {
+    lines.push(`kept ${skip.conceptId} \u2014 held by ${skip.heldBy.join(", ")}`);
+  }
+  for (const failure of result.failed) {
+    lines.push(`failed ${failure.conceptId} \u2014 ${failure.reason}`);
+  }
+  return lines.join("\n");
+}
+
 // src/commands/sync-instructions.ts
-var import_zod30 = require("zod");
+var import_zod36 = require("zod");
 var syncInstructionsCommand = define({
   name: "sync-instructions",
   usage: "sync-instructions <file> [--profile NAME] [--budget N] [--full-under N]",
   description: "CLI-only: plant the kb_context block between sentinel comments in AGENTS.md or CLAUDE.md, idempotently.",
-  input: import_zod30.z.object({
-    file: import_zod30.z.string().min(1).describe("The instruction file to edit in place."),
-    budgetTokens: import_zod30.z.number().int().positive().optional(),
-    fullUnderTokens: import_zod30.z.number().int().positive().optional(),
-    profile: import_zod30.z.string().optional()
+  input: import_zod36.z.object({
+    file: import_zod36.z.string().min(1).describe("The instruction file to edit in place."),
+    budgetTokens: import_zod36.z.number().int().positive().optional(),
+    fullUnderTokens: import_zod36.z.number().int().positive().optional(),
+    profile: import_zod36.z.string().optional()
   }),
   fromArgv: (argv) => {
     const budget = argvFlag(argv, "--budget");
@@ -6694,17 +8427,17 @@ var syncInstructionsCommand = define({
 });
 
 // src/commands/trace.ts
-var import_zod31 = require("zod");
+var import_zod37 = require("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: import_zod31.z.object({
+  input: import_zod37.z.object({
     bundlePath,
     conceptId,
-    edges: import_zod31.z.array(import_zod31.z.enum(TRACE_EDGES)).optional(),
-    depth: import_zod31.z.number().int().positive().optional()
+    edges: import_zod37.z.array(import_zod37.z.enum(TRACE_EDGES)).optional(),
+    depth: import_zod37.z.number().int().positive().optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -6726,37 +8459,37 @@ var traceCommand = define({
 });
 
 // src/commands/types.ts
-var import_zod32 = require("zod");
+var import_zod38 = require("zod");
 var typesCommand = define({
   name: "types",
   tool: "kb_types",
   usage: "types",
   description: "The twelve record types with their purpose, body sections, and starting status. Read this before writing rather than guessing headings \u2014 a section the type does not define is rejected.",
-  input: import_zod32.z.object({}),
+  input: import_zod38.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(RECORD_TYPES)
 });
 
 // src/commands/unpin.ts
-var import_zod33 = require("zod");
+var import_zod39 = require("zod");
 var unpinCommand = define({
   name: "unpin",
   tool: "kb_unpin",
   usage: "unpin [bundle-path]",
   description: "Remove a base from every manifest layer that holds it. Reports the layers touched.",
-  input: import_zod33.z.object({ bundlePath }),
+  input: import_zod39.z.object({ bundlePath }),
   fromArgv: (argv, path) => ({ bundlePath: argv[1] ?? path }),
   run: (_ctx, { bundlePath: path }) => unpinBase(process.cwd(), path)
 });
 
 // src/commands/validate.ts
-var import_zod34 = require("zod");
+var import_zod40 = require("zod");
 var validateCommand = define({
   name: "validate",
   tool: "kb_validate",
   usage: "validate",
   description: "Check pointers no single record can see: supersession links that disagree between the two records, typed causal links, and assumptions that cite sources. Each finding carries a severity: errors fail the exit code, warnings do not.",
-  input: import_zod34.z.object({ bundlePath }),
+  input: import_zod40.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: async ({ store }, { bundlePath: path }) => validateBundle(await store.list(path)),
   // Warnings never fail the exit code; every other severity does.
@@ -6766,16 +8499,16 @@ var validateCommand = define({
 });
 
 // src/commands/verify.ts
-var import_zod35 = require("zod");
+var import_zod41 = require("zod");
 var verifyCommand = define({
   name: "verify",
   tool: "kb_verify",
   usage: "verify <concept-id> --note <text>",
   description: "Append a verified[] event: who checked, when, and what was found. Append-only. A record's own generator is refused unless the actor is `human:`-prefixed.",
-  input: import_zod35.z.object({
+  input: import_zod41.z.object({
     bundlePath,
     conceptId,
-    note: import_zod35.z.string().refine((s) => s.trim().length > 0, {
+    note: import_zod41.z.string().refine((s) => s.trim().length > 0, {
       message: "note must say what the check found"
     })
   }),
@@ -6795,15 +8528,15 @@ var verifyCommand = define({
 });
 
 // src/commands/write.ts
-var import_zod36 = require("zod");
+var import_zod42 = require("zod");
 var writeCommand = define({
   name: "write",
   tool: "kb_write",
   usage: "write <type> < record.json",
   description: "Write one record. Search first \u2014 a duplicate concept id is rejected, not overwritten; kb_types lists each type's sections. An unsourced claim is an `assumption` with assumption: true, never a vague `fact`. Conflicting records get a `risk`, `open-question`, or superseding `decision`. Prefer a new short record over overloading one. Never delete; supersede.",
-  input: import_zod36.z.object({
+  input: import_zod42.z.object({
     bundlePath,
-    type: import_zod36.z.enum(KB_RECORD_TYPES),
+    type: import_zod42.z.enum(KB_RECORD_TYPES),
     input: composeInputSchema
   }),
   fromArgv: async (argv, path, stdin) => ({
@@ -6827,13 +8560,13 @@ var writeCommand = define({
 });
 
 // src/commands/write-decision.ts
-var import_zod37 = require("zod");
+var import_zod43 = require("zod");
 var writeDecisionCommand = define({
   name: "write-decision",
   tool: "kb_write_decision",
   usage: "write-decision < decision.json",
   description: "Write a decision, with `alternative` (what was rejected and why) and `impact` as fields. Record one when a later reader would otherwise simplify the constraint away; skip when the diff already answers it. `sources` for material read, `anchors` for code, `relatedConceptIds` for records.",
-  input: import_zod37.z.object({ bundlePath, input: decisionInputSchema }),
+  input: import_zod43.z.object({ bundlePath, input: decisionInputSchema }),
   fromArgv: async (_argv, path, stdin) => ({
     bundlePath: path,
     input: JSON.parse(await stdin())
@@ -6864,19 +8597,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,
@@ -6894,7 +8632,7 @@ var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 
 // src/version.ts
-var VERSION = true ? "0.1.19" : "0.0.0-dev";
+var VERSION = true ? "0.1.20" : "0.0.0-dev";
 
 // src/mcp.ts
 function createKbMcpServer() {
@@ -6933,7 +8671,7 @@ async function runKbMcpServer() {
 }
 
 // src/cli.ts
-var import_node_path12 = require("path");
+var import_node_path15 = require("path");
 async function runKbCli(argv) {
   const { flags, literal } = takeLiteral(argv);
   const {
@@ -6995,7 +8733,7 @@ function takeLiteral(argv) {
 function takeBundle(argv) {
   const at2 = argv.indexOf("--bundle");
   if (at2 === -1) {
-    return { bundle: (0, import_node_path12.join)(process.cwd(), KB_DIR), explicit: false, rest: argv };
+    return { bundle: (0, import_node_path15.join)(process.cwd(), KB_DIR), explicit: false, rest: argv };
   }
   const bundle = argv[at2 + 1];
   if (!bundle) die("--bundle requires a path");
@@ -7006,11 +8744,11 @@ function takeBundle(argv) {
   };
 }
 function readStdin() {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     let text = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => text += chunk);
-    process.stdin.on("end", () => resolve6(text));
+    process.stdin.on("end", () => resolve7(text));
     process.stdin.on("error", reject);
   });
 }
@@ -7055,12 +8793,14 @@ function usage() {
   DEFAULT_LOAD_BUDGET,
   DEFAULT_PACK_HOPS,
   DEFAULT_PACK_MAX_NODES,
+  DEFAULT_THRESHOLDS,
   DEFAULT_TYPED_LINK_RELS,
   DEFAULT_UNVERIFIED_DAYS,
   ErrorTypes,
   Fault,
   INDEX_FILE,
   KB_CAUSAL_LINK_RELS,
+  KB_CLASSES,
   KB_COMMANDS,
   KB_COMMANDS_BY_NAME,
   KB_CONCEPT_ID_PATTERN,
@@ -7074,10 +8814,15 @@ function usage() {
   KB_RECORD_TYPES,
   KB_SLUG_PATTERN,
   KbBaseFrozenError,
+  KbClassifyInputError,
   KbInvalidConceptIdError,
   KbMissingFlagValueError,
   KbPackBudgetExceededError,
   KbPinsMalformedError,
+  KbPromoteCollisionError,
+  KbPromoteSelfError,
+  KbPromoteStandingError,
+  KbPromoteStoppedError,
   KbRecordAlreadyExistsError,
   KbRecordNotFoundError,
   KbSelfVerificationError,
@@ -7090,16 +8835,20 @@ function usage() {
   PINS_FILE,
   PINS_LOCAL_FILE,
   PIN_LAYERS,
+  PROMOTION_SOURCE_ID,
   RECORD_TYPES,
   SEARCH_INDEX_FILE,
   TRACE_EDGES,
   TreeSitterResolver,
   adjudicate,
   anchorFilePath,
+  anchorOnHunk,
   assertBaseNotFrozen,
   backlinks,
   buildContext,
+  carry,
   catalog,
+  classifyDiff,
   classifyDrift,
   composeDecisionRecord,
   composeInputSchema,
@@ -7125,8 +8874,11 @@ function usage() {
   isKbLinkRel,
   isKbRecordType,
   isNoDecisionRecord,
+  isReviewTag,
   kbActorStampSchema,
   kbAnchorSchema,
+  kbAnchorSpanSchema,
+  kbAnchorWriteSchema,
   kbConceptIdSchema,
   kbJsonSchemas,
   kbLinkSchema,
@@ -7146,6 +8898,8 @@ function usage() {
   parseMarkdownWithFrontmatter,
   pinBase,
   prepareResolvers,
+  promoteCandidates,
+  promoteInputSchema,
   readMergedPins,
   readPinsLayer,
   readRemoteAnchors,
@@ -7167,6 +8921,7 @@ function usage() {
   selectDecisions,
   splitMarkdownFrontmatter,
   stringifyMarkdownWithFrontmatter,
+  symbolRangeIndex,
   syncInstructions,
   toHookJson,
   trace,