kibi-cli 1.0.1 → 2.1.0

package/src/public/operations/migration-plan.ts

@@ -41,7 +41,7 @@ export type MigrationAction = Readonly<{
     | "relationship"
     | "symbol"
     | "semantic"
-    | "verification"
+    | "proof"
     | "quality";
   state: MigrationActionState;
   safety: MigrationSafety;
@@ -134,6 +134,19 @@ function actionSort(left: MigrationAction, right: MigrationAction): number {
   );
 }
 
+export function compareReadyActionIds(
+  left: string,
+  right: string,
+  byId: ReadonlyMap<string, MigrationAction>,
+): number {
+  const leftAction = byId.get(left);
+  const rightAction = byId.get(right);
+  if (leftAction === undefined || rightAction === undefined) {
+    return left.localeCompare(right);
+  }
+  return actionSort(leftAction, rightAction);
+}
+
 /** Return actions in a deterministic dependency-first order for agents and the applier. */
 function dependencyOrder(
   actions: readonly MigrationAction[],
@@ -168,14 +181,7 @@ function dependencyOrder(
       }
       ready.push(candidateId);
       queued.add(candidateId);
-      ready.sort((left, right) => {
-        const leftAction = byId.get(left);
-        const rightAction = byId.get(right);
-        if (leftAction === undefined || rightAction === undefined) {
-          return left.localeCompare(right);
-        }
-        return actionSort(leftAction, rightAction);
-      });
+      ready.sort((left, right) => compareReadyActionIds(left, right, byId));
     }
   }
   // Preserve cyclic/missing-dependency actions in canonical order; validation will block them.
@@ -387,17 +393,18 @@ export function buildActionsFromCoverage(input: {
     const req =
       typeof batch.requirementId === "string" ? batch.requirementId : "";
     const ready = batch.state === "ready";
-    const automatic = phase === "source_coordinates";
+    const automatic =
+      phase === "source_coordinates" &&
+      batch.writePolicy === "refresh_then_sync";
     actions.push(
       migrationAction({
         id: `coverage-${id}`,
         code: `coverage_${phase}`,
-        category:
-          phase === "verification_evidence" ? "verification" : "semantic",
+        category: phase === "proof_evidence" ? "proof" : "semantic",
         state: ready ? "ready" : "blocked",
         safety: automatic
           ? "automatic"
-          : phase === "verification_evidence"
+          : phase === "proof_evidence"
             ? "execution"
             : "review",
         invocation: automatic
@@ -445,7 +452,7 @@ export function buildActionsFromCoverage(input: {
             }
           : {
               kind: "review",
-              instruction: `Review ${action} for ${symbolId} using current extraction and Git evidence.`,
+              instruction: `Review ${action} for ${symbolId} using current extraction and Git evidence. Query the symbol and validate/upsert a corrected sourceFile/title or an intentional granularity_reason: extractor-miss when extraction cannot locate it.`,
             },
         affectedEntityIds: [symbolId],
         evidence: { repair },
@@ -527,8 +534,8 @@ export function buildActionsFromStatus(input: {
   branchAttachment?: Readonly<Record<string, unknown>>;
   branchStore?: Readonly<Record<string, unknown>>;
   staleReasons?: readonly Readonly<Record<string, unknown>>[];
-  verificationSnapshotAvailable?: boolean;
-  verificationSnapshotDirty?: boolean;
+  proofSnapshotAvailable?: boolean;
+  proofSnapshotDirty?: boolean;
   kbSnapshotId?: string | null;
   workspaceSnapshot?: string | null;
   configStatus?: MigrationConfigStatus;
@@ -673,35 +680,35 @@ export function buildActionsFromStatus(input: {
       }),
     );
   }
-  if (input.verificationSnapshotAvailable === false) {
+  if (input.proofSnapshotAvailable === false) {
     actions.push(
       migrationAction({
         id: "verification-snapshot-unavailable",
-        code: "verification_snapshot_unavailable",
-        category: "verification",
+        code: "proof_snapshot_unavailable",
+        category: "proof",
         safety: "operator",
         invocation: {
           kind: "review",
           instruction:
             "Use a runtime that can compute a workspace verification snapshot before claiming proof.",
         },
-        evidence: { verificationSnapshotAvailable: false },
+        evidence: { proofSnapshotAvailable: false },
         dispositionRequired: true,
       }),
     );
-  } else if (input.verificationSnapshotDirty === true) {
+  } else if (input.proofSnapshotDirty === true) {
     actions.push(
       migrationAction({
         id: "verification-snapshot-dirty",
-        code: "verification_snapshot_dirty",
-        category: "verification",
+        code: "proof_snapshot_dirty",
+        category: "proof",
         safety: "review",
         invocation: {
           kind: "review",
           instruction:
             "Resolve or intentionally record the listed dirty workspace paths before reusing or creating proof receipts.",
         },
-        evidence: { verificationSnapshotDirty: true },
+        evidence: { proofSnapshotDirty: true },
         dispositionRequired: true,
       }),
     );
@@ -732,7 +739,7 @@ export function buildActionsFromStatus(input: {
       "storage",
       "schema",
       "freshness",
-      "verification",
+      "proof",
     ],
     incompleteDomains,
     actions,

package/src/public/operations/node-ports.ts

@@ -28,7 +28,7 @@ const SNAPSHOT_EXCLUDED_PREFIXES = [
   ".changeset/",
   ".kb/branches/",
   ".kb/recovery/",
-  ".kb/verification/",
+  ".kb/proof/runs/",
   ".kb/briefs/",
   ".kb/migrations/",
   "docs/",
@@ -37,7 +37,7 @@ const ALWAYS_IGNORED_GLOBS = [
   "**/.git/**",
   "**/.kb/branches/**",
   "**/.kb/recovery/**",
-  "**/.kb/verification/**",
+  "**/.kb/proof/runs/**",
   "**/.kb/briefs/**",
   "**/.kb/migrations/**",
   "**/node_modules/**",
@@ -58,7 +58,7 @@ function includedSnapshotPath(relativePath: string): boolean {
   );
 }
 
-function withoutVerificationReceiptFrontmatter(content: string): string {
+function withoutProofReceiptFrontmatter(content: string): string {
   const lines = content.match(/[^\n]*\n|[^\n]+$/g) ?? [];
   if (lines[0]?.trim() !== "---") return content;
   let inFrontmatter = true;
@@ -72,7 +72,7 @@ function withoutVerificationReceiptFrontmatter(content: string): string {
       retained.push(line);
       continue;
     }
-    if (inFrontmatter && /^verification_receipts\s*:/.test(line)) {
+    if (inFrontmatter && /^proof_receipts\s*:/.test(line)) {
       skippingReceipts = true;
       continue;
     }
@@ -91,14 +91,14 @@ function withoutVerificationReceiptFrontmatter(content: string): string {
 function snapshotFileContent(relativePath: string, content: Buffer): Buffer {
   if (relativePath.endsWith(".md")) {
     return Buffer.from(
-      withoutVerificationReceiptFrontmatter(content.toString("utf8")),
+      withoutProofReceiptFrontmatter(content.toString("utf8")),
     );
   }
   return content;
 }
 
 /**
- * A tracked markdown file whose only change is verification-receipt frontmatter
+ * A tracked markdown file whose only change is proof-receipt frontmatter
  * cannot alter the snapshot hash (receipts are stripped before hashing), so it
  * must not mark the workspace dirty either. CI proof runs append receipts to
  * tracked proof documents before reporting, and would otherwise always surface

package/src/public/operations/prolog-json.ts

@@ -55,6 +55,7 @@ export async function runOperationJsonQuery<T>(
   fileName: string,
   goal: string,
   errorLabel: string,
+  signal?: AbortSignal,
 ): Promise<T> {
   const modulePath = escapeAtom(
     resolveCoreModulePath(fileName).replaceAll("\\", "/"),
@@ -73,10 +74,16 @@ export async function runOperationJsonQuery<T>(
   const typedStatusQuery = prolog.queryStatusJson;
   const result =
     fileName === "status.pl" && typeof typedStatusQuery === "function"
-      ? await typedStatusQuery.call(prolog)
+      ? await typedStatusQuery.call(prolog, signal)
       : oneShotMode
-        ? await prolog.query(`(use_module('${modulePath}'), ${goal})`)
-        : await runInteractiveModuleQuery(prolog, modulePath, goal, errorLabel);
+        ? await prolog.query(`(use_module('${modulePath}'), ${goal})`, signal)
+        : await runInteractiveModuleQuery(
+            prolog,
+            modulePath,
+            goal,
+            errorLabel,
+            signal,
+          );
   if (!result.success) {
     throw new Error(
       `${errorLabel} query failed: ${result.error ?? "Unknown error"}`,
@@ -115,14 +122,15 @@ async function runInteractiveModuleQuery(
   modulePath: string,
   goal: string,
   errorLabel: string,
+  signal?: AbortSignal,
 ) {
-  const loadResult = await prolog.query(`use_module('${modulePath}')`);
+  const loadResult = await prolog.query(`use_module('${modulePath}')`, signal);
   if (!loadResult.success) {
     throw new Error(
       `${errorLabel} module load failed: ${loadResult.error ?? "Unknown error"}`,
     );
   }
-  return prolog.query(goal);
+  return prolog.query(goal, signal);
 }
 
 export function toPrologAtom(value?: string): string {

package/src/public/operations/repair-plan.ts

@@ -126,15 +126,14 @@ const REPAIR_PHASES = {
     validationRules: [],
     writePolicy: "runtime_recovery",
   },
-  verification_evidence: {
+  proof_evidence: {
     order: 80,
     objective:
-      "Run the scenario-backed E2E test and append a fresh snapshot-bound passing receipt.",
+      "Run the configured proof integration with kibi prove and append fresh snapshot-bound passing receipts.",
     workflowSteps: [
       "kb_status",
-      "execute_e2e",
-      "kb_validate_upsert",
-      "kb_upsert",
+      "execute_proof_run",
+      "kb_ingest_proof",
       "kb_coverage",
     ],
     validationRules: ["required-fields", "no-dangling-refs"],
@@ -206,12 +205,13 @@ const GAP_PHASE: Readonly<Record<string, RepairPhase>> = {
   blocking_contradiction: "contradiction_resolution",
   missing_scenario: "scenario_endpoints",
   missing_scenario_test: "scenario_tests",
-  verification_snapshot_unavailable: "snapshot_runtime",
-  missing_passing_e2e: "verification_evidence",
-  missing_verification_receipt: "verification_evidence",
-  stale_verification_receipt: "verification_evidence",
-  failed_verification_receipt: "verification_evidence",
-  invalid_verification_receipt: "verification_evidence",
+  proof_snapshot_unavailable: "snapshot_runtime",
+  missing_passing_e2e: "proof_evidence",
+  proof_contract_mismatch: "proof_evidence",
+  missing_proof_receipt: "proof_evidence",
+  stale_proof_receipt: "proof_evidence",
+  failed_proof_receipt: "proof_evidence",
+  invalid_proof_receipt: "proof_evidence",
   missing_executable_test_symbol: "executable_symbols",
   missing_production_symbol: "production_ownership",
   missing_production_symbol_coverage: "production_coverage",
@@ -233,12 +233,12 @@ const GAP_STAGE: Readonly<Record<string, string>> = {
   missing_scenario: "scenarios",
   missing_scenario_test: "scenario_tests",
   missing_passing_e2e: "passing_e2e",
-  missing_verification_receipt: "passing_e2e",
-  stale_verification_receipt: "passing_e2e",
-  failed_verification_receipt: "passing_e2e",
-  invalid_verification_receipt: "passing_e2e",
-  verification_contract_mismatch: "passing_e2e",
-  verification_snapshot_unavailable: "passing_e2e",
+  missing_proof_receipt: "passing_e2e",
+  stale_proof_receipt: "passing_e2e",
+  failed_proof_receipt: "passing_e2e",
+  invalid_proof_receipt: "passing_e2e",
+  proof_contract_mismatch: "passing_e2e",
+  proof_snapshot_unavailable: "passing_e2e",
   missing_executable_test_symbol: "executable_symbols",
   missing_production_symbol: "production_symbols",
   missing_production_symbol_coverage: "production_symbols",
@@ -427,7 +427,38 @@ function buildRequirementBatches(
   );
   const priorBatchIds: string[] = [];
   return phases.map((phase) => {
-    const definition = REPAIR_PHASES[phase];
+    const phaseRepairs = byPhase.get(phase) ?? [];
+    const coordinatesNeedReview =
+      phase === "source_coordinates" &&
+      phaseRepairs.some((repair) => {
+        const evidence = repair.evidence.coordinateRepairs;
+        return (
+          repair.gap !== "missing_symbol_coordinates" ||
+          !Array.isArray(evidence) ||
+          evidence.length === 0 ||
+          evidence.some((item) => !isRecord(item) || item.refreshable !== true)
+        );
+      });
+    const definition: RepairPhaseDefinition = coordinatesNeedReview
+      ? {
+          ...REPAIR_PHASES[phase],
+          objective: phaseRepairs.some(
+            (repair) => repair.gap === "missing_requirement_source",
+          )
+            ? "Bind the requirement to its current source document through validated upsert and inspect any missing symbol anchors before refreshing."
+            : "Query the affected symbols and repair their sourceFile/title or explicitly author granularity_reason: extractor-miss (or another intentional coarse anchor) through validated upsert before refreshing.",
+          workflowSteps: [
+            "kb_query",
+            "kb_validate_upsert",
+            "kb_upsert",
+            "kibi sync --refresh-symbol-coordinates",
+            "kibi sync",
+            "kb_check",
+            "kb_coverage",
+          ],
+          writePolicy: "review_then_sequential_upsert",
+        }
+      : REPAIR_PHASES[phase];
     const id = batchId(requirementId, phase);
     const batch: RepairPlanBatch = {
       id,
@@ -441,11 +472,17 @@ function buildRequirementBatches(
       validationRules: definition.validationRules,
       writePolicy: definition.writePolicy,
       autoApplicable: false,
-      repairs: (byPhase.get(phase) ?? []).sort(
-        (left, right) =>
-          left.proofPriority - right.proofPriority ||
-          left.gap.localeCompare(right.gap),
-      ),
+      repairs: phaseRepairs
+        .map((repair) =>
+          coordinatesNeedReview
+            ? { ...repair, action: definition.objective }
+            : repair,
+        )
+        .sort(
+          (left, right) =>
+            left.proofPriority - right.proofPriority ||
+            left.gap.localeCompare(right.gap),
+        ),
     };
     priorBatchIds.push(id);
     return batch;

package/src/public/operations/result-envelope.ts

@@ -36,6 +36,20 @@ function nextActions(value: unknown): KibiResult["nextActions"] {
   });
 }
 
+export function failedEffectStatus(
+  effect: OperationEffect,
+  failure: Record<string, unknown>,
+): KibiResult["effects"][number] {
+  return {
+    kind: effect,
+    status: "failed",
+    detail: failure.detail,
+    ...(typeof failure.errorCode === "string"
+      ? { errorCode: failure.errorCode }
+      : {}),
+  };
+}
+
 function effectStatus(
   effect: OperationEffect,
   data: Record<string, unknown> | undefined,
@@ -45,16 +59,7 @@ function effectStatus(
     const failure = failures.find(
       (entry) => record(entry) && entry.kind === effect,
     );
-    if (record(failure)) {
-      return {
-        kind: effect,
-        status: "failed",
-        detail: failure.detail,
-        ...(typeof failure.errorCode === "string"
-          ? { errorCode: failure.errorCode }
-          : {}),
-      };
-    }
+    if (record(failure)) return failedEffectStatus(effect, failure);
   }
   return { kind: effect, status: "completed" };
 }

package/src/public/operations/runtime-types.ts

@@ -1,12 +1,24 @@
+import type { CapabilityRegistry } from "../../plugins/registry.js";
+import type { PrologErrorRecord } from "../../prolog/error-terms.js";
 import type { BranchAttachment } from "../../utils/branch-resolver.js";
 import type { OperationEffect } from "./types.js";
 
 export type { OperationEffect } from "./types.js";
+// implements REQ-capability-plugin-activation-disclosure-v1
+export type { CapabilityRegistry } from "../../plugins/registry.js";
+
+/** Lazy or pre-materialized capability-plugin registry for an operation. */
+// implements REQ-capability-plugin-activation-disclosure-v1
+export type OperationPlugins =
+  | CapabilityRegistry
+  | (() => Promise<CapabilityRegistry>);
 
 export type PrologQueryResult = {
   readonly success: boolean;
   readonly bindings: Readonly<Record<string, string>>;
   readonly error?: string;
+  /** Structured error term when the failure crossed a kb.pl throw site. */
+  readonly errorRecord?: PrologErrorRecord;
 };
 
 export type PrologEntityQueryInput = Readonly<{
@@ -112,7 +124,7 @@ export interface PrologPort {
   /** Present on the journaled engine; used to distinguish a persistent port from one-shot SWI. */
   storageStatus?(): Promise<PrologQueryResult>;
   /** Typed public freshness query; avoids exposing module loading over RPC. */
-  queryStatusJson?(): Promise<PrologQueryResult>;
+  queryStatusJson?(signal?: AbortSignal): Promise<PrologQueryResult>;
 }
 
 export type FilesystemStat = {
@@ -172,6 +184,8 @@ export type RuntimeOptions = {
   readonly fs?: FilesystemPort;
   readonly git?: GitPort;
   readonly net?: NetworkPort;
+  /** Optional injectable capability registry (or lazy factory). */
+  readonly plugins?: OperationPlugins;
 };
 
 export type OperationContext = {
@@ -187,15 +201,25 @@ export type OperationContext = {
   readonly sourceFirst?: boolean;
   /** Internal apply-plan capability: source bytes were already approved/published. */
   readonly sourcePlanApplication?: boolean;
+  /** Internal apply-plan capability: caller holds the cooperative source lock. */
+  readonly sourceMutationLockHeld?: boolean;
   readonly git?: GitPort;
   readonly net?: NetworkPort;
   readonly branchAttachment?: BranchAttachment;
+  /** Pre-materialized or lazy capability registry supplied by the host runtime. */
+  readonly plugins?: OperationPlugins;
+  /** Lazily materialize the workspace capability registry. */
+  readonly ensurePlugins?: () => Promise<CapabilityRegistry>;
 };
-
 export interface RuntimeOperationSpec<TInput = unknown, TResult = unknown> {
   readonly name: string;
   readonly effects: readonly OperationEffect[];
   readonly requiresProlog: boolean;
+  /**
+   * When true, MCP embeds envelope `data` JSON in tool `content` for hosts that
+   * hide `structuredContent` (discovery/proof lookup). Default false.
+   */
+  readonly agentVisibleStructuredData?: boolean;
   execute(input: TInput, context: OperationContext): Promise<TResult>;
 }
 

package/src/public/operations/specs/check-rules.generated.ts

@@ -0,0 +1,38 @@
+/*
+ * Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ * Copyright (C) 2026 Piotr Franczyk
+ *
+ * This file is generated by scripts/generate-rule-registry.mjs from
+ * packages/core/schema/rule-registry.json. Do not edit it directly; edit the
+ * JSON source and regenerate.
+ */
+
+// implements REQ-006
+/** Every selectable kb_check rule name, registry order. */
+export const SELECTABLE_RULE_NAMES: readonly string[] = [
+  "must-priority-coverage",
+  "symbol-coverage",
+  "symbol-traceability",
+  "no-dangling-refs",
+  "source-relationship-parity",
+  "no-cycles",
+  "required-fields",
+  "deprecated-adr-no-successor",
+  "domain-contradictions",
+  "logic-coverage",
+  "rule-safety",
+  "rule-verifiability",
+  "query-plan-safety",
+  "req-status-vocabulary",
+  "strict-fact-shape",
+  "strict-req-fact-pairing",
+  "predicate-verifiability",
+  "strict-readiness",
+  "semantic-completeness",
+  "proof-contract-symbols",
+];
+
+// implements REQ-006
+/** Comma-separated "Allowed:" fragment for the kb_check rules description. */
+export const SELECTABLE_RULES_ALLOWED =
+  "must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, proof-contract-symbols";

package/src/public/operations/specs/check.ts

@@ -1,5 +1,9 @@
 import { executeCheck } from "../check-executor.js";
 import type { OperationSpec } from "../types.js";
+import {
+  SELECTABLE_RULES_ALLOWED,
+  SELECTABLE_RULE_NAMES,
+} from "./check-rules.generated.js";
 
 export const checkSpec = {
   name: "kb_check",
@@ -13,28 +17,9 @@ export const checkSpec = {
         type: "array",
         items: {
           type: "string",
-          enum: [
-            "must-priority-coverage",
-            "symbol-coverage",
-            "symbol-traceability",
-            "no-dangling-refs",
-            "source-relationship-parity",
-            "no-cycles",
-            "required-fields",
-            "deprecated-adr-no-successor",
-            "domain-contradictions",
-            "strict-fact-shape",
-            "strict-req-fact-pairing",
-            "predicate-verifiability",
-            "logic-coverage",
-            "rule-safety",
-            "rule-verifiability",
-            "semantic-completeness",
-            "query-plan-safety",
-          ],
+          enum: [...SELECTABLE_RULE_NAMES],
         },
-        description:
-          "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.",
+        description: `Optional rule subset. Allowed: ${SELECTABLE_RULES_ALLOWED}. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.`,
       },
       sourceFiles: {
         type: "array",
@@ -68,6 +53,12 @@ export const checkSpec = {
         description:
           "Optional workspace root for impact diagnostics. Defaults to the MCP server workspace.",
       },
+      async: {
+        type: "boolean",
+        default: false,
+        description:
+          "When true, start the check as a background job and return a kibi.job.v1 receipt immediately instead of holding the request until the tool timeout. Poll kb_job_status with the returned jobId. Use for full checks on large KBs that exceed the configured tool timeout.",
+      },
     },
   },
   requiresProlog: true,

package/src/public/operations/specs/discovery.ts

@@ -70,6 +70,7 @@ export const querySpec = {
   },
   requiresProlog: true,
   effects: ["kb-read"],
+  agentVisibleStructuredData: true,
   execute: executeQuery,
 } as const satisfies OperationSpec<QueryInput, QueryPayload>;
 
@@ -164,6 +165,7 @@ export const searchSpec = {
   },
   requiresProlog: true,
   effects: ["kb-read"],
+  agentVisibleStructuredData: true,
   execute: executeSearch,
 } as const satisfies OperationSpec<SearchInput, SearchPayload>;
 
@@ -176,5 +178,6 @@ export const statusSpec = {
   // Status must remain available when the branch store cannot be attached.
   requiresProlog: false,
   effects: ["kb-read", "workspace-read"],
+  agentVisibleStructuredData: true,
   execute: executeStatus,
 } as const satisfies OperationSpec<StatusInput, StatusPayload>;

package/src/public/operations/specs/mutation-schemas.ts

@@ -1,7 +1,11 @@
 import {
-  VERIFICATION_CONTRACT_SCHEMA,
-  VERIFICATION_RECEIPT_SCHEMA,
-} from "../../verification-receipt.js";
+  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",
@@ -152,13 +156,22 @@ export const ENTITY_PROPERTIES_SCHEMA = {
       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,
+      maxItems: MAX_PROOF_RECEIPTS,
+      items: PROOF_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.",
+        "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",
@@ -323,7 +336,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/src/public/operations/specs/planning.ts

@@ -143,6 +143,13 @@ 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"],