kibi-cli 1.0.1 → 2.1.0

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"],

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

@@ -0,0 +1,212 @@
+import { executeIngestProof } from "../../../operations/proof/ingest-proof.js";
+export type { IngestProofArgs, IngestProofResult, } from "../../../operations/proof/ingest-proof.js";
+export { executeIngestProof } from "../../../operations/proof/ingest-proof.js";
+export declare const ingestProofSpec: {
+    readonly name: "kb_ingest_proof";
+    readonly cliName: "ingest-proof";
+    readonly description: "Ingest a producer-emitted kibi.proof-run.v1 artifact and evaluate it against each selected test's kibi.proof-contract.v1 proof obligations. Revalidates the live workspace snapshot, integration command binding, run-level outcome, attempt history, success policy, and append-only proof-receipt history before deriving and appending idempotent kibi.proof-receipt.v1 receipts. Producers report what happened; Kibi evaluates proof. Prefer `kibi prove` so the configured producer runs automatically; direct ingestion is an integration path for custom producers and agents.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["snapshot", "artifact"];
+        readonly properties: {
+            readonly snapshot: {
+                readonly type: "string";
+                readonly pattern: "^[a-f0-9]{64}$";
+                readonly description: "Workspace snapshot captured immediately before the run.";
+            };
+            readonly artifact: {
+                readonly type: "object";
+                readonly description: "Producer-emitted kibi.proof-run.v1 proof artifact. Producers report what happened; Kibi evaluates proof obligations and policies. Produce it via `kibi prove` or direct kb_ingest_proof calls.";
+                readonly required: readonly ["version", "producer", "command_argv", "code_snapshot", "environment", "run", "proof_results"];
+                readonly properties: {
+                    readonly version: {
+                        readonly type: "string";
+                        readonly const: "kibi.proof-run.v1";
+                    };
+                    readonly producer: {
+                        readonly type: "object";
+                        readonly required: readonly ["name"];
+                        readonly properties: {
+                            readonly name: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly version: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                    readonly executor: {
+                        readonly type: "object";
+                        readonly required: readonly ["name"];
+                        readonly properties: {
+                            readonly name: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly version: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                    readonly command_argv: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly code_snapshot: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{64}$";
+                    };
+                    readonly environment: {
+                        readonly type: "object";
+                        readonly additionalProperties: true;
+                    };
+                    readonly run: {
+                        readonly type: "object";
+                        readonly required: readonly ["outcome", "exit_code", "started_at", "finished_at"];
+                        readonly properties: {
+                            readonly outcome: {
+                                readonly type: "string";
+                                readonly enum: readonly ["passed", "failed", "errored", "cancelled", "timed_out", "interrupted", "no_results"];
+                            };
+                            readonly exit_code: {
+                                readonly type: "integer";
+                            };
+                            readonly started_at: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly finished_at: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly failure_phase: {
+                                readonly type: "string";
+                                readonly enum: readonly ["setup", "collection", "execution", "teardown", "infrastructure"];
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                    readonly proof_results: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly maxItems: 1000;
+                        readonly items: {
+                            readonly type: "object";
+                            readonly description: "One observed proof result. binding distinguishes native-case observations from aggregate-run bindings; attempts must report facts only.";
+                            readonly required: readonly ["symbol_id", "target", "outcome", "binding", "attempts"];
+                            readonly properties: {
+                                readonly symbol_id: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly description: "Stable proof symbol ID (SYM-*).";
+                                };
+                                readonly target: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly description: "Ecosystem-neutral execution target (browser, runtime, database, device, deployment, or default).";
+                                };
+                                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 maxItems: 100;
+                                                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 diagnostics: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly integration: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly diagnostics: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly testIds: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly description: "Existing test entities with proof_contract.v1. Omit to evaluate every test contracted to the artifact's integration.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read", "kb-write", "workspace-read"];
+    readonly execute: typeof executeIngestProof;
+};
+//# sourceMappingURL=proof.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proof.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/proof.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,kBAAkB,EACnB,MAAM,2CAA2C,CAAC;AAInD,YAAY,EACV,eAAe,EACf,iBAAiB,GAClB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAC;AAG/E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B0C,CAAC"}

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

@@ -0,0 +1,30 @@
+import { executeIngestProof, } from "../../../operations/proof/ingest-proof.js";
+import { PROOF_RUN_ARTIFACT_SCHEMA } from "../../proof-protocol.js";
+export { executeIngestProof } from "../../../operations/proof/ingest-proof.js";
+// implements REQ-kibi-verification-evidence-contract
+export const ingestProofSpec = {
+    name: "kb_ingest_proof",
+    cliName: "ingest-proof",
+    description: "Ingest a producer-emitted kibi.proof-run.v1 artifact and evaluate it against each selected test's kibi.proof-contract.v1 proof obligations. Revalidates the live workspace snapshot, integration command binding, run-level outcome, attempt history, success policy, and append-only proof-receipt history before deriving and appending idempotent kibi.proof-receipt.v1 receipts. Producers report what happened; Kibi evaluates proof. Prefer `kibi prove` so the configured producer runs automatically; direct ingestion is an integration path for custom producers and agents.",
+    businessInputSchema: {
+        type: "object",
+        required: ["snapshot", "artifact"],
+        properties: {
+            snapshot: {
+                type: "string",
+                pattern: "^[a-f0-9]{64}$",
+                description: "Workspace snapshot captured immediately before the run.",
+            },
+            artifact: PROOF_RUN_ARTIFACT_SCHEMA,
+            testIds: {
+                type: "array",
+                minItems: 1,
+                items: { type: "string", minLength: 1 },
+                description: "Existing test entities with proof_contract.v1. Omit to evaluate every test contracted to the artifact's integration.",
+            },
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-read", "kb-write", "workspace-read"],
+    execute: executeIngestProof,
+};

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

@@ -21,6 +21,8 @@ export type CoverageInput = {
     readonly by?: "req" | "symbol" | "type";
     readonly tags?: readonly string[];
     readonly includePassing?: boolean;
+    /** Requirement proof-status filter (req mode). Implies include-passing. */
+    readonly statuses?: readonly string[];
     readonly includeTransitive?: boolean;
     readonly limit?: number;
     readonly offset?: number;
@@ -101,6 +103,16 @@ export declare const findGapsSpec: {
     readonly effects: readonly ["kb-read"];
     readonly execute: typeof executeFindGaps;
 };
+/**
+ * Per-contract receipt binding (W2): compute the current binding hash for
+ * every receipt-bearing test (contract + receipt-stripped authored document
+ * + bound-symbol code scope) and hand the Prolog coverage stage a
+ * TestId -> BindingHash dict. This is the default binding mode since slice 3;
+ * KIBI_PROOF_BINDING_MODE=strict-snapshot opts out (receipts then match only
+ * against the whole-workspace snapshot they were proven on).
+ */
+export declare function currentProofBindingMode(): "per_contract" | "strict_snapshot";
+export declare function perContractTestBindings(context: OperationContext): Promise<string | null>;
 export declare function executeCoverage(input: CoverageInput, context: OperationContext): Promise<OperationResult<CoveragePayload>>;
 export declare const coverageSpec: {
     readonly name: "kb_coverage";
@@ -124,6 +136,14 @@ export declare const coverageSpec: {
                 readonly type: "boolean";
                 readonly default: false;
             };
+            readonly statuses: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly enum: readonly ["proven", "missing", "unresolved", "not_applicable"];
+                };
+                readonly description: "Requirement proof-status filter (req mode): include only rows whose proofStatus is listed. Selecting statuses implies include-passing; not_applicable rows carry their typed applicability reason in proofStages.applicability.reason. The summary always reflects the whole KB.";
+            };
             readonly includeTransitive: {
                 readonly type: "boolean";
                 readonly default: true;

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

@@ -1 +1 @@
-{"version":3,"file":"reporting.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/reporting.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"reporting.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/reporting.ts"],"names":[],"mappings":"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"}

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

@@ -1,10 +1,12 @@
-import { VERIFICATION_RECEIPT_MAX_AGE_SECONDS } from "../../verification-receipt.js";
+import { join } from "node:path";
+import { resolveBoundSymbolScope } from "../../../extractors/manifest.js";
+import { PROOF_RECEIPT_MAX_AGE_SECONDS } from "../../proof-receipt.js";
 import { executeStatus } from "../discovery-executors.js";
 import { buildLegacyMigrationPlanFromContext, } from "../legacy-migration-plan.js";
 import { buildActionsFromCoverage, buildMigrationPlan, mergeMigrationPlans, } from "../migration-plan.js";
 import { runOperationJsonQuery, toPrologAtom, toPrologList, } from "../prolog-json.js";
 import { buildRepairPlan } from "../repair-plan.js";
-import { buildSymbolRepairPlan } from "../symbol-repair-plan.js";
+import { addCoordinateRepairEvidence, buildSymbolRepairPlan, } from "../symbol-repair-plan.js";
 import { readWorkspaceSnapshot } from "../workspace-snapshot.js";
 const ENTITY_TYPES = [
     "req",
@@ -28,6 +30,18 @@ function validateEntityType(type) {
         throw new Error(`Invalid type '${type}'. Valid types: ${ENTITY_TYPES.join(", ")}. Use a single type value, or omit this parameter to query all entities.`);
     }
 }
+const COVERAGE_PROOF_STATUSES = new Set([
+    "proven",
+    "missing",
+    "unresolved",
+    "not_applicable",
+]);
+function validateCoverageStatus(status) {
+    if (!COVERAGE_PROOF_STATUSES.has(status)) {
+        throw new Error(`Invalid coverage status '${status}'. Valid statuses: ${[...COVERAGE_PROOF_STATUSES].join(", ")}.`);
+    }
+    return status;
+}
 export async function executeFindGaps(input, context) {
     validateEntityType(input.type);
     try {
@@ -73,6 +87,71 @@ export const findGapsSpec = {
     effects: ["kb-read"],
     execute: executeFindGaps,
 };
+/**
+ * Per-contract receipt binding (W2): compute the current binding hash for
+ * every receipt-bearing test (contract + receipt-stripped authored document
+ * + bound-symbol code scope) and hand the Prolog coverage stage a
+ * TestId -> BindingHash dict. This is the default binding mode since slice 3;
+ * KIBI_PROOF_BINDING_MODE=strict-snapshot opts out (receipts then match only
+ * against the whole-workspace snapshot they were proven on).
+ */
+// implements REQ-kibi-verification-evidence-contract
+export function currentProofBindingMode() {
+    return process.env.KIBI_PROOF_BINDING_MODE?.trim() === "strict-snapshot"
+        ? "strict_snapshot"
+        : "per_contract";
+}
+export async function perContractTestBindings(context) {
+    if (currentProofBindingMode() !== "per_contract")
+        return null;
+    const { loadEntities } = await import("../discovery-entities.js");
+    const { receiptBindingHash } = await import("../../proof-fingerprint.js");
+    const { removeFrontmatterBlock } = await import("../../../operations/proof/receipt-document.js");
+    let tests;
+    try {
+        tests = await loadEntities(context.prolog, { type: "test" });
+    }
+    catch {
+        return null;
+    }
+    const entries = [];
+    const manifestPath = join(context.workspaceRoot, ".kb", "symbols.yaml");
+    for (const test of tests) {
+        const testId = typeof test.id === "string" ? test.id : "";
+        const contract = test.proof_contract !== undefined &&
+            test.proof_contract !== null &&
+            typeof test.proof_contract === "object"
+            ? test.proof_contract
+            : undefined;
+        const source = typeof test.source === "string" ? test.source : "";
+        if (testId === "" || contract === undefined || source === "")
+            continue;
+        if (!/\.(md|mdx)$/i.test(source))
+            continue;
+        if (!context.fs)
+            continue;
+        try {
+            const absolute = join(context.workspaceRoot, source);
+            const authored = await context.fs.readFile(absolute);
+            const stripped = removeFrontmatterBlock(authored, "proof_receipts");
+            const rawBindings = Array.isArray(test.proof_bindings)
+                ? test.proof_bindings
+                : [];
+            const boundIds = rawBindings
+                .map((binding) => typeof binding.symbol_id === "string" ? binding.symbol_id : "")
+                .filter((id) => id !== "");
+            const codeScope = resolveBoundSymbolScope(manifestPath, boundIds);
+            const binding = receiptBindingHash(contract, stripped ?? authored, codeScope);
+            entries.push(`${toPrologAtom(testId)}: ${toPrologAtom(binding)}`);
+        }
+        catch {
+            // Unreadable documents keep strict semantics for that test.
+        }
+    }
+    if (entries.length === 0)
+        return null;
+    return `_{${entries.join(", ")}}`;
+}
 export async function executeCoverage(input, context) {
     try {
         const snapshotEvidence = await readWorkspaceSnapshot(context);
@@ -80,8 +159,20 @@ export async function executeCoverage(input, context) {
             ? snapshotEvidence.snapshot.hash
             : "unknown";
         const checkedAt = context.clock().toISOString();
-        const payload = await runOperationJsonQuery(requireProlog(context), "discovery.pl", `discovery:coverage_report_json('${input.by ?? "req"}', ${toPrologList(input.tags)}, ${input.includePassing ?? false}, ${input.includeTransitive ?? true}, ${input.limit ?? 100}, ${input.offset ?? 0}, ${toPrologAtom(codeSnapshot)}, ${toPrologAtom(checkedAt)}, ${VERIFICATION_RECEIPT_MAX_AGE_SECONDS}, JsonString)`, "Coverage execution");
-        const repairPlan = buildRepairPlan(payload, input, codeSnapshot);
+        const statuses = (input.statuses ?? []).map((status) => validateCoverageStatus(status));
+        const bindingsDict = statuses.length === 0 && (input.by ?? "req") === "req"
+            ? await perContractTestBindings(context)
+            : null;
+        const goal = bindingsDict !== null
+            ? `discovery:coverage_report_json('${input.by ?? "req"}', ${toPrologList(input.tags)}, ${input.includePassing ?? false}, per_contract, ${bindingsDict}, ${input.includeTransitive ?? true}, ${input.limit ?? 100}, ${input.offset ?? 0}, ${toPrologAtom(codeSnapshot)}, ${toPrologAtom(checkedAt)}, ${PROOF_RECEIPT_MAX_AGE_SECONDS}, JsonString)`
+            : statuses.length > 0
+                ? `discovery:coverage_report_json('${input.by ?? "req"}', ${toPrologList(input.tags)}, ${input.includePassing ?? false}, ${toPrologList(statuses)}, ${input.includeTransitive ?? true}, ${input.limit ?? 100}, ${input.offset ?? 0}, ${toPrologAtom(codeSnapshot)}, ${toPrologAtom(checkedAt)}, ${PROOF_RECEIPT_MAX_AGE_SECONDS}, JsonString)`
+                : `discovery:coverage_report_json('${input.by ?? "req"}', ${toPrologList(input.tags)}, ${input.includePassing ?? false}, ${input.includeTransitive ?? true}, ${input.limit ?? 100}, ${input.offset ?? 0}, ${toPrologAtom(codeSnapshot)}, ${toPrologAtom(checkedAt)}, ${PROOF_RECEIPT_MAX_AGE_SECONDS}, JsonString)`;
+        const payload = await runOperationJsonQuery(requireProlog(context), "discovery.pl", goal, "Coverage execution");
+        const rows = (input.by ?? "req") === "req"
+            ? await addCoordinateRepairEvidence(payload.rows, context)
+            : payload.rows;
+        const repairPlan = buildRepairPlan({ ...payload, rows }, input, codeSnapshot);
         const symbolRepairPlan = input.by === "symbol"
             ? await buildSymbolRepairPlan(payload.rows, context)
             : undefined;
@@ -111,7 +202,7 @@ export async function executeCoverage(input, context) {
                     : {}),
                 workspaceSnapshot: codeSnapshot,
             },
-            evaluatedDomains: ["semantic", "verification", "symbol"],
+            evaluatedDomains: ["semantic", "proof", "symbol"],
             incompleteDomains: payload.meta?.scopeComplete === false ? ["coverage"] : [],
             actions: buildActionsFromCoverage({
                 ...(repairPlan !== undefined
@@ -127,22 +218,23 @@ export async function executeCoverage(input, context) {
             : coveragePlan;
         const enrichedPayload = {
             ...payload,
+            rows,
             ...(repairPlan !== undefined ? { repairPlan } : {}),
             ...(legacyMigrationPlan !== undefined ? { legacyMigrationPlan } : {}),
             ...(symbolRepairPlan !== undefined ? { symbolRepairPlan } : {}),
             migrationPlan,
             meta: {
                 ...(payload.meta ?? {}),
-                verificationReceiptMaxAgeSeconds: VERIFICATION_RECEIPT_MAX_AGE_SECONDS,
-                verificationSnapshot: codeSnapshot,
-                verificationSnapshotAvailable: snapshotEvidence.available,
+                proofReceiptMaxAgeSeconds: PROOF_RECEIPT_MAX_AGE_SECONDS,
+                proofSnapshot: codeSnapshot,
+                proofSnapshotAvailable: snapshotEvidence.available,
                 ...(snapshotEvidence.available
                     ? {
-                        verificationSnapshotDirty: snapshotEvidence.snapshot.dirty,
-                        verificationSnapshotFileCount: snapshotEvidence.snapshot.fileCount,
-                        verificationSnapshotVersion: snapshotEvidence.snapshot.version,
+                        proofSnapshotDirty: snapshotEvidence.snapshot.dirty,
+                        proofSnapshotFileCount: snapshotEvidence.snapshot.fileCount,
+                        proofSnapshotVersion: snapshotEvidence.snapshot.version,
                     }
-                    : { verificationSnapshotError: snapshotEvidence.error }),
+                    : { proofSnapshotError: snapshotEvidence.error }),
             },
         };
         const fullyCovered = Number(enrichedPayload.summary?.fullyCovered ?? 0);
@@ -173,6 +265,14 @@ export const coverageSpec = {
             by: { type: "string", enum: ["req", "symbol", "type"], default: "req" },
             tags: { type: "array", items: { type: "string" } },
             includePassing: { type: "boolean", default: false },
+            statuses: {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: ["proven", "missing", "unresolved", "not_applicable"],
+                },
+                description: "Requirement proof-status filter (req mode): include only rows whose proofStatus is listed. Selecting statuses implies include-passing; not_applicable rows carry their typed applicability reason in proofStages.applicability.reason. The summary always reflects the whole KB.",
+            },
             includeTransitive: { type: "boolean", default: true },
             limit: { type: "integer", default: 100 },
             offset: { type: "integer", default: 0 },

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

@@ -1,6 +1,6 @@
 import type { SemanticAdvisorArgs, SemanticAdvisorOperationResult } from "../../../operations/semantic-advisor/types.js";
 import type { OperationContext } from "../runtime-types.js";
-export declare function executeSemanticAdvisor(args: SemanticAdvisorArgs, _context?: OperationContext): Promise<SemanticAdvisorOperationResult>;
+export declare function executeSemanticAdvisor(args: SemanticAdvisorArgs, context?: OperationContext): Promise<SemanticAdvisorOperationResult>;
 declare function executeSemanticAdvisorInput(input: Readonly<Record<string, unknown>>, context: OperationContext): Promise<SemanticAdvisorOperationResult>;
 export declare const semanticAdvisorSpec: {
     readonly name: "kb_semantic_advisor";

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

@@ -1 +1 @@
-{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/semantic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,8BAA8B,EAC/B,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAmB5D,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,mBAAmB,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,OAAO,CAAC,8BAA8B,CAAC,CA8BzC;AAED,iBAAe,2BAA2B,CACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,8BAA8B,CAAC,CAiCzC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EE,CAAC"}
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/semantic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,8BAA8B,EAC/B,MAAM,+CAA+C,CAAC;AAEvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAmB5D,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,mBAAmB,EACzB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,8BAA8B,CAAC,CA2FzC;AAED,iBAAe,2BAA2B,CACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,8BAA8B,CAAC,CAiCzC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EE,CAAC"}