kibi-cli 2.30.0 → 2.31.1

package/dist/cli-operation-metadata.d.ts

@@ -39,7 +39,7 @@ export declare const CLI_OPERATION_METADATA: readonly [{
 }, {
     readonly name: "kb_coverage";
     readonly cliName: "coverage";
-    readonly description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Use it to ask which requirements are proven and what blocks the rest; use kb_find_gaps for a plain list of missing links and kb_check for rule violations. Reports include the compatible repair plan plus typed kibi.migration-plan.v2 actions; semantic and E2E actions remain review/execution work. Paginated plans identify incomplete scope and no mutation occurs.";
+    readonly description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Use it to ask which requirements are tested end to end, how strong each requirement's evidence is (evidenceLevel: proved, tested, asserted or unverified), and what blocks the rest; use kb_find_gaps for a plain list of missing links and kb_check for rule violations. Reports include the compatible repair plan plus typed kibi.migration-plan.v2 actions; semantic and E2E actions remain review/execution work. Paginated plans identify incomplete scope and no mutation occurs.";
 }, {
     readonly name: "kb_graph";
     readonly cliName: "graph";

package/dist/cli-operation-metadata.js

@@ -45,7 +45,7 @@ export const CLI_OPERATION_METADATA = [
     {
         name: "kb_coverage",
         cliName: "coverage",
-        description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Use it to ask which requirements are proven and what blocks the rest; use kb_find_gaps for a plain list of missing links and kb_check for rule violations. Reports include the compatible repair plan plus typed kibi.migration-plan.v2 actions; semantic and E2E actions remain review/execution work. Paginated plans identify incomplete scope and no mutation occurs.",
+        description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Use it to ask which requirements are tested end to end, how strong each requirement's evidence is (evidenceLevel: proved, tested, asserted or unverified), and what blocks the rest; use kb_find_gaps for a plain list of missing links and kb_check for rule violations. Reports include the compatible repair plan plus typed kibi.migration-plan.v2 actions; semantic and E2E actions remain review/execution work. Paginated plans identify incomplete scope and no mutation occurs.",
     },
     {
         name: "kb_graph",

package/dist/cli-register-reporting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-register-reporting.d.ts","sourceRoot":"","sources":["../src/cli-register-reporting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYzC,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAkOhE"}
+{"version":3,"file":"cli-register-reporting.d.ts","sourceRoot":"","sources":["../src/cli-register-reporting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYzC,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA+QhE"}

package/dist/cli-register-reporting.js

@@ -65,7 +65,7 @@ export function registerReportingCommands(program) {
         .option("--by <group>", "Coverage mode: req|symbol|type", "req")
         .option("--tag <tags>", "Comma-separated tag filter")
         .option("--include-passing", "Include passing rows", false)
-        .option("--status <statuses>", "Comma-separated requirement proof-status filter (proven, missing, unresolved, not_applicable); implies include-passing")
+        .option("--status <statuses>", "Comma-separated requirement proof-status filter (tested, missing, unresolved, not_applicable); implies include-passing")
         .option("--no-include-transitive", "Disable transitive symbol coverage")
         .option("--limit <n>", "Limit results", "100")
         .option("--offset <n>", "Skip results", "0")
@@ -120,6 +120,8 @@ export function registerReportingCommands(program) {
         .option("--min-links <n>", "Minimum number of links required for symbol coverage", "1")
         .option("--dry-run", "Do not modify files; only print what would happen")
         .option("--format <format>", "Output format: text|json", "text")
+        .option("--write-certificates <file>", "Also save the kibi.certificates.v1 bundle the kb-consistency rule re-checked")
+        .option("--certificates <file>", "Only re-check a saved kibi.certificates.v1 bundle against the current KB with the independent checker")
         .action(withExitCode(async (options, command) => {
         if (options.input !== undefined) {
             await runJsonInvocation({
@@ -129,7 +131,26 @@ export function registerReportingCommands(program) {
             });
             return undefined;
         }
-        return (await import("./commands/check.js")).checkCommand(options);
+        // implements REQ-kibi-kb-certificates
+        if (options.certificates !== undefined) {
+            if (options.writeCertificates !== undefined ||
+                options.staged ||
+                options.rules !== undefined)
+                throw new Error("check: --certificates only re-checks a saved bundle; it cannot be combined with --write-certificates, --staged or --rules");
+            return (await import("./commands/check-certificates.js")).checkCertificatesCommand({
+                certificates: options.certificates,
+                json: options.format === "json",
+            });
+        }
+        if (options.writeCertificates !== undefined && options.staged)
+            throw new Error("check: --write-certificates saves the full KB's bundle; it cannot be combined with --staged");
+        const { writeCertificates, ...checkOptions } = options;
+        const result = await (await import("./commands/check.js")).checkCommand(checkOptions);
+        if (writeCertificates !== undefined) {
+            const saved = await (await import("./commands/check-certificates.js")).writeCertificates(writeCertificates);
+            process.stderr.write(`Saved ${saved.certificates} certificate(s) to ${saved.path}\n`);
+        }
+        return result;
     }));
     program
         .command("check-diff")

package/dist/commands/check-certificates.d.ts

@@ -0,0 +1,52 @@
+import type { OperationContext } from "../public/operations/runtime-types.js";
+type TheoremReport = Readonly<{
+    theorem: string;
+    verdict: "proved" | "disproved" | "unresolved";
+    groups?: number;
+    models?: number;
+    contradictions?: readonly unknown[];
+    unresolved?: readonly unknown[];
+    predicates?: number;
+    edges?: number;
+}>;
+type RejectedCertificate = Readonly<{
+    certificate: number;
+    kind: string;
+    reason: string;
+    group?: unknown;
+}>;
+export type VerificationReport = Readonly<{
+    version: string;
+    status: "verified" | "rejected";
+    certificates: number;
+    verified: number;
+    rejected: readonly RejectedCertificate[];
+    theorems: readonly TheoremReport[];
+    notCovered: readonly string[];
+}>;
+/**
+ * The exit code for re-checking a saved bundle: 0 only when every certificate
+ * re-verifies and no theorem is disproved. An unresolved theorem does not
+ * fail the run; it is reported and never counts as proved.
+ */
+export declare function certificatesExitCode(report: VerificationReport): 0 | 1;
+export declare function renderVerification(report: VerificationReport): string;
+/** Re-check a saved kibi.certificates.v1 bundle against the current KB. */
+export declare function recheckCertificates(bundlePath: string, context: OperationContext): Promise<VerificationReport>;
+/** `kibi check --certificates <file>`: print the re-check report. */
+export declare function checkCertificatesCommand(options: {
+    certificates: string;
+    json?: boolean;
+}): Promise<{
+    exitCode: number;
+}>;
+/**
+ * `kibi check --write-certificates <file>`: save the bundle the
+ * kb-consistency rule re-checked, so another checker can re-check it.
+ */
+export declare function writeCertificates(bundlePath: string): Promise<{
+    path: string;
+    certificates: number;
+}>;
+export {};
+//# sourceMappingURL=check-certificates.d.ts.map

package/dist/commands/check-certificates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-certificates.d.ts","sourceRoot":"","sources":["../../src/commands/check-certificates.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAG9E,KAAK,aAAa,GAAG,QAAQ,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,QAAQ,GAAG,WAAW,GAAG,YAAY,CAAC;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACpC,UAAU,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC,CAAC;AAEH,KAAK,mBAAmB,GAAG,QAAQ,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC,CAAC;AAGH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACzC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;IACnC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B,CAAC,CAAC;AA+BH;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,kBAAkB,GAAG,CAAC,GAAG,CAAC,CAKtE;AA4BD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CA4CrE;AAsCD,2EAA2E;AAC3E,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,kBAAkB,CAAC,CAQ7B;AAGD,qEAAqE;AACrE,wBAAsB,wBAAwB,CAAC,OAAO,EAAE;IACtD,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAUhC;AAGD;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;IACnE,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC,CAUD"}

package/dist/commands/check-certificates.js

@@ -0,0 +1,163 @@
+/*
+ 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.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { escapeAtom } from "../prolog/codec.js";
+import { runOperationJsonQuery } from "../public/operations/prolog-json.js";
+import { createCliRuntime } from "../runtime/cli-runtime.js";
+const THEOREM_LABELS = {
+    properties_consistent: "Property facts are consistent",
+    predicates_consistent: "Predicate facts are consistent",
+    decisions_consistent: "Allow/deny decisions are consistent",
+    rules_stratified: "Stored rules are stratified",
+};
+const NOT_COVERED_LABELS = {
+    rule_conflicts: "opposing rule pairs (kibi check domain-contradictions)",
+    scenario_feasibility: "scenario feasibility (kibi check scenario-feasibility)",
+};
+function assertReadableBundle(filePath) {
+    if (!existsSync(filePath)) {
+        throw new Error(`check: no certificate bundle at ${filePath}`);
+    }
+    try {
+        JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch {
+        throw new Error(`check: ${filePath} is not valid JSON`);
+    }
+}
+function prologPath(filePath) {
+    return escapeAtom(path.resolve(filePath).replaceAll("\\", "/"));
+}
+// implements REQ-kibi-kb-certificates
+/**
+ * The exit code for re-checking a saved bundle: 0 only when every certificate
+ * re-verifies and no theorem is disproved. An unresolved theorem does not
+ * fail the run; it is reported and never counts as proved.
+ */
+export function certificatesExitCode(report) {
+    if (report.status !== "verified")
+        return 1;
+    return report.theorems.some((theorem) => theorem.verdict === "disproved")
+        ? 1
+        : 0;
+}
+function describeGroup(entry) {
+    if (entry === null || typeof entry !== "object")
+        return String(entry);
+    const record = entry;
+    if (typeof record.subjectKey === "string") {
+        const scope = typeof record.scope === "string" && record.scope !== ""
+            ? ` (scope ${record.scope})`
+            : "";
+        const reason = typeof record.reason === "string" ? `: ${record.reason}` : "";
+        return `${record.subjectKey}.${String(record.propertyKey)}${scope}${reason}`;
+    }
+    if (typeof record.name === "string") {
+        const args = Array.isArray(record.args)
+            ? record.args
+            : Array.isArray(record.key)
+                ? record.key
+                : [];
+        const reason = typeof record.reason === "string" ? `: ${record.reason}` : "";
+        return `${String(record.namespace)}:${record.name}(${args.join(", ")})${reason}`;
+    }
+    return JSON.stringify(entry);
+}
+// implements REQ-kibi-kb-certificates
+export function renderVerification(report) {
+    const lines = [];
+    lines.push(report.status === "verified"
+        ? `Kibi certificates: all ${report.certificates} re-verified`
+        : `Kibi certificates: ${report.rejected.length} problem(s); ${report.verified} of ${report.certificates} certificates re-verified`);
+    lines.push("");
+    for (const theorem of report.theorems) {
+        const label = THEOREM_LABELS[theorem.theorem] ?? theorem.theorem;
+        const detail = theorem.theorem === "rules_stratified"
+            ? `${theorem.predicates ?? 0} predicates, ${theorem.edges ?? 0} dependencies`
+            : (theorem.groups ?? 0) === 0
+                ? "no facts of this kind"
+                : `${theorem.models ?? 0} of ${theorem.groups ?? 0} groups have a model`;
+        lines.push(`- ${label}: ${theorem.verdict} (${detail})`);
+        for (const contradiction of theorem.contradictions ?? []) {
+            lines.push(`    contradiction: ${describeGroup(contradiction)}`);
+        }
+        for (const unresolved of theorem.unresolved ?? []) {
+            lines.push(`    unresolved: ${describeGroup(unresolved)}`);
+        }
+    }
+    if (report.rejected.length > 0) {
+        lines.push("");
+        lines.push("Rejected:");
+        for (const rejected of report.rejected) {
+            const where = rejected.certificate > 0
+                ? `certificate ${rejected.certificate} (${rejected.kind})`
+                : describeGroup(rejected.group ?? rejected.kind);
+            lines.push(`- ${where}: ${rejected.reason}`);
+        }
+    }
+    if (report.notCovered.length > 0) {
+        lines.push("");
+        lines.push(`Not certified yet: ${report.notCovered
+            .map((name) => NOT_COVERED_LABELS[name] ?? name)
+            .join("; ")}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+async function withEngine(run) {
+    const runtime = createCliRuntime();
+    const context = await runtime.open({
+        name: "kibi_check_certificates",
+        effects: [],
+        requiresProlog: true,
+        execute: async () => undefined,
+    }, {});
+    let completed = false;
+    try {
+        const result = await run(context);
+        completed = true;
+        return result;
+    }
+    finally {
+        await runtime.close(context, completed
+            ? { status: "success", result: 0 }
+            : { status: "error", error: 1 });
+    }
+}
+function prologOf(context) {
+    if (context.prolog === undefined) {
+        throw new Error("check: the Kibi engine is not available");
+    }
+    return context.prolog;
+}
+// implements REQ-kibi-kb-certificates
+/** Re-check a saved kibi.certificates.v1 bundle against the current KB. */
+export async function recheckCertificates(bundlePath, context) {
+    assertReadableBundle(bundlePath);
+    return await runOperationJsonQuery(prologOf(context), "certificate_check.pl", `certificate_check:kb_verify_certificates_file('${prologPath(bundlePath)}', JsonString)`, "Certificate verification");
+}
+// implements REQ-kibi-kb-certificates
+/** `kibi check --certificates <file>`: print the re-check report. */
+export async function checkCertificatesCommand(options) {
+    const report = await withEngine((context) => recheckCertificates(options.certificates, context));
+    process.stdout.write(options.json
+        ? `${JSON.stringify(report, null, 2)}\n`
+        : renderVerification(report));
+    return { exitCode: certificatesExitCode(report) };
+}
+// implements REQ-kibi-kb-certificates
+/**
+ * `kibi check --write-certificates <file>`: save the bundle the
+ * kb-consistency rule re-checked, so another checker can re-check it.
+ */
+export async function writeCertificates(bundlePath) {
+    const target = path.resolve(bundlePath);
+    return await withEngine((context) => runOperationJsonQuery(prologOf(context), "certificates.pl", `certificates:kb_write_certificates('${prologPath(target)}', JsonString)`, "Certificate generation"));
+}

package/dist/commands/discovery-table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery-table.d.ts","sourceRoot":"","sources":["../../src/commands/discovery-table.ts"],"names":[],"mappings":"AAIA,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAmCvE;AA4ED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACzC,MAAM,CA4ER"}
+{"version":3,"file":"discovery-table.d.ts","sourceRoot":"","sources":["../../src/commands/discovery-table.ts"],"names":[],"mappings":"AAIA,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAmCvE;AA4ED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACzC,MAAM,CA+ER"}

package/dist/commands/discovery-table.js

@@ -87,9 +87,10 @@ export function renderCoverageTable(payload) {
     const summaryTable = new Table({
         head: ["Metric", "Value"],
         colWidths: [24, 16],
+        wordWrap: true,
     });
     for (const [key, value] of Object.entries(summary)) {
-        summaryTable.push([key, stringifyCell(value)]);
+        summaryTable.push([key, summaryCell(value)]);
     }
     const firstRow = firstFields(rows);
     const isRequirementCoverage = firstRow !== undefined && Object.hasOwn(firstRow, "scenarioCount");
@@ -102,13 +103,14 @@ export function renderCoverageTable(payload) {
                 "Coverage",
                 "Depth",
                 "Proof",
+                "Evidence",
                 "Scen",
                 "Tests",
                 "Symbols",
                 "Structural gaps",
                 "Proof gaps",
             ],
-            colWidths: [20, 12, 12, 18, 36, 12, 8, 8, 10, 24, 36],
+            colWidths: [20, 12, 12, 18, 36, 12, 12, 8, 8, 10, 24, 36],
             wordWrap: true,
         })
         : new Table({
@@ -126,6 +128,7 @@ export function renderCoverageTable(payload) {
                 stringifyCell(item.coverageStatus),
                 stringifyCell(item.coverageDepth),
                 stringifyCell(item.proofStatus),
+                stringifyCell(item.evidenceLevel),
                 stringifyCell(item.scenarioCount),
                 stringifyCell(item.testCount),
                 stringifyCell(item.transitiveSymbolCount),
@@ -287,6 +290,15 @@ function stringifyCell(value) {
     }
     return String(value);
 }
+// A nested summary count, such as evidenceLevels, reads as key=value pairs.
+function summaryCell(value) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        return Object.entries(value)
+            .map(([key, count]) => `${key}=${stringifyCell(count)}`)
+            .join(" ");
+    }
+    return stringifyCell(value);
+}
 function joinCells(value) {
     if (!Array.isArray(value) || value.length === 0) {
         return "-";

package/dist/commands/report.js

@@ -170,16 +170,16 @@ export async function reportCommand(options, deps = {}) {
     const summary = coverage.requirements.summary;
     const total = Number(summary.total ?? 0);
     const notApplicable = Number(summary.proofNotApplicable ?? 0);
-    const proven = Number(summary.proofProven ?? 0);
+    const tested = Number(summary.proofTested ?? 0);
     const currentRequirements = Math.max(0, total - notApplicable);
     const proofPercent = currentRequirements === 0
         ? 0
-        : Math.round((proven / currentRequirements) * 100);
+        : Math.round((tested / currentRequirements) * 100);
     const hasContradiction = coverage.requirements.rows.some((row) => Array.isArray(row.proofGaps) &&
         row.proofGaps.includes("blocking_contradiction"));
     const snapshotStale = coverage.requirements.meta?.dirty === true ||
         coverage.requirements.meta?.proofSnapshotDirty === true;
-    const badgeMessage = currentRequirements === 0 ? "no requirements" : `${proofPercent}% proven`;
+    const badgeMessage = currentRequirements === 0 ? "no requirements" : `${proofPercent}% tested`;
     const badgeColor = currentRequirements === 0
         ? KIBI_BRAND.rail
         : hasContradiction

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

@@ -1 +1 @@
-{"version":3,"file":"signoff.d.ts","sourceRoot":"","sources":["../../src/commands/signoff.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,kBAAkB,EAKxB,MAAM,uBAAuB,CAAC;AAQ/B,OAAO,EAKL,KAAK,WAAW,EACjB,MAAM,qBAAqB,CAAC;AAG7B,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC,CAAC;AAGH,MAAM,MAAM,kBAAkB,GAAG,kBAAkB,GACjD,QAAQ,CAAC;IACP,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAClD,CAAC,CAAC;AAKL,iFAAiF;AACjF,eAAO,MAAM,kBAAkB,wBAAwB,CAAC;AAGxD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAGnE;AAoFD;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,cAAc,EACvB,IAAI,GAAE,kBAAuB,GAC5B,OAAO,CAAC,WAAW,CAAC,CA4EtB"}
+{"version":3,"file":"signoff.d.ts","sourceRoot":"","sources":["../../src/commands/signoff.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,kBAAkB,EAKxB,MAAM,uBAAuB,CAAC;AAQ/B,OAAO,EAKL,KAAK,WAAW,EACjB,MAAM,qBAAqB,CAAC;AAG7B,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC,CAAC;AAGH,MAAM,MAAM,kBAAkB,GAAG,kBAAkB,GACjD,QAAQ,CAAC;IACP,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAClD,CAAC,CAAC;AAKL,iFAAiF;AACjF,eAAO,MAAM,kBAAkB,wBAAwB,CAAC;AAGxD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAGnE;AAuFD;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,cAAc,EACvB,IAAI,GAAE,kBAAuB,GAC5B,OAAO,CAAC,WAAW,CAAC,CA4EtB"}

package/dist/commands/signoff.js

@@ -75,6 +75,9 @@ async function loadProof() {
             status: typeof row.proofStatus === "string" ? row.proofStatus : "missing",
             gate: earliestUnmetGate(row),
             testCount: typeof row.testCount === "number" ? row.testCount : 0,
+            ...(typeof row.evidenceLevel === "string"
+                ? { evidenceLevel: row.evidenceLevel }
+                : {}),
             contradictions: conflicts
                 .map(record)
                 .filter((conflict) => conflict.status === "contradiction")
@@ -133,7 +136,7 @@ export async function signoffCommand(options, deps = {}) {
     else if (format === "chat") {
         write(`${renderSignoffChatMarkdown(view)}\n`);
         // The page path goes to stderr so stdout stays pasteable as the reply.
-        (deps.writeNote ?? ((text) => process.stderr.write(text)))(`Kibi signoff page: ${path.join(cwd, SIGNOFF_LATEST_HTML)} (attach or publish it next to the reply when the host can show a page)\n`);
+        (deps.writeNote ?? ((text) => process.stderr.write(text)))(`Kibi signoff page: ${path.join(cwd, SIGNOFF_LATEST_HTML)} (publish it as a rendered page, such as a Claude Artifact, when the host has a page tool; an attached .html file shows as raw source in chat apps)\n`);
     }
     else {
         const target = options.output?.trim()

package/dist/operations/planning/apply-plan.js

@@ -2265,13 +2265,13 @@ async function applyMigrationPlan(args, context, onCommitted = () => undefined)
             : finalStatus.proofSnapshotDirty === false
                 ? "fresh"
                 : "not_evaluated";
-    const proven = coverageSummary?.proofProven;
+    const tested = coverageSummary?.proofTested;
     const missing = coverageSummary?.proofMissing;
-    const proofState = typeof proven !== "number" || typeof missing !== "number"
+    const proofState = typeof tested !== "number" || typeof missing !== "number"
         ? "not_evaluated"
-        : proven > 0 && missing === 0
-            ? "proven"
-            : proven > 0
+        : tested > 0 && missing === 0
+            ? "tested"
+            : tested > 0
                 ? "mixed"
                 : "unresolved";
     const payload = {

package/dist/operations/proof/baseline-diff.d.ts

@@ -1,4 +1,4 @@
-export declare const PROOF_BASELINE_VERSION = "kibi.proof-baseline.v2";
+export declare const PROOF_BASELINE_VERSION = "kibi.proof-baseline.v3";
 export type RequirementFingerprint = {
     readonly proofStatus: string;
     readonly gaps: readonly string[];

package/dist/operations/proof/baseline-diff.js

@@ -8,7 +8,7 @@
  (at your option) any later version.
  */
 // implements REQ-kibi-verification-evidence-contract
-export const PROOF_BASELINE_VERSION = "kibi.proof-baseline.v2";
+export const PROOF_BASELINE_VERSION = "kibi.proof-baseline.v3";
 function asStringArray(value) {
     if (!Array.isArray(value))
         return [];

package/dist/operations/proof/impact.d.ts

@@ -5,8 +5,8 @@ export type ProofBaselineFile = {
     readonly version?: string;
     readonly mode?: string;
     readonly currentRequirements?: number;
-    readonly proofProven?: number;
-    readonly currentUnproven?: number;
+    readonly proofTested?: number;
+    readonly currentUntested?: number;
     readonly trackedGaps?: Record<string, number>;
     readonly requirements?: RequirementFingerprints;
 };
@@ -14,8 +14,8 @@ export type ProofImpactResult = {
     readonly comparisonTarget: typeof COMMITTED_BASELINE_PATH;
     readonly baselineVersion: string;
     readonly currentRequirements: number;
-    readonly proofProven: number;
-    readonly currentUnproven: number;
+    readonly proofTested: number;
+    readonly currentUntested: number;
     readonly changes: ReturnType<typeof diffFingerprints>;
 };
 export type ReadCommittedFile = (workspaceRoot: string, relativePath: string) => string | Promise<string>;
@@ -27,6 +27,12 @@ export type ProofImpactExecuteOptions = {
 };
 export declare function readCommittedHeadFile(workspaceRoot: string, relativePath: string): string;
 export declare function loadCommittedBaseline(workspaceRoot: string, readCommittedFile?: ReadCommittedFile): Promise<ProofBaselineFile>;
+/**
+ * A baseline committed before kibi.proof-baseline.v3 records a fully tested
+ * requirement as `proven`. Read it as `tested`, so the comparison shows real
+ * changes instead of a rename on every row.
+ */
+export declare function upgradeBaselineStatuses(baseline: ProofBaselineFile): ProofBaselineFile;
 /** Diagnostic only: successful evaluation always exits 0. Ratchet lives in check-proof-baseline.mjs. */
 export declare function proofImpactExitCode(_result: ProofImpactResult): 0;
 export declare function buildProofImpact(baseline: ProofBaselineFile, coverage: {

package/dist/operations/proof/impact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"impact.d.ts","sourceRoot":"","sources":["../../../src/operations/proof/impact.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAEjF,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,gBAAgB,EAGjB,MAAM,oBAAoB,CAAC;AAG5B,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAE7D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,QAAQ,CAAC,YAAY,CAAC,EAAE,uBAAuB,CAAC;CACjD,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,gBAAgB,EAAE,OAAO,uBAAuB,CAAC;IAC1D,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;CACvD,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAC9B,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,KACjB,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAE9B,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IAC/C,QAAQ,CAAC,YAAY,CAAC,EAAE,CACtB,OAAO,EAAE,gBAAgB,KACtB,OAAO,CAAC;QAAE,iBAAiB,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAC9C,CAAC;AAgDF,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,GACnB,MAAM,CAcR;AAGD,wBAAsB,qBAAqB,CACzC,aAAa,EAAE,MAAM,EACrB,iBAAiB,GAAE,iBAAyC,GAC3D,OAAO,CAAC,iBAAiB,CAAC,CAS5B;AAED,wGAAwG;AACxG,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,iBAAiB,GAAG,CAAC,CAEjE;AAGD,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9D;IAAE,MAAM,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,eAAe,EAAE,CAAA;CAAE,CAuBxD;AAGD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,iBAAiB,EACzB,IAAI,EAAE,SAAS,eAAe,EAAE,GAC/B,MAAM,CAYR;AAGD,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC;IACT,MAAM,EAAE,iBAAiB,CAAC;IAC1B,IAAI,EAAE,eAAe,EAAE,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,CAmBD"}
+{"version":3,"file":"impact.d.ts","sourceRoot":"","sources":["../../../src/operations/proof/impact.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAEjF,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,uBAAuB,EAC5B,gBAAgB,EAGjB,MAAM,oBAAoB,CAAC;AAG5B,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAE7D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,QAAQ,CAAC,YAAY,CAAC,EAAE,uBAAuB,CAAC;CACjD,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,gBAAgB,EAAE,OAAO,uBAAuB,CAAC;IAC1D,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;CACvD,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAC9B,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,KACjB,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAE9B,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IAC/C,QAAQ,CAAC,YAAY,CAAC,EAAE,CACtB,OAAO,EAAE,gBAAgB,KACtB,OAAO,CAAC;QAAE,iBAAiB,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAC9C,CAAC;AAgDF,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,GACnB,MAAM,CAcR;AAGD,wBAAsB,qBAAqB,CACzC,aAAa,EAAE,MAAM,EACrB,iBAAiB,GAAE,iBAAyC,GAC3D,OAAO,CAAC,iBAAiB,CAAC,CAW5B;AAED;;;;GAIG;AAEH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,iBAAiB,GAC1B,iBAAiB,CAUnB;AAED,wGAAwG;AACxG,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,iBAAiB,GAAG,CAAC,CAEjE;AAGD,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9D;IAAE,MAAM,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,eAAe,EAAE,CAAA;CAAE,CAuBxD;AAGD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,iBAAiB,EACzB,IAAI,EAAE,SAAS,eAAe,EAAE,GAC/B,MAAM,CAYR;AAGD,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC;IACT,MAAM,EAAE,iBAAiB,CAAC;IAC1B,IAAI,EAAE,eAAe,EAAE,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC,CAmBD"}

package/dist/operations/proof/impact.js

@@ -58,12 +58,32 @@ export function readCommittedHeadFile(workspaceRoot, relativePath) {
 // implements REQ-kibi-verification-evidence-contract
 export async function loadCommittedBaseline(workspaceRoot, readCommittedFile = readCommittedHeadFile) {
     const raw = await readCommittedFile(workspaceRoot, COMMITTED_BASELINE_PATH);
+    let parsed;
     try {
-        return JSON.parse(raw);
+        parsed = JSON.parse(raw);
     }
     catch {
         throw new Error(`proof impact: HEAD:${COMMITTED_BASELINE_PATH} is not valid JSON`);
     }
+    return upgradeBaselineStatuses(parsed);
+}
+/**
+ * A baseline committed before kibi.proof-baseline.v3 records a fully tested
+ * requirement as `proven`. Read it as `tested`, so the comparison shows real
+ * changes instead of a rename on every row.
+ */
+// implements REQ-kibi-evidence-levels
+export function upgradeBaselineStatuses(baseline) {
+    if (baseline.requirements === undefined)
+        return baseline;
+    const requirements = {};
+    for (const [id, entry] of Object.entries(baseline.requirements)) {
+        requirements[id] =
+            entry?.proofStatus === "proven"
+                ? { ...entry, proofStatus: "tested" }
+                : entry;
+    }
+    return { ...baseline, requirements };
 }
 /** Diagnostic only: successful evaluation always exits 0. Ratchet lives in check-proof-baseline.mjs. */
 export function proofImpactExitCode(_result) {
@@ -77,8 +97,8 @@ export function buildProofImpact(baseline, coverage) {
     const summary = coverage.summary ?? {};
     const proofNotApplicable = asNumber(summary.proofNotApplicable);
     const total = asNumber(summary.total);
-    const proofProven = asNumber(summary.proofProven);
-    const currentUnproven = asNumber(summary.proofMissing) + asNumber(summary.proofUnresolved);
+    const proofTested = asNumber(summary.proofTested);
+    const currentUntested = asNumber(summary.proofMissing) + asNumber(summary.proofUnresolved);
     const current = fingerprintRequirements(rows);
     const changes = diffFingerprints(baseline.requirements, current);
     return {
@@ -87,8 +107,8 @@ export function buildProofImpact(baseline, coverage) {
             comparisonTarget: COMMITTED_BASELINE_PATH,
             baselineVersion: baseline.version ?? "unknown",
             currentRequirements: total - proofNotApplicable,
-            proofProven,
-            currentUnproven,
+            proofTested,
+            currentUntested,
             changes,
         },
     };
@@ -99,8 +119,8 @@ export function renderProofImpact(result, rows) {
         `Proof impact compared to committed ${result.comparisonTarget}`,
         `baseline version: ${result.baselineVersion}`,
         `current requirements: ${result.currentRequirements}`,
-        `proofProven: ${result.proofProven}`,
-        `currentUnproven: ${result.currentUnproven}`,
+        `proofTested: ${result.proofTested}`,
+        `currentUntested: ${result.currentUntested}`,
         `changed requirements: ${result.changes.length}`,
         "",
     ];

package/dist/public/diagnostic-usage.js

@@ -103,7 +103,7 @@ function appendCoverageFields(fields, args, result) {
     const scope = isRecord(repairPlan?.scope) ? repairPlan.scope : undefined;
     fields.coverage_by = typeof args.by === "string" ? args.by : "req";
     fields.coverage_requirement_count = Number(summary.total ?? rows.length);
-    fields.coverage_proven_count = Number(summary.proofProven ?? 0);
+    fields.coverage_tested_count = Number(summary.proofTested ?? 0);
     fields.coverage_proof_missing_count = Number(summary.proofMissing ?? 0);
     fields.coverage_proof_gap_count = gapCodes.length;
     fields.coverage_gap_codes = [...new Set(gapCodes)].sort();
@@ -160,7 +160,7 @@ export function deriveDiagnosticUsageFields(tool, args, telemetry, result) {
     }
     if (tool === "kb_coverage" && structured) {
         appendCoverageFields(fields, args, structured);
-        fields.result_summary = `${String(fields.coverage_proven_count)} proven; ${String(fields.coverage_proof_gap_count)} proof gaps`;
+        fields.result_summary = `${String(fields.coverage_tested_count)} tested; ${String(fields.coverage_proof_gap_count)} proof gaps`;
     }
     if (tool === "kb_semantic_advisor" && structured) {
         appendSemanticFields(fields, structured.receipt);

package/dist/public/operations/catalog.d.ts

@@ -372,7 +372,7 @@ export declare const OPERATION_CATALOG: readonly [{
 }, {
     readonly name: "kb_coverage";
     readonly cliName: "coverage";
-    readonly description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Use it to ask which requirements are proven and what blocks the rest; use kb_find_gaps for a plain list of missing links and kb_check for rule violations. Reports include the compatible repair plan plus typed kibi.migration-plan.v2 actions; semantic and E2E actions remain review/execution work. Paginated plans identify incomplete scope and no mutation occurs.";
+    readonly description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Use it to ask which requirements are tested end to end, how strong each requirement's evidence is (evidenceLevel: proved, tested, asserted or unverified), and what blocks the rest; use kb_find_gaps for a plain list of missing links and kb_check for rule violations. Reports include the compatible repair plan plus typed kibi.migration-plan.v2 actions; semantic and E2E actions remain review/execution work. Paginated plans identify incomplete scope and no mutation occurs.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -392,13 +392,13 @@ export declare const OPERATION_CATALOG: readonly [{
             readonly includePassing: {
                 readonly type: "boolean";
                 readonly default: false;
-                readonly description: "Also return rows that are already proven or not applicable. By default only rows that still need repair are returned.";
+                readonly description: "Also return rows that are already tested or not applicable. By default only rows that still need repair are returned.";
             };
             readonly statuses: {
                 readonly type: "array";
                 readonly items: {
                     readonly type: "string";
-                    readonly enum: readonly ["proven", "missing", "unresolved", "not_applicable"];
+                    readonly enum: readonly ["tested", "missing", "unresolved", "not_applicable"];
                 };
                 readonly description: "Requirement proof-status filter (req mode): include only rows whose proofStatus is listed. Selecting statuses implies include-passing; not_applicable rows carry their typed applicability reason in proofStages.applicability.reason. The summary always reflects the whole KB.";
             };
@@ -1859,7 +1859,7 @@ export declare const OPERATION_CATALOG: readonly [{
                     readonly type: "string";
                     readonly enum: readonly string[];
                 };
-                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, decision-firm-edited, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
+                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, decision-firm-edited, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers, kb-consistency, kb-consistency-unresolved. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
             };
             readonly sourceFiles: {
                 readonly type: "array";

package/dist/public/operations/specs/check-rules.generated.d.ts

@@ -1,5 +1,5 @@
 /** Every selectable kb_check rule name, registry order. */
 export declare const SELECTABLE_RULE_NAMES: readonly string[];
 /** Comma-separated "Allowed:" fragment for the kb_check rules description. */
-export declare const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, decision-firm-edited, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers";
+export declare const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, decision-firm-edited, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers, kb-consistency, kb-consistency-unresolved";
 //# sourceMappingURL=check-rules.generated.d.ts.map

package/dist/public/operations/specs/check-rules.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-rules.generated.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check-rules.generated.ts"],"names":[],"mappings":"AAUA,2DAA2D;AAC3D,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAsDlD,CAAC;AAGF,8EAA8E;AAC9E,eAAO,MAAM,wBAAwB,srCACgpC,CAAC"}
+{"version":3,"file":"check-rules.generated.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check-rules.generated.ts"],"names":[],"mappings":"AAUA,2DAA2D;AAC3D,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAwDlD,CAAC;AAGF,8EAA8E;AAC9E,eAAO,MAAM,wBAAwB,iuCAC2rC,CAAC"}