kibi-cli 0.19.0 → 2.0.0

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

@@ -0,0 +1,279 @@
+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 scenarioIds: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly maxItems: 20;
+                            readonly description: "Stable scenario draft IDs verified by this test. Required when multiple scenario drafts are supplied.";
+                        };
+                        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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0JsC,CAAC;AAGrE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDwC,CAAC"}

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

@@ -0,0 +1,197 @@
+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 },
+                        scenarioIds: {
+                            type: "array",
+                            items: { type: "string", minLength: 1 },
+                            maxItems: 20,
+                            description: "Stable scenario draft IDs verified by this test. Required when multiple scenario drafts are supplied.",
+                        },
+                        verificationScope: {
+                            type: "string",
+                            enum: ["unit", "integration", "end_to_end"],
+                        },
+                        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,
+};