kibi-cli 2.38.0 → 2.40.0

package/dist/public/operations/specs/upsert.d.ts

@@ -135,6 +135,16 @@ export declare const upsertSpec: {
                         readonly minLength: 1;
                         readonly description: "Requirement-only. Optional reference to the exception's approval decision record.";
                     };
+                    readonly failure_side_waiver: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Requirement-only. Why the requirement has no failure side to test (its claims state a capability or output shape). Waives happy_path_only once failure_side_waiver_approved_by is set.";
+                    };
+                    readonly failure_side_waiver_approved_by: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Requirement-only. The person who accepted failure_side_waiver.";
+                    };
                     readonly firmness: {
                         readonly type: "string";
                         readonly enum: readonly ["firm", "default", "exploratory"];
@@ -232,13 +242,13 @@ export declare const upsertSpec: {
                                 readonly description: "What the checker establishes; absent means e2e. exhaustive, typecheck, arithmetic, smt, rule, state_machine and regex must leave a kibi.code-certificate.v1 that Kibi re-checks before the receipt counts as proved. source reads the contract's source itself: the run may leave {version, kind: source, test_id, source} or nothing, and Kibi stores its own read as the certificate.";
                             };
                             readonly source: {
-                                readonly description: "source: the project source a source proof reads. A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+                                readonly description: "source: the project source a source proof reads. A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?} over TypeScript, JavaScript, Python and SWI-Prolog files. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. prolog: {file, functor: Name/Arity, arg?} reads one argument of every fact with that functor in a SWI-Prolog file (requires/1 in pack.pl), without running it. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
                                 readonly type: "object";
                                 readonly required: readonly ["reader"];
                                 readonly properties: {
                                     readonly reader: {
                                         readonly type: "string";
-                                        readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                                        readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator", "prolog"];
                                     };
                                 };
                                 readonly additionalProperties: true;
@@ -262,6 +272,11 @@ export declare const upsertSpec: {
                                         readonly minLength: 1;
                                         readonly description: "exhaustive: when the export is a list of records, the field of each record that names a domain member (a catalog's name).";
                                     };
+                                    readonly arg: {
+                                        readonly type: "integer";
+                                        readonly minimum: 1;
+                                        readonly description: "A SWI-Prolog predicate's argument (1-based) whose solutions Kibi reads, when the predicate takes more than one argument (operator/2 with arg 1 lists each operator's name).";
+                                    };
                                 };
                                 readonly additionalProperties: false;
                             };
@@ -302,14 +317,19 @@ export declare const upsertSpec: {
                                             readonly type: "string";
                                             readonly minLength: 1;
                                         };
+                                        readonly arg: {
+                                            readonly type: "integer";
+                                            readonly minimum: 1;
+                                            readonly description: "A SWI-Prolog predicate's argument (1-based) whose solutions Kibi reads, when the predicate takes more than one argument (operator/2 with arg 1 lists each operator's name).";
+                                        };
                                         readonly source: {
                                             readonly type: "object";
-                                            readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+                                            readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?} over TypeScript, JavaScript, Python and SWI-Prolog files. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. prolog: {file, functor: Name/Arity, arg?} reads one argument of every fact with that functor in a SWI-Prolog file (requires/1 in pack.pl), without running it. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
                                             readonly required: readonly ["reader"];
                                             readonly properties: {
                                                 readonly reader: {
                                                     readonly type: "string";
-                                                    readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                                                    readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator", "prolog"];
                                                 };
                                             };
                                             readonly additionalProperties: true;
@@ -370,6 +390,11 @@ export declare const upsertSpec: {
                                                 readonly type: "string";
                                                 readonly minLength: 1;
                                             };
+                                            readonly arg: {
+                                                readonly type: "integer";
+                                                readonly minimum: 1;
+                                                readonly description: "A SWI-Prolog predicate's argument (1-based) whose solutions Kibi reads, when the predicate takes more than one argument (operator/2 with arg 1 lists each operator's name).";
+                                            };
                                         };
                                         readonly additionalProperties: false;
                                     }, {
@@ -378,12 +403,12 @@ export declare const upsertSpec: {
                                         readonly properties: {
                                             readonly source: {
                                                 readonly type: "object";
-                                                readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+                                                readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?} over TypeScript, JavaScript, Python and SWI-Prolog files. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. prolog: {file, functor: Name/Arity, arg?} reads one argument of every fact with that functor in a SWI-Prolog file (requires/1 in pack.pl), without running it. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
                                                 readonly required: readonly ["reader"];
                                                 readonly properties: {
                                                     readonly reader: {
                                                         readonly type: "string";
-                                                        readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                                                        readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator", "prolog"];
                                                     };
                                                 };
                                                 readonly additionalProperties: true;
@@ -406,6 +431,11 @@ export declare const upsertSpec: {
                                         readonly type: "string";
                                         readonly minLength: 1;
                                     };
+                                    readonly arg: {
+                                        readonly type: "integer";
+                                        readonly minimum: 1;
+                                        readonly description: "A SWI-Prolog predicate's argument (1-based) whose solutions Kibi reads, when the predicate takes more than one argument (operator/2 with arg 1 lists each operator's name).";
+                                    };
                                 };
                                 readonly additionalProperties: false;
                             };
@@ -422,6 +452,11 @@ export declare const upsertSpec: {
                                         readonly type: "string";
                                         readonly minLength: 1;
                                     };
+                                    readonly arg: {
+                                        readonly type: "integer";
+                                        readonly minimum: 1;
+                                        readonly description: "A SWI-Prolog predicate's argument (1-based) whose solutions Kibi reads, when the predicate takes more than one argument (operator/2 with arg 1 lists each operator's name).";
+                                    };
                                 };
                                 readonly additionalProperties: false;
                             };
@@ -837,6 +872,26 @@ export declare const upsertSpec: {
                         readonly type: "string";
                         readonly description: "Exact atomic requirement clause represented by this fact, retained for human audit. On a grounding fact Kibi derives claim_key from it; an observation or meta fact quotes the clause it is about without a key.";
                     };
+                    readonly dimension_waiver: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Fact-only. Why the quantifier word in claim_text ranges over nothing, so the claim needs no count, set or rule. Waives dimension_unrepresented once dimension_waiver_approved_by is set.";
+                    };
+                    readonly dimension_waiver_approved_by: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Fact-only. The person who accepted dimension_waiver.";
+                    };
+                    readonly case_waiver: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Fact-only. Why the edge cases derived from this fact are covered some other way or cannot occur. Waives uncovered_case once case_waiver_approved_by is set.";
+                    };
+                    readonly case_waiver_approved_by: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "Fact-only. The person who accepted case_waiver.";
+                    };
                     readonly predicate_name: {
                         readonly type: "string";
                         readonly description: "Optional predicate name for ontology predicate facts. Prefer kb_model mode predicates before hand-writing predicate_name.";

package/dist/public/operations/specs/upsert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DuC,CAAC"}
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DuC,CAAC"}

package/dist/public/operations/symbol-coordinates-check.d.ts

@@ -0,0 +1,11 @@
+import type { Violation } from "../../utils/rule-registry.js";
+import type { PrologPort } from "./runtime-types.js";
+/**
+ * A symbol whose source file exists but which Kibi could not place in it is
+ * linked to no code: impact review, coverage and proofs never see it there.
+ * kibi sync names it in its refresh output only, so the check reports every
+ * such symbol as a warning (advisory, non-blocking).
+ */
+export declare const SYMBOL_COORDINATES_MISSING_RULE = "symbol-coordinates-missing";
+export declare function collectSymbolCoordinatesMissingViolations(prolog: Pick<PrologPort, "query">, workspaceRoot: string, rules: ReadonlySet<string>): Promise<Violation[]>;
+//# sourceMappingURL=symbol-coordinates-check.d.ts.map

package/dist/public/operations/symbol-coordinates-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-coordinates-check.d.ts","sourceRoot":"","sources":["../../../src/public/operations/symbol-coordinates-check.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;GAKG;AAEH,eAAO,MAAM,+BAA+B,+BAA+B,CAAC;AAa5E,wBAAsB,yCAAyC,CAC7D,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,EACjC,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GACzB,OAAO,CAAC,SAAS,EAAE,CAAC,CA8BtB"}

package/dist/public/operations/symbol-coordinates-check.js

@@ -0,0 +1,66 @@
+/*
+ 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 { existsSync, statSync } from "node:fs";
+import * as path from "node:path";
+import { parseEntityFromList, parseListOfLists } from "../../prolog/codec.js";
+/**
+ * A symbol whose source file exists but which Kibi could not place in it is
+ * linked to no code: impact review, coverage and proofs never see it there.
+ * kibi sync names it in its refresh output only, so the check reports every
+ * such symbol as a warning (advisory, non-blocking).
+ */
+// implements REQ-cli-check, REQ-generated-coordinate-persistence
+export const SYMBOL_COORDINATES_MISSING_RULE = "symbol-coordinates-missing";
+const SYMBOL_PLACEMENT_QUERY = "findall([Id,symbol,Fields], (kb_entity(Id, symbol, Props), include([Key=_]>>memberchk(Key, [title,status,sourceFile,sourceLine]), Props, Fields)), Rows)";
+const INACTIVE_STATUSES = new Set([
+    "deprecated",
+    "removed",
+    "retired",
+    "superseded",
+]);
+// implements REQ-cli-check
+export async function collectSymbolCoordinatesMissingViolations(prolog, workspaceRoot, rules) {
+    if (!rules.has(SYMBOL_COORDINATES_MISSING_RULE))
+        return [];
+    const rows = await prolog.query(SYMBOL_PLACEMENT_QUERY);
+    if (!rows.success)
+        throw new Error(`symbol-coordinates-missing symbol projection failed: ${rows.error ?? "unknown error"}`);
+    const violations = [];
+    for (const row of parseListOfLists(rows.bindings.Rows ?? "[]")) {
+        const entity = parseEntityFromList(row);
+        const id = typeof entity.id === "string" ? entity.id : "";
+        const sourceFile = typeof entity.sourceFile === "string" ? entity.sourceFile : "";
+        const status = typeof entity.status === "string" ? entity.status : "";
+        if (id === "" || sourceFile === "" || INACTIVE_STATUSES.has(status))
+            continue;
+        if (entity.sourceLine !== undefined && entity.sourceLine !== null)
+            continue;
+        const absolute = path.resolve(workspaceRoot, sourceFile);
+        if (!existsSync(absolute) || !statSync(absolute).isFile())
+            continue;
+        const title = typeof entity.title === "string" ? entity.title : id;
+        violations.push({
+            rule: SYMBOL_COORDINATES_MISSING_RULE,
+            entityId: id,
+            source: sourceFile,
+            description: `${id} (${title}) has no symbol coordinates in ${sourceFile}: Kibi could not place it, so its links are checked against no code`,
+            suggestion: "Run kibi sync --refresh-symbol-coordinates and read its failed lines; use the name the extractor gives the declaration, install the plugins and grammar packs kibi doctor names, or add symbol_role and granularity_reason for a file-level link.",
+        });
+    }
+    return violations;
+}

package/dist/public/proof-protocol.d.ts

@@ -353,13 +353,13 @@ export declare const PROOF_CONTRACT_SCHEMA: {
             readonly description: "What the checker establishes; absent means e2e. exhaustive, typecheck, arithmetic, smt, rule, state_machine and regex must leave a kibi.code-certificate.v1 that Kibi re-checks before the receipt counts as proved. source reads the contract's source itself: the run may leave {version, kind: source, test_id, source} or nothing, and Kibi stores its own read as the certificate.";
         };
         readonly source: {
-            readonly description: "source: the project source a source proof reads. A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+            readonly description: "source: the project source a source proof reads. A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?} over TypeScript, JavaScript, Python and SWI-Prolog files. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. prolog: {file, functor: Name/Arity, arg?} reads one argument of every fact with that functor in a SWI-Prolog file (requires/1 in pack.pl), without running it. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
             readonly type: "object";
             readonly required: readonly ["reader"];
             readonly properties: {
                 readonly reader: {
                     readonly type: "string";
-                    readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                    readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator", "prolog"];
                 };
             };
             readonly additionalProperties: true;
@@ -383,6 +383,11 @@ export declare const PROOF_CONTRACT_SCHEMA: {
                     readonly minLength: 1;
                     readonly description: "exhaustive: when the export is a list of records, the field of each record that names a domain member (a catalog's name).";
                 };
+                readonly arg: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly description: "A SWI-Prolog predicate's argument (1-based) whose solutions Kibi reads, when the predicate takes more than one argument (operator/2 with arg 1 lists each operator's name).";
+                };
             };
             readonly additionalProperties: false;
         };
@@ -423,14 +428,19 @@ export declare const PROOF_CONTRACT_SCHEMA: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
+                    readonly arg: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                        readonly description: "A SWI-Prolog predicate's argument (1-based) whose solutions Kibi reads, when the predicate takes more than one argument (operator/2 with arg 1 lists each operator's name).";
+                    };
                     readonly source: {
                         readonly type: "object";
-                        readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+                        readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?} over TypeScript, JavaScript, Python and SWI-Prolog files. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. prolog: {file, functor: Name/Arity, arg?} reads one argument of every fact with that functor in a SWI-Prolog file (requires/1 in pack.pl), without running it. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
                         readonly required: readonly ["reader"];
                         readonly properties: {
                             readonly reader: {
                                 readonly type: "string";
-                                readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                                readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator", "prolog"];
                             };
                         };
                         readonly additionalProperties: true;
@@ -491,6 +501,11 @@ export declare const PROOF_CONTRACT_SCHEMA: {
                             readonly type: "string";
                             readonly minLength: 1;
                         };
+                        readonly arg: {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                            readonly description: "A SWI-Prolog predicate's argument (1-based) whose solutions Kibi reads, when the predicate takes more than one argument (operator/2 with arg 1 lists each operator's name).";
+                        };
                     };
                     readonly additionalProperties: false;
                 }, {
@@ -499,12 +514,12 @@ export declare const PROOF_CONTRACT_SCHEMA: {
                     readonly properties: {
                         readonly source: {
                             readonly type: "object";
-                            readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+                            readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?} over TypeScript, JavaScript, Python and SWI-Prolog files. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. prolog: {file, functor: Name/Arity, arg?} reads one argument of every fact with that functor in a SWI-Prolog file (requires/1 in pack.pl), without running it. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
                             readonly required: readonly ["reader"];
                             readonly properties: {
                                 readonly reader: {
                                     readonly type: "string";
-                                    readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                                    readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator", "prolog"];
                                 };
                             };
                             readonly additionalProperties: true;
@@ -527,6 +542,11 @@ export declare const PROOF_CONTRACT_SCHEMA: {
                     readonly type: "string";
                     readonly minLength: 1;
                 };
+                readonly arg: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly description: "A SWI-Prolog predicate's argument (1-based) whose solutions Kibi reads, when the predicate takes more than one argument (operator/2 with arg 1 lists each operator's name).";
+                };
             };
             readonly additionalProperties: false;
         };
@@ -543,6 +563,11 @@ export declare const PROOF_CONTRACT_SCHEMA: {
                     readonly type: "string";
                     readonly minLength: 1;
                 };
+                readonly arg: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly description: "A SWI-Prolog predicate's argument (1-based) whose solutions Kibi reads, when the predicate takes more than one argument (operator/2 with arg 1 lists each operator's name).";
+                };
             };
             readonly additionalProperties: false;
         };

package/dist/public/proof-protocol.d.ts.map

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

package/dist/public/proof-protocol.js

@@ -227,19 +227,25 @@ export const PROOF_RUN_ARTIFACT_SCHEMA = {
     },
     additionalProperties: false,
 };
+const ARG_SCHEMA = {
+    type: "integer",
+    minimum: 1,
+    description: "A SWI-Prolog predicate's argument (1-based) whose solutions Kibi reads, when the predicate takes more than one argument (operator/2 with arg 1 lists each operator's name).",
+};
 const SOURCE_REFERENCE_SCHEMA = {
     type: "object",
     required: ["symbol_id"],
     properties: {
         symbol_id: { type: "string", minLength: 1 },
         export: { type: "string", minLength: 1 },
+        arg: ARG_SCHEMA,
     },
     additionalProperties: false,
 };
-// implements REQ-kibi-source-proof-kinds
+// implements REQ-kibi-source-proof-kinds, REQ-kibi-prolog-source-readers
 const SOURCE_SPEC_SCHEMA = {
     type: "object",
-    description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.",
+    description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?} over TypeScript, JavaScript, Python and SWI-Prolog files. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. prolog: {file, functor: Name/Arity, arg?} reads one argument of every fact with that functor in a SWI-Prolog file (requires/1 in pack.pl), without running it. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.",
     required: ["reader"],
     properties: {
         reader: { type: "string", enum: [...SOURCE_READERS] },
@@ -318,6 +324,7 @@ export const PROOF_CONTRACT_SCHEMA = {
                     minLength: 1,
                     description: "exhaustive: when the export is a list of records, the field of each record that names a domain member (a catalog's name).",
                 },
+                arg: ARG_SCHEMA,
             },
             additionalProperties: false,
         },
@@ -344,6 +351,7 @@ export const PROOF_CONTRACT_SCHEMA = {
                 properties: {
                     symbol_id: { type: "string", minLength: 1 },
                     export: { type: "string", minLength: 1 },
+                    arg: ARG_SCHEMA,
                     source: SOURCE_SPEC_SCHEMA,
                     measure: {
                         type: "string",
@@ -655,10 +663,18 @@ function proofContractKindErrors(contract) {
             !nonEmptyString(row.symbol_id) ||
             (row.export !== undefined && !nonEmptyString(row.export)) ||
             (row.field !== undefined && !nonEmptyString(row.field)) ||
-            Object.keys(row).some((key) => key !== "symbol_id" && key !== "export" && key !== "field"))
-            errors.push("proof_contract.domain_source must be {symbol_id, export?, field?} naming the symbol that defines the domain, the export to read when its title is not the export name, and the record field that names each member");
+            (row.arg !== undefined && !isArgIndex(row.arg)) ||
+            Object.keys(row).some((key) => key !== "symbol_id" &&
+                key !== "export" &&
+                key !== "field" &&
+                key !== "arg"))
+            errors.push("proof_contract.domain_source must be {symbol_id, export?, field?, arg?} naming the symbol that defines the domain, the export to read when its title is not the export name, the record field that names each member, and for a SWI-Prolog predicate the argument (1-based) that names it");
+        else if (row.field !== undefined && row.arg !== undefined)
+            errors.push("proof_contract.domain_source takes field (a record field) or arg (a Prolog argument), not both");
         else if (row.field !== undefined && kind !== "exhaustive")
             errors.push(`proof_contract.domain_source.field applies only to kind exhaustive, not ${String(kind ?? "e2e")}`);
+        else if (row.arg !== undefined && kind !== "exhaustive")
+            errors.push(`proof_contract.domain_source.arg applies only to kind exhaustive, not ${String(kind ?? "e2e")}`);
     }
     else if (kind === "exhaustive" || kind === "typecheck")
         errors.push(`proof_contract.domain_source is required for kind ${String(kind)}: name the symbol the proof reads its domain from`);
@@ -692,8 +708,10 @@ function proofContractKindErrors(contract) {
                 if (row === null || row.source === undefined)
                     return;
                 errors.push(...sourceSpecErrors(row.source, `proof_contract.value_source[${index}].source`));
-                if (row.symbol_id !== undefined || row.export !== undefined)
-                    errors.push(`proof_contract.value_source[${index}] names a source, so it takes no symbol_id or export`);
+                if (row.symbol_id !== undefined ||
+                    row.export !== undefined ||
+                    row.arg !== undefined)
+                    errors.push(`proof_contract.value_source[${index}] names a source, so it takes no symbol_id, export or arg`);
                 if (row.measure !== undefined && row.measure !== "count")
                     errors.push(`proof_contract.value_source[${index}].measure must be count for a source: Kibi counts the members it reads`);
             });
@@ -706,12 +724,16 @@ function proofContractKindErrors(contract) {
                 return (row !== null &&
                     nonEmptyString(row.symbol_id) &&
                     (row.export === undefined || nonEmptyString(row.export)) &&
+                    (row.arg === undefined || isArgIndex(row.arg)) &&
                     (row.measure === undefined ||
                         row.measure === "value" ||
                         row.measure === "count") &&
-                    Object.keys(row).every((key) => key === "symbol_id" || key === "export" || key === "measure"));
+                    Object.keys(row).every((key) => key === "symbol_id" ||
+                        key === "export" ||
+                        key === "arg" ||
+                        key === "measure"));
             }))
-            errors.push("proof_contract.value_source must be [{symbol_id, export?, measure?: value|count} or {source, measure?: count}] naming the code constants or project sources the assumptions read");
+            errors.push("proof_contract.value_source must be [{symbol_id, export?, arg?, measure?: value|count} or {source, measure?: count}] naming the code constants or project sources the assumptions read");
         else if (kind !== "arithmetic" && kind !== "smt")
             errors.push(`proof_contract.value_source applies only to kind arithmetic or smt, not ${String(kind ?? "e2e")}`);
     }
@@ -729,12 +751,16 @@ function proofContractKindErrors(contract) {
     }
     return errors;
 }
-function isSourceReference(value) {
+function isArgIndex(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 1;
+}
+function isSourceReference(value, options = { arg: true }) {
     const row = record(value);
     return (row !== null &&
         nonEmptyString(row.symbol_id) &&
         (row.export === undefined || nonEmptyString(row.export)) &&
-        Object.keys(row).every((key) => key === "symbol_id" || key === "export"));
+        (row.arg === undefined || (options.arg === true && isArgIndex(row.arg))) &&
+        Object.keys(row).every((key) => key === "symbol_id" || key === "export" || key === "arg"));
 }
 function isSourceMap(value, accepts = isSourceReference) {
     const row = record(value);
@@ -744,10 +770,11 @@ function isSourceMap(value, accepts = isSourceReference) {
 }
 function isPredicateReference(value) {
     const row = record(value);
+    // A predicate is called with every argument, so it projects none.
     if (row === null || row.harness_for === undefined)
-        return isSourceReference(value);
+        return isSourceReference(value, { arg: false });
     const { harness_for: harness, ...reference } = row;
-    return (isSourceReference(reference) &&
+    return (isSourceReference(reference, { arg: false }) &&
         Array.isArray(harness) &&
         harness.length > 0 &&
         harness.every(nonEmptyString));
@@ -770,7 +797,7 @@ function sourceContractErrors(contract) {
             errors.push(`proof_contract.source applies only to kind source, not ${String(kind ?? "e2e")}`);
     }
     else if (kind === "source")
-        errors.push("proof_contract.source is required for kind source: name the project source Kibi reads (reader json, yaml, glob, openapi, references, schema, routes or validator)");
+        errors.push("proof_contract.source is required for kind source: name the project source Kibi reads (reader json, yaml, glob, openapi, references, schema, routes, validator or prolog)");
     const domains = record(contract.domains);
     for (const [type, entry] of Object.entries(domains ?? {}))
         if (isSourceDomain(entry)) {
@@ -797,10 +824,10 @@ function nonNumericContractErrors(contract) {
         errors.push("proof_contract.predicate_source must map each predicate name to {symbol_id, export?, harness_for?} naming the function that decides it");
     if (contract.domains !== undefined &&
         !isSourceMap(contract.domains, (entry) => isSourceReference(entry) || isSourceDomain(entry)))
-        errors.push("proof_contract.domains must map each argument type to {symbol_id, export?} naming the export that lists its values, or {source} naming the project source Kibi reads them from");
+        errors.push("proof_contract.domains must map each argument type to {symbol_id, export?, arg?} naming the export (or SWI-Prolog predicate and argument) that lists its values, or {source} naming the project source Kibi reads them from");
     for (const field of ["initial_source", "pattern_source"])
         if (contract[field] !== undefined && !isSourceReference(contract[field]))
-            errors.push(`proof_contract.${field} must be {symbol_id, export?} naming the export Kibi reads`);
+            errors.push(`proof_contract.${field} must be {symbol_id, export?, arg?} naming the export (or SWI-Prolog predicate and argument) Kibi reads`);
     only("predicate_source", ["rule"]);
     only("domains", ["rule", "state_machine"]);
     only("initial_source", ["state_machine"]);
@@ -840,6 +867,7 @@ export function optionalProofContractFields(contract) {
             symbol_id: domain.symbol_id,
             ...(typeof domain.export === "string" ? { export: domain.export } : {}),
             ...(typeof domain.field === "string" ? { field: domain.field } : {}),
+            ...(isArgIndex(domain.arg) ? { arg: domain.arg } : {}),
         };
     const witness = record(contract.witness);
     if (witness && typeof witness.path === "string")
@@ -863,6 +891,7 @@ export function optionalProofContractFields(contract) {
             return {
                 symbol_id: row.symbol_id,
                 ...(typeof row.export === "string" ? { export: row.export } : {}),
+                ...(isArgIndex(row.arg) ? { arg: row.arg } : {}),
                 ...(row.measure === "value" || row.measure === "count"
                     ? { measure: row.measure }
                     : {}),
@@ -931,6 +960,7 @@ function sourceReference(value) {
     return {
         symbol_id: row.symbol_id,
         ...(typeof row.export === "string" ? { export: row.export } : {}),
+        ...(isArgIndex(row.arg) ? { arg: row.arg } : {}),
     };
 }
 function sourceMap(value) {

package/dist/public/proof-sources.d.ts

@@ -1,4 +1,4 @@
-export declare const SOURCE_READERS: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+export declare const SOURCE_READERS: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator", "prolog"];
 export type SourceReader = (typeof SOURCE_READERS)[number];
 /** A source spec as a proof contract states it; see sourceSpecErrors. */
 export type SourceSpec = Readonly<Record<string, unknown>> & Readonly<{
@@ -56,7 +56,7 @@ export declare function sourceSpecErrors(value: unknown, label: string): string[
 /** The spec with only the keys its reader takes, for contract hashing. */
 export declare function normalizeSourceSpec(value: unknown): SourceSpec | undefined;
 /** Workspace-relative files a glob list matches, sorted. */
-export declare function matchWorkspaceFiles(workspaceRoot: string, patterns: readonly string[], ignore?: readonly string[]): string[];
+export declare function matchWorkspaceFiles(workspaceRoot: string, patterns: readonly string[], ignore?: readonly string[], caseSensitive?: boolean): string[];
 export type SourceDependency = Readonly<{
     id: string;
     hash: string;
@@ -90,6 +90,8 @@ export declare function readSource(workspaceRoot: string, spec: SourceSpec, eval
 export type SourceCodeEvaluation = {
     ok: true;
     members?: string[];
+    /** The prolog reader's members in file order, duplicates kept. */
+    sequence?: string[];
     entities?: SourceEntity[];
     routes?: SourceRoute[];
 } | {

package/dist/public/proof-sources.d.ts.map

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