kibi-cli 2.21.2 → 2.22.1

package/dist/public/operations/specs/check-rules.generated.js

@@ -12,6 +12,7 @@ export const SELECTABLE_RULE_NAMES = [
     "must-priority-coverage",
     "symbol-coverage",
     "symbol-traceability",
+    "symbol-granularity",
     "no-dangling-refs",
     "source-relationship-parity",
     "branch-store-not-compiled",
@@ -63,4 +64,4 @@ export const SELECTABLE_RULE_NAMES = [
 ];
 // implements REQ-006
 /** Comma-separated "Allowed:" fragment for the kb_check rules description. */
-export const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers";
+export const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers";

package/dist/public/operations/specs/check.d.ts

@@ -12,7 +12,7 @@ export declare const checkSpec: {
                     readonly type: "string";
                     readonly enum: readonly string[];
                 };
-                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
+                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
             };
             readonly sourceFiles: {
                 readonly type: "array";

package/dist/public/operations/specs/planning.d.ts

@@ -270,7 +270,7 @@ export declare const applyPlanSpec: {
             readonly plan: {
                 readonly type: "object";
                 readonly required: readonly ["version", "planHash"];
-                readonly description: "The complete kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or hash-bound kibi.entity-deletion-plan.v1 object. Migration plans require approvedActionIds and reject blocked/non-automatic actions.";
+                readonly description: "The complete kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or hash-bound kibi.entity-deletion-plan.v1 object. Migration plans require approvedActionIds and reject blocked actions and review actions Kibi cannot execute.";
             };
             readonly approvedActionIds: {
                 readonly type: "array";
@@ -278,7 +278,7 @@ export declare const applyPlanSpec: {
                     readonly type: "string";
                     readonly minLength: 1;
                 };
-                readonly description: "Required for migration-plan.v2. Exact automatic action IDs explicitly approved for this application.";
+                readonly description: "Required for migration-plan.v2. Exact action IDs explicitly approved for this application: automatic actions, or review actions with a cli invocation that Kibi executes only when approved by id (for example semantic_inventory_rederive_drop_grounding).";
             };
             readonly recoveryJournalId: {
                 readonly type: "string";

package/dist/public/operations/specs/planning.js

@@ -188,12 +188,12 @@ export const applyPlanSpec = {
             plan: {
                 type: "object",
                 required: ["version", "planHash"],
-                description: "The complete kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or hash-bound kibi.entity-deletion-plan.v1 object. Migration plans require approvedActionIds and reject blocked/non-automatic actions.",
+                description: "The complete kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or hash-bound kibi.entity-deletion-plan.v1 object. Migration plans require approvedActionIds and reject blocked actions and review actions Kibi cannot execute.",
             },
             approvedActionIds: {
                 type: "array",
                 items: { type: "string", minLength: 1 },
-                description: "Required for migration-plan.v2. Exact automatic action IDs explicitly approved for this application.",
+                description: "Required for migration-plan.v2. Exact action IDs explicitly approved for this application: automatic actions, or review actions with a cli invocation that Kibi executes only when approved by id (for example semantic_inventory_rederive_drop_grounding).",
             },
             recoveryJournalId: {
                 type: "string",

package/dist/public/operations/specs/semantic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/semantic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,8BAA8B,EAC/B,MAAM,+CAA+C,CAAC;AAEvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAmB5D,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,mBAAmB,EACzB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,8BAA8B,CAAC,CA2FzC;AAED,iBAAe,2BAA2B,CACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,8BAA8B,CAAC,CAiCzC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EE,CAAC"}
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/semantic.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,mBAAmB,EACnB,8BAA8B,EAE/B,MAAM,+CAA+C,CAAC;AAEvD,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,qBAAqB,CAAC;AA8CxE,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,mBAAmB,EACzB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,8BAA8B,CAAC,CAiGzC;AAED,iBAAe,2BAA2B,CACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,8BAA8B,CAAC,CAiCzC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EE,CAAC"}

package/dist/public/operations/specs/semantic.js

@@ -1,5 +1,6 @@
 import { InputError } from "../../../cli-errors.js";
 import { analyzeSemanticAdvisorInputWithPlugins } from "../../../operations/semantic-advisor/plugin-orchestration.js";
+import { storedLedgerDriftWarning } from "../../../operations/semantic-advisor/stored-ledger-drift.js";
 import { publicCapabilityStamp } from "../../../plugins/compose-semantic-classifier.js";
 function requiredText(value) {
     const text = typeof value === "string" ? value.trim() : "";
@@ -12,6 +13,29 @@ function optionalString(value) {
     const text = typeof value === "string" ? value.trim() : "";
     return text || undefined;
 }
+/**
+ * The stored-ledger comparison runs only for a requirement the caller named
+ * and only when the host can open the branch engine; analysis without a KB
+ * (a preview, a unit test, a workspace before `kibi sync`) stays as it was.
+ * A store that cannot be read is not an analysis failure, so the warning is
+ * simply absent then.
+ */
+// implements REQ-kibi-proposition-complete-ingestion
+async function storedLedgerWarnings(args, text, receipt, context) {
+    const id = optionalString(args.id);
+    if (!id || (optionalString(args.type) ?? "req") !== "req")
+        return [];
+    try {
+        const prolog = context?.prolog ?? (await context?.ensureProlog?.());
+        if (!prolog)
+            return [];
+        const warning = await storedLedgerDriftWarning(prolog, id, text, receipt);
+        return warning ? [warning] : [];
+    }
+    catch {
+        return [];
+    }
+}
 export async function executeSemanticAdvisor(args, context) {
     const text = requiredText(args.text);
     const id = optionalString(args.id) ?? "REQ-SEMANTIC-ADVISOR-PREVIEW";
@@ -39,6 +63,7 @@ export async function executeSemanticAdvisor(args, context) {
             : {}),
     });
     const result = orchestrated.analysis;
+    const ledgerWarnings = await storedLedgerWarnings(args, text, result.receipt, context);
     const pluginWarnings = orchestrated.stamps.length > 0
         ? [
             `Capability plugins consulted: ${orchestrated.stamps
@@ -87,7 +112,7 @@ export async function executeSemanticAdvisor(args, context) {
         ],
         structuredContent: {
             receipt: result.receipt,
-            warnings: [...result.warnings, ...pluginWarnings],
+            warnings: [...result.warnings, ...ledgerWarnings, ...pluginWarnings],
             ...(capabilityPlugins ? { capabilityPlugins } : {}),
         },
     };

package/dist/public/operations/symbol-granularity-check.d.ts

@@ -0,0 +1,18 @@
+import type { Violation } from "../../utils/rule-registry.js";
+import type { PrologPort } from "./runtime-types.js";
+/**
+ * Full-check form of the staged gate's `symbol_granularity_violation`: a
+ * symbol with traceability relationships must not link its source file
+ * coarsely while narrower behavioral symbols are available, unless it carries
+ * an allowed granularity_reason.
+ */
+export declare const SYMBOL_GRANULARITY_RULE = "symbol-granularity";
+/**
+ * `symbol-granularity`: the staged gate's granularity predicate, evaluated
+ * for every symbol against its whole working-tree file, every declaration a
+ * candidate as if the file were fully staged. Only files of symbols the gate
+ * would judge are analyzed; a file the source analyzers cannot fully analyze
+ * is skipped.
+ */
+export declare function collectSymbolGranularityViolations(prolog: Pick<PrologPort, "query">, workspaceRoot: string, rules: ReadonlySet<string>): Promise<Violation[]>;
+//# sourceMappingURL=symbol-granularity-check.d.ts.map

package/dist/public/operations/symbol-granularity-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-granularity-check.d.ts","sourceRoot":"","sources":["../../../src/public/operations/symbol-granularity-check.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAQ9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;GAKG;AAEH,eAAO,MAAM,uBAAuB,uBAAuB,CAAC;AA+J5D;;;;;;GAMG;AAEH,wBAAsB,kCAAkC,CACtD,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,EACjC,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GACzB,OAAO,CAAC,SAAS,EAAE,CAAC,CAYtB"}

package/dist/public/operations/symbol-granularity-check.js

@@ -0,0 +1,175 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import { readFileSync, statSync } from "node:fs";
+import * as path from "node:path";
+import { createMaintenanceSourceAnalysisService } from "../../plugins/maintenance-source-analysis.js";
+import { normalizeEntityId, parseEntityFromList, parseListOfLists, parseTriples, } from "../../prolog/codec.js";
+import { extractSymbolsFromStagedFileAsync, } from "../../traceability/symbol-extract.js";
+import { createSymbolGranularityDiagnostics } from "../impact/diagnostics.js";
+import { createImpactManifestLookup } from "../impact/manifest.js";
+import { normalizeSourceFile } from "../impact/source-changes.js";
+import { isAllowedGranularityReason, isTraceabilityRelationshipType, } from "../symbol-granularity.js";
+/**
+ * Full-check form of the staged gate's `symbol_granularity_violation`: a
+ * symbol with traceability relationships must not link its source file
+ * coarsely while narrower behavioral symbols are available, unless it carries
+ * an allowed granularity_reason.
+ */
+// implements REQ-cli-check, REQ-cli-staged-impact-enforcement
+export const SYMBOL_GRANULARITY_RULE = "symbol-granularity";
+const SYMBOL_ROWS_QUERY = "findall([Id,symbol,Fields], (kb_entity(Id, symbol, Props), include([Key=_]>>memberchk(Key, [title,status,source,sourceFile,granularity_reason]), Props, Fields)), Rows)";
+const SYMBOL_RELATIONSHIPS_QUERY = "findall([From,To,Type], (member(Type, [implements,covered_by,executable_for]), kb_relationship(Type, From, To), kb_entity(From, symbol, _)), Rels)";
+function stringField(entity, key) {
+    const value = entity[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+// implements REQ-cli-check
+async function loadSymbolResults(prolog, workspaceRoot) {
+    const rows = await prolog.query(SYMBOL_ROWS_QUERY);
+    if (!rows.success) {
+        throw new Error(`symbol-granularity symbol projection failed: ${rows.error ?? "unknown error"}`);
+    }
+    const rels = await prolog.query(SYMBOL_RELATIONSHIPS_QUERY);
+    if (!rels.success) {
+        throw new Error(`symbol-granularity relationship projection failed: ${rels.error ?? "unknown error"}`);
+    }
+    const relationships = new Map();
+    for (const [rawFrom, rawTo, type] of parseTriples(rels.bindings.Rels ?? "[]")) {
+        const from = normalizeEntityId(rawFrom);
+        const current = relationships.get(from) ?? [];
+        current.push({ from, to: normalizeEntityId(rawTo), type });
+        relationships.set(from, current);
+    }
+    const results = [];
+    for (const row of parseListOfLists(rows.bindings.Rows ?? "[]")) {
+        const entity = parseEntityFromList(row);
+        const id = stringField(entity, "id");
+        const sourceFile = stringField(entity, "sourceFile");
+        if (id === undefined || sourceFile === undefined)
+            continue;
+        const granularityReason = stringField(entity, "granularity_reason");
+        results.push({
+            entity: {
+                id,
+                type: "symbol",
+                title: stringField(entity, "title") ?? "",
+                status: stringField(entity, "status") ?? "",
+                created_at: "",
+                updated_at: "",
+                source: stringField(entity, "source") ?? "",
+                ...(granularityReason !== undefined
+                    ? { granularity_reason: granularityReason }
+                    : {}),
+            },
+            relationships: relationships.get(id) ?? [],
+            sourceFile: normalizeSourceFile(workspaceRoot, sourceFile),
+        });
+    }
+    return results;
+}
+/**
+ * The symbols the staged gate would judge: they carry a traceability
+ * relationship and no allowed granularity_reason. Other symbols are exempt,
+ * so their source files need no analysis.
+ */
+// implements REQ-cli-check
+function granularityCandidates(results) {
+    return results.filter((result) => result.relationships.some((relationship) => isTraceabilityRelationshipType(relationship.type)) && !isAllowedGranularityReason(result.entity.granularity_reason));
+}
+function readRegularFile(absolutePath) {
+    try {
+        if (!statSync(absolutePath).isFile())
+            return null;
+        return readFileSync(absolutePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+// implements REQ-cli-check
+async function analyzeFiles(files, results, workspaceRoot) {
+    const manifestLookup = createImpactManifestLookup(results);
+    const service = createMaintenanceSourceAnalysisService(workspaceRoot);
+    const analyses = new Map();
+    for (const file of files) {
+        const content = readRegularFile(path.resolve(workspaceRoot, file));
+        if (content === null)
+            continue;
+        try {
+            const analysis = await service.analyzeTextV2(file, content);
+            // Only a complete parser-backed analysis decides; the staged gate
+            // reports an incomplete one itself when the file is touched.
+            if (analysis.status !== "ok")
+                continue;
+            const symbols = await extractSymbolsFromStagedFileAsync({
+                path: file,
+                status: "M",
+                content,
+                hunkRanges: [{ start: 1, end: Number.MAX_SAFE_INTEGER }],
+            }, manifestLookup, { analyzeText: async () => analysis });
+            analyses.set(file, symbols);
+        }
+        catch {
+            // An analysis failure cannot decide anything for this file.
+        }
+    }
+    return analyses;
+}
+// implements REQ-cli-check
+function granularityViolations(candidates, sourceSymbolsByFile, workspaceRoot) {
+    return createSymbolGranularityDiagnostics({
+        manifestResults: candidates.filter((result) => result.sourceFile !== undefined &&
+            sourceSymbolsByFile.has(result.sourceFile)),
+        symbolsByFile: new Map(),
+        sourceSymbolsByFile,
+        workspaceRoot,
+    }).map((diagnostic) => ({
+        rule: SYMBOL_GRANULARITY_RULE,
+        entityId: diagnostic.entityId ?? "",
+        description: diagnostic.message,
+        suggestion: diagnostic.suggestion,
+        ...(diagnostic.source !== undefined ? { source: diagnostic.source } : {}),
+        evidence: {
+            diagnosticId: diagnostic.id,
+            ...(diagnostic.evidence ?? {}),
+        },
+    }));
+}
+/**
+ * `symbol-granularity`: the staged gate's granularity predicate, evaluated
+ * for every symbol against its whole working-tree file, every declaration a
+ * candidate as if the file were fully staged. Only files of symbols the gate
+ * would judge are analyzed; a file the source analyzers cannot fully analyze
+ * is skipped.
+ */
+// implements REQ-cli-check, REQ-cli-staged-impact-enforcement
+export async function collectSymbolGranularityViolations(prolog, workspaceRoot, rules) {
+    if (!rules.has(SYMBOL_GRANULARITY_RULE))
+        return [];
+    const results = await loadSymbolResults(prolog, workspaceRoot);
+    const candidates = granularityCandidates(results);
+    const files = [
+        ...new Set(candidates.map((result) => result.sourceFile ?? "")),
+    ]
+        .filter((file) => file.length > 0)
+        .sort();
+    if (files.length === 0)
+        return [];
+    const analyses = await analyzeFiles(files, results, workspaceRoot);
+    return granularityViolations(candidates, analyses, workspaceRoot);
+}

package/dist/public/skills/kibi-usage/SKILL.md

@@ -2,7 +2,7 @@
 id: kibi-usage
 name: Kibi Usage
 description: Use Kibi's source-first, exact-Git, migration-aware, proof-aware operations safely across MCP or the trusted local CLI, including partial completion repair.
-version: 2.16.0
+version: 2.16.1
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -286,8 +286,13 @@ authored. Each one is the order the write path accepts.
    existing entity, whose stored ledger Kibi keeps.
 2. **Changing the text of a grounded requirement.** New prose means new
    claim keys, so a bare rewrite is refused with `modeled proposition
-   claim_keys must match logical grounding target claim_keys exactly`.
-   Prefer supersession for a change of meaning: analyze the new prose,
+   claim_keys must match logical grounding target claim_keys exactly`; the
+   error names the modeled keys no fact declares and the facts whose keys
+   the ledger dropped. Analyze the new prose with the requirement's `id`
+   first: the receipt warns `Claim-key drift against the stored ledger`
+   and names the grounded clauses the new wording drops (the title worded
+   differently from the stored `semantic_text` is the usual cause), before
+   any write. Prefer supersession for a change of meaning: analyze the new prose,
    write its facts, write the new requirement (`-v2`) with `supersedes` to
    the old one, then set the old one to `status: closed`. Its scenario
    follows the same rule as in recipe 1: create the new scenario (with

package/dist/public/symbol-granularity.d.ts

@@ -17,5 +17,22 @@ export declare function isCoarseGranularityReason(value: unknown): value is Coar
 export declare function getSymbolRole(candidate: GranularSymbolCandidate): SymbolRole;
 export declare function isBehavioralSymbol(candidate: GranularSymbolCandidate): boolean;
 export declare function getBehavioralSymbolNames(candidates: GranularSymbolCandidate[]): string[];
+/**
+ * The candidates that are narrower than a manifest symbol: members of it
+ * (`Title.member`), or, when the source declares no symbol named like it,
+ * every other declaration in the file.
+ */
+export declare function narrowerSymbols<T extends {
+    name: string;
+}>(manifestSymbolName: string, candidates: readonly T[], sourceSymbols: readonly {
+    name: string;
+}[]): T[];
+/**
+ * The behavioral symbols that make a traceability link on
+ * `manifestSymbolName` coarse: the staged granularity gate blocks such a
+ * link unless it carries a granularity_reason, and `kibi migrate` marks
+ * exactly these links legacy-link. Empty when the link is narrow enough.
+ */
+export declare function coarseLinkBehavioralNames(manifestSymbolName: string, sourceSymbols: readonly GranularSymbolCandidate[]): string[];
 export declare function getNonBehavioralSymbolNames(candidates: GranularSymbolCandidate[]): string[];
 //# sourceMappingURL=symbol-granularity.d.ts.map

package/dist/public/symbol-granularity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbol-granularity.d.ts","sourceRoot":"","sources":["../../src/public/symbol-granularity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,0BAA0B,EAC1B,wCAAwC,EACxC,gCAAgC,EAChC,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,cAAc,EACd,YAAY,EACZ,KAAK,UAAU,EACf,+BAA+B,EAC/B,KAAK,4BAA4B,EAClC,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,0BAA0B,EAC1B,wCAAwC,EACxC,gCAAgC,EAChC,cAAc,EACd,YAAY,EACZ,+BAA+B,GAChC,CAAC;AACF,YAAY,EACV,uBAAuB,EACvB,iBAAiB,EACjB,UAAU,EACV,4BAA4B,GAC7B,MAAM,mCAAmC,CAAC;AAE3C,MAAM,MAAM,UAAU,GAClB,UAAU,GACV,OAAO,GACP,QAAQ,GACR,UAAU,GACV,UAAU,GACV,WAAW,GACX,MAAM,GACN,UAAU,GACV,MAAM,GACN,SAAS,CAAC;AAEd,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC;AAE1C,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAYD,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAE5D;AAED,eAAO,MAAM,uBAAuB,wBAAkB,CAAC;AAEvD,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAIhE;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,4BAA4B,CAIvC;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,iBAAiB,CAE5B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,uBAAuB,CAElC;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,uBAAuB,GAAG,UAAU,CAI5E;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,uBAAuB,GACjC,OAAO,CAET;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,uBAAuB,EAAE,GACpC,MAAM,EAAE,CAMV;AAED,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,uBAAuB,EAAE,GACpC,MAAM,EAAE,CAQV"}
+{"version":3,"file":"symbol-granularity.d.ts","sourceRoot":"","sources":["../../src/public/symbol-granularity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,0BAA0B,EAC1B,wCAAwC,EACxC,gCAAgC,EAChC,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,cAAc,EACd,YAAY,EACZ,KAAK,UAAU,EACf,+BAA+B,EAC/B,KAAK,4BAA4B,EAClC,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,0BAA0B,EAC1B,wCAAwC,EACxC,gCAAgC,EAChC,cAAc,EACd,YAAY,EACZ,+BAA+B,GAChC,CAAC;AACF,YAAY,EACV,uBAAuB,EACvB,iBAAiB,EACjB,UAAU,EACV,4BAA4B,GAC7B,MAAM,mCAAmC,CAAC;AAE3C,MAAM,MAAM,UAAU,GAClB,UAAU,GACV,OAAO,GACP,QAAQ,GACR,UAAU,GACV,UAAU,GACV,WAAW,GACX,MAAM,GACN,UAAU,GACV,MAAM,GACN,SAAS,CAAC;AAEd,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC;AAE1C,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAYD,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAE5D;AAED,eAAO,MAAM,uBAAuB,wBAAkB,CAAC;AAEvD,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAIhE;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,4BAA4B,CAIvC;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,iBAAiB,CAE5B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,uBAAuB,CAElC;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,uBAAuB,GAAG,UAAU,CAI5E;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,uBAAuB,GACjC,OAAO,CAET;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,uBAAuB,EAAE,GACpC,MAAM,EAAE,CAMV;AAED;;;;GAIG;AAEH,wBAAgB,eAAe,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EACxD,kBAAkB,EAAE,MAAM,EAC1B,UAAU,EAAE,SAAS,CAAC,EAAE,EACxB,aAAa,EAAE,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,GACzC,CAAC,EAAE,CASL;AAED;;;;;GAKG;AAEH,wBAAgB,yBAAyB,CACvC,kBAAkB,EAAE,MAAM,EAC1B,aAAa,EAAE,SAAS,uBAAuB,EAAE,GAChD,MAAM,EAAE,CAIV;AAED,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,uBAAuB,EAAE,GACpC,MAAM,EAAE,CAQV"}

package/dist/public/symbol-granularity.js

@@ -37,6 +37,27 @@ export function getBehavioralSymbolNames(candidates) {
         ...new Set(candidates.filter(isBehavioralSymbol).map((candidate) => candidate.name)),
     ].sort();
 }
+/**
+ * The candidates that are narrower than a manifest symbol: members of it
+ * (`Title.member`), or, when the source declares no symbol named like it,
+ * every other declaration in the file.
+ */
+// implements REQ-symbol-behavioral-anchors, REQ-cli-schema-migration
+export function narrowerSymbols(manifestSymbolName, candidates, sourceSymbols) {
+    const declared = sourceSymbols.some((symbol) => symbol.name === manifestSymbolName);
+    return candidates.filter((candidate) => candidate.name !== manifestSymbolName &&
+        (candidate.name.startsWith(`${manifestSymbolName}.`) || !declared));
+}
+/**
+ * The behavioral symbols that make a traceability link on
+ * `manifestSymbolName` coarse: the staged granularity gate blocks such a
+ * link unless it carries a granularity_reason, and `kibi migrate` marks
+ * exactly these links legacy-link. Empty when the link is narrow enough.
+ */
+// implements REQ-symbol-behavioral-anchors, REQ-cli-schema-migration
+export function coarseLinkBehavioralNames(manifestSymbolName, sourceSymbols) {
+    return getBehavioralSymbolNames(narrowerSymbols(manifestSymbolName, sourceSymbols, sourceSymbols));
+}
 export function getNonBehavioralSymbolNames(candidates) {
     return [
         ...new Set(candidates

package/dist/traceability/evidence-model.d.ts

@@ -61,14 +61,18 @@ export interface KibiImpactSymbolsManifestFileDetail {
     path: string;
     /** Symbol count extraction finds in the staged source content. */
     expectedCount: number;
-    /** Symbol count the staged manifest+coordinates evidence covers. */
+    /**
+     * Extracted symbols that have a matching staged manifest+coordinates entry
+     * (`expectedCount - missing.length`); evidence-only entries in `extra` are
+     * not counted.
+     */
     coveredCount: number;
-    /** Extracted symbols with no evidence entry (title + definition line). */
+    /** Every extracted symbol with no evidence entry (title + definition line). */
     missing: Array<{
         title: string;
         line: number;
     }>;
-    /** Evidence entries the extractor no longer finds at the recorded shape. */
+    /** Every evidence entry the extractor no longer finds at the recorded shape. */
     extra: string[];
 }
 /**

package/dist/traceability/evidence-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"evidence-model.d.ts","sourceRoot":"","sources":["../../src/traceability/evidence-model.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"evidence-model.d.ts","sourceRoot":"","sources":["../../src/traceability/evidence-model.ts"],"names":[],"mappings":"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"}

package/dist/traceability/staged-symbols-manifest.js

@@ -264,8 +264,7 @@ function getEffectiveManifestRecords(options) {
         stagedCoordinateArtifact,
     };
 }
-/** Max missing/extra symbol titles surfaced per file before "+N more". */
-const MAX_DETAIL_ITEMS = 6;
+// implements REQ-cli-staged-impact-enforcement
 function diffSymbolEvidence(sourcePath, expectedSymbols, stagedSymbols) {
     const stagedTitles = new Set(stagedSymbols.map((symbol) => symbol.title));
     const expectedTitles = new Set(expectedSymbols.map((symbol) => symbol.title));
@@ -282,12 +281,14 @@ function diffSymbolEvidence(sourcePath, expectedSymbols, stagedSymbols) {
     if (missing.length === 0 && extra.length === 0) {
         return null;
     }
+    // Keep the complete lists: human-facing renderers truncate (with an
+    // accurate "… and N more"), while JSON evidence carries every name.
     return {
         path: sourcePath,
         expectedCount: expectedSymbols.length,
-        coveredCount: stagedSymbols.length,
-        missing: missing.slice(0, MAX_DETAIL_ITEMS),
-        extra: extra.slice(0, MAX_DETAIL_ITEMS),
+        coveredCount: expectedSymbols.length - missing.length,
+        missing,
+        extra,
     };
 }
 export function assessStagedSymbolsManifest(options) {

package/dist/traceability/validate.d.ts

@@ -1,4 +1,5 @@
-import type { PrologProcess } from "../prolog.js";
+import { type PrologProcess } from "../prolog.js";
+import { type ParsedViolation } from "../prolog/codec.js";
 export interface ValidationOptions {
     minLinks: number;
     prolog: PrologProcess;
@@ -17,6 +18,18 @@ declare function splitTopLevelComma(s: string): string[];
 declare function splitTopLevelLists(value: string): string[];
 declare function parsePrologListOfLists(value: string): string[][];
 export declare function validateStagedSymbols(options: ValidationOptions): Promise<Violation[]>;
+/**
+ * Full-check `symbol-coverage` for the staged change set: the changed source
+ * symbols in the consulted overlay plus `extraSymbolIds` (symbols whose staged
+ * manifest entry changed). The Prolog rule is the one `kibi check` runs, so a
+ * commit cannot pass the staged gate with coverage the full check rejects.
+ */
+export declare function validateStagedSymbolCoverage(options: {
+    prolog: PrologProcess;
+    extraSymbolIds?: readonly string[];
+}): Promise<ParsedViolation[]>;
+/** Text lines for staged symbol-coverage violations, in `kibi check` form. */
+export declare function formatCoverageViolations(violations: readonly ParsedViolation[]): string;
 export declare function formatViolations(violations: Violation[]): string;
 export declare const __test__: {
     unquoteAtom: typeof unquoteAtom;

package/dist/traceability/validate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/traceability/validate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,aAAa,CAAC;CACvB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO1C;AAED,iBAAS,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CA0B/C;AAED,iBAAS,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CA8CnD;AAED,iBAAS,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAuBzD;AAGD,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,SAAS,EAAE,CAAC,CAgDtB;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG,MAAM,CAkBhE;AAGD,eAAO,MAAM,QAAQ;;;;;CAKpB,CAAC"}
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/traceability/validate.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,aAAa,EAAmB,MAAM,cAAc,CAAC;AACnE,OAAO,EACL,KAAK,eAAe,EAIrB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,aAAa,CAAC;CACvB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO1C;AAED,iBAAS,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CA0B/C;AAED,iBAAS,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CA8CnD;AAED,iBAAS,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAuBzD;AAGD,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,SAAS,EAAE,CAAC,CAgDtB;AAED;;;;;GAKG;AAEH,wBAAsB,4BAA4B,CAAC,OAAO,EAAE;IAC1D,MAAM,EAAE,aAAa,CAAC;IACtB,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAgB7B;AAED,8EAA8E;AAE9E,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,SAAS,eAAe,EAAE,GACrC,MAAM,CAaR;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG,MAAM,CAkBhE;AAGD,eAAO,MAAM,QAAQ;;;;;CAKpB,CAAC"}

package/dist/traceability/validate.js

@@ -1,3 +1,6 @@
+import path from "node:path";
+import { resolveKbPlPath } from "../prolog.js";
+import { escapeAtom, parseViolationRows, toPrologAtom, } from "../prolog/codec.js";
 function unquoteAtom(value) {
     // remove surrounding single quotes and unescape doubled quotes
     const trimmed = value.trim();
@@ -141,6 +144,44 @@ export async function validateStagedSymbols(options) {
     }
     return violations;
 }
+/**
+ * Full-check `symbol-coverage` for the staged change set: the changed source
+ * symbols in the consulted overlay plus `extraSymbolIds` (symbols whose staged
+ * manifest entry changed). The Prolog rule is the one `kibi check` runs, so a
+ * commit cannot pass the staged gate with coverage the full check rejects.
+ */
+// implements REQ-014
+export async function validateStagedSymbolCoverage(options) {
+    const extra = `[${[...new Set(options.extraSymbolIds ?? [])]
+        .sort()
+        .map(toPrologAtom)
+        .join(",")}]`;
+    const checksPl = escapeAtom(path.join(path.dirname(resolveKbPlPath()), "checks.pl"));
+    const goal = `(use_module('${checksPl}'), call(checks:check_changed_symbol_coverage(${extra}, Violations)))`;
+    const res = await options.prolog.query(goal);
+    if (!res.success) {
+        throw new Error(`Prolog symbol-coverage query failed: ${res.error || "unknown error"}`);
+    }
+    return parseViolationRows(res.bindings.Violations ?? "[]");
+}
+/** Text lines for staged symbol-coverage violations, in `kibi check` form. */
+// implements REQ-014
+export function formatCoverageViolations(violations) {
+    if (violations.length === 0)
+        return "";
+    const lines = [
+        `Found ${violations.length} symbol-coverage violation(s) in staged symbols (the same rule kibi check runs):`,
+    ];
+    for (const violation of violations) {
+        lines.push("", `[${violation.rule}] ${violation.entityId}`);
+        if (violation.source)
+            lines.push(`  Source: ${violation.source}`);
+        lines.push(`  ${violation.description}`);
+        if (violation.suggestion)
+            lines.push(`  Suggestion: ${violation.suggestion}`);
+    }
+    return lines.join("\n");
+}
 export function formatViolations(violations) {
     // implements REQ-014
     if (!violations || violations.length === 0)

package/dist/utils/rule-registry.generated.d.ts

@@ -13,6 +13,11 @@ export declare const GENERATED_RULES: readonly [{
     readonly description: "Production symbols must directly implement requirements for ownership; covered_by is coverage only and executable_for is test identity only";
     readonly enforcementClass: "canonical";
     readonly category: "traceability";
+}, {
+    readonly name: "symbol-granularity";
+    readonly description: "A symbol with traceability relationships must not link its source file coarsely while narrower behavioral symbols are available, unless it carries an allowed granularity_reason; the staged gate's symbol_granularity_violation evaluated KB-wide";
+    readonly enforcementClass: "canonical";
+    readonly category: "traceability";
 }, {
     readonly name: "no-dangling-refs";
     readonly description: "All relationship targets must exist in the KB";

package/dist/utils/rule-registry.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyWlB,CAAC"}
+{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgXlB,CAAC"}

package/dist/utils/rule-registry.generated.js

@@ -26,6 +26,12 @@ export const GENERATED_RULES = [
         enforcementClass: "canonical",
         category: "traceability",
     },
+    {
+        name: "symbol-granularity",
+        description: "A symbol with traceability relationships must not link its source file coarsely while narrower behavioral symbols are available, unless it carries an allowed granularity_reason; the staged gate's symbol_granularity_violation evaluated KB-wide",
+        enforcementClass: "canonical",
+        category: "traceability",
+    },
     {
         name: "no-dangling-refs",
         description: "All relationship targets must exist in the KB",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "2.21.2",
+  "version": "2.22.1",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {
@@ -235,8 +235,8 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-core": "^0.21.1",
-    "kibi-plugin-builtin": "^0.5.1",
+    "kibi-core": "^0.22.0",
+    "kibi-plugin-builtin": "^0.5.2",
     "kibi-plugin-sdk": "^0.5.0",
     "kibi-swipl": "^1.0.1",
     "saxes": "^6.0.0",