kibi-cli 0.14.0 → 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" },
@@ -38,6 +241,59 @@
         "severity": { "type": "string" },
         "links": { "type": "array", "items": { "type": "string" } },
         "text_ref": { "type": "string" },
+        "logic_claims": {
+            "type": "array",
+            "minItems": 1,
+            "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",
@@ -88,7 +344,9 @@
                 "observation",
                 "meta",
                 "predicate_schema",
-                "predicate"
+                "predicate",
+                "rule_schema",
+                "rule"
             ]
         },
         "subject_key": { "type": "string" },
@@ -115,6 +373,8 @@
         "valid_from": { "type": "string" },
         "valid_to": { "type": "string" },
         "canonical_key": { "type": "string" },
+        "claim_key": { "type": "string", "pattern": "^CLAIM-[A-F0-9]{16}$" },
+        "claim_text": { "type": "string" },
         "predicate_name": { "type": "string" },
         "predicate_namespace": { "type": "string" },
         "predicate_arity": { "type": "integer", "minimum": 1 },
@@ -126,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",
@@ -138,6 +405,19 @@
         "type"
     ],
     "allOf": [
+        {
+            "if": {
+                "properties": { "type": { "const": "req" } }
+            },
+            "then": {},
+            "else": { "not": { "required": ["logic_claims"] } }
+        },
+        {
+            "if": {
+                "anyOf": [{ "required": ["claim_key"] }, { "required": ["claim_text"] }]
+            },
+            "then": { "required": ["claim_key", "claim_text"] }
+        },
         {
             "if": {
                 "properties": { "type": { "const": "test" } }
@@ -152,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" } }
@@ -176,6 +486,8 @@
                         { "required": ["valid_from"] },
                         { "required": ["valid_to"] },
                         { "required": ["canonical_key"] },
+                        { "required": ["claim_key"] },
+                        { "required": ["claim_text"] },
                         { "required": ["predicate_name"] },
                         { "required": ["predicate_namespace"] },
                         { "required": ["predicate_arity"] },
@@ -184,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

@@ -1,6 +1,6 @@
 import type { QualityDiagnostic } from "../public/impact/types.js";
 import { type KibiImpactEvidence } from "./evidence-model.js";
-export type KibiImpactDiagnosticId = "kibi_impact_evidence_missing" | "symbols_manifest_stale" | "symbol_granularity_violation" | "symbol_semantic_review_needed" | "multi_requirement_symbol_review" | "duplicate_symbol_coordinate_review" | "component_mixed_purpose_review" | "broad_requirement_review" | "requirement_status_review" | "strict_fact_modeling_review" | "kibi_impact_override_missing_rationale";
+export type KibiImpactDiagnosticId = "kibi_impact_evidence_missing" | "symbols_manifest_stale" | "symbol_granularity_violation" | "symbol_semantic_review_needed" | "multi_requirement_symbol_review" | "duplicate_symbol_coordinate_review" | "component_mixed_purpose_review" | "broad_requirement_review" | "requirement_status_review" | "strict_fact_modeling_review" | "logical_coverage_review" | "kibi_impact_override_missing_rationale";
 export interface KibiImpactDiagnostic extends QualityDiagnostic {
     /** Stable staged-enforcement diagnostic identifier. */
     id: KibiImpactDiagnosticId;
@@ -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,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

@@ -10,6 +10,7 @@ export interface StagedAuthoredSymbolsManifestEvidence {
         sourcePath: string;
         entityIds: string[];
     }>;
+    changedEntityIds: string[];
 }
 export declare function assessStagedSymbolsManifest(options: {
     symbolsManifestPath: string;

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;CAC7D;AA+SD,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,CA8ElC;AAoBD,wBAAgB,4CAA4C,CAAC,OAAO,EAAE;IACpE,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B,GAAG,qCAAqC,CAgDxC"}
+{"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, "/");
@@ -100,6 +111,9 @@ function normalizeRelationships(relationships) {
 function normalizeManifestSymbolsForSourceFile(records, sourceFile) {
     return records
         .filter((record) => {
+        if (isDocumentedCoarseRecord(record)) {
+            return false;
+        }
         const recordSource = typeof record.sourceFile === "string"
             ? record.sourceFile
             : typeof record.source === "string"
@@ -226,6 +240,19 @@ 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 baselineSymbols = normalizeManifestSymbolsForSourceFile(baselineMergedRecords, sourceFile.path);
         if (signaturesEqual(expectedSymbols, baselineSymbols)) {
@@ -256,42 +283,44 @@ export function assessStagedSymbolsManifest(options) {
     }
     return { state: "stale", sourcePaths, path: paths.coordinatesPath };
 }
-function getEntityIdsForSourceFile(records, sourceFile) {
-    return records
-        .filter((record) => {
-        const recordSource = typeof record.sourceFile === "string"
-            ? record.sourceFile
-            : typeof record.source === "string"
-                ? record.source
-                : null;
-        return recordSource === sourceFile && typeof record.id === "string";
-    })
-        .map((record) => record.id)
-        .sort();
-}
 export function collectStagedAuthoredSymbolsManifestEvidence(options) {
     const { sourceFiles, stagedFiles } = options;
     const paths = resolveRelativeManifestPaths();
     const stagedManifestFile = stagedFiles.find((file) => file.path === paths.symbolsPath);
     if (!stagedManifestFile) {
-        return { path: paths.symbolsPath, entries: [] };
+        return { path: paths.symbolsPath, entries: [], changedEntityIds: [] };
     }
     const headManifestRecords = parseManifestRecords(readHeadFileContent(paths.symbolsPath), paths.symbolsPath) ?? [];
     const stagedManifestRecords = parseManifestRecords(stagedManifestFile.content, paths.symbolsPath);
     if (stagedManifestRecords === null) {
-        return { path: paths.symbolsPath, entries: [] };
+        return { path: paths.symbolsPath, entries: [], changedEntityIds: [] };
     }
+    const sourcePaths = uniqueSorted([...headManifestRecords, ...stagedManifestRecords].flatMap((record) => {
+        const sourceFile = typeof record.sourceFile === "string"
+            ? record.sourceFile
+            : typeof record.source === "string"
+                ? record.source
+                : null;
+        return sourceFile === null ? [] : [sourceFile];
+    }));
+    const changedEntityIdsBySourcePath = new Map(sourcePaths.map((sourcePath) => {
+        const headSymbols = normalizeAuthoredManifestSymbolsForSourceFile(headManifestRecords, sourcePath);
+        const stagedSymbols = normalizeAuthoredManifestSymbolsForSourceFile(stagedManifestRecords, sourcePath);
+        return [
+            sourcePath,
+            getChangedAuthoredEntityIds(headSymbols, stagedSymbols),
+        ];
+    }));
     const entries = [];
     for (const sourceFile of sourceFiles) {
-        const headSymbols = normalizeAuthoredManifestSymbolsForSourceFile(headManifestRecords, sourceFile.path);
-        const stagedSymbols = normalizeAuthoredManifestSymbolsForSourceFile(stagedManifestRecords, sourceFile.path);
-        if (signaturesEqual(headSymbols, stagedSymbols)) {
+        const entityIds = changedEntityIdsBySourcePath.get(sourceFile.path) ?? [];
+        if (entityIds.length === 0)
             continue;
-        }
-        entries.push({
-            sourcePath: sourceFile.path,
-            entityIds: getChangedAuthoredEntityIds(headSymbols, stagedSymbols),
-        });
+        entries.push({ sourcePath: sourceFile.path, entityIds });
     }
-    return { path: paths.symbolsPath, entries };
+    return {
+        path: paths.symbolsPath,
+        entries,
+        changedEntityIds: uniqueSorted(Array.from(changedEntityIdsBySourcePath.values()).flat()),
+    };
 }

package/dist/traceability/symbol-extract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbol-extract.d.ts","sourceRoot":"","sources":["../../src/traceability/symbol-extract.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,UAAU,EAEhB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7D,KAAK,wBAAwB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAU7D,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AAE9D,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAG5E;AAmOD,wBAAgB,4BAA4B,CAE1C,UAAU,EAAE,UAAU,EACtB,cAAc,CAAC,EAAE,cAAc,GAC9B,eAAe,EAAE,CAwSnB"}
+{"version":3,"file":"symbol-extract.d.ts","sourceRoot":"","sources":["../../src/traceability/symbol-extract.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,UAAU,EAEhB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7D,KAAK,wBAAwB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAU7D,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AAE9D,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAG5E;AAmOD,wBAAgB,4BAA4B,CAE1C,UAAU,EAAE,UAAU,EACtB,cAAc,CAAC,EAAE,cAAc,GAC9B,eAAe,EAAE,CA2SnB"}