kibi-cli 2.38.0 → 2.40.0

package/src/public/proof-protocol.ts

@@ -279,21 +279,29 @@ export const PROOF_RUN_ARTIFACT_SCHEMA = {
   additionalProperties: false,
 } as const;
 
+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).",
+} as const;
+
 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,
 } as const;
 
-// 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.",
+    "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] },
@@ -382,6 +390,7 @@ export const PROOF_CONTRACT_SCHEMA = {
           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,
     },
@@ -411,6 +420,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",
@@ -819,17 +829,30 @@ function proofContractKindErrors(contract: Record<string, unknown>): string[] {
       !nonEmptyString(row.symbol_id) ||
       (row.export !== undefined && !nonEmptyString(row.export)) ||
       (row.field !== undefined && !nonEmptyString(row.field)) ||
+      (row.arg !== undefined && !isArgIndex(row.arg)) ||
       Object.keys(row).some(
-        (key) => key !== "symbol_id" && key !== "export" && key !== "field",
+        (key) =>
+          key !== "symbol_id" &&
+          key !== "export" &&
+          key !== "field" &&
+          key !== "arg",
       )
     )
       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",
+        "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`,
@@ -878,9 +901,13 @@ function proofContractKindErrors(contract: Record<string, unknown>): string[] {
             `proof_contract.value_source[${index}].source`,
           ),
         );
-        if (row.symbol_id !== undefined || row.export !== undefined)
+        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 or export`,
+            `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(
@@ -897,18 +924,22 @@ function proofContractKindErrors(contract: Record<string, unknown>): string[] {
           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",
+              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",
+        "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(
@@ -938,13 +969,23 @@ function proofContractKindErrors(contract: Record<string, unknown>): string[] {
   return errors;
 }
 
-function isSourceReference(value: unknown): boolean {
+function isArgIndex(value: unknown): boolean {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1;
+}
+
+function isSourceReference(
+  value: unknown,
+  options: Readonly<{ arg?: boolean }> = { arg: true },
+): boolean {
   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",
+    )
   );
 }
 
@@ -964,11 +1005,12 @@ function isSourceMap(
 
 function isPredicateReference(value: unknown): boolean {
   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) &&
+    isSourceReference(reference, { arg: false }) &&
     Array.isArray(harness) &&
     harness.length > 0 &&
     harness.every(nonEmptyString)
@@ -998,7 +1040,7 @@ function sourceContractErrors(contract: Record<string, unknown>): string[] {
       );
   } 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)",
+      "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 ?? {}))
@@ -1046,12 +1088,12 @@ function nonNumericContractErrors(contract: Record<string, unknown>): string[] {
     )
   )
     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",
+      "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`,
+        `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"]);
@@ -1113,7 +1155,12 @@ export function optionalProofContractFields(
 > {
   const fields: {
     kind?: ProofKind;
-    domain_source?: { symbol_id: string; export?: string; field?: string };
+    domain_source?: {
+      symbol_id: string;
+      export?: string;
+      field?: string;
+      arg?: number;
+    };
     witness?: { path: string };
     constraint_source?: { fact_ids: string[] };
     value_source?: ValueSourceEntry[];
@@ -1132,6 +1179,7 @@ export function optionalProofContractFields(
       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 as number } : {}),
     };
   const witness = record(contract.witness);
   if (witness && typeof witness.path === "string")
@@ -1154,6 +1202,7 @@ export function optionalProofContractFields(
         return {
           symbol_id: row.symbol_id,
           ...(typeof row.export === "string" ? { export: row.export } : {}),
+          ...(isArgIndex(row.arg) ? { arg: row.arg as number } : {}),
           ...(row.measure === "value" || row.measure === "count"
             ? { measure: row.measure }
             : {}),
@@ -1177,10 +1226,19 @@ export function optionalProofContractFields(
   return fields;
 }
 
-type SourceReference = { symbol_id: string; export?: string };
-type PredicateReference = SourceReference & { harness_for?: string[] };
+type SourceReference = { symbol_id: string; export?: string; arg?: number };
+type PredicateReference = {
+  symbol_id: string;
+  export?: string;
+  harness_for?: string[];
+};
 type ValueSourceEntry =
-  | { symbol_id: string; export?: string; measure?: "value" | "count" }
+  | {
+      symbol_id: string;
+      export?: string;
+      arg?: number;
+      measure?: "value" | "count";
+    }
   | { source: SourceSpec; measure: "count" };
 
 function predicateMap(
@@ -1229,6 +1287,7 @@ function sourceReference(value: unknown): SourceReference | undefined {
   return {
     symbol_id: row.symbol_id,
     ...(typeof row.export === "string" ? { export: row.export } : {}),
+    ...(isArgIndex(row.arg) ? { arg: row.arg as number } : {}),
   };
 }
 

package/src/public/proof-sources.ts

@@ -22,8 +22,9 @@
  * JSON or YAML file, the files a glob matches, an OpenAPI document, the
  * references the code makes (environment variables, imports, calls, string
  * arguments, thrown error codes, property values), a data schema (drizzle,
- * Prisma or SQL migrations), a web app's route table (Hono, Express) and a
- * validator object (zod and anything with safeParse).
+ * Prisma or SQL migrations), a web app's route table (Hono, Express), a
+ * validator object (zod and anything with safeParse) and the facts of a
+ * SWI-Prolog file (a pack's requires/1).
  *
  * Every reader is exact or refuses: a member Kibi cannot read statically (a
  * computed environment variable name, a dynamic import, an ALTER TABLE form
@@ -47,6 +48,7 @@ export const SOURCE_READERS = [
   "schema",
   "routes",
   "validator",
+  "prolog",
 ] as const;
 
 export type SourceReader = (typeof SOURCE_READERS)[number];
@@ -148,6 +150,7 @@ const KEYS: Readonly<Record<SourceReader, readonly string[]>> = {
     "select",
   ],
   validator: ["reader", "file", "export", "select"],
+  prolog: ["reader", "file", "functor", "arg"],
 };
 
 function record(value: unknown): Record<string, unknown> | null {
@@ -322,6 +325,23 @@ export function sourceSpecErrors(value: unknown, label: string): string[] {
           `${label}.export is required for reader validator: name the object schema`,
         );
       break;
+    case "prolog":
+      file("file", true);
+      if (
+        typeof row.functor !== "string" ||
+        !/^[a-z][A-Za-z0-9_]*\/(?:0|[1-9][0-9]*)$/.test(row.functor)
+      )
+        errors.push(
+          `${label}.functor is required for reader prolog: name the facts read as Name/Arity (requires/1)`,
+        );
+      if (
+        row.arg !== undefined &&
+        !(Number.isInteger(row.arg) && (row.arg as number) >= 1)
+      )
+        errors.push(
+          `${label}.arg must be the 1-based argument of each fact that holds the member`,
+        );
+      break;
   }
   return errors;
 }
@@ -352,15 +372,28 @@ export function matchWorkspaceFiles(
   workspaceRoot: string,
   patterns: readonly string[],
   ignore: readonly string[] = [],
+  caseSensitive = true,
 ): string[] {
+  // A symbolic link to a file is read as that file (git and compilers read
+  // it so); links to folders are not walked.
   return fg
     .sync([...patterns], {
       cwd: workspaceRoot,
       ignore: [...DEFAULT_IGNORE, ...ignore],
+      caseSensitiveMatch: caseSensitive,
       dot: true,
-      onlyFiles: true,
+      onlyFiles: false,
+      markDirectories: true,
       followSymbolicLinks: false,
     })
+    .filter((file) => {
+      if (file.endsWith("/")) return false;
+      try {
+        return statSync(path.join(workspaceRoot, file)).isFile();
+      } catch {
+        return false;
+      }
+    })
     .map((file) => file.split(path.sep).join("/"))
     .sort();
 }
@@ -451,6 +484,9 @@ export function sourceDependencies(
       addFile(String(spec.file));
       for (const file of globList(spec.names_from)) addFile(file);
       break;
+    case "prolog":
+      addFile(String(spec.file));
+      break;
   }
   if (
     spec.reader === "routes" ||
@@ -1617,6 +1653,14 @@ export async function readSource(
       ok: true,
       model: { members: sortedUnique(evaluated.members ?? []) },
     };
+  if (spec.reader === "prolog")
+    return {
+      ok: true,
+      model: {
+        members: sortedUnique(evaluated.members ?? []),
+        sequence: evaluated.sequence ?? [],
+      },
+    };
   if (spec.reader === "routes") {
     const routes = selectedRoutes(spec, evaluated.routes ?? []).sort((a, b) =>
       `${a.path} ${a.method}` < `${b.path} ${b.method}` ? -1 : 1,
@@ -1644,6 +1688,8 @@ export type SourceCodeEvaluation =
   | {
       ok: true;
       members?: string[];
+      /** The prolog reader's members in file order, duplicates kept. */
+      sequence?: string[];
       entities?: SourceEntity[];
       routes?: SourceRoute[];
     }
@@ -1671,6 +1717,8 @@ export function describeSource(spec: SourceSpec): string {
       return `routes of ${spec.export} in ${spec.file}${spec.path_prefix ? ` under ${spec.path_prefix}` : ""}`;
     case "validator":
       return `validator ${spec.export} in ${spec.file}`;
+    case "prolog":
+      return `${spec.functor} facts in ${spec.file}${spec.arg ? ` (argument ${spec.arg})` : ""}`;
   }
 }
 

package/src/public/schemas/entity.ts

@@ -411,6 +411,20 @@ const entitySchema: Record<string, unknown> = {
       description:
         "Requirement-only. Optional reference to the approval decision record (ticket, ADR or review link) for an exception requirement.",
     },
+    failure_side_waiver: {
+      type: "string",
+      minLength: 1,
+      pattern: "\\S",
+      description:
+        "Requirement-only. Why the requirement has no failure side to test: its claims state a capability or an output shape, so there is no input or attempt for Kibi to refuse. Waives the happy_path_only gap once failure_side_waiver_approved_by is set.",
+    },
+    failure_side_waiver_approved_by: {
+      type: "string",
+      minLength: 1,
+      pattern: "\\S",
+      description:
+        "Requirement-only. The person who accepted failure_side_waiver. Without it the waiver is reported as awaiting approval and the gap stays open.",
+    },
     rationale: {
       type: "string",
       minLength: 1,
@@ -497,6 +511,23 @@ const entitySchema: Record<string, unknown> = {
           semantic_key: { type: "string" },
           payload_hash: { type: "string" },
           reason: { type: "string" },
+          // The advisor's hint for a quantified clause, kept so its receipt
+          // propositions can be copied into the inventory unchanged.
+          dimension: {
+            type: "object",
+            required: ["quantifier", "rewrites"],
+            properties: {
+              quantifier: { type: "string", minLength: 1 },
+              rewrites: {
+                type: "array",
+                items: {
+                  type: "string",
+                  enum: ["bound", "rule", "count", "set"],
+                },
+              },
+            },
+            additionalProperties: false,
+          },
         },
         additionalProperties: false,
       },
@@ -606,6 +637,34 @@ const entitySchema: Record<string, unknown> = {
     canonical_key: { type: "string" },
     claim_key: { type: "string", pattern: "^CLAIM-[A-F0-9]{16}$" },
     claim_text: { type: "string" },
+    dimension_waiver: {
+      type: "string",
+      minLength: 1,
+      pattern: "\\S",
+      description:
+        "Fact-only. Why the quantifier word in claim_text (each, every, all, or a cardinality bound) ranges over nothing, so the claim needs no count, set or rule. Waives dimension_unrepresented for the claim once dimension_waiver_approved_by is set.",
+    },
+    dimension_waiver_approved_by: {
+      type: "string",
+      minLength: 1,
+      pattern: "\\S",
+      description:
+        "Fact-only. The person who accepted dimension_waiver. Without it the waiver is reported as awaiting approval and the gap stays open.",
+    },
+    case_waiver: {
+      type: "string",
+      minLength: 1,
+      pattern: "\\S",
+      description:
+        "Fact-only. Why the edge cases Kibi derives from this fact (the value past a bound, a value outside a set) are covered some other way or cannot occur. Waives uncovered_case for the fact once case_waiver_approved_by is set.",
+    },
+    case_waiver_approved_by: {
+      type: "string",
+      minLength: 1,
+      pattern: "\\S",
+      description:
+        "Fact-only. The person who accepted case_waiver. Without it the waiver is reported as awaiting approval and the gap stays open.",
+    },
     predicate_name: { type: "string" },
     predicate_namespace: { type: "string" },
     predicate_arity: { type: "integer", minimum: 1 },
@@ -699,6 +758,10 @@ const entitySchema: Record<string, unknown> = {
             { required: ["canonical_key"] },
             { required: ["claim_key"] },
             { required: ["claim_text"] },
+            { required: ["dimension_waiver"] },
+            { required: ["dimension_waiver_approved_by"] },
+            { required: ["case_waiver"] },
+            { required: ["case_waiver_approved_by"] },
             { required: ["predicate_name"] },
             { required: ["predicate_namespace"] },
             { required: ["predicate_arity"] },
@@ -760,6 +823,8 @@ const entitySchema: Record<string, unknown> = {
             { required: ["proof_exempt_reason"] },
             { required: ["approved_by"] },
             { required: ["approval_ref"] },
+            { required: ["failure_side_waiver"] },
+            { required: ["failure_side_waiver_approved_by"] },
             { required: ["rationale"] },
             { required: ["exempts_claims"] },
             { required: ["required_evidence"] },

package/src/public/skills/kibi-commit-review/SKILL.md

@@ -2,7 +2,7 @@
 id: kibi-commit-review
 name: kibi-commit-review
 description: "Use when kibi check --staged or the Kibi pre-commit hook blocks a commit (kibi_impact_evidence_missing, symbols_manifest_stale, symbol_granularity_violation, symbol-coverage, kibi check-generated drift, Staged impact review failed), or when preparing a commit or pull-request impact review. Covers reading the per-file Detail lines, authoring .kb/symbols.yaml symbol entries through kb_upsert, staging the tracked Kibi evidence with git add (symbol coordinates are derived and never staged), kb_prepare_impact_review for a staged or diff scope, the kibi signoff requirements summary to show before a commit, and how merge commits and migration renames are judged."
-version: 1.3.0
+version: 1.4.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -91,7 +91,11 @@ apps); never attach the `.html` as a file, which chat apps show as raw source;
 past 15 requirements the Markdown stops and only the page lists them all.
 Host details: `kibi-decisions`, `resources/signoff-views.md`. `--no-proof` skips the proof lookup, which reads coverage and is slow
 on a large knowledge base. The summary is not an approval: never set
-`approved_by` or `origin.ref` from it.
+`approved_by` or `origin.ref` from it. Show it before you open or merge the
+pull request. When the person answers, record their answer in the same
+change (their name in `approved_by`, their words in `origin.ref` or
+`approval_ref`) and push it to the same pull request; never move a signoff,
+firmness or waiver approval into a separate pull request.
 
 ## Impact reviews
 

package/src/public/skills/kibi-decisions/SKILL.md

@@ -2,7 +2,7 @@
 id: kibi-decisions
 name: kibi-decisions
 description: "Use when the person states a rule or decision (must, never, always, from now on, we decided), when a Kibi hook asks to confirm or warns about an edit to code that implements a firm requirement, when the Stop hook says source files changed but nothing was recorded, when kb_check quotes requirement_statement_unverified, or when a request conflicts with a recorded requirement or ADR. Covers reading firmness and origin, recording a person's rule as firm with origin.ref, superseding with a Why this changed section, the kb_compile_intent unresolved/reviewCandidates/conflictReviews loop, asking before overriding a firm rule, and putting decisions to the person as one numbered kibi signoff --questions view."
-version: 1.4.0
+version: 1.5.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -115,7 +115,12 @@ again until none is open, then record each rule with their words in
 `origin.ref`. Fields and outputs: `resources/signoff-views.md`.
 
 Never invent words for `origin.ref`, never set `approved_by` yourself, and
-mark your own picks `default` and guesses `exploratory`. Payload shapes,
+mark your own picks `default` and guesses `exploratory`. Once the person has
+answered, recording their answer (their name in `approved_by` or a
+`*_waiver_approved_by` field, their words in `origin.ref` or `approval_ref`)
+is yours to do: put it on the branch of the change it approves and push it to
+that pull request, never to a separate one. Ask before you open or merge the
+pull request, so the answer lands in it. Payload shapes,
 refusal messages and the `kb_compile_intent` review loop are in
 `resources/decision-records.md`.
 

package/src/public/skills/kibi-decisions/resources/signoff-views.md

@@ -51,7 +51,9 @@ writes and opens the page; `--format json` prints the view.
 The person answers by number ("1 yes, 2 exploratory, 3 reword: ..."). Copy
 each answer into `answer`, render again, and record the rules only once every
 question is answered. An answer is the person's words: quote it in
-`origin.ref`; a view itself is never an approval.
+`origin.ref`; a view itself is never an approval. Record the answers on the
+branch of the change they approve and push them to its pull request, never to
+a separate one.
 
 ## Summary contents
 

package/src/public/skills/kibi-usage/SKILL.md

@@ -2,7 +2,7 @@
 id: kibi-usage
 name: Kibi Usage
 description: Use Kibi's source-first, exact-Git, migration-aware, proof-aware operations safely across MCP or the trusted local CLI, including partial completion repair.
-version: 2.36.0
+version: 2.40.1
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -20,6 +20,7 @@ resources:
   - resources/fact-lanes.md
   - resources/workflows.md
   - resources/proof.md
+  - resources/prolog-proofs.md
   - resources/ui-requirements.md
   - resources/logic-ir.md
   - resources/kb-improvement.md
@@ -94,8 +95,10 @@ it is a pointer to the knowledge, never proof. Each line answers one question:
   requirement first. Read the lead requirement with `kb_query({id})` before
   changing behavior; add `includeBody: true` to see its authored prose, and
   fix a stale sentence there with `kb_upsert` `document.body`.
-- `REQ-… must keep true: FACT-…` (edit only): the ground facts the lead
-  requirement requires. An edit that breaks one of them is a requirement
+- `REQ-… must keep true: <claim>` (edit only): what the lead requirement
+  requires, as the claims its facts model (with the operator and members,
+  such as "The greet function must not call console.log") or, without
+  them, its own statement. An edit that breaks one of them is a requirement
   change: ask before changing the rule (see Decision firmness), and never
   code around the fact.
 - `Decision: ADR-…` (edit only): the decision behind the lead requirement.
@@ -372,6 +375,14 @@ human sets `approved_by`; `kb_check` flags approvals an agent recorded without
 corroboration. Never fill in an approval yourself. Record why a requirement
 exists in `rationale`, or link the ADR that explains it.
 
+A signoff belongs to the change it approves. Ask for it before you open or
+merge the pull request, and when the person answers, record their answer
+(`approved_by` or a `*_waiver_approved_by` field set to them, their words in
+`origin.ref` or `approval_ref`) on the same branch and push it to the same pull
+request. Writing down an answer the person gave is not approving it yourself.
+Never open a separate pull request only to carry a signoff, firmness or waiver
+approval.
+
 ## Decision firmness
 
 Requirements and ADRs carry `firmness`, which says what you may do with them.