@saasontools/strauss-kb 0.1.20 → 0.1.22

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,7 +448,10 @@ var Fault = /* @__PURE__ */ ((Fault2) => {
 })(Fault || {});
 var ErrorTypes = /* @__PURE__ */ ((ErrorTypes2) => {
   ErrorTypes2["KbRecordAlreadyExists"] = "KbRecordAlreadyExists";
+  ErrorTypes2["KbAnchorSetDuplicate"] = "KbAnchorSetDuplicate";
   ErrorTypes2["KbClassifyInput"] = "KbClassifyInput";
+  ErrorTypes2["KbFlagConflict"] = "KbFlagConflict";
+  ErrorTypes2["KbInvalidActor"] = "KbInvalidActor";
   ErrorTypes2["KbInvalidConceptId"] = "KbInvalidConceptId";
   ErrorTypes2["KbMatchInput"] = "KbMatchInput";
   ErrorTypes2["KbMissingFlagValue"] = "KbMissingFlagValue";
@@ -534,6 +552,38 @@ var KbSelfVerificationError = class extends BaseError {
   actor;
   generatedBy;
 };
+var KbInvalidActorError = class extends BaseError {
+  constructor(actor, reason) {
+    super({
+      message: `kb: actor ${JSON.stringify(actor)} ${reason} \u2014 set STRAUSS_KB_ACTOR, e.g. human:alice or agent:reviewer`,
+      errorType: "KbInvalidActor" /* KbInvalidActor */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { actor, reason, action: "refused" }
+    });
+    this.actor = actor;
+    this.reason = reason;
+  }
+  actor;
+  reason;
+};
+var KbFlagConflictError = class extends BaseError {
+  constructor(flags) {
+    super({
+      message: `kb: ${flags.join(" and ")} cannot be combined`,
+      errorType: "KbFlagConflict" /* KbFlagConflict */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { flags }
+    });
+    this.flags = flags;
+  }
+  flags;
+};
 var KbPackBudgetExceededError = class extends BaseError {
   constructor(recordCount, approxTokens2, budgetTokens, excluded) {
     super({
@@ -2619,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
@@ -2636,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})/;
@@ -3361,6 +3426,7 @@ var KbStore = class {
    * its contents.
    */
   async write(bundlePath2, input, actor = "unknown") {
+    assertActor(actor);
     if (!KB_SLUG_PATTERN.test(input.slug)) {
       throw new KbInvalidConceptIdError("slug must be kebab-case", {
         slug: input.slug
@@ -3462,6 +3528,7 @@ var KbStore = class {
    * timeouts.
    */
   async setStatus(bundlePath2, conceptId2, status, actor = "unknown") {
+    assertActor(actor);
     return this.mutate(
       bundlePath2,
       conceptId2,
@@ -3470,22 +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") {
-    const checked = anchors.map((anchor) => kbAnchorWriteSchema.parse(anchor));
+    assertActor(actor);
+    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
     );
   }
   /**
@@ -3500,6 +3576,7 @@ var KbStore = class {
    * logs what it publishes.
    */
   async verify(bundlePath2, conceptId2, note, actor = "unknown", at2 = (/* @__PURE__ */ new Date()).toISOString()) {
+    assertActor(actor, { named: true });
     const event = kbVerifiedEventSchema.parse({ by: actor, at: at2, note });
     const existing = await this.read(bundlePath2, conceptId2);
     if (!existing) throw new KbRecordNotFoundError(conceptId2);
@@ -3530,6 +3607,7 @@ var KbStore = class {
    * in normal use, and validation drops to catching hand-edits.
    */
   async supersede(bundlePath2, conceptId2, replacementId, actor = "unknown") {
+    assertActor(actor);
     const replacement = await this.read(bundlePath2, replacementId);
     if (!replacement) throw new KbRecordNotFoundError(replacementId);
     const superseded = await this.markSuperseded(
@@ -3553,6 +3631,7 @@ var KbStore = class {
   }
   /** Resolves an open question, stamping who answered and when. */
   async answer(bundlePath2, conceptId2, answer, actor = "unknown", at2 = (/* @__PURE__ */ new Date()).toISOString()) {
+    assertActor(actor);
     return this.mutate(
       bundlePath2,
       conceptId2,
@@ -3579,6 +3658,7 @@ ${answer}
    * terminal status since the caller listed it is reported, not removed.
    */
   async deleteRecord(bundlePath2, conceptId2, expected, actor = "unknown") {
+    assertActor(actor);
     const target = this.recordPath(bundlePath2, conceptId2);
     const witness = await this.read(bundlePath2, conceptId2);
     if (!witness) throw new KbRecordNotFoundError(conceptId2);
@@ -3882,6 +3962,7 @@ ${answer}
    * base too, where nothing was written.
    */
   async note(bundlePath2, entry) {
+    assertActor(entry.by);
     await this.record(this.root(bundlePath2), entry);
   }
   /**
@@ -3934,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 };
   }
   /**
@@ -4139,9 +4223,119 @@ function normalizeActor(id) {
   if (colon === -1) return id.toLowerCase();
   return id.slice(0, colon + 1).toLowerCase() + id.slice(colon + 1);
 }
+var KB_ACTOR_PATTERN = /^[A-Za-z][\w-]*(?::[\p{L}\p{M}\p{N}_.@+/-]+)?$/u;
+function assertActor(actor, { named = false } = {}) {
+  if (!KB_ACTOR_PATTERN.test(actor)) {
+    throw new KbInvalidActorError(actor, "is not kind or kind:name");
+  }
+  if (named && normalizeActor(actor) === "unknown") {
+    throw new KbInvalidActorError(actor, "cannot verify: name who checked");
+  }
+}
 
 // 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)
@@ -4213,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;
@@ -5639,19 +5835,11 @@ function argvPositional(argv, ...names) {
 }
 
 // src/commands/anchor-resolve.ts
-function resolverSummary(results) {
-  const names = [
-    ...new Set(
-      results.flatMap((entry) => entry.resolver ? [entry.resolver] : [])
-    )
-  ].sort();
-  return names.length ? `${names.join(" + ")} resolver` : "whole-file";
-}
 var anchorResolveCommand = define({
   name: "anchor-resolve",
   tool: "kb_anchor_resolve",
-  usage: "anchor-resolve <concept-id> [--repo-root <path>] [--offline] [--rebaseline] [--restamp]",
-  description: "Resolve a record's anchors: stamp a hash onto anchors that lack one, report drift where the code moved. An anchor naming another repository is read from that remote through a bare cache; --offline uses the cache only. kb_verify's mechanical counterpart \u2014 reach for it when the question is whether the code still is what it was. Exits non-zero on drift.",
+  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({
     bundlePath,
     conceptId,
@@ -5664,6 +5852,9 @@ var anchorResolveCommand = define({
     ),
     restamp: import_zod9.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(
+      "Resolve and report only: no hash, no `resolved_at`, no log entry."
     )
   }),
   fromArgv: (argv, path) => ({
@@ -5672,9 +5863,24 @@ var anchorResolveCommand = define({
     repoRoot: argvFlag(argv, "--repo-root"),
     offline: argv.includes("--offline"),
     rebaseline: argv.includes("--rebaseline"),
-    restamp: argv.includes("--restamp")
+    restamp: argv.includes("--restamp"),
+    check: argv.includes("--check")
   }),
-  run: async ({ store, actor, now }, { bundlePath: path, conceptId: id, repoRoot, offline, rebaseline, restamp }) => {
+  run: async ({ store, actor, now }, {
+    bundlePath: path,
+    conceptId: id,
+    repoRoot,
+    offline,
+    rebaseline,
+    restamp,
+    check
+  }) => {
+    if (check && (rebaseline || restamp)) {
+      throw new KbFlagConflictError([
+        "check",
+        rebaseline ? "rebaseline" : "restamp"
+      ]);
+    }
     const root = repoRoot ?? process.cwd();
     const record = await store.read(path, id);
     if (!record) throw new KbRecordNotFoundError(id);
@@ -5683,7 +5889,6 @@ var anchorResolveCommand = define({
       return {
         conceptId: id,
         results: [],
-        verified: false,
         note: "record has no anchors"
       };
     }
@@ -5741,7 +5946,7 @@ var anchorResolveCommand = define({
       if (!anchor.hash) {
         results.push({
           ...base2,
-          state: "stamped",
+          state: check ? "unstamped" : "stamped",
           currentHash: stampedHash,
           hashKind: stampedKind,
           ...producedBy ? { resolver: producedBy } : {}
@@ -5793,7 +5998,7 @@ var anchorResolveCommand = define({
       if (refresh) dirty = true;
     }
     let frozen = false;
-    if (dirty) {
+    if (dirty && !check) {
       try {
         await assertBaseNotFrozen(process.cwd(), path);
       } catch (error) {
@@ -5808,42 +6013,11 @@ var anchorResolveCommand = define({
     const unreachable = results.filter(
       (entry) => isUncheckedReason(entry.reason)
     ).length;
-    const checked = results.length - unreachable;
     const matches3 = results.filter((entry) => entry.state === "match").length;
-    const note = `${matches3}/${checked} anchors match${unreachable ? `, ${unreachable} unreachable` : ""}`;
-    const clean = checked > 0 && matches3 === checked && unreachable === 0;
-    if (clean) {
-      try {
-        await store.verify(
-          path,
-          id,
-          `anchor-resolve: ${note} (${resolverSummary(results)})`,
-          actor,
-          now()
-        );
-      } catch (error) {
-        if (!(error instanceof KbSelfVerificationError)) throw error;
-        return {
-          conceptId: id,
-          results,
-          verified: false,
-          verifyRefused: "self-verification",
-          ...frozenNote,
-          ...hintNote
-        };
-      }
-      return {
-        conceptId: id,
-        results,
-        verified: true,
-        ...frozenNote,
-        ...hintNote
-      };
-    }
+    const note = `${matches3}/${results.length - unreachable} anchors match, ${unreachable} unreachable`;
     return {
       conceptId: id,
       results,
-      verified: false,
       ...unreachable ? { note } : {},
       ...frozenNote,
       ...hintNote
@@ -5930,14 +6104,117 @@ async function readSources(anchors, root, offline) {
   return sources;
 }
 
-// src/commands/answer.ts
+// src/commands/anchor-set/model.ts
 var import_zod10 = require("zod");
+var anchorSetInputSchema = import_zod10.z.object({
+  reason: import_zod10.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_zod10.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_zod10.z.object({
+  bundlePath,
+  conceptId,
+  input: anchorSetInputSchema,
+  resolve: import_zod10.z.boolean().optional().describe(
+    "Also resolve and stamp every anchor against the current code, as anchor-resolve --rebaseline does."
+  ),
+  repoRoot: import_zod10.z.string().min(1).optional().describe(
+    "Where the anchored source lives, for resolve. Defaults to the working directory."
+  ),
+  offline: import_zod10.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 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
+    );
+    const changes = applied?.changes ?? [];
+    if (!resolve7) {
+      return {
+        conceptId: id,
+        reason: input.reason,
+        changes,
+        anchors: record.frontmatter.strauss_anchors ?? [],
+        baseline: "unchanged",
+        note: NOTE
+      };
+    }
+    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);
+    return {
+      conceptId: id,
+      reason: input.reason,
+      changes,
+      anchors: after?.frontmatter.strauss_anchors ?? [],
+      baseline: "stamped",
+      resolved: resolved.results,
+      note: STAMPED_NOTE
+    };
+  },
+  // With `resolve`, a pointer that names nothing is a failed set, not a
+  // finding to read later. A remote nothing could reach was never checked, so
+  // it does not fail — the same line anchor-resolve draws.
+  failsWhen: (result) => (result.resolved ?? []).some((entry) => {
+    const { state, reason } = entry;
+    return state === "unresolved" && !isUncheckedReason(reason);
+  })
+});
+
+// src/commands/answer.ts
+var import_zod11 = 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_zod11.z.object({ bundlePath, conceptId, answer: import_zod11.z.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -5951,27 +6228,27 @@ var answerCommand = define({
 });
 
 // src/commands/backlinks.ts
-var import_zod11 = require("zod");
+var import_zod12 = 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_zod12.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_zod13 = 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_zod13.z.object({
     bundlePath,
-    type: import_zod12.z.enum(KB_RECORD_TYPES).optional(),
+    type: import_zod13.z.enum(KB_RECORD_TYPES).optional(),
     tags: TAGS
   }),
   fromArgv: (argv, path) => {
@@ -6043,7 +6320,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_zod16 = require("zod");
 
 // src/drift/moved.ts
 var import_promises9 = require("fs/promises");
@@ -6380,7 +6657,7 @@ function claimOf(record) {
 }
 
 // src/commands/match/command.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 
 // src/commands/match/errors.ts
 var KbMatchInputError = class extends BaseError {
@@ -6400,21 +6677,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_zod14 = require("zod");
+var diffHunkSchema = import_zod14.z.object({
+  startLine: import_zod14.z.number().int().positive(),
+  endLine: import_zod14.z.number().int().positive(),
+  side: import_zod14.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_zod14.z.object({
+  filePath: import_zod14.z.string().min(1).describe("Repo-relative, spelled the way anchors are."),
+  hunks: import_zod14.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_zod14.z.object({
+  file: import_zod14.z.string().min(1),
+  symbol: import_zod14.z.string().min(1),
+  startLine: import_zod14.z.number().int().positive(),
+  endLine: import_zod14.z.number().int().positive()
 });
 
 // src/commands/match/parse-unified-diff.ts
@@ -6663,17 +6940,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_zod15.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_zod15.z.array(diffFileSchema).describe("The changed files, each with its post-change line ranges."),
+    symbolRanges: import_zod15.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_zod15.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_zod15.z.boolean().optional().describe(
       "Return superseded, rejected and unsettled records too, each carrying its standing."
     )
   }),
@@ -6687,11 +6964,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(
@@ -6777,22 +7054,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_zod16.z.array(
+    diffHunkSchema.extend({ lines: import_zod16.z.array(import_zod16.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_zod16.z.string().min(1).optional().describe("Where `git diff -M` says the path came from."),
+  similarity: import_zod16.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_zod16.z.object({
     bundlePath,
-    files: import_zod15.z.array(classifyFileSchema).describe("The changed files, each with its line ranges."),
+    files: import_zod16.z.array(classifyFileSchema).describe("The changed files, each with its line ranges."),
     repoRoot: REPO_ROOT,
-    offline: import_zod15.z.boolean().optional().describe(
+    offline: import_zod16.z.boolean().optional().describe(
       "Resolve symbol ranges from what is already on disk, never fetching a grammar."
     )
   }),
@@ -6805,15 +7082,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
         })
@@ -6903,29 +7180,29 @@ function renderClassify(result) {
 }
 
 // src/commands/context.ts
-var import_zod16 = require("zod");
+var import_zod17 = 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_zod17.z.object({
+    budgetTokens: import_zod17.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_zod17.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_zod17.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_zod17.z.array(import_zod17.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_zod17.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_zod17.z.string().optional().describe(
       "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
     )
   }),
@@ -6964,20 +7241,20 @@ var contextCommand = define({
 });
 
 // src/commands/doctor.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 
 // src/commands/reassess.ts
-var import_zod17 = require("zod");
+var import_zod18 = 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_zod18.z.object({
     bundlePath,
     conceptId,
     repoRoot: REPO_ROOT,
-    withDiff: import_zod17.z.boolean().optional().describe(
+    withDiff: import_zod18.z.boolean().optional().describe(
       "Recover each anchor's committed span and render the diff. Reads git history."
     )
   }),
@@ -7122,13 +7399,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_zod19.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_zod19.z.object({
     bundlePath,
     repoRoot: REPO_ROOT,
     expiringDays: days(
@@ -7143,16 +7420,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_zod19.z.boolean().optional().describe(
       "Read foreign anchors from the local repo cache only, never fetching."
     ),
-    strict: import_zod18.z.boolean().optional().describe(
+    strict: import_zod19.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_zod19.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_zod19.z.boolean().optional().describe(
       "With `drifted`: recover each anchor's committed span and render the old-vs-new diff. Reads git history."
     )
   }),
@@ -7329,7 +7606,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_zod20 = require("zod");
 var NUMBERED = /^(\d{4})-(.+)\.md$/;
 var MARKER = "<!-- strauss-kb export: ";
 var exportCommand = define({
@@ -7337,10 +7614,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_zod20.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_zod20.z.enum(["madr"]).describe("Output layout. `madr` is the only one so far."),
+    to: import_zod20.z.string().min(1).describe("Directory the ADR files are written into.")
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -7462,19 +7739,19 @@ function bodySections(body) {
 }
 
 // src/commands/impact.ts
-var import_zod20 = require("zod");
+var import_zod21 = 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_zod21.z.object({
     bundlePath,
     conceptId,
-    depth: import_zod20.z.number().int().positive().optional().describe(
+    depth: import_zod21.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_zod21.z.array(import_zod21.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."
     )
   }),
@@ -7495,15 +7772,15 @@ var impactCommand = define({
 });
 
 // src/commands/list.ts
-var import_zod21 = require("zod");
+var import_zod22 = 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_zod22.z.object({
     bundlePath,
-    type: import_zod21.z.enum(KB_RECORD_TYPES).optional(),
+    type: import_zod22.z.enum(KB_RECORD_TYPES).optional(),
     tags: TAGS
   }),
   fromArgv: (argv, path) => {
@@ -7527,17 +7804,17 @@ var listCommand = define({
 });
 
 // src/commands/load.ts
-var import_zod22 = require("zod");
+var import_zod23 = 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_zod23.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_zod23.z.enum(KB_RECORD_TYPES).optional(),
+    budgetTokens: import_zod23.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
+    all: import_zod23.z.boolean().optional().describe(
       "Loads the entire base regardless of size, bypassing the token budget; mutually exclusive with budgetTokens."
     ),
     repoRoot: REPO_ROOT
@@ -7579,25 +7856,25 @@ var loadCommand = define({
 });
 
 // src/commands/log.ts
-var import_zod23 = require("zod");
+var import_zod24 = 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_zod24.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_zod25 = 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_zod25.z.object({ bundlePath, reason: import_zod25.z.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     reason: argv.slice(1).join(" ").trim()
@@ -7614,20 +7891,20 @@ var noDecisionCommand = define({
 });
 
 // src/commands/pack.ts
-var import_zod25 = require("zod");
+var import_zod26 = 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_zod26.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_zod26.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
+    maxNodes: import_zod26.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_zod26.z.number().int().positive().optional().describe(
       "Approximate token ceiling over what is actually emitted. Defaults to 25000."
     )
   }),
@@ -7714,22 +7991,22 @@ function warningLabel(warning) {
 }
 
 // src/commands/pin.ts
-var import_zod26 = require("zod");
+var import_zod27 = 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_zod27.z.object({
     bundlePath,
-    mode: import_zod26.z.enum(["full", "index"]).optional().describe(
+    mode: import_zod27.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_zod27.z.array(import_zod27.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
+    layer: import_zod27.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_zod27.z.boolean().optional().describe(
       "true: the base is concluded \u2014 writes against it refuse while pinned. false: lift a freeze."
     )
   }),
@@ -7758,13 +8035,13 @@ var pinCommand = define({
 });
 
 // src/commands/pins.ts
-var import_zod27 = require("zod");
+var import_zod28 = 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_zod28.z.object({}),
   fromArgv: () => ({}),
   run: ({ store }) => listPins(store, process.cwd())
 });
@@ -7900,16 +8177,16 @@ function recordType(conceptId2) {
 }
 
 // src/commands/promote/model.ts
-var import_zod28 = require("zod");
-var promoteInputSchema = import_zod28.z.object({
+var import_zod29 = require("zod");
+var promoteInputSchema = import_zod29.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_zod29.z.array(conceptId).max(64).optional().describe("Records to copy into the target base. Omit with `list`."),
+  to: import_zod29.z.string().min(1).optional().describe("Absolute path to the base being promoted into."),
+  source: import_zod29.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_zod29.z.boolean().optional().describe("Overwrite a record the target base already holds."),
+  list: import_zod29.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"]
@@ -8046,17 +8323,17 @@ function renderPromote(result) {
 }
 
 // src/commands/query.ts
-var import_zod29 = require("zod");
+var import_zod30 = 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_zod30.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_zod30.z.string().optional(),
+    type: import_zod30.z.enum(KB_RECORD_TYPES).optional(),
+    includeNonCurrent: import_zod30.z.boolean().optional(),
     tags: TAGS,
     repoRoot: REPO_ROOT
   }),
@@ -8090,43 +8367,43 @@ var queryCommand = define({
 });
 
 // src/commands/read-index.ts
-var import_zod30 = require("zod");
+var import_zod31 = 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_zod31.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_zod32 = 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_zod32.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(kbJsonSchemas())
 });
 
 // src/commands/stamp.ts
 var import_promises12 = require("fs/promises");
-var import_zod32 = require("zod");
+var import_zod33 = 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_zod33.z.object({
+    bundlePath: import_zod33.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_zod33.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."
     )
   }),
@@ -8212,16 +8489,16 @@ async function readBaseline(since) {
 }
 
 // src/commands/status.ts
-var import_zod33 = require("zod");
+var import_zod34 = 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_zod34.z.object({
     bundlePath,
     conceptId,
-    status: import_zod33.z.enum(KB_RECORD_STATUSES)
+    status: import_zod34.z.enum(KB_RECORD_STATUSES)
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -8236,13 +8513,13 @@ var statusCommand = define({
 });
 
 // src/commands/supersede.ts
-var import_zod34 = require("zod");
+var import_zod35 = 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_zod35.z.object({ bundlePath, conceptId, replacementId: conceptId }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -8256,7 +8533,7 @@ var supersedeCommand = define({
 });
 
 // src/commands/sweep.ts
-var import_zod35 = require("zod");
+var import_zod36 = require("zod");
 var TERMINAL = [
   "resolved",
   "rejected",
@@ -8267,15 +8544,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_zod36.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_zod36.z.string({ error: "sweep needs --tag: it never sweeps a whole base" }).min(1).describe("Only records carrying this tag are considered."),
+    terminal: import_zod36.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_zod36.z.boolean().optional().describe("Report what would go, and delete nothing.")
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -8392,16 +8669,16 @@ function renderSweep(result) {
 }
 
 // src/commands/sync-instructions.ts
-var import_zod36 = require("zod");
+var import_zod37 = 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_zod37.z.object({
+    file: import_zod37.z.string().min(1).describe("The instruction file to edit in place."),
+    budgetTokens: import_zod37.z.number().int().positive().optional(),
+    fullUnderTokens: import_zod37.z.number().int().positive().optional(),
+    profile: import_zod37.z.string().optional()
   }),
   fromArgv: (argv) => {
     const budget = argvFlag(argv, "--budget");
@@ -8427,17 +8704,17 @@ var syncInstructionsCommand = define({
 });
 
 // src/commands/trace.ts
-var import_zod37 = require("zod");
+var import_zod38 = 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_zod38.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_zod38.z.array(import_zod38.z.enum(TRACE_EDGES)).optional(),
+    depth: import_zod38.z.number().int().positive().optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -8459,37 +8736,37 @@ var traceCommand = define({
 });
 
 // src/commands/types.ts
-var import_zod38 = require("zod");
+var import_zod39 = 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_zod39.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(RECORD_TYPES)
 });
 
 // src/commands/unpin.ts
-var import_zod39 = require("zod");
+var import_zod40 = 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_zod40.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_zod41 = 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_zod41.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.
@@ -8499,16 +8776,16 @@ var validateCommand = define({
 });
 
 // src/commands/verify.ts
-var import_zod41 = require("zod");
+var import_zod42 = 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_zod42.z.object({
     bundlePath,
     conceptId,
-    note: import_zod41.z.string().refine((s) => s.trim().length > 0, {
+    note: import_zod42.z.string().refine((s) => s.trim().length > 0, {
       message: "note must say what the check found"
     })
   }),
@@ -8528,15 +8805,15 @@ var verifyCommand = define({
 });
 
 // src/commands/write.ts
-var import_zod42 = require("zod");
+var import_zod43 = 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_zod43.z.object({
     bundlePath,
-    type: import_zod42.z.enum(KB_RECORD_TYPES),
+    type: import_zod43.z.enum(KB_RECORD_TYPES),
     input: composeInputSchema
   }),
   fromArgv: async (argv, path, stdin) => ({
@@ -8560,13 +8837,13 @@ var writeCommand = define({
 });
 
 // src/commands/write-decision.ts
-var import_zod43 = require("zod");
+var import_zod44 = 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_zod44.z.object({ bundlePath, input: decisionInputSchema }),
   fromArgv: async (_argv, path, stdin) => ({
     bundlePath: path,
     input: JSON.parse(await stdin())
@@ -8596,6 +8873,7 @@ var KB_COMMANDS = [
   answerCommand,
   verifyCommand,
   anchorResolveCommand,
+  anchorSetCommand,
   reassessCommand,
   promoteCommand,
   loadCommand,
@@ -8632,7 +8910,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.20" : "0.0.0-dev";
+var VERSION = true ? "0.1.22" : "0.0.0-dev";
 
 // src/mcp.ts
 function createKbMcpServer() {
@@ -8813,6 +9091,7 @@ function usage() {
   KB_RECORD_STATUSES,
   KB_RECORD_TYPES,
   KB_SLUG_PATTERN,
+  KbAnchorSetDuplicateError,
   KbBaseFrozenError,
   KbClassifyInputError,
   KbInvalidConceptIdError,
@@ -8843,6 +9122,8 @@ function usage() {
   adjudicate,
   anchorFilePath,
   anchorOnHunk,
+  anchorSetInputSchema,
+  applyAnchorSet,
   assertBaseNotFrozen,
   backlinks,
   buildContext,
@@ -8876,19 +9157,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,