kibi-cli 2.31.1 → 2.35.1

package/dist/operations/migration/evidence-floor.js

@@ -0,0 +1,230 @@
+/*
+ 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 path from "node:path";
+import { effectiveFirmness } from "../../decision-firmness.js";
+import { authoredSupersededIds, isCurrentAuthoredEntity, readAuthoredEntity, } from "../../public/operations/entity-context.js";
+import { readAllShards } from "../../relationships/shards.js";
+import { listLaneMarkdownFiles, readText, withTopLevelField, writeFileAtomically, } from "./kb-sources.js";
+/** Schema 11: record the floor of firm requirements that had no proof path. */
+// implements REQ-kibi-evidence-floors, REQ-cli-schema-migration
+export const EVIDENCE_FLOOR_PIN_CODE = "evidence_floor_pin";
+/** The floor the migration records: a person stands behind the requirement. */
+const PINNED_FLOOR = "asserted";
+function linkTargets(entity, type) {
+    const links = entity.data.links;
+    if (!Array.isArray(links))
+        return [];
+    return links.flatMap((link) => link !== null &&
+        typeof link === "object" &&
+        link.type === type &&
+        typeof link.target === "string"
+        ? [link.target]
+        : []);
+}
+function authoredEntities(workspaceRoot, lane) {
+    const entities = [];
+    for (const file of listLaneMarkdownFiles(workspaceRoot, [lane])) {
+        const content = readText(file.absolutePath);
+        if (content === null)
+            continue;
+        const entity = readAuthoredEntity(content, file.relativePath);
+        if (entity !== null)
+            entities.push({ entity, content, relativePath: file.relativePath });
+    }
+    return entities;
+}
+/**
+ * An end-to-end test with a proof contract whose newest receipt passed: the
+ * least a requirement needs to have been tested, judged on the receipt the
+ * evidence ladder reads. A contract that was never run through kibi prove,
+ * one whose latest run failed, or a unit-scoped one cannot reach tested.
+ */
+function hasPassingProof(entity) {
+    if (entity.data.proof_contract === undefined)
+        return false;
+    if (entity.data.verification_scope !== "end_to_end")
+        return false;
+    const receipts = entity.data.proof_receipts;
+    if (!Array.isArray(receipts) || receipts.length === 0)
+        return false;
+    const latest = receipts.reduce((best, receipt, index) => {
+        if (receipt === null || typeof receipt !== "object")
+            return best;
+        const record = receipt;
+        // Finish times increase strictly; history order is the fallback.
+        const at = typeof record.finished_at === "string"
+            ? record.finished_at
+            : String(index).padStart(12, "0");
+        return best === null || at >= best.at
+            ? { at, outcome: record.outcome }
+            : best;
+    }, null);
+    return latest?.outcome === "passed";
+}
+/**
+ * Requirement ids with a proof path: a linked scenario (specified_by) that an
+ * end-to-end test with a proof contract and a passing receipt verifies
+ * (scenario verified_by test, or test validates scenario), read from authored
+ * links and relationship shards.
+ */
+function requirementsWithProofPath(workspaceRoot, requirements) {
+    const scenariosOf = new Map();
+    const testsOf = new Map();
+    const add = (map, from, to) => {
+        const set = map.get(from) ?? new Set();
+        set.add(to);
+        map.set(from, set);
+    };
+    for (const requirement of requirements)
+        for (const target of linkTargets(requirement, "specified_by"))
+            add(scenariosOf, requirement.id, target);
+    for (const { entity } of authoredEntities(workspaceRoot, "scenarios"))
+        for (const target of linkTargets(entity, "verified_by"))
+            add(testsOf, entity.id, target);
+    const contracted = new Set();
+    for (const { entity } of authoredEntities(workspaceRoot, "tests")) {
+        if (hasPassingProof(entity))
+            contracted.add(entity.id);
+        for (const target of linkTargets(entity, "validates"))
+            add(testsOf, target, entity.id);
+    }
+    try {
+        for (const relationship of readAllShards(path.join(workspaceRoot, ".kb"))) {
+            if (relationship.type === "specified_by")
+                add(scenariosOf, relationship.from, relationship.to);
+            else if (relationship.type === "verified_by")
+                add(testsOf, relationship.from, relationship.to);
+            else if (relationship.type === "validates")
+                add(testsOf, relationship.to, relationship.from);
+        }
+    }
+    catch {
+        // Malformed shards fail sync with their own diagnostic.
+    }
+    const withPath = new Set();
+    for (const [requirementId, scenarios] of scenariosOf)
+        for (const scenarioId of scenarios)
+            for (const testId of testsOf.get(scenarioId) ?? [])
+                if (contracted.has(testId))
+                    withPath.add(requirementId);
+    return withPath;
+}
+/**
+ * Current firm requirements without required_evidence and without a proof
+ * path that has passed. From schema 11 a firm requirement needs tested
+ * evidence, which these have not reached, so the migration records their
+ * floor as asserted in the requirement itself, where a reviewer sees it and
+ * can raise it later. Requirements with a passing proof path keep the tested
+ * floor; `kept` lists them, since remaining gaps (a stale receipt, a missing
+ * covered_by) still show in kibi check. Read-only.
+ */
+// implements REQ-kibi-evidence-floors, REQ-cli-schema-migration
+export function planEvidenceFloorPins(workspaceRoot, ladder) {
+    const files = authoredEntities(workspaceRoot, "requirements").filter(({ entity }) => entity.type === "req");
+    const requirements = files.map(({ entity }) => entity);
+    const superseded = authoredSupersededIds(workspaceRoot, requirements);
+    const withPath = requirementsWithProofPath(workspaceRoot, requirements);
+    const targets = [];
+    const kept = [];
+    const skipped = [];
+    for (const { entity, content, relativePath } of files) {
+        if (entity.data.required_evidence !== undefined ||
+            entity.data.proof_exempt === true ||
+            !isCurrentAuthoredEntity(entity, superseded) ||
+            effectiveFirmness(entity.type, entity.data.firmness, entity.data.origin) !== "firm")
+            continue;
+        // The ladder on the compiled store judges every gap (failed latest
+        // receipts, missing coverage or coordinates), so a requirement it puts
+        // below the tested floor is pinned even with a passing receipt; one
+        // without any authored proof path is pinned whatever the store says,
+        // since the store may predate the authored sources.
+        if (withPath.has(entity.id) && ladder?.get(entity.id) !== "below") {
+            kept.push(entity.id);
+            continue;
+        }
+        const after = withTopLevelField(content, "required_evidence", PINNED_FLOOR);
+        if (after === null) {
+            skipped.push({
+                id: entity.id,
+                path: relativePath,
+                reason: "required_evidence could not be edited safely",
+            });
+            continue;
+        }
+        targets.push({
+            id: entity.id,
+            type: entity.type,
+            path: relativePath,
+            before: content,
+            after,
+        });
+    }
+    return {
+        targets,
+        skipped,
+        kept,
+        decidedBy: ladder === undefined || ladder === null ? "authored" : "ladder",
+    };
+}
+/** Write the planned floors; returns how many requirements were rewritten. */
+// implements REQ-kibi-evidence-floors, REQ-cli-schema-migration
+export function applyEvidenceFloorPins(workspaceRoot, ladder) {
+    const plan = planEvidenceFloorPins(workspaceRoot, ladder);
+    for (const target of plan.targets)
+        writeFileAtomically(path.join(workspaceRoot, target.path), target.after);
+    return plan.targets.length;
+}
+/**
+ * Read the evidence ladder's floor verdicts from the branch's compiled store,
+ * so the migration keeps the tested floor only where kibi check will accept
+ * it. Returns null when no healthy, synced store is attached (never synced,
+ * damaged, another branch's store) or the evaluation fails; the migration
+ * then decides from authored receipts alone and says so.
+ */
+// implements REQ-kibi-evidence-floors, REQ-cli-schema-migration
+export async function readLadderFloorVerdicts(workspaceRoot) {
+    try {
+        const [{ createCliRuntime }, { executeOperation }, { statusSpec }, { readEvidenceFloorRows },] = await Promise.all([
+            import("../../runtime/cli-runtime.js"),
+            import("../../public/operations/runtime-types.js"),
+            import("../../public/operations/specs/discovery.js"),
+            import("../../public/operations/evidence-floor.js"),
+        ]);
+        const runtime = createCliRuntime({ workspaceRoot });
+        const status = (await executeOperation(runtime, statusSpec, {}))
+            .structuredContent;
+        if (status?.branchStore?.state !== "healthy" ||
+            status?.snapshotId === "missing" ||
+            status?.branchAttachment?.kind !== "exact")
+            return null;
+        const rows = await executeOperation(runtime, {
+            name: "kb_migrate_evidence_floor_preview",
+            effects: ["kb-read"],
+            requiresProlog: true,
+            execute: (_input, context) => readEvidenceFloorRows(context),
+        }, {});
+        const verdicts = new Map();
+        for (const row of rows)
+            if (row.requiredEvidence === "tested")
+                verdicts.set(row.id, row.status);
+        return verdicts;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/operations/migration/proof-contract-claims.d.ts

@@ -0,0 +1,72 @@
+import type { BodyContextTarget } from "./entity-body-context.js";
+/** Schema 12: pin proves on a certificate contract with one provable claim. */
+export declare const PROOF_CONTRACT_CLAIMS_PIN_CODE = "proof_contract_claims_pin";
+/** Schema 12: certificate contracts a person must bind to their claims. */
+export declare const PROOF_CONTRACT_CLAIMS_REVIEW_CODE = "proof_contract_claims_review";
+/**
+ * A modeled claim a certificate contract's test reaches, with the binding a
+ * certificate of its kind would get: derived when the claim's fact derives
+ * an obligation for the kind, attested when the fact has no derivation,
+ * incompatible (with the reason) when the kind cannot express it.
+ */
+export type ClaimCandidate = Readonly<{
+    claim_key: string;
+    requirement_id: string;
+    fact_id: string;
+    binding: "derived" | "attested" | "incompatible";
+    reason?: string;
+}>;
+/**
+ * A certificate-kind contract without proves, with every modeled claim of
+ * the requirements its test reaches through its scenarios.
+ */
+export type ClaimCandidateRow = Readonly<{
+    test_id: string;
+    kind: string;
+    candidates: readonly ClaimCandidate[];
+}>;
+export type ProofContractClaimsReview = Readonly<{
+    id: string;
+    path: string;
+    kind: string;
+    candidates: readonly ClaimCandidate[];
+}>;
+export type ProofContractClaimsPlan = Readonly<{
+    targets: readonly BodyContextTarget[];
+    /** Contracts left without proves: no derived claim, or several. */
+    review: readonly ProofContractClaimsReview[];
+    skipped: readonly Readonly<{
+        id: string;
+        path: string;
+        reason: string;
+    }>[];
+}>;
+/**
+ * What a person reviewing a contract without proves has to do, naming every
+ * claim its test reaches and how a certificate of its kind would bind it.
+ */
+export declare function claimReviewInstruction(row: ProofContractClaimsReview): string;
+/**
+ * Add proves to a test's proof_contract block, leaving every other byte of
+ * the document unchanged: the list goes after the block's last line, at the
+ * indentation of its other keys. Returns null when the contract is not a
+ * block mapping, already names proves, or the edit would not read back as
+ * exactly that change.
+ */
+export declare function withProofContractProves(content: string, keys: readonly string[]): string | null;
+/**
+ * Certificate-kind contracts without proves, judged on the synced store: a
+ * contract whose test reaches exactly one claim its kind can derive an
+ * obligation for gets that claim pinned in proves; any other is left for a
+ * person to bind (review). Read-only.
+ */
+export declare function planProofContractClaimPins(workspaceRoot: string, rows: readonly ClaimCandidateRow[] | null): ProofContractClaimsPlan;
+export declare function applyProofContractClaimPins(workspaceRoot: string, rows: readonly ClaimCandidateRow[] | null): ProofContractClaimsPlan;
+/**
+ * The claim candidates of every certificate contract without proves, read
+ * from the branch's compiled store. Returns null when no healthy, synced
+ * store is attached or the evaluation fails; the migration then pins
+ * nothing, and proof-contract-claims lists the contracts.
+ */
+export declare function readProofContractClaimCandidates(workspaceRoot: string): Promise<readonly ClaimCandidateRow[] | null>;
+//# sourceMappingURL=proof-contract-claims.d.ts.map

package/dist/operations/migration/proof-contract-claims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-contract-claims.d.ts","sourceRoot":"","sources":["../../../src/operations/migration/proof-contract-claims.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAQlE,+EAA+E;AAE/E,eAAO,MAAM,8BAA8B,8BAA8B,CAAC;AAE1E,2EAA2E;AAE3E,eAAO,MAAM,iCAAiC,iCAAiC,CAAC;AAEhF;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,SAAS,GAAG,UAAU,GAAG,cAAc,CAAC;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,SAAS,cAAc,EAAE,CAAC;CACvC,CAAC,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAC/C,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,SAAS,cAAc,EAAE,CAAC;CACvC,CAAC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC7C,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACtC,mEAAmE;IACnE,MAAM,EAAE,SAAS,yBAAyB,EAAE,CAAC;IAC7C,OAAO,EAAE,SAAS,QAAQ,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,CAAC;CAC5E,CAAC,CAAC;AAUH;;;GAGG;AAEH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,yBAAyB,GAAG,MAAM,CAiB7E;AAMD;;;;;;GAMG;AAEH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,MAAM,GAAG,IAAI,CAwCf;AAED;;;;;GAKG;AAEH,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,SAAS,iBAAiB,EAAE,GAAG,IAAI,GACxC,uBAAuB,CA+CzB;AAGD,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,SAAS,iBAAiB,EAAE,GAAG,IAAI,GACxC,uBAAuB,CAKzB;AAED;;;;;GAKG;AAEH,wBAAsB,gCAAgC,CACpD,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,SAAS,iBAAiB,EAAE,GAAG,IAAI,CAAC,CA6C9C"}

package/dist/operations/migration/proof-contract-claims.js

@@ -0,0 +1,215 @@
+/*
+ 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 path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { load as loadYaml } from "js-yaml";
+import { readAuthoredEntity } from "../../public/operations/entity-context.js";
+import { listLaneMarkdownFiles, readText, sliceFrontmatter, writeFileAtomically, } from "./kb-sources.js";
+/** Schema 12: pin proves on a certificate contract with one provable claim. */
+// implements REQ-kibi-claim-bound-proofs, REQ-cli-schema-migration
+export const PROOF_CONTRACT_CLAIMS_PIN_CODE = "proof_contract_claims_pin";
+/** Schema 12: certificate contracts a person must bind to their claims. */
+// implements REQ-kibi-claim-bound-proofs, REQ-cli-schema-migration
+export const PROOF_CONTRACT_CLAIMS_REVIEW_CODE = "proof_contract_claims_review";
+function describeCandidate(candidate) {
+    const where = `${candidate.claim_key} (${candidate.requirement_id}, ${candidate.fact_id})`;
+    if (candidate.binding === "derived")
+        return `${where}: provable`;
+    if (candidate.binding === "attested")
+        return `${where}: attested only, the fact has no derivation`;
+    return `${where}: ${candidate.reason ?? "its kind cannot express the fact"}`;
+}
+/**
+ * What a person reviewing a contract without proves has to do, naming every
+ * claim its test reaches and how a certificate of its kind would bind it.
+ */
+// implements REQ-kibi-claim-bound-proofs, REQ-cli-schema-migration
+export function claimReviewInstruction(row) {
+    const factKind = row.kind === "exhaustive" || row.kind === "typecheck"
+        ? "set"
+        : row.kind === "regex"
+            ? "string"
+            : row.kind === "rule" || row.kind === "state_machine"
+                ? "rule, predicate or set"
+                : "numeric";
+    if (row.candidates.length === 0)
+        return `${row.id} (${row.path}) has a ${row.kind} proof contract, but its test reaches no modeled claim through a scenario. Link the test to the scenario of the requirement it proves, then add proof_contract.proves with the claim keys its certificate establishes and run kibi prove --test ${row.id}.`;
+    const derived = row.candidates.filter((c) => c.binding === "derived");
+    const advice = derived.length > 1
+        ? "Add proof_contract.proves with the claim keys its certificate establishes"
+        : `None is provable by a ${row.kind} certificate as modeled: add proof_contract.proves with the claim it establishes (it then counts as attested, not proved), or model that claim's grounding fact as a ${factKind} fact first`;
+    return `${row.id} (${row.path}) has a ${row.kind} proof contract without proves. Claims its test reaches: ${row.candidates.map(describeCandidate).join("; ")}. ${advice}, then run kibi prove --test ${row.id}.`;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * Add proves to a test's proof_contract block, leaving every other byte of
+ * the document unchanged: the list goes after the block's last line, at the
+ * indentation of its other keys. Returns null when the contract is not a
+ * block mapping, already names proves, or the edit would not read back as
+ * exactly that change.
+ */
+// implements REQ-kibi-claim-bound-proofs, REQ-cli-schema-migration
+export function withProofContractProves(content, keys) {
+    const slice = sliceFrontmatter(content);
+    if (slice === null || keys.length === 0)
+        return null;
+    const lines = slice.text.split(/(?<=\n)/);
+    const start = lines.findIndex((line) => /^proof_contract:[ \t]*\r?\n$/.test(line));
+    if (start < 0)
+        return null;
+    let end = start + 1;
+    let indent = null;
+    while (end < lines.length) {
+        const line = lines[end] ?? "";
+        const leading = /^([ \t]+)\S/.exec(line);
+        if (leading === null)
+            break;
+        if (indent === null)
+            indent = leading[1] ?? "";
+        end += 1;
+    }
+    if (indent === null)
+        return null;
+    const inserted = [
+        `${indent}proves:${slice.eol}`,
+        ...keys.map((key) => `${indent}${indent}- ${key}${slice.eol}`),
+    ];
+    const text = [...lines.slice(0, end), ...inserted, ...lines.slice(end)].join("");
+    try {
+        const before = loadYaml(slice.text);
+        const next = loadYaml(text);
+        if (!isRecord(before) || !isRecord(next))
+            return null;
+        const contract = before.proof_contract;
+        if (!isRecord(contract) || contract.proves !== undefined)
+            return null;
+        const expected = {
+            ...before,
+            proof_contract: { ...contract, proves: [...keys] },
+        };
+        if (!isDeepStrictEqual(next, expected))
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return `${slice.prefix}${text}${slice.suffix}`;
+}
+/**
+ * Certificate-kind contracts without proves, judged on the synced store: a
+ * contract whose test reaches exactly one claim its kind can derive an
+ * obligation for gets that claim pinned in proves; any other is left for a
+ * person to bind (review). Read-only.
+ */
+// implements REQ-kibi-claim-bound-proofs, REQ-cli-schema-migration
+export function planProofContractClaimPins(workspaceRoot, rows) {
+    const byTest = new Map((rows ?? []).map((row) => [row.test_id, row]));
+    const targets = [];
+    const review = [];
+    const skipped = [];
+    if (byTest.size === 0)
+        return { targets, review, skipped };
+    for (const file of listLaneMarkdownFiles(workspaceRoot, ["tests"])) {
+        const content = readText(file.absolutePath);
+        if (content === null)
+            continue;
+        const entity = readAuthoredEntity(content, file.relativePath);
+        const row = entity === null ? undefined : byTest.get(entity.id);
+        if (entity === null || row === undefined)
+            continue;
+        const keys = [
+            ...new Set(row.candidates
+                .filter((c) => c.binding === "derived")
+                .map((c) => c.claim_key)),
+        ].sort();
+        if (keys.length !== 1) {
+            review.push({
+                id: entity.id,
+                path: file.relativePath,
+                kind: row.kind,
+                candidates: row.candidates,
+            });
+            continue;
+        }
+        const after = withProofContractProves(content, keys);
+        if (after === null) {
+            skipped.push({
+                id: entity.id,
+                path: file.relativePath,
+                reason: "its proof_contract is not a block mapping Kibi can extend in place",
+            });
+            continue;
+        }
+        targets.push({
+            id: entity.id,
+            type: "test",
+            path: file.relativePath,
+            before: content,
+            after,
+        });
+    }
+    return { targets, review, skipped };
+}
+// implements REQ-kibi-claim-bound-proofs, REQ-cli-schema-migration
+export function applyProofContractClaimPins(workspaceRoot, rows) {
+    const plan = planProofContractClaimPins(workspaceRoot, rows);
+    for (const target of plan.targets)
+        writeFileAtomically(path.join(workspaceRoot, target.path), target.after);
+    return plan;
+}
+/**
+ * The claim candidates of every certificate contract without proves, read
+ * from the branch's compiled store. Returns null when no healthy, synced
+ * store is attached or the evaluation fails; the migration then pins
+ * nothing, and proof-contract-claims lists the contracts.
+ */
+// implements REQ-kibi-claim-bound-proofs, REQ-cli-schema-migration
+export async function readProofContractClaimCandidates(workspaceRoot) {
+    try {
+        const [{ createCliRuntime }, { executeOperation }, { statusSpec }, { runOperationJsonQuery },] = await Promise.all([
+            import("../../runtime/cli-runtime.js"),
+            import("../../public/operations/runtime-types.js"),
+            import("../../public/operations/specs/discovery.js"),
+            import("../../public/operations/prolog-json.js"),
+        ]);
+        const runtime = createCliRuntime({ workspaceRoot });
+        const status = (await executeOperation(runtime, statusSpec, {}))
+            .structuredContent;
+        if (status?.branchStore?.state !== "healthy" ||
+            status?.snapshotId === "missing" ||
+            status?.branchAttachment?.kind !== "exact")
+            return null;
+        const rows = await executeOperation(runtime, {
+            name: "kb_migrate_proof_contract_claims_preview",
+            effects: ["kb-read"],
+            requiresProlog: true,
+            execute: async (_input, context) => {
+                const prolog = context.prolog ?? (await context.ensureProlog?.());
+                if (prolog === undefined)
+                    return [];
+                return runOperationJsonQuery(prolog, "claim_obligations.pl", "claim_obligations:proof_contract_claim_candidates_json(JsonString)", "Proof contract claim candidates");
+            },
+        }, {});
+        return Array.isArray(rows) ? rows : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/operations/migration/schema6.d.ts

@@ -1,5 +1,7 @@
 import { type MigrationAction } from "../../public/operations/migration-plan.js";
 import { CLOSE_SUPERSEDED_REQUIREMENTS_CODE, MIGRATION_SYNC_ACTION_ID, MIGRATION_SYNC_CODE, SOURCE_PATH_REWRITE_CODE } from "../../public/operations/schema6-check-actions.js";
+import { type LadderFloorVerdicts } from "./evidence-floor.js";
+import { type ClaimCandidateRow } from "./proof-contract-claims.js";
 /** The KB schema generation that introduced entity `origin`. */
 export declare const ORIGIN_SCHEMA_VERSION = 6;
 /** The KB schema generation that requires body context on current entities. */
@@ -58,6 +60,10 @@ export type Schema6MigrationFragment = Readonly<{
 export declare function buildSchema6MigrationFragment(input: {
     workspaceRoot: string;
     currentSchemaVersion: number | null;
+    /** The evidence ladder's floor verdicts on the synced store, when read. */
+    ladderFloors?: LadderFloorVerdicts | null;
+    /** Claim candidates of certificate contracts without proves, when read. */
+    claimCandidates?: readonly ClaimCandidateRow[] | null;
 }): Schema6MigrationFragment;
 /**
  * Actions for the superseded-requirement-open and source-path-dangling

package/dist/operations/migration/schema6.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema6.d.ts","sourceRoot":"","sources":["../../../src/operations/migration/schema6.ts"],"names":[],"mappings":"AAwBA,OAAO,EACL,KAAK,eAAe,EAErB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAEL,kCAAkC,EAClC,wBAAwB,EACxB,mBAAmB,EAEnB,wBAAwB,EAOzB,MAAM,kDAAkD,CAAC;AAwE1D,gEAAgE;AAEhE,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC,+EAA+E;AAE/E,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C,4DAA4D;AAE5D,eAAO,MAAM,gCAAgC,IAAI,CAAC;AAElD,yEAAyE;AAEzE,eAAO,MAAM,gCAAgC,gCAAgC,CAAC;AAC9E,gEAAgE;AAEhE,eAAO,MAAM,8BAA8B,8BAA8B,CAAC;AAC1E;;;GAGG;AAEH,eAAO,MAAM,+CAA+C,+CACd,CAAC;AAC/C,iFAAiF;AAEjF,eAAO,MAAM,8BAA8B,8BAA8B,CAAC;AAC1E,+EAA+E;AAE/E,eAAO,MAAM,6BAA6B,6BAA6B,CAAC;AAExE,eAAO,MAAM,kCAAkC,6BAA6B,CAAC;AAC7E,yEAAyE;AAEzE,eAAO,MAAM,2BAA2B,2BAA2B,CAAC;AAEpE,eAAO,MAAM,gCAAgC,2BAA2B,CAAC;AACzE,OAAO,EACL,kCAAkC,EAClC,wBAAwB,EACxB,mBAAmB,EACnB,wBAAwB,GACzB,CAAC;AAiNF;;;;;;;GAOG;AAEH,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,MAAM,GACpB,eAAe,EAAE,CAkFnB;AAyBD;;;GAGG;AAEH,wBAAgB,+BAA+B,CAC7C,aAAa,EAAE,MAAM,GACpB,KAAK,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAsDnE;AAGD,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;IACpC,uDAAuD;IACvD,sBAAsB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC,CAAC,CAAC;AAEH;;;;;;GAMG;AAEH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE;IACnD,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC,GAAG,wBAAwB,CA0R3B;AAED;;;;;;GAMG;AAEH,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG;IAClE,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,sBAAsB,EAAE,MAAM,EAAE,CAAC;CAClC,CAuCA;AAED;;;GAGG;AAEH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,GACpB,eAAe,GAAG,IAAI,CAuBxB;AAED,qEAAqE;AAErE,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,eAAe,CAEjB;AAgDD,KAAK,YAAY,GAAG,QAAQ,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC,CAAC;AAEH,4DAA4D;AAE5D,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,IAAI,CAAC,CAkJf;AAED;;;GAGG;AAEH,eAAO,MAAM,+BAA+B,EAAE,WAAW,CAAC,MAAM,CAK9D,CAAC;AAGH,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,MAAM,CActD,CAAC"}
+{"version":3,"file":"schema6.d.ts","sourceRoot":"","sources":["../../../src/operations/migration/schema6.ts"],"names":[],"mappings":"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"}