kibi-cli 0.19.0 → 1.0.1

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

@@ -1,7 +1,10 @@
 import { VERIFICATION_RECEIPT_MAX_AGE_SECONDS } from "../../verification-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 { readWorkspaceSnapshot } from "../workspace-snapshot.js";
 const ENTITY_TYPES = [
     "req",
@@ -79,13 +82,55 @@ export async function executeCoverage(input, context) {
         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 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", "verification", "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,
             ...(repairPlan !== undefined ? { repairPlan } : {}),
             ...(legacyMigrationPlan !== undefined ? { legacyMigrationPlan } : {}),
+            ...(symbolRepairPlan !== undefined ? { symbolRepairPlan } : {}),
+            migrationPlan,
             meta: {
                 ...(payload.meta ?? {}),
                 verificationReceiptMaxAgeSeconds: VERIFICATION_RECEIPT_MAX_AGE_SECONDS,
@@ -121,7 +166,7 @@ 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: {

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

@@ -106,7 +106,7 @@ export declare const upsertSpec: {
                     };
                     readonly granularity_reason: {
                         readonly type: "string";
-                        readonly enum: readonly ["config-artifact", "module-level-behavior", "extractor-miss", "legacy-link"];
+                        readonly enum: readonly ["config-artifact", "module-level-behavior", "extractor-miss", "legacy-link", "test-suite"];
                         readonly description: "Optional justification for a coarse file/module-level symbol traceability relationship when narrower function/class/type symbols exist.";
                     };
                     readonly symbol_role: {
@@ -124,63 +124,206 @@ export declare const upsertSpec: {
                         readonly enum: readonly ["internal", "consumer"];
                         readonly description: "Optional typed verification perspective for test entities. Example: 'consumer'.";
                     };
-                    readonly verification_receipts: {
-                        readonly type: "array";
-                        readonly maxItems: 50;
-                        readonly items: {
-                            readonly type: "object";
-                            readonly required: readonly ["version", "receipt_id", "test_id", "runner", "command", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest"];
-                            readonly properties: {
-                                readonly version: {
-                                    readonly type: "string";
-                                    readonly const: "kibi.verification-receipt.v1";
-                                };
-                                readonly receipt_id: {
-                                    readonly type: "string";
-                                    readonly pattern: "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
-                                };
-                                readonly test_id: {
-                                    readonly type: "string";
-                                    readonly minLength: 1;
-                                };
-                                readonly runner: {
+                    readonly verification_contract: {
+                        readonly type: "object";
+                        readonly required: readonly ["version", "runner", "command_argv", "required_case_symbols", "required_projects", "success_policy"];
+                        readonly properties: {
+                            readonly version: {
+                                readonly type: "string";
+                                readonly const: "kibi.verification-contract.v1";
+                            };
+                            readonly runner: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly command_argv: {
+                                readonly type: "array";
+                                readonly minItems: 1;
+                                readonly items: {
                                     readonly type: "string";
                                     readonly minLength: 1;
                                 };
-                                readonly command: {
+                            };
+                            readonly required_case_symbols: {
+                                readonly type: "array";
+                                readonly items: {
                                     readonly type: "string";
                                     readonly minLength: 1;
                                 };
-                                readonly scope: {
-                                    readonly type: "string";
-                                    readonly enum: readonly ["unit", "integration", "end_to_end"];
-                                };
-                                readonly outcome: {
-                                    readonly type: "string";
-                                    readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped"];
-                                };
-                                readonly code_snapshot: {
-                                    readonly type: "string";
-                                    readonly pattern: "^[a-f0-9]{64}$";
-                                };
-                                readonly environment_hash: {
-                                    readonly type: "string";
-                                    readonly pattern: "^[a-f0-9]{64}$";
-                                };
-                                readonly started_at: {
+                                readonly uniqueItems: true;
+                            };
+                            readonly required_projects: {
+                                readonly type: "array";
+                                readonly items: {
                                     readonly type: "string";
                                     readonly minLength: 1;
                                 };
-                                readonly finished_at: {
-                                    readonly type: "string";
-                                    readonly minLength: 1;
+                                readonly uniqueItems: true;
+                            };
+                            readonly success_policy: {
+                                readonly type: "string";
+                                readonly const: "all_required_cases_first_attempt";
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                    readonly verification_receipts: {
+                        readonly type: "array";
+                        readonly maxItems: 50;
+                        readonly items: {
+                            readonly oneOf: readonly [{
+                                readonly type: "object";
+                                readonly required: readonly ["version", "receipt_id", "test_id", "runner", "command", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest"];
+                                readonly properties: {
+                                    readonly version: {
+                                        readonly type: "string";
+                                        readonly const: "kibi.verification-receipt.v1";
+                                    };
+                                    readonly receipt_id: {
+                                        readonly type: "string";
+                                        readonly pattern: "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
+                                    };
+                                    readonly test_id: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly runner: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly command: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly scope: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["unit", "integration", "end_to_end"];
+                                    };
+                                    readonly outcome: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
+                                    };
+                                    readonly code_snapshot: {
+                                        readonly type: "string";
+                                        readonly pattern: "^[a-f0-9]{64}$";
+                                    };
+                                    readonly environment_hash: {
+                                        readonly type: "string";
+                                        readonly pattern: "^[a-f0-9]{64}$";
+                                    };
+                                    readonly started_at: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly finished_at: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly artifact_digest: {
+                                        readonly type: "string";
+                                        readonly pattern: "^[a-f0-9]{64}$";
+                                    };
                                 };
-                                readonly artifact_digest: {
-                                    readonly type: "string";
-                                    readonly pattern: "^[a-f0-9]{64}$";
+                                readonly additionalProperties: false;
+                            }, {
+                                readonly required: readonly ["version", "receipt_id", "test_id", "runner", "command", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest", "command_argv", "contract_hash", "case_results"];
+                                readonly properties: {
+                                    readonly version: {
+                                        readonly type: "string";
+                                        readonly const: "kibi.verification-receipt.v2";
+                                    };
+                                    readonly command_argv: {
+                                        readonly type: "array";
+                                        readonly minItems: 1;
+                                        readonly items: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                        };
+                                    };
+                                    readonly contract_hash: {
+                                        readonly type: "string";
+                                        readonly pattern: "^[a-f0-9]{64}$";
+                                    };
+                                    readonly case_results: {
+                                        readonly type: "array";
+                                        readonly minItems: 1;
+                                        readonly maxItems: 1000;
+                                        readonly items: {
+                                            readonly type: "object";
+                                            readonly required: readonly ["symbol_id", "project", "outcome", "retries", "duration_ms"];
+                                            readonly properties: {
+                                                readonly symbol_id: {
+                                                    readonly type: "string";
+                                                    readonly minLength: 1;
+                                                };
+                                                readonly project: {
+                                                    readonly type: "string";
+                                                    readonly minLength: 1;
+                                                };
+                                                readonly outcome: {
+                                                    readonly type: "string";
+                                                    readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted"];
+                                                };
+                                                readonly retries: {
+                                                    readonly type: "integer";
+                                                    readonly minimum: 0;
+                                                };
+                                                readonly duration_ms: {
+                                                    readonly type: "integer";
+                                                    readonly minimum: 0;
+                                                };
+                                            };
+                                            readonly additionalProperties: false;
+                                        };
+                                    };
+                                    readonly receipt_id: {
+                                        readonly type: "string";
+                                        readonly pattern: "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
+                                    };
+                                    readonly test_id: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly runner: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly command: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly scope: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["unit", "integration", "end_to_end"];
+                                    };
+                                    readonly outcome: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
+                                    };
+                                    readonly code_snapshot: {
+                                        readonly type: "string";
+                                        readonly pattern: "^[a-f0-9]{64}$";
+                                    };
+                                    readonly environment_hash: {
+                                        readonly type: "string";
+                                        readonly pattern: "^[a-f0-9]{64}$";
+                                    };
+                                    readonly started_at: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly finished_at: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly artifact_digest: {
+                                        readonly type: "string";
+                                        readonly pattern: "^[a-f0-9]{64}$";
+                                    };
                                 };
-                            };
-                            readonly additionalProperties: false;
+                                readonly type: "object";
+                                readonly additionalProperties: false;
+                            }];
                         };
                         readonly description: "Append-only test execution evidence. Proof accepts only the newest valid passed receipt bound to the current code snapshot and within the seven-day freshness window.";
                     };
@@ -377,6 +520,20 @@ export declare const upsertSpec: {
                     };
                 };
             };
+            readonly document: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly description: "Optional source-first document write. Paths are workspace-relative; omit body when updating to preserve the existing body bytes.";
+                readonly properties: {
+                    readonly path: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly body: {
+                        readonly type: "string";
+                    };
+                };
+            };
         };
     };
     readonly requiresProlog: true;

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

@@ -1 +1 @@
-{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BuC,CAAC"}
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCuC,CAAC"}

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

@@ -19,6 +19,15 @@ export const upsertSpec = {
             },
             properties: ENTITY_PROPERTIES_SCHEMA,
             relationships: RELATIONSHIPS_SCHEMA,
+            document: {
+                type: "object",
+                additionalProperties: false,
+                description: "Optional source-first document write. Paths are workspace-relative; omit body when updating to preserve the existing body bytes.",
+                properties: {
+                    path: { type: "string", minLength: 1 },
+                    body: { type: "string" },
+                },
+            },
         },
     },
     requiresProlog: true,

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

@@ -0,0 +1,78 @@
+import { executeIngestVerification } from "../../../operations/verification/ingest-verification.js";
+export type { IngestVerificationArgs, IngestVerificationResult, } from "../../../operations/verification/ingest-verification.js";
+export { executeIngestVerification } from "../../../operations/verification/ingest-verification.js";
+export declare const ingestVerificationSpec: {
+    readonly name: "kb_ingest_verification";
+    readonly cliName: "ingest-verification";
+    readonly description: "Ingest a reporter-produced kibi.playwright-run.v1 artifact for a contracted test. Revalidates the live workspace snapshot, runner/command contract, required case/project coverage, and append-only receipt history before deriving and appending a kibi.verification-receipt.v2. It never accepts a caller-authored receipt or trusted outcome.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["testId", "snapshot", "artifact"];
+        readonly properties: {
+            readonly testId: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly description: "Existing test entity with verification_contract.v1.";
+            };
+            readonly snapshot: {
+                readonly type: "string";
+                readonly pattern: "^[a-f0-9]{64}$";
+                readonly description: "Workspace verification snapshot captured immediately before the run.";
+            };
+            readonly artifact: {
+                readonly type: "object";
+                readonly required: readonly ["version", "runner", "command_argv", "code_snapshot", "environment_hash", "started_at", "finished_at", "process_exit_code", "cases"];
+                readonly properties: {
+                    readonly version: {
+                        readonly type: "string";
+                        readonly const: "kibi.playwright-run.v1";
+                    };
+                    readonly runner: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    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_hash: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{64}$";
+                    };
+                    readonly started_at: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly finished_at: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly process_exit_code: {
+                        readonly type: "integer";
+                    };
+                    readonly cases: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly maxItems: 1000;
+                        readonly items: {
+                            readonly type: "object";
+                        };
+                    };
+                };
+                readonly additionalProperties: true;
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read", "kb-write", "workspace-read"];
+    readonly execute: typeof executeIngestVerification;
+};
+//# sourceMappingURL=verification.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verification.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/verification.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,yBAAyB,EAC1B,MAAM,yDAAyD,CAAC;AAGjE,YAAY,EACV,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,yDAAyD,CAAC;AACjE,OAAO,EAAE,yBAAyB,EAAE,MAAM,yDAAyD,CAAC;AAGpG,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+DlC,CAAC"}

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

@@ -0,0 +1,62 @@
+import { executeIngestVerification, } from "../../../operations/verification/ingest-verification.js";
+export { executeIngestVerification } from "../../../operations/verification/ingest-verification.js";
+// implements REQ-kibi-verification-evidence-contract
+export const ingestVerificationSpec = {
+    name: "kb_ingest_verification",
+    cliName: "ingest-verification",
+    description: "Ingest a reporter-produced kibi.playwright-run.v1 artifact for a contracted test. Revalidates the live workspace snapshot, runner/command contract, required case/project coverage, and append-only receipt history before deriving and appending a kibi.verification-receipt.v2. It never accepts a caller-authored receipt or trusted outcome.",
+    businessInputSchema: {
+        type: "object",
+        required: ["testId", "snapshot", "artifact"],
+        properties: {
+            testId: {
+                type: "string",
+                minLength: 1,
+                description: "Existing test entity with verification_contract.v1.",
+            },
+            snapshot: {
+                type: "string",
+                pattern: "^[a-f0-9]{64}$",
+                description: "Workspace verification snapshot captured immediately before the run.",
+            },
+            artifact: {
+                type: "object",
+                required: [
+                    "version",
+                    "runner",
+                    "command_argv",
+                    "code_snapshot",
+                    "environment_hash",
+                    "started_at",
+                    "finished_at",
+                    "process_exit_code",
+                    "cases",
+                ],
+                properties: {
+                    version: { type: "string", const: "kibi.playwright-run.v1" },
+                    runner: { type: "string", minLength: 1 },
+                    command_argv: {
+                        type: "array",
+                        minItems: 1,
+                        items: { type: "string", minLength: 1 },
+                    },
+                    code_snapshot: { type: "string", pattern: "^[a-f0-9]{64}$" },
+                    environment_hash: { type: "string", pattern: "^[a-f0-9]{64}$" },
+                    started_at: { type: "string", minLength: 1 },
+                    finished_at: { type: "string", minLength: 1 },
+                    process_exit_code: { type: "integer" },
+                    cases: {
+                        type: "array",
+                        minItems: 1,
+                        maxItems: 1000,
+                        items: { type: "object" },
+                    },
+                },
+                additionalProperties: true,
+            },
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-read", "kb-write", "workspace-read"],
+    execute: executeIngestVerification,
+};

package/dist/public/operations/symbol-repair-plan.d.ts

@@ -0,0 +1,11 @@
+import type { OperationContext } from "./runtime-types.js";
+export declare const SYMBOL_REPAIR_PLAN_VERSION: "kibi.symbol-repair-plan.v1";
+export type SymbolRepairPlan = Readonly<{
+    version: typeof SYMBOL_REPAIR_PLAN_VERSION;
+    readOnly: true;
+    autoApplicable: false;
+    repairs: readonly Readonly<Record<string, unknown>>[];
+}>;
+/** Build review-only, evidence-backed symbol recovery suggestions. */
+export declare function buildSymbolRepairPlan(rows: readonly Readonly<Record<string, unknown>>[], context: OperationContext): Promise<SymbolRepairPlan | undefined>;
+//# sourceMappingURL=symbol-repair-plan.d.ts.map

package/dist/public/operations/symbol-repair-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-repair-plan.d.ts","sourceRoot":"","sources":["../../../src/public/operations/symbol-repair-plan.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,eAAO,MAAM,0BAA0B,EAAG,4BAAqC,CAAC;AAEhF,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,OAAO,EAAE,OAAO,0BAA0B,CAAC;IAC3C,QAAQ,EAAE,IAAI,CAAC;IACf,cAAc,EAAE,KAAK,CAAC;IACtB,OAAO,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;CACvD,CAAC,CAAC;AA0DH,sEAAsE;AACtE,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,EAClD,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAwFvC"}