kibi-cli 2.3.0 → 2.5.0

package/dist/commands/migrate.js

@@ -18,6 +18,10 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
 import * as path from "node:path";
 import { load as parseYAML } from "js-yaml";
+import { applySafeInventoryRederivations, planInventoryRederivation, } from "../operations/migration/inventory-rederive.js";
+import { applyOriginBackfill, planOriginBackfill, } from "../operations/migration/origin-backfill.js";
+import { applySourcePathRepairs, findSourceRepairs, } from "../operations/migration/source-paths.js";
+import { applySupersededClosures, planSupersededClosures, } from "../operations/migration/superseded-closure.js";
 import { extractSymbolsFromStagedFile } from "../traceability/symbol-extract.js";
 import { resolveBranchAttachment } from "../utils/branch-resolver.js";
 import { defaultKbManifest, readKbManifest, readKbManifestStatus, writeKbManifest, } from "../utils/kb-manifest.js";
@@ -57,6 +61,18 @@ const SCHEMA_MIGRATION_STEPS = [
         to: 5,
         description: "Move Kibi knowledge into the canonical .kb/ namespace and retire .kb/config.json.",
     },
+    {
+        id: "entity-origin-v6",
+        from: 5,
+        to: 6,
+        description: "Record origin {kind: migration} on authored entities written before schema 6, close superseded requirements, and repair authored source fields (point moved knowledge files at .kb/, remove redundant and dead values).",
+    },
+    {
+        id: "polarity-values-v7",
+        from: 6,
+        to: 7,
+        description: "Encode legacy polarity-only property facts as eq boolean true with require/forbid polarity; strict fact shapes are blocking.",
+    },
 ];
 function migrationStepsFor(fromVersion) {
     const start = Math.max(0, fromVersion ?? 0);
@@ -117,6 +133,10 @@ function buildMigrationAuditRecord(args) {
         semanticAdvisorBackfill: args.semanticAdvisorBackfill,
         status: "applied",
         symbolGranularityLegacyLinks: args.symbolGranularityLegacyLinks,
+        entityOriginBackfill: args.entityOriginBackfill,
+        supersededRequirementsClosed: args.supersededRequirementsClosed,
+        sourcePathsRewritten: args.sourcePathsRewritten,
+        sourcePathsRemoved: args.sourcePathsRemoved,
         toVersion: LATEST_KB_SCHEMA_VERSION,
         warning: args.warning,
         steps: args.steps,
@@ -261,6 +281,119 @@ function migrateSymbolGranularity(options) {
     }
     return { count, manifestPath };
 }
+function describeRederivation(plan) {
+    const { keptModeled, roleChanges, newlyUnresolved, downgradedModeled } = plan.summary;
+    return `${plan.requirementId}: ${keptModeled} modeled claim(s) kept, ${roleChanges} role change(s), ${newlyUnresolved} claim(s) now unresolved, ${downgradedModeled} modeled claim(s) downgraded`;
+}
+function printManualRederivations(plans) {
+    for (const plan of plans) {
+        printWarning(`${plan.requirementId} (${plan.path}) no longer matches the current semantic advisor and needs a manual fix: ${plan.reasons.join("; ")}. Run 'kibi migrate --format json' for the exact repair steps.`);
+    }
+}
+/**
+ * Re-derive semantic inventories that drifted with the current advisor. Safe
+ * re-derivations keep every claim whose claim_key and text still match;
+ * anything else is reported for a manual fix.
+ */
+// implements REQ-cli-schema-migration, REQ-kibi-proposition-complete-ingestion
+function rederiveDriftedInventories(cwd, dryRun) {
+    if (dryRun) {
+        const plans = planInventoryRederivation(cwd);
+        for (const plan of plans.filter((candidate) => candidate.safe)) {
+            console.log(`dry run: would re-derive the semantic inventory of ${describeRederivation(plan)}.`);
+        }
+        const manual = plans.filter((candidate) => !candidate.safe);
+        printManualRederivations(manual);
+        return {
+            rederived: plans
+                .filter((candidate) => candidate.safe)
+                .map((candidate) => candidate.requirementId),
+            manual: manual.length,
+        };
+    }
+    const plans = planInventoryRederivation(cwd);
+    const result = applySafeInventoryRederivations(cwd);
+    const rederived = result.rederived
+        .filter((outcome) => outcome.outcome === "rederived")
+        .map((outcome) => outcome.requirementId);
+    for (const plan of plans.filter((candidate) => rederived.includes(candidate.requirementId))) {
+        console.log(`Re-derived the semantic inventory of ${describeRederivation(plan)}.`);
+    }
+    printManualRederivations(result.manual);
+    return { rederived, manual: result.manual.length };
+}
+const REMOVED_SOURCES_NOTE = "the compiled source is always the entity's own file";
+/**
+ * Close superseded requirements and repair authored source fields: point
+ * moved knowledge files at .kb/, and remove values that name the entity's
+ * own file or nothing Kibi can map. Superseded requirements and dangling
+ * sources block kibi check, so this runs at any schema version.
+ * Supersession cycles and source fields Kibi cannot edit safely are left for
+ * a person and reported as warnings.
+ */
+// implements REQ-cli-schema-migration, REQ-core-validation-rules, REQ-kibi-schema6-migration
+function repairLifecycleFindings(cwd, dryRun) {
+    const supersession = planSupersededClosures(cwd);
+    let closed = supersession.closures.length;
+    let rewritten = 0;
+    let removed = 0;
+    let unrepaired = [];
+    if (dryRun) {
+        const repairs = findSourceRepairs(cwd);
+        for (const repair of repairs) {
+            if (repair.refused !== undefined) {
+                unrepaired.push({ file: repair.file, reason: repair.refused });
+            }
+            else if (repair.fix.kind === "rewrite") {
+                rewritten += 1;
+            }
+            else {
+                removed += 1;
+            }
+        }
+        if (closed > 0) {
+            console.log(`dry run: would close ${closed} superseded requirement(s): ${supersession.closures.map((closure) => closure.id).join(", ")}.`);
+        }
+        if (rewritten > 0) {
+            console.log(`dry run: would point ${rewritten} pre-canonical source path(s) at their .kb/ files.`);
+        }
+        if (removed > 0) {
+            console.log(`dry run: would remove ${removed} redundant or dead source field(s); ${REMOVED_SOURCES_NOTE}.`);
+        }
+    }
+    else {
+        const closures = applySupersededClosures(cwd);
+        closed = closures.closed.length;
+        if (closed > 0) {
+            console.log(`Closed ${closed} superseded requirement(s): ${closures.closed.map((closure) => closure.id).join(", ")}.`);
+        }
+        for (const skip of closures.skipped) {
+            printWarning(`Status not set for ${skip.path}: ${skip.reason}.`);
+        }
+        const repairs = applySourcePathRepairs(cwd);
+        rewritten = repairs.rewritten.length;
+        removed = repairs.removed.length;
+        unrepaired = [...repairs.skipped];
+        if (rewritten > 0) {
+            console.log(`Pointed ${rewritten} pre-canonical source path(s) at their .kb/ files.`);
+        }
+        if (removed > 0) {
+            console.log(`Removed ${removed} redundant or dead source field(s); ${REMOVED_SOURCES_NOTE}.`);
+        }
+    }
+    for (const cycle of supersession.cycles) {
+        printWarning(`Requirements ${cycle.members.join(", ")} supersede each other; decide which one is current, remove the supersedes link that points at it, and close the others.`);
+    }
+    for (const skip of unrepaired) {
+        printWarning(`Source field of ${skip.file} not repaired: ${skip.reason}; a person edits it by hand (kibi migrate --format json lists it as review_source_path_dangling).`);
+    }
+    return {
+        closed,
+        rewritten,
+        removed,
+        manual: supersession.cycles.length + unrepaired.length,
+    };
+}
 export function warnMigrationRequiredWithoutYes() {
     printWarning("Migration required for this repository.");
     console.log("No changes applied.");
@@ -326,6 +459,27 @@ export async function migrateCommand(options = {}) {
         return { exitCode: 1 };
     }
     if (!needsStorageMigration && !needsSchemaUpgrade) {
+        const { planPolarityValueBackfill, applyPolarityValueBackfill } = await import("../operations/migration/polarity-values.js");
+        const polarityCount = options.dryRun
+            ? planPolarityValueBackfill(cwd).length
+            : applyPolarityValueBackfill(cwd);
+        // An advisor change can make stored inventories drift at any version,
+        // and lifecycle findings block kibi check at any version.
+        const drift = rederiveDriftedInventories(cwd, options.dryRun === true);
+        const lifecycle = repairLifecycleFindings(cwd, options.dryRun === true);
+        const rewroteSources = polarityCount > 0 ||
+            drift.rederived.length > 0 ||
+            lifecycle.closed > 0 ||
+            lifecycle.rewritten > 0 ||
+            lifecycle.removed > 0;
+        if (rewroteSources || drift.manual > 0 || lifecycle.manual > 0) {
+            if (options.dryRun !== true && rewroteSources) {
+                console.log("Run 'kibi sync' to recompile the rewritten sources.");
+            }
+            if (options.yes === true)
+                updateGitIgnore(cwd);
+            return { exitCode: 0 };
+        }
         console.log(`No migration needed: the KB is already at schemaVersion ${LATEST_KB_SCHEMA_VERSION} on the canonical .kb/ layout.`);
         if (existsSync(auditPath)) {
             console.log(`Existing migration audit metadata: ${toRelativePath(cwd, auditPath)}`);
@@ -339,7 +493,12 @@ export async function migrateCommand(options = {}) {
     const migrationSteps = migrationStepsFor(configStatus.currentVersion);
     const symbolGranularityStep = migrationSteps.some((step) => step.id === "symbol-granularity-v2");
     const semanticBackfillStep = migrationSteps.some((step) => step.id === "semantic-backfill-v4");
+    const originBackfillStep = migrationSteps.some((step) => step.id === "entity-origin-v6");
+    const { planPolarityValueBackfill, applyPolarityValueBackfill } = await import("../operations/migration/polarity-values.js");
+    const polarityBackfill = planPolarityValueBackfill(cwd);
     if (options.dryRun) {
+        if (polarityBackfill.length > 0)
+            console.log(`dry run: would encode ${polarityBackfill.length} legacy polarity-only fact(s) as typed booleans.`);
         if (storagePlan.moves.length > 0) {
             console.log(`dry run: would move ${storagePlan.moves.length} legacy knowledge file(s) into .kb/:`);
             for (const move of storagePlan.moves) {
@@ -361,6 +520,14 @@ export async function migrateCommand(options = {}) {
                 console.log(`dry run: would mark ${preview.count} legacy coarse symbol link(s) as legacy-link.`);
             }
         }
+        if (originBackfillStep) {
+            const backfill = planOriginBackfill(cwd);
+            if (backfill.targets.length > 0) {
+                console.log(`dry run: would record origin {kind: migration} on ${backfill.targets.length} authored entit(ies) without one.`);
+            }
+        }
+        rederiveDriftedInventories(cwd, true);
+        repairLifecycleFindings(cwd, true);
         console.log(`dry run: would write migration audit metadata to ${toRelativePath(cwd, auditPath)}.`);
         console.log("Re-run with --yes to apply these changes.");
         return { exitCode: 0 };
@@ -376,22 +543,35 @@ export async function migrateCommand(options = {}) {
             console.log("Retired legacy .kb/config.json.");
         }
     }
-    const symbolGranularityMigration = migrateSymbolGranularity({
-        cwd,
-        dryRun: !symbolGranularityStep || options.dryRun || !options.yes,
-    });
+    const symbolGranularityMigration = symbolGranularityStep
+        ? migrateSymbolGranularity({
+            cwd,
+            dryRun: options.yes !== true,
+        })
+        : { count: 0 };
     const semanticAdvisorBackfill = normalizeSemanticAdvisorBackfill(readKbManifest(cwd)?.semanticAdvisorBackfill) ??
         normalizeSemanticAdvisorBackfill(storagePlan.semanticAdvisorBackfill) ??
         (semanticBackfillStep || needsStorageMigration
             ? "pending"
             : "not_applicable");
+    const migratedAt = new Date().toISOString();
+    const polarityValuesRewritten = applyPolarityValueBackfill(cwd);
+    if (polarityValuesRewritten > 0)
+        console.log(`Encoded ${polarityValuesRewritten} legacy polarity-only fact(s) as typed booleans.`);
+    // Source rewrites run before the manifest records the new schema, so an
+    // interrupted run is retried by the next 'kibi migrate --yes'; both are
+    // idempotent.
+    const originBackfill = originBackfillStep
+        ? applyOriginBackfill(cwd, migratedAt)
+        : { written: [], skipped: [], previouslyStamped: 0 };
+    rederiveDriftedInventories(cwd, false);
+    const lifecycle = repairLifecycleFindings(cwd, false);
     const existingManifest = readKbManifest(cwd) ?? defaultKbManifest();
     writeKbManifest(cwd, {
         ...existingManifest,
         schemaVersion: LATEST_KB_SCHEMA_VERSION,
         semanticAdvisorBackfill,
     });
-    const migratedAt = new Date().toISOString();
     writeJsonAtomically(auditPath, buildMigrationAuditRecord({
         branch,
         manifestPath: KB_MANIFEST_RELATIVE,
@@ -399,6 +579,10 @@ export async function migrateCommand(options = {}) {
         migratedAt,
         semanticAdvisorBackfill,
         symbolGranularityLegacyLinks: symbolGranularityMigration.count,
+        entityOriginBackfill: originBackfill.written.length + originBackfill.previouslyStamped,
+        supersededRequirementsClosed: lifecycle.closed,
+        sourcePathsRewritten: lifecycle.rewritten,
+        sourcePathsRemoved: lifecycle.removed,
         warning: migrationWarning,
         steps: migrationSteps.map((step) => step.id),
     }));
@@ -409,20 +593,29 @@ export async function migrateCommand(options = {}) {
     if (semanticAdvisorBackfill === "pending") {
         console.log(`Marked semantic advisor backfill as pending in ${KB_MANIFEST_RELATIVE}.`);
     }
+    if (originBackfill.written.length > 0) {
+        console.log(`Recorded origin {kind: migration} on ${originBackfill.written.length} authored entit(ies).`);
+    }
+    for (const skip of originBackfill.skipped) {
+        printWarning(`Origin not recorded for ${skip.path}: ${skip.reason}.`);
+    }
     console.log(`Wrote migration audit metadata to ${toRelativePath(cwd, auditPath)}.`);
     console.log("Migration complete. Future 'kibi migrate' runs will be a no-op.");
     updateGitIgnore(cwd);
     return { exitCode: 0 };
 }
 const KB_MANIFEST_RELATIVE = ".kb/manifest.json";
+// implements REQ-agent-guided-migration-orchestration, REQ-cli-schema-migration
 async function buildWorkspaceMigrationPlan(workspaceRoot = process.cwd()) {
-    const [{ createCliRuntime }, { executeOperation }, { statusSpec }, { checkSpec }, { coverageSpec }, { mergeMigrationPlans },] = await Promise.all([
+    const [{ createCliRuntime }, { executeOperation }, { statusSpec }, { checkSpec }, { coverageSpec }, { buildMigrationPlan, mergeMigrationPlans, migrationAction, withoutActionCodes, }, { ORIGIN_SCHEMA_VERSION, buildSchema6MigrationFragment, migrationSyncAction, }, { SOURCE_PLANNED_LIFECYCLE_CODES },] = await Promise.all([
         import("../runtime/cli-runtime.js"),
         import("../public/operations/runtime-types.js"),
         import("../public/operations/specs/discovery.js"),
         import("../public/operations/specs/check.js"),
         import("../public/operations/specs/reporting.js"),
         import("../public/operations/migration-plan.js"),
+        import("../operations/migration/schema6.js"),
+        import("../public/operations/schema6-check-actions.js"),
     ]);
     const runtime = createCliRuntime({ workspaceRoot });
     const statusResult = await executeOperation(runtime, statusSpec, {});
@@ -430,14 +623,57 @@ async function buildWorkspaceMigrationPlan(workspaceRoot = process.cwd()) {
     const plans = [];
     if (status?.migrationPlan !== undefined)
         plans.push(status.migrationPlan);
+    // Source-derived schema 6 actions: re-derive drifted inventories, backfill
+    // origin and list exceptions that exempt nothing. They rewrite authored
+    // sources, so the schema upgrade (which performs them too) depends on them
+    // and one sync recompiles the result.
+    const currentSchemaVersion = status?.schemaStatus?.currentVersion ??
+        readKbManifest(workspaceRoot)?.schemaVersion ??
+        null;
+    const fragment = buildSchema6MigrationFragment({
+        workspaceRoot,
+        currentSchemaVersion,
+    });
+    const fragmentActions = [...fragment.actions];
+    const statusActions = status?.migrationPlan?.actions ?? [];
+    const schemaUpgrade = statusActions.find((action) => action.id === "schema-config-upgrade");
+    if (schemaUpgrade !== undefined &&
+        fragment.sourceRewriteActionIds.length > 0) {
+        fragmentActions.push(migrationAction({
+            ...schemaUpgrade,
+            dependsOn: [
+                ...schemaUpgrade.dependsOn,
+                ...fragment.sourceRewriteActionIds,
+            ],
+        }));
+    }
+    const unsafeDrift = fragment.actions.some((action) => action.code === "semantic_inventory_review");
+    if (!unsafeDrift &&
+        (fragment.sourceRewriteActionIds.length > 0 || schemaUpgrade !== undefined)) {
+        fragmentActions.push(migrationSyncAction([
+            ...fragment.sourceRewriteActionIds,
+            ...statusActions
+                .filter((action) => action.safety === "automatic")
+                .map((action) => action.id),
+        ]));
+    }
+    // A check needs a compiled store: a never-synced store reports every
+    // authored relationship as missing. A schema 5 store compiles the same
+    // facts as schema 6, so its check findings are planned before the upgrade.
     const storeHealthy = status?.branchStore?.state === "healthy";
-    const schemaCurrent = status?.schemaStatus?.needsMigration !== true;
-    if (storeHealthy &&
-        schemaCurrent &&
-        status?.branchAttachment?.kind === "exact") {
+    const schemaCheckable = status?.schemaStatus?.needsMigration !== true ||
+        (currentSchemaVersion !== null &&
+            currentSchemaVersion >= ORIGIN_SCHEMA_VERSION - 1);
+    const storeSynced = status?.snapshotId !== "missing";
+    const checkable = storeHealthy &&
+        schemaCheckable &&
+        status?.branchAttachment?.kind === "exact";
+    if (checkable && storeSynced) {
         const checkResult = await executeOperation(runtime, checkSpec, {});
         if (checkResult.structuredContent?.migrationPlan !== undefined) {
-            plans.push(checkResult.structuredContent.migrationPlan);
+            // Lifecycle repairs and their sync are planned above from authored
+            // sources, which may be newer than the compiled store.
+            plans.push(withoutActionCodes(checkResult.structuredContent.migrationPlan, SOURCE_PLANNED_LIFECYCLE_CODES));
         }
         const coverageInputs = [
             { by: "req", limit: 10_000, offset: 0 },
@@ -450,8 +686,28 @@ async function buildWorkspaceMigrationPlan(workspaceRoot = process.cwd()) {
             }
         }
     }
+    const skippedCheck = checkable && !storeSynced;
+    if (fragmentActions.length > 0 ||
+        fragment.diagnostics.length > 0 ||
+        skippedCheck) {
+        plans.push(buildMigrationPlan({
+            ...(status?.migrationPlan !== undefined
+                ? { expected: status.migrationPlan.expected }
+                : {}),
+            evaluatedDomains: ["schema", "semantic"],
+            incompleteDomains: skippedCheck ? ["quality"] : [],
+            actions: fragmentActions,
+            diagnostics: [
+                ...fragment.diagnostics,
+                ...(skippedCheck
+                    ? [
+                        "kibi check did not run because this branch has never been synced; apply the plan (or run kibi sync) and rerun kibi migrate for quality actions.",
+                    ]
+                    : []),
+            ],
+        }));
+    }
     if (plans.length === 0) {
-        const { buildMigrationPlan } = await import("../public/operations/migration-plan.js");
         return buildMigrationPlan({
             evaluatedDomains: ["package", "branch", "storage", "schema"],
             incompleteDomains: ["status"],
@@ -483,12 +739,23 @@ async function migratePlanCommand(options) {
             console.log("No approved automatic migration actions are ready.");
             return { exitCode: 0 };
         }
-        const [{ createCliRuntime }, { executeOperation }, { applyPlanSpec }] = await Promise.all([
+        const [{ createCliRuntime }, { executeOperation }, { applyPlanSpec }, { withConsoleOnStderr },] = await Promise.all([
             import("../runtime/cli-runtime.js"),
             import("../public/operations/runtime-types.js"),
             import("../public/operations/specs/planning.js"),
+            import("../cli-json-command.js"),
         ]);
-        const result = await executeOperation(createCliRuntime({ workspaceRoot }), applyPlanSpec, { plan, approvedPlanHash: options.approvedPlanHash, approvedActionIds });
+        const approvedPlanHash = options.approvedPlanHash;
+        const execute = () => executeOperation(createCliRuntime({ workspaceRoot }), applyPlanSpec, {
+            plan,
+            approvedPlanHash,
+            approvedActionIds,
+        });
+        // The actions reuse commands that print progress; keep stdout to the
+        // JSON result.
+        const result = options.format === "json"
+            ? await withConsoleOnStderr(execute)
+            : await execute();
         if (options.format === "json") {
             console.log(JSON.stringify(result, null, 2));
         }

package/dist/commands/proof-compact.d.ts

@@ -0,0 +1,9 @@
+export type ProofCompactOptions = Readonly<{
+    test?: string;
+    dryRun?: boolean;
+    json?: boolean;
+}>;
+export declare function proofCompactCommand(options: ProofCompactOptions): Promise<{
+    exitCode: number;
+}>;
+//# sourceMappingURL=proof-compact.d.ts.map

package/dist/commands/proof-compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-compact.d.ts","sourceRoot":"","sources":["../../src/commands/proof-compact.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC,CAAC;AAGH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CA4C/B"}

package/dist/commands/proof-compact.js

@@ -0,0 +1,58 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { executeCompactReceipts } from "../operations/proof/compact-receipts.js";
+import { createCliRuntime } from "../runtime/cli-runtime.js";
+// implements REQ-kibi-fresh-verification-receipts-v2
+export async function proofCompactCommand(options) {
+    const runtime = createCliRuntime();
+    const spec = {
+        name: "kibi_proof_compact",
+        effects: ["kb-mutate", "workspace-write"],
+        requiresProlog: true,
+        execute: async () => undefined,
+    };
+    const context = await runtime.open(spec, {});
+    let completed = false;
+    try {
+        const result = await executeCompactReceipts({
+            ...(options.test === undefined ? {} : { testId: options.test }),
+            ...(options.dryRun === true ? { dryRun: true } : {}),
+        }, context);
+        if (options.json === true) {
+            process.stdout.write(`${JSON.stringify(result.structuredContent, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(`${result.content[0]?.text ?? ""}\n`);
+            for (const row of result.structuredContent.tests) {
+                process.stdout.write(`  ${row.testId}: ${row.before} -> ${row.after} receipt(s)\n`);
+            }
+            for (const row of result.structuredContent.skipped) {
+                process.stdout.write(`  ${row.testId}: skipped (${row.reason})\n`);
+            }
+        }
+        completed = true;
+        if (options.dryRun !== true)
+            await runtime.afterSuccess(spec, context);
+        return { exitCode: 0 };
+    }
+    finally {
+        await runtime.close(context, completed
+            ? { status: "success", result: 0 }
+            : { status: "error", error: 1 });
+    }
+}

package/dist/commands/prove.d.ts

@@ -1,7 +1,9 @@
 import { executeIngestProof } from "../operations/proof/ingest-proof.js";
+import { type ProofRunAttribution } from "../proof/command-test-report.js";
 import type { ProofIntegration } from "../proof/integrations.js";
 import type { OperationRuntime } from "../public/operations/runtime-types.js";
 import { readWorkspaceSnapshot } from "../public/operations/workspace-snapshot.js";
+import { type ProofRunArtifact } from "../public/proof-protocol.js";
 export type ProveCommandOptions = Readonly<{
     testId?: string;
     requirement?: string;
@@ -33,5 +35,41 @@ export declare function commandEnvironment(integration: ProofIntegration, comman
 export declare function proveCommand(options: ProveCommandOptions, deps?: ProveCommandDependencies): Promise<{
     exitCode: number;
 }>;
+/** The artifacts one integration run is evaluated through. */
+export type EvaluatedRun = Readonly<{
+    /** Each artifact is ingested against exactly its own tests. */
+    artifacts: readonly Readonly<{
+        artifact: ProofRunArtifact;
+        testIds: readonly string[];
+    }>[];
+    /** The whole process run, kept when the evidence was partitioned. */
+    wholeRun?: ProofRunArtifact;
+    attribution?: ProofRunAttribution;
+}>;
+/** Read a command integration's optional per-test report and attribute it. */
+export declare function readCommandAttribution(reportPath: string, selectedTestIds: readonly string[], exitCode: number): Promise<ProofRunAttribution>;
+/** Where a partition's evaluated artifact is kept next to the run artifact. */
+export declare function partitionArtifactPath(artifactPath: string, outcome: string): string;
+/**
+ * Build the kibi.proof-run.v1 evidence of a `command` integration run.
+ *
+ * Without per-test attribution the run is one unit, exactly as before: a
+ * failing process fails every selected test. With a valid
+ * kibi.proof-test-report.v1 the run is split into one artifact per test
+ * outcome: tests whose own steps all passed are evaluated against a passing
+ * slice (exit code 0, the aggregate result of their own steps), and each
+ * failing outcome gets a failing slice that names the steps that failed. The
+ * whole-process artifact is kept alongside for audit.
+ */
+export declare function buildCommandRunArtifacts(input: {
+    integration: ProofIntegration;
+    commandArgv: readonly string[];
+    exitCode: number;
+    startedAt: string;
+    finishedAt: string;
+    snapshot: string;
+    tests: readonly SelectedTest[];
+    attribution: ProofRunAttribution;
+}): EvaluatedRun;
 export {};
 //# sourceMappingURL=prove.d.ts.map

package/dist/commands/prove.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prove.d.ts","sourceRoot":"","sources":["../../src/commands/prove.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAEzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AASjE,OAAO,KAAK,EAEV,gBAAgB,EACjB,MAAM,uCAAuC,CAAC;AAE/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC;AAYnF,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC,CAAC;AAGH,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,kBAAkB,CAAC;CACzC,CAAC,CAAC;AAEH,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE5C;;;;;GAKG;AAEH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC,GAC1D,MAAM,CAiBR;AAED;;;;GAIG;AAEH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,QAAQ,EAAE,MAAM,GACf,GAAG,CAAC,MAAM,CAAC,CAUb;AAQD,wBAAgB,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAEjD;AAkCD,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,gBAAgB,EAC7B,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,UAAU,EAAE,MAAM,GACjB,MAAM,CAAC,UAAU,CAWnB;AAsKD,wBAAsB,YAAY,CAChC,OAAO,EAAE,mBAAmB,EAC5B,IAAI,GAAE,wBAA6B,GAClC,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAgL/B"}
+{"version":3,"file":"prove.d.ts","sourceRoot":"","sources":["../../src/commands/prove.ts"],"names":[],"mappings":"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"}