kibi-cli 0.16.1 → 0.18.1

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" },
@@ -38,12 +241,80 @@
         "severity": { "type": "string" },
         "links": { "type": "array", "items": { "type": "string" } },
         "text_ref": { "type": "string" },
+        "semantic_text": {
+            "type": "string",
+            "description": "Requirement-only authored prose whose exact UTF-8 bytes anchor the semantic inventory without replacing text_ref evidence."
+        },
         "logic_claims": {
             "type": "array",
             "minItems": 1,
             "uniqueItems": true,
             "items": { "type": "string", "pattern": "^CLAIM-[A-F0-9]{16}$" }
         },
+        "semantic_clauses": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "type": "string", "minLength": 1 }
+        },
+        "semantic_inventory_version": {
+            "type": "string",
+            "const": "kibi.semantic-inventory.v1"
+        },
+        "semantic_source_field": {
+            "type": "string",
+            "enum": ["semantic_text", "text_ref", "title"]
+        },
+        "semantic_source_hash": {
+            "type": "string",
+            "pattern": "^[a-f0-9]{64}$"
+        },
+        "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",
@@ -73,6 +344,63 @@
             "type": "string",
             "enum": ["internal", "consumer"]
         },
+        "verification_receipts": {
+            "type": "array",
+            "maxItems": 50,
+            "items": {
+                "type": "object",
+                "required": [
+                    "version",
+                    "receipt_id",
+                    "test_id",
+                    "runner",
+                    "command",
+                    "scope",
+                    "outcome",
+                    "code_snapshot",
+                    "environment_hash",
+                    "started_at",
+                    "finished_at",
+                    "artifact_digest"
+                ],
+                "properties": {
+                    "version": {
+                        "type": "string",
+                        "const": "kibi.verification-receipt.v1"
+                    },
+                    "receipt_id": {
+                        "type": "string",
+                        "pattern": "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$"
+                    },
+                    "test_id": { "type": "string", "minLength": 1 },
+                    "runner": { "type": "string", "minLength": 1 },
+                    "command": { "type": "string", "minLength": 1 },
+                    "scope": {
+                        "type": "string",
+                        "enum": ["unit", "integration", "end_to_end"]
+                    },
+                    "outcome": {
+                        "type": "string",
+                        "enum": ["passed", "failed", "errored", "cancelled", "skipped"]
+                    },
+                    "code_snapshot": {
+                        "type": "string",
+                        "pattern": "^[a-f0-9]{64}$"
+                    },
+                    "environment_hash": {
+                        "type": "string",
+                        "pattern": "^[a-f0-9]{64}$"
+                    },
+                    "started_at": { "type": "string", "minLength": 1 },
+                    "finished_at": { "type": "string", "minLength": 1 },
+                    "artifact_digest": {
+                        "type": "string",
+                        "pattern": "^[a-f0-9]{64}$"
+                    }
+                },
+                "additionalProperties": false
+            }
+        },
         "type": {
             "type": "string",
             "enum": [
@@ -94,7 +422,9 @@
                 "observation",
                 "meta",
                 "predicate_schema",
-                "predicate"
+                "predicate",
+                "rule_schema",
+                "rule"
             ]
         },
         "subject_key": { "type": "string" },
@@ -134,7 +464,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",
@@ -168,11 +505,46 @@
                 "not": {
                     "anyOf": [
                         { "required": ["verification_scope"] },
-                        { "required": ["verification_perspective"] }
+                        { "required": ["verification_perspective"] },
+                        { "required": ["verification_receipts"] }
                     ]
                 }
             }
         },
+        {
+            "if": { "required": ["verification_receipts"] },
+            "then": { "required": ["verification_scope"] }
+        },
+        {
+            "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,7 +579,32 @@
                         { "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": {
+                    "anyOf": [
+                        { "required": ["semantic_inventory"] },
+                        { "required": ["semantic_clauses"] },
+                        { "required": ["semantic_text"] },
+                        { "required": ["semantic_inventory_version"] },
+                        { "required": ["semantic_source_field"] },
+                        { "required": ["semantic_source_hash"] }
                     ]
                 }
             }

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;AAoPD,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"}