kibi-cli 0.19.0 → 2.0.0

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-proof-evidence-protocol
+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

@@ -1,4 +1,5 @@
 import { type LegacyMigrationPlan } from "../legacy-migration-plan.js";
+import { type MigrationPlan } from "../migration-plan.js";
 import { type RepairPlan } from "../repair-plan.js";
 import type { OperationContext } from "../runtime-types.js";
 import type { OperationResult } from "../types.js";
@@ -20,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;
@@ -34,6 +37,8 @@ export type CoveragePayload = {
     readonly rows: readonly Readonly<Record<string, unknown>>[];
     readonly repairPlan?: RepairPlan;
     readonly legacyMigrationPlan?: LegacyMigrationPlan;
+    readonly symbolRepairPlan?: Readonly<Record<string, unknown>>;
+    readonly migrationPlan?: MigrationPlan;
     readonly meta?: Readonly<Record<string, unknown>>;
 };
 export type GraphInput = {
@@ -98,11 +103,20 @@ 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 executeCoverage(input: CoverageInput, context: OperationContext): Promise<OperationResult<CoveragePayload>>;
 export declare const coverageSpec: {
     readonly name: "kb_coverage";
     readonly cliName: "coverage";
-    readonly description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Requirement reports include a deterministic, dependency-ordered, read-only repair plan; optional legacy migration previews reconstruct authored proposition inventories and rank exact schema candidates without producing executable writes. Paginated plans identify incomplete scope. Requirement rows keep coverageStatus separate from proofStatus and require fresh snapshot-bound E2E receipts before proof. No mutation side effects.";
+    readonly description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Reports include the compatible repair plan plus typed kibi.migration-plan.v2 actions; semantic and E2E actions remain review/execution work. Paginated plans identify incomplete scope and no mutation occurs.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -121,6 +135,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,7 +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 { addCoordinateRepairEvidence, buildSymbolRepairPlan, } from "../symbol-repair-plan.js";
 import { readWorkspaceSnapshot } from "../workspace-snapshot.js";
 const ENTITY_TYPES = [
     "req",
@@ -25,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 {
@@ -70,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-proof-evidence-protocol
+export function currentProofBindingMode() {
+    return process.env.KIBI_PROOF_BINDING_MODE?.trim() === "strict-snapshot"
+        ? "strict_snapshot"
+        : "per_contract";
+}
+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);
@@ -77,27 +159,82 @@ 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;
         const legacyMigrationPlan = input.includeMigrationPreview === true && repairPlan !== undefined
             ? await buildLegacyMigrationPlanFromContext(repairPlan, input, codeSnapshot, context)
             : undefined;
+        // Coverage can still report its complete Prolog-backed domain in a
+        // synthetic or non-Git workspace where branch status cannot be resolved.
+        // Preserve the coverage plan and let status expose its own branch action
+        // when an attachment is available.
+        let statusPlan;
+        try {
+            const statusResult = await executeStatus({}, context);
+            statusPlan = statusResult.structuredContent?.migrationPlan;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!message.includes("Failed to resolve active branch"))
+                throw error;
+        }
+        const coveragePlan = buildMigrationPlan({
+            expected: {
+                branch: context.branchAttachment?.gitBranch ?? null,
+                kbBranch: context.branchAttachment?.kbBranch ?? null,
+                ...(typeof payload.meta?.snapshotId === "string"
+                    ? { kbSnapshotId: payload.meta.snapshotId }
+                    : {}),
+                workspaceSnapshot: codeSnapshot,
+            },
+            evaluatedDomains: ["semantic", "proof", "symbol"],
+            incompleteDomains: payload.meta?.scopeComplete === false ? ["coverage"] : [],
+            actions: buildActionsFromCoverage({
+                ...(repairPlan !== undefined
+                    ? {
+                        repairPlan: repairPlan,
+                    }
+                    : {}),
+                ...(symbolRepairPlan !== undefined ? { symbolRepairPlan } : {}),
+            }),
+        });
+        const migrationPlan = statusPlan
+            ? mergeMigrationPlans([statusPlan, coveragePlan])
+            : 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);
@@ -121,13 +258,21 @@ export async function executeCoverage(input, context) {
 export const coverageSpec = {
     name: "kb_coverage",
     cliName: "coverage",
-    description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Requirement reports include a deterministic, dependency-ordered, read-only repair plan; optional legacy migration previews reconstruct authored proposition inventories and rank exact schema candidates without producing executable writes. Paginated plans identify incomplete scope. Requirement rows keep coverageStatus separate from proofStatus and require fresh snapshot-bound E2E receipts before proof. No mutation side effects.",
+    description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Reports include the compatible repair plan plus typed kibi.migration-plan.v2 actions; semantic and E2E actions remain review/execution work. Paginated plans identify incomplete scope and no mutation occurs.",
     businessInputSchema: {
         type: "object",
         properties: {
             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 },