kibi-cli 0.18.1 → 1.0.1

package/dist/operations/mutation/upsert.js

@@ -1,12 +1,22 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, realpathSync, unlinkSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+import { OperationError } from "../../cli-errors.js";
+import { readManifestWithCoordinateOverlay } from "../../extractors/manifest.js";
+import { extractManifestSymbolRecords } from "../../extractors/manifest.js";
 import { escapeAtom } from "../../prolog/codec.js";
 import { loadEntities } from "../../public/operations/discovery-entities.js";
 import { appendOnlyVerificationReceiptHistoryErrors } from "../../public/verification-receipt.js";
+import { appendRelationship, computeShardPath, } from "../../relationships/shards.js";
+import { resolveBranchAttachment } from "../../utils/branch-resolver.js";
 import { analyzeSemanticAdvisorInput } from "../semantic-advisor/analyze-prose.js";
 import { assertLogicalGroundingClaimKeys, assertSemanticInventoryBoundary, } from "../semantic-advisor/ingestion-boundary.js";
 import { buildUpsertCommitGoal, formatUpsertError } from "./contradictions.js";
-import { existingRelationships, validateLiveRelationshipTargets, validateRelationshipSources, validateStrictLanePairing, } from "./relationships.js";
+import { existingRelationships, validateLiveRelationshipTargets, validateRelationshipSources, validateStrictLanePairing, validateSupersedesSourceHistory, } from "./relationships.js";
+import { writePendingSourceReceipt, writeSourceForUpsert, } from "./source-authoring.js";
+import { acquireSymbolCompilerLock, releaseSymbolCompilerLock, } from "./symbol-compiler-lock.js";
 import { validateSymbolGranularity } from "./symbol-granularity.js";
-import { refreshSymbolCoordinates } from "./symbol-refresh.js";
+import { refreshSymbolCoordinatesForManifest } from "./symbol-refresh.js";
 import { validateUpsertInput } from "./validation.js";
 import { scenarioCoverageWarnings } from "./warnings.js";
 function requireProlog(context) {
@@ -28,6 +38,58 @@ function parseChangeKind(value) {
         ? normalized
         : null;
 }
+function fileHash(pathname) {
+    if (!existsSync(pathname))
+        return null;
+    return createHash("sha256").update(readFileSync(pathname)).digest("hex");
+}
+function textHash(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function assertRelationshipShardContained(workspaceRoot, shardPath) {
+    const root = path.resolve(workspaceRoot);
+    const relationshipRoot = path.resolve(root, ".kb", "relationships");
+    const absolute = path.resolve(shardPath);
+    if (!absolute.startsWith(`${relationshipRoot}${path.sep}`)) {
+        throw new OperationError("SOURCE_PATH_INVALID", `Relationship shard escapes the canonical workspace lane: ${shardPath}`);
+    }
+    let existing = absolute;
+    while (!existsSync(existing) && path.dirname(existing) !== existing) {
+        existing = path.dirname(existing);
+    }
+    const real = realpathSync.native(existing);
+    if (real !== root && !real.startsWith(`${root}${path.sep}`)) {
+        throw new OperationError("SOURCE_PATH_INVALID", `Relationship shard follows a symlink outside the workspace: ${shardPath}`);
+    }
+}
+function restoreRelationshipShard(shardPath, before, expectedAfterHash) {
+    // Compare before restore: a concurrent writer may have replaced the shard
+    // after our append. Never clobber newer bytes; the next check/sync reports
+    // any canonical source path that needs reconciliation.
+    if (expectedAfterHash !== null) {
+        let currentHash = null;
+        try {
+            currentHash = fileHash(shardPath);
+        }
+        catch {
+            currentHash = null;
+        }
+        if (currentHash !== expectedAfterHash) {
+            console.warn(`Skipped relationship shard rollback for ${path.relative(process.cwd(), shardPath)}: shard changed after the Kibi write.`);
+            return;
+        }
+    }
+    if (before === null) {
+        try {
+            unlinkSync(shardPath);
+        }
+        catch {
+            // The file may already be absent after an interrupted atomic replace.
+        }
+        return;
+    }
+    writeFileSync(shardPath, before, "utf8");
+}
 export async function validateAppendOnlyVerificationReceipts(entity, context) {
     if (entity.type !== "test")
         return;
@@ -45,16 +107,23 @@ export async function validateAppendOnlyVerificationReceipts(entity, context) {
     }
 }
 export async function effectiveRelationships(input, entity, relationships, context) {
-    if (input.relationships !== undefined && input.relationships.length > 0) {
-        return relationships;
-    }
     const prolog = requireProlog(context);
     const exists = await prolog.query(`once(kb_entity('${escapeAtom(input.id)}', _, _))`);
     if (!exists.success)
         return relationships;
     try {
-        const current = await existingRelationships(prolog, String(entity.id));
-        return current.length > 0 ? current : relationships;
+        const current = (await existingRelationships(prolog, String(entity.id)))
+            // An upsert owns only relationships whose source is the upserted entity.
+            // Incoming relationships must not be copied into its validation or
+            // canonical source projection.
+            .filter((relationship) => relationship.from === input.id);
+        const merged = new Map();
+        for (const relationship of [...current, ...relationships]) {
+            const key = `${String(relationship.type)}\u0000${String(relationship.from)}\u0000${String(relationship.to)}`;
+            // The explicit input wins so any supplied metadata is retained.
+            merged.set(key, relationship);
+        }
+        return [...merged.values()];
     }
     catch (error) {
         if (error instanceof Error)
@@ -62,55 +131,243 @@ export async function effectiveRelationships(input, entity, relationships, conte
         throw error;
     }
 }
+/**
+ * Re-extract one complete canonical symbol entity from the authored manifest
+ * plus the freshly published generated coordinate artifact. Source-first
+ * commits must match exactly what the next sync would compile, instead of
+ * hand-merging generated fields into the caller's partial payload.
+ */
+function reextractCanonicalSymbolEntity(symbolId, authoredRelativePath, workspaceRoot) {
+    const absoluteManifest = path.resolve(workspaceRoot, authoredRelativePath);
+    let records;
+    try {
+        records = readManifestWithCoordinateOverlay(absoluteManifest);
+    }
+    catch (error) {
+        throw new Error(`Canonical symbol manifest ${authoredRelativePath} could not be compiled after coordinate refresh: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const mine = records.find((candidate) => candidate.id === symbolId);
+    if (mine === undefined)
+        return null;
+    const [result] = extractManifestSymbolRecords([mine], absoluteManifest);
+    if (result === undefined)
+        return null;
+    return {
+        ...result.entity,
+        ...(result.sourceFile === undefined
+            ? {}
+            : { sourceFile: result.sourceFile }),
+    };
+}
 export async function executeUpsert(input, context) {
+    const branchAttachment = context.branchAttachment ?? resolveBranchAttachment(context.workspaceRoot);
+    if ("error" in branchAttachment) {
+        throw new Error(`Unable to resolve KB branch: ${branchAttachment.error}`);
+    }
+    if (branchAttachment.migrationRequired &&
+        (context.branchAttachment !== undefined || context.fs !== undefined)) {
+        throw new Error(`Upsert blocked: KB is attached through legacy branch storage (${branchAttachment.gitBranch} -> ${branchAttachment.kbBranch}). Run 'kibi branch migrate --from ${branchAttachment.kbBranch} --to ${branchAttachment.gitBranch} --apply' first.`);
+    }
     const prolog = requireProlog(context);
+    let sourceWrite = null;
+    let commitEntity;
+    let sourceRolledBack = false;
+    let compiledCommitted = false;
+    let relationshipCount = 0;
+    let changeKind = null;
+    let semanticAdvisor;
+    let compilerLock;
+    let coordinatePublication;
+    let operationFailure;
+    const relationshipShardBefore = new Map();
+    const relationshipShardAfterHash = new Map();
+    const holdsSymbolCompilerLock = input.type === "symbol" &&
+        context.fs !== undefined &&
+        context.sourceFirst !== false;
     try {
+        if (holdsSymbolCompilerLock) {
+            // Symbol source publication, coordinate refresh, canonical
+            // re-extraction, and the RDF commit form one read-modify-write cycle.
+            // Serialize the whole cycle so concurrent full refreshes or sibling
+            // upserts cannot lose updates.
+            compilerLock = await acquireSymbolCompilerLock(context.workspaceRoot);
+        }
         const validated = validateUpsertInput(input, context.clock());
         await validateAppendOnlyVerificationReceipts(validated.entity, context);
         validateRelationshipSources(input.id, validated.relationships);
         await validateSymbolGranularity(validated.entity, validated.relationships, context);
         const relationships = await effectiveRelationships(input, validated.entity, validated.relationships, context);
-        await validateStrictLanePairing(prolog, relationships);
-        await validateLiveRelationshipTargets(prolog, validated.entity, relationships);
+        relationshipCount = validated.relationships.length;
+        await validateStrictLanePairing(prolog, validated.relationships);
+        await validateLiveRelationshipTargets(prolog, validated.entity, validated.relationships);
+        await validateSupersedesSourceHistory(prolog, validated.entity, validated.relationships, context.workspaceRoot);
         const semantic = analyzeSemanticAdvisorInput({
             payload: { ...input, relationships },
         });
+        semanticAdvisor = semantic.receipt;
         assertSemanticInventoryBoundary({ ...input, relationships }, relationships, semantic.receipt);
         await assertLogicalGroundingClaimKeys(prolog, { ...input, relationships }, relationships);
+        if (context.fs !== undefined && context.sourceFirst !== false) {
+            const existingRows = await loadEntities(prolog, {
+                id: input.id,
+                type: input.type,
+            });
+            const existing = existingRows[0];
+            const existingSource = existing !== undefined && typeof existing.source === "string"
+                ? existing.source
+                : undefined;
+            // Existing non-authored runtime sources (mcp://, test://, etc.) have no
+            // tracked document to update unless the caller explicitly supplies one;
+            // new entities are required to choose a source target in this
+            // filesystem-capable context.
+            if (input.document !== undefined ||
+                existingSource?.match(/\.(?:md|mdx|ya?ml|json)$/i) ||
+                // A filesystem-capable runtime is source-first for every new entity.
+                // writeSourceForUpsert emits the typed DOCUMENT_PATH_REQUIRED request
+                // when configuration has zero or multiple writable targets, rather
+                // than silently creating compiled-only state.
+                existing === undefined) {
+                sourceWrite = await writeSourceForUpsert(input, validated.entity, existing, context);
+                if (sourceWrite !== null) {
+                    // The authored path is the entity's canonical identity. Runtime
+                    // transport provenance (mcp://...) must never survive a source-first
+                    // write or a later delete/sync cycle.
+                    commitEntity = {
+                        ...validated.entity,
+                        source: sourceWrite.receipt.path,
+                    };
+                }
+            }
+        }
+        // Relationship shards are canonical source artifacts. Patch them before
+        // the compiled transaction so a failed commit can restore exact bytes and
+        // a successful commit never leaves a compiled-only relationship behind.
+        if (context.fs !== undefined && validated.relationships.length > 0) {
+            for (const relationship of validated.relationships) {
+                const type = typeof relationship.type === "string" ? relationship.type : "";
+                const from = typeof relationship.from === "string" ? relationship.from : input.id;
+                const to = typeof relationship.to === "string" ? relationship.to : "";
+                if (!type || !from || !to)
+                    continue;
+                const shardPath = computeShardPath(path.join(context.workspaceRoot, ".kb"), from);
+                assertRelationshipShardContained(context.workspaceRoot, shardPath);
+                if (!relationshipShardBefore.has(shardPath)) {
+                    relationshipShardBefore.set(shardPath, existsSync(shardPath) ? readFileSync(shardPath, "utf8") : null);
+                }
+                appendRelationship(path.join(context.workspaceRoot, ".kb"), {
+                    type,
+                    from,
+                    to,
+                    created_at: context.clock().toISOString(),
+                    created_by: "kibi/upsert",
+                    source: "mcp://kibi/upsert",
+                });
+                relationshipShardAfterHash.set(shardPath, fileHash(shardPath));
+            }
+        }
+        // Coordinates are generated compiler state owned by
+        // `.kb/symbol-coordinates.yaml`. Refresh the target's generated record
+        // from current extraction (we hold the symbol compiler lock), then commit
+        // the complete canonical entity the next sync would compile. Failures
+        // abort before the RDF transaction so source and shard rollbacks keep all
+        // surfaces consistent; stale coordinates are never reused as a fallback.
+        if (input.type === "symbol" &&
+            context.fs !== undefined &&
+            context.sourceFirst !== false &&
+            sourceWrite !== null) {
+            const refresh = await refreshSymbolCoordinatesForManifest(input.id, path.resolve(context.workspaceRoot, sourceWrite.receipt.path), context);
+            coordinatePublication = refresh.publication;
+            if (!refresh.found || refresh.outcome === "removed") {
+                throw new Error(`Coordinate refresh could not find ${input.id} in the authored symbol manifest`);
+            }
+            const canonical = reextractCanonicalSymbolEntity(input.id, sourceWrite.receipt.path, context.workspaceRoot);
+            if (canonical === null) {
+                throw new Error(`Canonical symbol manifest ${sourceWrite.receipt.path} no longer contains ${input.id} after coordinate refresh`);
+            }
+            // The authored path is the entity's canonical identity. Runtime
+            // transport provenance (mcp://...) must never survive a source-first
+            // write or a later delete/sync cycle.
+            commitEntity = {
+                ...canonical,
+                source: sourceWrite.receipt.path,
+            };
+        }
         const transaction = buildUpsertCommitGoal({
-            entity: validated.entity,
-            relationships,
+            entity: commitEntity ?? validated.entity,
+            relationships: validated.relationships,
             skipContradictionCheck: input._skipContradictionCheck === true,
         });
         const written = await prolog.query(transaction);
         if (!written.success) {
+            await sourceWrite?.rollback();
+            sourceRolledBack = sourceWrite !== null;
+            for (const [shardPath, before] of relationshipShardBefore) {
+                restoreRelationshipShard(shardPath, before, relationshipShardAfterHash.get(shardPath) ?? null);
+            }
             throw new Error(formatUpsertError(input.id, written.error));
         }
+        compiledCommitted = true;
         // The combined commit is the sole mutation boundary. Invalidate reads only
         // after Prolog reports success so a failed/rolled-back commit does not
         // disturb callers' view of the current snapshot.
         prolog.invalidateCache?.();
-        const changeKind = parseChangeKind(written.bindings.ChangeKind);
+        changeKind = parseChangeKind(written.bindings.ChangeKind);
         if (changeKind === null) {
             throw new Error(`Upsert commit completed without a created/updated result for ${input.id}`);
         }
-        if (input.type === "symbol") {
-            try {
-                await refreshSymbolCoordinates(input.id, context);
-            }
-            catch (error) {
-                if (!(error instanceof Error))
-                    throw error;
-            }
-        }
         const coverage = await scenarioCoverageWarnings(prolog, validated.relationships, input.type, input.id);
         const created = changeKind === "created" ? 1 : 0;
+        const shardWarnings = [];
+        const relationshipSourceWrites = [];
+        for (const [shardPath, before] of relationshipShardBefore) {
+            const afterHash = fileHash(shardPath);
+            const beforeHash = before === null ? null : textHash(before);
+            if (afterHash === null || afterHash === beforeHash)
+                continue;
+            const relative = path
+                .relative(context.workspaceRoot, shardPath)
+                .replaceAll("\\", "/");
+            writePendingSourceReceipt(context.workspaceRoot, relative, afterHash);
+            relationshipSourceWrites.push({
+                path: relative,
+                mode: "write",
+                beforeHash,
+                afterHash,
+                created: before === null,
+            });
+        }
         const payload = {
             created,
             updated: changeKind === "updated" ? 1 : 0,
-            relationships_created: relationships.length,
-            warnings: [...semantic.warnings, ...coverage],
+            relationships_created: validated.relationships.length,
+            warnings: [...semantic.warnings, ...coverage, ...shardWarnings],
             semanticAdvisor: semantic.receipt,
+            ...(shardWarnings.length > 0
+                ? {
+                    status: "committed_with_repairs",
+                    effectFailures: shardWarnings.map((detail) => ({
+                        kind: "workspace-write",
+                        errorCode: "RELATIONSHIP_SHARD_WRITE_FAILED",
+                        detail,
+                    })),
+                    nextActions: [
+                        {
+                            operation: "kb_check",
+                            reason: "Relationship shard publication failed after the KB commit; inspect the shard diagnostics and repair the canonical YAML before syncing.",
+                            required: true,
+                        },
+                    ],
+                }
+                : {}),
+            ...(sourceWrite ? { sourceWrites: [sourceWrite.receipt] } : {}),
+            ...(relationshipSourceWrites.length > 0
+                ? {
+                    sourceWrites: [
+                        ...(sourceWrite ? [sourceWrite.receipt] : []),
+                        ...relationshipSourceWrites,
+                    ],
+                }
+                : {}),
             ...(input.type === "req"
                 ? {
                     contradictionCheck: {
@@ -136,7 +393,89 @@ export async function executeUpsert(input, context) {
         };
     }
     catch (error) {
+        let coordinateRollbackError;
+        if (!compiledCommitted && coordinatePublication !== undefined) {
+            try {
+                coordinatePublication.rollback();
+            }
+            catch (rollbackError) {
+                coordinateRollbackError = rollbackError;
+            }
+        }
+        if (!compiledCommitted) {
+            for (const [shardPath, before] of relationshipShardBefore) {
+                try {
+                    restoreRelationshipShard(shardPath, before, relationshipShardAfterHash.get(shardPath) ?? null);
+                }
+                catch {
+                    // Preserve the original failure; the next check/sync reports any
+                    // canonical source path that could not be restored.
+                }
+            }
+        }
+        if (!compiledCommitted && sourceWrite !== null && !sourceRolledBack) {
+            try {
+                await sourceWrite.rollback();
+                sourceRolledBack = true;
+            }
+            catch {
+                // Preserve the original mutation error; the recovery journal can
+                // reconcile a failed source rollback on the next sync.
+            }
+        }
+        if (compiledCommitted) {
+            const detail = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Upserted ${input.id}, but a derived effect requires repair.`,
+                    },
+                ],
+                structuredContent: {
+                    created: changeKind === "created" ? 1 : 0,
+                    updated: changeKind === "updated" ? 1 : 0,
+                    relationships_created: relationshipCount,
+                    warnings: [detail],
+                    semanticAdvisor: semanticAdvisor,
+                    status: "committed_with_repairs",
+                    effectFailures: [
+                        {
+                            kind: "derived-effect",
+                            errorCode: "POST_COMMIT_EFFECT_FAILED",
+                            detail,
+                        },
+                    ],
+                    nextActions: [
+                        {
+                            operation: "kb_status",
+                            reason: "The compiled mutation committed; inspect the authoritative source and derived status before repairing.",
+                            required: true,
+                        },
+                        {
+                            operation: "kb_sync",
+                            reason: "Recompile canonical source files after the committed derived effect failure; do not retry the original upsert.",
+                            required: true,
+                        },
+                    ],
+                },
+            };
+        }
+        if (coordinateRollbackError !== undefined) {
+            const failure = new AggregateError([error, coordinateRollbackError], `Upsert failed and coordinate artifact rollback failed for ${input.id}`);
+            operationFailure = { error: failure };
+            throw failure;
+        }
+        if (error instanceof OperationError) {
+            operationFailure = { error };
+            throw error;
+        }
         const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Upsert execution failed: ${message}`);
+        const failure = new Error(`Upsert execution failed: ${message}`);
+        operationFailure = { error: failure };
+        throw failure;
+    }
+    finally {
+        releaseSymbolCompilerLock(compilerLock, operationFailure);
     }
 }

package/dist/operations/mutation/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/validation.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,0BAA0B,EAC3B,MAAM,oCAAoC,CAAC;AAQ5C,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAiF/D,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,IAAI,GACR,eAAe,CAwDjB;AAED,OAAO,EAAE,0BAA0B,EAAE,CAAC"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/validation.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,0BAA0B,EAC3B,MAAM,oCAAoC,CAAC;AAQ5C,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAkF/D,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,IAAI,GACR,eAAe,CAwDjB;AAED,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/operations/mutation/validation.js

@@ -22,6 +22,7 @@ const validateEntity = ajv.compile({
                 "module-level-behavior",
                 "extractor-miss",
                 "legacy-link",
+                "test-suite",
             ],
         },
         symbol_role: { type: "string", enum: [...SYMBOL_ROLES] },

package/dist/operations/planning/apply-plan.d.ts

@@ -0,0 +1,117 @@
+import { type MigrationPlan } from "../../public/operations/migration-plan.js";
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import { type BootstrapAction, type BootstrapPlanV1 } from "../bootstrap/types.js";
+import { type CompilePlanV1, type SourceWritePlan } from "./compile-intent.js";
+export declare const PLAN_APPLY_RESULT_VERSION: "kibi.plan-apply-result.v1";
+export type ApplyPlanArgs = Readonly<{
+    plan: BootstrapPlanV1;
+    approvedPlanHash: string;
+}> | Readonly<{
+    plan: CompilePlanV1;
+    approvedPlanHash: string;
+}> | Readonly<{
+    plan: MigrationPlan;
+    approvedPlanHash: string;
+    approvedActionIds: readonly string[];
+}> | Readonly<{
+    plan: EntityDeletionPlan;
+    approvedPlanHash: string;
+}> | Readonly<{
+    recoveryJournalId: string;
+}>;
+export type EntityDeletionPlan = Readonly<{
+    version: "kibi.entity-deletion-plan.v1";
+    planHash: string;
+    entityIds: readonly string[];
+    sourceHashes: Readonly<Record<string, string | null>>;
+    sourceWrites?: readonly SourceWritePlan[];
+    supersessionRequired: boolean;
+}>;
+type BootstrapActionResult = Readonly<{
+    actionId: string;
+    outcome: "applied" | "failed" | "skipped";
+    detail: string;
+}>;
+export type ApplyPlanResult = Readonly<{
+    version: typeof PLAN_APPLY_RESULT_VERSION;
+    outcome: "applied" | "replayed" | "partially_applied";
+    planHash: string;
+    actionResults: readonly BootstrapActionResult[];
+    changedEntities: number;
+    changedRelationships: number;
+    finalSnapshots: {
+        branch: string;
+        kbSnapshotId: string;
+        workspaceSnapshot: string;
+    };
+    recoveryJournalId: string | null;
+    changedPaths?: readonly string[];
+    validationSummary?: Readonly<Record<string, unknown>>;
+    status?: "committed_with_repairs";
+    effectFailures?: readonly Readonly<Record<string, unknown>>[];
+    nextActions?: readonly Readonly<Record<string, unknown>>[];
+}> | Readonly<{
+    version: typeof PLAN_APPLY_RESULT_VERSION;
+    outcome: "applied" | "replayed";
+    planHash: string;
+    changedEntities: number;
+    changedRelationships: number;
+    changedPaths: readonly string[];
+    finalSnapshots: {
+        branch: string;
+        kbSnapshotId: string;
+        workspaceSnapshot: string;
+    };
+    validationSummary: {
+        stepsValidated: number;
+        stepsApplied: number;
+        sourceHashesChecked: number;
+        notes: readonly string[];
+    };
+    recoveryJournalId: string | null;
+    status?: "committed_with_repairs";
+    effectFailures?: readonly Readonly<Record<string, unknown>>[];
+    nextActions?: readonly Readonly<Record<string, unknown>>[];
+}> | Readonly<{
+    version: "kibi.entity-deletion-apply-result.v1";
+    outcome: "applied";
+    planHash: string;
+    deleted: number;
+    sourcePaths: readonly string[];
+    recoveryJournalId?: string | null;
+    status?: "committed_with_repairs";
+    nextActions?: readonly Readonly<Record<string, unknown>>[];
+}> | Readonly<{
+    version: "kibi.migration-apply-result.v1";
+    outcome: "applied" | "partially_applied" | "replayed" | "reconciliation_required";
+    planHash: string;
+    actionResults: readonly Readonly<{
+        actionId: string;
+        outcome: "applied" | "failed" | "skipped";
+        detail: string;
+    }>[];
+    finalSnapshots: {
+        branch: string;
+        kbSnapshotId: string;
+        workspaceSnapshot: string;
+    };
+    notes: readonly string[];
+    remainingPlan?: MigrationPlan;
+    closeout?: {
+        taskOutcome: "complete" | "interim" | "blocked";
+        kbState: "clean_fresh" | "stale" | "dirty" | "legacy_compat" | "not_evaluated";
+        verificationState: "fresh" | "dirty" | "unavailable" | "not_evaluated";
+        proofState: "proven" | "mixed" | "unresolved" | "not_evaluated";
+        limitationDisposition: "none" | "accepted" | "unaccepted" | "not_applicable";
+    };
+}>;
+export declare function orderBootstrapActions(actions: readonly BootstrapAction[], completed?: Set<string>): BootstrapAction[];
+export declare function executeApplyPlan(args: ApplyPlanArgs, context: OperationContext): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent: ApplyPlanResult;
+}>;
+export {};
+//# sourceMappingURL=apply-plan.d.ts.map

package/dist/operations/planning/apply-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-plan.d.ts","sourceRoot":"","sources":["../../../src/operations/planning/apply-plan.ts"],"names":[],"mappings":"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"}