kibi-cli 1.0.1 → 2.0.0

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

@@ -107,208 +107,302 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
             readonly enum: readonly ["internal", "consumer"];
             readonly description: "Optional typed verification perspective for test entities. Example: 'consumer'.";
         };
-        readonly verification_contract: {
+        readonly proof_contract: {
+            readonly description: "Semantic proof contract binding this test to explicit proof obligations executed by one configured integration.";
             readonly type: "object";
-            readonly required: readonly ["version", "runner", "command_argv", "required_case_symbols", "required_projects", "success_policy"];
+            readonly required: readonly ["version", "integration", "required_proofs", "success_policy"];
             readonly properties: {
                 readonly version: {
                     readonly type: "string";
-                    readonly const: "kibi.verification-contract.v1";
+                    readonly const: "kibi.proof-contract.v1";
                 };
-                readonly runner: {
+                readonly integration: {
                     readonly type: "string";
                     readonly minLength: 1;
                 };
-                readonly command_argv: {
+                readonly required_proofs: {
                     readonly type: "array";
                     readonly minItems: 1;
+                    readonly maxItems: 1000;
                     readonly items: {
+                        readonly type: "object";
+                        readonly required: readonly ["symbol_id", "target"];
+                        readonly properties: {
+                            readonly symbol_id: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly target: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly success_policy: {
+                    readonly type: "string";
+                    readonly enum: readonly ["all_required_first_attempt"];
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly proof_bindings: {
+            readonly description: "Optional native-runner bindings (native ids, aliases, source coordinates) for proof obligations. Bindings are provenance metadata and never replace the semantic contract.";
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["symbol_id", "target"];
+                readonly properties: {
+                    readonly symbol_id: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
-                };
-                readonly required_case_symbols: {
-                    readonly type: "array";
-                    readonly items: {
+                    readonly target: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
-                    readonly uniqueItems: true;
-                };
-                readonly required_projects: {
-                    readonly type: "array";
-                    readonly items: {
+                    readonly native_id: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
-                    readonly uniqueItems: true;
-                };
-                readonly success_policy: {
-                    readonly type: "string";
-                    readonly const: "all_required_cases_first_attempt";
+                    readonly aliases: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly source_file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
                 };
+                readonly additionalProperties: false;
             };
-            readonly additionalProperties: false;
         };
-        readonly verification_receipts: {
+        readonly proof_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 type: "object";
+                readonly description: "Kibi-derived kibi.proof-receipt.v1. Receipts are never caller-authored; kb_ingest_proof derives them from kibi.proof-run.v1 artifacts.";
+                readonly required: readonly ["version", "receipt_id", "test_id", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest", "contract_hash", "fingerprint", "fingerprint_components", "integration_id", "producer", "command_argv", "run_outcome", "proof_results"];
+                readonly properties: {
+                    readonly version: {
+                        readonly type: "string";
+                        readonly const: "kibi.proof-receipt.v1";
                     };
-                    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 receipt_id: {
+                        readonly type: "string";
+                        readonly pattern: "^PR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
+                    };
+                    readonly test_id: {
+                        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 contract_hash: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{64}$";
+                    };
+                    readonly binding_hash: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{64}$";
+                    };
+                    readonly fingerprint: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{64}$";
+                    };
+                    readonly fingerprint_components: {
+                        readonly type: "object";
+                        readonly required: readonly ["contract", "integration", "command", "bindings", "producer"];
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly contract: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-f0-9]{64}$";
+                            };
+                            readonly integration: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-f0-9]{64}$";
+                            };
+                            readonly command: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-f0-9]{64}$";
+                            };
+                            readonly bindings: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-f0-9]{64}$";
+                            };
+                            readonly producer: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-f0-9]{64}$";
+                            };
                         };
-                        readonly command_argv: {
-                            readonly type: "array";
-                            readonly minItems: 1;
-                            readonly items: {
+                    };
+                    readonly integration_id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly producer: {
+                        readonly type: "object";
+                        readonly required: readonly ["name"];
+                        readonly properties: {
+                            readonly name: {
                                 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 version: {
+                                readonly type: "string";
+                                readonly minLength: 1;
                             };
                         };
-                        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 additionalProperties: false;
+                    };
+                    readonly command_argv: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly items: {
                             readonly type: "string";
                             readonly minLength: 1;
                         };
-                        readonly finished_at: {
-                            readonly type: "string";
-                            readonly minLength: 1;
+                    };
+                    readonly run_outcome: {
+                        readonly type: "string";
+                        readonly enum: readonly ["passed", "failed", "errored", "cancelled", "timed_out", "interrupted", "no_results"];
+                    };
+                    readonly proof_results: {
+                        readonly type: "array";
+                        readonly minItems: 0;
+                        readonly maxItems: 1000;
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["symbol_id", "target", "outcome", "binding", "attempts"];
+                            readonly properties: {
+                                readonly symbol_id: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly target: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly outcome: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
+                                };
+                                readonly binding: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["native_case", "aggregate_run"];
+                                };
+                                readonly native_id: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly attempts: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "object";
+                                        readonly required: readonly ["status", "entries"];
+                                        readonly properties: {
+                                            readonly status: {
+                                                readonly type: "string";
+                                                readonly const: "complete";
+                                            };
+                                            readonly entries: {
+                                                readonly type: "array";
+                                                readonly minItems: 1;
+                                                readonly items: {
+                                                    readonly type: "object";
+                                                    readonly required: readonly ["outcome"];
+                                                    readonly properties: {
+                                                        readonly outcome: {
+                                                            readonly type: "string";
+                                                            readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
+                                                        };
+                                                        readonly duration_ms: {
+                                                            readonly type: "number";
+                                                            readonly minimum: 0;
+                                                        };
+                                                    };
+                                                    readonly additionalProperties: false;
+                                                };
+                                            };
+                                        };
+                                        readonly additionalProperties: false;
+                                    }, {
+                                        readonly type: "object";
+                                        readonly required: readonly ["status"];
+                                        readonly properties: {
+                                            readonly status: {
+                                                readonly type: "string";
+                                                readonly const: "unavailable";
+                                            };
+                                        };
+                                        readonly additionalProperties: false;
+                                    }];
+                                };
+                            };
+                            readonly additionalProperties: false;
                         };
-                        readonly artifact_digest: {
-                            readonly type: "string";
-                            readonly pattern: "^[a-f0-9]{64}$";
+                    };
+                    readonly gaps: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["symbol_id", "target", "reason"];
+                            readonly properties: {
+                                readonly symbol_id: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly target: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly reason: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                            };
+                            readonly additionalProperties: false;
                         };
                     };
-                    readonly type: "object";
-                    readonly additionalProperties: false;
-                }];
+                };
+                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.";
+            readonly description: "Append-only proof evidence. Proof accepts only the newest valid passed receipt bound to the current code snapshot, current contract hash, and effective execution fingerprint within the seven-day freshness window. Ingest rotates the oldest entries at the cap.";
         };
         readonly fact_kind: {
             readonly type: "string";
@@ -472,7 +566,7 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
     };
     readonly allOf: readonly [Record<string, unknown>, {
         readonly if: {
-            readonly required: readonly ["verification_receipts"];
+            readonly required: readonly ["proof_receipts"];
         };
         readonly then: {
             readonly required: readonly ["verification_scope"];

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":"AAKA,eAAO,MAAM,YAAY,gFASf,CAAC;AAYX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiT3B,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":"AASA,eAAO,MAAM,YAAY,gFASf,CAAC;AAYX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0T3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA2CvB,CAAC"}

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

@@ -1,4 +1,5 @@
-import { VERIFICATION_CONTRACT_SCHEMA, VERIFICATION_RECEIPT_SCHEMA, } from "../../verification-receipt.js";
+import { PROOF_BINDINGS_SCHEMA, PROOF_CONTRACT_SCHEMA, } from "../../proof-protocol.js";
+import { MAX_PROOF_RECEIPTS, PROOF_RECEIPT_SCHEMA, } from "../../proof-receipt.js";
 export const ENTITY_TYPES = [
     "req",
     "scenario",
@@ -129,12 +130,19 @@ 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: {
+        proof_contract: {
+            ...PROOF_CONTRACT_SCHEMA,
+            description: "Semantic proof contract binding this test to explicit proof obligations executed by one configured integration.",
+        },
+        proof_bindings: {
+            ...PROOF_BINDINGS_SCHEMA,
+            description: "Optional native-runner bindings (native ids, aliases, source coordinates) for proof obligations. Bindings are provenance metadata and never replace the semantic contract.",
+        },
+        proof_receipts: {
             type: "array",
-            maxItems: 50,
-            items: VERIFICATION_RECEIPT_SCHEMA,
-            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.",
+            maxItems: MAX_PROOF_RECEIPTS,
+            items: PROOF_RECEIPT_SCHEMA,
+            description: "Append-only proof evidence. Proof accepts only the newest valid passed receipt bound to the current code snapshot, current contract hash, and effective execution fingerprint within the seven-day freshness window. Ingest rotates the oldest entries at the cap.",
         },
         fact_kind: {
             type: "string",
@@ -285,7 +293,7 @@ export const ENTITY_PROPERTIES_SCHEMA = {
     allOf: [
         CLAIM_PROVENANCE_CONDITIONAL,
         {
-            if: { required: ["verification_receipts"] },
+            if: { required: ["proof_receipts"] },
             // biome-ignore lint/suspicious/noThenProperty: JSON Schema conditional keyword.
             then: { required: ["verification_scope"] },
         },

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

@@ -179,6 +179,15 @@ export declare const compileIntentSpec: {
                             readonly type: "string";
                             readonly minLength: 1;
                         };
+                        readonly scenarioIds: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly maxItems: 20;
+                            readonly description: "Stable scenario draft IDs verified by this test. Required when multiple scenario drafts are supplied.";
+                        };
                         readonly verificationScope: {
                             readonly type: "string";
                             readonly enum: readonly ["unit", "integration", "end_to_end"];

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

@@ -1 +1 @@
-{"version":3,"file":"planning.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/planning.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,gBAAgB,EACjB,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAGL,oBAAoB,EACrB,MAAM,gDAAgD,CAAC;AAGxD,YAAY,EACV,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,oBAAoB,GACrB,MAAM,gDAAgD,CAAC;AACxD,YAAY,EACV,aAAa,EACb,eAAe,GAChB,MAAM,4CAA4C,CAAC;AACpD,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,gDAAgD,CAAC;AAGtF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmJsC,CAAC;AAGrE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDwC,CAAC"}
+{"version":3,"file":"planning.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/planning.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,gBAAgB,EACjB,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAGL,oBAAoB,EACrB,MAAM,gDAAgD,CAAC;AAGxD,YAAY,EACV,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,oBAAoB,GACrB,MAAM,gDAAgD,CAAC;AACxD,YAAY,EACV,aAAa,EACb,eAAe,GAChB,MAAM,4CAA4C,CAAC;AACpD,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,gDAAgD,CAAC;AAGtF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0JsC,CAAC;AAGrE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDwC,CAAC"}

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

@@ -108,6 +108,12 @@ export const compileIntentSpec = {
                         id: { type: "string" },
                         title: { type: "string", minLength: 1 },
                         body: { type: "string", minLength: 1 },
+                        scenarioIds: {
+                            type: "array",
+                            items: { type: "string", minLength: 1 },
+                            maxItems: 20,
+                            description: "Stable scenario draft IDs verified by this test. Required when multiple scenario drafts are supplied.",
+                        },
                         verificationScope: {
                             type: "string",
                             enum: ["unit", "integration", "end_to_end"],