kibi-core 0.13.0 → 0.14.1

package/src/kb.pl

@@ -14,6 +14,7 @@
     kb_assert_entity/2,
     kb_assert_entity_no_audit/2,
     kb_commit_upsert/5,
+    kb_commit_upsert_batch/2,
     kb_log_entity_upsert/3,
     kb_retract_entity/1,
     kb_retract_entity/3,
@@ -24,10 +25,13 @@
     kb_indexed_sources/1,
     kb_query_entities/8,
     kb_search_entities/6,
+    kb_list_search_candidates/5,
+    kb_entity_ids/1,
     kb_rebuild_indexes/0,
     kb_entity/3,
     kb_entities_by_source/2,
     kb_assert_relationship/4,
+    kb_query_proof_contracts/4,
     kb_assert_relationship_no_audit/4,
     kb_log_relationship_upsert/4,
     kb_relationship/3,
@@ -56,6 +60,7 @@
     symbol_no_req_coverage/2,
     predicate_schema/6,
     predicate_fact/5,
+    canonical_property_tuple/9,
     contradicting_reqs/3,
     req_conflict_witness/3,
     check_req_contradiction/1,
@@ -71,12 +76,15 @@
 :- use_module(library(thread)).
 :- use_module(library(filesex)).
 :- use_module(library(readutil)).
+:- use_module(library(sha), [sha_hash/3, hash_atom/2]).
 :- use_module(library(http/json)).
 :- use_module(library(aggregate), [aggregate_all/3]).
 :- use_module(library(lists), [sum_list/2]).
 :- use_module(library(ordsets)).
+:- use_module(library(solution_sequences), [distinct/1, limit/2, offset/2, order_by/2]).
 :- use_module('../schema/entities.pl', [entity_type/1, entity_property/3, required_property/2]).
 :- use_module('../schema/relationships.pl', [relationship_type/1, valid_relationship/3]).
+:- use_module('units.pl', [canonical_quantity/6]).
 :- use_module('../schema/validation.pl', [validate_entity/2, validate_relationship/3]).
 
 % Constants
@@ -117,6 +125,13 @@ kb_uri('urn-kibi:').
 :- dynamic kb_index_symbol_coordinate/5.
 :- dynamic kb_index_entity_count/1.
 :- dynamic kb_index_triple_count/1.
+% Read memo for per-entity property lists, valid only for the recorded
+% Graph-rdf_generation key. rdf_generation/1 changes on every RDF
+% modification (including inside transactions) and reverts on rollback, so
+% the memo never serves a property list the store no longer holds.
+:- dynamic kb_entity_props_memo/2.
+:- dynamic kb_entity_props_memo_key/1.
+:- dynamic kb_index_verified_key/1.
 :- dynamic entity/4.  % Support legacy .pl file format (Type, Id, Title, Props)
 
 %% kb_attach(+Directory)
@@ -187,8 +202,22 @@ kb_attach_journaled(Directory) :-
     load_kb_pl_files(Directory),
     kb_rebuild_indexes.
 
+% SWI-Prolog's rdf_db fails to write journals ("invalid term_t ... out of
+% range") for graphs whose URI is roughly 230 characters or longer.  Store
+% paths inside deep workspaces reach that length, so those stores use a short
+% digest-based graph URI; shorter paths keep the file:// URI they always had.
+journal_expected_graph_uri(Directory, Expected) :-
+    atom_concat('file://', Directory, FileURI),
+    atom_length(FileURI, Length),
+    (   Length =< 200
+    ->  Expected = FileURI
+    ;   sha_hash(Directory, Hash, [algorithm(sha1)]),
+        hash_atom(Hash, Digest),
+        atom_concat('urn:kibi:store:', Digest, Expected)
+    ).
+
 journal_graph_uri(Directory, GraphURI) :-
-    atom_concat('file://', Directory, Expected),
+    journal_expected_graph_uri(Directory, Expected),
     (   rdf_graph(Expected)
     ->  GraphURI = Expected
     ;   findall(G,
@@ -259,15 +288,16 @@ kb_write_lock_owner(Directory) :-
     ;   BootId = ""
     ),
     get_time(Now),
-    format_time(atom(StartedAt), '%FT%TZ', Now),
+    stamp_date_time(Now, NowUTC, 'UTC'),
+    format_time(atom(StartedAt), '%FT%TZ', NowUTC),
     atom_concat(Path, '.tmp', TmpPath),
     setup_call_cleanup(
         open(TmpPath, write, Stream),
         json_write_dict(Stream,
-                        json([pid:Pid,
-                              workspaceRoot:Directory,
-                              bootId:BootId,
-                              startedAt:StartedAt]),
+                        _{pid:Pid,
+                          workspaceRoot:Directory,
+                          bootId:BootId,
+                          startedAt:StartedAt},
                         []),
         (close(Stream), rename_file(TmpPath, Path))).
 
@@ -324,6 +354,9 @@ kb_detach :-
             retractall(kb_dirty),
             retractall(kb_index_ready),
             retractall(kb_index_dirty),
+            retractall(kb_index_verified_key(_)),
+            retractall(kb_entity_props_memo(_, _)),
+            retractall(kb_entity_props_memo_key(_)),
             retractall(kb_index_entity(_, _)),
             retractall(kb_index_type(_, _)),
             retractall(kb_index_tag(_, _)),
@@ -1089,6 +1122,62 @@ kb_maybe_check_req_contradiction(req, Id, false) :-
     check_req_contradiction(Id).
 kb_maybe_check_req_contradiction(_, _, _).
 
+% Stage one upsert inside an already-open transaction. The caller saves once.
+kb_stage_upsert(Type, Props, Relationships, SkipContradiction, ChangeKind) :-
+    memberchk(id=Id, Props),
+    memberchk(SkipContradiction, [true, false]),
+    upsert_change_kind(Id, ChangeKind),
+    kb_assert_entity_no_audit(Type, Props),
+    kb_commit_relationships_no_audit(Relationships),
+    kb_maybe_check_req_contradiction(Type, Id, SkipContradiction),
+    kb_log_entity_upsert(ChangeKind, Type, Props),
+    kb_commit_relationship_audits(Relationships).
+
+kb_stage_upserts([], []).
+kb_stage_upserts([
+    upsert(Type, Props, Relationships, SkipContradiction)|Rest
+], [ChangeKind|Kinds]) :-
+    kb_stage_upsert(Type, Props, Relationships, SkipContradiction, ChangeKind),
+    kb_stage_upserts(Rest, Kinds).
+
+%% kb_commit_upsert_batch(+Entries, -ChangeKinds)
+% implements REQ-core-atomic-upsert-persistence
+% Commit many upserts in one RDF transaction and one journal flush.
+% Entries are upsert(Type, Props, Relationships, SkipContradiction) terms.
+kb_commit_upsert_batch(Entries, ChangeKinds) :-
+    kb_storage_mode(journaled),
+    !,
+    with_kb_mutex((
+        (   kb_dirty -> WasDirty = true ; WasDirty = false ),
+        catch(
+            rdf_transaction((
+                kb_stage(rdf_mutation),
+                kb_stage_upserts(Entries, ChangeKinds)
+            )),
+            Error,
+            (   (WasDirty == false -> retractall(kb_dirty) ; true),
+                throw(Error)
+            )
+        ),
+        kb_mark_dirty,
+        kb_save_journaled
+    )).
+kb_commit_upsert_batch(Entries, ChangeKinds) :-
+    kb_attached(Directory),
+    atom_concat(Directory, '/kb.rdf', DataFile),
+    kb_stage(runtime),
+    kb_runtime_diagnostic,
+    kb_stage(lock),
+    with_kb_file_lock(Directory, (
+        audit_store_writable,
+        ensure_snapshot_current(DataFile),
+        rdf_transaction((
+            kb_stage(rdf_mutation),
+            kb_stage_upserts(Entries, ChangeKinds),
+            kb_save_locked(Directory)
+        ))
+    )).
+
 kb_commit_relationship_audits([]).
 kb_commit_relationship_audits([
     rel(RelType, FromId, ToId, _Metadata)|Rest
@@ -1324,6 +1413,42 @@ kb_entity(Id, Type, Props) :-
 % Raw RDF/entity facts are kept separate from the index wrapper.  Rebuilding
 % an index must never recurse through the indexed query path.
 kb_entity_raw(Id, Type, Props) :-
+    (   nonvar(Id)
+    ->  rdf_entity_solutions(Id, Solutions),
+        member(Type-Props, Solutions)
+    ;   kb_entity_raw_rdf(Id, Type, Props)
+    ).
+
+% Fallback: read from legacy entity/4 facts loaded from .pl files
+kb_entity_raw(Id, Type, Props) :-
+    entity(Type, Id, _Title, PropList),
+    convert_legacy_props(PropList, Props).
+
+%% rdf_entity_solutions(+Id, -Solutions)
+% Coverage, proof, and check predicates look up the same entities tens of
+% thousands of times, and every lookup materializes and decodes every
+% property (including receipt histories). Memoize the decoded Type-Props
+% solutions per entity for the current graph and RDF generation.
+rdf_entity_solutions(Id, Solutions) :-
+    (   kb_graph(Graph)
+    ->  rdf_generation(Generation),
+        Key = Graph-Generation,
+        (   kb_entity_props_memo_key(Current),
+            Current == Key
+        ->  true
+        ;   retractall(kb_entity_props_memo(_, _)),
+            retractall(kb_entity_props_memo_key(_)),
+            assertz(kb_entity_props_memo_key(Key))
+        ),
+        (   kb_entity_props_memo(Id, Cached)
+        ->  Solutions = Cached
+        ;   findall(Type-Props, kb_entity_raw_rdf(Id, Type, Props), Solutions),
+            assertz(kb_entity_props_memo(Id, Solutions))
+        )
+    ;   Solutions = []
+    ).
+
+kb_entity_raw_rdf(Id, Type, Props) :-
     kb_graph(Graph),
     % Find entity by pattern - use unquoted namespace term kb:type
     (   var(Id)
@@ -1344,20 +1469,37 @@ kb_entity_raw(Id, Type, Props) :-
         literal_to_value(Key, ValueLiteral, Value)
 ), Props).
 
-% Fallback: read from legacy entity/4 facts loaded from .pl files
-kb_entity_raw(Id, Type, Props) :-
-    entity(Type, Id, _Title, PropList),
-    convert_legacy_props(PropList, Props).
-
+% Verifying the index counts every type triple in the store. Remember the
+% inputs of the last successful check (graph, RDF generation, legacy fact
+% count, and the index's own entity count) and skip the recount while all of
+% them are unchanged: the recount would then return the same answer. The
+% index count must be part of the key because incremental index updates are
+% plain Prolog facts that an RDF rollback does not undo, while the RDF
+% generation does revert.
 kb_ensure_indexes :-
     (   kb_index_ready,
         \+ kb_index_dirty,
         kb_index_entity_count(Expected),
-        current_entity_index_count(Expected)
+        index_verification_key(Expected, Key),
+        (   kb_index_verified_key(Verified),
+            Verified == Key
+        ->  true
+        ;   current_entity_index_count(Expected),
+            retractall(kb_index_verified_key(_)),
+            assertz(kb_index_verified_key(Key))
+        )
     ->  true
     ;   kb_rebuild_indexes
     ).
 
+index_verification_key(IndexCount, key(Graph, Generation, LegacyCount, IndexCount)) :-
+    (kb_graph(Graph) -> true ; Graph = none),
+    rdf_generation(Generation),
+    (   predicate_property(kb:entity(_, _, _, _), number_of_clauses(Count))
+    ->  LegacyCount = Count
+    ;   LegacyCount = 0
+    ).
+
 % Rebuild all acceleration structures from RDF/entity facts.  This is
 % intentionally disposable: no query result is written back to RDF when an
 % index is stale or externally invalidated.
@@ -1380,6 +1522,7 @@ kb_rebuild_indexes :-
         assertz(kb_index_triple_count(TripleCount)),
         retractall(kb_index_dirty),
         retractall(kb_index_ready),
+        retractall(kb_index_verified_key(_)),
         assertz(kb_index_ready)
     )).
 
@@ -1515,6 +1658,97 @@ kb_query_entities(TypeFilter, IdFilter, Tags, SourceFilter, Limit, Offset, Rows,
               kb_entity(Id, Type, Props) ),
             Rows).
 
+%% kb_query_proof_contracts(+Id, +Limit, +Offset, -Rows)
+% Page proof-campaign candidates while reading only contract and binding RDF
+% properties. In particular, do not call kb_entity/3 here: that materializes
+% complete entity properties, including potentially large receipt histories.
+% implements REQ-kibi-verification-evidence-contract
+kb_query_proof_contracts(IdFilter, Limit, Offset, Rows) :-
+    integer(Limit),
+    integer(Offset),
+    Limit >= 0,
+    Offset >= 0,
+    findall([Id, test, Projected],
+            ( limit(Limit,
+                    offset(Offset,
+                           order_by([asc(Id)],
+                                    distinct(proof_contract_candidate(IdFilter, Id))))),
+              proof_contract_properties(Id, Contract, Bindings, Source),
+              optional_projected_property(proof_bindings, Bindings,
+                                          BindingProps),
+              optional_projected_property(source, Source, SourceProps),
+              append([[id=Id, proof_contract=Contract],
+                      BindingProps, SourceProps],
+                     Projected) ),
+            Rows).
+
+optional_projected_property(_Key, Value, []) :-
+    var(Value),
+    !.
+optional_projected_property(Key, Value, [Key=Value]).
+
+proof_contract_properties(Id, Contract, Bindings) :-
+    proof_contract_properties(Id, Contract, Bindings, _Source).
+
+% Source is projected alongside the contract so per-contract receipt binding
+% can hash the authored document without materializing receipt histories.
+proof_contract_properties(Id, Contract, Bindings, Source) :-
+    (   (   kb_graph(Graph),
+            entity_id_to_uri(Id, EntityURI),
+            rdf(EntityURI, kb:type, TypeLiteral, Graph),
+            literal_to_atom(TypeLiteral, test),
+            kb_property_uri(proof_contract, ContractURI),
+            rdf(EntityURI, ContractURI, ContractLiteral, Graph)
+        )
+    ->  literal_to_value(proof_contract, ContractLiteral, Contract),
+        (   kb_property_uri(proof_bindings, BindingsURI),
+            rdf(EntityURI, BindingsURI, BindingsLiteral, Graph)
+        ->  literal_to_value(proof_bindings, BindingsLiteral, Bindings)
+        ;   true
+        ),
+        (   kb_property_uri(source, SourceURI),
+            rdf(EntityURI, SourceURI, SourceLiteral, Graph)
+        ->  literal_to_value(source, SourceLiteral, Source)
+        ;   true
+        )
+    ;   entity(test, Id, _, Properties),
+        memberchk(proof_contract=Contract, Properties),
+        (   memberchk(proof_bindings=Bindings, Properties)
+        ->  true
+        ;   true
+        ),
+        (   memberchk(source=Source, Properties)
+        ->  true
+        ;   true
+        )
+    ).
+
+%% kb_property_uri(+Key, -URI)
+% Property predicates are asserted in-session as the prefixed atom 'kb:Key',
+% but a store reloaded from its snapshot carries the expanded 'urn-kibi:Key'
+% form. Direct RDF lookups must accept both (as uri_to_key/2 already does),
+% or projections silently miss every entity of a reloaded store.
+kb_property_uri(Key, URI) :-
+    kb_uri(BaseURI),
+    atom_concat(BaseURI, Key, URI).
+kb_property_uri(Key, URI) :-
+    atom_concat('kb:', Key, URI).
+
+% implements REQ-kibi-verification-evidence-contract
+proof_contract_candidate(none, Id) :-
+    kb_graph(Graph),
+    kb_property_uri(proof_contract, ContractURI),
+    rdf(EntityURI, ContractURI, _, Graph),
+    entity_uri_to_id(EntityURI, Id),
+    rdf(EntityURI, kb:type, TypeLiteral, Graph),
+    literal_to_atom(TypeLiteral, test).
+proof_contract_candidate(none, Id) :-
+    entity(test, Id, _, Properties),
+    memberchk(proof_contract=_, Properties).
+proof_contract_candidate(some(Id), Id) :-
+    atom(Id),
+    proof_contract_properties(Id, _, _).
+
 indexed_entity_match(TypeFilter, IdFilter, Tags, SourceFilter, Id) :-
     (   IdFilter == none
     ->  kb_index_entity(Id, _)
@@ -1573,10 +1807,74 @@ kb_search_entities(TypeFilter, Query, Limit, Offset, Rows, Count) :-
     length(Ids, Count),
     drop_index_ids(Offset, Ids, Remaining),
     take_index_ids(Limit, Remaining, PageIds),
-    findall([Id, Type, Props],
-            ( member(Id, PageIds), kb_entity(Id, Type, Props) ),
+    search_candidate_rows(PageIds, Rows).
+
+%% kb_list_search_candidates(+Type, +Limit, +Offset, -Rows, -Count)
+% Page every indexed entity (optionally of one type) as projected search
+% candidate rows, ordered by id. Semantic discovery uses it when no lexical
+% token can pre-filter the candidate set.
+kb_list_search_candidates(TypeFilter, Limit, Offset, Rows, Count) :-
+    integer(Limit),
+    integer(Offset),
+    Limit >= 0,
+    Offset >= 0,
+    kb_ensure_indexes,
+    findall(Id,
+            ( kb_index_entity(Id, _),
+              (TypeFilter == none -> true ; kb_index_type(TypeFilter, Id)) ),
+            RawIds),
+    sort(RawIds, Ids),
+    length(Ids, Count),
+    drop_index_ids(Offset, Ids, Remaining),
+    take_index_ids(Limit, Remaining, PageIds),
+    search_candidate_rows(PageIds, Rows).
+
+%% kb_entity_ids(-Ids)
+% Every entity id, without materializing any properties.
+kb_entity_ids(Ids) :-
+    kb_ensure_indexes,
+    findall(Id, kb_index_entity(Id, _), RawIds),
+    sort(RawIds, Ids).
+
+% Search candidates carry only the properties ranking, snippets, and summary
+% output read. Large structured properties (receipt histories, proof
+% contracts, semantic inventories, rule IR) stay in the store: a candidate
+% page of receipt-bearing tests otherwise exceeds the bounded engine output.
+% Callers that need complete entities reload the final page by id.
+search_candidate_rows(PageIds, Rows) :-
+    findall([Id, Type, Projected],
+            ( member(Id, PageIds),
+              kb_entity(Id, Type, Props),
+              include(search_candidate_property, Props, Projected) ),
             Rows).
 
+search_candidate_property(Key=_) :-
+    search_candidate_key(Key).
+
+search_candidate_key(id).
+search_candidate_key(title).
+search_candidate_key(status).
+search_candidate_key(priority).
+search_candidate_key(severity).
+search_candidate_key(owner).
+search_candidate_key(tags).
+search_candidate_key(source).
+search_candidate_key(sourceFile).
+search_candidate_key(sourceLine).
+search_candidate_key(sourceColumn).
+search_candidate_key(sourceEndLine).
+search_candidate_key(sourceEndColumn).
+search_candidate_key(source_line).
+search_candidate_key(source_end_line).
+search_candidate_key(updated_at).
+search_candidate_key(created_at).
+search_candidate_key(semantic_text).
+search_candidate_key(text_ref).
+search_candidate_key(body).
+search_candidate_key(content).
+search_candidate_key(markdownBody).
+search_candidate_key(markdown_body).
+
 indexed_token_match(QueryToken, Id) :-
     kb_index_token(IndexedToken, Id),
     sub_atom(IndexedToken, _, _, _, QueryToken),
@@ -2269,10 +2567,14 @@ req_conflict_witness(ReqA, ReqB, Witness) :-
     FactA \= FactB,
     scope_intersects(ScopeA, ScopeB),
     intervals_overlap(ValidFromA, ValidToA, ValidFromB, ValidToB),
-    (   polarity_conflict(SubjectKey, PropertyKey, OpA, ValTypeA, ValA, UnitA, ScopeA, PolarityA,
-                          OpB, ValTypeB, ValB, UnitB, ScopeB, PolarityB, Reason)
-    ;   property_conflict(SubjectKey, PropertyKey, OpA, ValTypeA, ValA, UnitA, PolarityA,
-                          OpB, ValTypeB, ValB, UnitB, PolarityB, Reason)
+    % Compare canonical quantities (30 min == 1800 s); witnesses keep the
+    % authored values so evidence still points at the source text.
+    canonical_quantity(ValTypeA, ValA, UnitA, CanonTypeA, CanonValA, CanonUnitA),
+    canonical_quantity(ValTypeB, ValB, UnitB, CanonTypeB, CanonValB, CanonUnitB),
+    (   polarity_conflict(SubjectKey, PropertyKey, OpA, CanonTypeA, CanonValA, CanonUnitA, ScopeA, PolarityA,
+                          OpB, CanonTypeB, CanonValB, CanonUnitB, ScopeB, PolarityB, Reason)
+    ;   property_conflict(SubjectKey, PropertyKey, OpA, CanonTypeA, CanonValA, CanonUnitA, PolarityA,
+                          OpB, CanonTypeB, CanonValB, CanonUnitB, PolarityB, Reason)
     ),
     property_conflict_side(ReqA, FactA, SubjectKey, PropertyKey, OpA, ValTypeA, ValA, UnitA, ScopeA, PolarityA, ValidFromA, ValidToA, Left),
     property_conflict_side(ReqB, FactB, SubjectKey, PropertyKey, OpB, ValTypeB, ValB, UnitB, ScopeB, PolarityB, ValidFromB, ValidToB, Right),
@@ -2418,6 +2720,14 @@ fact_property_tuple(FactId, Subject, Property, Op, ValType, Value, Unit, Scope,
     ( memberchk(scope=ScopeRaw, Props) -> normalize_term_atom(ScopeRaw, Scope) ; Scope = '' ),
     ( memberchk(polarity=PolarityRaw, Props) -> normalize_term_atom(PolarityRaw, Polarity) ; Polarity = require ).
 
+%% canonical_property_tuple(+FactId, -Subject, -Property, -Op, -ValType, -Value, -Unit, -Scope, -Polarity)
+% fact_property_tuple/9 with the quantity converted to its canonical base unit
+% (units.pl). Used only for comparison; the authored fact is never rewritten.
+% implements REQ-kibi-unit-canonicalization
+canonical_property_tuple(FactId, Subject, Property, Op, CanonType, CanonValue, CanonUnit, Scope, Polarity) :-
+    fact_property_tuple(FactId, Subject, Property, Op, ValType, Value, Unit, Scope, Polarity),
+    canonical_quantity(ValType, Value, Unit, CanonType, CanonValue, CanonUnit).
+
 %% predicate_schema(+FactId, -Namespace, -Name, -Arity, -ArgumentNames, -ArgumentTypes)
 % Read one project-local ontology predicate schema fact.
 predicate_schema(FactId, Namespace, Name, Arity, ArgumentNames, ArgumentTypes) :-

package/src/requirement_proof.pl

@@ -8,6 +8,9 @@
     requirement_proof/4
 ]).
 
+% Source contains non-ASCII text; do not depend on the host locale.
+:- encoding(utf8).
+
 :- use_module(library(http/json)).
 :- use_module(library(crypto)).
 :- use_module(library(date)).
@@ -237,7 +240,47 @@ inventory_entry_field(List, Key, Value) :-
     is_list(List),
     memberchk(Key=Value, List).
 
+% Pure-function memos, content-addressed by variant_sha1/2, so they need no
+% invalidation: equal inputs always produce equal outputs. Proof evaluation
+% re-parses the same receipt histories and re-validates the same receipts on
+% every coverage run; both are bounded so a long-lived engine cannot grow them
+% without limit.
+:- dynamic pure_memo/3.
+:- dynamic pure_memo_size/1.
+
+pure_memo_limit(4096).
+
+pure_memo(Kind, Input, Goal, Output) :-
+    variant_sha1(Kind-Input, Key),
+    (   pure_memo(Key, Kind, Cached)
+    ->  Output = Cached
+    ;   call(Goal, Input, Result),
+        pure_memo_remember(Key, Kind, Result),
+        Output = Result
+    ).
+
+pure_memo_remember(Key, Kind, Output) :-
+    (   pure_memo_size(Size)
+    ->  true
+    ;   Size = 0
+    ),
+    pure_memo_limit(Limit),
+    (   Size >= Limit
+    ->  retractall(pure_memo(_, _, _)),
+        NextSize = 1
+    ;   NextSize is Size + 1
+    ),
+    retractall(pure_memo_size(_)),
+    assertz(pure_memo_size(NextSize)),
+    assertz(pure_memo(Key, Kind, Output)).
+
 inventory_entries(Raw, Entries) :-
+    (   (atom(Raw) ; string(Raw))
+    ->  pure_memo(inventory_entries, Raw, parse_inventory_entries, Entries)
+    ;   parse_inventory_entries(Raw, Entries)
+    ).
+
+parse_inventory_entries(Raw, Entries) :-
     (   is_list(Raw)
     ->  Entries = Raw
     ;   Raw = ^^(Value, _)
@@ -727,8 +770,8 @@ receipt_evidence_state(TestId, Scope, Props, Receipts, _Present, _Context,
     proof_contract_binding(Props, ContractBinding),
     (ContractBinding == invalid
     ; Receipts == []
-    ; member(Receipt, Receipts), \+ valid_receipt_shape(TestId, Receipt)
-    ; \+ chronological_receipt_history(Receipts)),
+    ; pure_memo(receipt_history_well_formed, TestId-Receipts,
+                receipt_history_well_formed, false)),
     !.
 receipt_evidence_state(TestId, Scope, Props, Receipts, _Present, Context, Evidence) :-
     receipt_for_current_mode(TestId, Context, Receipts, SnapshotReceipts),
@@ -745,6 +788,13 @@ receipt_evidence_state(TestId, Scope, Props, Receipts, _Present, Context, Eviden
         )
     ).
 
+receipt_history_well_formed(TestId-Receipts, WellFormed) :-
+    (   forall(member(Receipt, Receipts), valid_receipt_shape(TestId, Receipt)),
+        chronological_receipt_history(Receipts)
+    ->  WellFormed = true
+    ;   WellFormed = false
+    ).
+
 proof_receipt_entries(Props, Receipts, Present) :-
     (   memberchk(proof_receipts=Raw, Props)
     ->  Present = true,
@@ -889,10 +939,10 @@ receipt_for_current_mode(TestId, Context, Receipts, SnapshotReceipts) :-
     (   Context.proofBindingMode == per_contract,
         get_dict(TestId, Context.proofTestBindings, CurrentBinding)
     ->  include(receipt_with_binding_hash, Receipts, BoundReceipts),
-        include(receipt_for_binding(CurrentBinding), BoundReceipts, SnapshotReceipts),
-        (   SnapshotReceipts == []
+        include(receipt_for_binding(CurrentBinding), BoundReceipts, BindingReceipts),
+        (   BindingReceipts == []
         ->  include(receipt_for_snapshot(Context.proofSnapshot), Receipts, SnapshotReceipts)
-        ;   true
+        ;   SnapshotReceipts = BindingReceipts
         )
     ;   include(receipt_for_snapshot(Context.proofSnapshot), Receipts, SnapshotReceipts)
     ).

package/src/rule_registry.pl

@@ -34,6 +34,13 @@ known_rule('predicate-verifiability').
 known_rule('strict-readiness').
 known_rule('semantic-completeness').
 known_rule('proof-contract-symbols').
+known_rule('entity-id-style').
+known_rule('domain-redundancy').
+known_rule('domain-implication').
+known_rule('subject-key-identity').
+known_rule('subject-key-shape').
+known_rule('ontology-quality').
+known_rule('predicate-schema-conformance').
 
 rule_enforcement_class('must-priority-coverage', canonical).
 rule_enforcement_class('symbol-coverage', canonical).
@@ -55,6 +62,13 @@ rule_enforcement_class('predicate-verifiability', advisory).
 rule_enforcement_class('strict-readiness', migration).
 rule_enforcement_class('semantic-completeness', migration).
 rule_enforcement_class('proof-contract-symbols', advisory).
+rule_enforcement_class('entity-id-style', advisory).
+rule_enforcement_class('domain-redundancy', advisory).
+rule_enforcement_class('domain-implication', advisory).
+rule_enforcement_class('subject-key-identity', advisory).
+rule_enforcement_class('subject-key-shape', advisory).
+rule_enforcement_class('ontology-quality', advisory).
+rule_enforcement_class('predicate-schema-conformance', advisory).
 
 rule_implementation('must-priority-coverage', prolog).
 rule_implementation('symbol-coverage', prolog).
@@ -76,6 +90,13 @@ rule_implementation('predicate-verifiability', prolog).
 rule_implementation('strict-readiness', prolog).
 rule_implementation('semantic-completeness', prolog).
 rule_implementation('proof-contract-symbols', prolog).
+rule_implementation('entity-id-style', prolog).
+rule_implementation('domain-redundancy', prolog).
+rule_implementation('domain-implication', prolog).
+rule_implementation('subject-key-identity', prolog).
+rule_implementation('subject-key-shape', prolog).
+rule_implementation('ontology-quality', prolog).
+rule_implementation('predicate-schema-conformance', typescript).
 
 rule_predicate('must-priority-coverage', check_must_priority_coverage).
 rule_predicate('symbol-coverage', check_symbol_coverage).
@@ -95,6 +116,12 @@ rule_predicate('predicate-verifiability', check_predicate_verifiability).
 rule_predicate('strict-readiness', check_strict_readiness).
 rule_predicate('semantic-completeness', check_semantic_completeness).
 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).
+rule_predicate('domain-implication', check_domain_implication).
+rule_predicate('subject-key-identity', check_subject_key_identity).
+rule_predicate('subject-key-shape', check_subject_key_shape).
+rule_predicate('ontology-quality', check_ontology_quality).
 
 rule_predicate_arity('must-priority-coverage', 1).
 rule_predicate_arity('symbol-coverage', 1).
@@ -114,6 +141,12 @@ rule_predicate_arity('predicate-verifiability', 1).
 rule_predicate_arity('strict-readiness', 1).
 rule_predicate_arity('semantic-completeness', 1).
 rule_predicate_arity('proof-contract-symbols', 1).
+rule_predicate_arity('entity-id-style', 1).
+rule_predicate_arity('domain-redundancy', 1).
+rule_predicate_arity('domain-implication', 1).
+rule_predicate_arity('subject-key-identity', 1).
+rule_predicate_arity('subject-key-shape', 1).
+rule_predicate_arity('ontology-quality', 1).
 
 rule_description('must-priority-coverage', 'Every must-priority requirement 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').
@@ -135,3 +168,10 @@ rule_description('predicate-verifiability', 'Detect requires_predicate links tha
 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('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').
+rule_description('domain-implication', 'Informational: one requirement\'s numeric bound strictly implies another requirement\'s bound on the same subject and property').
+rule_description('subject-key-identity', 'Subject keys must name a shared component, not be derived from a requirement ID').
+rule_description('subject-key-shape', 'Subject keys follow dotted component.aspect[.sub] with lowercase snake segments').
+rule_description('ontology-quality', 'Informational: predicate schemas whose argument values mostly occur in only one fact are carrying prose instead of a shared vocabulary').
+rule_description('predicate-schema-conformance', 'Predicate facts match a predicate_schema (project-local, or the built-in catalog in the default namespace) and use its declared argument constants').