@saasontools/strauss-kb 0.1.21 → 0.1.23

package/dist/index.d.ts

@@ -91,9 +91,9 @@ declare const kbAnchorSchema: z.ZodObject<{
     resolved_at: z.ZodOptional<z.ZodString>;
     lines: z.ZodOptional<z.ZodNumber>;
     resolver: z.ZodOptional<z.ZodEnum<{
-        span: "span";
         "tree-sitter": "tree-sitter";
         regex: "regex";
+        span: "span";
     }>>;
 }, z.core.$strict>;
 /**
@@ -124,10 +124,30 @@ declare const kbAnchorWriteSchema: z.ZodObject<{
     resolved_at: z.ZodOptional<z.ZodString>;
     lines: z.ZodOptional<z.ZodNumber>;
     resolver: z.ZodOptional<z.ZodEnum<{
-        span: "span";
         "tree-sitter": "tree-sitter";
         regex: "regex";
+        span: "span";
+    }>>;
+}, z.core.$strict>;
+/**
+ * An anchor's address, with none of the baseline a resolver stamps: a `hash`
+ * under a locator is an unknown key. Picked rather than respelled, so a new
+ * locator field on the anchor is one here too. See
+ * `contract.anchor-locator-is-the-address-half-of-an-anchor`.
+ */
+declare const kbAnchorLocatorSchema: z.ZodObject<{
+    symbol: z.ZodOptional<z.ZodString>;
+    span: z.ZodOptional<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, z.core.$strict>>;
+    file: z.ZodString;
+    ref: z.ZodOptional<z.ZodString>;
+    side: z.ZodOptional<z.ZodEnum<{
+        old: "old";
+        new: "new";
     }>>;
+    repo: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 /**
  * One typed causal edge, as the frontmatter stores it.
@@ -211,9 +231,9 @@ declare const kbRecordFrontmatterSchema: z.ZodObject<{
         resolved_at: z.ZodOptional<z.ZodString>;
         lines: z.ZodOptional<z.ZodNumber>;
         resolver: z.ZodOptional<z.ZodEnum<{
-            span: "span";
             "tree-sitter": "tree-sitter";
             regex: "regex";
+            span: "span";
         }>>;
     }, z.core.$strict>>>;
     strauss_verify: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -222,11 +242,11 @@ declare const kbRecordFrontmatterSchema: z.ZodObject<{
         rel: z.ZodString;
     }, z.core.$loose>>>;
     strauss_status: z.ZodDefault<z.ZodEnum<{
+        resolved: "resolved";
         draft: "draft";
         proposed: "proposed";
         accepted: "accepted";
         open: "open";
-        resolved: "resolved";
         rejected: "rejected";
         superseded: "superseded";
     }>>;
@@ -254,6 +274,7 @@ type KbActorStamp = z.infer<typeof kbActorStampSchema>;
 type KbVerifiedEvent = z.infer<typeof kbVerifiedEventSchema>;
 type KbAnchorSpan = z.infer<typeof kbAnchorSpanSchema>;
 type KbAnchor = z.infer<typeof kbAnchorSchema>;
+type KbAnchorLocator = z.infer<typeof kbAnchorLocatorSchema>;
 type KbLink = z.infer<typeof kbLinkSchema>;
 type KbRecordFrontmatter = z.infer<typeof kbRecordFrontmatterSchema>;
 type KbRecord = {
@@ -1032,14 +1053,187 @@ declare function impact(targetId: string, bundle: KbRecord[], options?: KbImpact
 declare function inboundIndex(bundle: KbRecord[]): Map<string, KbInboundEdge[]>;
 
 declare const LOG_FILE = "log.jsonl";
+/**
+ * One pointer change, as an `anchor-set` entry records it: `from` for a move or
+ * a drop, `to` for a move or an addition. Locators only — the log says which
+ * pointer moved, never what it was hashed against. Derived from the record
+ * before and after, so it reports what happened rather than what was asked.
+ */
+declare const kbLogAnchorChangeSchema: z.ZodObject<{
+    op: z.ZodEnum<{
+        move: "move";
+        add: "add";
+        drop: "drop";
+    }>;
+    from: z.ZodOptional<z.ZodObject<{
+        symbol: z.ZodOptional<z.ZodString>;
+        span: z.ZodOptional<z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+        }, z.core.$strict>>;
+        file: z.ZodString;
+        ref: z.ZodOptional<z.ZodString>;
+        side: z.ZodOptional<z.ZodEnum<{
+            old: "old";
+            new: "new";
+        }>>;
+        repo: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    to: z.ZodOptional<z.ZodObject<{
+        symbol: z.ZodOptional<z.ZodString>;
+        span: z.ZodOptional<z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+        }, z.core.$strict>>;
+        file: z.ZodString;
+        ref: z.ZodOptional<z.ZodString>;
+        side: z.ZodOptional<z.ZodEnum<{
+            old: "old";
+            new: "new";
+        }>>;
+        repo: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const kbLogEntryFields: z.ZodObject<{
+    at: z.ZodISODateTime;
+    by: z.ZodString;
+    operation: z.ZodString;
+    conceptId: z.ZodString;
+    target: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        op: z.ZodEnum<{
+            move: "move";
+            add: "add";
+            drop: "drop";
+        }>;
+        from: z.ZodOptional<z.ZodObject<{
+            symbol: z.ZodOptional<z.ZodString>;
+            span: z.ZodOptional<z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodNumber;
+            }, z.core.$strict>>;
+            file: z.ZodString;
+            ref: z.ZodOptional<z.ZodString>;
+            side: z.ZodOptional<z.ZodEnum<{
+                old: "old";
+                new: "new";
+            }>>;
+            repo: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        to: z.ZodOptional<z.ZodObject<{
+            symbol: z.ZodOptional<z.ZodString>;
+            span: z.ZodOptional<z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodNumber;
+            }, z.core.$strict>>;
+            file: z.ZodString;
+            ref: z.ZodOptional<z.ZodString>;
+            side: z.ZodOptional<z.ZodEnum<{
+                old: "old";
+                new: "new";
+            }>>;
+            repo: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+}, z.core.$strip>;
+/**
+ * Read-side, and tolerant of a key it has never heard of: one base is read by
+ * every version that touches the repository, so a log has to read *forward*.
+ * Under `.strict()` the first version to add a field turned its own entries
+ * into `malformed` for every older reader — the entries an audit most needs
+ * were the only ones that vanished. A line missing a required field, or
+ * carrying an `at` that is not an ISO datetime, is still malformed.
+ */
 declare const kbLogEntrySchema: z.ZodObject<{
     at: z.ZodISODateTime;
     by: z.ZodString;
     operation: z.ZodString;
     conceptId: z.ZodString;
     target: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        op: z.ZodEnum<{
+            move: "move";
+            add: "add";
+            drop: "drop";
+        }>;
+        from: z.ZodOptional<z.ZodObject<{
+            symbol: z.ZodOptional<z.ZodString>;
+            span: z.ZodOptional<z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodNumber;
+            }, z.core.$strict>>;
+            file: z.ZodString;
+            ref: z.ZodOptional<z.ZodString>;
+            side: z.ZodOptional<z.ZodEnum<{
+                old: "old";
+                new: "new";
+            }>>;
+            repo: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        to: z.ZodOptional<z.ZodObject<{
+            symbol: z.ZodOptional<z.ZodString>;
+            span: z.ZodOptional<z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodNumber;
+            }, z.core.$strict>>;
+            file: z.ZodString;
+            ref: z.ZodOptional<z.ZodString>;
+            side: z.ZodOptional<z.ZodEnum<{
+                old: "old";
+                new: "new";
+            }>>;
+            repo: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+}, z.core.$loose>;
+/** Write-side: this package controls exactly what it appends. */
+declare const kbLogEntryWriteSchema: z.ZodObject<{
+    at: z.ZodISODateTime;
+    by: z.ZodString;
+    operation: z.ZodString;
+    conceptId: z.ZodString;
+    target: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        op: z.ZodEnum<{
+            move: "move";
+            add: "add";
+            drop: "drop";
+        }>;
+        from: z.ZodOptional<z.ZodObject<{
+            symbol: z.ZodOptional<z.ZodString>;
+            span: z.ZodOptional<z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodNumber;
+            }, z.core.$strict>>;
+            file: z.ZodString;
+            ref: z.ZodOptional<z.ZodString>;
+            side: z.ZodOptional<z.ZodEnum<{
+                old: "old";
+                new: "new";
+            }>>;
+            repo: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        to: z.ZodOptional<z.ZodObject<{
+            symbol: z.ZodOptional<z.ZodString>;
+            span: z.ZodOptional<z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodNumber;
+            }, z.core.$strict>>;
+            file: z.ZodString;
+            ref: z.ZodOptional<z.ZodString>;
+            side: z.ZodOptional<z.ZodEnum<{
+                old: "old";
+                new: "new";
+            }>>;
+            repo: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
-type KbLogEntry = z.infer<typeof kbLogEntrySchema>;
+type KbLogEntry = z.infer<typeof kbLogEntryFields>;
+type KbLogAnchorChange = z.infer<typeof kbLogAnchorChangeSchema>;
 /**
  * The log is the bundle's only primary artifact, and the reason it is handled
  * unlike `INDEX.md`.
@@ -1156,6 +1350,14 @@ type KbWriteInput = {
     /** Replace an existing record rather than failing on the collision. */
     overwrite?: boolean;
 };
+/**
+ * What a patching caller hands `updateAnchors`. Omitting `log` keeps the
+ * default `anchor-resolve` entry.
+ */
+type KbAnchorWrite = {
+    anchors: KbAnchor[];
+    log?: Omit<KbLogEntry, "at" | "conceptId" | "by">;
+};
 /** What a record had to still be for `deleteRecord` to remove it. */
 type KbDeleteExpectation = {
     tag: string;
@@ -1220,16 +1422,12 @@ declare class KbStore {
      */
     setStatus(bundlePath: string, conceptId: string, status: KbRecordStatus, actor?: string): Promise<KbRecord>;
     /**
-     * Replaces a record's anchors wholesale, preserving everything else.
-     *
-     * Wholesale rather than merged: the caller just resolved the anchors it is
-     * writing, so it holds the complete current set, and a merge would keep
-     * stale entries the resolution pass deliberately dropped.
-     *
-     * Through the write schema: this is a write, and a defect a hand-edit put in
-     * the frontmatter must not be published back out under an actor stamp.
+     * Replaces a record's anchors, preserving everything else. An array is the
+     * whole set; a function is a patch and runs inside the mutation, against
+     * the anchors the record holds then — see
+     * `decision.anchor-update-patch-inside-mutation`.
      */
-    updateAnchors(bundlePath: string, conceptId: string, anchors: KbAnchor[], actor?: string): Promise<KbRecord>;
+    updateAnchors(bundlePath: string, conceptId: string, anchors: KbAnchor[] | ((current: KbAnchor[]) => KbAnchorWrite), 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
@@ -1500,6 +1698,7 @@ declare enum Fault {
 /** Machine-readable discriminant, stable across message rewording. */
 declare enum ErrorTypes {
     KbRecordAlreadyExists = "KbRecordAlreadyExists",
+    KbAnchorSetDuplicate = "KbAnchorSetDuplicate",
     KbClassifyInput = "KbClassifyInput",
     KbFlagConflict = "KbFlagConflict",
     KbInvalidActor = "KbInvalidActor",
@@ -1826,9 +2025,9 @@ declare const composeInputSchema: z.ZodObject<{
         resolved_at: z.ZodOptional<z.ZodString>;
         lines: z.ZodOptional<z.ZodNumber>;
         resolver: z.ZodOptional<z.ZodEnum<{
-            span: "span";
             "tree-sitter": "tree-sitter";
             regex: "regex";
+            span: "span";
         }>>;
     }, z.core.$strict>>>;
     sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -2634,9 +2833,9 @@ declare const decisionInputSchema: z.ZodObject<{
         resolved_at: z.ZodOptional<z.ZodString>;
         lines: z.ZodOptional<z.ZodNumber>;
         resolver: z.ZodOptional<z.ZodEnum<{
-            span: "span";
             "tree-sitter": "tree-sitter";
             regex: "regex";
+            span: "span";
         }>>;
     }, z.core.$strict>>>;
     verify: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -2693,6 +2892,118 @@ declare function selectDecisions(records: KbRecord[]): KbRecord[];
 declare const KB_COMMANDS: KbCommand[];
 declare const KB_COMMANDS_BY_NAME: Map<string, KbCommand>;
 
+/** One change the write made, as the result and the log entry report it. */
+type KbAnchorChange = {
+    /** `move` keeps a baseline under a new address; `add` and `drop` are plain. */
+    op: "move" | "add" | "drop";
+    from?: KbAnchorLocator;
+    to?: KbAnchorLocator;
+};
+type KbAnchorSetOutcome = {
+    anchors: KbAnchor[];
+    changes: KbAnchorChange[];
+};
+/**
+ * Checks a proposed anchor set and says what changed against the current one.
+ * Accepted as given — whether the code behind a pointer was read is the
+ * caller's claim, recorded in the log, not something this can check. Refuses
+ * only two anchors at one address.
+ */
+declare function applyAnchorSet(current: KbAnchor[], incoming: KbAnchor[]): KbAnchorSetOutcome;
+/** An anchor's address, without the baseline a resolver stamped onto it. */
+declare function locatorOf(anchor: KbAnchor): KbAnchorLocator;
+
+/** Two anchors at one address: they would drift and rebaseline as a pair. */
+declare class KbAnchorSetDuplicateError extends BaseError {
+    readonly locator: string;
+    constructor(locator: string);
+}
+
+/**
+ * What the run did about an anchor it set out to write. `applied` is set only
+ * after the record is persisted, so a report never claims a baseline the store
+ * does not hold.
+ */
+type AnchorUpdateOutcome = "applied" | "skipped" | "failed";
+/** Why an intended write did not happen. */
+type AnchorUpdateReason = "frozen" | "write-failed" | "pinned-ref";
+type AnchorResolveResult = {
+    file: string;
+    symbol?: string;
+    /** Set only for `side: "old"`: resolved at `ref`, never in the working tree. */
+    side?: "old";
+    /** `unstamped`: no hash yet, and nothing wrote one. */
+    state: "stamped" | "unstamped" | "match" | "drifted" | "unresolved";
+    storedHash?: string;
+    currentHash?: string;
+    /** What the compared hashes were taken over. */
+    hashKind?: AnchorHashKind;
+    /** `null` when the anchor recorded no `lines` — size unknown, not zero. */
+    diffSize?: number | null;
+    reason?: AnchorUnresolvedReason | AnchorDriftReason;
+    resolver?: AnchorResolverName;
+    /** Set only where a baseline write was due: the comparison is `state`. */
+    outcome?: AnchorUpdateOutcome;
+    outcomeReason?: AnchorUpdateReason;
+    rebaselined?: boolean;
+    /** Set only when the anchor was resolved against another repository. */
+    repo?: string;
+    remoteState?: RemoteAnchorState;
+};
+
+/**
+ * The record's anchors, as the caller means them to end up.
+ *
+ * A whole set rather than a patch: the caller has just read the record, so it
+ * holds every anchor including its baseline, and carrying one forward under a
+ * new symbol is a field edit rather than an operation to name.
+ */
+declare const anchorSetInputSchema: z.ZodObject<{
+    reason: z.ZodString;
+    anchors: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        symbol: z.ZodOptional<z.ZodString>;
+        span: z.ZodOptional<z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+        }, z.core.$strict>>;
+        side: z.ZodOptional<z.ZodEnum<{
+            old: "old";
+            new: "new";
+        }>>;
+        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<{
+            "tree-sitter": "tree-sitter";
+            regex: "regex";
+            span: "span";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type AnchorSetInput = z.infer<typeof anchorSetInputSchema>;
+type KbAnchorSetResult = {
+    conceptId: string;
+    reason: string;
+    /** Unchanged anchors are not listed; a no-op write reports nothing. */
+    changes: KbAnchorChange[];
+    anchors: KbAnchor[];
+    /**
+     * `unchanged` without `resolve`; with it, `stamped` only when every anchor
+     * matched or its write was `applied`, else `incomplete`.
+     */
+    baseline: "unchanged" | "stamped" | "incomplete";
+    /** anchor-resolve's per-anchor results, when `resolve` ran. */
+    resolved?: AnchorResolveResult[];
+    note: string;
+};
+
 /**
  * Listing candidates and promoting share one input, and the two need different
  * arguments. The rule lives here rather than in `run` so both surfaces refuse
@@ -3082,4 +3393,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 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_THRESHOLDS, 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_CLASSES, 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 KbAnchorSpan, type KbBacklink, type KbBacklinksResult, KbBaseFrozenError, type KbCatalogEntry, type KbCatalogResult, type KbClass, type KbClassifiedFile, type KbClassifiedHunk, type KbClassifyFile, KbClassifyInputError, type KbClassifyOptions, type KbClassifyResult, type KbClassifyThresholds, type KbCommand, type KbCommandContext, type KbContextBudgets, type KbContextOptions, type KbContextResult, type KbDoctorCheck, type KbDoctorFinding, type KbDoctorGroup, type KbDoctorOptions, type KbDoctorReport, type KbDoctorThresholds, type KbDroppedLink, type KbEdgeKind, type KbExportForeignFile, type KbExportResult, type KbExportedDecision, 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 KbMatch, type KbMatchRecord, 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 KbPromoteCandidate, KbPromoteCollisionError, type KbPromoteResult, KbPromoteSelfError, KbPromoteStandingError, KbPromoteStoppedError, type KbPromotedRecord, 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 KbVerdict, type KbVerifiedEvent, type KbWarning, KbWriteConflictError, type KbWriteInput, LINK_RELS, LOG_FILE, type MatchOptions, NO_DECISION_SLUG, PINS_FILE, PINS_LOCAL_FILE, PIN_LAYERS, PROMOTION_SOURCE_ID, type QmdModule, RECORD_TYPES, type RemoteAnchorState, type RemoteOptions, type RemoteRead, type ResolvedSymbol, type ResolverAttempt, type ResolverAttemptOptions, SEARCH_INDEX_FILE, type SearchHit, type SearchOptions, type SymbolRange, type SymbolRangeIndex, TRACE_EDGES, TreeSitterResolver, adjudicate, anchorFilePath, anchorOnHunk, assertBaseNotFrozen, backlinks, buildContext, carry, catalog, classifyDiff, 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, isReviewTag, kbActorStampSchema, kbAnchorSchema, kbAnchorSpanSchema, kbAnchorWriteSchema, kbConceptIdSchema, kbJsonSchemas, kbLinkSchema, kbLogEntrySchema, kbRecordFrontmatterSchema, kbSourceSchema, kbVerifiedEventSchema, languageForFile, listPins, loadQmd, matchToDiff, matchesTags, mergedContextBudgets, neighbours, pack, parseLog, parseMarkdownWithFrontmatter, pinBase, prepareResolvers, promoteCandidates, promoteInputSchema, readMergedPins, readPinsLayer, readRemoteAnchors, reassessPacket, regexResolver, renderCatalogLine, renderIndex, renderIndexLine, renderLogEntry, repoCacheDir, resolveAnchor, resolveAnchorSpan, resolveHeads, resolveHits, resolvePinPath, runKbCli, runKbMcpServer, searchBase, selectDecisions, splitMarkdownFrontmatter, stringifyMarkdownWithFrontmatter, symbolRangeIndex, syncInstructions, toHookJson, trace, treeSitterLanguages, unifiedDiff, unpinBase, validateBundle };
+export { type AnchorResolution, type AnchorResolver, type AnchorResolverName, type AnchorSetInput, 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_THRESHOLDS, 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_CLASSES, 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 KbAnchorChange, type KbAnchorDriftEntry, type KbAnchorLocator, KbAnchorSetDuplicateError, type KbAnchorSetOutcome, type KbAnchorSetResult, type KbAnchorSpan, type KbAnchorWrite, type KbBacklink, type KbBacklinksResult, KbBaseFrozenError, type KbCatalogEntry, type KbCatalogResult, type KbClass, type KbClassifiedFile, type KbClassifiedHunk, type KbClassifyFile, KbClassifyInputError, type KbClassifyOptions, type KbClassifyResult, type KbClassifyThresholds, type KbCommand, type KbCommandContext, type KbContextBudgets, type KbContextOptions, type KbContextResult, type KbDoctorCheck, type KbDoctorFinding, type KbDoctorGroup, type KbDoctorOptions, type KbDoctorReport, type KbDoctorThresholds, type KbDroppedLink, type KbEdgeKind, type KbExportForeignFile, type KbExportResult, type KbExportedDecision, type KbImpactOptions, type KbImpactResult, type KbImpactedRecord, type KbInboundEdge, KbInvalidConceptIdError, type KbLink, type KbLinkEdge, type KbLinkRel, type KbLinkRelSpec, type KbLoadResult, type KbLogAnchorChange, type KbLogEntry, type KbLogReadResult, type KbLogger, type KbMatch, type KbMatchRecord, 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 KbPromoteCandidate, KbPromoteCollisionError, type KbPromoteResult, KbPromoteSelfError, KbPromoteStandingError, KbPromoteStoppedError, type KbPromotedRecord, 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 KbVerdict, type KbVerifiedEvent, type KbWarning, KbWriteConflictError, type KbWriteInput, LINK_RELS, LOG_FILE, type MatchOptions, NO_DECISION_SLUG, PINS_FILE, PINS_LOCAL_FILE, PIN_LAYERS, PROMOTION_SOURCE_ID, type QmdModule, RECORD_TYPES, type RemoteAnchorState, type RemoteOptions, type RemoteRead, type ResolvedSymbol, type ResolverAttempt, type ResolverAttemptOptions, SEARCH_INDEX_FILE, type SearchHit, type SearchOptions, type SymbolRange, type SymbolRangeIndex, TRACE_EDGES, TreeSitterResolver, adjudicate, anchorFilePath, anchorOnHunk, anchorSetInputSchema, applyAnchorSet, assertBaseNotFrozen, backlinks, buildContext, carry, catalog, classifyDiff, 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, isReviewTag, kbActorStampSchema, kbAnchorLocatorSchema, kbAnchorSchema, kbAnchorSpanSchema, kbAnchorWriteSchema, kbConceptIdSchema, kbJsonSchemas, kbLinkSchema, kbLogAnchorChangeSchema, kbLogEntrySchema, kbLogEntryWriteSchema, kbRecordFrontmatterSchema, kbSourceSchema, kbVerifiedEventSchema, languageForFile, listPins, loadQmd, locatorOf, matchToDiff, matchesTags, mergedContextBudgets, neighbours, pack, parseLog, parseMarkdownWithFrontmatter, pinBase, prepareResolvers, promoteCandidates, promoteInputSchema, readMergedPins, readPinsLayer, readRemoteAnchors, reassessPacket, regexResolver, renderCatalogLine, renderIndex, renderIndexLine, renderLogEntry, repoCacheDir, resolveAnchor, resolveAnchorSpan, resolveHeads, resolveHits, resolvePinPath, runKbCli, runKbMcpServer, searchBase, selectDecisions, splitMarkdownFrontmatter, stringifyMarkdownWithFrontmatter, symbolRangeIndex, syncInstructions, toHookJson, trace, treeSitterLanguages, unifiedDiff, unpinBase, validateBundle };

package/dist/index.js

@@ -1,10 +1,10 @@
 import {
   runKbCli
-} from "./chunk-VXWN62HT.js";
+} from "./chunk-5IPQVXCM.js";
 import {
   createKbMcpServer,
   runKbMcpServer
-} from "./chunk-WVJULVGY.js";
+} from "./chunk-3EZ3PAPA.js";
 import {
   BaseError,
   CONTEXT_BEGIN,
@@ -36,6 +36,7 @@ import {
   KB_RECORD_STATUSES,
   KB_RECORD_TYPES,
   KB_SLUG_PATTERN,
+  KbAnchorSetDuplicateError,
   KbBaseFrozenError,
   KbClassifyInputError,
   KbInvalidConceptIdError,
@@ -66,6 +67,8 @@ import {
   adjudicate,
   anchorFilePath,
   anchorOnHunk,
+  anchorSetInputSchema,
+  applyAnchorSet,
   assertBaseNotFrozen,
   backlinks,
   buildContext,
@@ -98,19 +101,23 @@ import {
   isNoDecisionRecord,
   isReviewTag,
   kbActorStampSchema,
+  kbAnchorLocatorSchema,
   kbAnchorSchema,
   kbAnchorSpanSchema,
   kbAnchorWriteSchema,
   kbConceptIdSchema,
   kbJsonSchemas,
   kbLinkSchema,
+  kbLogAnchorChangeSchema,
   kbLogEntrySchema,
+  kbLogEntryWriteSchema,
   kbRecordFrontmatterSchema,
   kbSourceSchema,
   kbVerifiedEventSchema,
   languageForFile,
   listPins,
   loadQmd,
+  locatorOf,
   matchToDiff,
   matchesTags,
   mergedContextBudgets,
@@ -149,7 +156,7 @@ import {
   unifiedDiff,
   unpinBase,
   validateBundle
-} from "./chunk-XBZ7G5R5.js";
+} from "./chunk-XENLCPL5.js";
 export {
   BaseError,
   CONTEXT_BEGIN,
@@ -181,6 +188,7 @@ export {
   KB_RECORD_STATUSES,
   KB_RECORD_TYPES,
   KB_SLUG_PATTERN,
+  KbAnchorSetDuplicateError,
   KbBaseFrozenError,
   KbClassifyInputError,
   KbInvalidConceptIdError,
@@ -211,6 +219,8 @@ export {
   adjudicate,
   anchorFilePath,
   anchorOnHunk,
+  anchorSetInputSchema,
+  applyAnchorSet,
   assertBaseNotFrozen,
   backlinks,
   buildContext,
@@ -244,19 +254,23 @@ export {
   isNoDecisionRecord,
   isReviewTag,
   kbActorStampSchema,
+  kbAnchorLocatorSchema,
   kbAnchorSchema,
   kbAnchorSpanSchema,
   kbAnchorWriteSchema,
   kbConceptIdSchema,
   kbJsonSchemas,
   kbLinkSchema,
+  kbLogAnchorChangeSchema,
   kbLogEntrySchema,
+  kbLogEntryWriteSchema,
   kbRecordFrontmatterSchema,
   kbSourceSchema,
   kbVerifiedEventSchema,
   languageForFile,
   listPins,
   loadQmd,
+  locatorOf,
   matchToDiff,
   matchesTags,
   mergedContextBudgets,