kibi-cli 2.30.0 → 2.31.0

package/dist/traceability/staged-consistency.js

@@ -4,7 +4,8 @@ import { readSnapshotKnowledge } from "./snapshot-knowledge.js";
 import { cleanupTempKb, createTempKb, projectStagedEntities, } from "./temp-kb.js";
 /**
  * Canonical rules that decide whether the staged knowledge is consistent:
- * requirement contradictions, success scenarios a current requirement
+ * requirement contradictions (pairwise, and joint ones whose certificate the
+ * independent checker re-verifies), success scenarios a current requirement
  * forbids, and exceptions that name claims they cannot waive. They read only
  * authored knowledge, so the staged tree alone decides them.
  */
@@ -13,6 +14,7 @@ const STAGED_CONSISTENCY_RULES = [
     "domain-contradictions",
     "scenario-feasibility",
     "exception-claim-keys",
+    "kb-consistency",
 ];
 /**
  * True when the staged change set touches entity documents or relationship

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

@@ -269,5 +269,15 @@ export declare const GENERATED_RULES: readonly [{
     readonly description: "When a plugin activated for kibi.check-policy.v1 declares marker rules, every file implementing a requirement grounded in the rule's pattern predicate (with its declared sibling files) must contain each marker the KB declares for that pattern";
     readonly enforcementClass: "canonical";
     readonly category: "traceability";
+}, {
+    readonly name: "kb-consistency";
+    readonly description: "The facts current requirements name must hold together, jointly and not only pairwise: every property context needs a value that satisfies all its facts, every atom and decision key one truth value, and stored rules a stratification. Each finding is a contradiction certificate (an irreducible core, two disagreeing facts or a negation cycle) re-verified by the independent checker, or a certificate that checker rejects";
+    readonly enforcementClass: "canonical";
+    readonly category: "integrity";
+}, {
+    readonly name: "kb-consistency-unresolved";
+    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";
 }];
 //# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuXlB,CAAC"}
+{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqYlB,CAAC"}

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

@@ -332,4 +332,16 @@ export const GENERATED_RULES = [
         enforcementClass: "canonical",
         category: "traceability",
     },
+    {
+        name: "kb-consistency",
+        description: "The facts current requirements name must hold together, jointly and not only pairwise: every property context needs a value that satisfies all its facts, every atom and decision key one truth value, and stored rules a stratification. Each finding is a contradiction certificate (an irreducible core, two disagreeing facts or a negation cycle) re-verified by the independent checker, or a certificate that checker rejects",
+        enforcementClass: "canonical",
+        category: "integrity",
+    },
+    {
+        name: "kb-consistency-unresolved",
+        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",
+        enforcementClass: "advisory",
+        category: "integrity",
+    },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "2.30.0",
+  "version": "2.31.0",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {
@@ -235,7 +235,7 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-core": "^0.22.5",
+    "kibi-core": "^0.23.0",
     "kibi-plugin-builtin": "^0.5.3",
     "kibi-plugin-sdk": "^0.5.0",
     "kibi-swipl": "^1.0.1",

package/src/public/diagnostic-usage.ts

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

package/src/public/operations/specs/check-rules.generated.ts

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

package/src/public/operations/specs/reporting.ts

@@ -118,7 +118,7 @@ function validateEntityType(type?: string): void {
 }
 
 const COVERAGE_PROOF_STATUSES: ReadonlySet<string> = new Set([
-  "proven",
+  "tested",
   "missing",
   "unresolved",
   "not_applicable",
@@ -227,7 +227,7 @@ export const findGapsSpec = {
  * + bound-symbol code scope) and hand the Prolog coverage stage a
  * TestId -> BindingHash dict. This is the default binding mode since slice 3;
  * KIBI_PROOF_BINDING_MODE=strict-snapshot opts out (receipts then match only
- * against the whole-workspace snapshot they were proven on).
+ * against the whole-workspace snapshot they were produced on).
  */
 // implements REQ-kibi-verification-evidence-contract
 export function currentProofBindingMode(): "per_contract" | "strict_snapshot" {
@@ -431,13 +431,13 @@ export async function executeCoverage(
       },
     };
     const fullyCovered = Number(enrichedPayload.summary?.fullyCovered ?? 0);
-    const proofProven = Number(enrichedPayload.summary?.proofProven ?? 0);
+    const proofTested = Number(enrichedPayload.summary?.proofTested ?? 0);
     const total = Number(enrichedPayload.summary?.total ?? 0);
     return {
       content: [
         {
           type: "text",
-          text: `Coverage summary: ${fullyCovered} structurally covered and ${proofProven} proven out of ${total}.`,
+          text: `Coverage summary: ${fullyCovered} structurally covered and ${proofTested} tested end to end out of ${total}.`,
         },
       ],
       structuredContent: enrichedPayload,
@@ -452,7 +452,7 @@ export const coverageSpec = {
   name: "kb_coverage",
   cliName: "coverage",
   description:
-    "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Use it to ask which requirements are proven and what blocks the rest; use kb_find_gaps for a plain list of missing links and kb_check for rule violations. Reports include the compatible repair plan plus typed kibi.migration-plan.v2 actions; semantic and E2E actions remain review/execution work. Paginated plans identify incomplete scope and no mutation occurs.",
+    "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Use it to ask which requirements are tested end to end, how strong each requirement's evidence is (evidenceLevel: proved, tested, asserted or unverified), and what blocks the rest; use kb_find_gaps for a plain list of missing links and kb_check for rule violations. Reports include the compatible repair plan plus typed kibi.migration-plan.v2 actions; semantic and E2E actions remain review/execution work. Paginated plans identify incomplete scope and no mutation occurs.",
   businessInputSchema: {
     type: "object",
     properties: {
@@ -473,13 +473,13 @@ export const coverageSpec = {
         type: "boolean",
         default: false,
         description:
-          "Also return rows that are already proven or not applicable. By default only rows that still need repair are returned.",
+          "Also return rows that are already tested or not applicable. By default only rows that still need repair are returned.",
       },
       statuses: {
         type: "array",
         items: {
           type: "string",
-          enum: ["proven", "missing", "unresolved", "not_applicable"],
+          enum: ["tested", "missing", "unresolved", "not_applicable"],
         },
         description:
           "Requirement proof-status filter (req mode): include only rows whose proofStatus is listed. Selecting statuses implies include-passing; not_applicable rows carry their typed applicability reason in proofStages.applicability.reason. The summary always reflects the whole KB.",

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

@@ -2,7 +2,7 @@
 id: kibi-freshness
 name: kibi-freshness
 description: Check exact Git attachment, branch migration/quarantine, compiled-store freshness, source linkage, and repair state before decisions or writes.
-version: 2.0.0
+version: 2.1.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -53,7 +53,7 @@ echo '{}' | npx --no-install kibi status --input -
   `committed_with_repairs`, follow required typed `nextActions`; never retry the
   original operation.
 
-For every freshness, branch, or completion question, call `kb_status` first, then `kb_query` the entities and source files that status names, then `kb_check` as the last Kibi call before answering. Never skip the query step, even when status alone seems to answer the question. If another query or write follows a check, run `kb_check` again before answering. When asked whether requirements are consistent or proven, run `kb_query`, then `kb_check` with the domain-contradictions rule, then `kb_coverage`, and read whether the analysis was complete. Report any unmodeled or unknown clause as incomplete analysis, not as consistent. Only when every clause is fully modeled and compatible, state plainly that no conflict was found. For authorized knowledge changes, keep the exact supplied target and intended relationship edges, and discover and query those targets first. Validate the payload with `kb_upsert` and `dryRun: true`, then perform the authorized `kb_upsert` with that same payload and read the result back exactly before the final checks. A passing dry run is validation, not completion. Distinct authorized payloads may need several sequential writes, each validated and read back, but never retry a mutation that already committed. If a mutation returns `committed_with_repairs`, follow its typed `nextActions` instead of repeating the original operation.
+For every freshness, branch, or completion question, call `kb_status` first, then `kb_query` the entities and source files that status names, then `kb_check` as the last Kibi call before answering. Never skip the query step, even when status alone seems to answer the question. If another query or write follows a check, run `kb_check` again before answering. When asked whether requirements are consistent or proven, run `kb_query`, then `kb_check` with the rules `domain-contradictions`, `kb-consistency` and `kb-consistency-unresolved`, then `kb_coverage`, and read whether the analysis was complete. `domain-contradictions` compares facts two at a time; `kb-consistency` checks every fact of a property together, so a clean pairwise result is not proof. Report a `kb-consistency` violation as a conflict, name every requirement it lists, and give superseding or changing one of them as the next step; never edit or delete facts to make the check pass. Report a context `kb-consistency-unresolved` names as unresolved, never as consistent, with the step that would make it comparable. Report any unmodeled or unknown clause as incomplete analysis, not as consistent. Only when every clause is fully modeled and compatible, state plainly that no conflict was found. For authorized knowledge changes, keep the exact supplied target and intended relationship edges, and discover and query those targets first. Validate the payload with `kb_upsert` and `dryRun: true`, then perform the authorized `kb_upsert` with that same payload and read the result back exactly before the final checks. A passing dry run is validation, not completion. Distinct authorized payloads may need several sequential writes, each validated and read back, but never retry a mutation that already committed. If a mutation returns `committed_with_repairs`, follow its typed `nextActions` instead of repeating the original operation.
 
 ## Guidance
 

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.22.0
+version: 2.24.0
 kibiCompatibility: ">=1.0.0"
 tags:
   - kibi
@@ -168,7 +168,7 @@ End every task with these five independent fields:
 taskOutcome: complete | interim | blocked
 kbState: clean_fresh | stale | dirty | legacy_compat | not_evaluated
 verificationState: fresh | dirty | unavailable | not_evaluated
-proofState: proven | mixed | unresolved | not_evaluated
+proofState: tested | mixed | unresolved | not_evaluated
 limitationDisposition: none | accepted | unaccepted | not_applicable
 ```
 

package/src/public/skills/kibi-usage/resources/proof.md

@@ -1,6 +1,6 @@
 # Proof and Verification Workflow
 
-Use this resource when a requirement must be proven before handoff, when
+Use this resource when a requirement must be tested end to end before handoff, when
 wiring a proof-bearing test, or when `kb_ingest_proof` or `kibi prove`
 rejected evidence.
 
@@ -97,9 +97,9 @@ Cosmetic edits (descriptions, labels) never stale proof. Execution-relevant
 edits (command, artifact, targets, options, bindings, contract) change the
 effective fingerprint and do.
 
-## What counts toward proofProven
+## What counts toward proofTested
 
-A requirement is proven only by its scenarios' tests, and a scenario test
+A requirement reaches `proofStatus: tested` only through its scenarios' tests, and a scenario test
 counts only when it is an **end-to-end** test with a valid, fresh, passing
 receipt for the current snapshot.
 
@@ -109,7 +109,7 @@ receipt for the current snapshot.
   `source` path contains `e2e`) counts as end-to-end; anything else is
   `unknown` scope.
 - A `unit` or `integration` receipt is still recorded on the test entity, but
-  it does not move `proofProven` for a behavioural requirement: the
+  it does not move `proofTested` for a behavioural requirement: the
   requirement keeps the `missing_passing_e2e` gap in `proofGaps`. The one
   exception is a scenario whose specifying requirements are all grounded only
   in component-scope UI predicates (`ui_pattern`, `same_pattern`,
@@ -120,6 +120,38 @@ receipt for the current snapshot.
   receipt does not change it, and a `passing` status without a fresh receipt
   proves nothing.
 
+## Evidence levels
+
+Every requirement row also carries `evidenceLevel`, the strength of what backs
+it, and `evidence`, the entries that earned it (each with `kind`, `scope` and
+`level`):
+
+- `proved`: a re-checkable certificate covers every case. No proof kind issues
+  certificates yet, so nothing reaches it today.
+- `tested`: `proofStatus` is `tested`; fresh E2E receipts cover every linked
+  scenario.
+- `asserted`: a person stands behind the statement (approved, or firm by
+  `firmness` or a non-agent origin) but nothing current checks it.
+- `unverified`: an agent wrote it, no person approved it, nothing checks it.
+
+Report the level as it is. Never call an `asserted` or `unverified`
+requirement proven or tested, and never call `tested` proved. Firmness is a
+separate axis: it says how sure the person is, not how strong the evidence is.
+
+## Knowledge-base certificates
+
+`kb_check` (`kibi check`) proves facts about the KB itself in its
+`kb-consistency` rule and re-checks each answer with an independent checker:
+property facts are consistent (a model per subject, property and scope, or an
+irreducible contradiction core), predicate facts and allow/deny decisions are
+consistent, and stored rules are stratified. It catches facts that contradict
+only together, which the pairwise `domain-contradictions` rule misses. A
+`kb-consistency` violation names the core facts and the requirements behind
+them: supersede or change one of those requirements; never edit the facts so
+the check passes. Quote a `kb-consistency-unresolved` diagnostic as
+unresolved, never as consistent. Opposing rule pairs and scenario
+feasibility are not certified yet; their own rules still decide them.
+
 ## Attempt semantics (factual, never optimistic)
 
 - `attempts: {status: "complete", entries: [...]}` — known history; the

package/src/public/skills/kibi-usage/resources/workflows.md

@@ -9,7 +9,7 @@ success flag):
 taskOutcome: complete | interim | blocked
 kbState: clean_fresh | stale | dirty | legacy_compat | not_evaluated
 verificationState: fresh | dirty | unavailable | not_evaluated
-proofState: proven | mixed | unresolved | not_evaluated
+proofState: tested | mixed | unresolved | not_evaluated
 limitationDisposition: none | accepted | unaccepted | not_applicable
 ```
 

package/templates/github/kibi-badge.yml

@@ -5,7 +5,7 @@
 # explicitly do not want to publish the HTML report.
 # Manual step: Settings → Pages → Source → GitHub Actions
 #
-# Pull requests still generate the report (same snapshot and % proven)
+# Pull requests still generate the report (same snapshot and % tested)
 # and upload it as a workflow artifact. Only the repository default
 # branch (and manual workflow_dispatch) may deploy the canonical badge
 # to GitHub Pages. Use the unprivileged pull_request event so untrusted