kibi-cli 1.0.1 → 2.0.0

package/src/public/operations/catalog.ts

@@ -16,6 +16,7 @@ import {
   validateUpsertSpec,
 } from "./specs/mutation.js";
 import { applyPlanSpec, compileIntentSpec } from "./specs/planning.js";
+import { ingestProofSpec } from "./specs/proof.js";
 import { coverageSpec, findGapsSpec, graphSpec } from "./specs/reporting.js";
 import { semanticAdvisorSpec } from "./specs/semantic.js";
 import {
@@ -24,7 +25,6 @@ import {
   skillsReadSpec,
 } from "./specs/skills.js";
 import { sparqlRemoteSpec } from "./specs/sparql.js";
-import { ingestVerificationSpec } from "./specs/verification.js";
 import type {
   OperationName,
   OperationSpec,
@@ -52,7 +52,7 @@ export const OPERATION_CATALOG = [
   sparqlRemoteSpec,
   compileIntentSpec,
   applyPlanSpec,
-  ingestVerificationSpec,
+  ingestProofSpec,
 ] as const satisfies readonly OperationSpec[];
 
 function envelopeSchema(
@@ -183,14 +183,20 @@ const SPECS_BY_NAME: ReadonlyMap<OperationName, ResolvedOperationSpec> =
   );
 
 // implements REQ-kibi-operation-interface-parity
-export function getSpec(name: OperationName): ResolvedOperationSpec {
-  const spec = SPECS_BY_NAME.get(name);
+export function requireKnownSpec(
+  spec: ResolvedOperationSpec | undefined,
+  name: OperationName,
+): ResolvedOperationSpec {
   if (!spec) {
     throw new RangeError(`Unknown Kibi operation: ${name}`);
   }
   return spec;
 }
 
+export function getSpec(name: OperationName): ResolvedOperationSpec {
+  return requireKnownSpec(SPECS_BY_NAME.get(name), name);
+}
+
 // implements REQ-kibi-operation-interface-parity
 export function listSpecs(): readonly ResolvedOperationSpec[] {
   return OPERATION_CATALOG.map(withContractDefaults);

package/src/public/operations/check-executor.ts

@@ -127,7 +127,7 @@ export async function executeCheck(
     const workspaceRoot = args.workspaceRoot ?? context.workspaceRoot;
     const prolog = requireProlog(context);
     const snapshotEvidence = await readWorkspaceSnapshot(context);
-    const verificationSnapshot = snapshotEvidence.available
+    const proofSnapshot = snapshotEvidence.available
       ? snapshotEvidence.snapshot.hash
       : undefined;
     const checkedAt = context.clock().toISOString();
@@ -152,9 +152,7 @@ export async function executeCheck(
             : await collectFullKbQualityDiagnostics({
                 prolog,
                 workspaceRoot,
-                ...(verificationSnapshot !== undefined
-                  ? { verificationSnapshot }
-                  : {}),
+                ...(proofSnapshot !== undefined ? { proofSnapshot } : {}),
                 checkedAt,
                 now: context.clock(),
                 ...maxDiagnosticsOption,
@@ -229,9 +227,7 @@ export async function executeCheck(
             prolog,
             hardViolationEntityIds: new Set(violations.map((v) => v.entityId)),
             workspaceRoot,
-            ...(verificationSnapshot !== undefined
-              ? { verificationSnapshot }
-              : {}),
+            ...(proofSnapshot !== undefined ? { proofSnapshot } : {}),
             checkedAt,
             now: context.clock(),
             ...maxDiagnosticsOption,

package/src/public/operations/contracts.ts

@@ -45,7 +45,9 @@ const stringArray: OperationJsonSchema = {
 /** Preserve JSON Schema's nullable scalar/object representation in every
  * generated consumer contract.  Using a `type` union keeps the catalog
  * readable and lets the MCP bridge round-trip the same wire schema. */
-function nullable(schema: OperationJsonSchema): OperationJsonSchema {
+export function nullableJsonSchema(
+  schema: OperationJsonSchema,
+): OperationJsonSchema {
   const type = schema.type;
   if (typeof type === "string") {
     return { ...schema, type: [type, "null"] };
@@ -86,19 +88,23 @@ export const OPERATION_DATA_SCHEMAS: Readonly<
     syncState: stringValue,
     kbPath: stringValue,
     lastSyncSource: stringValue,
-    verificationSnapshot: stringValue,
-    verificationSnapshotAvailable: booleanValue,
-    verificationSnapshotDirty: booleanValue,
-    verificationSnapshotFileCount: integerValue,
-    verificationSnapshotVersion: stringValue,
-    verificationSnapshotError: stringValue,
+    attachedPath: stringValue,
+    attachedGeneration: stringValue,
+    attachedDev: integerValue,
+    attachedIno: integerValue,
+    proofSnapshot: stringValue,
+    proofSnapshotAvailable: booleanValue,
+    proofSnapshotDirty: booleanValue,
+    proofSnapshotFileCount: integerValue,
+    proofSnapshotVersion: stringValue,
+    proofSnapshotError: stringValue,
     staleReasons: recordArray,
     staleReasonCount: integerValue,
     staleReasonsTruncated: booleanValue,
     branchAttachment: recordValue,
-    verificationSnapshotChanges: recordArray,
-    verificationSnapshotChangeCount: integerValue,
-    verificationSnapshotChangesTruncated: booleanValue,
+    proofSnapshotChanges: recordArray,
+    proofSnapshotChangeCount: integerValue,
+    proofSnapshotChangesTruncated: booleanValue,
     branchStore: recordValue,
     engineStatus: recordValue,
     schemaStatus: recordValue,
@@ -204,8 +210,8 @@ export const OPERATION_DATA_SCHEMAS: Readonly<
     valid: booleanValue,
     errors: valueArray,
     warnings: valueArray,
-    semanticAdvisor: nullable(recordValue),
-    normalizedPreview: nullable(recordValue),
+    semanticAdvisor: nullableJsonSchema(recordValue),
+    normalizedPreview: nullableJsonSchema(recordValue),
   }),
   kb_upsert: objectData({
     created: integerValue,
@@ -280,12 +286,14 @@ export const OPERATION_DATA_SCHEMAS: Readonly<
     effectFailures: recordArray,
     nextActions: recordArray,
   }),
-  kb_ingest_verification: objectData({
-    receipt: recordValue,
-    testId: stringValue,
-    proofOutcome: stringValue,
-    receiptCount: integerValue,
-    upsert: recordValue,
+  kb_ingest_proof: objectData({
+    artifactDigest: stringValue,
+    environmentHash: stringValue,
+    integration: stringValue,
+    passed: integerValue,
+    failed: integerValue,
+    unchanged: integerValue,
+    results: recordArray,
     status: stringValue,
     effectFailures: recordArray,
     nextActions: recordArray,
@@ -333,11 +341,21 @@ const EFFECT_OVERRIDES: Readonly<
     "kb-write": { destructive: true, retrySafety: "unsafe" },
     "workspace-write": { destructive: true, retrySafety: "unsafe" },
   },
-  kb_ingest_verification: {
+  kb_ingest_proof: {
     "kb-write": { destructive: true, retrySafety: "unsafe" },
   },
 };
 
+export function assertUniqueEffectKinds(
+  operation: string,
+  declarations: readonly { readonly kind: string }[],
+  expectedSize: number,
+): void {
+  if (new Set(declarations.map(({ kind }) => kind)).size !== expectedSize) {
+    throw new Error(`Duplicate effect contract for ${operation}`);
+  }
+}
+
 export function declaredEffects(
   operation: OperationName,
   effects: readonly OperationEffect[],
@@ -359,8 +377,6 @@ export function declaredEffects(
       openWorld: override.openWorld === true,
     };
   });
-  if (new Set(declarations.map(({ kind }) => kind)).size !== expected.size) {
-    throw new Error(`Duplicate effect contract for ${operation}`);
-  }
+  assertUniqueEffectKinds(operation, declarations, expected.size);
   return declarations;
 }

package/src/public/operations/discovery-entities.ts

@@ -11,6 +11,9 @@ export type EntityQueryInput = {
   readonly id?: string;
   readonly tags?: readonly string[];
   readonly sourceFile?: string;
+  /** Page size for index-backed queries; bounds each query's output. */
+  readonly limit?: number;
+  readonly offset?: number;
 };
 
 export const VALID_ENTITY_TYPES = [
@@ -63,6 +66,10 @@ export function buildEntityGoal(input: EntityQueryInput): string {
   }
   if (type) {
     const safeType = escapeAtomContent(type);
+    if (input.limit !== undefined) {
+      const offset = input.offset ?? 0;
+      return `kb_query_entities('${safeType}', none, [], none, ${input.limit}, ${offset}, Results, Count)`;
+    }
     return `findall([Id,'${safeType}',Props], kb_entity(Id, '${safeType}', Props), Results)`;
   }
   return "findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)";

package/src/public/operations/discovery-executors.ts

@@ -14,6 +14,7 @@ import { resolveBranchAttachment } from "../../utils/branch-resolver.js";
 import {
   type BranchStoreInspection,
   branchStoreReason,
+  storeLockJournalReason,
   inspectBranchStore,
 } from "../../utils/branch-store.js";
 import {
@@ -76,12 +77,12 @@ export type StatusPayload = {
   readonly syncState: string;
   readonly kbPath?: string;
   readonly lastSyncSource?: string;
-  readonly verificationSnapshot?: string;
-  readonly verificationSnapshotAvailable?: boolean;
-  readonly verificationSnapshotDirty?: boolean;
-  readonly verificationSnapshotFileCount?: number;
-  readonly verificationSnapshotVersion?: string;
-  readonly verificationSnapshotError?: string;
+  readonly proofSnapshot?: string;
+  readonly proofSnapshotAvailable?: boolean;
+  readonly proofSnapshotDirty?: boolean;
+  readonly proofSnapshotFileCount?: number;
+  readonly proofSnapshotVersion?: string;
+  readonly proofSnapshotError?: string;
   readonly staleReasons?: readonly Record<string, unknown>[];
   readonly staleReasonCount?: number;
   readonly staleReasonsTruncated?: boolean;
@@ -91,9 +92,9 @@ export type StatusPayload = {
     readonly kind: "exact" | "explicit_override" | "legacy_compat";
     readonly migrationRequired: boolean;
   };
-  readonly verificationSnapshotChanges?: readonly Record<string, unknown>[];
-  readonly verificationSnapshotChangeCount?: number;
-  readonly verificationSnapshotChangesTruncated?: boolean;
+  readonly proofSnapshotChanges?: readonly Record<string, unknown>[];
+  readonly proofSnapshotChangeCount?: number;
+  readonly proofSnapshotChangesTruncated?: boolean;
   readonly branchStore?: BranchStoreInspection;
   readonly engineStatus?: {
     readonly state: "healthy" | "unavailable";
@@ -385,6 +386,7 @@ export async function executeStatus(
     const snapshotEvidence = await readWorkspaceSnapshot(context);
     const existingReasons = payload.staleReasons ?? [];
     const storeReason = branchStoreReason(store);
+    const lockReason = storeLockJournalReason(store.path);
     const engineReason = engineStatus
       ? {
           code: engineStatus.errorCode ?? "engine_status_unavailable",
@@ -402,6 +404,7 @@ export async function executeStatus(
     const staleReasons = [
       ...existingReasons,
       ...(storeReason ? [storeReason] : []),
+      ...(lockReason ? [lockReason] : []),
       ...(engineReason ? [engineReason] : []),
     ].sort((left, right) =>
       String(left.path ?? "").localeCompare(String(right.path ?? "")),
@@ -414,23 +417,22 @@ export async function executeStatus(
       staleReasons,
       staleReasonCount: staleReasons.length,
       staleReasonsTruncated: false,
-      verificationSnapshot: snapshotEvidence.available
+      proofSnapshot: snapshotEvidence.available
         ? snapshotEvidence.snapshot.hash
         : "unknown",
-      verificationSnapshotAvailable: snapshotEvidence.available,
+      proofSnapshotAvailable: snapshotEvidence.available,
       ...(snapshotEvidence.available
         ? {
-            verificationSnapshotDirty: snapshotEvidence.snapshot.dirty,
-            verificationSnapshotFileCount: snapshotEvidence.snapshot.fileCount,
-            verificationSnapshotVersion: snapshotEvidence.snapshot.version,
-            verificationSnapshotChanges:
-              snapshotEvidence.snapshot.changes ?? [],
-            verificationSnapshotChangeCount:
+            proofSnapshotDirty: snapshotEvidence.snapshot.dirty,
+            proofSnapshotFileCount: snapshotEvidence.snapshot.fileCount,
+            proofSnapshotVersion: snapshotEvidence.snapshot.version,
+            proofSnapshotChanges: snapshotEvidence.snapshot.changes ?? [],
+            proofSnapshotChangeCount:
               snapshotEvidence.snapshot.changeCount ?? 0,
-            verificationSnapshotChangesTruncated:
+            proofSnapshotChangesTruncated:
               snapshotEvidence.snapshot.changesTruncated ?? false,
           }
-        : { verificationSnapshotError: snapshotEvidence.error }),
+        : { proofSnapshotError: snapshotEvidence.error }),
     };
     const schemaStatus = readMigrationConfigStatus(context.workspaceRoot);
     const migrationPlan = buildActionsFromStatus({
@@ -438,9 +440,9 @@ export async function executeStatus(
       branchAttachment: attachment,
       branchStore: store,
       staleReasons,
-      verificationSnapshotAvailable: snapshotEvidence.available,
+      proofSnapshotAvailable: snapshotEvidence.available,
       ...(snapshotEvidence.available
-        ? { verificationSnapshotDirty: snapshotEvidence.snapshot.dirty }
+        ? { proofSnapshotDirty: snapshotEvidence.snapshot.dirty }
         : {}),
       kbSnapshotId: payload.snapshotId,
       workspaceSnapshot: snapshotEvidence.available
@@ -448,7 +450,7 @@ export async function executeStatus(
         : null,
       configStatus: schemaStatus,
     });
-    const bootstrapSourceFiles = context.fs?.glob
+    const listed = context.fs?.glob
       ? await context.fs.glob(
           [
             ".kb/requirements/**/*.md",
@@ -463,6 +465,7 @@ export async function executeStatus(
           { cwd: context.workspaceRoot },
         )
       : [];
+    const bootstrapSourceFiles = Array.isArray(listed) ? listed : [];
     const bootstrapActivation = await classifyActivation(
       context,
       bootstrapSourceFiles,
@@ -514,7 +517,7 @@ export async function executeStatus(
       content: [
         {
           type: "text",
-          text: `Branch ${payload.branch} is ${payload.syncState} (snapshot ${payload.snapshotId}, dirty=${payload.dirty}, verificationSnapshot=${enrichedPayload.verificationSnapshot})`,
+          text: `Branch ${payload.branch} is ${payload.syncState} (snapshot ${payload.snapshotId}, dirty=${payload.dirty}, proofSnapshot=${enrichedPayload.proofSnapshot})`,
         },
       ],
       structuredContent: statusWithPlan,

package/src/public/operations/index.ts

@@ -13,7 +13,7 @@ export * from "./specs/check.js";
 export * from "./specs/discovery.js";
 export * from "./specs/modeling.js";
 export * from "./specs/planning.js";
-export * from "./specs/verification.js";
+export * from "./specs/proof.js";
 export * from "./specs/mutation.js";
 export * from "./specs/reporting.js";
 export * from "./specs/semantic.js";

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/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;