kibi-cli 0.19.0 → 1.0.1

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

@@ -2,7 +2,7 @@ import { executeCheck } from "../check-executor.js";
 export declare const checkSpec: {
     readonly name: "kb_check";
     readonly cliName: "check";
-    readonly description: "Run KB validation rules and return violations. Use before or after mutations, and after meaningful source edits with impact options to surface symbol granularity and semantic-review diagnostics. Do not use for point lookups. No write side effects. Prefer explicit rules for faster iteration; omit rules for final full validation plus full-KB qualityDiagnostics review, including telemetry acceptance when .kb/usage.log exists.";
+    readonly description: "Run KB validation rules and return violations, quality diagnostics, and typed kibi.migration-plan.v2 actions. Use before or after mutations and after source edits; checks remain read-only and never infer or apply actions from prose suggestions.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -10,9 +10,9 @@ export declare const checkSpec: {
                 readonly type: "array";
                 readonly items: {
                     readonly type: "string";
-                    readonly enum: readonly ["must-priority-coverage", "symbol-coverage", "symbol-traceability", "no-dangling-refs", "no-cycles", "required-fields", "deprecated-adr-no-successor", "domain-contradictions", "strict-fact-shape", "strict-req-fact-pairing", "predicate-verifiability", "logic-coverage", "rule-safety", "rule-verifiability", "semantic-completeness", "query-plan-safety"];
+                    readonly enum: readonly ["must-priority-coverage", "symbol-coverage", "symbol-traceability", "no-dangling-refs", "source-relationship-parity", "no-cycles", "required-fields", "deprecated-adr-no-successor", "domain-contradictions", "strict-fact-shape", "strict-req-fact-pairing", "predicate-verifiability", "logic-coverage", "rule-safety", "rule-verifiability", "semantic-completeness", "query-plan-safety"];
                 };
-                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; if supplied, server preserves scoped validation and skips the full-KB advisory scan.";
+                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
             };
             readonly sourceFiles: {
                 readonly type: "array";
@@ -40,7 +40,7 @@ export declare const checkSpec: {
             };
             readonly workspaceRoot: {
                 readonly type: "string";
-                readonly description: "Optional workspace root for impact diagnostics and .kb/config.json lookup. Defaults to the MCP server workspace.";
+                readonly description: "Optional workspace root for impact diagnostics. Defaults to the MCP server workspace.";
             };
         };
     };

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

@@ -1 +1 @@
-{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGpD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEY,CAAC"}
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGpD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwEY,CAAC"}

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

@@ -2,7 +2,7 @@ import { executeCheck } from "../check-executor.js";
 export const checkSpec = {
     name: "kb_check",
     cliName: "check",
-    description: "Run KB validation rules and return violations. Use before or after mutations, and after meaningful source edits with impact options to surface symbol granularity and semantic-review diagnostics. Do not use for point lookups. No write side effects. Prefer explicit rules for faster iteration; omit rules for final full validation plus full-KB qualityDiagnostics review, including telemetry acceptance when .kb/usage.log exists.",
+    description: "Run KB validation rules and return violations, quality diagnostics, and typed kibi.migration-plan.v2 actions. Use before or after mutations and after source edits; checks remain read-only and never infer or apply actions from prose suggestions.",
     businessInputSchema: {
         type: "object",
         properties: {
@@ -15,6 +15,7 @@ export const checkSpec = {
                         "symbol-coverage",
                         "symbol-traceability",
                         "no-dangling-refs",
+                        "source-relationship-parity",
                         "no-cycles",
                         "required-fields",
                         "deprecated-adr-no-successor",
@@ -29,7 +30,7 @@ export const checkSpec = {
                         "query-plan-safety",
                     ],
                 },
-                description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; if supplied, server preserves scoped validation and skips the full-KB advisory scan.",
+                description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.",
             },
             sourceFiles: {
                 type: "array",
@@ -55,7 +56,7 @@ export const checkSpec = {
             },
             workspaceRoot: {
                 type: "string",
-                description: "Optional workspace root for impact diagnostics and .kb/config.json lookup. Defaults to the MCP server workspace.",
+                description: "Optional workspace root for impact diagnostics. Defaults to the MCP server workspace.",
             },
         },
     },

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

@@ -45,7 +45,7 @@ export declare const querySpec: {
 export declare const searchSpec: {
     readonly name: "kb_search";
     readonly cliName: "search";
-    readonly description: "Search KB entities for discovery using metadata and markdown body text. Use for exploratory lookup before exact follow-up with kb_query. No mutation side effects.";
+    readonly description: "Search KB entities for discovery using legacy lexical ranking or deterministic intent-v1 ranking. Intent mode accepts host-agent semantic facets and source locations, returns evidence and abstains below its confidence threshold. Use for exploratory lookup before exact follow-up with kb_query. No mutation side effects.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["query"];
@@ -73,6 +73,90 @@ export declare const searchSpec: {
                 readonly default: 0;
                 readonly description: "Optional zero-based pagination offset. Default: 0.";
             };
+            readonly rankingMode: {
+                readonly type: "string";
+                readonly enum: readonly ["legacy", "intent-v1"];
+                readonly default: "legacy";
+                readonly description: "Optional deterministic ranking mode. Omit for backward-compatible lexical search; use intent-v1 for semantic facets, source-aware evidence, graph boosts, and abstention.";
+            };
+            readonly semanticFacets: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly actors: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly actions: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly objects: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly constraints: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly aliases: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                };
+                readonly description: "Optional host-agent semantic interpretation. Kibi uses these strings as deterministic aliases/facets; it does not call a model itself.";
+            };
+            readonly sourceLocations: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["path"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly path: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly description: "Workspace-relative source path.";
+                        };
+                        readonly line: {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                        };
+                        readonly column: {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                        };
+                        readonly symbol: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly description: "Optional changed-code locations. Results are matched to source-linked symbols/entities and include source evidence.";
+            };
+            readonly minScore: {
+                readonly type: "number";
+                readonly minimum: 0;
+                readonly maximum: 1;
+                readonly default: 0.18;
+                readonly description: "Intent-v1 acceptance threshold between 0 and 1. Low-confidence queries abstain instead of returning misleading matches.";
+            };
         };
     };
     readonly requiresProlog: true;
@@ -82,12 +166,12 @@ export declare const searchSpec: {
 export declare const statusSpec: {
     readonly name: "kb_status";
     readonly cliName: "status";
-    readonly description: "Report current branch, KB snapshot and freshness metadata, plus the deterministic workspace snapshot used to validate execution receipts. Read-only status inspection with no mutation side effects.";
+    readonly description: "Report current branch, KB snapshot, freshness metadata, schema status, and a typed kibi.migration-plan.v2 action graph. Read-only status inspection with no mutation side effects; damaged stores are diagnosed without starting the engine.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {};
     };
-    readonly requiresProlog: true;
+    readonly requiresProlog: false;
     readonly effects: readonly ["kb-read", "workspace-read"];
     readonly execute: typeof executeStatus;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAC;AAsBnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CsC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCuC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;;;;;;;;CASuC,CAAC"}
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAC;AAsBnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CsC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4FuC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;;;;;;;;CAUuC,CAAC"}

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

@@ -53,7 +53,7 @@ export const querySpec = {
 export const searchSpec = {
     name: "kb_search",
     cliName: "search",
-    description: "Search KB entities for discovery using metadata and markdown body text. Use for exploratory lookup before exact follow-up with kb_query. No mutation side effects.",
+    description: "Search KB entities for discovery using legacy lexical ranking or deterministic intent-v1 ranking. Intent mode accepts host-agent semantic facets and source locations, returns evidence and abstains below its confidence threshold. Use for exploratory lookup before exact follow-up with kb_query. No mutation side effects.",
     businessInputSchema: {
         type: "object",
         required: ["query"],
@@ -81,6 +81,55 @@ export const searchSpec = {
                 default: 0,
                 description: "Optional zero-based pagination offset. Default: 0.",
             },
+            rankingMode: {
+                type: "string",
+                enum: ["legacy", "intent-v1"],
+                default: "legacy",
+                description: "Optional deterministic ranking mode. Omit for backward-compatible lexical search; use intent-v1 for semantic facets, source-aware evidence, graph boosts, and abstention.",
+            },
+            semanticFacets: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    actors: { type: "array", items: { type: "string" }, maxItems: 20 },
+                    actions: { type: "array", items: { type: "string" }, maxItems: 20 },
+                    objects: { type: "array", items: { type: "string" }, maxItems: 20 },
+                    constraints: {
+                        type: "array",
+                        items: { type: "string" },
+                        maxItems: 20,
+                    },
+                    aliases: { type: "array", items: { type: "string" }, maxItems: 20 },
+                },
+                description: "Optional host-agent semantic interpretation. Kibi uses these strings as deterministic aliases/facets; it does not call a model itself.",
+            },
+            sourceLocations: {
+                type: "array",
+                maxItems: 20,
+                items: {
+                    type: "object",
+                    required: ["path"],
+                    additionalProperties: false,
+                    properties: {
+                        path: {
+                            type: "string",
+                            minLength: 1,
+                            description: "Workspace-relative source path.",
+                        },
+                        line: { type: "integer", minimum: 1 },
+                        column: { type: "integer", minimum: 1 },
+                        symbol: { type: "string", minLength: 1 },
+                    },
+                },
+                description: "Optional changed-code locations. Results are matched to source-linked symbols/entities and include source evidence.",
+            },
+            minScore: {
+                type: "number",
+                minimum: 0,
+                maximum: 1,
+                default: 0.18,
+                description: "Intent-v1 acceptance threshold between 0 and 1. Low-confidence queries abstain instead of returning misleading matches.",
+            },
         },
     },
     requiresProlog: true,
@@ -90,9 +139,10 @@ export const searchSpec = {
 export const statusSpec = {
     name: "kb_status",
     cliName: "status",
-    description: "Report current branch, KB snapshot and freshness metadata, plus the deterministic workspace snapshot used to validate execution receipts. Read-only status inspection with no mutation side effects.",
+    description: "Report current branch, KB snapshot, freshness metadata, schema status, and a typed kibi.migration-plan.v2 action graph. Read-only status inspection with no mutation side effects; damaged stores are diagnosed without starting the engine.",
     businessInputSchema: { type: "object", properties: {} },
-    requiresProlog: true,
+    // Status must remain available when the branch store cannot be attached.
+    requiresProlog: false,
     effects: ["kb-read", "workspace-read"],
     execute: executeStatus,
 };

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

@@ -14,7 +14,7 @@ export declare const modelRequirementSpec: {
             };
             readonly source: {
                 readonly type: "string";
-                readonly description: "Optional primary source path or provenance root used for stable IDs and text refs. Example: 'documentation/requirements/customer-retention.md'.";
+                readonly description: "Optional primary source path or provenance root used for stable IDs and text refs. Example: '.kb/requirements/customer-retention.md'.";
             };
             readonly sourceFiles: {
                 readonly type: "array";
@@ -48,7 +48,7 @@ export declare const modelRequirementSpec: {
             };
             readonly provenance: {
                 readonly type: "string";
-                readonly description: "Optional extracted text reference. Falls back to source when omitted. Example: 'documentation/requirements/customer-retention.md#L1'.";
+                readonly description: "Optional extracted text reference. Falls back to source when omitted. Example: '.kb/requirements/customer-retention.md#L1'.";
             };
             readonly existingLogicClaims: {
                 readonly type: "array";
@@ -84,7 +84,7 @@ export declare const modelRequirementSpec: {
 export declare const suggestPredicatesSpec: {
     readonly name: "kb_suggest_predicates";
     readonly cliName: "suggest-predicates";
-    readonly description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Read-only guidance returns ranked candidates, an applicable predicate-fact plan only when every ordered argument is bound, a separate requires_predicate relationship plan when a requirement ID is supplied, or an explicit ontology-gap observation when no predicate fits.";
+    readonly description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Retrieval/ranking is followed by a semantic applicability gate and conservative binding review; complete-looking generic placeholders never trigger application. Read-only guidance returns additive candidate diagnostics, an applicable predicate-fact plan only for a semantically eligible candidate with reviewed bindings, or an explicit ontology-gap observation plus a deterministic review-only predicate schema draft when no schema fits.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["text"];

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

@@ -14,7 +14,7 @@ export const modelRequirementSpec = {
             },
             source: {
                 type: "string",
-                description: "Optional primary source path or provenance root used for stable IDs and text refs. Example: 'documentation/requirements/customer-retention.md'.",
+                description: "Optional primary source path or provenance root used for stable IDs and text refs. Example: '.kb/requirements/customer-retention.md'.",
             },
             sourceFiles: {
                 type: "array",
@@ -46,7 +46,7 @@ export const modelRequirementSpec = {
             },
             provenance: {
                 type: "string",
-                description: "Optional extracted text reference. Falls back to source when omitted. Example: 'documentation/requirements/customer-retention.md#L1'.",
+                description: "Optional extracted text reference. Falls back to source when omitted. Example: '.kb/requirements/customer-retention.md#L1'.",
             },
             existingLogicClaims: {
                 type: "array",
@@ -79,7 +79,7 @@ export const modelRequirementSpec = {
 export const suggestPredicatesSpec = {
     name: "kb_suggest_predicates",
     cliName: "suggest-predicates",
-    description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Read-only guidance returns ranked candidates, an applicable predicate-fact plan only when every ordered argument is bound, a separate requires_predicate relationship plan when a requirement ID is supplied, or an explicit ontology-gap observation when no predicate fits.",
+    description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Retrieval/ranking is followed by a semantic applicability gate and conservative binding review; complete-looking generic placeholders never trigger application. Read-only guidance returns additive candidate diagnostics, an applicable predicate-fact plan only for a semantically eligible candidate with reviewed bindings, or an explicit ontology-gap observation plus a deterministic review-only predicate schema draft when no schema fits.",
     businessInputSchema: {
         type: "object",
         required: ["text"],

package/dist/public/operations/specs/mutation-schemas.d.ts

@@ -89,7 +89,7 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
         };
         readonly granularity_reason: {
             readonly type: "string";
-            readonly enum: readonly ["config-artifact", "module-level-behavior", "extractor-miss", "legacy-link"];
+            readonly enum: readonly ["config-artifact", "module-level-behavior", "extractor-miss", "legacy-link", "test-suite"];
             readonly description: "Optional justification for a coarse file/module-level symbol traceability relationship when narrower function/class/type symbols exist.";
         };
         readonly symbol_role: {
@@ -107,63 +107,206 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
             readonly enum: readonly ["internal", "consumer"];
             readonly description: "Optional typed verification perspective for test entities. Example: 'consumer'.";
         };
-        readonly verification_receipts: {
-            readonly type: "array";
-            readonly maxItems: 50;
-            readonly items: {
-                readonly type: "object";
-                readonly required: readonly ["version", "receipt_id", "test_id", "runner", "command", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest"];
-                readonly properties: {
-                    readonly version: {
-                        readonly type: "string";
-                        readonly const: "kibi.verification-receipt.v1";
-                    };
-                    readonly receipt_id: {
-                        readonly type: "string";
-                        readonly pattern: "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
-                    };
-                    readonly test_id: {
-                        readonly type: "string";
-                        readonly minLength: 1;
-                    };
-                    readonly runner: {
+        readonly verification_contract: {
+            readonly type: "object";
+            readonly required: readonly ["version", "runner", "command_argv", "required_case_symbols", "required_projects", "success_policy"];
+            readonly properties: {
+                readonly version: {
+                    readonly type: "string";
+                    readonly const: "kibi.verification-contract.v1";
+                };
+                readonly runner: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly command_argv: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly items: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
-                    readonly command: {
+                };
+                readonly required_case_symbols: {
+                    readonly type: "array";
+                    readonly items: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
-                    readonly scope: {
-                        readonly type: "string";
-                        readonly enum: readonly ["unit", "integration", "end_to_end"];
-                    };
-                    readonly outcome: {
-                        readonly type: "string";
-                        readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped"];
-                    };
-                    readonly code_snapshot: {
-                        readonly type: "string";
-                        readonly pattern: "^[a-f0-9]{64}$";
-                    };
-                    readonly environment_hash: {
-                        readonly type: "string";
-                        readonly pattern: "^[a-f0-9]{64}$";
-                    };
-                    readonly started_at: {
+                    readonly uniqueItems: true;
+                };
+                readonly required_projects: {
+                    readonly type: "array";
+                    readonly items: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
-                    readonly finished_at: {
-                        readonly type: "string";
-                        readonly minLength: 1;
+                    readonly uniqueItems: true;
+                };
+                readonly success_policy: {
+                    readonly type: "string";
+                    readonly const: "all_required_cases_first_attempt";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly verification_receipts: {
+            readonly type: "array";
+            readonly maxItems: 50;
+            readonly items: {
+                readonly oneOf: readonly [{
+                    readonly type: "object";
+                    readonly required: readonly ["version", "receipt_id", "test_id", "runner", "command", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest"];
+                    readonly properties: {
+                        readonly version: {
+                            readonly type: "string";
+                            readonly const: "kibi.verification-receipt.v1";
+                        };
+                        readonly receipt_id: {
+                            readonly type: "string";
+                            readonly pattern: "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
+                        };
+                        readonly test_id: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly runner: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly command: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly scope: {
+                            readonly type: "string";
+                            readonly enum: readonly ["unit", "integration", "end_to_end"];
+                        };
+                        readonly outcome: {
+                            readonly type: "string";
+                            readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
+                        };
+                        readonly code_snapshot: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-f0-9]{64}$";
+                        };
+                        readonly environment_hash: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-f0-9]{64}$";
+                        };
+                        readonly started_at: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly finished_at: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly artifact_digest: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-f0-9]{64}$";
+                        };
                     };
-                    readonly artifact_digest: {
-                        readonly type: "string";
-                        readonly pattern: "^[a-f0-9]{64}$";
+                    readonly additionalProperties: false;
+                }, {
+                    readonly required: readonly ["version", "receipt_id", "test_id", "runner", "command", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest", "command_argv", "contract_hash", "case_results"];
+                    readonly properties: {
+                        readonly version: {
+                            readonly type: "string";
+                            readonly const: "kibi.verification-receipt.v2";
+                        };
+                        readonly command_argv: {
+                            readonly type: "array";
+                            readonly minItems: 1;
+                            readonly items: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                        readonly contract_hash: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-f0-9]{64}$";
+                        };
+                        readonly case_results: {
+                            readonly type: "array";
+                            readonly minItems: 1;
+                            readonly maxItems: 1000;
+                            readonly items: {
+                                readonly type: "object";
+                                readonly required: readonly ["symbol_id", "project", "outcome", "retries", "duration_ms"];
+                                readonly properties: {
+                                    readonly symbol_id: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly project: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly outcome: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted"];
+                                    };
+                                    readonly retries: {
+                                        readonly type: "integer";
+                                        readonly minimum: 0;
+                                    };
+                                    readonly duration_ms: {
+                                        readonly type: "integer";
+                                        readonly minimum: 0;
+                                    };
+                                };
+                                readonly additionalProperties: false;
+                            };
+                        };
+                        readonly receipt_id: {
+                            readonly type: "string";
+                            readonly pattern: "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
+                        };
+                        readonly test_id: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly runner: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly command: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly scope: {
+                            readonly type: "string";
+                            readonly enum: readonly ["unit", "integration", "end_to_end"];
+                        };
+                        readonly outcome: {
+                            readonly type: "string";
+                            readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
+                        };
+                        readonly code_snapshot: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-f0-9]{64}$";
+                        };
+                        readonly environment_hash: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-f0-9]{64}$";
+                        };
+                        readonly started_at: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly finished_at: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly artifact_digest: {
+                            readonly type: "string";
+                            readonly pattern: "^[a-f0-9]{64}$";
+                        };
                     };
-                };
-                readonly additionalProperties: false;
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                }];
             };
             readonly description: "Append-only test execution evidence. Proof accepts only the newest valid passed receipt bound to the current code snapshot and within the seven-day freshness window.";
         };

package/dist/public/operations/specs/mutation-schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutation-schemas.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation-schemas.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,gFASf,CAAC;AAYX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+S3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA2CvB,CAAC"}
+{"version":3,"file":"mutation-schemas.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation-schemas.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY,gFASf,CAAC;AAYX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiT3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA2CvB,CAAC"}

package/dist/public/operations/specs/mutation-schemas.js

@@ -1,4 +1,4 @@
-import { VERIFICATION_RECEIPT_SCHEMA } from "../../verification-receipt.js";
+import { VERIFICATION_CONTRACT_SCHEMA, VERIFICATION_RECEIPT_SCHEMA, } from "../../verification-receipt.js";
 export const ENTITY_TYPES = [
     "req",
     "scenario",
@@ -103,6 +103,7 @@ export const ENTITY_PROPERTIES_SCHEMA = {
                 "module-level-behavior",
                 "extractor-miss",
                 "legacy-link",
+                "test-suite",
             ],
             description: "Optional justification for a coarse file/module-level symbol traceability relationship when narrower function/class/type symbols exist.",
         },
@@ -128,6 +129,7 @@ export const ENTITY_PROPERTIES_SCHEMA = {
             enum: ["internal", "consumer"],
             description: "Optional typed verification perspective for test entities. Example: 'consumer'.",
         },
+        verification_contract: VERIFICATION_CONTRACT_SCHEMA,
         verification_receipts: {
             type: "array",
             maxItems: 50,