kibi-core 0.22.5 → 0.23.0

package/src/requirement_proof.pl

@@ -25,7 +25,7 @@
 ]).
 :- use_module('logic_ir.pl', [logic_rule_safety/2]).
 
-proof_version('kibi.requirement-proof.v3').
+proof_version('kibi.requirement-proof.v4').
 
 requirement_proof_context(Context) :-
     requirement_proof_context(unknown, '1970-01-01T00:00:00Z', 604800, Context).
@@ -71,12 +71,12 @@ requirement_proof(ReqId, ReqProps, _Context, Proof) :-
     kb:current_req(ReqId),
     proof_exempt(ReqProps, Reason),
     !,
-    exempt_requirement_proof(Reason, Proof).
-requirement_proof(ReqId, _ReqProps, _Context, Proof) :-
+    exempt_requirement_proof(Reason, ReqProps, Proof).
+requirement_proof(ReqId, ReqProps, _Context, Proof) :-
     \+ kb:current_req(ReqId),
     !,
     applicability_exclusion_reason(ReqId, Reason),
-    exempt_requirement_proof(Reason, Proof).
+    exempt_requirement_proof(Reason, ReqProps, Proof).
 requirement_proof(ReqId, ReqProps, Context, Proof) :-
     semantic_inventory_stage(ReqProps, SemanticStage, Inventory),
     logic_grounding_stage(ReqId, ReqProps, Inventory, Context, LogicStage),
@@ -101,10 +101,13 @@ requirement_proof(ReqId, ReqProps, Context, Proof) :-
     proof_issues(Stages, Gaps, Advisories),
     proof_repairs(Gaps, Repairs),
     proof_status(Stages, Status),
+    requirement_evidence(ReqProps, Status, PassingE2eTests, EvidenceLevel, Evidence),
     proof_version(Version),
     Proof = _{
         proofVersion: Version,
         proofStatus: Status,
+        evidenceLevel: EvidenceLevel,
+        evidence: Evidence,
         proofGaps: Gaps,
         proofAdvisories: Advisories,
         proofRepairs: Repairs,
@@ -112,11 +115,14 @@ requirement_proof(ReqId, ReqProps, Context, Proof) :-
         testResolutions: ScenarioTestStage.resolutions
     }.
 
-exempt_requirement_proof(Reason, Proof) :-
+exempt_requirement_proof(Reason, ReqProps, Proof) :-
+    requirement_evidence(ReqProps, not_applicable, [], EvidenceLevel, Evidence),
     proof_version(Version),
     Proof = _{
         proofVersion: Version,
         proofStatus: not_applicable,
+        evidenceLevel: EvidenceLevel,
+        evidence: Evidence,
         proofGaps: [],
         proofAdvisories: [],
         proofRepairs: [],
@@ -1674,7 +1680,84 @@ proof_status(Stages, unresolved) :-
     stage_dict(Stages, Stage),
     memberchk(Stage.status, [unresolved, blocked]),
     !.
-proof_status(_, proven).
+proof_status(_, tested).
+
+% implements REQ-kibi-evidence-levels
+%% requirement_evidence(+Props, +ProofStatus, +PassingE2eTests, -Level, -Evidence)
+% How strong the evidence behind a requirement is, never stronger than what
+% backs it.  Levels, strongest first: proved (a re-checkable certificate
+% covers every case), tested (passing E2E receipts cover every linked
+% scenario: proofStatus tested), asserted (a person stands behind the
+% statement but nothing current checks it), unverified (an agent wrote it and
+% no person approved it).  No proof kind issues certificates yet, so proved
+% is never reached here.  Evidence lists what earned the level and anything
+% weaker that also holds, each entry naming its kind and scope.
+requirement_evidence(Props, ProofStatus, PassingE2eTests, Level, Evidence) :-
+    findall(Entry, evidence_entry(Props, ProofStatus, PassingE2eTests, Entry), Evidence),
+    evidence_level(Evidence, Level).
+
+evidence_entry(_Props, tested, PassingE2eTests, _{kind: e2e, scope: code, level: tested, tests: PassingE2eTests}).
+evidence_entry(Props, _ProofStatus, _PassingE2eTests, Entry) :-
+    human_intent(Props, Basis, Ref),
+    (   Ref == ''
+    ->  Entry = _{kind: human_intent, scope: intent, level: asserted, basis: Basis}
+    ;   Entry = _{kind: human_intent, scope: intent, level: asserted, basis: Basis, ref: Ref}
+    ).
+
+evidence_level(Evidence, Level) :-
+    (   member(Level0, [proved, tested, asserted]),
+        member(Entry, Evidence),
+        get_dict(level, Entry, Level0)
+    ->  Level = Level0
+    ;   Level = unverified
+    ).
+
+%% human_intent(+Props, -Basis, -Ref)
+% A person stands behind the requirement: someone approved it
+% (origin.approved_by, the field agent-requirement-unapproved reads), or it
+% reads as firm (firmness: firm, or no firmness and an origin other than
+% agent, as for decision firmness).  The top-level approved_by approves an
+% exception; an agent can write it, so on its own it approves nothing here.
+human_intent(Props, approved, Ref) :-
+    origin_field(Props, approved_by, _),
+    !,
+    intent_ref(Props, Ref).
+human_intent(Props, firm, Ref) :-
+    effective_firmness(Props, firm),
+    !,
+    intent_ref(Props, Ref).
+
+effective_firmness(Props, Firmness) :-
+    (   memberchk(firmness=Raw, Props),
+        normalize_atom(Raw, Explicit),
+        memberchk(Explicit, [firm, default, exploratory])
+    ->  Firmness = Explicit
+    ;   origin_field(Props, kind, agent)
+    ->  Firmness = default
+    ;   Firmness = firm
+    ).
+
+intent_ref(Props, Ref) :-
+    (   origin_field(Props, ref, Ref0)
+    ->  Ref = Ref0
+    ;   prop_text(Props, approval_ref, Ref0)
+    ->  Ref = Ref0
+    ;   Ref = ''
+    ).
+
+prop_text(Props, Key, Text) :-
+    Prop =.. [=, Key, Raw],
+    memberchk(Prop, Props),
+    normalize_atom(Raw, Text),
+    Text \== ''.
+
+origin_field(Props, Key, Value) :-
+    memberchk(origin=Raw, Props),
+    normalize_atom(Raw, Json),
+    catch(atom_json_dict(Json, Origin, [value_string_as(atom)]), _, fail),
+    get_dict(Key, Origin, Value0),
+    normalize_atom(Value0, Value),
+    Value \== ''.
 
 stage_dict(Stages, Stage) :-
     dict_pairs(Stages, _, Pairs),
@@ -1690,7 +1773,7 @@ proof_advisories(Stages, Advisories) :-
 % Every linked scenario is a mandatory proof obligation. Receipt-completeness
 % failures therefore remain blocking even when another scenario has a passing
 % receipt; unit/integration-only evidence stays nonblocking in the E2E lane.
-% Invariant: proofStatus == proven implies proofGaps == [].
+% Invariant: proofStatus == tested implies proofGaps == [].
 proof_issues(Stages, Gaps, Advisories) :-
     findall(Gap,
         (gap_definition(Gap, _, _, _),

package/src/rule_registry.pl

@@ -67,6 +67,8 @@ known_rule('supersedes-reason-missing').
 known_rule('supersedes-reason-acknowledged').
 known_rule('policy-ownership').
 known_rule('policy-markers').
+known_rule('kb-consistency').
+known_rule('kb-consistency-unresolved').
 
 rule_enforcement_class('must-priority-coverage', canonical).
 rule_enforcement_class('symbol-coverage', canonical).
@@ -121,6 +123,8 @@ rule_enforcement_class('supersedes-reason-missing', canonical).
 rule_enforcement_class('supersedes-reason-acknowledged', advisory).
 rule_enforcement_class('policy-ownership', canonical).
 rule_enforcement_class('policy-markers', canonical).
+rule_enforcement_class('kb-consistency', canonical).
+rule_enforcement_class('kb-consistency-unresolved', advisory).
 
 rule_implementation('must-priority-coverage', prolog).
 rule_implementation('symbol-coverage', prolog).
@@ -175,6 +179,8 @@ rule_implementation('supersedes-reason-missing', typescript).
 rule_implementation('supersedes-reason-acknowledged', typescript).
 rule_implementation('policy-ownership', typescript).
 rule_implementation('policy-markers', typescript).
+rule_implementation('kb-consistency', prolog).
+rule_implementation('kb-consistency-unresolved', prolog).
 
 rule_predicate('must-priority-coverage', check_must_priority_coverage).
 rule_predicate('symbol-coverage', check_symbol_coverage).
@@ -210,6 +216,8 @@ rule_predicate('ontology-quality', check_ontology_quality).
 rule_predicate('symbol-owner-superseded', check_symbol_owner_superseded).
 rule_predicate('adr-unlinked', check_adr_unlinked).
 rule_predicate('adr-proposed', check_adr_proposed).
+rule_predicate('kb-consistency', check_kb_consistency).
+rule_predicate('kb-consistency-unresolved', check_kb_consistency_unresolved).
 
 rule_predicate_arity('must-priority-coverage', 1).
 rule_predicate_arity('symbol-coverage', 1).
@@ -245,6 +253,8 @@ rule_predicate_arity('ontology-quality', 1).
 rule_predicate_arity('symbol-owner-superseded', 1).
 rule_predicate_arity('adr-unlinked', 1).
 rule_predicate_arity('adr-proposed', 1).
+rule_predicate_arity('kb-consistency', 1).
+rule_predicate_arity('kb-consistency-unresolved', 1).
 
 rule_description('must-priority-coverage', 'Every current must-priority requirement (not superseded, retired, or closed without the implemented tag) must have a scenario and a test').
 rule_description('symbol-coverage', 'Production symbols need qualifying coverage via covered_by plus a canonical requirement/scenario test path').
@@ -299,3 +309,5 @@ rule_description('supersedes-reason-missing', 'A current requirement or ADR that
 rule_description('supersedes-reason-acknowledged', 'Informational: how many current superseding requirements and ADRs have only supersede edges the schema 9 migration acknowledged without a \'Why this changed\' section; one summary finding per check').
 rule_description('policy-ownership', 'When a plugin activated for kibi.check-policy.v1 declares ownership rules, every production symbol in a rule\'s file set must implement a current requirement grounded (requires_predicate) in one of the rule\'s predicates; projects without an activated check policy are unaffected').
 rule_description('policy-markers', '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').
+rule_description('kb-consistency', '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').
+rule_description('kb-consistency-unresolved', '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').