@saasontools/strauss-kb 0.1.12 → 0.1.13

package/dist/index.d.ts

@@ -71,6 +71,22 @@ declare const kbAnchorSchema: z.ZodObject<{
     resolved_at: z.ZodOptional<z.ZodString>;
     lines: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
+/**
+ * One typed causal edge, as the frontmatter stores it.
+ *
+ * Read-side, and therefore tolerant: `rel` is a plain string here even though
+ * the vocabulary is closed, for the same reason `type` is. Rejecting an unknown
+ * rel at parse time would make the file vanish from `list()`, and a bundle
+ * cannot report a defect in a record it refuses to load. `kb_validate` turns an
+ * unknown rel into an error; `composeRecord` stops one being written.
+ *
+ * `target` is likewise not required to resolve — a dangling target is a
+ * validation warning rather than a parse failure.
+ */
+declare const kbLinkSchema: z.ZodObject<{
+    target: z.ZodString;
+    rel: z.ZodString;
+}, z.core.$loose>;
 declare const KB_RECORD_TYPES: readonly ["fact", "requirement", "constraint", "decision", "assumption", "open-question", "risk", "contract", "flow", "affected-system", "test-obligation", "source-note"];
 type KbRecordType = (typeof KB_RECORD_TYPES)[number];
 /** Both halves of `<type>.<slug>` are kebab-case, and neither may be empty. */
@@ -126,6 +142,10 @@ declare const kbRecordFrontmatterSchema: z.ZodObject<{
         lines: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>>;
     strauss_verify: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    strauss_links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        target: z.ZodString;
+        rel: z.ZodString;
+    }, z.core.$loose>>>;
     strauss_status: z.ZodDefault<z.ZodEnum<{
         draft: "draft";
         proposed: "proposed";
@@ -158,6 +178,7 @@ type KbSource = z.infer<typeof kbSourceSchema>;
 type KbActorStamp = z.infer<typeof kbActorStampSchema>;
 type KbVerifiedEvent = z.infer<typeof kbVerifiedEventSchema>;
 type KbAnchor = z.infer<typeof kbAnchorSchema>;
+type KbLink = z.infer<typeof kbLinkSchema>;
 type KbRecordFrontmatter = z.infer<typeof kbRecordFrontmatterSchema>;
 type KbRecord = {
     /** Path minus `.md`, relative to the bundle root. OKF's concept identity. */
@@ -361,8 +382,19 @@ declare function resolveHeads(from: KbRecord, byId: Map<string, KbRecord>): {
  * suits a bounded pack but floods a timeline. Also absent by design:
  * `strauss_answered` carries no target id, so a question's resolution lives
  * in its own body rather than in another record.
+ *
+ * `typed-link` is in, where `body-link` is out, because the two differ in how
+ * cheaply they are made. A body link is any markdown a writer happened to
+ * type; a `strauss_links` entry is a deliberate claim from a closed vocabulary
+ * about what this record depends on. That is exactly the kind of edge a
+ * timeline should follow — "we chose this because of that" is the history.
+ *
+ * Only the causal rels, though. `related_to` asserts no dependence and reaches
+ * whatever a writer thought worth mentioning, which is the same flooding
+ * `body-link` is excluded for; a bibliography is a neighbourhood's business
+ * (`pack`), not a history's.
  */
-declare const TRACE_EDGES: readonly ["supersession", "anchor", "source"];
+declare const TRACE_EDGES: readonly ["typed-link", "supersession", "anchor", "source"];
 type KbTraceEdge = (typeof TRACE_EDGES)[number];
 type KbTraceStep = {
     record: KbRecord;
@@ -515,6 +547,105 @@ declare function catalog(bundle: KbRecord[], options?: {
  */
 declare function renderCatalogLine(entry: KbCatalogEntry): string;
 
+/**
+ * Types for the inbound half of the typed causal graph. `kb-edges.ts` answers
+ * "what does this record point at"; this module answers who is leaning on it,
+ * and what breaks if it moves.
+ */
+/** One inbound typed edge: `from --rel--> the record asked about`. */
+type KbInboundEdge = {
+    from: string;
+    /**
+     * A stored rel, not necessarily a known one, so a record carrying an
+     * unrecognised rel is reported rather than dropped from the answer.
+     */
+    rel: string;
+};
+/** One record pointing at the target, with the standing of what it claims. */
+type KbBacklink = KbInboundEdge & {
+    title: string | null;
+    standing: KbStanding;
+    warnings: KbWarning[];
+};
+type KbBacklinksResult = {
+    target: string;
+    /** Every inbound edge, whatever its rel. Ordered by source id, then rel. */
+    backlinks: KbBacklink[];
+};
+/**
+ * One typed edge as the impact walk traversed it, both ends named. The walk
+ * follows `depends_on` against the edge and `informs` along it, so a reader of
+ * `via` needs the edge as written, not as walked.
+ */
+type KbLinkEdge = {
+    source: string;
+    target: string;
+    rel: string;
+};
+type KbImpactOptions = {
+    /**
+     * Which rels the walk follows. Defaults to every rel that carries a
+     * direction of dependence. A rel outside that set — unknown, or the inert
+     * `related_to` — is refused rather than ignored.
+     */
+    rels?: readonly string[];
+    /**
+     * How many hops out to walk. Unbounded by default: a blast radius cut at a
+     * depth the caller did not choose looks like a small one.
+     */
+    depth?: number;
+};
+type KbImpactedRecord = {
+    conceptId: string;
+    title: string | null;
+    standing: KbStanding;
+    warnings: KbWarning[];
+    /** Hops from the record asked about. 1 is a direct dependant. */
+    depth: number;
+    /** Every edge that reached it, nearest first. */
+    via: KbLinkEdge[];
+};
+type KbImpactResult = {
+    root: string;
+    /** Ordered by depth, then concept id. Never includes the root itself. */
+    impacted: KbImpactedRecord[];
+    /**
+     * Reached, reported, and not walked through: records whose standing means
+     * their own declared edges no longer hold. Named rather than dropped, so the
+     * caller can see where the walk stopped.
+     */
+    stopped: string[];
+    /**
+     * Whether the depth cap ended the walk with dependants still to expand. A cut
+     * blast radius must say so, or it reads as a complete one that is small.
+     */
+    truncated: boolean;
+    /** The records the depth cap left unexpanded. Empty unless `truncated`. */
+    unexpanded: string[];
+};
+
+/**
+ * Every edge the bundle holds against this id: one hop, every rel including
+ * `related_to`, each row carrying the standing of the record that made it.
+ * Flat and factual, where `impact` answers the causal, transitive question.
+ */
+declare function backlinks(targetId: string, bundle: KbRecord[]): KbBacklinksResult;
+
+/**
+ * The transitive set of *dependants*, not the set of inbound edges: each rel is
+ * followed in its own direction of dependence. `related_to` and unknown rels
+ * propagate nothing. A superseded or rejected record is reported, then not
+ * walked through. A record expands once, so cycles terminate.
+ */
+declare function impact(targetId: string, bundle: KbRecord[], options?: KbImpactOptions): KbImpactResult;
+
+/**
+ * The whole bundle's typed edges, indexed by target — built once per call, so a
+ * walk stays linear in the bundle rather than quadratic. Order is `list()`'s
+ * own, then each record's declared link order, so repeated runs agree.
+ */
+declare function inboundIndex(bundle: KbRecord[]): Map<string, KbInboundEdge[]>;
+
 declare const LOG_FILE = "log.jsonl";
 declare const kbLogEntrySchema: z.ZodObject<{
     at: z.ZodISODateTime;
@@ -785,6 +916,10 @@ declare class KbStore {
     }): Promise<KbCatalogResult>;
     /** A bounded neighbourhood around one record. See `pack.ts`. */
     pack(bundlePath: string, rootId: string, options?: KbPackOptions): Promise<KbPackResult>;
+    /** What breaks if this record changes. See `kb-links/impact.ts`. */
+    impact(bundlePath: string, targetId: string, options?: KbImpactOptions): Promise<KbImpactResult>;
+    /** Who points at this record, one hop. See `kb-links/backlinks.ts`. */
+    backlinks(bundlePath: string, targetId: string): Promise<KbBacklinksResult>;
     /**
      * The stored index, rebuilt if it disagrees with the records.
      *
@@ -908,6 +1043,7 @@ declare enum ErrorTypes {
     KbPackBudgetExceeded = "KbPackBudgetExceeded",
     KbRecordNotFound = "KbRecordNotFound",
     KbSelfVerification = "KbSelfVerification",
+    KbUnknownLinkRel = "KbUnknownLinkRel",
     KbWriteConflict = "KbWriteConflict"
 }
 type ErrorDetails = Record<string, string | boolean | number | string[] | boolean[] | number[]>;
@@ -971,6 +1107,19 @@ declare class KbPackBudgetExceededError extends BaseError {
     readonly excluded: string[];
     constructor(recordCount: number, approxTokens: number, budgetTokens: number, excluded: string[]);
 }
+/**
+ * A `rels` option naming something the walk can never follow.
+ *
+ * Refused rather than ignored: dropping an unrecognised rel would return an
+ * empty impact set — "nothing breaks" — indistinguishable from a genuine
+ * result. `related_to` is refused here too, since it asserts no dependence and
+ * following it can only produce that same empty set.
+ */
+declare class KbUnknownLinkRelError extends BaseError {
+    readonly rel: string;
+    readonly expected: readonly string[];
+    constructor(rel: string, expected: readonly string[]);
+}
 /**
  * A flag that takes a value, given none.
  *
@@ -1009,7 +1158,68 @@ type KbRecordTypeSpec = {
 };
 declare const RECORD_TYPES: Readonly<Record<KbRecordType, KbRecordTypeSpec>>;
 declare function isKbRecordType(value: string): value is KbRecordType;
+/**
+ * The closed vocabulary of typed causal edges — `strauss_links[].rel` — which a
+ * producer may not extend. `related_to` is the non-dependence escape hatch and
+ * the one rel `kb_impact` does not follow. Every edge lives on the source's
+ * frontmatter, source → target; `phrase` is the template compose.ts renders.
+ */
+type KbLinkRelSpec = {
+    /** One line, for schema output and CLI help. */
+    purpose: string;
+    /** Sentence stem: `<phrase> [target](target.md).` */
+    phrase: string;
+    /**
+     * Which end of the edge breaks when the other end changes.
+     *
+     * The rel's *direction of dependence*, which does not follow the edge's own
+     * direction. `A depends_on B` puts the dependant at the source: A breaks when
+     * B moves. `A informs B` puts it at the target. A walk that treated both as
+     * "inbound" would report the blast radius of `informs`, `blocks`,
+     * `invalidates` and `constrains` backwards.
+     *
+     * `null` means the rel asserts no dependence either way, so nothing
+     * propagates along it. `related_to` is the only such rel.
+     */
+    dependant: "source" | "target" | null;
+};
+declare const KB_LINK_RELS: readonly ["depends_on", "constrains", "informs", "blocks", "invalidates", "verified_by", "satisfies", "related_to"];
+type KbLinkRel = (typeof KB_LINK_RELS)[number];
+declare const LINK_RELS: Readonly<Record<KbLinkRel, KbLinkRelSpec>>;
+/**
+ * The rels that carry a direction of dependence, and therefore the only ones
+ * anything can propagate along. `kb_impact`'s default edge set, and what
+ * `trace` follows.
+ *
+ * Derived from the table rather than restated, so a rel cannot be causal in one
+ * place and inert in another. The cast is a non-emptiness assertion for
+ * `z.enum`.
+ */
+declare const KB_CAUSAL_LINK_RELS: [KbLinkRel, ...KbLinkRel[]];
+declare function isKbLinkRel(value: string): value is KbLinkRel;
 
+/**
+ * One typed causal edge, as a producer states it.
+ *
+ * Strict where `kbLinkSchema` is tolerant, the same split
+ * `kbVerifiedEventSchema` makes against `kbActorStampSchema`: what this package
+ * writes must be inside the closed vocabulary, what it reads may not be, since
+ * a foreign record has to stay loadable for `kb_validate` to fault it.
+ */
+declare const composeLinkSchema: z.ZodObject<{
+    target: z.ZodString;
+    rel: z.ZodEnum<{
+        depends_on: "depends_on";
+        constrains: "constrains";
+        informs: "informs";
+        blocks: "blocks";
+        invalidates: "invalidates";
+        verified_by: "verified_by";
+        satisfies: "satisfies";
+        related_to: "related_to";
+    }>;
+}, z.core.$strict>;
+type ComposeLink = z.infer<typeof composeLinkSchema>;
 declare const composeInputSchema: z.ZodObject<{
     slug: z.ZodString;
     title: z.ZodString;
@@ -1036,6 +1246,19 @@ declare const composeInputSchema: z.ZodObject<{
     verify: z.ZodOptional<z.ZodArray<z.ZodString>>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     relatedConceptIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        target: z.ZodString;
+        rel: z.ZodEnum<{
+            depends_on: "depends_on";
+            constrains: "constrains";
+            informs: "informs";
+            blocks: "blocks";
+            invalidates: "invalidates";
+            verified_by: "verified_by";
+            satisfies: "satisfies";
+            related_to: "related_to";
+        }>;
+    }, z.core.$strict>>>;
     supersedes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     materiality: z.ZodOptional<z.ZodEnum<{
         blocking: "blocking";
@@ -1420,35 +1643,65 @@ declare function matchToDiff(files: DiffFile[], records: KbRecord[], options?: M
  * There is no separate `related` kind: compose.ts renders `relatedConceptIds`
  * as body links (`Relates to [id](id.md).`), so in stored form a related edge
  * IS a body link, and a distinct kind would count the same markdown twice.
- */
-declare const KB_EDGE_KINDS: readonly ["body-link", "supersession", "anchor", "source"];
+ *
+ * `typed-link` is not that case, despite compose.ts also rendering a sentence
+ * per link. The edge is `strauss_links` in the frontmatter — the authoritative,
+ * typed form — and the sentence is its rendering for a reader that only knows
+ * OKF. A record can carry the frontmatter without the prose (hand-written, or
+ * from a producer we did not write), so reading only the body would miss it.
+ * A pair connected both ways comes back with both kinds in `via`, which is the
+ * honest answer: it was declared, and it was written about.
+ *
+ * `body-link` and `typed-link` are DIRECTED — the edges a record itself makes,
+ * read off its own body or frontmatter. `supersession`, `anchor` and `source`
+ * are symmetric: they hold between two records because both name the same
+ * thing, so either end sees the other. Callers wanting the inbound half of a
+ * typed edge use `kb-links/` (`kb_backlinks`, `kb_impact`) rather than this
+ * module, which answers "what does this record point at".
+ */
+declare const KB_EDGE_KINDS: readonly ["body-link", "typed-link", "supersession", "anchor", "source"];
 type KbEdgeKind = (typeof KB_EDGE_KINDS)[number];
 type KbNeighbour = {
     record: KbRecord;
     /** Every edge kind that connects it to the record asked about. */
     via: KbEdgeKind[];
 };
+/**
+ * Which rels a `typed-link` walk may follow.
+ *
+ * Defaults to the whole known vocabulary — including `related_to`, since a
+ * neighbourhood is the one place a bibliography belongs. It never includes an
+ * unknown rel: a rel outside the vocabulary is not a claim any walk can
+ * interpret, so no walk traverses it anywhere, and `kb_validate` reports it as
+ * an error rather than a walk quietly acting on it.
+ */
+declare const DEFAULT_TYPED_LINK_RELS: readonly string[];
 /**
  * Every record `from` touches, each carrying the full set of edge kinds that
  * connect the pair. Order is deterministic: bundle order per kind, kinds in
  * the order given.
  */
-declare function neighbours(from: KbRecord, bundle: KbRecord[], kinds?: readonly KbEdgeKind[]): KbNeighbour[];
-/** The records one edge kind connects `from` to, in bundle order. */
-declare function edgeNeighbours(from: KbRecord, bundle: KbRecord[], kind: KbEdgeKind): KbRecord[];
+declare function neighbours(from: KbRecord, bundle: KbRecord[], kinds?: readonly KbEdgeKind[], linkRels?: readonly string[]): KbNeighbour[];
+/**
+ * The records one edge kind connects `from` to, in bundle order.
+ *
+ * `linkRels` narrows the `typed-link` kind and is ignored by the others —
+ * `trace` passes the causal rels, `pack` takes the default.
+ */
+declare function edgeNeighbours(from: KbRecord, bundle: KbRecord[], kind: KbEdgeKind, linkRels?: readonly string[]): KbRecord[];
 
+/** `error` fails the check; `warning` does not. */
+type KbValidationSeverity = "error" | "warning";
 type KbValidationProblem = {
     check: string;
     conceptId: string;
     note: string;
+    severity: KbValidationSeverity;
 };
 /**
- * Checks that only hold across the whole bundle.
- *
- * Per-record shape is the schema's job and is enforced on every read, so
- * nothing here re-states it. What a schema cannot see is whether one record's
- * pointers agree with another's — and since `supersede()` now writes both
- * directions, a disagreement means someone edited a file by hand.
+ * Checks that only hold across the whole bundle: whether one record's pointers
+ * agree with another's. Per-record shape is the schema's job, enforced on every
+ * read, so nothing here re-states it.
  */
 declare function validateBundle(records: KbRecord[]): KbValidationProblem[];
 
@@ -1574,6 +1827,19 @@ declare const decisionInputSchema: z.ZodObject<{
     }, z.core.$strict>>>;
     verify: z.ZodOptional<z.ZodArray<z.ZodString>>;
     relatedConceptIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        target: z.ZodString;
+        rel: z.ZodEnum<{
+            depends_on: "depends_on";
+            constrains: "constrains";
+            informs: "informs";
+            blocks: "blocks";
+            invalidates: "invalidates";
+            verified_by: "verified_by";
+            satisfies: "satisfies";
+            related_to: "related_to";
+        }>;
+    }, z.core.$strict>>>;
     supersedes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     materiality: z.ZodOptional<z.ZodEnum<{
         blocking: "blocking";
@@ -1805,4 +2071,4 @@ declare function parseMarkdownWithFrontmatter<S extends z.ZodType>(text: string,
     frontmatter: ReturnType<S["safeParse"]>;
 };
 
-export { type AnchorResolver, BaseError, CONTEXT_BEGIN, CONTEXT_END, CONTEXT_PROFILES, type ComposeInput, type ComposedRecord, DECISION_TYPE, DEFAULT_AGING_DAYS, DEFAULT_EXPIRING_DAYS, DEFAULT_LOAD_BUDGET, DEFAULT_PACK_HOPS, DEFAULT_PACK_MAX_NODES, DEFAULT_UNVERIFIED_DAYS, type DecisionInput, type DiffFile, type DiffHunk, type DiffMatch, type ErrorDetails, type ErrorProps, ErrorTypes, Fault, INDEX_FILE, KB_COMMANDS, KB_COMMANDS_BY_NAME, KB_CONCEPT_ID_PATTERN, KB_CONFIDENCES, KB_DIR, KB_DOCTOR_CHECKS, KB_EDGE_KINDS, KB_MATERIALITIES, KB_RECORD_STATUSES, KB_RECORD_TYPES, KB_SLUG_PATTERN, type KbActorStamp, type KbAdjudicated, type KbAnchor, type KbAnchorDriftEntry, KbBaseFrozenError, type KbCatalogEntry, type KbCatalogResult, type KbCommand, type KbCommandContext, type KbContextBudgets, type KbContextOptions, type KbContextResult, type KbDoctorCheck, type KbDoctorFinding, type KbDoctorGroup, type KbDoctorOptions, type KbDoctorReport, type KbDoctorThresholds, type KbEdgeKind, KbInvalidConceptIdError, type KbLoadResult, type KbLogEntry, type KbLogReadResult, type KbLogger, type KbMergedPin, type KbMergedPins, KbMissingFlagValueError, type KbNeighbour, KbPackBudgetExceededError, type KbPackOptions, type KbPackResult, type KbPackedRecord, type KbPin, type KbPinLayer, type KbPinOptions, type KbPinResult, type KbPinStatus, KbPinsMalformedError, type KbPinsManifest, type KbRecord, KbRecordAlreadyExistsError, type KbRecordFrontmatter, KbRecordNotFoundError, type KbRecordStatus, type KbRecordType, type KbRecordTypeSpec, type KbSearchLogger, KbSelfVerificationError, type KbSource, type KbStanding, KbStore, type KbSupersededStub, type KbSyncResult, type KbTraceEdge, type KbTraceOptions, type KbTraceStep, type KbValidationProblem, type KbVerifiedEvent, type KbWarning, KbWriteConflictError, type KbWriteInput, LOG_FILE, type MatchOptions, NO_DECISION_SLUG, PINS_FILE, PINS_LOCAL_FILE, PIN_LAYERS, type QmdModule, RECORD_TYPES, type ResolvedSymbol, SEARCH_INDEX_FILE, type SearchHit, type SearchOptions, type SymbolRange, TRACE_EDGES, adjudicate, anchorFilePath, assertBaseNotFrozen, buildContext, catalog, composeDecisionRecord, composeInputSchema, composeNoDecisionRecord, composeRecord, contextProfileBudgets, createKbMcpServer, decisionInputSchema, detectAnchorDrift, doctor, edgeNeighbours, hashAnchorText, indexIsStale, isKbRecordType, isNoDecisionRecord, kbActorStampSchema, kbAnchorSchema, kbConceptIdSchema, kbJsonSchemas, kbLogEntrySchema, kbRecordFrontmatterSchema, kbSourceSchema, kbVerifiedEventSchema, listPins, loadQmd, matchToDiff, mergedContextBudgets, neighbours, pack, parseLog, parseMarkdownWithFrontmatter, pinBase, readMergedPins, readPinsLayer, regexResolver, renderCatalogLine, renderIndex, renderIndexLine, renderLogEntry, resolveAnchor, resolveHeads, resolveHits, resolvePinPath, runKbCli, runKbMcpServer, searchBase, selectDecisions, splitMarkdownFrontmatter, stringifyMarkdownWithFrontmatter, syncInstructions, toHookJson, trace, unpinBase, validateBundle };
+export { type AnchorResolver, BaseError, CONTEXT_BEGIN, CONTEXT_END, CONTEXT_PROFILES, type ComposeInput, type ComposeLink, type ComposedRecord, DECISION_TYPE, DEFAULT_AGING_DAYS, DEFAULT_EXPIRING_DAYS, DEFAULT_LOAD_BUDGET, DEFAULT_PACK_HOPS, DEFAULT_PACK_MAX_NODES, DEFAULT_TYPED_LINK_RELS, DEFAULT_UNVERIFIED_DAYS, type DecisionInput, type DiffFile, type DiffHunk, type DiffMatch, type ErrorDetails, type ErrorProps, ErrorTypes, Fault, INDEX_FILE, KB_CAUSAL_LINK_RELS, KB_COMMANDS, KB_COMMANDS_BY_NAME, KB_CONCEPT_ID_PATTERN, KB_CONFIDENCES, KB_DIR, KB_DOCTOR_CHECKS, KB_EDGE_KINDS, KB_LINK_RELS, KB_MATERIALITIES, KB_RECORD_STATUSES, KB_RECORD_TYPES, KB_SLUG_PATTERN, type KbActorStamp, type KbAdjudicated, type KbAnchor, type KbAnchorDriftEntry, type KbBacklink, type KbBacklinksResult, KbBaseFrozenError, type KbCatalogEntry, type KbCatalogResult, type KbCommand, type KbCommandContext, type KbContextBudgets, type KbContextOptions, type KbContextResult, type KbDoctorCheck, type KbDoctorFinding, type KbDoctorGroup, type KbDoctorOptions, type KbDoctorReport, type KbDoctorThresholds, type KbEdgeKind, type KbImpactOptions, type KbImpactResult, type KbImpactedRecord, type KbInboundEdge, KbInvalidConceptIdError, type KbLink, type KbLinkEdge, type KbLinkRel, type KbLinkRelSpec, type KbLoadResult, type KbLogEntry, type KbLogReadResult, type KbLogger, type KbMergedPin, type KbMergedPins, KbMissingFlagValueError, type KbNeighbour, KbPackBudgetExceededError, type KbPackOptions, type KbPackResult, type KbPackedRecord, type KbPin, type KbPinLayer, type KbPinOptions, type KbPinResult, type KbPinStatus, KbPinsMalformedError, type KbPinsManifest, type KbRecord, KbRecordAlreadyExistsError, type KbRecordFrontmatter, KbRecordNotFoundError, type KbRecordStatus, type KbRecordType, type KbRecordTypeSpec, type KbSearchLogger, KbSelfVerificationError, type KbSource, type KbStanding, KbStore, type KbSupersededStub, type KbSyncResult, type KbTraceEdge, type KbTraceOptions, type KbTraceStep, KbUnknownLinkRelError, type KbValidationProblem, type KbValidationSeverity, type KbVerifiedEvent, type KbWarning, KbWriteConflictError, type KbWriteInput, LINK_RELS, LOG_FILE, type MatchOptions, NO_DECISION_SLUG, PINS_FILE, PINS_LOCAL_FILE, PIN_LAYERS, type QmdModule, RECORD_TYPES, type ResolvedSymbol, SEARCH_INDEX_FILE, type SearchHit, type SearchOptions, type SymbolRange, TRACE_EDGES, adjudicate, anchorFilePath, assertBaseNotFrozen, backlinks, buildContext, catalog, composeDecisionRecord, composeInputSchema, composeLinkSchema, composeNoDecisionRecord, composeRecord, contextProfileBudgets, createKbMcpServer, decisionInputSchema, detectAnchorDrift, doctor, edgeNeighbours, hashAnchorText, impact, inboundIndex, indexIsStale, isKbLinkRel, isKbRecordType, isNoDecisionRecord, kbActorStampSchema, kbAnchorSchema, kbConceptIdSchema, kbJsonSchemas, kbLinkSchema, kbLogEntrySchema, kbRecordFrontmatterSchema, kbSourceSchema, kbVerifiedEventSchema, listPins, loadQmd, matchToDiff, mergedContextBudgets, neighbours, pack, parseLog, parseMarkdownWithFrontmatter, pinBase, readMergedPins, readPinsLayer, regexResolver, renderCatalogLine, renderIndex, renderIndexLine, renderLogEntry, resolveAnchor, resolveHeads, resolveHits, resolvePinPath, runKbCli, runKbMcpServer, searchBase, selectDecisions, splitMarkdownFrontmatter, stringifyMarkdownWithFrontmatter, syncInstructions, toHookJson, trace, unpinBase, validateBundle };

package/dist/index.js

@@ -1,10 +1,10 @@
 import {
   runKbCli
-} from "./chunk-F2U2YLWV.js";
+} from "./chunk-ZICKDZGY.js";
 import {
   createKbMcpServer,
   runKbMcpServer
-} from "./chunk-EXKK2KUN.js";
+} from "./chunk-WZODZNR6.js";
 import {
   BaseError,
   CONTEXT_BEGIN,
@@ -16,10 +16,12 @@ import {
   DEFAULT_LOAD_BUDGET,
   DEFAULT_PACK_HOPS,
   DEFAULT_PACK_MAX_NODES,
+  DEFAULT_TYPED_LINK_RELS,
   DEFAULT_UNVERIFIED_DAYS,
   ErrorTypes,
   Fault,
   INDEX_FILE,
+  KB_CAUSAL_LINK_RELS,
   KB_COMMANDS,
   KB_COMMANDS_BY_NAME,
   KB_CONCEPT_ID_PATTERN,
@@ -27,6 +29,7 @@ import {
   KB_DIR,
   KB_DOCTOR_CHECKS,
   KB_EDGE_KINDS,
+  KB_LINK_RELS,
   KB_MATERIALITIES,
   KB_RECORD_STATUSES,
   KB_RECORD_TYPES,
@@ -40,7 +43,9 @@ import {
   KbRecordNotFoundError,
   KbSelfVerificationError,
   KbStore,
+  KbUnknownLinkRelError,
   KbWriteConflictError,
+  LINK_RELS,
   LOG_FILE,
   NO_DECISION_SLUG,
   PINS_FILE,
@@ -52,10 +57,12 @@ import {
   adjudicate,
   anchorFilePath,
   assertBaseNotFrozen,
+  backlinks,
   buildContext,
   catalog,
   composeDecisionRecord,
   composeInputSchema,
+  composeLinkSchema,
   composeNoDecisionRecord,
   composeRecord,
   contextProfileBudgets,
@@ -64,13 +71,17 @@ import {
   doctor,
   edgeNeighbours,
   hashAnchorText,
+  impact,
+  inboundIndex,
   indexIsStale,
+  isKbLinkRel,
   isKbRecordType,
   isNoDecisionRecord,
   kbActorStampSchema,
   kbAnchorSchema,
   kbConceptIdSchema,
   kbJsonSchemas,
+  kbLinkSchema,
   kbLogEntrySchema,
   kbRecordFrontmatterSchema,
   kbSourceSchema,
@@ -103,7 +114,7 @@ import {
   trace,
   unpinBase,
   validateBundle
-} from "./chunk-33ZCBEUV.js";
+} from "./chunk-XALWG3EZ.js";
 
 // src/match-diff.ts
 function matchToDiff(files, records, options = {}) {
@@ -195,10 +206,12 @@ export {
   DEFAULT_LOAD_BUDGET,
   DEFAULT_PACK_HOPS,
   DEFAULT_PACK_MAX_NODES,
+  DEFAULT_TYPED_LINK_RELS,
   DEFAULT_UNVERIFIED_DAYS,
   ErrorTypes,
   Fault,
   INDEX_FILE,
+  KB_CAUSAL_LINK_RELS,
   KB_COMMANDS,
   KB_COMMANDS_BY_NAME,
   KB_CONCEPT_ID_PATTERN,
@@ -206,6 +219,7 @@ export {
   KB_DIR,
   KB_DOCTOR_CHECKS,
   KB_EDGE_KINDS,
+  KB_LINK_RELS,
   KB_MATERIALITIES,
   KB_RECORD_STATUSES,
   KB_RECORD_TYPES,
@@ -219,7 +233,9 @@ export {
   KbRecordNotFoundError,
   KbSelfVerificationError,
   KbStore,
+  KbUnknownLinkRelError,
   KbWriteConflictError,
+  LINK_RELS,
   LOG_FILE,
   NO_DECISION_SLUG,
   PINS_FILE,
@@ -231,10 +247,12 @@ export {
   adjudicate,
   anchorFilePath,
   assertBaseNotFrozen,
+  backlinks,
   buildContext,
   catalog,
   composeDecisionRecord,
   composeInputSchema,
+  composeLinkSchema,
   composeNoDecisionRecord,
   composeRecord,
   contextProfileBudgets,
@@ -244,13 +262,17 @@ export {
   doctor,
   edgeNeighbours,
   hashAnchorText,
+  impact,
+  inboundIndex,
   indexIsStale,
+  isKbLinkRel,
   isKbRecordType,
   isNoDecisionRecord,
   kbActorStampSchema,
   kbAnchorSchema,
   kbConceptIdSchema,
   kbJsonSchemas,
+  kbLinkSchema,
   kbLogEntrySchema,
   kbRecordFrontmatterSchema,
   kbSourceSchema,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/match-diff.ts"],"sourcesContent":["import { adjudicate, type KbAdjudicated } from \"./adjudicate.js\";\nimport type { KbAnchor, KbRecord } from \"./kb-record.schema.js\";\n\n/**\n * Which records apply to which part of a change.\n *\n * Takes a structural description of a diff rather than a patch, so this package\n * carries no diff parser: callers already have one, and a knowledge base has no\n * business preferring a particular flavour of unified diff.\n *\n * Deterministic on purpose. Every step here is mechanical — the one judgment,\n * whether a matched record is worth showing a reviewer, is deliberately absent.\n * A model placed here would sit between the reviewer and their diff on every\n * review, to answer a question nobody has yet shown needs asking.\n *\n * Distinct from `load()`, which hands a reader the whole base. That answers\n * \"does anything address this question\"; this answers \"what is attached to this\n * code\", and an anchor is the author's own statement rather than an inference\n * from one. A reader guessing which record relates to a hunk would be guessing\n * at something already written down — and a diff has dozens of hunks, which is\n * dozens of reader calls against microseconds of matching. Where they compose:\n * this narrows a hunk to a few records, and a reader asked to explain them gets\n * those, not the base.\n */\nexport type DiffHunk = {\n  /** 1-based, inclusive, in the file's post-change line numbering. */\n  startLine: number;\n  endLine: number;\n};\n\nexport type DiffFile = {\n  /** Repo-relative, matching how anchors are written. */\n  filePath: string;\n  hunks: DiffHunk[];\n};\n\n/**\n * A symbol resolved to lines. Supplied by whatever the caller uses to index\n * symbols; absence is tolerated — see `place()`.\n */\nexport type SymbolRange = {\n  file: string;\n  symbol: string;\n  startLine: number;\n  endLine: number;\n};\n\nexport type DiffMatch = {\n  filePath: string;\n  hunk: DiffHunk;\n  /** Current records first — what still holds should be read before what does not. */\n  records: KbAdjudicated[];\n  /**\n   * `symbol` when every record here was placed by a resolved symbol range,\n   * `file` when at least one fell back to the whole file. Reported rather than\n   * hidden: a caller showing a file-level match as though it were pinned to\n   * these lines is claiming a precision it does not have.\n   */\n  precision: \"symbol\" | \"file\";\n};\n\nexport type MatchOptions = {\n  /** Without these, symbol anchors degrade to file level rather than vanishing. */\n  symbolRanges?: SymbolRange[];\n  now?: Date;\n};\n\nexport function matchToDiff(\n  files: DiffFile[],\n  records: KbRecord[],\n  options: MatchOptions = {},\n): DiffMatch[] {\n  const ranges = indexRanges(options.symbolRanges ?? []);\n  const anchored = records.filter(\n    (record) => (record.frontmatter.strauss_anchors ?? []).length > 0,\n  );\n  const matches: DiffMatch[] = [];\n\n  for (const file of files) {\n    const candidates = anchored\n      .map((record) => ({\n        record,\n        anchors: (record.frontmatter.strauss_anchors ?? []).filter(\n          (anchor) => normalize(anchor.file) === normalize(file.filePath),\n        ),\n      }))\n      .filter(({ anchors }) => anchors.length > 0);\n    if (!candidates.length) continue;\n\n    for (const hunk of file.hunks) {\n      const hits: KbRecord[] = [];\n      let precision: DiffMatch[\"precision\"] = \"symbol\";\n\n      for (const { record, anchors } of candidates) {\n        const placement = place(anchors, file.filePath, hunk, ranges);\n        if (placement === \"miss\") continue;\n        if (placement === \"file\") precision = \"file\";\n        hits.push(record);\n      }\n\n      if (!hits.length) continue;\n      matches.push({\n        filePath: file.filePath,\n        hunk,\n        records: order(adjudicate(hits, records, options.now)),\n        precision,\n      });\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Whether any of a record's anchors puts it on this hunk.\n *\n * An anchor naming only a file is about the whole file, so it lands on every\n * hunk in it. One naming a symbol lands only where that symbol's lines overlap\n * — unless nothing resolved the symbol, in which case it falls back to the file\n * rather than disappearing. A record silently absent because a resolver was\n * unavailable is worse than one shown imprecisely and labelled as such.\n */\nfunction place(\n  anchors: KbAnchor[],\n  filePath: string,\n  hunk: DiffHunk,\n  ranges: Map<string, SymbolRange[]>,\n): \"symbol\" | \"file\" | \"miss\" {\n  let fallback: \"file\" | \"miss\" = \"miss\";\n\n  for (const anchor of anchors) {\n    if (!anchor.symbol) return \"file\";\n\n    const resolved = ranges.get(key(filePath, anchor.symbol));\n    if (!resolved?.length) {\n      fallback = \"file\";\n      continue;\n    }\n    if (resolved.some((range) => overlaps(range, hunk))) return \"symbol\";\n  }\n\n  return fallback;\n}\n\nfunction overlaps(range: SymbolRange, hunk: DiffHunk): boolean {\n  return range.startLine <= hunk.endLine && hunk.startLine <= range.endLine;\n}\n\n/** Current before superseded, then oldest first, so an arc reads in order. */\nfunction order(records: KbAdjudicated[]): KbAdjudicated[] {\n  const rank: Record<string, number> = {\n    current: 0,\n    unsettled: 1,\n    open: 2,\n    superseded: 3,\n    rejected: 4,\n  };\n  return [...records].sort(\n    (left, right) =>\n      (rank[left.standing] ?? 9) - (rank[right.standing] ?? 9) ||\n      (left.record.frontmatter.generated?.at ?? \"\").localeCompare(\n        right.record.frontmatter.generated?.at ?? \"\",\n      ),\n  );\n}\n\nfunction indexRanges(ranges: SymbolRange[]): Map<string, SymbolRange[]> {\n  const byKey = new Map<string, SymbolRange[]>();\n  for (const range of ranges) {\n    const id = key(range.file, range.symbol);\n    byKey.set(id, [...(byKey.get(id) ?? []), range]);\n  }\n  return byKey;\n}\n\nfunction key(file: string, symbol: string): string {\n  return `${normalize(file)}#${symbol}`;\n}\n\n/** Anchors are written by hand often enough that `./` shows up. */\nfunction normalize(path: string): string {\n  return path.replace(/^\\.\\//, \"\");\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/match-diff.ts"],"sourcesContent":["import { adjudicate, type KbAdjudicated } from \"./adjudicate.js\";\nimport type { KbAnchor, KbRecord } from \"./kb-record.schema.js\";\n\n/**\n * Which records apply to which part of a change.\n *\n * Takes a structural description of a diff rather than a patch, so this package\n * carries no diff parser: callers already have one, and a knowledge base has no\n * business preferring a particular flavour of unified diff.\n *\n * Deterministic on purpose. Every step here is mechanical — the one judgment,\n * whether a matched record is worth showing a reviewer, is deliberately absent.\n * A model placed here would sit between the reviewer and their diff on every\n * review, to answer a question nobody has yet shown needs asking.\n *\n * Distinct from `load()`, which hands a reader the whole base. That answers\n * \"does anything address this question\"; this answers \"what is attached to this\n * code\", and an anchor is the author's own statement rather than an inference\n * from one. A reader guessing which record relates to a hunk would be guessing\n * at something already written down — and a diff has dozens of hunks, which is\n * dozens of reader calls against microseconds of matching. Where they compose:\n * this narrows a hunk to a few records, and a reader asked to explain them gets\n * those, not the base.\n */\nexport type DiffHunk = {\n  /** 1-based, inclusive, in the file's post-change line numbering. */\n  startLine: number;\n  endLine: number;\n};\n\nexport type DiffFile = {\n  /** Repo-relative, matching how anchors are written. */\n  filePath: string;\n  hunks: DiffHunk[];\n};\n\n/**\n * A symbol resolved to lines. Supplied by whatever the caller uses to index\n * symbols; absence is tolerated — see `place()`.\n */\nexport type SymbolRange = {\n  file: string;\n  symbol: string;\n  startLine: number;\n  endLine: number;\n};\n\nexport type DiffMatch = {\n  filePath: string;\n  hunk: DiffHunk;\n  /** Current records first — what still holds should be read before what does not. */\n  records: KbAdjudicated[];\n  /**\n   * `symbol` when every record here was placed by a resolved symbol range,\n   * `file` when at least one fell back to the whole file. Reported rather than\n   * hidden: a caller showing a file-level match as though it were pinned to\n   * these lines is claiming a precision it does not have.\n   */\n  precision: \"symbol\" | \"file\";\n};\n\nexport type MatchOptions = {\n  /** Without these, symbol anchors degrade to file level rather than vanishing. */\n  symbolRanges?: SymbolRange[];\n  now?: Date;\n};\n\nexport function matchToDiff(\n  files: DiffFile[],\n  records: KbRecord[],\n  options: MatchOptions = {},\n): DiffMatch[] {\n  const ranges = indexRanges(options.symbolRanges ?? []);\n  const anchored = records.filter(\n    (record) => (record.frontmatter.strauss_anchors ?? []).length > 0,\n  );\n  const matches: DiffMatch[] = [];\n\n  for (const file of files) {\n    const candidates = anchored\n      .map((record) => ({\n        record,\n        anchors: (record.frontmatter.strauss_anchors ?? []).filter(\n          (anchor) => normalize(anchor.file) === normalize(file.filePath),\n        ),\n      }))\n      .filter(({ anchors }) => anchors.length > 0);\n    if (!candidates.length) continue;\n\n    for (const hunk of file.hunks) {\n      const hits: KbRecord[] = [];\n      let precision: DiffMatch[\"precision\"] = \"symbol\";\n\n      for (const { record, anchors } of candidates) {\n        const placement = place(anchors, file.filePath, hunk, ranges);\n        if (placement === \"miss\") continue;\n        if (placement === \"file\") precision = \"file\";\n        hits.push(record);\n      }\n\n      if (!hits.length) continue;\n      matches.push({\n        filePath: file.filePath,\n        hunk,\n        records: order(adjudicate(hits, records, options.now)),\n        precision,\n      });\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Whether any of a record's anchors puts it on this hunk.\n *\n * An anchor naming only a file is about the whole file, so it lands on every\n * hunk in it. One naming a symbol lands only where that symbol's lines overlap\n * — unless nothing resolved the symbol, in which case it falls back to the file\n * rather than disappearing. A record silently absent because a resolver was\n * unavailable is worse than one shown imprecisely and labelled as such.\n */\nfunction place(\n  anchors: KbAnchor[],\n  filePath: string,\n  hunk: DiffHunk,\n  ranges: Map<string, SymbolRange[]>,\n): \"symbol\" | \"file\" | \"miss\" {\n  let fallback: \"file\" | \"miss\" = \"miss\";\n\n  for (const anchor of anchors) {\n    if (!anchor.symbol) return \"file\";\n\n    const resolved = ranges.get(key(filePath, anchor.symbol));\n    if (!resolved?.length) {\n      fallback = \"file\";\n      continue;\n    }\n    if (resolved.some((range) => overlaps(range, hunk))) return \"symbol\";\n  }\n\n  return fallback;\n}\n\nfunction overlaps(range: SymbolRange, hunk: DiffHunk): boolean {\n  return range.startLine <= hunk.endLine && hunk.startLine <= range.endLine;\n}\n\n/** Current before superseded, then oldest first, so an arc reads in order. */\nfunction order(records: KbAdjudicated[]): KbAdjudicated[] {\n  const rank: Record<string, number> = {\n    current: 0,\n    unsettled: 1,\n    open: 2,\n    superseded: 3,\n    rejected: 4,\n  };\n  return [...records].sort(\n    (left, right) =>\n      (rank[left.standing] ?? 9) - (rank[right.standing] ?? 9) ||\n      (left.record.frontmatter.generated?.at ?? \"\").localeCompare(\n        right.record.frontmatter.generated?.at ?? \"\",\n      ),\n  );\n}\n\nfunction indexRanges(ranges: SymbolRange[]): Map<string, SymbolRange[]> {\n  const byKey = new Map<string, SymbolRange[]>();\n  for (const range of ranges) {\n    const id = key(range.file, range.symbol);\n    byKey.set(id, [...(byKey.get(id) ?? []), range]);\n  }\n  return byKey;\n}\n\nfunction key(file: string, symbol: string): string {\n  return `${normalize(file)}#${symbol}`;\n}\n\n/** Anchors are written by hand often enough that `./` shows up. */\nfunction normalize(path: string): string {\n  return path.replace(/^\\.\\//, \"\");\n}\n"],"mappings":"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","names":[]}