@saasontools/strauss-kb 0.1.21 → 0.1.23

package/dist/index.cjs

@@ -60,6 +60,7 @@ __export(index_exports, {
   KB_RECORD_STATUSES: () => KB_RECORD_STATUSES,
   KB_RECORD_TYPES: () => KB_RECORD_TYPES,
   KB_SLUG_PATTERN: () => KB_SLUG_PATTERN,
+  KbAnchorSetDuplicateError: () => KbAnchorSetDuplicateError,
   KbBaseFrozenError: () => KbBaseFrozenError,
   KbClassifyInputError: () => KbClassifyInputError,
   KbInvalidConceptIdError: () => KbInvalidConceptIdError,
@@ -90,6 +91,8 @@ __export(index_exports, {
   adjudicate: () => adjudicate,
   anchorFilePath: () => anchorFilePath,
   anchorOnHunk: () => anchorOnHunk,
+  anchorSetInputSchema: () => anchorSetInputSchema,
+  applyAnchorSet: () => applyAnchorSet,
   assertBaseNotFrozen: () => assertBaseNotFrozen,
   backlinks: () => backlinks,
   buildContext: () => buildContext,
@@ -123,19 +126,23 @@ __export(index_exports, {
   isNoDecisionRecord: () => isNoDecisionRecord,
   isReviewTag: () => isReviewTag,
   kbActorStampSchema: () => kbActorStampSchema,
+  kbAnchorLocatorSchema: () => kbAnchorLocatorSchema,
   kbAnchorSchema: () => kbAnchorSchema,
   kbAnchorSpanSchema: () => kbAnchorSpanSchema,
   kbAnchorWriteSchema: () => kbAnchorWriteSchema,
   kbConceptIdSchema: () => kbConceptIdSchema,
   kbJsonSchemas: () => kbJsonSchemas,
   kbLinkSchema: () => kbLinkSchema,
+  kbLogAnchorChangeSchema: () => kbLogAnchorChangeSchema,
   kbLogEntrySchema: () => kbLogEntrySchema,
+  kbLogEntryWriteSchema: () => kbLogEntryWriteSchema,
   kbRecordFrontmatterSchema: () => kbRecordFrontmatterSchema,
   kbSourceSchema: () => kbSourceSchema,
   kbVerifiedEventSchema: () => kbVerifiedEventSchema,
   languageForFile: () => languageForFile,
   listPins: () => listPins,
   loadQmd: () => loadQmd,
+  locatorOf: () => locatorOf,
   matchToDiff: () => matchToDiff,
   matchesTags: () => matchesTags,
   mergedContextBudgets: () => mergedContextBudgets,
@@ -347,6 +354,14 @@ var kbAnchorWriteSchema = kbAnchorSchema.superRefine((anchor, ctx) => {
     });
   }
 });
+var kbAnchorLocatorSchema = kbAnchorSchema.pick({
+  file: true,
+  symbol: true,
+  span: true,
+  side: true,
+  repo: true,
+  ref: true
+});
 var kbLinkSchema = import_zod.z.object({
   target: import_zod.z.string().min(1),
   rel: import_zod.z.string().min(1)
@@ -433,6 +448,7 @@ var Fault = /* @__PURE__ */ ((Fault2) => {
 })(Fault || {});
 var ErrorTypes = /* @__PURE__ */ ((ErrorTypes2) => {
   ErrorTypes2["KbRecordAlreadyExists"] = "KbRecordAlreadyExists";
+  ErrorTypes2["KbAnchorSetDuplicate"] = "KbAnchorSetDuplicate";
   ErrorTypes2["KbClassifyInput"] = "KbClassifyInput";
   ErrorTypes2["KbFlagConflict"] = "KbFlagConflict";
   ErrorTypes2["KbInvalidActor"] = "KbInvalidActor";
@@ -2653,7 +2669,12 @@ var import_node_path6 = require("path");
 // src/kb-log.ts
 var import_zod3 = require("zod");
 var LOG_FILE = "log.jsonl";
-var kbLogEntrySchema = import_zod3.z.object({
+var kbLogAnchorChangeSchema = import_zod3.z.object({
+  op: import_zod3.z.enum(["move", "add", "drop"]),
+  from: kbAnchorLocatorSchema.optional(),
+  to: kbAnchorLocatorSchema.optional()
+}).strict();
+var kbLogEntryFields = import_zod3.z.object({
   // Validated, not just `min(1)`: `at` is a sort key (see `parseLog`
   // below), and a value that isn't actually chronological — a Unix
   // timestamp, a human-typed date, garbage — would sort wrong without
@@ -2670,10 +2691,20 @@ var kbLogEntrySchema = import_zod3.z.object({
    * 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();
+  target: import_zod3.z.string().min(1).optional(),
+  /**
+   * Why the operation was performed, where the operation demands one.
+   * `anchor-set` does: a pointer moved by a reader is only auditable if
+   * the reading is recorded beside it.
+   */
+  reason: import_zod3.z.string().min(1).optional(),
+  /** What `anchor-set` changed, derived from the record before and after. */
+  anchors: import_zod3.z.array(kbLogAnchorChangeSchema).optional()
+});
+var kbLogEntrySchema = kbLogEntryFields.passthrough();
+var kbLogEntryWriteSchema = kbLogEntryFields.strict();
 function renderLogEntry(entry) {
-  return `${JSON.stringify(kbLogEntrySchema.parse(entry))}
+  return `${JSON.stringify(kbLogEntryWriteSchema.parse(entry))}
 `;
 }
 var CONFLICT_MARKER = /^(<{7}|\|{7}|={7}|>{7})/;
@@ -3506,23 +3537,31 @@ var KbStore = class {
     );
   }
   /**
-   * Replaces a record's anchors wholesale, preserving everything else.
-   *
-   * Wholesale rather than merged: the caller just resolved the anchors it is
-   * writing, so it holds the complete current set, and a merge would keep
-   * stale entries the resolution pass deliberately dropped.
-   *
-   * 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.
+   * Replaces a record's anchors, preserving everything else. An array is the
+   * whole set; a function is a patch and runs inside the mutation, against
+   * the anchors the record holds then — see
+   * `decision.anchor-update-patch-inside-mutation`.
    */
   async updateAnchors(bundlePath2, conceptId2, anchors, actor = "unknown") {
     assertActor(actor);
-    const checked = anchors.map((anchor) => kbAnchorWriteSchema.parse(anchor));
+    let entry = {
+      operation: "anchor-resolve",
+      by: actor
+    };
     return this.mutate(
       bundlePath2,
       conceptId2,
-      (frontmatter) => ({ ...frontmatter, strauss_anchors: checked }),
-      { operation: "anchor-resolve", by: actor }
+      (frontmatter) => {
+        const write = typeof anchors === "function" ? anchors(frontmatter.strauss_anchors ?? []) : { anchors };
+        if (write.log) entry = { ...write.log, by: actor };
+        return {
+          ...frontmatter,
+          strauss_anchors: write.anchors.map(
+            (anchor) => kbAnchorWriteSchema.parse(anchor)
+          )
+        };
+      },
+      () => entry
     );
   }
   /**
@@ -3976,7 +4015,10 @@ ${answer}
       throw new KbWriteConflictError(conceptId2);
     }
     await this.publish(target, contents, true, conceptId2);
-    await this.record(this.root(bundlePath2), { ...entry, conceptId: conceptId2 });
+    await this.record(this.root(bundlePath2), {
+      ...typeof entry === "function" ? entry() : entry,
+      conceptId: conceptId2
+    });
     return { conceptId: conceptId2, frontmatter, body };
   }
   /**
@@ -4193,6 +4235,107 @@ function assertActor(actor, { named = false } = {}) {
 
 // src/compose.ts
 var import_zod4 = require("zod");
+
+// src/anchors/errors.ts
+function locatorText(locator) {
+  const span2 = locator.span ? `:${locator.span.start}-${locator.span.end}` : "";
+  const symbol = locator.symbol ? `:${cap(locator.symbol)}` : "";
+  const repo = locator.repo ? `${cap(locator.repo)}@` : "";
+  const ref = locator.ref ? `@${cap(locator.ref)}` : "";
+  return `${repo}${cap(locator.file)}${symbol}${span2}${ref}`;
+}
+var FIELD_CAP = 120;
+function cap(value) {
+  return value.length > FIELD_CAP ? `${value.slice(0, FIELD_CAP - 1)}\u2026` : value;
+}
+var KbAnchorSetDuplicateError = class extends BaseError {
+  constructor(locator) {
+    super({
+      message: `kb: ${locator} appears twice in this set \u2014 a record holds each pointer once`,
+      errorType: "KbAnchorSetDuplicate" /* KbAnchorSetDuplicate */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { locator, action: "refused" }
+    });
+    this.locator = locator;
+  }
+  locator;
+};
+
+// src/anchors/apply.ts
+var LOCATOR_FIELDS = [
+  "file",
+  "symbol",
+  "span",
+  "side",
+  "repo",
+  "ref"
+];
+function applyAnchorSet(current, incoming) {
+  const anchors = incoming.map((anchor) => ({ ...anchor }));
+  const seen = /* @__PURE__ */ new Set();
+  for (const anchor of anchors) {
+    const key2 = locatorKey(anchor);
+    if (seen.has(key2)) {
+      throw new KbAnchorSetDuplicateError(locatorText(locatorOf(anchor)));
+    }
+    seen.add(key2);
+  }
+  return { anchors, changes: diff(current, anchors) };
+}
+function diff(current, next) {
+  const before = new Map(
+    current.filter((anchor) => anchor.hash).map((a) => [a.hash, a])
+  );
+  const beforeLocators = new Map(current.map((a) => [locatorKey(a), a]));
+  const afterLocators = new Set(next.map((anchor) => locatorKey(anchor)));
+  const moved = /* @__PURE__ */ new Set();
+  const changes = [];
+  for (const anchor of next) {
+    const source = anchor.hash ? before.get(anchor.hash) : void 0;
+    if (source) {
+      if (locatorKey(source) === locatorKey(anchor)) continue;
+      moved.add(locatorKey(source));
+      changes.push({
+        op: "move",
+        from: locatorOf(source),
+        to: locatorOf(anchor)
+      });
+      continue;
+    }
+    if (beforeLocators.has(locatorKey(anchor))) continue;
+    changes.push({ op: "add", to: locatorOf(anchor) });
+  }
+  for (const anchor of current) {
+    const key2 = locatorKey(anchor);
+    if (afterLocators.has(key2) || moved.has(key2)) continue;
+    changes.push({ op: "drop", from: locatorOf(anchor) });
+  }
+  return changes;
+}
+function locatorOf(anchor) {
+  return kbAnchorLocatorSchema.parse(
+    Object.fromEntries(
+      LOCATOR_FIELDS.flatMap(
+        (field) => anchor[field] === void 0 ? [] : [[field, anchor[field]]]
+      )
+    )
+  );
+}
+function locatorKey(anchor) {
+  return JSON.stringify([
+    anchor.file,
+    anchor.symbol ?? "",
+    anchor.span ? `${anchor.span.start}-${anchor.span.end}` : "",
+    anchor.side ?? "new",
+    anchor.repo === void 0 ? "" : normalizeRepoUrl(anchor.repo),
+    anchor.ref ?? ""
+  ]);
+}
+
+// src/compose.ts
 var composeLinkSchema = import_zod4.z.object({
   target: kbConceptIdSchema,
   rel: import_zod4.z.enum(KB_LINK_RELS)
@@ -4264,7 +4407,9 @@ function composeRecord(type, input, writtenBy, writtenAt) {
     strauss_status: spec.initialStatus
   };
   if (parsed.stale_after) frontmatter.stale_after = parsed.stale_after;
-  if (parsed.anchors?.length) frontmatter.strauss_anchors = parsed.anchors;
+  if (parsed.anchors?.length) {
+    frontmatter.strauss_anchors = applyAnchorSet([], parsed.anchors).anchors;
+  }
   if (parsed.verify?.length) frontmatter.strauss_verify = parsed.verify;
   if (parsed.tags?.length) frontmatter.tags = parsed.tags;
   if (parsed.sources?.length) frontmatter.sources = parsed.sources;
@@ -5622,8 +5767,8 @@ function selectDecisions(records) {
   );
 }
 
-// src/commands/anchor-resolve.ts
-var import_zod9 = require("zod");
+// src/commands/anchor-resolve/command.ts
+var import_zod10 = require("zod");
 
 // src/commands/model.ts
 var import_zod8 = require("zod");
@@ -5689,26 +5834,270 @@ function argvPositional(argv, ...names) {
   );
 }
 
-// src/commands/anchor-resolve.ts
+// src/commands/anchor-resolve/apply.ts
+var import_zod9 = require("zod");
+async function baseFrozen(cwd, bundlePath2) {
+  try {
+    await assertBaseNotFrozen(cwd, bundlePath2);
+    return false;
+  } catch (caught) {
+    if (!(caught instanceof KbBaseFrozenError)) throw caught;
+    return true;
+  }
+}
+async function applyPlan(plans, target) {
+  if (!plans.some((plan) => plan.write)) {
+    return { results: plans.map((plan) => plan.finding) };
+  }
+  let failure = target.frozen ? "frozen" : void 0;
+  let error;
+  if (!failure) {
+    try {
+      await target.store.updateAnchors(
+        target.bundlePath,
+        target.conceptId,
+        plans.map((plan) => plan.anchor),
+        target.actor
+      );
+    } catch (caught) {
+      if (caught instanceof BaseError || caught instanceof import_zod9.z.ZodError) {
+        throw caught;
+      }
+      failure = "write-failed";
+      error = clamp(caught instanceof Error ? caught.message : String(caught));
+    }
+  }
+  return {
+    results: plans.map((plan) => settle(plan, failure)),
+    ...error ? { error } : {}
+  };
+}
+function settle(plan, failure) {
+  if (!plan.write) return plan.finding;
+  if (failure) {
+    return { ...plan.finding, outcome: "failed", outcomeReason: failure };
+  }
+  if (plan.write === "refresh") return plan.finding;
+  return plan.write === "stamp" ? { ...plan.finding, state: "stamped", outcome: "applied" } : { ...plan.finding, outcome: "applied", rebaselined: true };
+}
+function clamp(message) {
+  const line = message.split("\n")[0] ?? "";
+  return line.length > 200 ? `${line.slice(0, 199)}\u2026` : line;
+}
+
+// src/commands/anchor-resolve/sources.ts
+async function readSources(anchors, root, offline) {
+  const origin = new LazyOrigin(root);
+  if (anchors.some((anchor) => anchor.repo)) await origin.prime();
+  const foreign = new Map(
+    anchors.map((anchor) => [anchor, origin.isForeign(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
+  });
+  const sources = /* @__PURE__ */ new Map();
+  for (const anchor of local) {
+    const read = reads.get(anchor.file);
+    sources.set(
+      anchor,
+      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);
+    const atDefault = blobs.get(wantKey(key2, void 0, anchor.file));
+    const primary = anchor.ref ? blobs.get(wantKey(key2, anchor.ref, anchor.file)) : atDefault;
+    if (!primary?.ok) {
+      sources.set(anchor, {
+        ok: false,
+        reason: primary?.ok === false ? primary.reason : "remote-unreachable",
+        repo
+      });
+      continue;
+    }
+    sources.set(anchor, {
+      ok: true,
+      source: primary.source,
+      repo,
+      ...anchor.ref && atDefault?.ok ? { head: atDefault.source } : {}
+    });
+  }
+  return sources;
+}
+
+// src/commands/anchor-resolve/plan.ts
+async function planAnchors(anchors, options) {
+  const { root, offline, rebaseline, restamp, check, frozen, now } = options;
+  const sources = await readSources(anchors, root, offline);
+  const resolvers = defaultAnchorResolvers({ offline });
+  await prepareResolvers(
+    resolvers,
+    anchors.map((anchor) => anchor.file)
+  );
+  const plans = [];
+  for (const anchor of anchors) {
+    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.
+      ...anchor.hash ? { storedHash: anchor.hash } : {}
+    };
+    const source = sources.get(anchor);
+    if (source.repo) base2.repo = source.repo;
+    if (!source.ok) {
+      plans.push({
+        finding: { ...base2, state: "unresolved", reason: source.reason },
+        anchor
+      });
+      continue;
+    }
+    const outcome = resolveAnchorSpan(source.source, anchor, resolvers);
+    if (!outcome.ok) {
+      plans.push({
+        finding: { ...base2, state: "unresolved", reason: outcome.reason },
+        anchor
+      });
+      continue;
+    }
+    const resolved = outcome.span;
+    const producedBy = outcome.resolver;
+    const { hash: currentHash, kind } = anchorHashOf(anchor, outcome);
+    const currentLines = resolved.endLine - resolved.startLine + 1;
+    const stampedKind = outcome.normalized ? "ast" : "raw";
+    const stampedHash = outcome.normalized ? anchorHashOf({ ...anchor, hash: void 0 }, outcome).hash : currentHash;
+    const stamped = {
+      ...anchor,
+      hash: stampedHash,
+      hash_kind: stampedKind,
+      lines: currentLines,
+      resolved_at: now(),
+      ...producedBy ? { resolver: producedBy } : {}
+    };
+    const pinned = anchor.ref !== void 0 && source.repo !== void 0;
+    if (!anchor.hash) {
+      plans.push({
+        finding: {
+          ...base2,
+          state: "unstamped",
+          currentHash: stampedHash,
+          hashKind: stampedKind,
+          ...producedBy ? { resolver: producedBy } : {}
+        },
+        anchor: check ? anchor : stamped,
+        ...check ? {} : { write: "stamp" }
+      });
+      continue;
+    }
+    if (anchor.hash !== currentHash) {
+      plans.push({
+        finding: {
+          ...base2,
+          state: "drifted",
+          currentHash,
+          hashKind: kind,
+          diffSize: lineDelta(anchor, currentLines),
+          ...producedBy ? { resolver: producedBy } : {},
+          // A regex-stamped anchor re-read by tree-sitter drifts because the
+          // resolver changed, not because the code did.
+          ...resolverChanged(source.source, anchor, producedBy) ? { reason: "resolver-changed" } : {},
+          ...pinned ? { remoteState: "drifted-from-ref" } : {}
+        },
+        anchor: rebaseline && !check ? stamped : anchor,
+        ...rebaseline && !check ? { write: "rebaseline" } : {}
+      });
+      continue;
+    }
+    const onDefault = pinned ? headHash(source, anchor, resolvers) : void 0;
+    if (onDefault && onDefault.hash !== anchor.hash) {
+      plans.push({
+        finding: {
+          ...base2,
+          state: "drifted",
+          currentHash: onDefault.hash,
+          diffSize: lineDelta(anchor, onDefault.lines),
+          remoteState: "drifted-on-default",
+          ...rebaseline ? {
+            outcome: "skipped",
+            outcomeReason: "pinned-ref"
+          } : {}
+        },
+        anchor
+      });
+      continue;
+    }
+    const backfill = anchor.resolved_at === void 0 && !frozen;
+    const refresh = !check && (restamp || backfill);
+    plans.push({
+      finding: {
+        ...base2,
+        state: "match",
+        currentHash,
+        hashKind: kind,
+        ...producedBy ? { resolver: producedBy } : {},
+        ...pinned ? { remoteState: "matches-ref" } : {}
+      },
+      anchor: refresh ? { ...anchor, resolved_at: now() } : anchor,
+      ...refresh ? { write: "refresh" } : {}
+    });
+  }
+  return plans;
+}
+function lineDelta(anchor, current) {
+  return anchor.lines === void 0 ? null : Math.abs(current - anchor.lines);
+}
+function headHash(source, anchor, resolvers) {
+  if (source.head === void 0) return void 0;
+  const outcome = resolveAnchorSpan(source.head, anchor, resolvers);
+  if (!outcome.ok) return void 0;
+  return {
+    hash: hashAnchorText(outcome.span.text),
+    lines: outcome.span.endLine - outcome.span.startLine + 1
+  };
+}
+
+// src/commands/anchor-resolve/command.ts
 var anchorResolveCommand = define({
   name: "anchor-resolve",
   tool: "kb_anchor_resolve",
   usage: "anchor-resolve <concept-id> [--repo-root <path>] [--offline] [--rebaseline] [--restamp] [--check]",
-  description: "Resolve a record's anchors: stamp a hash onto anchors that lack one, report drift where the code moved. An anchor naming another repository is read from that remote through a bare cache; --offline uses the cache only. Never writes verified[]; a judgment is kb_verify. Exits non-zero on drift.",
-  input: import_zod9.z.object({
+  description: "Resolve a record's anchors: stamp a hash onto anchors that lack one, report drift where the code moved. An anchor naming another repository is read from that remote through a bare cache; --offline uses the cache only. Never writes verified[]; a judgment is kb_verify. Each result says what it compared and whether the write applied.",
+  input: import_zod10.z.object({
     bundlePath,
     conceptId,
-    repoRoot: import_zod9.z.string().min(1).optional(),
-    offline: import_zod9.z.boolean().optional().describe(
+    repoRoot: import_zod10.z.string().min(1).optional(),
+    offline: import_zod10.z.boolean().optional().describe(
       "Resolve foreign anchors from the local repo cache only, never fetching."
     ),
-    rebaseline: import_zod9.z.boolean().optional().describe(
+    rebaseline: import_zod10.z.boolean().optional().describe(
       "Accept the current code as the new baseline for anchors that drifted."
     ),
-    restamp: import_zod9.z.boolean().optional().describe(
+    restamp: import_zod10.z.boolean().optional().describe(
       "Refresh `resolved_at` on anchors that already match. Off by default, so a green run writes nothing."
     ),
-    check: import_zod9.z.boolean().optional().describe(
+    check: import_zod10.z.boolean().optional().describe(
       "Resolve and report only: no hash, no `resolved_at`, no log entry."
     )
   }),
@@ -5747,226 +6136,176 @@ var anchorResolveCommand = define({
         note: "record has no anchors"
       };
     }
-    const results = [];
-    const updated = [];
-    let dirty = false;
-    const sources = await readSources(anchors, root, offline === true);
-    const resolvers = defaultAnchorResolvers({ offline: offline === true });
-    await prepareResolvers(
-      resolvers,
-      anchors.map((anchor) => anchor.file)
-    );
-    for (const anchor of anchors) {
-      const base2 = {
-        file: anchor.file,
-        ...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.
-        ...anchor.hash ? { storedHash: anchor.hash } : {}
-      };
-      const source = sources.get(anchor);
-      if (source.repo) base2.repo = source.repo;
-      if (!source.ok) {
-        results.push({ ...base2, state: "unresolved", reason: source.reason });
-        updated.push(anchor);
-        continue;
-      }
-      const outcome = resolveAnchorSpan(source.source, anchor, resolvers);
-      if (!outcome.ok) {
-        results.push({
-          ...base2,
-          state: "unresolved",
-          reason: outcome.reason
-        });
-        updated.push(anchor);
-        continue;
-      }
-      const resolved = outcome.span;
-      const producedBy = outcome.resolver;
-      const { hash: currentHash, kind } = anchorHashOf(anchor, outcome);
-      const currentLines = resolved.endLine - resolved.startLine + 1;
-      const stampedKind = outcome.normalized ? "ast" : "raw";
-      const stampedHash = outcome.normalized ? anchorHashOf({ ...anchor, hash: void 0 }, outcome).hash : currentHash;
-      const stamped = {
-        ...anchor,
-        hash: stampedHash,
-        hash_kind: stampedKind,
-        lines: currentLines,
-        resolved_at: now(),
-        ...producedBy ? { resolver: producedBy } : {}
-      };
-      const pinned = anchor.ref !== void 0 && source.repo !== void 0;
-      if (!anchor.hash) {
-        results.push({
-          ...base2,
-          state: check ? "unstamped" : "stamped",
-          currentHash: stampedHash,
-          hashKind: stampedKind,
-          ...producedBy ? { resolver: producedBy } : {}
-        });
-        updated.push(stamped);
-        dirty = true;
-        continue;
-      }
-      if (anchor.hash !== currentHash) {
-        results.push({
-          ...base2,
-          state: "drifted",
-          currentHash,
-          hashKind: kind,
-          diffSize: lineDelta(anchor, currentLines),
-          ...producedBy ? { resolver: producedBy } : {},
-          // A regex-stamped anchor re-read by tree-sitter drifts because the
-          // resolver changed, not because the code did.
-          ...resolverChanged(source.source, anchor, producedBy) ? { reason: "resolver-changed" } : {},
-          ...pinned ? { remoteState: "drifted-from-ref" } : {},
-          ...rebaseline ? { rebaselined: true } : {}
-        });
-        updated.push(rebaseline ? stamped : anchor);
-        if (rebaseline) dirty = true;
-        continue;
-      }
-      const onDefault = pinned ? headHash(source, anchor, resolvers) : void 0;
-      if (onDefault && onDefault.hash !== anchor.hash) {
-        results.push({
-          ...base2,
-          state: "drifted",
-          currentHash: onDefault.hash,
-          diffSize: lineDelta(anchor, onDefault.lines),
-          remoteState: "drifted-on-default"
-        });
-        updated.push(anchor);
-        continue;
-      }
-      results.push({
-        ...base2,
-        state: "match",
-        currentHash,
-        hashKind: kind,
-        ...producedBy ? { resolver: producedBy } : {},
-        ...pinned ? { remoteState: "matches-ref" } : {}
-      });
-      const refresh = restamp || anchor.resolved_at === void 0;
-      updated.push(refresh ? { ...anchor, resolved_at: now() } : anchor);
-      if (refresh) dirty = true;
-    }
-    let frozen = false;
-    if (dirty && !check) {
-      try {
-        await assertBaseNotFrozen(process.cwd(), path);
-      } catch (error) {
-        if (!(error instanceof KbBaseFrozenError)) throw error;
-        frozen = true;
-      }
-      if (!frozen) await store.updateAnchors(path, id, updated, actor);
-    }
-    const frozenNote = frozen ? { frozen: true, note: "base is frozen: nothing was stamped" } : {};
+    const frozen = check ? false : await baseFrozen(process.cwd(), path);
+    const plans = await planAnchors(anchors, {
+      root,
+      offline: offline === true,
+      rebaseline: rebaseline === true,
+      restamp: restamp === true,
+      check: check === true,
+      frozen,
+      now
+    });
+    const applied = await applyPlan(plans, {
+      store,
+      actor,
+      bundlePath: path,
+      conceptId: id,
+      frozen
+    });
+    const results = applied.results;
+    const refused = frozen && plans.some((plan) => plan.write);
     const hints = grammarHints();
     const hintNote = hints.length ? { hints } : {};
     const unreachable = results.filter(
       (entry) => isUncheckedReason(entry.reason)
     ).length;
     const matches3 = results.filter((entry) => entry.state === "match").length;
-    const note = `${matches3}/${results.length - unreachable} anchors match, ${unreachable} unreachable`;
+    const note = [
+      unreachable ? `${matches3}/${results.length - unreachable} anchors match, ${unreachable} unreachable` : "",
+      refused ? "base is frozen: nothing was stamped" : "",
+      applied.error ? `nothing was written: ${applied.error}` : ""
+    ].filter(Boolean).join("; ");
     return {
       conceptId: id,
       results,
-      ...unreachable ? { note } : {},
-      ...frozenNote,
+      ...note ? { note } : {},
+      ...refused ? { frozen: true } : {},
       ...hintNote
     };
   },
+  // Drift is a finding until a write settles it: a rebaseline the base took is
+  // the answer to the drift it reports, while one refused, skipped, or never
+  // asked for leaves the gate exactly what it was meant to catch.
+  //
   // A stored hash that no longer resolves is a broken anchor, not an absence:
-  // the file was deleted or the symbol renamed, and exiting zero on it would
-  // let the one edit that destroys an anchor pass the gate that exists to
-  // catch it. An anchor nobody ever stamped is still just unstamped, and one
-  // whose remote nothing could reach was never checked — failing CI on either
-  // would gate on work this command did not do.
+  // the file was deleted or the symbol renamed. An anchor nobody ever stamped
+  // is still just unstamped, and one whose remote nothing could reach was
+  // never checked — failing CI on either would gate on work this command did
+  // not do.
   failsWhen: (result) => result.results.some(
-    (entry) => entry.state === "drifted" || entry.state === "unresolved" && entry.storedHash !== void 0 && !isUncheckedReason(entry.reason)
+    (entry) => entry.outcome === "failed" || entry.outcome === "skipped" || entry.state === "drifted" && entry.outcome !== "applied" || entry.state === "unresolved" && entry.storedHash !== void 0 && !isUncheckedReason(entry.reason)
   )
 });
-function lineDelta(anchor, current) {
-  return anchor.lines === void 0 ? null : Math.abs(current - anchor.lines);
-}
-function headHash(source, anchor, resolvers) {
-  if (source.head === void 0) return void 0;
-  const outcome = resolveAnchorSpan(source.head, anchor, resolvers);
-  if (!outcome.ok) return void 0;
-  return {
-    hash: hashAnchorText(outcome.span.text),
-    lines: outcome.span.endLine - outcome.span.startLine + 1
-  };
-}
-async function readSources(anchors, root, offline) {
-  const origin = new LazyOrigin(root);
-  if (anchors.some((anchor) => anchor.repo)) await origin.prime();
-  const foreign = new Map(
-    anchors.map((anchor) => [anchor, origin.isForeign(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
-  });
-  const sources = /* @__PURE__ */ new Map();
-  for (const anchor of local) {
-    const read = reads.get(anchor.file);
-    sources.set(
-      anchor,
-      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 }
+
+// src/commands/anchor-set/model.ts
+var import_zod11 = require("zod");
+var anchorSetInputSchema = import_zod11.z.object({
+  reason: import_zod11.z.string().refine((text) => text.trim().length > 0, {
+    message: "reason must say what was reviewed"
+  }).describe(
+    "What the reviewer read that makes these the right pointers. Recorded in the log."
+  ),
+  anchors: import_zod11.z.array(kbAnchorWriteSchema).min(1).describe(
+    "The complete new anchor set. Carry an anchor's hash forward to keep drift visible until the new code is read."
+  )
+}).strict();
+var anchorSetCommandInput = import_zod11.z.object({
+  bundlePath,
+  conceptId,
+  input: anchorSetInputSchema,
+  resolve: import_zod11.z.boolean().optional().describe(
+    "Also resolve and stamp every anchor against the current code, as anchor-resolve --rebaseline does."
+  ),
+  repoRoot: import_zod11.z.string().min(1).optional().describe(
+    "Where the anchored source lives, for resolve. Defaults to the working directory."
+  ),
+  offline: import_zod11.z.boolean().optional().describe("With resolve, read foreign anchors from the repo cache only.")
+});
+
+// src/commands/anchor-set/command.ts
+var NOTE = "pointers only: nothing was resolved or verified. Run anchor-resolve to check the new pointers, --rebaseline to accept the code, or pass resolve to do both here.";
+var STAMPED_NOTE = "pointers set and stamped against the current code. Not verification: run verify separately if someone reviewed it.";
+var INCOMPLETE_NOTE = "pointers set, but not every anchor was stamped: see each resolved entry's state and outcome.";
+var anchorSetCommand = define({
+  name: "anchor-set",
+  tool: "kb_anchor_set",
+  usage: "anchor-set <concept-id> [--resolve] [--repo-root <path>] [--offline] < anchors.json",
+  description: "Set a record's code anchors after a reviewed refactor, with a reason. The array is the whole set. With resolve, every anchor is stamped against the current code in the same call; without it, run kb_anchor_resolve next. Recorded in the log, never verification.",
+  input: anchorSetCommandInput,
+  fromArgv: async (argv, path, stdin) => ({
+    bundlePath: path,
+    conceptId: argv[1],
+    input: JSON.parse(await stdin()),
+    resolve: argv.includes("--resolve"),
+    repoRoot: argvFlag(argv, "--repo-root"),
+    offline: argv.includes("--offline")
+  }),
+  run: async (ctx, { bundlePath: path, conceptId: id, input, resolve: resolve7, repoRoot, offline }) => {
+    const { store, actor } = ctx;
+    await assertBaseNotFrozen(process.cwd(), path);
+    let applied;
+    const record = await store.updateAnchors(
+      path,
+      id,
+      (current) => {
+        applied = applyAnchorSet(current, input.anchors);
+        return {
+          anchors: applied.anchors,
+          log: {
+            operation: "anchor-set",
+            reason: input.reason,
+            anchors: applied.changes
+          }
+        };
+      },
+      actor
     );
-  }
-  for (const anchor of remote) {
-    const repo = anchor.repo;
-    const key2 = normalizeRepoUrl(repo);
-    const atDefault = blobs.get(wantKey(key2, void 0, anchor.file));
-    const primary = anchor.ref ? blobs.get(wantKey(key2, anchor.ref, anchor.file)) : atDefault;
-    if (!primary?.ok) {
-      sources.set(anchor, {
-        ok: false,
-        reason: primary?.ok === false ? primary.reason : "remote-unreachable",
-        repo
-      });
-      continue;
+    const changes = applied?.changes ?? [];
+    if (!resolve7) {
+      return {
+        conceptId: id,
+        reason: input.reason,
+        changes,
+        anchors: record.frontmatter.strauss_anchors ?? [],
+        baseline: "unchanged",
+        note: NOTE
+      };
     }
-    sources.set(anchor, {
-      ok: true,
-      source: primary.source,
-      repo,
-      ...anchor.ref && atDefault?.ok ? { head: atDefault.source } : {}
-    });
+    const resolved = await anchorResolveCommand.run(
+      ctx,
+      anchorResolveCommand.input.parse({
+        bundlePath: path,
+        conceptId: id,
+        rebaseline: true,
+        ...repoRoot ? { repoRoot } : {},
+        ...offline ? { offline } : {}
+      })
+    );
+    const after = await store.read(path, id);
+    const stamped = resolved.results.every(
+      (entry) => entry.state === "match" || entry.outcome === "applied"
+    );
+    return {
+      conceptId: id,
+      reason: input.reason,
+      changes,
+      anchors: after?.frontmatter.strauss_anchors ?? [],
+      baseline: stamped ? "stamped" : "incomplete",
+      resolved: resolved.results,
+      note: stamped ? STAMPED_NOTE : INCOMPLETE_NOTE
+    };
+  },
+  // With `resolve`, a pointer that names nothing is a failed set, not a
+  // finding to read later, and a stamp that did not land fails as it does in
+  // anchor-resolve. A remote nothing could reach was never checked, so it does
+  // not fail — the same line anchor-resolve draws.
+  failsWhen: (result, input) => {
+    const resolved = result.resolved ?? [];
+    return resolved.some(
+      (entry) => entry.state === "unresolved" && !isUncheckedReason(entry.reason)
+    ) || anchorResolveCommand.failsWhen?.({ results: resolved }, input) === true;
   }
-  return sources;
-}
+});
 
 // src/commands/answer.ts
-var import_zod10 = require("zod");
+var import_zod12 = require("zod");
 var answerCommand = define({
   name: "answer",
   tool: "kb_answer",
   usage: "answer <concept-id> <answer...>",
   description: "Resolve an open question: set status, stamp who and when, append an Answer section. If the answer overturns a decision or assumption, supersede that record explicitly.",
-  input: import_zod10.z.object({ bundlePath, conceptId, answer: import_zod10.z.string().min(1) }),
+  input: import_zod12.z.object({ bundlePath, conceptId, answer: import_zod12.z.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -5980,27 +6319,27 @@ var answerCommand = define({
 });
 
 // src/commands/backlinks.ts
-var import_zod11 = require("zod");
+var import_zod13 = require("zod");
 var backlinksCommand = define({
   name: "backlinks",
   tool: "kb_backlinks",
   usage: "backlinks <concept-id>",
   description: "Who points at this record: every inbound typed causal link (`strauss_links`), one hop, every rel including `related_to`, each with its rel and the standing of the record that made it. Use it when you need the exact edges \u2014 reviewing or renaming a record.",
-  input: import_zod11.z.object({ bundlePath, conceptId }),
+  input: import_zod13.z.object({ bundlePath, conceptId }),
   fromArgv: (argv, path) => ({ bundlePath: path, conceptId: argv[1] }),
   run: async ({ store }, { bundlePath: path, conceptId: id }) => store.backlinks(path, id)
 });
 
 // src/commands/catalog.ts
-var import_zod12 = require("zod");
+var import_zod14 = require("zod");
 var catalogCommand = define({
   name: "catalog",
   tool: "kb_catalog",
   usage: "catalog [type] [--tag T]...",
   description: "Lists every record as one line \u2014 concept id, type, title, standing, and a stale flag \u2014 at roughly thirty tokens each. Pick this over kb_load once kb_load refuses: kb_catalog never refuses. Superseded records show only their replacement; fetch bodies with kb_load, kb_pack, kb_query, or kb_trace.",
-  input: import_zod12.z.object({
+  input: import_zod14.z.object({
     bundlePath,
-    type: import_zod12.z.enum(KB_RECORD_TYPES).optional(),
+    type: import_zod14.z.enum(KB_RECORD_TYPES).optional(),
     tags: TAGS
   }),
   fromArgv: (argv, path) => {
@@ -6072,7 +6411,7 @@ function count(value, noun) {
 var import_node_buffer = require("buffer");
 var import_promises10 = require("fs/promises");
 var import_node_path12 = require("path");
-var import_zod15 = require("zod");
+var import_zod17 = require("zod");
 
 // src/drift/moved.ts
 var import_promises9 = require("fs/promises");
@@ -6409,7 +6748,7 @@ function claimOf(record) {
 }
 
 // src/commands/match/command.ts
-var import_zod14 = require("zod");
+var import_zod16 = require("zod");
 
 // src/commands/match/errors.ts
 var KbMatchInputError = class extends BaseError {
@@ -6429,21 +6768,21 @@ var KbMatchInputError = class extends BaseError {
 };
 
 // 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()
+var import_zod15 = require("zod");
+var diffHunkSchema = import_zod15.z.object({
+  startLine: import_zod15.z.number().int().positive(),
+  endLine: import_zod15.z.number().int().positive(),
+  side: import_zod15.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 diffFileSchema = import_zod15.z.object({
+  filePath: import_zod15.z.string().min(1).describe("Repo-relative, spelled the way anchors are."),
+  hunks: import_zod15.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()
+var symbolRangeSchema = import_zod15.z.object({
+  file: import_zod15.z.string().min(1),
+  symbol: import_zod15.z.string().min(1),
+  startLine: import_zod15.z.number().int().positive(),
+  endLine: import_zod15.z.number().int().positive()
 });
 
 // src/commands/match/parse-unified-diff.ts
@@ -6692,17 +7031,17 @@ var matchCommand = define({
   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({
+  input: import_zod16.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(
+    files: import_zod16.z.array(diffFileSchema).describe("The changed files, each with its post-change line ranges."),
+    symbolRanges: import_zod16.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(
+    offline: import_zod16.z.boolean().optional().describe(
       "Resolve symbol ranges from what is already on disk, never fetching a grammar."
     ),
-    includeNonCurrent: import_zod14.z.boolean().optional().describe(
+    includeNonCurrent: import_zod16.z.boolean().optional().describe(
       "Return superseded, rejected and unsettled records too, each carrying its standing."
     )
   }),
@@ -6716,11 +7055,11 @@ var matchCommand = define({
       ...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]}`);
+      const diff2 = await readRangeDiff(repoRoot ?? process.cwd(), range);
+      if (!diff2.ok) {
+        throw new KbMatchInputError(`--git ${range} ${REFUSED[diff2.reason]}`);
       }
-      return { ...base2, files: parseUnifiedDiff(diff.text) };
+      return { ...base2, files: parseUnifiedDiff(diff2.text) };
     }
     if (!argv.includes("--stdin")) {
       throw new KbMatchInputError(
@@ -6806,22 +7145,22 @@ function project(match, ranges, all) {
 
 // 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() })
+  hunks: import_zod17.z.array(
+    diffHunkSchema.extend({ lines: import_zod17.z.array(import_zod17.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()
+  renamedFrom: import_zod17.z.string().min(1).optional().describe("Where `git diff -M` says the path came from."),
+  similarity: import_zod17.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({
+  input: import_zod17.z.object({
     bundlePath,
-    files: import_zod15.z.array(classifyFileSchema).describe("The changed files, each with its line ranges."),
+    files: import_zod17.z.array(classifyFileSchema).describe("The changed files, each with its line ranges."),
     repoRoot: REPO_ROOT,
-    offline: import_zod15.z.boolean().optional().describe(
+    offline: import_zod17.z.boolean().optional().describe(
       "Resolve symbol ranges from what is already on disk, never fetching a grammar."
     )
   }),
@@ -6834,15 +7173,15 @@ var classifyCommand = define({
       ...argv.includes("--offline") ? { offline: true } : {}
     };
     if (range !== void 0) {
-      const diff = await readRangeDiff(repoRoot ?? process.cwd(), range);
-      if (!diff.ok) {
+      const diff2 = await readRangeDiff(repoRoot ?? process.cwd(), range);
+      if (!diff2.ok) {
         throw new KbClassifyInputError(
-          `--git ${range} ${REFUSED2[diff.reason]}`
+          `--git ${range} ${REFUSED2[diff2.reason]}`
         );
       }
       return {
         ...base2,
-        files: parseUnifiedDiff(diff.text, {
+        files: parseUnifiedDiff(diff2.text, {
           keepEmpty: true,
           withLines: true
         })
@@ -6932,29 +7271,29 @@ function renderClassify(result) {
 }
 
 // src/commands/context.ts
-var import_zod16 = require("zod");
+var import_zod18 = 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(
+  input: import_zod18.z.object({
+    budgetTokens: import_zod18.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(
+    fullUnderTokens: import_zod18.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(
+    profile: import_zod18.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(
+    excludeTags: import_zod18.z.array(import_zod18.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(
+    format: import_zod18.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(
+    event: import_zod18.z.string().optional().describe(
       "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
     )
   }),
@@ -6993,20 +7332,20 @@ var contextCommand = define({
 });
 
 // src/commands/doctor.ts
-var import_zod18 = require("zod");
+var import_zod20 = require("zod");
 
 // src/commands/reassess.ts
-var import_zod17 = require("zod");
+var import_zod19 = 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({
+  input: import_zod19.z.object({
     bundlePath,
     conceptId,
     repoRoot: REPO_ROOT,
-    withDiff: import_zod17.z.boolean().optional().describe(
+    withDiff: import_zod19.z.boolean().optional().describe(
       "Recover each anchor's committed span and render the diff. Reads git history."
     )
   }),
@@ -7151,13 +7490,13 @@ function at(file, symbol) {
 }
 
 // src/commands/doctor.ts
-var days = (what, fallback) => import_zod18.z.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
+var days = (what, fallback) => import_zod20.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_zod18.z.object({
+  input: import_zod20.z.object({
     bundlePath,
     repoRoot: REPO_ROOT,
     expiringDays: days(
@@ -7172,16 +7511,16 @@ var doctorCommand = define({
       "How long a record may stay `open` or `proposed` before `aging` reports it, in days.",
       DEFAULT_AGING_DAYS
     ),
-    offline: import_zod18.z.boolean().optional().describe(
+    offline: import_zod20.z.boolean().optional().describe(
       "Read foreign anchors from the local repo cache only, never fetching."
     ),
-    strict: import_zod18.z.boolean().optional().describe(
+    strict: import_zod20.z.boolean().optional().describe(
       "Turn an expired record into a non-zero exit for the CLI. No effect on the report itself."
     ),
-    drifted: import_zod18.z.boolean().optional().describe(
+    drifted: import_zod20.z.boolean().optional().describe(
       "Report only drift, as a reassessment packet per record: claim, per-anchor class, and what depends on it."
     ),
-    withDiff: import_zod18.z.boolean().optional().describe(
+    withDiff: import_zod20.z.boolean().optional().describe(
       "With `drifted`: recover each anchor's committed span and render the old-vs-new diff. Reads git history."
     )
   }),
@@ -7358,7 +7697,7 @@ function renderPackets(result) {
 // src/commands/export.ts
 var import_promises11 = require("fs/promises");
 var import_node_path13 = require("path");
-var import_zod19 = require("zod");
+var import_zod21 = require("zod");
 var NUMBERED = /^(\d{4})-(.+)\.md$/;
 var MARKER = "<!-- strauss-kb export: ";
 var exportCommand = define({
@@ -7366,10 +7705,10 @@ var exportCommand = define({
   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({
+  input: import_zod21.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.")
+    format: import_zod21.z.enum(["madr"]).describe("Output layout. `madr` is the only one so far."),
+    to: import_zod21.z.string().min(1).describe("Directory the ADR files are written into.")
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -7491,19 +7830,19 @@ function bodySections(body) {
 }
 
 // src/commands/impact.ts
-var import_zod20 = require("zod");
+var import_zod22 = 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_zod20.z.object({
+  input: import_zod22.z.object({
     bundlePath,
     conceptId,
-    depth: import_zod20.z.number().int().positive().optional().describe(
+    depth: import_zod22.z.number().int().positive().optional().describe(
       "Hops out from the record. Unbounded when omitted; a walk this cuts reports truncated: true."
     ),
-    rels: import_zod20.z.array(import_zod20.z.enum(KB_CAUSAL_LINK_RELS)).optional().describe(
+    rels: import_zod22.z.array(import_zod22.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."
     )
   }),
@@ -7524,15 +7863,15 @@ var impactCommand = define({
 });
 
 // src/commands/list.ts
-var import_zod21 = require("zod");
+var import_zod23 = 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_zod21.z.object({
+  input: import_zod23.z.object({
     bundlePath,
-    type: import_zod21.z.enum(KB_RECORD_TYPES).optional(),
+    type: import_zod23.z.enum(KB_RECORD_TYPES).optional(),
     tags: TAGS
   }),
   fromArgv: (argv, path) => {
@@ -7556,17 +7895,17 @@ var listCommand = define({
 });
 
 // src/commands/load.ts
-var import_zod22 = require("zod");
+var import_zod24 = 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_zod22.z.object({
+  input: import_zod24.z.object({
     bundlePath,
-    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(
+    type: import_zod24.z.enum(KB_RECORD_TYPES).optional(),
+    budgetTokens: import_zod24.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
+    all: import_zod24.z.boolean().optional().describe(
       "Loads the entire base regardless of size, bypassing the token budget; mutually exclusive with budgetTokens."
     ),
     repoRoot: REPO_ROOT
@@ -7608,25 +7947,25 @@ var loadCommand = define({
 });
 
 // src/commands/log.ts
-var import_zod23 = require("zod");
+var import_zod25 = 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_zod23.z.object({ bundlePath }),
+  input: import_zod25.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readLog(path)
 });
 
 // src/commands/no-decision.ts
-var import_zod24 = require("zod");
+var import_zod26 = 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_zod24.z.object({ bundlePath, reason: import_zod24.z.string().min(1) }),
+  input: import_zod26.z.object({ bundlePath, reason: import_zod26.z.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     reason: argv.slice(1).join(" ").trim()
@@ -7643,20 +7982,20 @@ var noDecisionCommand = define({
 });
 
 // src/commands/pack.ts
-var import_zod25 = require("zod");
+var import_zod27 = 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_zod25.z.object({
+  input: import_zod27.z.object({
     bundlePath,
     conceptId,
-    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(
+    hops: import_zod27.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
+    maxNodes: import_zod27.z.number().int().positive().optional().describe(
       "How many records the pack may hold, root included. Defaults to 20."
     ),
-    budgetTokens: import_zod25.z.number().int().positive().optional().describe(
+    budgetTokens: import_zod27.z.number().int().positive().optional().describe(
       "Approximate token ceiling over what is actually emitted. Defaults to 25000."
     )
   }),
@@ -7743,22 +8082,22 @@ function warningLabel(warning) {
 }
 
 // src/commands/pin.ts
-var import_zod26 = require("zod");
+var import_zod28 = 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_zod26.z.object({
+  input: import_zod28.z.object({
     bundlePath,
-    mode: import_zod26.z.enum(["full", "index"]).optional().describe(
+    mode: import_zod28.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_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(
+    profiles: import_zod28.z.array(import_zod28.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
+    layer: import_zod28.z.enum(["project", "local", "user"]).optional().describe(
       "Which manifest to write: project (committed, default), local (personal, gitignored), user (~/.strauss, every workspace)."
     ),
-    frozen: import_zod26.z.boolean().optional().describe(
+    frozen: import_zod28.z.boolean().optional().describe(
       "true: the base is concluded \u2014 writes against it refuse while pinned. false: lift a freeze."
     )
   }),
@@ -7787,13 +8126,13 @@ var pinCommand = define({
 });
 
 // src/commands/pins.ts
-var import_zod27 = require("zod");
+var import_zod29 = 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_zod27.z.object({}),
+  input: import_zod29.z.object({}),
   fromArgv: () => ({}),
   run: ({ store }) => listPins(store, process.cwd())
 });
@@ -7929,16 +8268,16 @@ function recordType(conceptId2) {
 }
 
 // src/commands/promote/model.ts
-var import_zod28 = require("zod");
-var promoteInputSchema = import_zod28.z.object({
+var import_zod30 = require("zod");
+var promoteInputSchema = import_zod30.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(
+  conceptIds: import_zod30.z.array(conceptId).max(64).optional().describe("Records to copy into the target base. Omit with `list`."),
+  to: import_zod30.z.string().min(1).optional().describe("Absolute path to the base being promoted into."),
+  source: import_zod30.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.")
+  force: import_zod30.z.boolean().optional().describe("Overwrite a record the target base already holds."),
+  list: import_zod30.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"]
@@ -8075,17 +8414,17 @@ function renderPromote(result) {
 }
 
 // src/commands/query.ts
-var import_zod29 = require("zod");
+var import_zod31 = 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_zod29.z.object({
+  input: import_zod31.z.object({
     bundlePath,
-    text: import_zod29.z.string().optional(),
-    type: import_zod29.z.enum(KB_RECORD_TYPES).optional(),
-    includeNonCurrent: import_zod29.z.boolean().optional(),
+    text: import_zod31.z.string().optional(),
+    type: import_zod31.z.enum(KB_RECORD_TYPES).optional(),
+    includeNonCurrent: import_zod31.z.boolean().optional(),
     tags: TAGS,
     repoRoot: REPO_ROOT
   }),
@@ -8119,43 +8458,43 @@ var queryCommand = define({
 });
 
 // src/commands/read-index.ts
-var import_zod30 = require("zod");
+var import_zod32 = 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_zod30.z.object({ bundlePath }),
+  input: import_zod32.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readIndex(path)
 });
 
 // src/commands/schema.ts
-var import_zod31 = require("zod");
+var import_zod33 = 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_zod31.z.object({}),
+  input: import_zod33.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(kbJsonSchemas())
 });
 
 // src/commands/stamp.ts
 var import_promises12 = require("fs/promises");
-var import_zod32 = require("zod");
+var import_zod34 = 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_zod32.z.object({
-    bundlePath: import_zod32.z.string().min(1).optional().describe(
+  input: import_zod34.z.object({
+    bundlePath: import_zod34.z.string().min(1).optional().describe(
       "Absolute path to one knowledge base. Omit to stamp every pinned base."
     ),
-    since: import_zod32.z.string().min(1).optional().describe(
+    since: import_zod34.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."
     )
   }),
@@ -8241,16 +8580,16 @@ async function readBaseline(since) {
 }
 
 // src/commands/status.ts
-var import_zod33 = require("zod");
+var import_zod35 = 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_zod33.z.object({
+  input: import_zod35.z.object({
     bundlePath,
     conceptId,
-    status: import_zod33.z.enum(KB_RECORD_STATUSES)
+    status: import_zod35.z.enum(KB_RECORD_STATUSES)
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -8265,13 +8604,13 @@ var statusCommand = define({
 });
 
 // src/commands/supersede.ts
-var import_zod34 = require("zod");
+var import_zod36 = 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_zod34.z.object({ bundlePath, conceptId, replacementId: conceptId }),
+  input: import_zod36.z.object({ bundlePath, conceptId, replacementId: conceptId }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -8285,7 +8624,7 @@ var supersedeCommand = define({
 });
 
 // src/commands/sweep.ts
-var import_zod35 = require("zod");
+var import_zod37 = require("zod");
 var TERMINAL = [
   "resolved",
   "rejected",
@@ -8296,15 +8635,15 @@ var sweepCommand = define({
   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({
+  input: import_zod37.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, {
+    tag: import_zod37.z.string({ error: "sweep needs --tag: it never sweeps a whole base" }).min(1).describe("Only records carrying this tag are considered."),
+    terminal: import_zod37.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.")
+    dryRun: import_zod37.z.boolean().optional().describe("Report what would go, and delete nothing.")
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -8421,16 +8760,16 @@ function renderSweep(result) {
 }
 
 // src/commands/sync-instructions.ts
-var import_zod36 = require("zod");
+var import_zod38 = 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_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()
+  input: import_zod38.z.object({
+    file: import_zod38.z.string().min(1).describe("The instruction file to edit in place."),
+    budgetTokens: import_zod38.z.number().int().positive().optional(),
+    fullUnderTokens: import_zod38.z.number().int().positive().optional(),
+    profile: import_zod38.z.string().optional()
   }),
   fromArgv: (argv) => {
     const budget = argvFlag(argv, "--budget");
@@ -8456,17 +8795,17 @@ var syncInstructionsCommand = define({
 });
 
 // src/commands/trace.ts
-var import_zod37 = require("zod");
+var import_zod39 = 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_zod37.z.object({
+  input: import_zod39.z.object({
     bundlePath,
     conceptId,
-    edges: import_zod37.z.array(import_zod37.z.enum(TRACE_EDGES)).optional(),
-    depth: import_zod37.z.number().int().positive().optional()
+    edges: import_zod39.z.array(import_zod39.z.enum(TRACE_EDGES)).optional(),
+    depth: import_zod39.z.number().int().positive().optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -8488,37 +8827,37 @@ var traceCommand = define({
 });
 
 // src/commands/types.ts
-var import_zod38 = require("zod");
+var import_zod40 = 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_zod38.z.object({}),
+  input: import_zod40.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(RECORD_TYPES)
 });
 
 // src/commands/unpin.ts
-var import_zod39 = require("zod");
+var import_zod41 = 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_zod39.z.object({ bundlePath }),
+  input: import_zod41.z.object({ bundlePath }),
   fromArgv: (argv, path) => ({ bundlePath: argv[1] ?? path }),
   run: (_ctx, { bundlePath: path }) => unpinBase(process.cwd(), path)
 });
 
 // src/commands/validate.ts
-var import_zod40 = require("zod");
+var import_zod42 = 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_zod40.z.object({ bundlePath }),
+  input: import_zod42.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.
@@ -8528,16 +8867,16 @@ var validateCommand = define({
 });
 
 // src/commands/verify.ts
-var import_zod41 = require("zod");
+var import_zod43 = 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_zod41.z.object({
+  input: import_zod43.z.object({
     bundlePath,
     conceptId,
-    note: import_zod41.z.string().refine((s) => s.trim().length > 0, {
+    note: import_zod43.z.string().refine((s) => s.trim().length > 0, {
       message: "note must say what the check found"
     })
   }),
@@ -8557,15 +8896,15 @@ var verifyCommand = define({
 });
 
 // src/commands/write.ts
-var import_zod42 = require("zod");
+var import_zod44 = 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_zod42.z.object({
+  input: import_zod44.z.object({
     bundlePath,
-    type: import_zod42.z.enum(KB_RECORD_TYPES),
+    type: import_zod44.z.enum(KB_RECORD_TYPES),
     input: composeInputSchema
   }),
   fromArgv: async (argv, path, stdin) => ({
@@ -8589,13 +8928,13 @@ var writeCommand = define({
 });
 
 // src/commands/write-decision.ts
-var import_zod43 = require("zod");
+var import_zod45 = 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_zod43.z.object({ bundlePath, input: decisionInputSchema }),
+  input: import_zod45.z.object({ bundlePath, input: decisionInputSchema }),
   fromArgv: async (_argv, path, stdin) => ({
     bundlePath: path,
     input: JSON.parse(await stdin())
@@ -8625,6 +8964,7 @@ var KB_COMMANDS = [
   answerCommand,
   verifyCommand,
   anchorResolveCommand,
+  anchorSetCommand,
   reassessCommand,
   promoteCommand,
   loadCommand,
@@ -8661,7 +9001,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.21" : "0.0.0-dev";
+var VERSION = true ? "0.1.23" : "0.0.0-dev";
 
 // src/mcp.ts
 function createKbMcpServer() {
@@ -8842,6 +9182,7 @@ function usage() {
   KB_RECORD_STATUSES,
   KB_RECORD_TYPES,
   KB_SLUG_PATTERN,
+  KbAnchorSetDuplicateError,
   KbBaseFrozenError,
   KbClassifyInputError,
   KbInvalidConceptIdError,
@@ -8872,6 +9213,8 @@ function usage() {
   adjudicate,
   anchorFilePath,
   anchorOnHunk,
+  anchorSetInputSchema,
+  applyAnchorSet,
   assertBaseNotFrozen,
   backlinks,
   buildContext,
@@ -8905,19 +9248,23 @@ function usage() {
   isNoDecisionRecord,
   isReviewTag,
   kbActorStampSchema,
+  kbAnchorLocatorSchema,
   kbAnchorSchema,
   kbAnchorSpanSchema,
   kbAnchorWriteSchema,
   kbConceptIdSchema,
   kbJsonSchemas,
   kbLinkSchema,
+  kbLogAnchorChangeSchema,
   kbLogEntrySchema,
+  kbLogEntryWriteSchema,
   kbRecordFrontmatterSchema,
   kbSourceSchema,
   kbVerifiedEventSchema,
   languageForFile,
   listPins,
   loadQmd,
+  locatorOf,
   matchToDiff,
   matchesTags,
   mergedContextBudgets,