kibi-cli 2.31.1 → 2.35.1

package/dist/utils/merge-driver-setup.d.ts

@@ -1,5 +1,12 @@
+/**
+ * The command that runs the project's local kibi, chosen from its lockfile so
+ * a pnpm, Yarn or Bun repository is not told to use npm.
+ */
+export declare function localKibiCommand(cwd: string): string;
 /** How to route the authored manifests to `kibi merge-driver`. */
-export declare const MERGE_DRIVER_SETUP = "Add to .gitattributes: \".kb/symbols.yaml merge=kibi\" and \".kb/relationships/*.yaml merge=kibi\"; then run: git config merge.kibi.driver \"npm exec --no -- kibi merge-driver %O %A %B\" (see docs/cli-reference.md#kibi-merge-driver-base-current-other).";
+export declare function mergeDriverSetup(cwd?: string): string;
+/** The npm form of {@link mergeDriverSetup}. */
+export declare const MERGE_DRIVER_SETUP: string;
 /**
  * What keeps Git from resolving `.kb/symbols.yaml` with `kibi merge-driver`:
  * the attribute that routes the file to it, and the driver command. Empty

package/dist/utils/merge-driver-setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merge-driver-setup.d.ts","sourceRoot":"","sources":["../../src/utils/merge-driver-setup.ts"],"names":[],"mappings":"AAsBA,kEAAkE;AAElE,eAAO,MAAM,kBAAkB,iQAC2N,CAAC;AAwB3P;;;;;GAKG;AAEH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAiBpE"}
+{"version":3,"file":"merge-driver-setup.d.ts","sourceRoot":"","sources":["../../src/utils/merge-driver-setup.ts"],"names":[],"mappings":"AAsBA;;;GAGG;AAEH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMpD;AAED,kEAAkE;AAElE,wBAAgB,gBAAgB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAIrD;AAED,gDAAgD;AAEhD,eAAO,MAAM,kBAAkB,QAAqB,CAAC;AAwBrD;;;;;GAKG;AAEH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAiBpE"}

package/dist/utils/merge-driver-setup.js

@@ -16,11 +16,32 @@
  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 import { execFileSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
+/**
+ * The command that runs the project's local kibi, chosen from its lockfile so
+ * a pnpm, Yarn or Bun repository is not told to use npm.
+ */
+// implements REQ-cli-doctor
+export function localKibiCommand(cwd) {
+    const has = (file) => existsSync(path.join(cwd, file));
+    if (has("pnpm-lock.yaml"))
+        return "pnpm exec kibi";
+    if (has("yarn.lock"))
+        return "yarn exec kibi";
+    if (has("bun.lock") || has("bun.lockb"))
+        return "bunx --no-install kibi";
+    return "npm exec --no -- kibi";
+}
 /** How to route the authored manifests to `kibi merge-driver`. */
 // implements REQ-cli-doctor
-export const MERGE_DRIVER_SETUP = 'Add to .gitattributes: ".kb/symbols.yaml merge=kibi" and ".kb/relationships/*.yaml merge=kibi"; then run: git config merge.kibi.driver "npm exec --no -- kibi merge-driver %O %A %B" (see docs/cli-reference.md#kibi-merge-driver-base-current-other).';
+export function mergeDriverSetup(cwd) {
+    const command = cwd === undefined ? "npm exec --no -- kibi" : localKibiCommand(cwd);
+    return `Add to .gitattributes: ".kb/symbols.yaml merge=kibi" and ".kb/relationships/*.yaml merge=kibi"; then run: git config merge.kibi.driver "${command} merge-driver %O %A %B" (see docs/cli-reference.md#kibi-merge-driver-base-current-other).`;
+}
+/** The npm form of {@link mergeDriverSetup}. */
+// implements REQ-cli-doctor
+export const MERGE_DRIVER_SETUP = mergeDriverSetup();
 function gitOutput(cwd, args) {
     try {
         return execFileSync("git", [...args], {

package/dist/utils/rule-registry.generated.d.ts

@@ -279,5 +279,15 @@ export declare const GENERATED_RULES: readonly [{
     readonly description: "Advisory: a property context, atom or decision key whose facts the consistency checker cannot compare (mixed value types or units, an unsupported operator or polarity, or a contradiction whose validity windows never overlap); it never counts as consistent";
     readonly enforcementClass: "advisory";
     readonly category: "integrity";
+}, {
+    readonly name: "evidence-floor";
+    readonly description: "Every current requirement's computed evidence level (proved, tested, asserted, unverified) must reach its floor: required_evidence when set, otherwise tested for a firm requirement and no floor for any other. Receipts that are only older than the code count as pending re-proof and pass, unless kibi check runs with --fresh-evidence, which also needs a clean proof snapshot";
+    readonly enforcementClass: "canonical";
+    readonly category: "integrity";
+}, {
+    readonly name: "proof-contract-claims";
+    readonly description: "From schema 12, every certificate-kind proof contract (exhaustive, typecheck, arithmetic, smt, rule, state_machine, regex) must name the claims it proves in proves, and each named claim must be a modeled claim of a current requirement the test reaches through its scenarios, grounded by a fact that proof kind can express or attest";
+    readonly enforcementClass: "canonical";
+    readonly category: "integrity";
 }];
 //# sourceMappingURL=rule-registry.generated.d.ts.map

package/dist/utils/rule-registry.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqYlB,CAAC"}
+{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmZlB,CAAC"}

package/dist/utils/rule-registry.generated.js

@@ -344,4 +344,16 @@ export const GENERATED_RULES = [
         enforcementClass: "advisory",
         category: "integrity",
     },
+    {
+        name: "evidence-floor",
+        description: "Every current requirement's computed evidence level (proved, tested, asserted, unverified) must reach its floor: required_evidence when set, otherwise tested for a firm requirement and no floor for any other. Receipts that are only older than the code count as pending re-proof and pass, unless kibi check runs with --fresh-evidence, which also needs a clean proof snapshot",
+        enforcementClass: "canonical",
+        category: "integrity",
+    },
+    {
+        name: "proof-contract-claims",
+        description: "From schema 12, every certificate-kind proof contract (exhaustive, typecheck, arithmetic, smt, rule, state_machine, regex) must name the claims it proves in proves, and each named claim must be a modeled claim of a current requirement the test reaches through its scenarios, grounded by a fact that proof kind can express or attest",
+        enforcementClass: "canonical",
+        category: "integrity",
+    },
 ];

package/dist/utils/schema-version.d.ts

@@ -1,4 +1,4 @@
-export declare const LATEST_KB_SCHEMA_VERSION = 10;
+export declare const LATEST_KB_SCHEMA_VERSION = 13;
 export interface SchemaVersionStatus {
     status: "missing" | "invalid" | "older" | "current" | "newer";
     currentVersion: number | null;

package/dist/utils/schema-version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-version.d.ts","sourceRoot":"","sources":["../../src/utils/schema-version.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,CAAC;IAC9D,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;CAAE,GACrD,IAAI,GACJ,SAAS,CAAC;AAGd,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAChD,MAAM,GAAG,IAAI,CAgBf;AAGD,wBAAgB,sBAAsB,CACpC,MAAM,CAAC,EAAE,mBAAmB,GAC3B,mBAAmB,CAgDrB"}
+{"version":3,"file":"schema-version.d.ts","sourceRoot":"","sources":["../../src/utils/schema-version.ts"],"names":[],"mappings":"AA+BA,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,CAAC;IAC9D,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;CAAE,GACrD,IAAI,GACJ,SAAS,CAAC;AAGd,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAChD,MAAM,GAAG,IAAI,CAgBf;AAGD,wBAAgB,sBAAsB,CACpC,MAAM,CAAC,EAAE,mBAAmB,GAC3B,mBAAmB,CAgDrB"}

package/dist/utils/schema-version.js

@@ -22,7 +22,13 @@
 // "Why this changed" section on new supersedes.
 // Schema 10 reads a requirement or ADR without firmness as firm unless an
 // agent wrote it.
-export const LATEST_KB_SCHEMA_VERSION = 10;
+// Schema 11 checks each current requirement's evidence level against its
+// floor (required_evidence, else tested when firm).
+// Schema 12 requires every certificate-kind proof contract to name the
+// claims it proves.
+// Schema 13 derives symbol coordinates on every sync and keeps
+// .kb/symbol-coordinates.yaml out of Git.
+export const LATEST_KB_SCHEMA_VERSION = 13;
 // implements REQ-003
 export function normalizeSchemaVersion(schemaVersion) {
     if (schemaVersion === undefined || schemaVersion === null) {

package/dist/utils/strict-modeling.d.ts

@@ -4,8 +4,9 @@ export interface SemanticClaim {
     source: string;
     subjectKey: string;
     propertyKey: string;
-    operator: "eq" | "gt" | "gte" | "lt" | "lte" | "neq" | "bool" | "polarity";
-    value: string | number | boolean;
+    operator: "eq" | "gt" | "gte" | "lt" | "lte" | "neq" | "bool" | "polarity" | "matches" | "includes" | "subset_of" | "excludes";
+    /** A list of strings is a set value (operator eq, includes, subset_of or excludes). */
+    value: string | number | boolean | readonly string[];
     confidence: number;
     provenance?: string;
 }

package/dist/utils/strict-modeling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strict-modeling.d.ts","sourceRoot":"","sources":["../../src/utils/strict-modeling.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"strict-modeling.d.ts","sourceRoot":"","sources":["../../src/utils/strict-modeling.ts"],"names":[],"mappings":"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"}

package/dist/utils/strict-modeling.js

@@ -226,6 +226,8 @@ export function normalizeSourceKey(value) {
     return normalized;
 }
 function normalizeStableValue(value) {
+    if (Array.isArray(value))
+        return normalizeStableValue([...new Set(value)].sort().join("|"));
     if (typeof value === "string") {
         const normalized = value
             .trim()
@@ -279,8 +281,20 @@ function buildUniqueTags(tags) {
 function buildPropertyFactTitle(normalizedPropertyKey, claim) {
     const label = humanizeKey(normalizedPropertyKey);
     if (claim.operator === "polarity") {
-        return `${label} ${normalizePolarityValue(claim.value) === "forbid" ? "forbidden" : "required"}`;
+        return `${label} ${normalizePolarityValue(scalarValue(claim.value)) === "forbid" ? "forbidden" : "required"}`;
     }
+    if (Array.isArray(claim.value)) {
+        const setLabel = claim.operator === "includes"
+            ? "includes"
+            : claim.operator === "subset_of"
+                ? "within"
+                : claim.operator === "excludes"
+                    ? "excludes"
+                    : "=";
+        return `${label} ${setLabel} ${claim.value.join(", ")}`;
+    }
+    if (claim.operator === "matches")
+        return `${label} matches ${String(claim.value)}`;
     const operatorLabel = claim.operator === "bool"
         ? "="
         : claim.operator === "eq"
@@ -297,19 +311,32 @@ function buildPropertyFactTitle(normalizedPropertyKey, claim) {
     return `${label} ${operatorLabel} ${String(claim.value)}`;
 }
 function buildPropertyFactFields(claim) {
+    // implements REQ-kibi-source-proof-kinds
+    if (Array.isArray(claim.value))
+        return {
+            operator: claim.operator,
+            value_type: "set",
+            value_set: [...new Set(claim.value)].sort(),
+        };
+    if (claim.operator === "matches")
+        return {
+            operator: "matches",
+            value_type: "string",
+            value_string: String(claim.value),
+        };
     if (claim.operator === "polarity") {
         return {
             operator: "eq",
             value_type: "bool",
             value_bool: true,
-            polarity: normalizePolarityValue(claim.value),
+            polarity: normalizePolarityValue(scalarValue(claim.value)),
         };
     }
     if (claim.operator === "bool") {
         return {
             operator: "eq",
             value_type: "bool",
-            value_bool: normalizeBooleanValue(claim.value),
+            value_bool: normalizeBooleanValue(scalarValue(claim.value)),
         };
     }
     return {
@@ -328,7 +355,7 @@ function numericClaimValue(claim) {
         /^\s*-?\d+(?:\.\d+)?\s*$/.test(claim.value)) {
         return Number(claim.value);
     }
-    return claim.value;
+    return scalarValue(claim.value);
 }
 function buildTypedValueFields(value) {
     if (typeof value === "boolean") {
@@ -420,3 +447,9 @@ function buildEntitySourcePath(directory, entityId) {
 export function factSourcePath(factId) {
     return buildEntitySourcePath(resolveEntitySourcePaths().facts, factId);
 }
+/** A claim value as one scalar: a set value joins its members. */
+function scalarValue(value) {
+    return Array.isArray(value)
+        ? value.join("|")
+        : value;
+}

package/dist/workspace-cwd.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Run from a subdirectory of a Kibi workspace against that workspace's KB,
+ * the way git finds its repository: walk up to the nearest directory with
+ * `.kb/manifest.json`. Without this, a command run from `apps/server/`
+ * compiles a second, empty branch store there and reports an empty KB.
+ * An explicit KIBI_WORKSPACE (or alias) and `kibi init` keep the given
+ * directory. Relative path option values keep meaning what the user typed:
+ * the result is the directory to run in and argv with those values made
+ * absolute.
+ */
+export declare function resolveWorkspaceCwd(argv: readonly string[], cwd: string, env: NodeJS.ProcessEnv): Readonly<{
+    cwd: string;
+    argv: string[];
+}>;
+//# sourceMappingURL=workspace-cwd.d.ts.map

package/dist/workspace-cwd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-cwd.d.ts","sourceRoot":"","sources":["../src/workspace-cwd.ts"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AAEH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,CAAC,UAAU,GACrB,QAAQ,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAS3C"}

package/dist/workspace-cwd.js

@@ -0,0 +1,86 @@
+/*
+ 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 fs from "node:fs";
+import path from "node:path";
+const WORKSPACE_ENV_KEYS = [
+    "KIBI_WORKSPACE",
+    "KIBI_PROJECT_ROOT",
+    "KIBI_ROOT",
+];
+/** Options whose value is a file or directory the user named from their shell. */
+const PATH_OPTIONS = new Set([
+    "--input",
+    "--output",
+    "--certificates",
+    "--write-certificates",
+]);
+/** Commands that act on the current directory itself, never on an enclosing KB. */
+const CWD_COMMANDS = new Set(["init"]);
+function enclosingKbRoot(start) {
+    let current = path.resolve(start);
+    while (true) {
+        if (fs.existsSync(path.join(current, ".kb", "manifest.json")))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function absolutePathArgs(argv, base) {
+    const absolute = (value) => value === "-" || path.isAbsolute(value) ? value : path.resolve(base, value);
+    const result = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index] ?? "";
+        const eq = arg.indexOf("=");
+        if (eq > 0 && PATH_OPTIONS.has(arg.slice(0, eq))) {
+            result.push(`${arg.slice(0, eq)}=${absolute(arg.slice(eq + 1))}`);
+            continue;
+        }
+        result.push(arg);
+        const next = argv[index + 1];
+        if (PATH_OPTIONS.has(arg) && next !== undefined && !next.startsWith("--")) {
+            result.push(absolute(next));
+            index += 1;
+        }
+    }
+    return result;
+}
+/**
+ * Run from a subdirectory of a Kibi workspace against that workspace's KB,
+ * the way git finds its repository: walk up to the nearest directory with
+ * `.kb/manifest.json`. Without this, a command run from `apps/server/`
+ * compiles a second, empty branch store there and reports an empty KB.
+ * An explicit KIBI_WORKSPACE (or alias) and `kibi init` keep the given
+ * directory. Relative path option values keep meaning what the user typed:
+ * the result is the directory to run in and argv with those values made
+ * absolute.
+ */
+// implements REQ-cli-subdirectory-workspace
+export function resolveWorkspaceCwd(argv, cwd, env) {
+    const unchanged = { cwd, argv: [...argv] };
+    if (WORKSPACE_ENV_KEYS.some((key) => (env[key] ?? "").trim() !== ""))
+        return unchanged;
+    const command = argv.slice(2).find((arg) => !arg.startsWith("-"));
+    if (command === undefined || CWD_COMMANDS.has(command))
+        return unchanged;
+    const root = enclosingKbRoot(cwd);
+    if (root === null || root === path.resolve(cwd))
+        return unchanged;
+    return { cwd: root, argv: absolutePathArgs(argv, cwd) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "2.31.1",
+  "version": "2.35.1",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {
@@ -92,6 +92,10 @@
       "types": "./dist/public/extractors/markdown.d.ts",
       "default": "./dist/public/extractors/markdown.js"
     },
+    "./proof-certificates": {
+      "types": "./dist/public/proof-certificates.d.ts",
+      "default": "./dist/public/proof-certificates.js"
+    },
     "./schemas/entity": {
       "types": "./dist/public/schemas/entity.d.ts",
       "default": "./dist/public/schemas/entity.js"
@@ -235,7 +239,7 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-core": "^0.23.0",
+    "kibi-core": "^0.26.1",
     "kibi-plugin-builtin": "^0.5.3",
     "kibi-plugin-sdk": "^0.5.0",
     "kibi-swipl": "^1.0.1",

package/schema/entities.pl

@@ -56,6 +56,9 @@ entity_property(req, exempts_claims, list).
 % Absent reads as default.
 entity_property(req, firmness, atom).
 entity_property(adr, firmness, atom).
+% The weakest evidence level a current requirement accepts: proved, tested,
+% asserted or unverified. Absent: tested when firm, otherwise unverified.
+entity_property(req, required_evidence, atom).
 % Intended outcome of a scenario: success, rejection or error.
 entity_property(scenario, expects, atom).
 
@@ -69,6 +72,8 @@ entity_property(fact, value_string, string).
 entity_property(fact, value_int, integer).
 entity_property(fact, value_number, number).
 entity_property(fact, value_bool, boolean).
+% The exact members of a set fact (value_type set).
+entity_property(fact, value_set, list).
 entity_property(fact, unit, string).
 entity_property(fact, scope, string).
 entity_property(fact, polarity, atom).
@@ -150,6 +155,7 @@ optional_property(req, rationale).
 optional_property(req, exempts_claims).
 optional_property(req, firmness).
 optional_property(adr, firmness).
+optional_property(req, required_evidence).
 optional_property(test, verification_scope).
 optional_property(test, verification_perspective).
 optional_property(test, proof_contract).

package/schema/validation.pl

@@ -108,6 +108,7 @@ is_fact_only_field(value_string).
 is_fact_only_field(value_int).
 is_fact_only_field(value_number).
 is_fact_only_field(value_bool).
+is_fact_only_field(value_set).
 is_fact_only_field(unit).
 is_fact_only_field(scope).
 is_fact_only_field(polarity).
@@ -156,6 +157,8 @@ validate_fact_shape(property_value, Props) :-
     valid_operator(Op),
     memberchk(value_type=VT, Props),
     valid_value_type(VT),
+    ( Op == matches -> VT == string ; true ),
+    ( memberchk(Op, [includes, subset_of, excludes]) -> VT == set ; true ),
     exactly_one_value_field(Props),
     value_type_matches_field(VT, Props),
     valid_optional_fact_enums(Props),
@@ -224,10 +227,10 @@ text_atom(Value, Atom) :- atom(Value), !, Atom = Value.
 text_atom(Value, Atom) :- string(Value), atom_string(Atom, Value).
 
 % valid_operator(+Op)
-valid_operator(Op) :- memberchk(Op, [eq, neq, lt, lte, gt, gte]), !.
+valid_operator(Op) :- memberchk(Op, [eq, neq, lt, lte, gt, gte, matches, includes, subset_of, excludes]), !.
 
 % valid_value_type(+VT)
-valid_value_type(ValueType) :- memberchk(ValueType, [string, int, number, bool]), !.
+valid_value_type(ValueType) :- memberchk(ValueType, [string, int, number, bool, set]), !.
 
 % valid_polarity_in_props(+Props)
 % Validates polarity if present; succeeds if no polarity in props
@@ -299,6 +302,7 @@ is_value_field(value_string).
 is_value_field(value_int).
 is_value_field(value_number).
 is_value_field(value_bool).
+is_value_field(value_set).
 
 % value_type_matches_field(+ValueType, +Props)
 % Ensures that value_type matches the actual value field present
@@ -306,6 +310,7 @@ value_type_matches_field(string, Props) :- memberchk(value_string=_, Props), !.
 value_type_matches_field(int, Props) :- memberchk(value_int=_, Props), !.
 value_type_matches_field(number, Props) :- memberchk(value_number=_, Props), !.
 value_type_matches_field(bool, Props) :- memberchk(value_bool=_, Props), !.
+value_type_matches_field(set, Props) :- memberchk(value_set=_, Props), !.
 
 % valid_origin_in_props(+Props)
 % Entity provenance travels as a JSON object string (or a dict). When present

package/src/public/evidence-levels.ts

@@ -0,0 +1,23 @@
+/**
+ * How strong the evidence behind a requirement is, strongest first. proved: a
+ * re-checkable certificate covers every case. tested: fresh passing E2E
+ * receipts cover every linked scenario. asserted: a person stands behind it.
+ * unverified: an agent wrote it and no person approved it. The same list is
+ * the vocabulary of required_evidence, a requirement's evidence floor.
+ */
+// implements REQ-kibi-evidence-levels, REQ-kibi-evidence-floors
+export const EVIDENCE_LEVELS = [
+  "proved",
+  "tested",
+  "asserted",
+  "unverified",
+] as const;
+
+// implements REQ-kibi-evidence-levels
+export type EvidenceLevel = (typeof EVIDENCE_LEVELS)[number];
+
+/** Higher is stronger: unverified 0 through proved 3. */
+// implements REQ-kibi-evidence-floors
+export function evidenceRank(level: EvidenceLevel): number {
+  return EVIDENCE_LEVELS.length - 1 - EVIDENCE_LEVELS.indexOf(level);
+}

package/src/public/impact/coverage-depth-quality.ts

@@ -2,6 +2,7 @@ import type {
   ExtractedEntity,
   ExtractionResult,
 } from "../../extractors/markdown.js";
+import { COARSE_GRANULARITY_REASONS } from "../symbol-granularity.generated.js";
 import type { QualityDiagnostic } from "./types.js";
 
 type ReviewableCoverageDepth =
@@ -347,3 +348,75 @@ export function createCoverageDepthQualityDiagnostics(
       (left.entityId ?? "").localeCompare(right.entityId ?? ""),
     );
 }
+
+const COARSE_REASONS: ReadonlySet<string> = new Set(COARSE_GRANULARITY_REASONS);
+
+/**
+ * Requirements whose every implementing production symbol is a whole-file
+ * anchor (a coarse granularity_reason). Coverage then only says some test
+ * touches the file, so `tested` evidence is cheap; narrower behavioral
+ * symbols would tie it to the code that implements the claim.
+ */
+// implements REQ-audit-quality-diagnostics-v1
+export function createCoarseAnchorQualityDiagnostics(
+  manifestResults: readonly ExtractionResult[],
+): readonly QualityDiagnostic[] {
+  const superseded = supersededRequirementIds(manifestResults);
+  const anchorsByRequirement = new Map<string, ExtractedEntity[]>();
+  for (const result of manifestResults) {
+    if (result.entity.type !== "symbol") continue;
+    // Executable test code is not a production symbol.
+    if (result.relationships.some((rel) => rel.type === "executable_for"))
+      continue;
+    for (const relationship of result.relationships) {
+      if (relationship.type !== "implements") continue;
+      const list = anchorsByRequirement.get(relationship.to) ?? [];
+      list.push(result.entity);
+      anchorsByRequirement.set(relationship.to, list);
+    }
+  }
+  return manifestResults
+    .filter(
+      (result) =>
+        result.entity.type === "req" &&
+        isReviewableRequirement(result.entity, superseded),
+    )
+    .flatMap((result): QualityDiagnostic[] => {
+      const symbols = uniqueEntities(
+        anchorsByRequirement.get(result.entity.id) ?? [],
+      );
+      if (
+        symbols.length === 0 ||
+        !symbols.every((symbol) =>
+          COARSE_REASONS.has(symbol.granularity_reason ?? ""),
+        )
+      )
+        return [];
+      const requirement = result.entity;
+      return [
+        {
+          id: "coarse_anchor_only_review",
+          severity: "review",
+          blocking: false,
+          category: "coverage",
+          entityId: requirement.id,
+          source: requirement.source,
+          files: [requirement.source],
+          message: `Requirement ${requirement.id} (${requirement.title}) is implemented only by whole-file anchors, so its coverage says a test touches those files, not the code behind the claim.`,
+          suggestion:
+            "Link the functions, methods or types that implement the requirement with implements (and covered_by to their tests); keep the file anchor only for genuinely module-level behavior.",
+          evidence: {
+            requirementId: requirement.id,
+            title: requirement.title,
+            symbols: symbols.map((symbol) => ({
+              id: symbol.id,
+              granularityReason: symbol.granularity_reason ?? "",
+            })),
+          },
+        },
+      ];
+    })
+    .toSorted((left, right) =>
+      (left.entityId ?? "").localeCompare(right.entityId ?? ""),
+    );
+}

package/src/public/impact/full-kb-quality.ts

@@ -24,7 +24,10 @@ import {
   createTelemetryAcceptanceDiagnostics,
   parseTelemetryUsageLog,
 } from "../telemetry-acceptance.js";
-import { createCoverageDepthQualityDiagnostics } from "./coverage-depth-quality.js";
+import {
+  createCoarseAnchorQualityDiagnostics,
+  createCoverageDepthQualityDiagnostics,
+} from "./coverage-depth-quality.js";
 import { createRequirementQualityDiagnostics } from "./requirement-quality.js";
 import { createSymbolQualityDiagnostics } from "./symbol-quality.js";
 import type { QualityDiagnostic } from "./types.js";
@@ -297,6 +300,7 @@ function toExtractedEntity(entity: Record<string, unknown>): ExtractedEntity {
     "aliases",
     "examples",
     "predicate_args",
+    "value_set",
   ] as const) {
     const values = optionalStringArrayField(entity, field);
     if (values !== undefined) extracted[field] = values;
@@ -786,6 +790,7 @@ export async function collectFullKbQualityDiagnostics(
         : {}),
     }),
     ...coverageDepthDiagnostics,
+    ...createCoarseAnchorQualityDiagnostics(manifestResults),
     ...createSymbolQualityDiagnostics({
       manifestResults,
       symbolsByFile: new Map(),

package/src/public/operations/check-executor.ts

@@ -46,6 +46,7 @@ import { collectCheckPolicyViolations } from "./check-policy-rules.js";
 import { collectDecisionFirmnessViolations } from "./decision-firmness.js";
 import { executeStatus } from "./discovery-executors.js";
 import { collectEntityContextViolations } from "./entity-context.js";
+import { collectEvidenceFloorViolations } from "./evidence-floor.js";
 import {
   buildActionsFromCheck,
   buildMigrationPlan,
@@ -53,6 +54,7 @@ import {
 } from "./migration-plan.js";
 import { collectOriginReviewViolations } from "./origin-review.js";
 import { collectPredicateSchemaConformanceViolations } from "./predicate-schema-conformance.js";
+import { collectProofContractClaimViolations } from "./proof-contract-claims.js";
 import type { OperationContext, PrologPort } from "./runtime-types.js";
 import {
   SOURCE_PATH_DANGLING_RULE,
@@ -72,6 +74,8 @@ export type CheckInput = {
   readonly includeWorkingTreeDiff?: boolean;
   readonly includeImpactDiagnostics?: boolean;
   readonly maxDiagnostics?: number;
+  /** evidence-floor judges receipts as they are and needs a clean snapshot. */
+  readonly freshEvidence?: boolean;
 };
 
 export type CheckPayload = CheckStructuredContent;
@@ -393,6 +397,13 @@ export async function executeCheck(
       rulesAllowlist,
       workspaceRoot,
     );
+    const evidenceFloorFindings = await collectEvidenceFloorViolations(
+      context,
+      rulesAllowlist,
+      { freshEvidence: args.freshEvidence === true },
+    );
+    const proofContractClaimFindings =
+      await collectProofContractClaimViolations(context, rulesAllowlist);
     const partitioned = partitionCheckFindings([
       ...aggregatedFindings,
       ...queryPlanViolations,
@@ -404,6 +415,8 @@ export async function executeCheck(
       ...entityContextFindings,
       ...decisionFirmnessFindings,
       ...checkPolicyFindings,
+      ...evidenceFloorFindings,
+      ...proofContractClaimFindings,
     ]);
     const violations: Violation[] = partitioned.violations;
     const evaluated = await describeEvaluation(prolog, rulesAllowlist);