@saasontools/strauss-kb 0.1.11 → 0.1.13

package/dist/cli-main.cjs

@@ -78,6 +78,10 @@ var kbAnchorSchema = import_zod.z.object({
   /** Line count of the text the hash was taken over. */
   lines: import_zod.z.number().int().positive().optional()
 }).strict();
+var kbLinkSchema = import_zod.z.object({
+  target: import_zod.z.string().min(1),
+  rel: import_zod.z.string().min(1)
+}).passthrough();
 var KB_RECORD_TYPES = [
   "fact",
   "requirement",
@@ -129,6 +133,10 @@ var kbRecordFrontmatterSchema = import_zod.z.object({
   // strauss extensions — see the module comment.
   strauss_anchors: import_zod.z.array(kbAnchorSchema).optional(),
   strauss_verify: import_zod.z.array(import_zod.z.string().min(1)).optional(),
+  // Typed causal edges, source → target, living on the source. `A depends_on
+  // B` means A needs B, so `kb_impact` walks these inbound: what breaks if B
+  // changes is whatever declared a dependence on it.
+  strauss_links: import_zod.z.array(kbLinkSchema).optional(),
   // Total after parsing, tolerant before it. Our producers must supply a
   // status — an absent one would leave every reader inventing its own default
   // — but OKF calls a concept carrying only `type` fully conformant, so
@@ -213,8 +221,70 @@ var RECORD_TYPES = {
 function isKbRecordType(value) {
   return Object.prototype.hasOwnProperty.call(RECORD_TYPES, value);
 }
+var KB_LINK_RELS = [
+  "depends_on",
+  "constrains",
+  "informs",
+  "blocks",
+  "invalidates",
+  "verified_by",
+  "satisfies",
+  "related_to"
+];
+var LINK_RELS = {
+  depends_on: {
+    purpose: "The source needs the target to hold; the source breaks if the target changes",
+    phrase: "Depends on",
+    dependant: "source"
+  },
+  constrains: {
+    purpose: "The source bounds what the target may do; the target breaks if the constraint changes",
+    phrase: "Constrains",
+    dependant: "target"
+  },
+  informs: {
+    purpose: "The source shaped the target without binding it; the target is what needs revisiting",
+    phrase: "Informs",
+    dependant: "target"
+  },
+  blocks: {
+    purpose: "The target cannot proceed until the source is settled; the target is what waits",
+    phrase: "Blocks",
+    dependant: "target"
+  },
+  invalidates: {
+    purpose: "The source makes the target no longer hold; the target is what stops holding",
+    phrase: "Invalidates",
+    dependant: "target"
+  },
+  verified_by: {
+    purpose: "The target is the check that confirms the source; the source's confirmation moves with it",
+    phrase: "Verified by",
+    dependant: "source"
+  },
+  satisfies: {
+    purpose: "The source discharges the target's requirement; the source must change if the requirement does",
+    phrase: "Satisfies",
+    dependant: "source"
+  },
+  related_to: {
+    purpose: "A pointer worth following, with no claim of dependence",
+    phrase: "Relates to",
+    dependant: null
+  }
+};
+var KB_CAUSAL_LINK_RELS = KB_LINK_RELS.filter(
+  (rel) => LINK_RELS[rel].dependant !== null
+);
+function isKbLinkRel(value) {
+  return Object.prototype.hasOwnProperty.call(LINK_RELS, value);
+}
 
 // src/compose.ts
+var composeLinkSchema = import_zod2.z.object({
+  target: kbConceptIdSchema,
+  rel: import_zod2.z.enum(KB_LINK_RELS)
+}).strict();
 var composeInputSchema = import_zod2.z.object({
   slug: import_zod2.z.string().min(1),
   /** One line, in the reader's terms. Becomes OKF `title`. */
@@ -241,6 +311,18 @@ var composeInputSchema = import_zod2.z.object({
   tags: import_zod2.z.array(import_zod2.z.string().min(1)).optional(),
   /** Concept ids this record relates to; rendered as body links. */
   relatedConceptIds: import_zod2.z.array(kbConceptIdSchema).optional(),
+  /**
+   * Typed causal edges, source → target: `{ target: "fact.b", rel:
+   * "depends_on" }` on record A says A needs B. Stored in frontmatter and
+   * also rendered as one prose sentence each, so the meaning survives a
+   * reader that knows only OKF. The vocabulary goes into the description from
+   * the same table the walk uses, so `kb_schema` emits it.
+   */
+  links: import_zod2.z.array(composeLinkSchema).max(64).optional().describe(
+    `Typed causal edges, source \u2192 target \u2014 a link on this record says this record <rel> the target. ${KB_LINK_RELS.map(
+      (rel) => `${rel}: ${LINK_RELS[rel].purpose}`
+    ).join("; ")}.`
+  ),
   /** Concept ids this record replaces. The store settles the backlinks. */
   supersedes: import_zod2.z.array(kbConceptIdSchema).max(32).optional(),
   materiality: import_zod2.z.enum(KB_MATERIALITIES).optional(),
@@ -280,6 +362,15 @@ function composeRecord(type, input, writtenBy, writtenAt) {
   if (parsed.owner) frontmatter.strauss_owner = parsed.owner;
   if (parsed.supersedes?.length)
     frontmatter.strauss_supersedes = parsed.supersedes;
+  const selfLink = parsed.links?.find(
+    (link2) => link2.target === `${type}.${parsed.slug}`
+  );
+  if (selfLink) {
+    throw new Error(
+      `kb: ${type}.${parsed.slug} cannot ${selfLink.rel} itself \u2014 a link must name another record`
+    );
+  }
+  if (parsed.links?.length) frontmatter.strauss_links = parsed.links;
   const blocks = [];
   for (const heading of spec.sections) {
     const text = sections[heading];
@@ -291,6 +382,11 @@ ${text}`);
   for (const related of parsed.relatedConceptIds ?? []) {
     blocks.push(`Relates to [${related}](${related}.md).`);
   }
+  for (const link2 of parsed.links ?? []) {
+    blocks.push(
+      `${LINK_RELS[link2.rel].phrase} [${link2.target}](${link2.target}.md).`
+    );
+  }
   if (parsed.sources?.length) {
     blocks.push(
       parsed.sources.map((source) => `[^${source.id}]: ${source.title ?? source.resource}`).join("\n")
@@ -313,7 +409,7 @@ var decisionInputSchema = composeInputSchema.omit({ sections: true }).extend({
   impact: import_zod3.z.string().min(1).optional()
 }).strict();
 function composeDecisionRecord(input, writtenBy, writtenAt) {
-  const { alternative, impact, ...rest } = input;
+  const { alternative, impact: impact2, ...rest } = input;
   return composeRecord(
     DECISION_TYPE,
     {
@@ -322,7 +418,7 @@ function composeDecisionRecord(input, writtenBy, writtenAt) {
         Decision: input.title,
         Rationale: input.why,
         ...alternative ? { Rejected: alternative } : {},
-        ...impact ? { Impact: impact } : {}
+        ...impact2 ? { Impact: impact2 } : {}
       }
     },
     writtenBy,
@@ -904,6 +1000,23 @@ var KbPackBudgetExceededError = class extends BaseError {
   budgetTokens;
   excluded;
 };
+var KbUnknownLinkRelError = class extends BaseError {
+  constructor(rel, expected) {
+    super({
+      message: `kb: ${rel} is not a rel a walk can follow \u2014 expected one of ${expected.join(", ")}`,
+      errorType: "KbUnknownLinkRel" /* KbUnknownLinkRel */,
+      code: 400,
+      fault: "User" /* User */,
+      retriable: false,
+      reportToUser: true,
+      details: { rel, expected: expected.join(", ") }
+    });
+    this.rel = rel;
+    this.expected = expected;
+  }
+  rel;
+  expected;
+};
 var KbMissingFlagValueError = class extends BaseError {
   constructor(flag) {
     super({
@@ -1435,8 +1548,20 @@ var answerCommand = define({
   }
 });
 
-// src/commands/catalog.ts
+// src/commands/backlinks.ts
 var import_zod8 = 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_zod8.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_zod9 = require("zod");
 
 // src/adjudicate.ts
 var STANDING = {
@@ -1596,9 +1721,9 @@ var catalogCommand = define({
   tool: "kb_catalog",
   usage: "catalog [type]",
   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_zod8.z.object({
+  input: import_zod9.z.object({
     bundlePath,
-    type: import_zod8.z.enum(KB_RECORD_TYPES).optional()
+    type: import_zod9.z.enum(KB_RECORD_TYPES).optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -1653,7 +1778,7 @@ function count(value, noun) {
 }
 
 // src/commands/context.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/kb-context.ts
 var import_promises3 = require("fs/promises");
@@ -1919,20 +2044,20 @@ var contextCommand = define({
   tool: "kb_context",
   usage: "context [--profile NAME] [--budget N] [--full-under N] [--format json] [--event NAME]",
   description: "The pinned-base index block, for injection at every context birth \u2014 startup, clear, resume, and after compaction. An index, not the content: concept ids, titles and standing, with the bodies left behind kb_load at the point of use. Emits nothing when nothing is pinned. Refuses with the list of bases and their sizes rather than truncating past its budget. Budgets resolve most-specific-first: explicit flags, then the workspace manifests' `context` tables (per profile, over their `default`), then the built-in profile (session-start, compact, turn), then package defaults \u2014 so a repo tunes its own numbers in .strauss/kb-pins.json without touching hook commands. Like kb_schema and kb_types this takes no bundlePath \u2014 it reads the workspace pin manifests, because which bases a session should see is workspace state, not a property of one base.",
-  input: import_zod9.z.object({
-    budgetTokens: import_zod9.z.number().int().positive().optional().describe(
+  input: import_zod10.z.object({
+    budgetTokens: import_zod10.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_zod9.z.number().int().positive().optional().describe(
+    fullUnderTokens: import_zod10.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_zod9.z.string().optional().describe(
+    profile: import_zod10.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."
     ),
-    format: import_zod9.z.enum(["markdown", "json"]).optional().describe(
+    format: import_zod10.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_zod9.z.string().optional().describe(
+    event: import_zod10.z.string().optional().describe(
       "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
     )
   }),
@@ -1968,11 +2093,12 @@ var contextCommand = define({
 });
 
 // src/commands/doctor.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 
 // src/kb-edges.ts
 var KB_EDGE_KINDS = [
   "body-link",
+  "typed-link",
   "supersession",
   "anchor",
   "source"
@@ -1981,10 +2107,11 @@ var BODY_LINK_TARGET = new RegExp(
   `\\]\\((${KB_CONCEPT_ID_PATTERN.source.replace(/^\^|\$$/g, "")})\\.md\\)`,
   "g"
 );
-function neighbours(from, bundle, kinds = KB_EDGE_KINDS) {
+var DEFAULT_TYPED_LINK_RELS = KB_LINK_RELS;
+function neighbours(from, bundle, kinds = KB_EDGE_KINDS, linkRels = DEFAULT_TYPED_LINK_RELS) {
   const found = /* @__PURE__ */ new Map();
   for (const kind of kinds) {
-    for (const record of edgeNeighbours(from, bundle, kind)) {
+    for (const record of edgeNeighbours(from, bundle, kind, linkRels)) {
       const existing = found.get(record.conceptId);
       if (existing) {
         if (!existing.via.includes(kind)) existing.via.push(kind);
@@ -1995,7 +2122,7 @@ function neighbours(from, bundle, kinds = KB_EDGE_KINDS) {
   }
   return [...found.values()];
 }
-function edgeNeighbours(from, bundle, kind) {
+function edgeNeighbours(from, bundle, kind, linkRels = DEFAULT_TYPED_LINK_RELS) {
   switch (kind) {
     // A link whose target is not in the bundle is legal per compose.ts —
     // records are routinely written before the ones they point at exist — so
@@ -2009,6 +2136,21 @@ function edgeNeighbours(from, bundle, kind) {
         (candidate) => candidate.conceptId !== from.conceptId && targets.has(candidate.conceptId)
       );
     }
+    // Outbound only, like `body-link`, and for the same reason: this is what
+    // the record declares about itself. A missing target is legal — the walk
+    // skips it, and `kb_validate` is what reports it as a warning. A rel
+    // outside `linkRels` is skipped too, which is how an unknown rel stays
+    // untraversable everywhere rather than one walk at a time.
+    case "typed-link": {
+      const allowed = new Set(linkRels);
+      const targets = new Set(
+        (from.frontmatter.strauss_links ?? []).filter((link2) => allowed.has(link2.rel)).map((link2) => link2.target)
+      );
+      if (!targets.size) return [];
+      return bundle.filter(
+        (candidate) => candidate.conceptId !== from.conceptId && targets.has(candidate.conceptId)
+      );
+    }
     // Both directions and both pointers: `supersede()` writes the pair, but a
     // hand-edit can leave one side behind, and a walk trusting one pointer
     // would miss a replacement the bundle openly declares.
@@ -2050,7 +2192,7 @@ function anchorsTouch(left, right) {
 function validateBundle(records) {
   const byId = new Map(records.map((record) => [record.conceptId, record]));
   const problems = [];
-  const report = (check, conceptId2, note) => problems.push({ check, conceptId: conceptId2, note });
+  const report = (check, conceptId2, note, severity = "error") => problems.push({ check, conceptId: conceptId2, note, severity });
   for (const record of records) {
     const { conceptId: conceptId2, frontmatter: fm } = record;
     if (!isKbRecordType(fm.type)) {
@@ -2074,6 +2216,36 @@ function validateBundle(records) {
         report("supersedes", conceptId2, `${old} is not marked superseded`);
       }
     }
+    for (const link2 of fm.strauss_links ?? []) {
+      if (!isKbLinkRel(link2.rel)) {
+        report(
+          "link_rel",
+          conceptId2,
+          `unknown rel "${link2.rel}" on link to ${link2.target} \u2014 expected one of ${KB_LINK_RELS.join(", ")}`
+        );
+      }
+      if (!KB_CONCEPT_ID_PATTERN.test(link2.target)) {
+        report(
+          "link_target",
+          conceptId2,
+          `target "${link2.target}" is not a valid concept id \u2014 expected <type>.<slug>, both kebab-case`
+        );
+      } else if (link2.target === conceptId2) {
+        report(
+          "link_target",
+          conceptId2,
+          `links to itself (${link2.rel})`,
+          "warning"
+        );
+      } else if (!byId.has(link2.target)) {
+        report(
+          "link_target",
+          conceptId2,
+          `target ${link2.target} is not in the bundle`,
+          "warning"
+        );
+      }
+    }
     if (fm.strauss_assumption && fm.sources?.length) {
       report("assumption", conceptId2, "marked an assumption but cites sources");
     }
@@ -2350,13 +2522,13 @@ function ageInDays(record, now) {
 }
 
 // src/commands/doctor.ts
-var days = (what, fallback) => import_zod10.z.number().int().positive().optional().describe(`${what} Defaults to ${fallback}.`);
+var days = (what, fallback) => import_zod11.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] [--strict]",
   description: "Read-only health sweep: expired, expiring, unverified, aging, orphaned, broken-supersession, superseded-but-cited, drifted anchors. Every group is reported even when empty; nothing is written or re-stamped. Use it when picking up a base you have not touched in a while; kb_validate only checks that pointers between records agree.",
-  input: import_zod10.z.object({
+  input: import_zod11.z.object({
     bundlePath,
     repoRoot: REPO_ROOT,
     expiringDays: days(
@@ -2371,7 +2543,7 @@ var doctorCommand = define({
       "How long a record may stay `open` or `proposed` before `aging` reports it, in days.",
       DEFAULT_AGING_DAYS
     ),
-    strict: import_zod10.z.boolean().optional().describe(
+    strict: import_zod11.z.boolean().optional().describe(
       "Turn an expired record into a non-zero exit for the CLI. No effect on the report itself."
     )
   }),
@@ -2446,14 +2618,47 @@ function render2(result) {
   return lines.join("\n");
 }
 
+// src/commands/impact.ts
+var import_zod12 = 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_zod12.z.object({
+    bundlePath,
+    conceptId,
+    depth: import_zod12.z.number().int().positive().optional().describe(
+      "Hops out from the record. Unbounded when omitted; a walk this cuts reports truncated: true."
+    ),
+    rels: import_zod12.z.array(import_zod12.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."
+    )
+  }),
+  fromArgv: (argv, path) => {
+    const depth = argvFlag(argv, "--depth");
+    const rels = argvFlag(argv, "--rels");
+    return {
+      bundlePath: path,
+      conceptId: argv[1],
+      ...depth ? { depth: Number(depth) } : {},
+      ...rels ? { rels: rels.split(",").filter(Boolean) } : {}
+    };
+  },
+  run: async ({ store }, { bundlePath: path, conceptId: id, depth, rels }) => store.impact(path, id, {
+    ...depth !== void 0 ? { depth } : {},
+    ...rels?.length ? { rels } : {}
+  })
+});
+
 // src/commands/list.ts
-var import_zod11 = require("zod");
+var import_zod13 = require("zod");
 var listCommand = define({
   name: "list",
   tool: "kb_list",
   usage: "list [type]",
   description: "Every record, optionally narrowed to one type. Use kb_query when you have a question; this is for enumerating.",
-  input: import_zod11.z.object({ bundlePath, type: import_zod11.z.enum(KB_RECORD_TYPES).optional() }),
+  input: import_zod13.z.object({ bundlePath, type: import_zod13.z.enum(KB_RECORD_TYPES).optional() }),
   fromArgv: (argv, path) => ({ bundlePath: path, type: argv[1] }),
   run: async ({ store }, { bundlePath: path, type }) => (await store.list(path, type)).map((record) => ({
     conceptId: record.conceptId,
@@ -2465,17 +2670,17 @@ var listCommand = define({
 });
 
 // src/commands/load.ts
-var import_zod12 = require("zod");
+var import_zod14 = require("zod");
 var loadCommand = define({
   name: "load",
   tool: "kb_load",
   usage: "load [type] [--budget N | --all] [--repo-root PATH]",
-  description: "Loads the whole knowledge base at once, each record with its standing. Superseded records arrive as stubs (name, replacement, date); rejected and open records arrive whole. Refuses past the token budget rather than truncating \u2014 call kb_catalog, then kb_pack on the record that matters, or narrow with `type`; kb_query for a lookup by wording. `all` bypasses the budget.",
-  input: import_zod12.z.object({
+  description: "Loads the whole knowledge base at once, each record with its standing. Superseded records arrive as stubs; rejected and open records arrive whole. Refuses past the token budget \u2014 call kb_catalog, kb_pack on it; `all` bypasses the budget. Never read record files directly. Cache-stable; `digest` is the base's content stamp \u2014 hooks use it to tell you when to reload.",
+  input: import_zod14.z.object({
     bundlePath,
-    type: import_zod12.z.enum(KB_RECORD_TYPES).optional(),
-    budgetTokens: import_zod12.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
-    all: import_zod12.z.boolean().optional().describe(
+    type: import_zod14.z.enum(KB_RECORD_TYPES).optional(),
+    budgetTokens: import_zod14.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
+    all: import_zod14.z.boolean().optional().describe(
       "Loads the entire base regardless of size, bypassing the token budget; mutually exclusive with budgetTokens."
     ),
     repoRoot: REPO_ROOT
@@ -2517,25 +2722,25 @@ var loadCommand = define({
 });
 
 // src/commands/log.ts
-var import_zod13 = require("zod");
+var import_zod15 = require("zod");
 var logCommand = define({
   name: "log",
   tool: "kb_log",
   usage: "log",
   description: "What touched what, and when. The only artifact here that cannot be reconstructed from the records, so malformed lines are reported rather than repaired.",
-  input: import_zod13.z.object({ bundlePath }),
+  input: import_zod15.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readLog(path)
 });
 
 // src/commands/no-decision.ts
-var import_zod14 = require("zod");
+var import_zod16 = require("zod");
 var noDecisionCommand = define({
   name: "no-decision",
   tool: "kb_no_decision",
   usage: "no-decision <reason...>",
   description: 'Claim in one sentence that there was nothing to decide. Gating on "did you write a decision?" rewards writing a junk one; gating on "did you answer?" does not, so silence has to be expressible. Idempotent \u2014 restating it is not a collision.',
-  input: import_zod14.z.object({ bundlePath, reason: import_zod14.z.string().min(1) }),
+  input: import_zod16.z.object({ bundlePath, reason: import_zod16.z.string().min(1) }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     reason: argv.slice(1).join(" ").trim()
@@ -2552,20 +2757,20 @@ var noDecisionCommand = define({
 });
 
 // src/commands/pack.ts
-var import_zod15 = require("zod");
+var import_zod17 = require("zod");
 var packCommand = define({
   name: "pack",
   tool: "kb_pack",
   usage: "pack <conceptId> [--hops N] [--max-nodes N] [--budget N]",
   description: "The bounded neighbourhood around one record: everything within `hops` of the root, ranked and cut to `maxNodes`, with every cut record named under Excluded \u2014 a named gap is knowable, a silent one is not. Prefer this over kb_load when the base is too large to hold whole and the work centres on one record; prefer it over kb_query when the question needs the governed neighbourhood \u2014 what was settled and what binds near this record \u2014 rather than a lookup by wording. Superseded records arrive as name, replacement and date stubs exactly as kb_load emits them: their bodies no longer hold, and kb_trace has the history. Refuses outright rather than truncating when the pack would exceed its token budget \u2014 a partial pack is indistinguishable from a complete one \u2014 reporting the record count and every already-cut id so the caller can lower hops or maxNodes, or raise the budget. The header carries the bundle, root, budget and a timestamp; everything below the header is byte-identical across runs over an unchanged base, so two packs can be diffed and a changed byte means changed knowledge. This tool (with kb_load, kb_query and kb_trace) is the only supported way to read a base; a raw file read bypasses supersession resolution and returns replaced records as if current.",
-  input: import_zod15.z.object({
+  input: import_zod17.z.object({
     bundlePath,
     conceptId,
-    hops: import_zod15.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
-    maxNodes: import_zod15.z.number().int().positive().optional().describe(
+    hops: import_zod17.z.number().int().positive().optional().describe("How far from the root the walk may reach. Defaults to 2."),
+    maxNodes: import_zod17.z.number().int().positive().optional().describe(
       "How many records the pack may hold, root included. Defaults to 20."
     ),
-    budgetTokens: import_zod15.z.number().int().positive().optional().describe(
+    budgetTokens: import_zod17.z.number().int().positive().optional().describe(
       "Approximate token ceiling over what is actually emitted. Defaults to 25000."
     )
   }),
@@ -2652,22 +2857,22 @@ function warningLabel(warning) {
 }
 
 // src/commands/pin.ts
-var import_zod16 = require("zod");
+var import_zod18 = 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 pin manifest, so `context` surfaces it at every context birth. Three layers, nearest wins: the committed project manifest (.strauss/kb-pins.json, the default), `--local` (.strauss/kb-pins.local.json, personal and gitignored), and `--user` (~/.strauss/kb-pins.json, every workspace). Idempotent \u2014 re-pinning changes nothing unless --mode, --profiles, or --frozen/--unfreeze are given, which update just those fields. `--mode full` preloads the whole base into the block regardless of the full-under threshold; `--mode index` never upgrades. `--profiles` scopes the pin to named context profiles. `--frozen` marks the base concluded: write commands against it refuse and `context` labels it read-only. A path with no records yet succeeds with a warning; bases are routinely pinned before they are populated. Pins are workspace state: the pinned base itself is never touched.",
-  input: import_zod16.z.object({
+  input: import_zod18.z.object({
     bundlePath,
-    mode: import_zod16.z.enum(["full", "index"]).optional().describe(
+    mode: import_zod18.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_zod16.z.array(import_zod16.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
-    layer: import_zod16.z.enum(["project", "local", "user"]).optional().describe(
+    profiles: import_zod18.z.array(import_zod18.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
+    layer: import_zod18.z.enum(["project", "local", "user"]).optional().describe(
       "Which manifest to write: project (committed, default), local (personal, gitignored), user (~/.strauss, every workspace)."
     ),
-    frozen: import_zod16.z.boolean().optional().describe(
+    frozen: import_zod18.z.boolean().optional().describe(
       "true: the base is concluded \u2014 writes against it refuse while pinned. false: lift a freeze."
     )
   }),
@@ -2696,29 +2901,29 @@ var pinCommand = define({
 });
 
 // src/commands/pins.ts
-var import_zod17 = require("zod");
+var import_zod19 = require("zod");
 var pinsCommand = define({
   name: "pins",
   tool: "kb_pins",
   usage: "pins",
   description: "Every pinned base across the manifest layers, each with its layer and whether it currently resolves to readable records. Reads the workspace manifests rather than any one base, like kb_context.",
-  input: import_zod17.z.object({}),
+  input: import_zod19.z.object({}),
   fromArgv: () => ({}),
   run: ({ store }) => listPins(store, process.cwd())
 });
 
 // src/commands/query.ts
-var import_zod18 = require("zod");
+var import_zod20 = require("zod");
 var queryCommand = define({
   name: "query",
   tool: "kb_query",
   usage: "query <text...> [--repo-root PATH]",
-  description: "Search and return each match with its standing. Results are flagged, never filtered: a superseded record comes back alongside whatever replaced it, and a rejected one is marked as something explicitly not adopted. This is the lookup-by-wording rung, and the narrowest of the three: use it when you know roughly what the record says. The decision rule around it \u2014 while the base fits kb_load's token budget, kb_load it whole, because on this package's measurements a reader holding the whole base answered eight of nine questions whose wording appears in no record where embedding search answered four; once kb_load refuses, kb_catalog for one line per record and then kb_pack on the record the work centres on; and kb_query when the question is a point lookup rather than a neighbourhood. A query cannot tell you that nothing was decided \u2014 it returns its nearest hit whatever the distance \u2014 so reach for kb_catalog when the question is what exists. Never read record files directly: this tool (with kb_load, kb_catalog, kb_pack and kb_trace) is the only supported way to read a base; a file read bypasses supersession resolution and returns replaced records as if current.",
-  input: import_zod18.z.object({
+  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_zod20.z.object({
     bundlePath,
-    text: import_zod18.z.string().optional(),
-    type: import_zod18.z.enum(KB_RECORD_TYPES).optional(),
-    includeNonCurrent: import_zod18.z.boolean().optional(),
+    text: import_zod20.z.string().optional(),
+    type: import_zod20.z.enum(KB_RECORD_TYPES).optional(),
+    includeNonCurrent: import_zod20.z.boolean().optional(),
     repoRoot: REPO_ROOT
   }),
   // `--repo-root` is a flag, so its value must not fall into the search text.
@@ -2750,27 +2955,27 @@ var queryCommand = define({
 });
 
 // src/commands/read-index.ts
-var import_zod19 = require("zod");
+var import_zod21 = require("zod");
 var readIndexCommand = define({
   name: "index",
   tool: "kb_index",
   usage: "index",
   description: "The index, rebuilt if it disagrees with the records. One call gives the whole shape of the base: title, type, status, and description per record. The cheap re-orientation call after compaction or deep in a long session \u2014 a few hundred tokens; call it (or kb_context, when bases are pinned) first, then kb_load or fetch by concept id.",
-  input: import_zod19.z.object({ bundlePath }),
+  input: import_zod21.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: ({ store }, { bundlePath: path }) => store.readIndex(path)
 });
 
 // src/commands/schema.ts
-var import_zod22 = require("zod");
+var import_zod24 = require("zod");
 
 // src/json-schema.ts
-var import_zod21 = require("zod");
+var import_zod23 = require("zod");
 
 // src/kb-log.ts
-var import_zod20 = require("zod");
+var import_zod22 = require("zod");
 var LOG_FILE = "log.jsonl";
-var kbLogEntrySchema = import_zod20.z.object({
+var kbLogEntrySchema = import_zod22.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
@@ -2779,12 +2984,12 @@ var kbLogEntrySchema = import_zod20.z.object({
   // and rejects everything else, including a non-`Z` offset — so a
   // malformed `at` is reported the same way a malformed line already is,
   // rather than silently sorting into the wrong place.
-  at: import_zod20.z.iso.datetime(),
-  by: import_zod20.z.string().min(1),
-  operation: import_zod20.z.string().min(1),
-  conceptId: import_zod20.z.string().min(1),
+  at: import_zod22.z.iso.datetime(),
+  by: import_zod22.z.string().min(1),
+  operation: import_zod22.z.string().min(1),
+  conceptId: import_zod22.z.string().min(1),
   /** Second concept id, where the operation relates two — supersession. */
-  target: import_zod20.z.string().min(1).optional()
+  target: import_zod22.z.string().min(1).optional()
 }).strict();
 function renderLogEntry(entry) {
   return `${JSON.stringify(kbLogEntrySchema.parse(entry))}
@@ -2822,11 +3027,11 @@ function parseLog(raw) {
 // src/json-schema.ts
 function kbJsonSchemas() {
   return {
-    recordFrontmatter: import_zod21.z.toJSONSchema(kbRecordFrontmatterSchema, {
+    recordFrontmatter: import_zod23.z.toJSONSchema(kbRecordFrontmatterSchema, {
       io: "input"
     }),
-    composeInput: import_zod21.z.toJSONSchema(composeInputSchema, { io: "input" }),
-    logEntry: import_zod21.z.toJSONSchema(kbLogEntrySchema, { io: "input" })
+    composeInput: import_zod23.z.toJSONSchema(composeInputSchema, { io: "input" }),
+    logEntry: import_zod23.z.toJSONSchema(kbLogEntrySchema, { io: "input" })
   };
 }
 
@@ -2836,22 +3041,22 @@ var schemaCommand = define({
   tool: "kb_schema",
   usage: "schema",
   description: "JSON Schema for the frontmatter, the write input, and log entries \u2014 generated from the code that enforces them, so it cannot drift from what a write will accept.",
-  input: import_zod22.z.object({}),
+  input: import_zod24.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(kbJsonSchemas())
 });
 
 // src/commands/status.ts
-var import_zod23 = require("zod");
+var import_zod25 = require("zod");
 var statusCommand = define({
   name: "status",
   tool: "kb_status",
   usage: "status <concept-id> <status>",
   description: "Move a record's status, leaving everything else alone. Uses a compare-and-swap, so a concurrent change fails loudly rather than being overwritten.",
-  input: import_zod23.z.object({
+  input: import_zod25.z.object({
     bundlePath,
     conceptId,
-    status: import_zod23.z.enum(KB_RECORD_STATUSES)
+    status: import_zod25.z.enum(KB_RECORD_STATUSES)
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -2866,13 +3071,13 @@ var statusCommand = define({
 });
 
 // src/commands/supersede.ts
-var import_zod24 = require("zod");
+var import_zod26 = require("zod");
 var supersedeCommand = define({
   name: "supersede",
   tool: "kb_supersede",
   usage: "supersede <concept-id> <replacement-id>",
   description: "Mark a record superseded by another, linking both directions. Use this rather than editing a record whose meaning changed \u2014 a record that quietly becomes something else invalidates every reference to it, and the earlier understanding is what a later trace needs.",
-  input: import_zod24.z.object({ bundlePath, conceptId, replacementId: conceptId }),
+  input: import_zod26.z.object({ bundlePath, conceptId, replacementId: conceptId }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
     conceptId: argv[1],
@@ -2886,16 +3091,16 @@ var supersedeCommand = define({
 });
 
 // src/commands/sync-instructions.ts
-var import_zod25 = require("zod");
+var import_zod27 = require("zod");
 var syncInstructionsCommand = define({
   name: "sync-instructions",
   usage: "sync-instructions <file> [--profile NAME] [--budget N] [--full-under N]",
   description: "Idempotently plant the `context` block between sentinel comments in an instruction file (AGENTS.md, CLAUDE.md), creating the block when absent and leaving everything outside the sentinels alone. CLI-only: this is file plumbing for runtimes whose instruction files are re-read where their conversations are not, not an agent capability \u2014 the capability is kb_context.",
-  input: import_zod25.z.object({
-    file: import_zod25.z.string().min(1).describe("The instruction file to edit in place."),
-    budgetTokens: import_zod25.z.number().int().positive().optional(),
-    fullUnderTokens: import_zod25.z.number().int().positive().optional(),
-    profile: import_zod25.z.string().optional()
+  input: import_zod27.z.object({
+    file: import_zod27.z.string().min(1).describe("The instruction file to edit in place."),
+    budgetTokens: import_zod27.z.number().int().positive().optional(),
+    fullUnderTokens: import_zod27.z.number().int().positive().optional(),
+    profile: import_zod27.z.string().optional()
   }),
   fromArgv: (argv) => {
     const budget = argvFlag(argv, "--budget");
@@ -2921,10 +3126,15 @@ var syncInstructionsCommand = define({
 });
 
 // src/commands/trace.ts
-var import_zod26 = require("zod");
+var import_zod28 = require("zod");
 
 // src/trace.ts
-var TRACE_EDGES = ["supersession", "anchor", "source"];
+var TRACE_EDGES = [
+  "typed-link",
+  "supersession",
+  "anchor",
+  "source"
+];
 function trace(seedId, bundle, options = {}) {
   const edges = options.edges?.length ? options.edges : TRACE_EDGES;
   const maxDepth = options.depth ?? 3;
@@ -2939,7 +3149,12 @@ function trace(seedId, bundle, options = {}) {
     const next = [];
     for (const from of frontier) {
       for (const edge of edges) {
-        for (const record of edgeNeighbours(from, bundle, edge)) {
+        for (const record of edgeNeighbours(
+          from,
+          bundle,
+          edge,
+          KB_CAUSAL_LINK_RELS
+        )) {
           const existing = reached.get(record.conceptId);
           if (existing) {
             if (existing.depth > 0 && !existing.via.includes(edge)) {
@@ -2967,11 +3182,11 @@ var traceCommand = define({
   tool: "kb_trace",
   usage: "trace <concept-id> [edges...]",
   description: 'How a position was arrived at, as a timeline ordered by when each record was written. Deliberately includes rejected, draft, and superseded records \u2014 in a history those are the content, not noise. Follows supersession, shared code anchors, and shared sources. Use when the question is "why is this the way it is" rather than "what do we hold now". This tool (with kb_load and kb_query) is the only supported way to read a base; a raw file read bypasses supersession resolution and returns replaced records as if current.',
-  input: import_zod26.z.object({
+  input: import_zod28.z.object({
     bundlePath,
     conceptId,
-    edges: import_zod26.z.array(import_zod26.z.enum(TRACE_EDGES)).optional(),
-    depth: import_zod26.z.number().int().positive().optional()
+    edges: import_zod28.z.array(import_zod28.z.enum(TRACE_EDGES)).optional(),
+    depth: import_zod28.z.number().int().positive().optional()
   }),
   fromArgv: (argv, path) => ({
     bundlePath: path,
@@ -2993,53 +3208,56 @@ var traceCommand = define({
 });
 
 // src/commands/types.ts
-var import_zod27 = require("zod");
+var import_zod29 = 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_zod27.z.object({}),
+  input: import_zod29.z.object({}),
   fromArgv: () => ({}),
   run: () => Promise.resolve(RECORD_TYPES)
 });
 
 // src/commands/unpin.ts
-var import_zod28 = require("zod");
+var import_zod30 = require("zod");
 var unpinCommand = define({
   name: "unpin",
   tool: "kb_unpin",
   usage: "unpin [bundle-path]",
   description: "Remove a base from every pin manifest layer that holds it \u2014 project, local, and user \u2014 because unpinned means gone, not still injected from another file. Reports which layers were touched.",
-  input: import_zod28.z.object({ bundlePath }),
+  input: import_zod30.z.object({ bundlePath }),
   fromArgv: (argv, path) => ({ bundlePath: argv[1] ?? path }),
   run: (_ctx, { bundlePath: path }) => unpinBase(process.cwd(), path)
 });
 
 // src/commands/validate.ts
-var import_zod29 = require("zod");
+var import_zod31 = 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, and assumptions that cite sources. Per-record shape is enforced on every read, so a problem here means someone edited a file by hand.",
-  input: import_zod29.z.object({ bundlePath }),
+  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_zod31.z.object({ bundlePath }),
   fromArgv: (_argv, path) => ({ bundlePath: path }),
   run: async ({ store }, { bundlePath: path }) => validateBundle(await store.list(path)),
-  failsWhen: (result) => Array.isArray(result) && result.length > 0
+  // Warnings never fail the exit code; every other severity does.
+  failsWhen: (result) => Array.isArray(result) && result.some(
+    (problem) => problem.severity !== "warning"
+  )
 });
 
 // src/commands/verify.ts
-var import_zod30 = require("zod");
+var import_zod32 = require("zod");
 var verifyCommand = define({
   name: "verify",
   tool: "kb_verify",
   usage: "verify <concept-id> --note <text>",
   description: "Append one verified[] event \u2014 who checked the record, when, and what the check found. Appends only; prior events are never rewritten. A record's own generator is refused unless the actor is human: re-reading your own output is not an independent check.",
-  input: import_zod30.z.object({
+  input: import_zod32.z.object({
     bundlePath,
     conceptId,
-    note: import_zod30.z.string().refine((s) => s.trim().length > 0, {
+    note: import_zod32.z.string().refine((s) => s.trim().length > 0, {
       message: "note must say what the check found"
     })
   }),
@@ -3059,7 +3277,7 @@ var verifyCommand = define({
 });
 
 // src/commands/write.ts
-var import_zod31 = require("zod");
+var import_zod33 = require("zod");
 var writeCommand = define({
   name: "write",
   tool: "kb_write",
@@ -3073,9 +3291,9 @@ var writeCommand = define({
     "- Prefer a new record over overloading an existing one, and keep each short. A record nobody finishes reading is not durable memory.",
     "- Records are never deleted; supersede instead, so the earlier reasoning stays inspectable."
   ].join("\n"),
-  input: import_zod31.z.object({
+  input: import_zod33.z.object({
     bundlePath,
-    type: import_zod31.z.enum(KB_RECORD_TYPES),
+    type: import_zod33.z.enum(KB_RECORD_TYPES),
     input: composeInputSchema
   }),
   fromArgv: async (argv, path, stdin) => ({
@@ -3099,7 +3317,7 @@ var writeCommand = define({
 });
 
 // src/commands/write-decision.ts
-var import_zod32 = require("zod");
+var import_zod34 = require("zod");
 var writeDecisionCommand = define({
   name: "write-decision",
   tool: "kb_write_decision",
@@ -3112,7 +3330,7 @@ var writeDecisionCommand = define({
     "- `alternative` is what you turned down and why, not a list of everything considered.",
     "- A reference to material you read goes in `sources`; a reference to code goes in `anchors`; a reference to another record goes in `relatedConceptIds`."
   ].join("\n"),
-  input: import_zod32.z.object({ bundlePath, input: decisionInputSchema }),
+  input: import_zod34.z.object({ bundlePath, input: decisionInputSchema }),
   fromArgv: async (_argv, path, stdin) => ({
     bundlePath: path,
     input: JSON.parse(await stdin())
@@ -3147,6 +3365,8 @@ var KB_COMMANDS = [
   packCommand,
   queryCommand,
   traceCommand,
+  impactCommand,
+  backlinksCommand,
   listCommand,
   readIndexCommand,
   logCommand,
@@ -3367,6 +3587,141 @@ function typeRank(record) {
   return index === -1 ? TYPE_PRIORITY.length : index;
 }
 
+// src/kb-links/inbound.ts
+function inboundIndex(bundle) {
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const record of bundle) {
+    for (const link2 of record.frontmatter.strauss_links ?? []) {
+      if (link2.target === record.conceptId) continue;
+      const edges = byTarget.get(link2.target) ?? [];
+      if (edges.some(
+        (edge) => edge.from === record.conceptId && edge.rel === link2.rel
+      )) {
+        continue;
+      }
+      edges.push({ from: record.conceptId, rel: link2.rel });
+      byTarget.set(link2.target, edges);
+    }
+  }
+  return byTarget;
+}
+
+// src/kb-links/backlinks.ts
+function backlinks(targetId, bundle) {
+  const byId = new Map(bundle.map((record) => [record.conceptId, record]));
+  if (!byId.has(targetId)) throw new KbRecordNotFoundError(targetId);
+  const standingOf = new Map(
+    adjudicate(bundle, bundle).map((hit) => [hit.record.conceptId, hit])
+  );
+  const rows = [];
+  for (const edge of inboundIndex(bundle).get(targetId) ?? []) {
+    const record = byId.get(edge.from);
+    if (!record) continue;
+    const hit = standingOf.get(edge.from);
+    rows.push({
+      ...edge,
+      title: record.frontmatter.title ?? null,
+      standing: hit?.standing ?? "unsettled",
+      warnings: hit?.warnings ?? []
+    });
+  }
+  return {
+    target: targetId,
+    backlinks: rows.sort(
+      (left, right) => left.from.localeCompare(right.from) || left.rel.localeCompare(right.rel)
+    )
+  };
+}
+
+// src/kb-links/impact.ts
+function impact(targetId, bundle, options = {}) {
+  const byId = new Map(bundle.map((record) => [record.conceptId, record]));
+  if (!byId.has(targetId)) throw new KbRecordNotFoundError(targetId);
+  const rels = resolveRels(options.rels);
+  const maxDepth = options.depth ?? Number.POSITIVE_INFINITY;
+  const inbound = inboundIndex(bundle);
+  const standingOf = new Map(
+    adjudicate(bundle, bundle).map((hit) => [hit.record.conceptId, hit])
+  );
+  const reached = /* @__PURE__ */ new Map();
+  const stopped = [];
+  let frontier = [targetId];
+  let depth = 0;
+  while (frontier.length && depth < maxDepth) {
+    depth += 1;
+    const next = [];
+    const consider = (dependantId, edge) => {
+      if (dependantId === targetId) return;
+      const existing = reached.get(dependantId);
+      if (existing) {
+        if (!hasEdge(existing.via, edge)) existing.via.push(edge);
+        return;
+      }
+      const record = byId.get(dependantId);
+      if (!record) return;
+      const hit = standingOf.get(dependantId);
+      const entry = {
+        conceptId: dependantId,
+        title: record.frontmatter.title ?? null,
+        standing: hit?.standing ?? "unsettled",
+        warnings: hit?.warnings ?? [],
+        depth,
+        via: [edge]
+      };
+      reached.set(dependantId, entry);
+      if (entry.standing === "superseded" || entry.standing === "rejected") {
+        stopped.push(dependantId);
+        return;
+      }
+      next.push(dependantId);
+    };
+    for (const id of frontier) {
+      for (const edge of inbound.get(id) ?? []) {
+        if (!rels.has(edge.rel)) continue;
+        if (dependantEnd(edge.rel) !== "source") continue;
+        consider(edge.from, { source: edge.from, target: id, rel: edge.rel });
+      }
+      for (const link2 of byId.get(id)?.frontmatter.strauss_links ?? []) {
+        if (!rels.has(link2.rel)) continue;
+        if (dependantEnd(link2.rel) !== "target") continue;
+        if (link2.target === id) continue;
+        consider(link2.target, {
+          source: id,
+          target: link2.target,
+          rel: link2.rel
+        });
+      }
+    }
+    frontier = next;
+  }
+  return {
+    root: targetId,
+    impacted: [...reached.values()].sort(
+      (left, right) => left.depth - right.depth || left.conceptId.localeCompare(right.conceptId)
+    ),
+    stopped: stopped.sort(),
+    truncated: frontier.length > 0,
+    unexpanded: [...frontier].sort()
+  };
+}
+function resolveRels(rels) {
+  if (!rels?.length) return new Set(KB_CAUSAL_LINK_RELS);
+  for (const rel of rels) {
+    if (!isKbLinkRel(rel) || LINK_RELS[rel].dependant === null) {
+      throw new KbUnknownLinkRelError(rel, KB_CAUSAL_LINK_RELS);
+    }
+  }
+  return new Set(rels);
+}
+function dependantEnd(rel) {
+  return isKbLinkRel(rel) ? LINK_RELS[rel].dependant : null;
+}
+function hasEdge(edges, edge) {
+  return edges.some(
+    (existing) => existing.source === edge.source && existing.target === edge.target && existing.rel === edge.rel
+  );
+}
+
 // src/kb-gitattributes.ts
 var GITATTRIBUTES_FILE = ".gitattributes";
 var UNION_MERGE_LINE = `${LOG_FILE} text eol=lf merge=union`;
@@ -3733,6 +4088,7 @@ ${answer}
     const records = adjudicated.filter((hit) => hit.standing !== "superseded");
     const superseded = adjudicated.filter((hit) => hit.standing === "superseded").map(stub);
     const approxTokens2 = records.reduce((total, hit) => total + estimateTokens(hit.record), 0) + superseded.reduce((total, entry) => total + estimateStubTokens(entry), 0);
+    const bundleDigestValue = bundleDigest(records, superseded);
     if (!options.all && approxTokens2 > budgetTokens) {
       return {
         loaded: false,
@@ -3743,7 +4099,8 @@ ${answer}
           approxTokens: approxTokens2,
           budgetTokens,
           type: options.type
-        })
+        }),
+        digest: bundleDigestValue
       };
     }
     return {
@@ -3752,7 +4109,8 @@ ${answer}
       tokensLoaded: approxTokens2,
       budgetTokens: options.all ? null : budgetTokens,
       records,
-      superseded
+      superseded,
+      digest: bundleDigestValue
     };
   }
   /** How a position was arrived at, as a timeline. See `trace.ts`. */
@@ -3767,6 +4125,14 @@ ${answer}
   async pack(bundlePath2, rootId, options = {}) {
     return pack(await this.list(bundlePath2), rootId, options);
   }
+  /** What breaks if this record changes. See `kb-links/impact.ts`. */
+  async impact(bundlePath2, targetId, options = {}) {
+    return impact(targetId, await this.list(bundlePath2), options);
+  }
+  /** Who points at this record, one hop. See `kb-links/backlinks.ts`. */
+  async backlinks(bundlePath2, targetId) {
+    return backlinks(targetId, await this.list(bundlePath2));
+  }
   /**
    * The stored index, rebuilt if it disagrees with the records.
    *
@@ -4069,9 +4435,25 @@ function normalizeActor(id) {
 function digest(contents) {
   return (0, import_node_crypto2.createHash)("sha256").update(contents).digest("hex");
 }
+function bundleDigest(records, superseded) {
+  const entries = [
+    ...records.map(
+      (hit) => `${hit.record.conceptId}:current:${digest(
+        stringifyMarkdownWithFrontmatter(
+          hit.record.body,
+          hit.record.frontmatter
+        )
+      )}`
+    ),
+    ...superseded.map(
+      (entry) => `${entry.conceptId}:superseded:${digest(JSON.stringify(entry))}`
+    )
+  ].sort();
+  return digest(entries.join("\n"));
+}
 
 // src/version.ts
-var VERSION = true ? "0.1.11" : "0.0.0-dev";
+var VERSION = true ? "0.1.13" : "0.0.0-dev";
 
 // src/cli.ts
 async function runKbCli(argv) {