kibi-core 0.18.0 → 0.18.2

package/package.json

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

package/src/discovery.pl

@@ -513,17 +513,34 @@ hidden_provenance_stub(RequestedTags, Type, Props) :-
     \+ memberchk('bootstrap:provenance-stub', RequestedTags),
     provenance_stub_props(Type, Props).
 
+% A requested missing/present relationship is satisfied by its documented
+% inverse as well (docs/entity-schema.md: `validates` is the inverse edge of
+% `verified_by` for req/scenario <-> test links), so a requirement whose test
+% `validates` it is not a `verified_by` gap. relationshipCounts stay per name.
+% implements REQ-mcp-search-discovery
 relationships_missing(_Id, []).
 relationships_missing(Id, [Relationship|Rest]) :-
-    relationship_count(Id, Relationship, 0),
+    linked_relationship_count(Id, Relationship, 0),
     relationships_missing(Id, Rest).
 
+% implements REQ-mcp-search-discovery
 relationships_present(_Id, []).
 relationships_present(Id, [Relationship|Rest]) :-
-    relationship_count(Id, Relationship, Count),
+    linked_relationship_count(Id, Relationship, Count),
     Count > 0,
     relationships_present(Id, Rest).
 
+inverse_relationship(verified_by, validates).
+inverse_relationship(validates, verified_by).
+
+linked_relationship_count(Id, Relationship, Count) :-
+    relationship_count(Id, Relationship, Direct),
+    (   inverse_relationship(Relationship, Inverse)
+    ->  relationship_count(Id, Inverse, Reverse)
+    ;   Reverse = 0
+    ),
+    Count is Direct + Reverse.
+
 relationship_counts(Id, CountsDict) :-
     findall(Relationship-Count,
         (relationship_type(Relationship), relationship_count(Id, Relationship, Count)),

package/src/rule_registry.pl

@@ -19,6 +19,7 @@ known_rule('symbol-coverage').
 known_rule('symbol-traceability').
 known_rule('no-dangling-refs').
 known_rule('source-relationship-parity').
+known_rule('branch-store-not-compiled').
 known_rule('source-path-dangling').
 known_rule('no-cycles').
 known_rule('required-fields').
@@ -66,6 +67,7 @@ rule_enforcement_class('symbol-coverage', canonical).
 rule_enforcement_class('symbol-traceability', canonical).
 rule_enforcement_class('no-dangling-refs', canonical).
 rule_enforcement_class('source-relationship-parity', canonical).
+rule_enforcement_class('branch-store-not-compiled', canonical).
 rule_enforcement_class('source-path-dangling', canonical).
 rule_enforcement_class('no-cycles', canonical).
 rule_enforcement_class('required-fields', canonical).
@@ -113,6 +115,7 @@ rule_implementation('symbol-coverage', prolog).
 rule_implementation('symbol-traceability', prolog).
 rule_implementation('no-dangling-refs', prolog).
 rule_implementation('source-relationship-parity', typescript).
+rule_implementation('branch-store-not-compiled', typescript).
 rule_implementation('source-path-dangling', typescript).
 rule_implementation('no-cycles', prolog).
 rule_implementation('required-fields', prolog).
@@ -230,6 +233,7 @@ rule_description('symbol-coverage', 'Production symbols need qualifying coverage
 rule_description('symbol-traceability', 'Production symbols must directly implement requirements for ownership; covered_by is coverage only and executable_for is test identity only').
 rule_description('no-dangling-refs', 'All relationship targets must exist in the KB').
 rule_description('source-relationship-parity', 'Authored Markdown and relationship-shard edges must exactly match the compiled KB').
+rule_description('branch-store-not-compiled', 'The current branch\'s KB store must be compiled from the authored .kb/ sources; a missing or empty store is reported once, naming kibi sync, instead of every store-backed rule reading an empty KB').
 rule_description('source-path-dangling', 'An authored entity\'s source field must name an existing workspace path (a #anchor suffix is ignored), an existing entity id, or an http(s) URL; a missing source is allowed').
 rule_description('no-cycles', 'No circular dependency chains in requirements').
 rule_description('required-fields', 'All entities must have required fields').

package/src/semantic_quality.pl

@@ -363,7 +363,10 @@ implication_witness_violation(Witness, violation(
 % was minted as several facts so requirements about it never meet: more than
 % one active subject fact for the same subject_key, and more than one active
 % property_value fact stating the same claim: the same subject_key,
-% property_key, operator, typed value and unit.  Facts that differ in operator
+% property_key, operator, polarity (absent = require), typed value and unit.
+% A `forbid` fact states the opposite of its `require` twin, so the pair is
+% never one claim.  Facts linked only by superseded or deprecated requirements
+% are history, not live duplicates.  Facts that differ in operator
 % (the two bounds of a range) or in value (two requirements bounding the same
 % property differently) are distinct claims, which domain-contradictions and
 % domain-implication compare.  Each group is reported once, on its first fact
@@ -390,7 +393,8 @@ duplicate_subject_fact_violations(Violations) :-
     findall(
         SubjectKey-FactId,
         (   fact_subject_key_of_kind(FactId, subject, SubjectKey),
-            active_fact(FactId)
+            active_fact(FactId),
+            identity_live_fact(FactId)
         ),
         Pairs0
     ),
@@ -423,15 +427,17 @@ duplicate_subject_fact_violations(Violations) :-
 %% duplicate_property_fact_violations(-Violations)
 duplicate_property_fact_violations(Violations) :-
     findall(
-        key(SubjectKey, PropertyKey, Operator, Value)-FactId,
+        key(SubjectKey, PropertyKey, Operator, Polarity, Value)-FactId,
         (   fact_subject_key_of_kind(FactId, property_value, SubjectKey),
             kb_entity(FactId, fact, Props),
             memberchk(property_key=RawProperty, Props),
             normalize_term_atom(RawProperty, PropertyKey),
             memberchk(operator=RawOperator, Props),
             normalize_term_atom(RawOperator, Operator),
+            property_value_polarity(Props, Polarity),
             property_value_signature(Props, Value),
-            active_fact(FactId)
+            active_fact(FactId),
+            identity_live_fact(FactId)
         ),
         Pairs0
     ),
@@ -444,20 +450,55 @@ duplicate_property_fact_violations(Violations) :-
             Description,
             "Link every requirement to one shared fact and remove the duplicates (kb_delete) once nothing links them",
             Source,
-            _{subjectKey: SubjectKey, propertyKey: PropertyKey, operator: Operator, facts: FactIds}
+            _{subjectKey: SubjectKey, propertyKey: PropertyKey, operator: Operator, polarity: Polarity, facts: FactIds}
         ),
-        (   member(key(SubjectKey, PropertyKey, Operator, _)-FactIds, Groups),
+        (   member(key(SubjectKey, PropertyKey, Operator, Polarity, _)-FactIds, Groups),
             FactIds = [FirstId, _|_],
             length(FactIds, Count),
             atomic_list_concat(FactIds, ', ', FactText),
             format(string(Description),
-                "~w active property_value facts state the same claim on ~w ~w (operator ~w, same value) (~w), so one claim is minted as several facts",
-                [Count, SubjectKey, PropertyKey, Operator, FactText]),
+                "~w active property_value facts state the same claim on ~w ~w (operator ~w, polarity ~w, same value) (~w), so one claim is minted as several facts",
+                [Count, SubjectKey, PropertyKey, Operator, Polarity, FactText]),
             entity_text(FirstId, fact, source, Source)
         ),
         Violations
     ).
 
+%% property_value_polarity(+Props, -Polarity)
+% The polarity of a property_value fact; an absent polarity means require.
+% `forbid` states the opposite claim of `require` on the same tuple, so the
+% two never count as one claim minted twice.
+% implements REQ-kibi-subject-vocabulary
+property_value_polarity(Props, Polarity) :-
+    (   memberchk(polarity=Raw, Props),
+        normalize_term_atom(Raw, Polarity0),
+        Polarity0 \== ''
+    ->  Polarity = Polarity0
+    ;   Polarity = require
+    ).
+
+%% identity_live_fact(+FactId)
+% A fact still carried by the current requirement set: no requirement links
+% it (an orphan duplicate stays visible), or at least one current requirement
+% links it. A fact linked only by superseded or deprecated requirements is
+% history kept for the append-only supersedes chain, not a live duplicate.
+% `closed` means done, not retired, so a closed requirement still counts.
+% implements REQ-kibi-subject-vocabulary
+identity_live_fact(FactId) :-
+    findall(
+        ReqId,
+        (   member(LinkType, [constrains, requires_property, requires_predicate, requires_rule]),
+            kb_relationship(LinkType, ReqId, FactId)
+        ),
+        Linkers
+    ),
+    (   Linkers == []
+    ->  true
+    ;   member(ReqId, Linkers),
+        kb:current_req(ReqId)
+    ->  true
+    ).
+
 %% property_value_signature(+Props, -Signature)
 % The typed value and unit of a property_value fact, as Field-Value pairs in a
 % fixed field order, so two facts compare equal only when they store the same