kibi-core 0.16.0 → 0.17.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-core",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "private": false,
   "description": "Core Prolog modules and RDF graph logic for Kibi",
   "type": "module",

package/src/checks.pl

@@ -41,6 +41,7 @@
     check_rule_safety/1,
     check_rule_verifiability/1,
     check_semantic_completeness/1,
+    check_related_requirement_unmodeled/1,
     check_req_status_vocabulary/1,
     check_entity_id_style/1,
     check_domain_redundancy/1,
@@ -114,6 +115,7 @@ check_all(ViolationsDict) :-
     check_rule_safety(RuleSafety),
     check_rule_verifiability(RuleVerifiability),
     check_semantic_completeness(SemanticCompleteness),
+    check_related_requirement_unmodeled(RelatedRequirementUnmodeled),
     check_req_status_vocabulary(ReqStatusVocabulary),
     check_proof_contract_symbols(ProofContractSymbols),
     check_entity_id_style(EntityIdStyle),
@@ -148,6 +150,7 @@ check_all(ViolationsDict) :-
         rule_safety: RuleSafety,
         rule_verifiability: RuleVerifiability,
         semantic_completeness: SemanticCompleteness,
+        related_requirement_unmodeled: RelatedRequirementUnmodeled,
         req_status_vocabulary: ReqStatusVocabulary,
         proof_contract_symbols: ProofContractSymbols,
         entity_id_style: EntityIdStyle,
@@ -2763,7 +2766,7 @@ strict_req_fact_pairing_violation(violation(
 strict_req_fact_pairing_issue(
     ReqId,
     Description,
-    "Add a property_value fact via requires_property for the same subject_key"
+    "Add a property_value fact via requires_property for the same subject_key, or link requires_predicate to a fact_kind: predicate fact whose first argument is that subject_key"
 ) :-
     kb:current_req(ReqId),
     kb_relationship(constrains, ReqId, SubjectFactId),
@@ -2783,9 +2786,10 @@ strict_req_fact_pairing_issue(
         _ValidFrom,
         _ValidTo
     ),
+    \+ strict_req_predicate_grounds_subject(ReqId, SubjectKey),
     format(
         string(Description),
-        "Requirement constrains ~w (~w) but has no matching strict requires_property fact",
+        "Requirement constrains ~w (~w) but has no matching strict requires_property fact and no requires_predicate fact about that subject",
         [SubjectFactId, SubjectKey]
     ).
 
@@ -2867,13 +2871,27 @@ strict_req_fact_pairing_fact_kind(FactId, Kind) :-
     ;   Kind = legacy
     ).
 
+%% strict_req_predicate_grounds_subject(+ReqId, +SubjectKey)
+% A requirement that constrains a subject fact may ground its claim through
+% requires_predicate instead of requires_property (kb_model's replacementPlan
+% swaps one for the other). The predicate pairs with the subject when its
+% first argument is the subject_key, the argument position built-in and
+% project-local schemas use for the governed subject.
+% implements REQ-check-strict-pairing-predicate-grounding
+strict_req_predicate_grounds_subject(ReqId, SubjectKey) :-
+    kb:effective_req_predicate(ReqId, _FactId, _Namespace, _Name, [First|_], _Polarity),
+    First == SubjectKey,
+    !.
+
 strict_req_fact_pairing_kind_label(legacy, "a legacy fact without fact_kind").
 strict_req_fact_pairing_kind_label(Kind, Label) :-
     format(string(Label), "a fact_kind=~w fact", [Kind]).
 
 %% check_strict_readiness(-Violations)
 % Reports current strict-readiness levels for requirements that are still not
-% contradiction-ready. Legacy and prose-only requirements remain audit-only and
+% contradiction-ready. Each requirement has exactly one level: the first
+% strict_readiness_level/2 clause that holds, so the level is computed before
+% it is compared. Legacy and prose-only requirements remain audit-only and
 % are intentionally not treated as contradictions.
 check_strict_readiness(Violations) :-
     findall(
@@ -2899,7 +2917,8 @@ strict_readiness_issue(
     "Add a subject fact via constrains and a property_value fact via requires_property to model contradiction-safe semantics"
 ) :-
     kb_entity(ReqId, req, _),
-    strict_readiness_level(ReqId, prose_only).
+    strict_readiness_level(ReqId, Level),
+    Level == prose_only.
 
 strict_readiness_issue(
     ReqId,
@@ -2907,19 +2926,21 @@ strict_readiness_issue(
     "Replace prose or legacy fact links with a subject fact via constrains and a property_value fact via requires_property"
 ) :-
     kb_entity(ReqId, req, _),
-    strict_readiness_level(ReqId, traceable).
+    strict_readiness_level(ReqId, Level),
+    Level == traceable.
 
 strict_readiness_issue(
     ReqId,
     Description,
-    "Add a matching property_value fact via requires_property for the same subject_key"
+    "Add a matching property_value fact via requires_property for the same subject_key, or link requires_predicate to a predicate fact whose first argument is that subject_key"
 ) :-
     kb_entity(ReqId, req, _),
-    strict_readiness_level(ReqId, has_subject),
+    strict_readiness_level(ReqId, Level),
+    Level == has_subject,
     strict_readiness_primary_subject(ReqId, SubjectFactId, SubjectKey),
     format(
         string(Description),
-        "Strict readiness: not-ready (has-subject). Requirement constrains ~w (~w) but has no matching strict requires_property fact, so contradiction checks skip it.",
+        "Strict readiness: not-ready (has-subject). Requirement constrains ~w (~w) but has no matching strict requires_property fact and no requires_predicate fact about that subject, so contradiction checks skip it.",
         [SubjectFactId, SubjectKey]
     ).
 
@@ -2929,7 +2950,8 @@ strict_readiness_issue(
     "Ensure constrains and requires_property use the same subject_key, and keep the requirement current if it should participate in contradiction checks"
 ) :-
     kb_entity(ReqId, req, _),
-    strict_readiness_level(ReqId, strict_ready).
+    strict_readiness_level(ReqId, Level),
+    Level == strict_ready.
 
 strict_readiness_level(ReqId, contradiction_ready) :-
     kb:current_req(ReqId),
@@ -2948,6 +2970,11 @@ strict_readiness_level(ReqId, contradiction_ready) :-
         _ValidTo
     ),
     !.
+strict_readiness_level(ReqId, contradiction_ready) :-
+    kb:current_req(ReqId),
+    strict_readiness_primary_subject(ReqId, _SubjectFactId, SubjectKey),
+    strict_req_predicate_grounds_subject(ReqId, SubjectKey),
+    !.
 strict_readiness_level(ReqId, strict_ready) :-
     strict_readiness_has_strict_subject(ReqId),
     strict_readiness_has_strict_property(ReqId),
@@ -3332,6 +3359,89 @@ inventory_entry_status(Entry, Status) :-
 inventory_entry_status(Entry, Status) :-
     is_list(Entry), memberchk(status=Raw, Entry), normalize_term_atom(Raw, Status).
 
+%% check_related_requirement_unmodeled(-Violations)
+% implements REQ-check-related-requirement-unmodeled
+% domain-contradictions compares grounded facts only. A current requirement
+% whose proposition ledger still carries `missing` entries contributes no
+% facts, so when it relates_to a current requirement that is modeled (strict
+% subject/property facts or ground predicate facts) its claims are never
+% compared with that requirement: it can describe behavior the modeled one
+% forbids and `kb_check` stays clean. The relates_to edge says the author knew
+% the two overlap, so the gap is blocking: model the missing propositions
+% against the same subject keys or predicates, or supersede the older
+% requirement. Requirements without a ledger stay in the strict-readiness
+% migration lane and are not reported here.
+check_related_requirement_unmodeled(Violations) :-
+    findall(Violation, related_requirement_unmodeled_violation(Violation), Raw),
+    sort(Raw, Violations).
+
+related_requirement_unmodeled_violation(violation(
+    'related-requirement-unmodeled',
+    ReqId,
+    Description,
+    Suggestion,
+    Source
+)) :-
+    kb:current_req(ReqId),
+    requirement_missing_proposition_count(ReqId, MissingCount),
+    MissingCount > 0,
+    related_current_requirement(ReqId, OtherId),
+    modeled_requirement_summary(OtherId, Summary),
+    format(
+        string(Description),
+        "Requirement ~w leaves ~w proposition(s) unmodeled (status missing) while it relates_to ~w, which models ~w; domain-contradictions compares grounded facts only, so these claims are never checked against ~w",
+        [ReqId, MissingCount, OtherId, Summary, OtherId]
+    ),
+    format(
+        string(Suggestion),
+        "Model the missing propositions of ~w against ~w (a subject fact via constrains and property_value facts via requires_property on the same subject_key, or ground predicate facts via requires_predicate), or record that ~w supersedes ~w if it replaces that requirement",
+        [ReqId, Summary, ReqId, OtherId]
+    ),
+    violation_source(ReqId, req, Source).
+
+requirement_missing_proposition_count(ReqId, Count) :-
+    kb_entity(ReqId, req, Props),
+    memberchk(semantic_inventory=RawInventory, Props),
+    inventory_entries(RawInventory, Entries),
+    aggregate_all(
+        count,
+        ( member(Entry, Entries), inventory_entry_status(Entry, missing) ),
+        Count
+    ).
+
+related_current_requirement(ReqId, OtherId) :-
+    (   kb_relationship(relates_to, ReqId, OtherId)
+    ;   kb_relationship(relates_to, OtherId, ReqId)
+    ),
+    OtherId \== ReqId,
+    kb:current_req(OtherId).
+
+%% modeled_requirement_summary(+ReqId, -Summary)
+% Comma-separated list of the subject.property keys the requirement constrains
+% through contradiction-ready strict facts and the canonical keys of the ground
+% predicate facts it requires. Fails when the requirement models nothing.
+modeled_requirement_summary(ReqId, Summary) :-
+    setof(Key, modeled_requirement_key(ReqId, Key), Keys),
+    atomic_list_concat(Keys, ', ', Summary).
+
+modeled_requirement_key(ReqId, Key) :-
+    kb:effective_req_property_fact(
+        ReqId, SubjectKey, _FactId, PropertyKey,
+        _Operator, _ValueType, _Value, _Unit, _Scope, _Polarity, _ValidFrom, _ValidTo
+    ),
+    normalize_term_atom(SubjectKey, SubjectAtom),
+    normalize_term_atom(PropertyKey, PropertyAtom),
+    format(atom(Key), "~w.~w", [SubjectAtom, PropertyAtom]).
+modeled_requirement_key(ReqId, Key) :-
+    kb_relationship(requires_predicate, ReqId, FactId),
+    kb_entity(FactId, fact, Props),
+    predicate_verifiability_fact_kind(Props, predicate),
+    (   memberchk(canonical_key=RawKey, Props)
+    ->  normalize_term_atom(RawKey, Key)
+    ;   memberchk(predicate_name=RawName, Props),
+        normalize_term_atom(RawName, Key)
+    ).
+
 strict_readiness_has_fact_link(ReqId) :-
     kb_relationship(constrains, ReqId, FactId),
     kb_entity(FactId, fact, _),
@@ -3427,6 +3537,7 @@ check_selected_dispatch(Rules, _{
     rule_safety: RuleSafety,
     rule_verifiability: RuleVerifiability,
     semantic_completeness: SemanticCompleteness,
+    related_requirement_unmodeled: RelatedRequirementUnmodeled,
     req_status_vocabulary: ReqStatusVocabulary,
     proof_contract_symbols: ProofContractSymbols,
     entity_id_style: EntityIdStyle,
@@ -3461,6 +3572,7 @@ check_selected_dispatch(Rules, _{
     selected_rule(Rules, 'rule-safety', check_rule_safety, RuleSafety),
     selected_rule(Rules, 'rule-verifiability', check_rule_verifiability, RuleVerifiability),
     selected_rule(Rules, 'semantic-completeness', check_semantic_completeness, SemanticCompleteness),
+    selected_rule(Rules, 'related-requirement-unmodeled', check_related_requirement_unmodeled, RelatedRequirementUnmodeled),
     selected_rule(Rules, 'req-status-vocabulary', check_req_status_vocabulary, ReqStatusVocabulary),
     selected_rule(Rules, 'proof-contract-symbols', check_proof_contract_symbols, ProofContractSymbols),
     selected_rule(Rules, 'entity-id-style', check_entity_id_style, EntityIdStyle),

package/src/rule_registry.pl

@@ -40,6 +40,7 @@ known_rule('strict-req-fact-pairing').
 known_rule('predicate-verifiability').
 known_rule('strict-readiness').
 known_rule('semantic-completeness').
+known_rule('related-requirement-unmodeled').
 known_rule('proof-contract-symbols').
 known_rule('entity-id-style').
 known_rule('domain-redundancy').
@@ -84,6 +85,7 @@ rule_enforcement_class('strict-req-fact-pairing', advisory).
 rule_enforcement_class('predicate-verifiability', advisory).
 rule_enforcement_class('strict-readiness', migration).
 rule_enforcement_class('semantic-completeness', migration).
+rule_enforcement_class('related-requirement-unmodeled', canonical).
 rule_enforcement_class('proof-contract-symbols', advisory).
 rule_enforcement_class('entity-id-style', advisory).
 rule_enforcement_class('domain-redundancy', advisory).
@@ -128,6 +130,7 @@ rule_implementation('strict-req-fact-pairing', prolog).
 rule_implementation('predicate-verifiability', prolog).
 rule_implementation('strict-readiness', prolog).
 rule_implementation('semantic-completeness', prolog).
+rule_implementation('related-requirement-unmodeled', prolog).
 rule_implementation('proof-contract-symbols', prolog).
 rule_implementation('entity-id-style', prolog).
 rule_implementation('domain-redundancy', prolog).
@@ -169,6 +172,7 @@ rule_predicate('strict-req-fact-pairing', check_strict_req_fact_pairing).
 rule_predicate('predicate-verifiability', check_predicate_verifiability).
 rule_predicate('strict-readiness', check_strict_readiness).
 rule_predicate('semantic-completeness', check_semantic_completeness).
+rule_predicate('related-requirement-unmodeled', check_related_requirement_unmodeled).
 rule_predicate('proof-contract-symbols', check_proof_contract_symbols).
 rule_predicate('entity-id-style', check_entity_id_style).
 rule_predicate('domain-redundancy', check_domain_redundancy).
@@ -203,6 +207,7 @@ rule_predicate_arity('strict-req-fact-pairing', 1).
 rule_predicate_arity('predicate-verifiability', 1).
 rule_predicate_arity('strict-readiness', 1).
 rule_predicate_arity('semantic-completeness', 1).
+rule_predicate_arity('related-requirement-unmodeled', 1).
 rule_predicate_arity('proof-contract-symbols', 1).
 rule_predicate_arity('entity-id-style', 1).
 rule_predicate_arity('domain-redundancy', 1).
@@ -240,6 +245,7 @@ rule_description('strict-req-fact-pairing', 'Detect requirements with incomplete
 rule_description('predicate-verifiability', 'Detect requires_predicate links that do not target ground fact_kind: predicate facts').
 rule_description('strict-readiness', 'Report strict contradiction-readiness levels for requirements that are still prose-only or otherwise not contradiction-ready').
 rule_description('semantic-completeness', 'Every inventoried assertive proposition is modeled or explicitly classified').
+rule_description('related-requirement-unmodeled', 'A current requirement with unresolved (missing) propositions that relates_to a current requirement modeled with strict property or ground predicate facts; its claims are never compared by domain-contradictions until they are modeled against the same subject or predicates, or it supersedes that requirement').
 rule_description('proof-contract-symbols', 'Detect unresolved required_proofs.symbol_id values, type-shape required proofs, and proof_bindings.source_file disagreement with the named symbol sourceFile').
 rule_description('entity-id-style', 'Entity IDs name the governed behavior and match their filename stem; new purely numeric IDs are reported at creation boundaries').
 rule_description('domain-redundancy', 'Two current requirements must not ground the identical logical term or share a ground fact unless linked by supersedes or restates').