kibi-cli 0.18.1 → 1.0.1

package/dist/public/operations/specs/mutation-schemas.js

@@ -1,4 +1,4 @@
-import { VERIFICATION_RECEIPT_SCHEMA } from "../../verification-receipt.js";
+import { VERIFICATION_CONTRACT_SCHEMA, VERIFICATION_RECEIPT_SCHEMA, } from "../../verification-receipt.js";
 export const ENTITY_TYPES = [
     "req",
     "scenario",
@@ -103,6 +103,7 @@ export const ENTITY_PROPERTIES_SCHEMA = {
                 "module-level-behavior",
                 "extractor-miss",
                 "legacy-link",
+                "test-suite",
             ],
             description: "Optional justification for a coarse file/module-level symbol traceability relationship when narrower function/class/type symbols exist.",
         },
@@ -128,6 +129,7 @@ export const ENTITY_PROPERTIES_SCHEMA = {
             enum: ["internal", "consumer"],
             description: "Optional typed verification perspective for test entities. Example: 'consumer'.",
         },
+        verification_contract: VERIFICATION_CONTRACT_SCHEMA,
         verification_receipts: {
             type: "array",
             maxItems: 50,

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

@@ -38,14 +38,54 @@ export declare const deleteSpec: {
     readonly description: "Delete entities by ID. Use only for intentional removals after dependency checks. Do not use as a bulk cleanup shortcut. Side effects: mutates and saves KB; skips entities with dependents.";
     readonly businessInputSchema: {
         readonly type: "object";
-        readonly required: readonly ["ids"];
+        readonly oneOf: readonly [{
+            readonly required: readonly ["ids"];
+            readonly not: {
+                readonly required: readonly ["relationships"];
+            };
+        }, {
+            readonly required: readonly ["relationships"];
+            readonly not: {
+                readonly required: readonly ["ids"];
+            };
+        }];
         readonly properties: {
             readonly ids: {
                 readonly type: "array";
                 readonly items: {
                     readonly type: "string";
                 };
-                readonly description: "Required list of entity IDs to delete. Example: ['REQ-001','TEST-002']. At least one ID is required.";
+                readonly minItems: 1;
+                readonly description: "Entity IDs to delete after dependency checks.";
+            };
+            readonly relationships: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["type", "from", "to"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly type: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly from: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly to: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly description: "Exact relationship triples to retract, including legacy shard records.";
+            };
+            readonly approvedPlanHash: {
+                readonly type: "string";
+                readonly pattern: "^[a-fA-F0-9]{64}$";
+                readonly description: "Exact hash returned by a prior authored-entity deletion plan.";
             };
         };
     };

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

@@ -1 +1 @@
-{"version":3,"file":"mutation.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAOvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iDAAiD,CAAC;AAIxF,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBuC,CAAC;AAEvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;CAoBuC,CAAC"}
+{"version":3,"file":"mutation.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAOvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iDAAiD,CAAC;AAIxF,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBuC,CAAC;AAEvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CuC,CAAC"}

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

@@ -29,12 +29,36 @@ export const deleteSpec = {
     description: "Delete entities by ID. Use only for intentional removals after dependency checks. Do not use as a bulk cleanup shortcut. Side effects: mutates and saves KB; skips entities with dependents.",
     businessInputSchema: {
         type: "object",
-        required: ["ids"],
+        oneOf: [
+            { required: ["ids"], not: { required: ["relationships"] } },
+            { required: ["relationships"], not: { required: ["ids"] } },
+        ],
         properties: {
             ids: {
                 type: "array",
                 items: { type: "string" },
-                description: "Required list of entity IDs to delete. Example: ['REQ-001','TEST-002']. At least one ID is required.",
+                minItems: 1,
+                description: "Entity IDs to delete after dependency checks.",
+            },
+            relationships: {
+                type: "array",
+                minItems: 1,
+                items: {
+                    type: "object",
+                    required: ["type", "from", "to"],
+                    additionalProperties: false,
+                    properties: {
+                        type: { type: "string", minLength: 1 },
+                        from: { type: "string", minLength: 1 },
+                        to: { type: "string", minLength: 1 },
+                    },
+                },
+                description: "Exact relationship triples to retract, including legacy shard records.",
+            },
+            approvedPlanHash: {
+                type: "string",
+                pattern: "^[a-fA-F0-9]{64}$",
+                description: "Exact hash returned by a prior authored-entity deletion plan.",
             },
         },
     },

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

@@ -0,0 +1,270 @@
+import { executeApplyPlan } from "../../../operations/planning/apply-plan.js";
+import { executeCompileIntent } from "../../../operations/planning/compile-intent.js";
+export type { CompileIntentArgs, CompilePlanV1, ContradictionWitness, ProposalDecision, ScenarioDraft, TestDraft, TraceabilityProposal, } from "../../../operations/planning/compile-intent.js";
+export type { ApplyPlanArgs, ApplyPlanResult, } from "../../../operations/planning/apply-plan.js";
+export type { MigrationPlan } from "../migration-plan.js";
+export { executeApplyPlan } from "../../../operations/planning/apply-plan.js";
+export { executeCompileIntent } from "../../../operations/planning/compile-intent.js";
+export declare const compileIntentSpec: {
+    readonly name: "kb_compile_intent";
+    readonly cliName: "compile-intent";
+    readonly description: "Compile complete change intent into a deterministic, snapshot-bound read-only plan. Reuses intent-aware discovery and semantic modeling, accounts for every proposition, reports contradiction witnesses, proposes traceability links, and emits dependency-ordered kb_upsert-style steps only for resolved typed claims. No mutation side effects.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["intent", "mode"];
+        readonly properties: {
+            readonly intent: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 10000;
+                readonly description: "Complete post-change normative intent. Send the desired behavior, not a patch fragment.";
+            };
+            readonly mode: {
+                readonly type: "string";
+                readonly enum: readonly ["create", "update"];
+                readonly description: "Create a new requirement or update an existing one. Update auto-selection is allowed only with a high-confidence, well-separated candidate.";
+            };
+            readonly requirementId: {
+                readonly type: "string";
+                readonly description: "Optional exact requirement ID. Required for an update when automatic selection is below the confidence and margin gates.";
+            };
+            readonly title: {
+                readonly type: "string";
+                readonly description: "Optional requirement title; existing title is preserved for updates when omitted.";
+            };
+            readonly clauses: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly maxItems: 64;
+                readonly description: "Optional complete atomic clause decomposition. Each assertive clause receives independent proposition accounting.";
+            };
+            readonly semanticFacets: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly actors: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly actions: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly objects: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly constraints: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly aliases: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                };
+                readonly description: "Host-agent facets forwarded to deterministic intent-v1 discovery.";
+            };
+            readonly sourceLocations: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["path"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly path: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly line: {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                        };
+                        readonly column: {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                        };
+                        readonly symbol: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly description: "Workspace-relative source coordinates used for discovery and before-hash binding.";
+            };
+            readonly interpretations: {
+                readonly type: "array";
+                readonly maxItems: 3;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["claim_key", "claim_text", "ir"];
+                    readonly properties: {
+                        readonly claim_key: {
+                            readonly type: "string";
+                        };
+                        readonly claim_text: {
+                            readonly type: "string";
+                        };
+                        readonly confidence: {
+                            readonly type: "number";
+                            readonly minimum: 0;
+                            readonly maximum: 1;
+                        };
+                        readonly span: {
+                            readonly type: "object";
+                        };
+                        readonly ir: {
+                            readonly type: "object";
+                        };
+                    };
+                };
+                readonly description: "Optional host-supplied typed kibi.logic.v1 interpretations; Kibi validates them before including rule steps.";
+            };
+            readonly scenarioDrafts: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["title", "body"];
+                    readonly properties: {
+                        readonly id: {
+                            readonly type: "string";
+                        };
+                        readonly title: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly body: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly description: "Optional scenario drafts. Each is linked requirement -> scenario with specified_by.";
+            };
+            readonly testDrafts: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["title", "body"];
+                    readonly properties: {
+                        readonly id: {
+                            readonly type: "string";
+                        };
+                        readonly title: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly body: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly verificationScope: {
+                            readonly type: "string";
+                            readonly enum: readonly ["unit", "integration", "end_to_end"];
+                        };
+                        readonly verificationPerspective: {
+                            readonly type: "string";
+                            readonly enum: readonly ["internal", "consumer"];
+                        };
+                    };
+                };
+                readonly description: "Optional test drafts. Tests are attached to scenarios with verified_by; direct req -> test proof links are not emitted.";
+            };
+            readonly proposalDecisions: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["proposalId", "decision"];
+                    readonly properties: {
+                        readonly proposalId: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly decision: {
+                            readonly type: "string";
+                            readonly enum: readonly ["accept", "reject"];
+                        };
+                    };
+                };
+                readonly description: "Explicit decisions for deterministic traceability proposals. Pending proposals never enter steps.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read", "workspace-read"];
+    readonly execute: typeof executeCompileIntent;
+};
+export declare const applyPlanSpec: {
+    readonly name: "kb_apply_plan";
+    readonly cliName: "apply-plan";
+    readonly description: "Apply an explicitly approved kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or entity-deletion plan after revalidating its canonical hash and live snapshots. Bootstrap actions are dependency-ordered, sequential, source-first, and recoverable from a typed journal.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly oneOf: readonly [{
+            readonly required: readonly ["plan", "approvedPlanHash"];
+            readonly not: {
+                readonly required: readonly ["recoveryJournalId"];
+            };
+        }, {
+            readonly required: readonly ["recoveryJournalId"];
+            readonly not: {
+                readonly anyOf: readonly [{
+                    readonly required: readonly ["plan"];
+                }, {
+                    readonly required: readonly ["approvedPlanHash"];
+                }];
+            };
+        }];
+        readonly properties: {
+            readonly approvedPlanHash: {
+                readonly type: "string";
+                readonly pattern: "^[a-fA-F0-9]{64}$";
+                readonly description: "Exact SHA-256 planHash returned by kb_plan_bootstrap, kb_compile_intent, or another approved plan after human review.";
+            };
+            readonly plan: {
+                readonly type: "object";
+                readonly required: readonly ["version", "planHash"];
+                readonly description: "The complete kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or hash-bound kibi.entity-deletion-plan.v1 object. Migration plans require approvedActionIds and reject blocked/non-automatic actions.";
+            };
+            readonly approvedActionIds: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly description: "Required for migration-plan.v2. Exact automatic action IDs explicitly approved for this application.";
+            };
+            readonly recoveryJournalId: {
+                readonly type: "string";
+                readonly pattern: "^[A-Za-z0-9._-]+$";
+                readonly description: "Typed recovery journal identifier returned by a committed_with_repairs result. Recovery replays only the immutable journal and never the original plan request.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read", "kb-write", "workspace-read", "workspace-write"];
+    readonly execute: typeof executeApplyPlan;
+};
+//# sourceMappingURL=planning.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planning.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/planning.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,gBAAgB,EACjB,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAGL,oBAAoB,EACrB,MAAM,gDAAgD,CAAC;AAGxD,YAAY,EACV,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,oBAAoB,GACrB,MAAM,gDAAgD,CAAC;AACxD,YAAY,EACV,aAAa,EACb,eAAe,GAChB,MAAM,4CAA4C,CAAC;AACpD,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,gDAAgD,CAAC;AAGtF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmJsC,CAAC;AAGrE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDwC,CAAC"}

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

@@ -0,0 +1,191 @@
+import { executeApplyPlan, } from "../../../operations/planning/apply-plan.js";
+import { executeCompileIntent, } from "../../../operations/planning/compile-intent.js";
+export { executeApplyPlan } from "../../../operations/planning/apply-plan.js";
+export { executeCompileIntent } from "../../../operations/planning/compile-intent.js";
+// implements REQ-kibi-change-to-proof-plan-compiler
+export const compileIntentSpec = {
+    name: "kb_compile_intent",
+    cliName: "compile-intent",
+    description: "Compile complete change intent into a deterministic, snapshot-bound read-only plan. Reuses intent-aware discovery and semantic modeling, accounts for every proposition, reports contradiction witnesses, proposes traceability links, and emits dependency-ordered kb_upsert-style steps only for resolved typed claims. No mutation side effects.",
+    businessInputSchema: {
+        type: "object",
+        required: ["intent", "mode"],
+        properties: {
+            intent: {
+                type: "string",
+                minLength: 1,
+                maxLength: 10000,
+                description: "Complete post-change normative intent. Send the desired behavior, not a patch fragment.",
+            },
+            mode: {
+                type: "string",
+                enum: ["create", "update"],
+                description: "Create a new requirement or update an existing one. Update auto-selection is allowed only with a high-confidence, well-separated candidate.",
+            },
+            requirementId: {
+                type: "string",
+                description: "Optional exact requirement ID. Required for an update when automatic selection is below the confidence and margin gates.",
+            },
+            title: {
+                type: "string",
+                description: "Optional requirement title; existing title is preserved for updates when omitted.",
+            },
+            clauses: {
+                type: "array",
+                items: { type: "string", minLength: 1 },
+                maxItems: 64,
+                description: "Optional complete atomic clause decomposition. Each assertive clause receives independent proposition accounting.",
+            },
+            semanticFacets: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    actors: { type: "array", items: { type: "string" }, maxItems: 20 },
+                    actions: { type: "array", items: { type: "string" }, maxItems: 20 },
+                    objects: { type: "array", items: { type: "string" }, maxItems: 20 },
+                    constraints: {
+                        type: "array",
+                        items: { type: "string" },
+                        maxItems: 20,
+                    },
+                    aliases: { type: "array", items: { type: "string" }, maxItems: 20 },
+                },
+                description: "Host-agent facets forwarded to deterministic intent-v1 discovery.",
+            },
+            sourceLocations: {
+                type: "array",
+                maxItems: 20,
+                items: {
+                    type: "object",
+                    required: ["path"],
+                    additionalProperties: false,
+                    properties: {
+                        path: { type: "string", minLength: 1 },
+                        line: { type: "integer", minimum: 1 },
+                        column: { type: "integer", minimum: 1 },
+                        symbol: { type: "string", minLength: 1 },
+                    },
+                },
+                description: "Workspace-relative source coordinates used for discovery and before-hash binding.",
+            },
+            interpretations: {
+                type: "array",
+                maxItems: 3,
+                items: {
+                    type: "object",
+                    required: ["claim_key", "claim_text", "ir"],
+                    properties: {
+                        claim_key: { type: "string" },
+                        claim_text: { type: "string" },
+                        confidence: { type: "number", minimum: 0, maximum: 1 },
+                        span: { type: "object" },
+                        ir: { type: "object" },
+                    },
+                },
+                description: "Optional host-supplied typed kibi.logic.v1 interpretations; Kibi validates them before including rule steps.",
+            },
+            scenarioDrafts: {
+                type: "array",
+                maxItems: 20,
+                items: {
+                    type: "object",
+                    required: ["title", "body"],
+                    properties: {
+                        id: { type: "string" },
+                        title: { type: "string", minLength: 1 },
+                        body: { type: "string", minLength: 1 },
+                    },
+                },
+                description: "Optional scenario drafts. Each is linked requirement -> scenario with specified_by.",
+            },
+            testDrafts: {
+                type: "array",
+                maxItems: 20,
+                items: {
+                    type: "object",
+                    required: ["title", "body"],
+                    properties: {
+                        id: { type: "string" },
+                        title: { type: "string", minLength: 1 },
+                        body: { type: "string", minLength: 1 },
+                        verificationScope: {
+                            type: "string",
+                            enum: ["unit", "integration", "end_to_end"],
+                        },
+                        verificationPerspective: {
+                            type: "string",
+                            enum: ["internal", "consumer"],
+                        },
+                    },
+                },
+                description: "Optional test drafts. Tests are attached to scenarios with verified_by; direct req -> test proof links are not emitted.",
+            },
+            proposalDecisions: {
+                type: "array",
+                maxItems: 20,
+                items: {
+                    type: "object",
+                    required: ["proposalId", "decision"],
+                    properties: {
+                        proposalId: { type: "string", minLength: 1 },
+                        decision: { type: "string", enum: ["accept", "reject"] },
+                    },
+                },
+                description: "Explicit decisions for deterministic traceability proposals. Pending proposals never enter steps.",
+            },
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-read", "workspace-read"],
+    execute: executeCompileIntent,
+};
+// implements REQ-kibi-change-to-proof-plan-compiler
+export const applyPlanSpec = {
+    name: "kb_apply_plan",
+    cliName: "apply-plan",
+    description: "Apply an explicitly approved kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or entity-deletion plan after revalidating its canonical hash and live snapshots. Bootstrap actions are dependency-ordered, sequential, source-first, and recoverable from a typed journal.",
+    businessInputSchema: {
+        type: "object",
+        oneOf: [
+            {
+                required: ["plan", "approvedPlanHash"],
+                not: { required: ["recoveryJournalId"] },
+            },
+            {
+                required: ["recoveryJournalId"],
+                not: {
+                    anyOf: [{ required: ["plan"] }, { required: ["approvedPlanHash"] }],
+                },
+            },
+        ],
+        properties: {
+            approvedPlanHash: {
+                type: "string",
+                pattern: "^[a-fA-F0-9]{64}$",
+                description: "Exact SHA-256 planHash returned by kb_plan_bootstrap, kb_compile_intent, or another approved plan after human review.",
+            },
+            plan: {
+                type: "object",
+                required: ["version", "planHash"],
+                description: "The complete kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or hash-bound kibi.entity-deletion-plan.v1 object. Migration plans require approvedActionIds and reject blocked/non-automatic actions.",
+            },
+            approvedActionIds: {
+                type: "array",
+                items: { type: "string", minLength: 1 },
+                description: "Required for migration-plan.v2. Exact automatic action IDs explicitly approved for this application.",
+            },
+            recoveryJournalId: {
+                type: "string",
+                pattern: "^[A-Za-z0-9._-]+$",
+                description: "Typed recovery journal identifier returned by a committed_with_repairs result. Recovery replays only the immutable journal and never the original plan request.",
+            },
+        },
+    },
+    // Applying an entity-deletion plan must also retract the compiled entity;
+    // acquire the branch engine up front so the source commit and compiled
+    // retraction run under one capability-scoped operation context. Recovery
+    // journals remain usable even when the engine is unavailable.
+    requiresProlog: true,
+    effects: ["kb-read", "kb-write", "workspace-read", "workspace-write"],
+    execute: executeApplyPlan,
+};

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";
@@ -34,6 +35,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 = {
@@ -102,7 +105,7 @@ export declare function executeCoverage(input: CoverageInput, context: Operation
 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: {

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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"}