@saasontools/strauss-kb 0.1.5 → 0.1.7

package/dist/index.d.cts

@@ -31,6 +31,17 @@ declare const kbActorStampSchema: z.ZodObject<{
     by: z.ZodString;
     at: z.ZodString;
 }, z.core.$loose>;
+/**
+ * A `verified[]` event as this package writes one: the actor stamp plus a
+ * required note saying what the check found. Write-side only — the frontmatter
+ * keeps reading `verified` with `kbActorStampSchema`, because OKF-native
+ * entries carry no note and a consumer must not reject conformant records.
+ */
+declare const kbVerifiedEventSchema: z.ZodObject<{
+    by: z.ZodString;
+    at: z.ZodString;
+    note: z.ZodString;
+}, z.core.$loose>;
 /**
  * Where a record attaches in the code.
  *
@@ -124,6 +135,7 @@ declare const kbRecordFrontmatterSchema: z.ZodObject<{
 }, z.core.$loose>;
 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 KbRecordFrontmatter = z.infer<typeof kbRecordFrontmatterSchema>;
 type KbRecord = {
@@ -213,12 +225,11 @@ declare function resolveHeads(from: KbRecord, byId: Map<string, KbRecord>): {
 };
 
 /**
- * Edges a trace may follow.
- *
- * Two more are conceivable and absent: `strauss_answered` carries no target id,
- * so a question's resolution lives in its own body rather than in another
- * record; and following OKF's body markdown links would need a markdown AST
- * pass this package does not yet do.
+ * Edges a trace may follow — the shared kb-edges.ts definitions, minus
+ * `body-link`: body links can reach most of a bundle from anywhere, which
+ * 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.
  */
 declare const TRACE_EDGES: readonly ["supersession", "anchor", "source"];
 type KbTraceEdge = (typeof TRACE_EDGES)[number];
@@ -248,6 +259,58 @@ type KbTraceOptions = {
  */
 declare function trace(seedId: string, bundle: KbRecord[], options?: KbTraceOptions): KbTraceStep[];
 
+declare const DEFAULT_PACK_HOPS = 2;
+declare const DEFAULT_PACK_MAX_NODES = 20;
+type KbPackOptions = {
+    /** How far from the root the walk may reach. */
+    hops?: number;
+    /** How many records the pack may hold, root included. */
+    maxNodes?: number;
+    /** Approximate token ceiling over what is actually emitted. */
+    budgetTokens?: number;
+};
+/** One record as the pack emits it — the same mapping `kb_load` hands back. */
+type KbPackedRecord = {
+    conceptId: string;
+    title: string | null;
+    standing: KbStanding;
+    supersededBy: string[];
+    warnings: KbWarning[];
+    anchors: KbAnchor[];
+    body: string;
+};
+/**
+ * Deliberately timestamp-free: the same bundle and root must produce the same
+ * bytes on every run, so a caller can diff two packs and trust that a changed
+ * byte means changed knowledge.
+ */
+type KbPackResult = {
+    root: string;
+    records: KbPackedRecord[];
+    /** Named only, exactly as `load` stubs them. Bodies reachable via trace. */
+    superseded: KbSupersededStub[];
+    /** Every reachable record the hop and node limits cut, never summarized. */
+    excluded: string[];
+    recordCount: number;
+    tokensLoaded: number;
+    budgetTokens: number;
+};
+/**
+ * A bounded, progressively disclosed neighbourhood around one record.
+ *
+ * Where `load` hands over a whole base and `trace` a timeline, a pack is the
+ * subgraph a reader needs to act near one record: everything within `hops`
+ * of the root, cut to `maxNodes` by ranking, with every cut id listed —
+ * a named gap is knowable, a silent one is not.
+ *
+ * Adjudication runs against the whole bundle, not the reached slice, so a
+ * record's standing cannot depend on whether its replacement happened to be
+ * within reach. Superseded records become the same stubs `load` emits, costed
+ * as stubs, and the budget is a refusal rather than a truncation: a partial
+ * pack looks complete to its reader.
+ */
+declare function pack(bundle: KbRecord[], rootId: string, options?: KbPackOptions): KbPackResult;
+
 declare const LOG_FILE = "log.jsonl";
 declare const kbLogEntrySchema: z.ZodObject<{
     at: z.ZodString;
@@ -298,6 +361,8 @@ type KbLogger = {
     info?(entry: Record<string, unknown>): void;
     warn?(entry: Record<string, unknown>): void;
 };
+/** Roughly an eighth of a large context window — generous, and overridable. */
+declare const DEFAULT_LOAD_BUDGET = 25000;
 /**
  * A superseded record, named but not spelled out.
  *
@@ -386,6 +451,18 @@ declare class KbStore {
      * timeouts.
      */
     setStatus(bundlePath: string, conceptId: string, status: KbRecordStatus, actor?: string): Promise<KbRecord>;
+    /**
+     * Appends one `verified[]` event: who checked the record, when, and what the
+     * check found. Append-only — prior events are history, and are spread into
+     * the new array untouched rather than reshaped through the write schema.
+     *
+     * A record's generator cannot verify its own record unless the actor is
+     * human: the generator re-reading its own output is not an independent
+     * check. The rule runs before the mutation so a refusal never publishes,
+     * and the refusal is logged under its own operation name — `mutate` only
+     * logs what it publishes.
+     */
+    verify(bundlePath: string, conceptId: string, note: string, actor?: string, at?: string): Promise<KbRecord>;
     /**
      * Marks `conceptId` superseded by `replacementId`, and links both directions.
      *
@@ -443,6 +520,8 @@ declare class KbStore {
     }): Promise<KbLoadResult>;
     /** How a position was arrived at, as a timeline. See `trace.ts`. */
     trace(bundlePath: string, seedId: string, options?: KbTraceOptions): Promise<KbTraceStep[]>;
+    /** A bounded neighbourhood around one record. See `pack.ts`. */
+    pack(bundlePath: string, rootId: string, options?: KbPackOptions): Promise<KbPackResult>;
     /**
      * The stored index, rebuilt if it disagrees with the records.
      *
@@ -521,7 +600,9 @@ declare enum Fault {
 declare enum ErrorTypes {
     KbRecordAlreadyExists = "KbRecordAlreadyExists",
     KbInvalidConceptId = "KbInvalidConceptId",
+    KbPackBudgetExceeded = "KbPackBudgetExceeded",
     KbRecordNotFound = "KbRecordNotFound",
+    KbSelfVerification = "KbSelfVerification",
     KbWriteConflict = "KbWriteConflict"
 }
 type ErrorDetails = Record<string, string | boolean | number | string[] | boolean[] | number[]>;
@@ -564,6 +645,27 @@ declare class KbWriteConflictError extends BaseError {
     readonly conceptId: string;
     constructor(conceptId: string);
 }
+/** A generator confirming its own record adds no independent check. */
+declare class KbSelfVerificationError extends BaseError {
+    readonly conceptId: string;
+    readonly actor: string;
+    readonly generatedBy: string;
+    constructor(conceptId: string, actor: string, generatedBy: string);
+}
+/**
+ * A pack that will not fit its token budget. Refusal, not truncation: a
+ * partial pack is indistinguishable from a complete one, so the caller gets
+ * the full picture — how many records, how many tokens, and every id the
+ * walk's own limits already cut — and decides whether to raise the budget or
+ * tighten the walk.
+ */
+declare class KbPackBudgetExceededError extends BaseError {
+    readonly recordCount: number;
+    readonly approxTokens: number;
+    readonly budgetTokens: number;
+    readonly excluded: string[];
+    constructor(recordCount: number, approxTokens: number, budgetTokens: number, excluded: string[]);
+}
 declare class KbInvalidConceptIdError extends BaseError {
     constructor(message: string, details: Record<string, string>);
 }
@@ -986,6 +1088,33 @@ type MatchOptions = {
 };
 declare function matchToDiff(files: DiffFile[], records: KbRecord[], options?: MatchOptions): DiffMatch[];
 
+/**
+ * The edges between records in one bundle, defined once.
+ *
+ * Both walks — `trace` and `pack` — consume this module, so they cannot drift
+ * into disagreeing about what makes two records neighbours, and a diagnostic
+ * pass over the graph can reuse the same definition.
+ *
+ * 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"];
+type KbEdgeKind = (typeof KB_EDGE_KINDS)[number];
+type KbNeighbour = {
+    record: KbRecord;
+    /** Every edge kind that connects it to the record asked about. */
+    via: KbEdgeKind[];
+};
+/**
+ * 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[];
+
 type KbValidationProblem = {
     check: string;
     conceptId: string;
@@ -1265,4 +1394,4 @@ declare function parseMarkdownWithFrontmatter<S extends z.ZodType>(text: string,
     frontmatter: ReturnType<S["safeParse"]>;
 };
 
-export { BaseError, CONTEXT_BEGIN, CONTEXT_END, CONTEXT_PROFILES, type ComposeInput, type ComposedRecord, DECISION_TYPE, 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_MATERIALITIES, KB_RECORD_STATUSES, KB_RECORD_TYPES, KB_SLUG_PATTERN, type KbActorStamp, type KbAdjudicated, type KbAnchor, KbBaseFrozenError, type KbCommand, type KbCommandContext, type KbContextBudgets, type KbContextOptions, type KbContextResult, KbInvalidConceptIdError, type KbLoadResult, type KbLogEntry, type KbLogReadResult, type KbLogger, type KbMergedPin, type KbMergedPins, 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, type KbSource, type KbStanding, KbStore, type KbSupersededStub, type KbSyncResult, type KbTraceEdge, type KbTraceOptions, type KbTraceStep, type KbValidationProblem, type KbWarning, KbWriteConflictError, type KbWriteInput, LOG_FILE, type MatchOptions, NO_DECISION_SLUG, PINS_FILE, PINS_LOCAL_FILE, PIN_LAYERS, type QmdModule, RECORD_TYPES, SEARCH_INDEX_FILE, type SearchHit, type SearchOptions, type SymbolRange, TRACE_EDGES, adjudicate, assertBaseNotFrozen, buildContext, composeDecisionRecord, composeInputSchema, composeNoDecisionRecord, composeRecord, contextProfileBudgets, createKbMcpServer, decisionInputSchema, indexIsStale, isKbRecordType, isNoDecisionRecord, kbActorStampSchema, kbAnchorSchema, kbConceptIdSchema, kbJsonSchemas, kbLogEntrySchema, kbRecordFrontmatterSchema, kbSourceSchema, listPins, loadQmd, matchToDiff, mergedContextBudgets, parseLog, parseMarkdownWithFrontmatter, pinBase, readMergedPins, readPinsLayer, renderIndex, renderIndexLine, renderLogEntry, resolveHeads, resolveHits, resolvePinPath, runKbCli, runKbMcpServer, searchBase, selectDecisions, splitMarkdownFrontmatter, stringifyMarkdownWithFrontmatter, syncInstructions, toHookJson, trace, unpinBase, validateBundle };
+export { BaseError, CONTEXT_BEGIN, CONTEXT_END, CONTEXT_PROFILES, type ComposeInput, type ComposedRecord, DECISION_TYPE, DEFAULT_LOAD_BUDGET, DEFAULT_PACK_HOPS, DEFAULT_PACK_MAX_NODES, 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_EDGE_KINDS, KB_MATERIALITIES, KB_RECORD_STATUSES, KB_RECORD_TYPES, KB_SLUG_PATTERN, type KbActorStamp, type KbAdjudicated, type KbAnchor, KbBaseFrozenError, type KbCommand, type KbCommandContext, type KbContextBudgets, type KbContextOptions, type KbContextResult, type KbEdgeKind, KbInvalidConceptIdError, type KbLoadResult, type KbLogEntry, type KbLogReadResult, type KbLogger, type KbMergedPin, type KbMergedPins, 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, SEARCH_INDEX_FILE, type SearchHit, type SearchOptions, type SymbolRange, TRACE_EDGES, adjudicate, assertBaseNotFrozen, buildContext, composeDecisionRecord, composeInputSchema, composeNoDecisionRecord, composeRecord, contextProfileBudgets, createKbMcpServer, decisionInputSchema, edgeNeighbours, indexIsStale, isKbRecordType, isNoDecisionRecord, kbActorStampSchema, kbAnchorSchema, kbConceptIdSchema, kbJsonSchemas, kbLogEntrySchema, kbRecordFrontmatterSchema, kbSourceSchema, kbVerifiedEventSchema, listPins, loadQmd, matchToDiff, mergedContextBudgets, neighbours, pack, parseLog, parseMarkdownWithFrontmatter, pinBase, readMergedPins, readPinsLayer, renderIndex, renderIndexLine, renderLogEntry, resolveHeads, resolveHits, resolvePinPath, runKbCli, runKbMcpServer, searchBase, selectDecisions, splitMarkdownFrontmatter, stringifyMarkdownWithFrontmatter, syncInstructions, toHookJson, trace, unpinBase, validateBundle };

package/dist/index.d.ts

@@ -31,6 +31,17 @@ declare const kbActorStampSchema: z.ZodObject<{
     by: z.ZodString;
     at: z.ZodString;
 }, z.core.$loose>;
+/**
+ * A `verified[]` event as this package writes one: the actor stamp plus a
+ * required note saying what the check found. Write-side only — the frontmatter
+ * keeps reading `verified` with `kbActorStampSchema`, because OKF-native
+ * entries carry no note and a consumer must not reject conformant records.
+ */
+declare const kbVerifiedEventSchema: z.ZodObject<{
+    by: z.ZodString;
+    at: z.ZodString;
+    note: z.ZodString;
+}, z.core.$loose>;
 /**
  * Where a record attaches in the code.
  *
@@ -124,6 +135,7 @@ declare const kbRecordFrontmatterSchema: z.ZodObject<{
 }, z.core.$loose>;
 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 KbRecordFrontmatter = z.infer<typeof kbRecordFrontmatterSchema>;
 type KbRecord = {
@@ -213,12 +225,11 @@ declare function resolveHeads(from: KbRecord, byId: Map<string, KbRecord>): {
 };
 
 /**
- * Edges a trace may follow.
- *
- * Two more are conceivable and absent: `strauss_answered` carries no target id,
- * so a question's resolution lives in its own body rather than in another
- * record; and following OKF's body markdown links would need a markdown AST
- * pass this package does not yet do.
+ * Edges a trace may follow — the shared kb-edges.ts definitions, minus
+ * `body-link`: body links can reach most of a bundle from anywhere, which
+ * 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.
  */
 declare const TRACE_EDGES: readonly ["supersession", "anchor", "source"];
 type KbTraceEdge = (typeof TRACE_EDGES)[number];
@@ -248,6 +259,58 @@ type KbTraceOptions = {
  */
 declare function trace(seedId: string, bundle: KbRecord[], options?: KbTraceOptions): KbTraceStep[];
 
+declare const DEFAULT_PACK_HOPS = 2;
+declare const DEFAULT_PACK_MAX_NODES = 20;
+type KbPackOptions = {
+    /** How far from the root the walk may reach. */
+    hops?: number;
+    /** How many records the pack may hold, root included. */
+    maxNodes?: number;
+    /** Approximate token ceiling over what is actually emitted. */
+    budgetTokens?: number;
+};
+/** One record as the pack emits it — the same mapping `kb_load` hands back. */
+type KbPackedRecord = {
+    conceptId: string;
+    title: string | null;
+    standing: KbStanding;
+    supersededBy: string[];
+    warnings: KbWarning[];
+    anchors: KbAnchor[];
+    body: string;
+};
+/**
+ * Deliberately timestamp-free: the same bundle and root must produce the same
+ * bytes on every run, so a caller can diff two packs and trust that a changed
+ * byte means changed knowledge.
+ */
+type KbPackResult = {
+    root: string;
+    records: KbPackedRecord[];
+    /** Named only, exactly as `load` stubs them. Bodies reachable via trace. */
+    superseded: KbSupersededStub[];
+    /** Every reachable record the hop and node limits cut, never summarized. */
+    excluded: string[];
+    recordCount: number;
+    tokensLoaded: number;
+    budgetTokens: number;
+};
+/**
+ * A bounded, progressively disclosed neighbourhood around one record.
+ *
+ * Where `load` hands over a whole base and `trace` a timeline, a pack is the
+ * subgraph a reader needs to act near one record: everything within `hops`
+ * of the root, cut to `maxNodes` by ranking, with every cut id listed —
+ * a named gap is knowable, a silent one is not.
+ *
+ * Adjudication runs against the whole bundle, not the reached slice, so a
+ * record's standing cannot depend on whether its replacement happened to be
+ * within reach. Superseded records become the same stubs `load` emits, costed
+ * as stubs, and the budget is a refusal rather than a truncation: a partial
+ * pack looks complete to its reader.
+ */
+declare function pack(bundle: KbRecord[], rootId: string, options?: KbPackOptions): KbPackResult;
+
 declare const LOG_FILE = "log.jsonl";
 declare const kbLogEntrySchema: z.ZodObject<{
     at: z.ZodString;
@@ -298,6 +361,8 @@ type KbLogger = {
     info?(entry: Record<string, unknown>): void;
     warn?(entry: Record<string, unknown>): void;
 };
+/** Roughly an eighth of a large context window — generous, and overridable. */
+declare const DEFAULT_LOAD_BUDGET = 25000;
 /**
  * A superseded record, named but not spelled out.
  *
@@ -386,6 +451,18 @@ declare class KbStore {
      * timeouts.
      */
     setStatus(bundlePath: string, conceptId: string, status: KbRecordStatus, actor?: string): Promise<KbRecord>;
+    /**
+     * Appends one `verified[]` event: who checked the record, when, and what the
+     * check found. Append-only — prior events are history, and are spread into
+     * the new array untouched rather than reshaped through the write schema.
+     *
+     * A record's generator cannot verify its own record unless the actor is
+     * human: the generator re-reading its own output is not an independent
+     * check. The rule runs before the mutation so a refusal never publishes,
+     * and the refusal is logged under its own operation name — `mutate` only
+     * logs what it publishes.
+     */
+    verify(bundlePath: string, conceptId: string, note: string, actor?: string, at?: string): Promise<KbRecord>;
     /**
      * Marks `conceptId` superseded by `replacementId`, and links both directions.
      *
@@ -443,6 +520,8 @@ declare class KbStore {
     }): Promise<KbLoadResult>;
     /** How a position was arrived at, as a timeline. See `trace.ts`. */
     trace(bundlePath: string, seedId: string, options?: KbTraceOptions): Promise<KbTraceStep[]>;
+    /** A bounded neighbourhood around one record. See `pack.ts`. */
+    pack(bundlePath: string, rootId: string, options?: KbPackOptions): Promise<KbPackResult>;
     /**
      * The stored index, rebuilt if it disagrees with the records.
      *
@@ -521,7 +600,9 @@ declare enum Fault {
 declare enum ErrorTypes {
     KbRecordAlreadyExists = "KbRecordAlreadyExists",
     KbInvalidConceptId = "KbInvalidConceptId",
+    KbPackBudgetExceeded = "KbPackBudgetExceeded",
     KbRecordNotFound = "KbRecordNotFound",
+    KbSelfVerification = "KbSelfVerification",
     KbWriteConflict = "KbWriteConflict"
 }
 type ErrorDetails = Record<string, string | boolean | number | string[] | boolean[] | number[]>;
@@ -564,6 +645,27 @@ declare class KbWriteConflictError extends BaseError {
     readonly conceptId: string;
     constructor(conceptId: string);
 }
+/** A generator confirming its own record adds no independent check. */
+declare class KbSelfVerificationError extends BaseError {
+    readonly conceptId: string;
+    readonly actor: string;
+    readonly generatedBy: string;
+    constructor(conceptId: string, actor: string, generatedBy: string);
+}
+/**
+ * A pack that will not fit its token budget. Refusal, not truncation: a
+ * partial pack is indistinguishable from a complete one, so the caller gets
+ * the full picture — how many records, how many tokens, and every id the
+ * walk's own limits already cut — and decides whether to raise the budget or
+ * tighten the walk.
+ */
+declare class KbPackBudgetExceededError extends BaseError {
+    readonly recordCount: number;
+    readonly approxTokens: number;
+    readonly budgetTokens: number;
+    readonly excluded: string[];
+    constructor(recordCount: number, approxTokens: number, budgetTokens: number, excluded: string[]);
+}
 declare class KbInvalidConceptIdError extends BaseError {
     constructor(message: string, details: Record<string, string>);
 }
@@ -986,6 +1088,33 @@ type MatchOptions = {
 };
 declare function matchToDiff(files: DiffFile[], records: KbRecord[], options?: MatchOptions): DiffMatch[];
 
+/**
+ * The edges between records in one bundle, defined once.
+ *
+ * Both walks — `trace` and `pack` — consume this module, so they cannot drift
+ * into disagreeing about what makes two records neighbours, and a diagnostic
+ * pass over the graph can reuse the same definition.
+ *
+ * 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"];
+type KbEdgeKind = (typeof KB_EDGE_KINDS)[number];
+type KbNeighbour = {
+    record: KbRecord;
+    /** Every edge kind that connects it to the record asked about. */
+    via: KbEdgeKind[];
+};
+/**
+ * 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[];
+
 type KbValidationProblem = {
     check: string;
     conceptId: string;
@@ -1265,4 +1394,4 @@ declare function parseMarkdownWithFrontmatter<S extends z.ZodType>(text: string,
     frontmatter: ReturnType<S["safeParse"]>;
 };
 
-export { BaseError, CONTEXT_BEGIN, CONTEXT_END, CONTEXT_PROFILES, type ComposeInput, type ComposedRecord, DECISION_TYPE, 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_MATERIALITIES, KB_RECORD_STATUSES, KB_RECORD_TYPES, KB_SLUG_PATTERN, type KbActorStamp, type KbAdjudicated, type KbAnchor, KbBaseFrozenError, type KbCommand, type KbCommandContext, type KbContextBudgets, type KbContextOptions, type KbContextResult, KbInvalidConceptIdError, type KbLoadResult, type KbLogEntry, type KbLogReadResult, type KbLogger, type KbMergedPin, type KbMergedPins, 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, type KbSource, type KbStanding, KbStore, type KbSupersededStub, type KbSyncResult, type KbTraceEdge, type KbTraceOptions, type KbTraceStep, type KbValidationProblem, type KbWarning, KbWriteConflictError, type KbWriteInput, LOG_FILE, type MatchOptions, NO_DECISION_SLUG, PINS_FILE, PINS_LOCAL_FILE, PIN_LAYERS, type QmdModule, RECORD_TYPES, SEARCH_INDEX_FILE, type SearchHit, type SearchOptions, type SymbolRange, TRACE_EDGES, adjudicate, assertBaseNotFrozen, buildContext, composeDecisionRecord, composeInputSchema, composeNoDecisionRecord, composeRecord, contextProfileBudgets, createKbMcpServer, decisionInputSchema, indexIsStale, isKbRecordType, isNoDecisionRecord, kbActorStampSchema, kbAnchorSchema, kbConceptIdSchema, kbJsonSchemas, kbLogEntrySchema, kbRecordFrontmatterSchema, kbSourceSchema, listPins, loadQmd, matchToDiff, mergedContextBudgets, parseLog, parseMarkdownWithFrontmatter, pinBase, readMergedPins, readPinsLayer, renderIndex, renderIndexLine, renderLogEntry, resolveHeads, resolveHits, resolvePinPath, runKbCli, runKbMcpServer, searchBase, selectDecisions, splitMarkdownFrontmatter, stringifyMarkdownWithFrontmatter, syncInstructions, toHookJson, trace, unpinBase, validateBundle };
+export { BaseError, CONTEXT_BEGIN, CONTEXT_END, CONTEXT_PROFILES, type ComposeInput, type ComposedRecord, DECISION_TYPE, DEFAULT_LOAD_BUDGET, DEFAULT_PACK_HOPS, DEFAULT_PACK_MAX_NODES, 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_EDGE_KINDS, KB_MATERIALITIES, KB_RECORD_STATUSES, KB_RECORD_TYPES, KB_SLUG_PATTERN, type KbActorStamp, type KbAdjudicated, type KbAnchor, KbBaseFrozenError, type KbCommand, type KbCommandContext, type KbContextBudgets, type KbContextOptions, type KbContextResult, type KbEdgeKind, KbInvalidConceptIdError, type KbLoadResult, type KbLogEntry, type KbLogReadResult, type KbLogger, type KbMergedPin, type KbMergedPins, 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, SEARCH_INDEX_FILE, type SearchHit, type SearchOptions, type SymbolRange, TRACE_EDGES, adjudicate, assertBaseNotFrozen, buildContext, composeDecisionRecord, composeInputSchema, composeNoDecisionRecord, composeRecord, contextProfileBudgets, createKbMcpServer, decisionInputSchema, edgeNeighbours, indexIsStale, isKbRecordType, isNoDecisionRecord, kbActorStampSchema, kbAnchorSchema, kbConceptIdSchema, kbJsonSchemas, kbLogEntrySchema, kbRecordFrontmatterSchema, kbSourceSchema, kbVerifiedEventSchema, listPins, loadQmd, matchToDiff, mergedContextBudgets, neighbours, pack, parseLog, parseMarkdownWithFrontmatter, pinBase, readMergedPins, readPinsLayer, renderIndex, renderIndexLine, renderLogEntry, resolveHeads, resolveHits, resolvePinPath, runKbCli, runKbMcpServer, searchBase, selectDecisions, splitMarkdownFrontmatter, stringifyMarkdownWithFrontmatter, syncInstructions, toHookJson, trace, unpinBase, validateBundle };

package/dist/index.js

@@ -1,16 +1,19 @@
 import {
   runKbCli
-} from "./chunk-KQMGKSPZ.js";
+} from "./chunk-GKCG4P3L.js";
 import {
   createKbMcpServer,
   runKbMcpServer
-} from "./chunk-VOJ6D6OX.js";
+} from "./chunk-LCQKARFK.js";
 import {
   BaseError,
   CONTEXT_BEGIN,
   CONTEXT_END,
   CONTEXT_PROFILES,
   DECISION_TYPE,
+  DEFAULT_LOAD_BUDGET,
+  DEFAULT_PACK_HOPS,
+  DEFAULT_PACK_MAX_NODES,
   ErrorTypes,
   Fault,
   INDEX_FILE,
@@ -19,15 +22,18 @@ import {
   KB_CONCEPT_ID_PATTERN,
   KB_CONFIDENCES,
   KB_DIR,
+  KB_EDGE_KINDS,
   KB_MATERIALITIES,
   KB_RECORD_STATUSES,
   KB_RECORD_TYPES,
   KB_SLUG_PATTERN,
   KbBaseFrozenError,
   KbInvalidConceptIdError,
+  KbPackBudgetExceededError,
   KbPinsMalformedError,
   KbRecordAlreadyExistsError,
   KbRecordNotFoundError,
+  KbSelfVerificationError,
   KbStore,
   KbWriteConflictError,
   LOG_FILE,
@@ -47,6 +53,7 @@ import {
   composeRecord,
   contextProfileBudgets,
   decisionInputSchema,
+  edgeNeighbours,
   indexIsStale,
   isKbRecordType,
   isNoDecisionRecord,
@@ -57,9 +64,12 @@ import {
   kbLogEntrySchema,
   kbRecordFrontmatterSchema,
   kbSourceSchema,
+  kbVerifiedEventSchema,
   listPins,
   loadQmd,
   mergedContextBudgets,
+  neighbours,
+  pack,
   parseLog,
   parseMarkdownWithFrontmatter,
   pinBase,
@@ -80,7 +90,7 @@ import {
   trace,
   unpinBase,
   validateBundle
-} from "./chunk-FZIMFPGR.js";
+} from "./chunk-GKUQOJEK.js";
 
 // src/match-diff.ts
 function matchToDiff(files, records, options = {}) {
@@ -167,6 +177,9 @@ export {
   CONTEXT_END,
   CONTEXT_PROFILES,
   DECISION_TYPE,
+  DEFAULT_LOAD_BUDGET,
+  DEFAULT_PACK_HOPS,
+  DEFAULT_PACK_MAX_NODES,
   ErrorTypes,
   Fault,
   INDEX_FILE,
@@ -175,15 +188,18 @@ export {
   KB_CONCEPT_ID_PATTERN,
   KB_CONFIDENCES,
   KB_DIR,
+  KB_EDGE_KINDS,
   KB_MATERIALITIES,
   KB_RECORD_STATUSES,
   KB_RECORD_TYPES,
   KB_SLUG_PATTERN,
   KbBaseFrozenError,
   KbInvalidConceptIdError,
+  KbPackBudgetExceededError,
   KbPinsMalformedError,
   KbRecordAlreadyExistsError,
   KbRecordNotFoundError,
+  KbSelfVerificationError,
   KbStore,
   KbWriteConflictError,
   LOG_FILE,
@@ -204,6 +220,7 @@ export {
   contextProfileBudgets,
   createKbMcpServer,
   decisionInputSchema,
+  edgeNeighbours,
   indexIsStale,
   isKbRecordType,
   isNoDecisionRecord,
@@ -214,10 +231,13 @@ export {
   kbLogEntrySchema,
   kbRecordFrontmatterSchema,
   kbSourceSchema,
+  kbVerifiedEventSchema,
   listPins,
   loadQmd,
   matchToDiff,
   mergedContextBudgets,
+  neighbours,
+  pack,
   parseLog,
   parseMarkdownWithFrontmatter,
   pinBase,

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEO,SAAS,YACd,OACA,SACA,UAAwB,CAAC,GACZ;AACb,QAAM,SAAS,YAAY,QAAQ,gBAAgB,CAAC,CAAC;AACrD,QAAM,WAAW,QAAQ;AAAA,IACvB,CAAC,YAAY,OAAO,YAAY,mBAAmB,CAAC,GAAG,SAAS;AAAA,EAClE;AACA,QAAM,UAAuB,CAAC;AAE9B,aAAW,QAAQ,OAAO;AACxB,UAAM,aAAa,SAChB,IAAI,CAAC,YAAY;AAAA,MAChB;AAAA,MACA,UAAU,OAAO,YAAY,mBAAmB,CAAC,GAAG;AAAA,QAClD,CAAC,WAAW,UAAU,OAAO,IAAI,MAAM,UAAU,KAAK,QAAQ;AAAA,MAChE;AAAA,IACF,EAAE,EACD,OAAO,CAAC,EAAE,QAAQ,MAAM,QAAQ,SAAS,CAAC;AAC7C,QAAI,CAAC,WAAW,OAAQ;AAExB,eAAW,QAAQ,KAAK,OAAO;AAC7B,YAAM,OAAmB,CAAC;AAC1B,UAAI,YAAoC;AAExC,iBAAW,EAAE,QAAQ,QAAQ,KAAK,YAAY;AAC5C,cAAM,YAAY,MAAM,SAAS,KAAK,UAAU,MAAM,MAAM;AAC5D,YAAI,cAAc,OAAQ;AAC1B,YAAI,cAAc,OAAQ,aAAY;AACtC,aAAK,KAAK,MAAM;AAAA,MAClB;AAEA,UAAI,CAAC,KAAK,OAAQ;AAClB,cAAQ,KAAK;AAAA,QACX,UAAU,KAAK;AAAA,QACf;AAAA,QACA,SAAS,MAAM,WAAW,MAAM,SAAS,QAAQ,GAAG,CAAC;AAAA,QACrD;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AACT;AAWA,SAAS,MACP,SACA,UACA,MACA,QAC4B;AAC5B,MAAI,WAA4B;AAEhC,aAAW,UAAU,SAAS;AAC5B,QAAI,CAAC,OAAO,OAAQ,QAAO;AAE3B,UAAM,WAAW,OAAO,IAAI,IAAI,UAAU,OAAO,MAAM,CAAC;AACxD,QAAI,CAAC,UAAU,QAAQ;AACrB,iBAAW;AACX;AAAA,IACF;AACA,QAAI,SAAS,KAAK,CAAC,UAAU,SAAS,OAAO,IAAI,CAAC,EAAG,QAAO;AAAA,EAC9D;AAEA,SAAO;AACT;AAEA,SAAS,SAAS,OAAoB,MAAyB;AAC7D,SAAO,MAAM,aAAa,KAAK,WAAW,KAAK,aAAa,MAAM;AACpE;AAGA,SAAS,MAAM,SAA2C;AACxD,QAAM,OAA+B;AAAA,IACnC,SAAS;AAAA,IACT,WAAW;AAAA,IACX,MAAM;AAAA,IACN,YAAY;AAAA,IACZ,UAAU;AAAA,EACZ;AACA,SAAO,CAAC,GAAG,OAAO,EAAE;AAAA,IAClB,CAAC,MAAM,WACJ,KAAK,KAAK,QAAQ,KAAK,MAAM,KAAK,MAAM,QAAQ,KAAK,OACrD,KAAK,OAAO,YAAY,WAAW,MAAM,IAAI;AAAA,MAC5C,MAAM,OAAO,YAAY,WAAW,MAAM;AAAA,IAC5C;AAAA,EACJ;AACF;AAEA,SAAS,YAAY,QAAmD;AACtE,QAAM,QAAQ,oBAAI,IAA2B;AAC7C,aAAW,SAAS,QAAQ;AAC1B,UAAM,KAAK,IAAI,MAAM,MAAM,MAAM,MAAM;AACvC,UAAM,IAAI,IAAI,CAAC,GAAI,MAAM,IAAI,EAAE,KAAK,CAAC,GAAI,KAAK,CAAC;AAAA,EACjD;AACA,SAAO;AACT;AAEA,SAAS,IAAI,MAAc,QAAwB;AACjD,SAAO,GAAG,UAAU,IAAI,CAAC,IAAI,MAAM;AACrC;AAGA,SAAS,UAAU,MAAsB;AACvC,SAAO,KAAK,QAAQ,SAAS,EAAE;AACjC;","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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEO,SAAS,YACd,OACA,SACA,UAAwB,CAAC,GACZ;AACb,QAAM,SAAS,YAAY,QAAQ,gBAAgB,CAAC,CAAC;AACrD,QAAM,WAAW,QAAQ;AAAA,IACvB,CAAC,YAAY,OAAO,YAAY,mBAAmB,CAAC,GAAG,SAAS;AAAA,EAClE;AACA,QAAM,UAAuB,CAAC;AAE9B,aAAW,QAAQ,OAAO;AACxB,UAAM,aAAa,SAChB,IAAI,CAAC,YAAY;AAAA,MAChB;AAAA,MACA,UAAU,OAAO,YAAY,mBAAmB,CAAC,GAAG;AAAA,QAClD,CAAC,WAAW,UAAU,OAAO,IAAI,MAAM,UAAU,KAAK,QAAQ;AAAA,MAChE;AAAA,IACF,EAAE,EACD,OAAO,CAAC,EAAE,QAAQ,MAAM,QAAQ,SAAS,CAAC;AAC7C,QAAI,CAAC,WAAW,OAAQ;AAExB,eAAW,QAAQ,KAAK,OAAO;AAC7B,YAAM,OAAmB,CAAC;AAC1B,UAAI,YAAoC;AAExC,iBAAW,EAAE,QAAQ,QAAQ,KAAK,YAAY;AAC5C,cAAM,YAAY,MAAM,SAAS,KAAK,UAAU,MAAM,MAAM;AAC5D,YAAI,cAAc,OAAQ;AAC1B,YAAI,cAAc,OAAQ,aAAY;AACtC,aAAK,KAAK,MAAM;AAAA,MAClB;AAEA,UAAI,CAAC,KAAK,OAAQ;AAClB,cAAQ,KAAK;AAAA,QACX,UAAU,KAAK;AAAA,QACf;AAAA,QACA,SAAS,MAAM,WAAW,MAAM,SAAS,QAAQ,GAAG,CAAC;AAAA,QACrD;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AACT;AAWA,SAAS,MACP,SACA,UACA,MACA,QAC4B;AAC5B,MAAI,WAA4B;AAEhC,aAAW,UAAU,SAAS;AAC5B,QAAI,CAAC,OAAO,OAAQ,QAAO;AAE3B,UAAM,WAAW,OAAO,IAAI,IAAI,UAAU,OAAO,MAAM,CAAC;AACxD,QAAI,CAAC,UAAU,QAAQ;AACrB,iBAAW;AACX;AAAA,IACF;AACA,QAAI,SAAS,KAAK,CAAC,UAAU,SAAS,OAAO,IAAI,CAAC,EAAG,QAAO;AAAA,EAC9D;AAEA,SAAO;AACT;AAEA,SAAS,SAAS,OAAoB,MAAyB;AAC7D,SAAO,MAAM,aAAa,KAAK,WAAW,KAAK,aAAa,MAAM;AACpE;AAGA,SAAS,MAAM,SAA2C;AACxD,QAAM,OAA+B;AAAA,IACnC,SAAS;AAAA,IACT,WAAW;AAAA,IACX,MAAM;AAAA,IACN,YAAY;AAAA,IACZ,UAAU;AAAA,EACZ;AACA,SAAO,CAAC,GAAG,OAAO,EAAE;AAAA,IAClB,CAAC,MAAM,WACJ,KAAK,KAAK,QAAQ,KAAK,MAAM,KAAK,MAAM,QAAQ,KAAK,OACrD,KAAK,OAAO,YAAY,WAAW,MAAM,IAAI;AAAA,MAC5C,MAAM,OAAO,YAAY,WAAW,MAAM;AAAA,IAC5C;AAAA,EACJ;AACF;AAEA,SAAS,YAAY,QAAmD;AACtE,QAAM,QAAQ,oBAAI,IAA2B;AAC7C,aAAW,SAAS,QAAQ;AAC1B,UAAM,KAAK,IAAI,MAAM,MAAM,MAAM,MAAM;AACvC,UAAM,IAAI,IAAI,CAAC,GAAI,MAAM,IAAI,EAAE,KAAK,CAAC,GAAI,KAAK,CAAC;AAAA,EACjD;AACA,SAAO;AACT;AAEA,SAAS,IAAI,MAAc,QAAwB;AACjD,SAAO,GAAG,UAAU,IAAI,CAAC,IAAI,MAAM;AACrC;AAGA,SAAS,UAAU,MAAsB;AACvC,SAAO,KAAK,QAAQ,SAAS,EAAE;AACjC;","names":[]}