kibi-cli 0.16.1 → 0.17.0

package/dist/schemas/entity.schema.json

@@ -2,6 +2,209 @@
     "$id": "entity.schema.json",
     "title": "Entity",
     "type": "object",
+    "$defs": {
+        "logicTerm": {
+            "oneOf": [
+                {
+                    "type": "object",
+                    "required": ["kind", "name", "type"],
+                    "properties": {
+                        "kind": { "const": "var" },
+                        "name": { "type": "string", "pattern": "^[A-Z][A-Za-z0-9_]*$" },
+                        "type": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" }
+                    },
+                    "additionalProperties": false
+                },
+                {
+                    "type": "object",
+                    "required": ["kind", "value"],
+                    "properties": {
+                        "kind": { "const": "const" },
+                        "value": { "type": "string", "minLength": 1 },
+                        "type": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" }
+                    },
+                    "additionalProperties": false
+                },
+                {
+                    "type": "object",
+                    "required": ["kind", "value"],
+                    "properties": {
+                        "kind": { "const": "number" },
+                        "value": { "type": "number" },
+                        "unit": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" }
+                    },
+                    "additionalProperties": false
+                },
+                {
+                    "type": "object",
+                    "required": ["kind", "value", "unit"],
+                    "properties": {
+                        "kind": { "const": "duration" },
+                        "value": { "type": "number", "minimum": 0 },
+                        "unit": {
+                            "type": "string",
+                            "enum": ["ms", "s", "m", "h", "d", "w"]
+                        }
+                    },
+                    "additionalProperties": false
+                },
+                {
+                    "type": "object",
+                    "required": ["kind", "value"],
+                    "properties": {
+                        "kind": { "const": "timestamp" },
+                        "value": { "type": "string" }
+                    },
+                    "additionalProperties": false
+                },
+                {
+                    "type": "object",
+                    "required": ["kind", "start", "end"],
+                    "properties": {
+                        "kind": { "const": "interval" },
+                        "start": { "type": "string" },
+                        "end": { "type": "string" }
+                    },
+                    "additionalProperties": false
+                }
+            ]
+        },
+        "logicAtom": {
+            "type": "object",
+            "required": ["kind", "name", "args"],
+            "properties": {
+                "kind": { "const": "atom" },
+                "namespace": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" },
+                "name": { "type": "string", "pattern": "^[a-z][a-z0-9_:.\\/-]*$" },
+                "args": {
+                    "type": "array",
+                    "maxItems": 8,
+                    "items": { "$ref": "#/$defs/logicTerm" }
+                },
+                "polarity": { "enum": ["positive", "negative"] },
+                "closedWorld": { "type": "boolean" }
+            },
+            "additionalProperties": false
+        },
+        "logicExpression": {
+            "oneOf": [
+                { "$ref": "#/$defs/logicAtom" },
+                {
+                    "type": "object",
+                    "required": ["kind", "items"],
+                    "properties": {
+                        "kind": { "enum": ["all", "any"] },
+                        "items": {
+                            "type": "array",
+                            "minItems": 1,
+                            "maxItems": 32,
+                            "items": { "$ref": "#/$defs/logicExpression" }
+                        }
+                    },
+                    "additionalProperties": false
+                },
+                {
+                    "type": "object",
+                    "required": ["kind", "item"],
+                    "properties": {
+                        "kind": { "const": "not" },
+                        "item": { "$ref": "#/$defs/logicAtom" }
+                    },
+                    "additionalProperties": false
+                },
+                {
+                    "type": "object",
+                    "required": ["kind", "operator", "left", "right"],
+                    "properties": {
+                        "kind": { "const": "compare" },
+                        "operator": { "enum": ["eq", "neq", "lt", "lte", "gt", "gte"] },
+                        "left": { "$ref": "#/$defs/logicTerm" },
+                        "right": { "$ref": "#/$defs/logicTerm" }
+                    },
+                    "additionalProperties": false
+                },
+                {
+                    "type": "object",
+                    "required": ["kind", "atom", "operator", "value"],
+                    "properties": {
+                        "kind": { "const": "count" },
+                        "atom": { "$ref": "#/$defs/logicAtom" },
+                        "operator": { "enum": ["eq", "neq", "lt", "lte", "gt", "gte"] },
+                        "value": { "type": "integer", "minimum": 0 }
+                    },
+                    "additionalProperties": false
+                },
+                {
+                    "type": "object",
+                    "required": ["kind", "relation", "left", "right"],
+                    "properties": {
+                        "kind": { "const": "temporal" },
+                        "relation": {
+                            "enum": [
+                                "before",
+                                "after",
+                                "during",
+                                "overlaps",
+                                "starts",
+                                "finishes"
+                            ]
+                        },
+                        "left": { "$ref": "#/$defs/logicTerm" },
+                        "right": { "$ref": "#/$defs/logicTerm" }
+                    },
+                    "additionalProperties": false
+                }
+            ]
+        },
+        "logicRule": {
+            "type": "object",
+            "required": ["version", "kind", "modality"],
+            "properties": {
+                "version": { "const": "kibi.logic.v1" },
+                "kind": { "enum": ["atom", "rule", "constraint"] },
+                "modality": {
+                    "enum": ["assert", "deny", "oblige", "permit", "forbid"]
+                },
+                "head": { "$ref": "#/$defs/logicAtom" },
+                "body": { "$ref": "#/$defs/logicExpression" },
+                "variables": {
+                    "type": "array",
+                    "maxItems": 32,
+                    "items": {
+                        "type": "object",
+                        "required": ["name", "type"],
+                        "properties": {
+                            "name": { "type": "string", "pattern": "^[A-Z][A-Za-z0-9_]*$" },
+                            "type": {
+                                "type": "string",
+                                "pattern": "^[a-z][a-z0-9_:.\\/-]*$"
+                            },
+                            "quantifier": { "enum": ["forall", "exists"] }
+                        },
+                        "additionalProperties": false
+                    }
+                },
+                "exceptions": {
+                    "type": "array",
+                    "maxItems": 16,
+                    "items": { "$ref": "#/$defs/logicExpression" }
+                },
+                "scope": {
+                    "type": "object",
+                    "properties": {
+                        "authority": { "type": "string" },
+                        "name": { "type": "string" },
+                        "tags": { "type": "array", "items": { "type": "string" } }
+                    },
+                    "additionalProperties": false
+                },
+                "validFrom": { "type": "string" },
+                "validTo": { "type": "string" },
+                "ruleSchemaId": { "type": "string", "minLength": 1 }
+            },
+            "additionalProperties": false
+        }
+    },
     "properties": {
         "id": { "type": "string" },
         "title": { "type": "string" },
@@ -44,6 +247,53 @@
             "uniqueItems": true,
             "items": { "type": "string", "pattern": "^CLAIM-[A-F0-9]{16}$" }
         },
+        "semantic_inventory": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["claim_key", "claim_text", "role", "status", "span"],
+                "properties": {
+                    "claim_key": { "type": "string", "pattern": "^CLAIM-[A-F0-9]{16}$" },
+                    "claim_text": { "type": "string", "minLength": 1 },
+                    "role": {
+                        "type": "string",
+                        "enum": [
+                            "normative",
+                            "definition",
+                            "descriptive",
+                            "condition",
+                            "exception",
+                            "rationale",
+                            "example",
+                            "subjective"
+                        ]
+                    },
+                    "status": {
+                        "type": "string",
+                        "enum": [
+                            "modeled",
+                            "ambiguous",
+                            "ontology_gap",
+                            "nonlogical",
+                            "missing"
+                        ]
+                    },
+                    "span": {
+                        "type": "object",
+                        "required": ["start", "end"],
+                        "properties": {
+                            "start": { "type": "integer", "minimum": 0 },
+                            "end": { "type": "integer", "minimum": 0 }
+                        },
+                        "additionalProperties": false
+                    },
+                    "semantic_key": { "type": "string" },
+                    "payload_hash": { "type": "string" },
+                    "reason": { "type": "string" }
+                },
+                "additionalProperties": false
+            }
+        },
         "sourceFile": { "type": "string" },
         "granularity_reason": {
             "type": "string",
@@ -94,7 +344,9 @@
                 "observation",
                 "meta",
                 "predicate_schema",
-                "predicate"
+                "predicate",
+                "rule_schema",
+                "rule"
             ]
         },
         "subject_key": { "type": "string" },
@@ -134,7 +386,14 @@
         },
         "aliases": { "type": "array", "items": { "type": "string" } },
         "examples": { "type": "array", "items": { "type": "string" } },
-        "predicate_args": { "type": "array", "items": { "type": "string" } }
+        "predicate_args": { "type": "array", "items": { "type": "string" } },
+        "rule_ir": { "$ref": "#/$defs/logicRule" },
+        "rule_hash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "rule_schema_id": { "type": "string", "minLength": 1 },
+        "rule_name": { "type": "string", "minLength": 1 },
+        "semantic_key": { "type": "string", "pattern": "^SEM-[A-F0-9]{24}$" },
+        "claim_span_start": { "type": "integer", "minimum": 0 },
+        "claim_span_end": { "type": "integer", "minimum": 0 }
     },
     "required": [
         "id",
@@ -173,6 +432,36 @@
                 }
             }
         },
+        {
+            "if": {
+                "properties": {
+                    "type": { "const": "fact" },
+                    "fact_kind": { "const": "rule_schema" }
+                },
+                "required": ["type", "fact_kind"]
+            },
+            "then": {
+                "required": ["rule_name", "argument_names", "argument_types"]
+            }
+        },
+        {
+            "if": {
+                "properties": {
+                    "type": { "const": "fact" },
+                    "fact_kind": { "const": "rule" }
+                },
+                "required": ["type", "fact_kind"]
+            },
+            "then": {
+                "required": [
+                    "rule_ir",
+                    "rule_hash",
+                    "rule_schema_id",
+                    "rule_name",
+                    "semantic_key"
+                ]
+            }
+        },
         {
             "if": {
                 "properties": { "type": { "const": "fact" } }
@@ -207,11 +496,25 @@
                         { "required": ["argument_descriptions"] },
                         { "required": ["aliases"] },
                         { "required": ["examples"] },
-                        { "required": ["predicate_args"] }
+                        { "required": ["predicate_args"] },
+                        { "required": ["rule_ir"] },
+                        { "required": ["rule_hash"] },
+                        { "required": ["rule_schema_id"] },
+                        { "required": ["rule_name"] },
+                        { "required": ["semantic_key"] },
+                        { "required": ["claim_span_start"] },
+                        { "required": ["claim_span_end"] }
                     ]
                 }
             }
         },
+        {
+            "if": {
+                "properties": { "type": { "const": "req" } }
+            },
+            "then": {},
+            "else": { "not": { "required": ["semantic_inventory"] } }
+        },
         {
             "if": {
                 "properties": {

package/dist/traceability/staged-diagnostics.d.ts

@@ -21,5 +21,5 @@ export interface KibiImpactDiagnostic extends QualityDiagnostic {
  * files and manifest freshness. It only evaluates explicit predicates recorded in
  * `KibiImpactEvidence`.
  */
-export declare function collectStagedKibiDiagnostics(evidence: KibiImpactEvidence): KibiImpactDiagnostic[];
+export declare function collectStagedKibiDiagnostics(evidence: KibiImpactEvidence, symbolsManifestPath?: string): KibiImpactDiagnostic[];
 //# sourceMappingURL=staged-diagnostics.d.ts.map

package/dist/traceability/staged-diagnostics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staged-diagnostics.d.ts","sourceRoot":"","sources":["../../src/traceability/staged-diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAIL,KAAK,kBAAkB,EAIxB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,sBAAsB,GAC9B,8BAA8B,GAC9B,wBAAwB,GACxB,8BAA8B,GAC9B,+BAA+B,GAC/B,iCAAiC,GACjC,oCAAoC,GACpC,gCAAgC,GAChC,0BAA0B,GAC1B,2BAA2B,GAC3B,6BAA6B,GAC7B,yBAAyB,GACzB,wCAAwC,CAAC;AAE7C,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAC7D,uDAAuD;IACvD,EAAE,EAAE,sBAAsB,CAAC;IAC3B,QAAQ,EAAE,iBAAiB,CAAC,UAAU,CAAC,CAAC;IACxC,iEAAiE;IACjE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,gDAAgD;IAChD,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;CACpB;AA4DD;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,kBAAkB,GAC3B,oBAAoB,EAAE,CAoCxB"}
+{"version":3,"file":"staged-diagnostics.d.ts","sourceRoot":"","sources":["../../src/traceability/staged-diagnostics.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAGL,KAAK,kBAAkB,EAIxB,MAAM,qBAAqB,CAAC;AAQ7B,MAAM,MAAM,sBAAsB,GAC9B,8BAA8B,GAC9B,wBAAwB,GACxB,8BAA8B,GAC9B,+BAA+B,GAC/B,iCAAiC,GACjC,oCAAoC,GACpC,gCAAgC,GAChC,0BAA0B,GAC1B,2BAA2B,GAC3B,6BAA6B,GAC7B,yBAAyB,GACzB,wCAAwC,CAAC;AAE7C,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAC7D,uDAAuD;IACvD,EAAE,EAAE,sBAAsB,CAAC;IAC3B,QAAQ,EAAE,iBAAiB,CAAC,UAAU,CAAC,CAAC;IACxC,iEAAiE;IACjE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,gDAAgD;IAChD,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;CACpB;AAgED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,kBAAkB,EAC5B,mBAAmB,GAAE,MAAmC,GACvD,oBAAoB,EAAE,CA8CxB"}

package/dist/traceability/staged-diagnostics.js

@@ -1,8 +1,14 @@
-import { KIBI_STAGED_IMPACT_EVIDENCE_DOC, KIBI_SYMBOLS_MANIFEST_PATH, KIBI_SYMBOL_COORDINATES_PATH, getBehaviorSourcePaths, getMissingBehaviorSourcePaths, hasOverrideRationale, } from "./evidence-model.js";
+import * as path from "node:path";
+import { KIBI_STAGED_IMPACT_EVIDENCE_DOC, KIBI_SYMBOLS_MANIFEST_PATH, getBehaviorSourcePaths, getMissingBehaviorSourcePaths, hasOverrideRationale, } from "./evidence-model.js";
+function deriveCoordinatesPath(symbolsManifestPath) {
+    return path
+        .join(path.dirname(symbolsManifestPath), "symbol-coordinates.yaml")
+        .replace(/\\/g, "/");
+}
 function formatFileList(paths) {
     return paths.join(", ");
 }
-function createMissingEvidenceDiagnostic(paths) {
+function createMissingEvidenceDiagnostic(paths, symbolsManifestPath, coordinatesPath) {
     return {
         id: "kibi_impact_evidence_missing",
         severity: "error",
@@ -11,19 +17,19 @@ function createMissingEvidenceDiagnostic(paths) {
         files: [...paths],
         docs: [KIBI_STAGED_IMPACT_EVIDENCE_DOC],
         message: `Behavior-changing staged files are missing staged Kibi impact evidence (see ${KIBI_STAGED_IMPACT_EVIDENCE_DOC}): ${formatFileList(paths)}`,
-        suggestion: `Query Kibi via MCP before deciding. MCP writes update KB state but do not stage tracked evidence; also stage requirement/scenario/test/fact/symbol markdown, authored ${KIBI_SYMBOLS_MANIFEST_PATH} metadata, or refreshed ${KIBI_SYMBOL_COORDINATES_PATH}. Re-run kibi check --staged after staging tracked evidence.`,
+        suggestion: `Query Kibi via MCP before deciding. MCP writes update KB state but do not stage tracked evidence; also stage requirement/scenario/test/fact/symbol markdown, authored ${symbolsManifestPath} metadata, or refreshed ${coordinatesPath}. Re-run kibi check --staged after staging tracked evidence.`,
     };
 }
-function createSymbolsManifestStaleDiagnostic(paths) {
+function createSymbolsManifestStaleDiagnostic(paths, symbolsManifestPath, coordinatesPath) {
     return {
         id: "symbols_manifest_stale",
         severity: "error",
         blocking: true,
         category: "symbol",
-        files: [KIBI_SYMBOL_COORDINATES_PATH, ...paths],
+        files: [coordinatesPath, ...paths],
         docs: [KIBI_STAGED_IMPACT_EVIDENCE_DOC],
-        message: `${KIBI_SYMBOL_COORDINATES_PATH} is stale or missing for staged source files: ${formatFileList(paths)}`,
-        suggestion: `Run kibi sync --refresh-symbol-coordinates && git add ${KIBI_SYMBOL_COORDINATES_PATH} ${KIBI_SYMBOLS_MANIFEST_PATH}, then re-run kibi check --staged.`,
+        message: `${coordinatesPath} is stale or missing for staged source files: ${formatFileList(paths)}`,
+        suggestion: `Run kibi sync --refresh-symbol-coordinates && git add ${coordinatesPath} ${symbolsManifestPath}, then re-run kibi check --staged.`,
     };
 }
 function createMissingOverrideRationaleDiagnostic(evidence) {
@@ -49,8 +55,9 @@ function createMissingOverrideRationaleDiagnostic(evidence) {
  * files and manifest freshness. It only evaluates explicit predicates recorded in
  * `KibiImpactEvidence`.
  */
-export function collectStagedKibiDiagnostics(evidence) {
+export function collectStagedKibiDiagnostics(evidence, symbolsManifestPath = KIBI_SYMBOLS_MANIFEST_PATH) {
     const diagnostics = [];
+    const coordinatesPath = evidence.symbolsManifest.path || deriveCoordinatesPath(symbolsManifestPath);
     if (evidence.mode.kind === "no_impact_override" &&
         !hasOverrideRationale(evidence)) {
         diagnostics.push(createMissingOverrideRationaleDiagnostic(evidence));
@@ -58,11 +65,11 @@ export function collectStagedKibiDiagnostics(evidence) {
     if ((evidence.symbolsManifest.state === "stale" ||
         evidence.symbolsManifest.state === "missing") &&
         evidence.symbolsManifest.sourcePaths.length > 0) {
-        diagnostics.push(createSymbolsManifestStaleDiagnostic([...evidence.symbolsManifest.sourcePaths].sort()));
+        diagnostics.push(createSymbolsManifestStaleDiagnostic([...evidence.symbolsManifest.sourcePaths].sort(), symbolsManifestPath, coordinatesPath));
     }
     const missingBehaviorPaths = getMissingBehaviorSourcePaths(evidence);
     if (missingBehaviorPaths.length > 0) {
-        diagnostics.push(createMissingEvidenceDiagnostic(missingBehaviorPaths));
+        diagnostics.push(createMissingEvidenceDiagnostic(missingBehaviorPaths, symbolsManifestPath, coordinatesPath));
     }
     if (evidence.mode.kind === "no_impact_override" &&
         evidence.mode.override.sourcePaths.length === 0 &&

package/dist/traceability/staged-impact-contract.js

@@ -48,7 +48,7 @@ export const KIBI_IMPACT_DIAGNOSTICS = {
         id: "kibi_impact_evidence_missing",
         title: "Behavior edit requires staged Kibi impact evidence",
         resolution: [
-            "Query Kibi via MCP first: use kb_search for discovery, then kb_query for exact follow-up.",
+            "Query Kibi via visible MCP tools or the trusted project-local CLI (peer surfaces): use kb_search for discovery, then kb_query for exact follow-up.",
             "MCP writes update KB state but do not stage tracked evidence; also stage related KB entity markdown, authored documentation/symbols.yaml metadata, or refreshed documentation/symbol-coordinates.yaml.",
             "Re-run or let the hook run kibi check --staged.",
         ],

package/dist/traceability/staged-symbols-manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staged-symbols-manifest.d.ts","sourceRoot":"","sources":["../../src/traceability/staged-symbols-manifest.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AA+BlD,MAAM,WAAW,+BAA+B;IAC9C,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,cAAc,CAAC;IACtD,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,qCAAqC;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAC5D,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AA2TD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE;IACnD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B,GAAG,+BAA+B,CAmFlC;AAED,wBAAgB,4CAA4C,CAAC,OAAO,EAAE;IACpE,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B,GAAG,qCAAqC,CAmExC"}
+{"version":3,"file":"staged-symbols-manifest.d.ts","sourceRoot":"","sources":["../../src/traceability/staged-symbols-manifest.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AA0ClD,MAAM,WAAW,+BAA+B;IAC9C,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,cAAc,CAAC;IACtD,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,qCAAqC;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,KAAK,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAC5D,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAkTD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE;IACnD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B,GAAG,+BAA+B,CAgGlC;AAED,wBAAgB,4CAA4C,CAAC,OAAO,EAAE;IACpE,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B,GAAG,qCAAqC,CAmExC"}

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

@@ -3,7 +3,18 @@ import * as path from "node:path";
 import { extractManifestSymbolRecordsString, } from "../extractors/manifest.js";
 import { mergeCoordinatesWithManifest, readCoordinateArtifact, } from "../extractors/symbol-coordinates.js";
 import { analyzeSourceText } from "../extractors/symbols-coordinator.js";
+import { isCoarseGranularityReason } from "../public/symbol-granularity.js";
 import { resolveSymbolsManifestPaths } from "../utils/manifest-paths.js";
+/**
+ * True when a manifest record documents coarse file/module-level coverage using
+ * a canonical granularity reason that legitimately carries no generated
+ * per-symbol coordinates. Such records do not participate in coordinate
+ * freshness comparison. `legacy-link` records remain coordinate-bearing, and
+ * unknown or malformed reasons cannot bypass freshness checks.
+ */
+function isDocumentedCoarseRecord(record) {
+    return isCoarseGranularityReason(record.granularity_reason);
+}
 function toRepoRelativePath(absoluteOrRelativePath) {
     if (!path.isAbsolute(absoluteOrRelativePath)) {
         return absoluteOrRelativePath.replace(/\\/g, "/");
@@ -97,15 +108,10 @@ function normalizeRelationships(relationships) {
     })
         .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
 }
-function normalizeManifestSymbolsForSourceFile(records, sourceFile, expectedTitles) {
+function normalizeManifestSymbolsForSourceFile(records, sourceFile) {
     return records
         .filter((record) => {
-        const title = typeof record.title === "string" ? record.title : null;
-        const isDocumentedModuleSymbol = typeof record.granularity_reason === "string" &&
-            record.granularity_reason.length > 0;
-        if (title !== null &&
-            isDocumentedModuleSymbol &&
-            !expectedTitles.has(title)) {
+        if (isDocumentedCoarseRecord(record)) {
             return false;
         }
         const recordSource = typeof record.sourceFile === "string"
@@ -234,9 +240,21 @@ export function assessStagedSymbolsManifest(options) {
     const requiredRefreshPaths = [];
     const freshPaths = new Set();
     for (const sourceFile of sourceFiles) {
+        const manifestRecordsForFile = (stagedManifestRecords ?? []).filter((record) => {
+            const recordSource = typeof record.sourceFile === "string"
+                ? record.sourceFile
+                : typeof record.source === "string"
+                    ? record.source
+                    : null;
+            return recordSource === sourceFile.path;
+        });
+        const coarseCovered = manifestRecordsForFile.length > 0 &&
+            manifestRecordsForFile.every(isDocumentedCoarseRecord);
+        if (coarseCovered) {
+            continue;
+        }
         const expectedSymbols = normalizeExpectedSymbolsForStagedFile(sourceFile);
-        const expectedTitles = new Set(expectedSymbols.map((symbol) => symbol.title));
-        const baselineSymbols = normalizeManifestSymbolsForSourceFile(baselineMergedRecords, sourceFile.path, expectedTitles);
+        const baselineSymbols = normalizeManifestSymbolsForSourceFile(baselineMergedRecords, sourceFile.path);
         if (signaturesEqual(expectedSymbols, baselineSymbols)) {
             continue;
         }
@@ -244,7 +262,7 @@ export function assessStagedSymbolsManifest(options) {
         if (!stagedCoordinatesFile || stagedCoordinateArtifact === null) {
             continue;
         }
-        const stagedSymbols = normalizeManifestSymbolsForSourceFile(stagedMergedRecords, sourceFile.path, expectedTitles);
+        const stagedSymbols = normalizeManifestSymbolsForSourceFile(stagedMergedRecords, sourceFile.path);
         if (signaturesEqual(expectedSymbols, stagedSymbols)) {
             freshPaths.add(sourceFile.path);
         }

package/dist/traceability/temp-kb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"temp-kb.d.ts","sourceRoot":"","sources":["../../src/traceability/temp-kb.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGV,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,aAAa,CAAC;CACvB;AAMD;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CASvC;AAOD;;;GAGG;AACH,wBAAgB,iBAAiB,CAE/B,OAAO,EAAE,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,KAAK,aAAa,GACpD,IAAI,CAEN;AAuLD,iBAAe,cAAc,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB/D;AAED,OAAO,EAAE,cAAc,EAAE,CAAC;AAG1B,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,gBAAgB,EAAE,GAC1B,OAAO,CAAC,IAAI,CAAC,CA2Bf;AAED,wBAAsB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CA6C7E;AAGD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAkBrE;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA2BlE"}
+{"version":3,"file":"temp-kb.d.ts","sourceRoot":"","sources":["../../src/traceability/temp-kb.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGV,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,aAAa,CAAC;CACvB;AAMD;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CASvC;AAOD;;;GAGG;AACH,wBAAgB,iBAAiB,CAE/B,OAAO,EAAE,CAAC,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,KAAK,aAAa,GACpD,IAAI,CAEN;AAuMD,iBAAe,cAAc,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB/D;AAED,OAAO,EAAE,cAAc,EAAE,CAAC;AAG1B,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,gBAAgB,EAAE,GAC1B,OAAO,CAAC,IAAI,CAAC,CA2Bf;AAED,wBAAsB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CA6C7E;AAGD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,MAAM,CAkBrE;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA2BlE"}

package/dist/traceability/temp-kb.js

@@ -54,11 +54,17 @@ const FACT_STRING_FIELDS = new Set([
     "claim_text",
     "predicate_name",
     "predicate_namespace",
+    "rule_hash",
+    "rule_schema_id",
+    "rule_name",
+    "semantic_key",
 ]);
 const FACT_NUMBER_FIELDS = new Set([
     "value_int",
     "value_number",
     "predicate_arity",
+    "claim_span_start",
+    "claim_span_end",
 ]);
 const FACT_BOOLEAN_FIELDS = new Set(["value_bool", "closed_world"]);
 const FACT_STRING_ARRAY_FIELDS = new Set([
@@ -94,6 +100,10 @@ function serializeTypedFactFields(entity) {
             fields.push(`${field}=${toPrologString(String(value))}`);
         }
     }
+    const ruleIr = getEntityField(entity, "rule_ir");
+    if (ruleIr !== undefined && ruleIr !== null) {
+        fields.push(`rule_ir=${toPrologString(JSON.stringify(ruleIr))}`);
+    }
     for (const field of FACT_ATOM_FIELDS) {
         const value = getEntityField(entity, field);
         if (value !== undefined && value !== null) {
@@ -146,6 +156,9 @@ function buildEntityAssertionGoal(entity) {
     if (entity.type === "req" && entity.logic_claims) {
         props.push(`logic_claims=[${entity.logic_claims.map(toPrologAtom).join(",")}]`);
     }
+    if (entity.type === "req" && entity.semantic_inventory) {
+        props.push(`semantic_inventory=${toPrologString(JSON.stringify(entity.semantic_inventory))}`);
+    }
     if (entity.type === "fact") {
         props.push(...serializeTypedFactFields(entity));
     }

package/dist/types/relationships.d.ts

@@ -1,5 +1,5 @@
 export interface BaseRelationship {
-    type: "depends_on" | "specified_by" | "verified_by" | "validates" | "implements" | "covered_by" | "executable_for" | "constrained_by" | "constrains" | "requires_property" | "requires_predicate" | "guards" | "publishes" | "consumes" | "supersedes" | "relates_to";
+    type: "depends_on" | "specified_by" | "verified_by" | "validates" | "implements" | "covered_by" | "executable_for" | "constrained_by" | "constrains" | "requires_property" | "requires_predicate" | "requires_rule" | "guards" | "publishes" | "consumes" | "supersedes" | "relates_to";
     from: string;
     to: string;
     created_at?: string;

package/dist/types/relationships.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relationships.d.ts","sourceRoot":"","sources":["../../src/types/relationships.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EACA,YAAY,GACZ,cAAc,GACd,aAAa,GACb,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,gBAAgB,GAChB,gBAAgB,GAChB,YAAY,GACZ,mBAAmB,GACnB,oBAAoB,GACpB,QAAQ,GACR,WAAW,GACX,UAAU,GACV,YAAY,GACZ,YAAY,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"relationships.d.ts","sourceRoot":"","sources":["../../src/types/relationships.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EACA,YAAY,GACZ,cAAc,GACd,aAAa,GACb,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,gBAAgB,GAChB,gBAAgB,GAChB,YAAY,GACZ,mBAAmB,GACnB,oBAAoB,GACpB,eAAe,GACf,QAAQ,GACR,WAAW,GACX,UAAU,GACV,YAAY,GACZ,YAAY,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,eAAe,gBAAgB,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"rule-registry.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.ts"],"names":[],"mappings":"AAkBA;;;GAGG;AAEH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,QAAQ,EAAE,UAAU,GAAG,WAAW,GAAG,WAAW,GAAG,cAAc,CAAC;CACnE;AAED,MAAM,WAAW,yBAAyB;IACxC,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,mCAAmC;AACnC,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,kBAAkB,EAAE,yBAAyB,CAAC;CAC/C;AAED;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,SAAS,cAAc,EAiGjC,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,UAAU,aAAoC,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,YAKnC,CAAC;AAEF;;;;;GAKG;AAEH,wBAAgB,iBAAiB,CAC/B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrC,QAAQ,CAAC,EAAE,MAAM,GAChB,GAAG,CAAC,MAAM,CAAC,CAsBb;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAK5D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAC9B,YAAY,CAWd"}
+{"version":3,"file":"rule-registry.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.ts"],"names":[],"mappings":"AAkBA;;;GAGG;AAEH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,QAAQ,EAAE,UAAU,GAAG,WAAW,GAAG,WAAW,GAAG,cAAc,CAAC;CACnE;AAED,MAAM,WAAW,yBAAyB;IACxC,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,mCAAmC;AACnC,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,kBAAkB,EAAE,yBAAyB,CAAC;CAC/C;AAED;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,SAAS,cAAc,EAsHjC,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,UAAU,aAAoC,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,YAKnC,CAAC;AAEF;;;;;GAKG;AAEH,wBAAgB,iBAAiB,CAC/B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrC,QAAQ,CAAC,EAAE,MAAM,GAChB,GAAG,CAAC,MAAM,CAAC,CAsBb;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAK5D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAC9B,YAAY,CAWd"}

package/dist/utils/rule-registry.js

@@ -99,6 +99,24 @@ export const RULES = [
         defaultEnabled: true,
         category: "integrity",
     },
+    {
+        name: "rule-safety",
+        description: "Stored Logic IR rules use only the typed, bounded, stratified vocabulary",
+        defaultEnabled: true,
+        category: "integrity",
+    },
+    {
+        name: "rule-verifiability",
+        description: "Requirement rule links resolve to safe rules and registered rule schemas",
+        defaultEnabled: true,
+        category: "integrity",
+    },
+    {
+        name: "semantic-completeness",
+        description: "Every inventoried assertive proposition is modeled or explicitly classified",
+        defaultEnabled: false,
+        category: "integrity",
+    },
     {
         name: "query-plan-safety",
         description: "Detect Prolog validation clauses that place negation before generator calls",

package/dist/utils/schema-version.d.ts

@@ -1,5 +1,5 @@
 import type { KbConfig } from "./config.js";
-export declare const LATEST_KB_SCHEMA_VERSION = 3;
+export declare const LATEST_KB_SCHEMA_VERSION = 4;
 export interface SchemaVersionStatus {
     status: "missing" | "invalid" | "older" | "current" | "newer";
     currentVersion: number | null;

package/dist/utils/schema-version.js

@@ -1,5 +1,5 @@
 // implements REQ-003
-export const LATEST_KB_SCHEMA_VERSION = 3;
+export const LATEST_KB_SCHEMA_VERSION = 4;
 // implements REQ-003
 export function normalizeSchemaVersion(schemaVersion) {
     if (schemaVersion === undefined || schemaVersion === null) {