@saasontools/strauss-kb 0.1.17 → 0.1.19

package/dist/index.d.cts

@@ -68,6 +68,10 @@ declare const kbAnchorSchema: z.ZodObject<{
     repo: z.ZodOptional<z.ZodString>;
     ref: z.ZodOptional<z.ZodString>;
     hash: z.ZodOptional<z.ZodString>;
+    hash_kind: z.ZodOptional<z.ZodEnum<{
+        raw: "raw";
+        ast: "ast";
+    }>>;
     resolved_at: z.ZodOptional<z.ZodString>;
     lines: z.ZodOptional<z.ZodNumber>;
     resolver: z.ZodOptional<z.ZodEnum<{
@@ -142,6 +146,10 @@ declare const kbRecordFrontmatterSchema: z.ZodObject<{
         repo: z.ZodOptional<z.ZodString>;
         ref: z.ZodOptional<z.ZodString>;
         hash: z.ZodOptional<z.ZodString>;
+        hash_kind: z.ZodOptional<z.ZodEnum<{
+            raw: "raw";
+            ast: "ast";
+        }>>;
         resolved_at: z.ZodOptional<z.ZodString>;
         lines: z.ZodOptional<z.ZodNumber>;
         resolver: z.ZodOptional<z.ZodEnum<{
@@ -234,12 +242,23 @@ interface AnchorResolver {
     /** The richer verdict the chain uses; defaults to `resolve`. */
     attempt?(source: string, symbol: string, file?: string): ResolverAttempt;
     resolve(source: string, symbol: string, file?: string): ResolvedSymbol | null;
+    /**
+     * The span's normalised token stream — comments dropped, runs of whitespace
+     * collapsed — or `null` when this resolver cannot parse the text.
+     *
+     * Only a resolver that understands the language can offer one, which is why
+     * it is optional: a text heuristic normalising by guess would call two
+     * different programs equal.
+     */
+    normalize?(text: string, file?: string): string | null;
 }
 /** A resolved span, and which resolver produced it. */
 type AnchorResolution = {
     ok: true;
     span: ResolvedSymbol;
     resolver?: AnchorResolverName;
+    /** The span's token stream, when the resolver that spanned it can parse. */
+    normalized?: string;
 } | {
     ok: false;
     reason: AnchorUnresolvedReason;
@@ -272,6 +291,25 @@ type AnchorDriftReason = "resolver-changed";
  * commit it was taken from, and the code has moved since.
  */
 type RemoteAnchorState = "matches-ref" | "drifted-from-ref" | "drifted-on-default";
+/** What `hash` was taken over. Absent on an anchor means `raw`. */
+type AnchorHashKind = "raw" | "ast";
+/**
+ * How an anchor's code changed, once the bytes are known to differ.
+ *
+ * The classes a machine can settle, so a reader only sees the ones it cannot:
+ * `moved` and `cosmetic` are answered and closed, `gone` and `changed` are
+ * handed on. Deliberately shallow — whether the record's *claim* still holds
+ * is a reading, and no hash can stand in for one.
+ */
+declare const KB_DRIFT_CLASSES: readonly ["moved", "cosmetic", "gone", "changed"];
+type KbDriftClass = (typeof KB_DRIFT_CLASSES)[number];
+/** Where a `moved` anchor's stored hash turned up. */
+type KbDriftMovedTo = {
+    file: string;
+    symbol?: string;
+    startLine: number;
+    endLine: number;
+};
 type KbAnchorDriftEntry = {
     file: string;
     symbol?: string;
@@ -286,6 +324,17 @@ type KbAnchorDriftEntry = {
     /** Set only when the anchor was resolved against another repository. */
     repo?: string;
     remoteState?: RemoteAnchorState;
+    /** What the compared hashes were taken over. */
+    hashKind?: AnchorHashKind;
+    /**
+     * Provisional: `gone` or `changed`, the two a hash comparison alone can
+     * settle. `moved` and `cosmetic` cost a repository search and a git read, so
+     * `classifyDrift` refines this on the reassessment path rather than on every
+     * `load`.
+     */
+    class?: KbDriftClass;
+    /** Set by `classifyDrift` when the class is `moved`. */
+    movedTo?: KbDriftMovedTo;
 };
 type AnchorRead = {
     ok: true;
@@ -550,6 +599,12 @@ type KbWarningAnchor = {
     /** Set only for an anchor resolved against another repository. */
     repo?: string;
     remoteState?: string;
+    /**
+     * `gone` or `changed` — what a hash comparison alone can settle. `moved` and
+     * `cosmetic` cost a repository search and a git read, so they are
+     * `kb_reassess`'s answer, not a read path's.
+     */
+    class?: KbDriftClass;
 };
 type KbStanding = "current" | "superseded" | "rejected" | "unsettled" | "open";
 type KbAdjudicated = {
@@ -688,6 +743,22 @@ type KbPackResult = {
  */
 declare function pack(bundle: KbRecord[], rootId: string, options?: KbPackOptions): KbPackResult;
 
+/**
+ * Selection by frontmatter `tags`. Matching is exact and no vocabulary is
+ * enforced — a tag is whatever a writer put there.
+ */
+type KbTagFilter = {
+    /** AND: a record matches only when it carries every one of these. */
+    tags?: string[];
+    /** A record carrying any one of these is dropped, even if `tags` matched. */
+    excludeTags?: string[];
+};
+/**
+ * Whether one record survives the filter. An empty filter keeps everything,
+ * so every caller can pass one unconditionally.
+ */
+declare function matchesTags(record: KbRecord, filter: KbTagFilter): boolean;
+
 /** One record as the catalog names it — no body, no description, one line. */
 type KbCatalogEntry = {
     conceptId: string;
@@ -752,7 +823,7 @@ type KbCatalogResult = {
 declare function catalog(bundle: KbRecord[], options?: {
     type?: string;
     now?: Date;
-}): KbCatalogResult;
+} & KbTagFilter): KbCatalogResult;
 /**
  * One entry, as one line.
  *
@@ -965,6 +1036,15 @@ type KbStampResult = {
     /** Newest `generated.at` across the base, or null when none carries one. */
     newestAt: string | null;
     records: KbRecordStamp[];
+    /**
+     * Records with at least one anchor whose code no longer matches its hash.
+     *
+     * Outside the digest, and deliberately: drift is a fact about the working
+     * tree, not about the base's content, and folding it in would make a stamp
+     * change every time someone checked out a branch. `null` when the drift pass
+     * could not run — an unknown count, which is not zero.
+     */
+    drifted: number | null;
 };
 type KbWriteInput = {
     type: string;
@@ -1007,13 +1087,18 @@ declare class KbStore {
     /** One record by concept id, or null when it does not exist. */
     read(bundlePath: string, conceptId: string): Promise<KbRecord | null>;
     /**
-     * Every record in the bundle, optionally narrowed to one type.
+     * Every record in the bundle, optionally narrowed to one type and to the
+     * records carrying every tag in `filter.tags`. Selection only — `excludeTags`
+     * is not taken here, because `query`, `catalog` and `load` read through this
+     * and must adjudicate over the whole base.
      *
      * A file that fails to parse is skipped and logged rather than thrown: one
      * malformed record — hand-edited, or written by a producer we don't know —
      * must not make the whole bundle unreadable.
      */
-    list(bundlePath: string, type?: string): Promise<KbRecord[]>;
+    list(bundlePath: string, type?: string, filter?: {
+        tags?: string[];
+    }): Promise<KbRecord[]>;
     /**
      * Moves a record's status, preserving everything else.
      *
@@ -1071,7 +1156,7 @@ declare class KbStore {
         type?: string;
         includeNonCurrent?: boolean;
         repoRoot?: string;
-    }): Promise<KbAdjudicated[]>;
+    } & KbTagFilter): Promise<KbAdjudicated[]>;
     private rank;
     /**
      * Anchor drift over the records about to be handed back. Like the search
@@ -1133,21 +1218,28 @@ declare class KbStore {
         type?: string;
         all?: boolean;
         repoRoot?: string;
+        /** Records carrying any of these are left out. See `kb-tags.ts`. */
+        excludeTags?: string[];
     }): Promise<KbLoadResult>;
     /**
      * `load`'s digest without `load`'s bodies — the same records, adjudicated
-     * the same way, handed back as a stamp. Skips the anchor drift pass, which
-     * reads source files and only ever adds warnings: no warning reaches the
-     * digest, so the value is identical to the one `load` returns.
+     * the same way, handed back as a stamp.
+     *
+     * Drift is counted but kept out of the digest, which is what lets the reload
+     * hook ask one question and get two answers: whether the base moved, and
+     * whether the code under it did. A `load` and a `stamp` of the same base
+     * still agree on the digest, because no warning has ever reached it.
      */
-    stamp(bundlePath: string): Promise<KbStampResult>;
+    stamp(bundlePath: string, options?: {
+        repoRoot?: string;
+    }): Promise<KbStampResult>;
     /** How a position was arrived at, as a timeline. See `trace.ts`. */
     trace(bundlePath: string, seedId: string, options?: KbTraceOptions): Promise<KbTraceStep[]>;
     /** Every record named in one line each. See `catalog.ts`. */
     catalog(bundlePath: string, options?: {
         type?: string;
         now?: Date;
-    }): Promise<KbCatalogResult>;
+    } & KbTagFilter): 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`. */
@@ -1421,6 +1513,32 @@ declare class TreeSitterResolver implements AnchorResolver {
     resolve(source: string, symbol: string, file?: string): ResolvedSymbol | null;
     /** Parsed trees are keyed by content hash, so an unchanged file parses once. */
     private parse;
+    /**
+     * Every definition this file declares, as dotted symbol and span.
+     *
+     * The inverse of `attempt`: that asks "where is this name", this asks "what
+     * names are here". `moved` needs the second — the stored hash has to be
+     * looked for at every definition in the repository, and there is no name to
+     * ask about, since the whole question is which name now carries that code.
+     */
+    spans(source: string, file: string): {
+        symbol: string;
+        span: ResolvedSymbol;
+    }[];
+    /**
+     * The token stream of a span: every leaf the parser sees, comments dropped,
+     * joined by single spaces.
+     *
+     * This is what makes a reformat not be drift. Hashing it rather than the raw
+     * text means indentation, line breaks, trailing commas the formatter moved,
+     * and every comment above or inside the definition are outside the hash —
+     * and a renamed identifier or a changed literal is still inside it, because
+     * those are leaves.
+     *
+     * `null` when the file has no grammar, the grammar would not load, or the
+     * text will not parse: no normalisation is better than a guessed one.
+     */
+    normalize(text: string, file?: string): string | null;
     /** Drops cached trees. Grammars stay loaded — they are immutable. */
     reset(): void;
 }
@@ -1520,6 +1638,10 @@ declare const composeInputSchema: z.ZodObject<{
         repo: z.ZodOptional<z.ZodString>;
         ref: z.ZodOptional<z.ZodString>;
         hash: z.ZodOptional<z.ZodString>;
+        hash_kind: z.ZodOptional<z.ZodEnum<{
+            raw: "raw";
+            ast: "ast";
+        }>>;
         resolved_at: z.ZodOptional<z.ZodString>;
         lines: z.ZodOptional<z.ZodNumber>;
         resolver: z.ZodOptional<z.ZodEnum<{
@@ -1662,9 +1784,15 @@ declare const pinsManifestSchema: z.ZodObject<{
 }, z.core.$loose>;
 type KbPin = z.infer<typeof pinSchema>;
 type KbPinsManifest = z.infer<typeof pinsManifestSchema>;
+/** One profile's `context` settings, from the manifest or the built-ins. */
 type KbContextBudgets = {
     budgetTokens?: number;
     fullUnderTokens?: number;
+    /**
+     * Frontmatter tags whose records this profile leaves out of the block —
+     * `review`, say, kept out of session-start without unpinning the base.
+     */
+    excludeTags?: string[];
 };
 /** A pin as the merged view hands it back: entry + where it came from. */
 type KbMergedPin = KbPin & {
@@ -1804,6 +1932,12 @@ type KbContextOptions = {
      * name.
      */
     profile?: string;
+    /**
+     * Frontmatter tags whose records stay out of the block. Resolved like the
+     * budgets, and a profile setting rather than a pin's: it says what this
+     * context birth wants, so a base stays pinned and stays readable by tool.
+     */
+    excludeTags?: string[];
     /**
      * Where budget pressure is reported outside the block itself: a full pin
      * that had to degrade to an index, a block that refused. The block already
@@ -2128,6 +2262,10 @@ declare const decisionInputSchema: z.ZodObject<{
         repo: z.ZodOptional<z.ZodString>;
         ref: z.ZodOptional<z.ZodString>;
         hash: z.ZodOptional<z.ZodString>;
+        hash_kind: z.ZodOptional<z.ZodEnum<{
+            raw: "raw";
+            ast: "ast";
+        }>>;
         resolved_at: z.ZodOptional<z.ZodString>;
         lines: z.ZodOptional<z.ZodNumber>;
         resolver: z.ZodOptional<z.ZodEnum<{
@@ -2253,6 +2391,189 @@ type KbCommand<Shape extends z.ZodRawShape = z.ZodRawShape> = {
 declare const KB_COMMANDS: KbCommand[];
 declare const KB_COMMANDS_BY_NAME: Map<string, KbCommand>;
 
+/** Where a recovered file came from, so a packet can say how far back it looked. */
+type OldSourceOrigin = 
+/** `git show <anchor.ref>:<file>` — the rev the record itself named. */
+{
+    kind: "ref";
+    ref: string;
+}
+/** The last commit touching the path before `resolved_at`. */
+ | {
+    kind: "history";
+    ref: string;
+};
+
+type MovedSearch = {
+    /**
+     * Where this anchor's stored hash turned up, or `undefined`.
+     *
+     * Shared across every anchor of a run: one `git ls-files`, one parse cache,
+     * one set of loaded grammars. A `doctor --drifted` sweep over a base whose
+     * records anchor into the same few languages parses each candidate once, not
+     * once per drifted anchor.
+     */
+    find(anchor: KbAnchor): Promise<KbDriftMovedTo | undefined>;
+};
+
+/**
+ * Turning "the bytes changed" into one of four answers, two of which end the
+ * matter.
+ *
+ * The order is not arbitrary: `moved` is asked first because it is the only
+ * class that needs no history at all, and `cosmetic` second because it is the
+ * only one that needs the old text. What survives both is what a reader has to
+ * read — and the whole point of asking the cheap questions first is that most
+ * drift never reaches them.
+ *
+ * Everything here is read-only. Rebaselining a `moved` anchor is a write, and
+ * writes belong to the verb the caller named.
+ */
+type ClassifiedAnchor = {
+    anchor: KbAnchor;
+    entry: KbAnchorDriftEntry;
+    /** Resolved class. Never `undefined` — every reported anchor gets one. */
+    class: KbDriftClass;
+    /** The anchored text as it stands now. Absent when the class is `gone`. */
+    newText?: string;
+    /** The anchored text as it was, when history could produce it. */
+    oldText?: string;
+    oldOrigin?: OldSourceOrigin;
+};
+type ClassifyOptions = {
+    /** Test seam: replaces the disk reader. */
+    reader?: AnchorFileReader;
+    /** Skip the history read. `cosmetic` cannot be reached without it. */
+    withHistory?: boolean;
+    /**
+     * The run's shared `moved` search. A sweep classifying many records passes
+     * one, so the repository is listed once and each candidate file is parsed
+     * once for the whole sweep rather than once per record.
+     */
+    search?: MovedSearch;
+};
+/**
+ * Refines one record's drift entries. Anchors that matched, or that name
+ * another repository, are not drift and never appear.
+ */
+declare function classifyDrift(repoRoot: string, record: KbRecord, entries: readonly KbAnchorDriftEntry[], options?: ClassifyOptions): Promise<ClassifiedAnchor[]>;
+
+type UnifiedDiff = {
+    /** `-`/`+`/` ` prefixed lines, with a `@@` header. */
+    text: string;
+    added: number;
+    removed: number;
+    /** Whether the cap cut it short. */
+    truncated: boolean;
+};
+/**
+ * One hunk, no context trimming: the two sides are already a symbol's span,
+ * so the whole of both is the context a reader wants.
+ *
+ * The common subsequence is computed over line *hashes* through a simple
+ * O(n·m) table. Spans are bounded by the anchor file cap, and a smarter
+ * algorithm would be a second thing to be wrong about for a saving nobody can
+ * measure at this size.
+ */
+declare function unifiedDiff(before: string, after: string, options?: {
+    maxLines?: number;
+    oldLabel?: string;
+    newLabel?: string;
+}): UnifiedDiff;
+
+/**
+ * What a reader needs in order to decide whether a record still holds, without
+ * opening the repository.
+ *
+ * A drift finding today says two hashes disagree, which is not a thing anyone
+ * can judge. The packet is the same finding with the three pieces judgment
+ * actually takes: what the record claims, what the code did, and what depends
+ * on the answer. It stops there — the reading itself is the reader's, and
+ * every default below is a starting point the protocol expects to be argued
+ * with.
+ */
+type KbReassessDiff = {
+    status: "ok";
+    /** `ref` when the anchor pinned one, `history` when it was inferred. */
+    source: "ref" | "history";
+    /** The rev the old side was read at. */
+    ref: string;
+    unified: string;
+    added: number;
+    removed: number;
+    truncated: boolean;
+}
+/** No committed text to diff against; see `readOldSource`. */
+ | {
+    status: "unrecoverable";
+};
+type KbReassessAnchor = {
+    file: string;
+    symbol?: string;
+    class: KbDriftClass;
+    reason?: string;
+    storedHash: string;
+    currentHash?: string;
+    diffSize: number | null;
+    movedTo?: KbDriftMovedTo;
+    diff?: KbReassessDiff;
+};
+/**
+ * What the type says about a record whose code changed under it.
+ *
+ * A `fact` is a claim about the world that the code was the evidence for, so
+ * changed evidence presumptively unmakes it. A `decision` is a claim about a
+ * choice, and the reasoning for a choice routinely outlives the code that
+ * implemented it. Neither is a verdict — they are which way to lean while
+ * reading, and naming the lean is what keeps it arguable.
+ */
+type KbReassessDefault = "presumed-invalidated" | "rationale-may-survive" | "review";
+type KbReassessPacket = {
+    conceptId: string;
+    title: string | null;
+    type: string;
+    standing: KbStanding;
+    /** What breaks if this record is wrong — the record's `why`, stored as `description`. */
+    why: string | null;
+    /** The type's claim section — the sentence being reassessed. */
+    claim: {
+        section: string;
+        text: string;
+    } | null;
+    anchors: KbReassessAnchor[];
+    /**
+     * The record's dependants. A fact that stopped holding did not stop holding
+     * alone, and a reader deciding about it is deciding about these too.
+     */
+    impact: {
+        conceptId: string;
+        title: string | null;
+        standing: KbStanding;
+        depth: number;
+    }[];
+    impactTruncated: boolean;
+    default: KbReassessDefault;
+    defaultNote: string;
+};
+type PacketOptions = ClassifyOptions & {
+    /** Recover and render the old-vs-new span diff. Off by default: it reads git. */
+    withDiff?: boolean;
+    impact?: KbImpactResult;
+    standing?: KbStanding;
+};
+/**
+ * One record's packet, or `null` when nothing survived classification.
+ *
+ * A record whose every drifted anchor turned out to be `moved` or `cosmetic`
+ * is a record with no reassessment work, and emitting an empty packet for it
+ * would put it back in front of the reader the classification just cleared it
+ * from.
+ */
+declare function reassessPacket(repoRoot: string, record: KbRecord, entries: readonly KbAnchorDriftEntry[], options?: PacketOptions): Promise<{
+    packet: KbReassessPacket | null;
+    classified: ClassifiedAnchor[];
+}>;
+
 /**
  * A knowledge base's own MCP server, over stdio.
  *
@@ -2385,4 +2706,4 @@ declare function parseMarkdownWithFrontmatter<S extends z.ZodType>(text: string,
     frontmatter: ReturnType<S["safeParse"]>;
 };
 
-export { type AnchorResolution, type AnchorResolver, type AnchorResolverName, 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, type Grammar, type GrammarManifest, type GrammarOptions, 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 RemoteAnchorState, type RemoteOptions, type RemoteRead, type ResolvedSymbol, type ResolverAttempt, SEARCH_INDEX_FILE, type SearchHit, type SearchOptions, type SymbolRange, TRACE_EDGES, TreeSitterResolver, adjudicate, anchorFilePath, assertBaseNotFrozen, backlinks, buildContext, catalog, composeDecisionRecord, composeInputSchema, composeLinkSchema, composeNoDecisionRecord, composeRecord, contextProfileBudgets, createKbMcpServer, decisionInputSchema, defaultAnchorResolvers, detectAnchorDrift, doctor, edgeNeighbours, ensureGrammar, grammarHints, grammarManifest, grammarsCacheRoot, hashAnchorText, impact, inboundIndex, indexIsStale, isCanonicalRepoUrl, isKbLinkRel, isKbRecordType, isNoDecisionRecord, kbActorStampSchema, kbAnchorSchema, kbConceptIdSchema, kbJsonSchemas, kbLinkSchema, kbLogEntrySchema, kbRecordFrontmatterSchema, kbSourceSchema, kbVerifiedEventSchema, languageForFile, listPins, loadQmd, matchToDiff, mergedContextBudgets, neighbours, pack, parseLog, parseMarkdownWithFrontmatter, pinBase, prepareResolvers, readMergedPins, readPinsLayer, readRemoteAnchors, regexResolver, renderCatalogLine, renderIndex, renderIndexLine, renderLogEntry, repoCacheDir, resolveAnchor, resolveAnchorSpan, resolveHeads, resolveHits, resolvePinPath, runKbCli, runKbMcpServer, searchBase, selectDecisions, splitMarkdownFrontmatter, stringifyMarkdownWithFrontmatter, syncInstructions, toHookJson, trace, treeSitterLanguages, unpinBase, validateBundle };
+export { type AnchorResolution, type AnchorResolver, type AnchorResolverName, BaseError, CONTEXT_BEGIN, CONTEXT_END, CONTEXT_PROFILES, type ClassifiedAnchor, 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, type Grammar, type GrammarManifest, type GrammarOptions, 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 KbReassessAnchor, type KbReassessDefault, type KbReassessDiff, type KbReassessPacket, 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 KbTagFilter, 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 RemoteAnchorState, type RemoteOptions, type RemoteRead, type ResolvedSymbol, type ResolverAttempt, SEARCH_INDEX_FILE, type SearchHit, type SearchOptions, type SymbolRange, TRACE_EDGES, TreeSitterResolver, adjudicate, anchorFilePath, assertBaseNotFrozen, backlinks, buildContext, catalog, classifyDrift, composeDecisionRecord, composeInputSchema, composeLinkSchema, composeNoDecisionRecord, composeRecord, contextProfileBudgets, createKbMcpServer, decisionInputSchema, defaultAnchorResolvers, detectAnchorDrift, doctor, edgeNeighbours, ensureGrammar, grammarHints, grammarManifest, grammarsCacheRoot, hashAnchorText, impact, inboundIndex, indexIsStale, isCanonicalRepoUrl, isKbLinkRel, isKbRecordType, isNoDecisionRecord, kbActorStampSchema, kbAnchorSchema, kbConceptIdSchema, kbJsonSchemas, kbLinkSchema, kbLogEntrySchema, kbRecordFrontmatterSchema, kbSourceSchema, kbVerifiedEventSchema, languageForFile, listPins, loadQmd, matchToDiff, matchesTags, mergedContextBudgets, neighbours, pack, parseLog, parseMarkdownWithFrontmatter, pinBase, prepareResolvers, readMergedPins, readPinsLayer, readRemoteAnchors, reassessPacket, regexResolver, renderCatalogLine, renderIndex, renderIndexLine, renderLogEntry, repoCacheDir, resolveAnchor, resolveAnchorSpan, resolveHeads, resolveHits, resolvePinPath, runKbCli, runKbMcpServer, searchBase, selectDecisions, splitMarkdownFrontmatter, stringifyMarkdownWithFrontmatter, syncInstructions, toHookJson, trace, treeSitterLanguages, unifiedDiff, unpinBase, validateBundle };