kibi-core 0.12.0 → 0.14.0

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)).
@@ -77,10 +80,10 @@ requirement_proof(ReqId, ReqProps, Context, Proof) :-
     logic_grounding_stage(ReqId, ReqProps, Inventory, Context, LogicStage),
     contradiction_stage(ReqId, LogicStage.status, Context, ContradictionStage),
     scenario_stage(ReqId, ScenarioStage, ScenarioIds),
-    scenario_test_stage(ScenarioIds, ScenarioTestStage, _ScenarioTests),
+    scenario_test_stage(ScenarioIds, ScenarioTestStage, ScenarioTests),
     passing_e2e_stage(ScenarioTestStage, Context, PassingE2eStage, PassingE2eTests),
     executable_symbol_stage(PassingE2eTests, ExecutableStage, ExecutableSymbols),
-    production_symbol_stage(ReqId, PassingE2eTests, ProductionStage, ProductionSymbols),
+    production_symbol_stage(ReqId, PassingE2eTests, ScenarioTests, PassingE2eStage.receiptEvidence, Context, ProductionStage, ProductionSymbols),
     source_coordinate_stage(ReqProps, ExecutableSymbols, ProductionSymbols, CoordinateStage),
     Stages = _{
         semanticInventory: SemanticStage,
@@ -103,7 +106,8 @@ requirement_proof(ReqId, ReqProps, Context, Proof) :-
         proofGaps: Gaps,
         proofAdvisories: Advisories,
         proofRepairs: Repairs,
-        proofStages: Stages
+        proofStages: Stages,
+        testResolutions: ScenarioTestStage.resolutions
     }.
 
 exempt_requirement_proof(Reason, Proof) :-
@@ -236,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, _)
@@ -532,6 +576,7 @@ scenario_test_stage(ScenarioIds, Stage, ScenarioTests) :-
     ;   Status = passed
     ),
     maplist(entity_source_ref, ScenarioTests, Sources),
+    maplist(test_resolution_record, ScenarioTests, Resolutions),
     Stage = _{
         status: Status,
         scenarios: ScenarioIds,
@@ -539,7 +584,8 @@ scenario_test_stage(ScenarioIds, Stage, ScenarioTests) :-
         scenarioTestTargets: ScenarioTestTargets,
         invalidScenarioTestTargets: InvalidScenarioTestTargets,
         sources: Sources,
-        obligations: Obligations
+        obligations: Obligations,
+        resolutions: Resolutions
     }.
 
 scenario_test_obligation(ScenarioId, Obligation) :-
@@ -724,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),
@@ -742,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,
@@ -1069,6 +1122,14 @@ test_missing_executable_symbol(TestId) :-
     \+ (kb_relationship(executable_for, SymbolId, TestId), kb_entity(SymbolId, symbol, _)).
 
 production_symbol_stage(ReqId, PassingE2eTests, Stage, ProductionSymbols) :-
+    findall(TestId,
+        (kb_relationship(specified_by, ReqId, ScenarioId),
+         scenario_test(ScenarioId, TestId)),
+        ScenarioTests0),
+    sort(ScenarioTests0, ScenarioTests),
+    production_symbol_stage(ReqId, PassingE2eTests, ScenarioTests, [], _{}, Stage, ProductionSymbols).
+
+production_symbol_stage(ReqId, PassingE2eTests, ScenarioTests, ReceiptEvidence, Context, Stage, ProductionSymbols) :-
     findall(SymbolId,
         (kb_relationship(implements, SymbolId, ReqId),
          kb_entity(SymbolId, symbol, _),
@@ -1080,12 +1141,16 @@ production_symbol_stage(ReqId, PassingE2eTests, Stage, ProductionSymbols) :-
     include(symbol_not_covered_by_tests(PassingE2eTests), ProductionSymbols, UncoveredSymbols),
     production_stage_status(ProductionSymbols, StructuralSymbols, PassingE2eTests, UncoveredSymbols, Status, StatusReason),
     maplist(symbol_coordinate_ref, ProductionSymbols, Coordinates),
+    production_coverage_explanations(
+        ReqId, ProductionSymbols, StructuralSymbols, UncoveredSymbols,
+        PassingE2eTests, ScenarioTests, ReceiptEvidence, Context, Explanations),
     StageBase = _{
         status: Status,
         symbols: ProductionSymbols,
         structuralSymbols: StructuralSymbols,
         uncoveredSymbols: UncoveredSymbols,
-        coordinates: Coordinates
+        coordinates: Coordinates,
+        explanations: Explanations
     },
     (   Status == passed
     ->  Stage = StageBase
@@ -1127,6 +1192,271 @@ production_stage_status(ProductionSymbols, StructuralSymbols, PassingE2eTests, U
 symbol_not_covered_by_tests(Tests, SymbolId) :-
     \+ (member(TestId, Tests), kb_relationship(covered_by, SymbolId, TestId)).
 
+production_coverage_explanations(ReqId, ProductionSymbols, StructuralSymbols, UncoveredSymbols,
+        PassingE2eTests, ScenarioTests, ReceiptEvidence, Context, Explanations) :-
+    maplist(production_symbol_explanation(ReqId, UncoveredSymbols, PassingE2eTests, ScenarioTests, ReceiptEvidence, Context),
+            ProductionSymbols, ProductionExplanations),
+    maplist(structural_symbol_explanation(ReqId, PassingE2eTests, ScenarioTests, ReceiptEvidence, Context),
+            StructuralSymbols, StructuralExplanations),
+    append(ProductionExplanations, StructuralExplanations, Explanations).
+
+structural_symbol_explanation(ReqId, PassingE2eTests, ScenarioTests, ReceiptEvidence, Context, SymbolId, Explanation) :-
+    symbol_classification(SymbolId, Classification),
+    symbol_coverage_candidates(structural, PassingE2eTests, ScenarioTests, ReceiptEvidence, Context, SymbolId, Candidates),
+    explanation_reason_text(structural_unit_contract, ReasonText),
+    Explanation = _{
+        symbolId: SymbolId,
+        requirementId: ReqId,
+        classification: Classification,
+        status: covered,
+        reason: structural_unit_contract,
+        reasonText: ReasonText,
+        coverageCandidates: Candidates
+    }.
+
+production_symbol_explanation(ReqId, UncoveredSymbols, PassingE2eTests, ScenarioTests, ReceiptEvidence, Context, SymbolId, Explanation) :-
+    symbol_classification(SymbolId, Classification),
+    symbol_coverage_candidates(behavioral, PassingE2eTests, ScenarioTests, ReceiptEvidence, Context, SymbolId, Candidates),
+    production_symbol_rollup(UncoveredSymbols, PassingE2eTests, SymbolId, Candidates, Status, Reason),
+    explanation_reason_text(Reason, ReasonText),
+    Explanation = _{
+        symbolId: SymbolId,
+        requirementId: ReqId,
+        classification: Classification,
+        status: Status,
+        reason: Reason,
+        reasonText: ReasonText,
+        coverageCandidates: Candidates
+    }.
+
+production_symbol_rollup(_Uncovered, [], _SymbolId, _Candidates, uncovered, stage_blocked_no_passing_e2e) :-
+    !.
+production_symbol_rollup(UncoveredSymbols, _Passing, SymbolId, Candidates, uncovered, Reason) :-
+    memberchk(SymbolId, UncoveredSymbols),
+    !,
+    (Candidates == [] -> Reason = covered_by_missing ; Reason = no_qualifying_e2e_coverage).
+production_symbol_rollup(_Uncovered, _Passing, _SymbolId, _Candidates, covered, covered).
+
+symbol_classification(SymbolId, Classification) :-
+    kb_entity(SymbolId, symbol, Props),
+    memberchk(symbol_role=RawRole, Props),
+    normalize_atom(RawRole, Role),
+    Role \= '',
+    !,
+    Classification = Role.
+symbol_classification(_SymbolId, unknown).
+
+symbol_coverage_candidates(Mode, PassingE2eTests, ScenarioTests, ReceiptEvidence, Context, SymbolId, Candidates) :-
+    findall(TestId, kb_relationship(covered_by, SymbolId, TestId), TestIds0),
+    sort(TestIds0, TestIds),
+    maplist(coverage_candidate_dict(Mode, PassingE2eTests, ScenarioTests, ReceiptEvidence, Context), TestIds, Candidates).
+
+coverage_candidate_dict(Mode, PassingE2eTests, ScenarioTests, ReceiptEvidence, Context, TestId, Candidate) :-
+    coverage_candidate_qualification(Mode, PassingE2eTests, ScenarioTests, ReceiptEvidence, Context, TestId, Qualifies, Primary, Secondaries),
+    explanation_reason_text(Primary, ReasonText),
+    cheap_candidate_scope(TestId, Scope),
+    reused_receipt_state(ReceiptEvidence, TestId, ReceiptState),
+    CandidateBase = _{
+        testId: TestId,
+        relationship: covered_by,
+        qualifies: Qualifies,
+        reason: Primary,
+        reasonText: ReasonText,
+        secondaryReasons: Secondaries,
+        scope: Scope
+    },
+    (   ReceiptState == none
+    ->  Candidate = CandidateBase
+    ;   put_dict(receiptState, CandidateBase, ReceiptState, Candidate)
+    ).
+
+% Shared candidate evaluator. Mode selects the coverage contract:
+%   behavioral  — production symbols require passing scenario-backed E2E
+%   structural  — type-shape symbols may also qualify via a unit contract
+coverage_candidate_qualification(_Mode, PassingE2eTests, _ScenarioTests, _ReceiptEvidence, _Context, TestId, true, covered, []) :-
+    memberchk(TestId, PassingE2eTests),
+    !.
+coverage_candidate_qualification(_Mode, _Passing, _Scenario, _Evidence, _Context, TestId, false, missing_test_entity, []) :-
+    \+ kb_entity(TestId, test, _),
+    !.
+coverage_candidate_qualification(structural, _Passing, _Scenario, _Evidence, _Context, TestId, true, structural_unit_contract, []) :-
+    structural_unit_contract_test(TestId),
+    !.
+coverage_candidate_qualification(_Mode, _Passing, ScenarioTests, ReceiptEvidence, Context, TestId, false, Primary, Secondaries) :-
+    cheap_scope_reject_reason(TestId, ScopeReason),
+    (   \+ memberchk(TestId, ScenarioTests)
+    ->  Primary = test_not_in_requirement_scenario_chain,
+        maybe_singleton(ScopeReason, ScopeSecondaries),
+        reused_receipt_reject_reasons(ReceiptEvidence, TestId, ReceiptSecondaries),
+        append(ScopeSecondaries, ReceiptSecondaries, Secondaries)
+    ;   ScopeReason \= none
+    ->  Primary = ScopeReason,
+        reused_receipt_reject_reasons(ReceiptEvidence, TestId, Secondaries)
+    ;   receipt_reject_for_in_chain(ReceiptEvidence, Context, TestId, Primary, Secondaries)
+    ).
+
+structural_unit_contract_test(TestId) :-
+    kb_entity(TestId, test, TestProps),
+    test_scope(TestProps, unit),
+    memberchk(status=RawStatus, TestProps),
+    normalize_atom(RawStatus, Status),
+    memberchk(Status, [active, passing]).
+
+cheap_candidate_scope(TestId, Scope) :-
+    kb_entity(TestId, test, Props),
+    !,
+    test_scope(Props, Scope).
+cheap_candidate_scope(_TestId, unknown).
+
+cheap_scope_reject_reason(TestId, Reason) :-
+    cheap_candidate_scope(TestId, Scope),
+    scope_reject_reason(Scope, Reason).
+
+scope_reject_reason(unit, test_scope_is_unit) :- !.
+scope_reject_reason(end_to_end, none) :- !.
+scope_reject_reason(_Scope, test_scope_is_non_e2e).
+
+maybe_singleton(none, []) :- !.
+maybe_singleton(Reason, [Reason]).
+
+reused_receipt_state(Evidence, TestId, State) :-
+    member(Item, Evidence),
+    Item.testId == TestId,
+    !,
+    State = Item.state.
+reused_receipt_state(_Evidence, _TestId, none).
+
+reused_receipt_item(Evidence, TestId, Item) :-
+    member(Item, Evidence),
+    Item.testId == TestId,
+    !.
+
+reused_receipt_reject_reasons(Evidence, TestId, Reasons) :-
+    reused_receipt_item(Evidence, TestId, Item),
+    !,
+    receipt_item_reject_reason(Item, Reason),
+    maybe_singleton(Reason, Reasons).
+reused_receipt_reject_reasons(_Evidence, _TestId, []).
+
+receipt_reject_for_in_chain(Evidence, _Context, TestId, Primary, []) :-
+    reused_receipt_item(Evidence, TestId, Item),
+    !,
+    receipt_item_reject_reason(Item, Reason),
+    (Reason == none -> Primary = no_qualifying_e2e_coverage ; Primary = Reason).
+receipt_reject_for_in_chain(_Evidence, Context, TestId, Primary, []) :-
+    is_dict(Context),
+    Context \= _{},
+    test_receipt_evidence(Context, TestId, Evidence),
+    !,
+    receipt_item_reject_reason(Evidence, Reason),
+    (Reason == none -> Primary = no_qualifying_e2e_coverage ; Primary = Reason).
+receipt_reject_for_in_chain(_Evidence, _Context, _TestId, no_qualifying_e2e_coverage, []).
+
+receipt_item_reject_reason(Item, stale_proof_receipt) :-
+    Item.state == stale,
+    get_dict(codeSnapshot, Item, _),
+    !.
+receipt_item_reject_reason(Item, receipt_snapshot_mismatch) :-
+    Item.state == stale,
+    !.
+receipt_item_reject_reason(Item, Reason) :-
+    receipt_state_reject_reason(Item.state, Reason).
+
+receipt_state_reject_reason(missing, missing_proof_receipt) :- !.
+receipt_state_reject_reason(snapshot_unavailable, proof_snapshot_unavailable) :- !.
+receipt_state_reject_reason(contract_mismatch, receipt_contract_mismatch) :- !.
+receipt_state_reject_reason(invalid, invalid_proof_receipt) :- !.
+receipt_state_reject_reason(failed, failed_proof_receipt) :- !.
+receipt_state_reject_reason(not_end_to_end, none) :- !.
+receipt_state_reject_reason(stale, receipt_snapshot_mismatch) :- !.
+receipt_state_reject_reason(passed, none) :- !.
+receipt_state_reject_reason(none, none) :- !.
+receipt_state_reject_reason(_, none).
+
+explanation_reason_text(Reason, Text) :-
+    explanation_reason_text_def(Reason, Text),
+    !.
+explanation_reason_text(Reason, Reason) :-
+    atom(Reason).
+
+explanation_reason_text_def(covered, "Qualifying covered_by to a passing scenario-backed E2E test").
+explanation_reason_text_def(covered_by_missing, "No covered_by relationship to any test").
+explanation_reason_text_def(no_qualifying_e2e_coverage, "covered_by relationships exist but none qualify as passing scenario-backed E2E coverage").
+explanation_reason_text_def(structural_unit_contract, "type-shape symbol is satisfied by a unit structural contract").
+explanation_reason_text_def(executable_test, "Symbol is executable test code linked with executable_for").
+explanation_reason_text_def(stage_blocked_no_passing_e2e, "Production coverage cannot be evaluated because no passing E2E evidence is available for the current snapshot").
+explanation_reason_text_def(missing_test_entity, "covered_by target is not a test entity").
+explanation_reason_text_def(test_not_in_requirement_scenario_chain, "Test is not in this requirement's scenario chain").
+explanation_reason_text_def(test_scope_is_unit, "Test verification_scope is unit, which cannot cover behavioral production symbols").
+explanation_reason_text_def(test_scope_is_non_e2e, "Test verification_scope is not end_to_end").
+explanation_reason_text_def(proof_snapshot_unavailable, "Workspace snapshot is unavailable so receipt currency cannot be proven").
+explanation_reason_text_def(missing_proof_receipt, "Scenario-backed E2E test has no kibi.proof-receipt.v1").
+explanation_reason_text_def(receipt_snapshot_mismatch, "Receipts exist but none match the current snapshot or binding").
+explanation_reason_text_def(stale_proof_receipt, "Current-snapshot receipt is older than the allowed proof age").
+explanation_reason_text_def(receipt_contract_mismatch, "Receipt does not match the current proof contract hash or fingerprint").
+explanation_reason_text_def(invalid_proof_receipt, "Receipt evidence is malformed or otherwise uncheckable").
+explanation_reason_text_def(failed_proof_receipt, "Latest current receipt outcome is not passed").
+
+test_resolution_record(TestId, _{
+    testId: TestId,
+    requiredProofs: RequiredProofs,
+    executableFor: ExecutableFor
+}) :-
+    test_required_proof_refs(TestId, RequiredProofs),
+    test_executable_for_refs(TestId, ExecutableFor).
+
+test_required_proof_refs(TestId, Refs) :-
+    kb_entity(TestId, test, Props),
+    memberchk(proof_contract=RawContract, Props),
+    proof_contract_dict(RawContract, Contract),
+    contract_required_symbol_ids(Contract, SymbolIds),
+    !,
+    maplist(symbol_resolution_ref, SymbolIds, Refs).
+test_required_proof_refs(_TestId, []).
+
+contract_required_symbol_ids(Contract, SymbolIds) :-
+    (   get_dict(required_proofs, Contract, Raw)
+    ;   get_dict('required_proofs', Contract, Raw)
+    ),
+    !,
+    inventory_entries(Raw, Entries),
+    findall(SymbolId,
+        (member(Entry, Entries), required_proof_entry_symbol(Entry, SymbolId)),
+        SymbolIds0),
+    sort(SymbolIds0, SymbolIds).
+contract_required_symbol_ids(_, []).
+
+required_proof_entry_symbol(Entry, SymbolId) :-
+    (   inventory_entry_field(Entry, symbol_id, Raw)
+    ;   inventory_entry_field(Entry, symbolId, Raw)
+    ),
+    normalize_atom(Raw, SymbolId),
+    SymbolId \= ''.
+
+test_executable_for_refs(TestId, Refs) :-
+    findall(SymbolId,
+        (kb_relationship(executable_for, SymbolId, TestId), kb_entity(SymbolId, symbol, _)),
+        SymbolIds0),
+    sort(SymbolIds0, SymbolIds),
+    maplist(symbol_resolution_ref, SymbolIds, Refs).
+
+symbol_resolution_ref(SymbolId, Ref) :-
+    kb_entity(SymbolId, symbol, _),
+    !,
+    symbol_coordinate_ref(SymbolId, Coord),
+    symbol_classification(SymbolId, Role),
+    put_dict(_{role: Role, exists: true}, Coord, Ref).
+symbol_resolution_ref(SymbolId, _{
+    id: SymbolId,
+    sourceFile: '',
+    sourceLine: 0,
+    sourceColumn: 0,
+    sourceEndLine: 0,
+    sourceEndColumn: 0,
+    role: unresolved,
+    exists: false
+}).
+
 source_coordinate_stage(ReqProps, ExecutableSymbols, ProductionSymbols, Stage) :-
     append(ExecutableSymbols, ProductionSymbols, Symbols0),
     sort(Symbols0, Symbols),

package/src/rule_registry.pl

@@ -33,6 +33,14 @@ known_rule('strict-req-fact-pairing').
 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).
@@ -53,6 +61,14 @@ 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('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).
@@ -73,6 +89,14 @@ rule_implementation('strict-req-fact-pairing', prolog).
 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).
@@ -91,6 +115,13 @@ 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('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).
@@ -109,6 +140,13 @@ 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('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').
@@ -129,3 +167,11 @@ 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('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').