kibi-core 0.8.1 → 0.9.1

package/package.json

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

package/schema/entities.pl

@@ -29,8 +29,13 @@ entity_property(_, severity, atom).
 entity_property(_, links, list).
 entity_property(_, text_ref, uri).
 entity_property(_, sourceFile, uri).
+entity_property(req, semantic_text, string).
 entity_property(req, logic_claims, list).
-entity_property(req, semantic_inventory, list).
+entity_property(req, semantic_clauses, list).
+entity_property(req, semantic_inventory_version, string).
+entity_property(req, semantic_source_field, string).
+entity_property(req, semantic_source_hash, string).
+entity_property(req, semantic_inventory, list_or_json).
 
 % Typed fact fields - only valid for fact entities
 entity_property(fact, fact_kind, atom).
@@ -74,10 +79,15 @@ entity_property(fact, claim_span_end, integer).
 % Typed symbol metadata fields - only valid for symbol entities
 entity_property(symbol, symbol_role, atom).
 entity_property(symbol, granularity_reason, atom).
+entity_property(symbol, sourceLine, integer).
+entity_property(symbol, sourceColumn, integer).
+entity_property(symbol, sourceEndLine, integer).
+entity_property(symbol, sourceEndColumn, integer).
 
 % Typed test verification fields - only valid for test entities
 entity_property(test, verification_scope, atom).
 entity_property(test, verification_perspective, atom).
+entity_property(test, verification_receipts, string).
 
 % Required properties for all entity types
 required_property(Type, id) :- entity_type(Type).
@@ -94,10 +104,16 @@ optional_property(Type, priority) :- entity_type(Type).
 optional_property(Type, severity) :- entity_type(Type).
 optional_property(Type, links) :- entity_type(Type).
 optional_property(Type, text_ref) :- entity_type(Type).
+optional_property(req, semantic_text).
 optional_property(req, logic_claims).
+optional_property(req, semantic_clauses).
+optional_property(req, semantic_inventory_version).
+optional_property(req, semantic_source_field).
+optional_property(req, semantic_source_hash).
 optional_property(req, semantic_inventory).
 optional_property(test, verification_scope).
 optional_property(test, verification_perspective).
+optional_property(test, verification_receipts).
 
 % Documentation helpers
 % list all entity types

package/schema/validation.pl

@@ -45,6 +45,7 @@ check_kind(string, V) :- string(V).
 check_kind(atom_or_string, V) :- atom(V) ; string(V).
 check_kind(datetime, V) :- string(V). % accept ISO strings for now
 check_kind(list, V) :- is_list(V).
+check_kind(list_or_json, V) :- is_list(V) ; string(V) ; atom(V).
 check_kind(uri, V) :- string(V).
 check_kind(integer, V) :- integer(V).
 check_kind(number, V) :- number(V).
@@ -118,6 +119,7 @@ is_fact_only_field(claim_span_end).
 % is_test_only_field(+Key) - true if Key is a test-specific field
 is_test_only_field(verification_scope).
 is_test_only_field(verification_perspective).
+is_test_only_field(verification_receipts).
 
 % validate_fact_shape(+Kind, +Props)
 validate_fact_shape(subject, Props) :-

package/src/checks.pl

@@ -14,6 +14,7 @@
     check_required_fields/1,        % Returns list of missing required field violations
     check_deprecated_adrs/1,        % Returns list of deprecated ADR violations
     check_domain_contradictions/1,  % Returns list of contradiction violations
+    check_domain_contradiction_witnesses/1,
     check_strict_fact_shape/1,      % Returns list of malformed strict fact violations
     check_strict_req_fact_pairing/1,% Returns list of malformed strict req/fact pairing violations
     check_strict_readiness/1,       % Returns list of strict readiness audit violations
@@ -31,7 +32,7 @@
 :- use_module('kb.pl').
 :- use_module('../schema/entities.pl', [entity_type/1, required_property/2]).
 :- use_module('../schema/relationships.pl', [relationship_type/1]).
-:- use_module('logic_ir.pl', [logic_rule_safety/2, logic_rule_from_props/2, logic_rule_conflict/3, logic_rules_stratified/1]).
+:- use_module('logic_ir.pl', [logic_rule_safety/2, logic_rule_from_props/2, logic_rule_conflict/3, logic_rule_conflict_witness/3, logic_rules_stratified/1]).
 
 % Required fields for all entities
 required_fields([id, title, status, created_at, updated_at, source]).
@@ -587,39 +588,39 @@ checks_normalize_atom_list(Raw, Atoms) :-
 %% check_domain_contradictions(-Violations)
 % Finds all pairs of requirements with contradicting required properties.
 check_domain_contradictions(Violations) :-
-    findall(
-        violation(
-            'domain-contradictions',
-            EntityId,
-            Description,
-            "Supersede one requirement or align both to the same required property",
-            ""
-        ),
-        (   contradicting_reqs(ReqA, ReqB, Reason),
-            format(string(EntityId), "~w/~w", [ReqA, ReqB]),
-            format(string(Description), "~w [strict-readiness: contradiction-ready]", [Reason])
-        ),
-        StrictViolations
-    ),
-    findall(
-        violation(
-            'domain-contradictions',
-            EntityId,
-            Description,
-            "Align the opposing rule heads, separate their scopes, or add an explicit supersedes relationship",
-            ""
-        ),
-        (   opposing_rule_requirements(ReqA, ReqB, RuleA, RuleB),
-            logic_rule_conflict(RuleA, RuleB, Conflict),
-            Conflict \= disjoint,
-            format(string(EntityId), "~w/~w", [ReqA, ReqB]),
-            format(string(Description), "Rule conflict (~w) between ~w and ~w", [Conflict, ReqA, ReqB])
-        ),
-        RuleViolations
-    ),
-    append(StrictViolations, RuleViolations, Violations).
+    check_domain_contradiction_witnesses(Witnesses),
+    maplist(contradiction_witness_violation, Witnesses, Violations).
+
+%% check_domain_contradiction_witnesses(-Witnesses)
+% Exact, JSON-safe evidence for every strict-property, ground-predicate, and
+% safe-rule contradiction result.  Rule overlap that cannot be proven or
+% disproven remains status=unresolved rather than becoming consistency.
+check_domain_contradiction_witnesses(Witnesses) :-
+    findall(Witness, req_conflict_witness(_ReqA, _ReqB, Witness), GroundWitnesses),
+    findall(Witness, rule_contradiction_witness(Witness), RuleWitnesses),
+    append(GroundWitnesses, RuleWitnesses, Witnesses0),
+    sort(Witnesses0, Witnesses).
+
+contradiction_witness_violation(Witness, violation(
+    'domain-contradictions',
+    EntityId,
+    Description,
+    Suggestion,
+    ""
+)) :-
+    Witness.requirements = [ReqA, ReqB],
+    format(string(EntityId), "~w/~w", [ReqA, ReqB]),
+    (   Witness.kind == rule
+    ->  Description = Witness.reason,
+        Suggestion = "Align the opposing rule heads, separate their scopes, or add an explicit supersedes relationship"
+    ;   format(string(Description), "~w [strict-readiness: contradiction-ready]", [Witness.reason]),
+        Suggestion = "Supersede one requirement or align both to the same canonical logical term"
+    ).
 
 opposing_rule_requirements(ReqA, ReqB, RuleA, RuleB) :-
+    opposing_rule_requirement_facts(ReqA, ReqB, _FactA, _FactB, RuleA, RuleB).
+
+opposing_rule_requirement_facts(ReqA, ReqB, FactA, FactB, RuleA, RuleB) :-
     kb:current_req(ReqA),
     kb:current_req(ReqB),
     ReqA @< ReqB,
@@ -635,6 +636,94 @@ opposing_rule_requirements(ReqA, ReqB, RuleA, RuleB) :-
     logic_rule_from_props(PropsA, RuleA),
     logic_rule_from_props(PropsB, RuleB).
 
+rule_contradiction_witness(Witness) :-
+    opposing_rule_requirement_facts(ReqA, ReqB, FactA, FactB, RuleA, RuleB),
+    logic_rule_conflict_witness(RuleA, RuleB, InternalWitness),
+    InternalWitness.status \= disjoint,
+    rule_conflict_side(ReqA, FactA, Left),
+    rule_conflict_side(ReqB, FactB, Right),
+    rule_comparison_evidence(InternalWitness, Comparison),
+    format(string(Reason), "Rule conflict (~w) between ~w and ~w", [InternalWitness.status, ReqA, ReqB]),
+    Witness = _{
+        kind: rule,
+        status: InternalWitness.status,
+        requirements: [ReqA, ReqB],
+        reason: Reason,
+        left: Left,
+        right: Right,
+        comparison: Comparison
+    }.
+
+rule_conflict_side(ReqId, FactId, Side) :-
+    evidence_entity_source(ReqId, req, RequirementSource),
+    kb_entity(FactId, fact, Props),
+    evidence_property_text(Props, source, FactSource),
+    evidence_property_text(Props, claim_key, ClaimKey),
+    evidence_property_text(Props, claim_text, ClaimText),
+    evidence_property_text(Props, rule_hash, RuleHash),
+    evidence_property_text(Props, semantic_key, SemanticKey),
+    evidence_property_text(Props, rule_ir, RuleIr),
+    evidence_property_integer(Props, claim_span_start, ClaimSpanStart),
+    evidence_property_integer(Props, claim_span_end, ClaimSpanEnd),
+    Side = _{
+        requirementId: ReqId,
+        requirementSource: RequirementSource,
+        factId: FactId,
+        factSource: FactSource,
+        claimKey: ClaimKey,
+        claimText: ClaimText,
+        claimSpan: _{start: ClaimSpanStart, end: ClaimSpanEnd},
+        ruleHash: RuleHash,
+        semanticKey: SemanticKey,
+        ruleIr: RuleIr
+    }.
+
+rule_comparison_evidence(Internal, Evidence) :-
+    term_string(Internal.head_a, HeadA, [quoted(true), max_depth(0)]),
+    term_string(Internal.head_b, HeadB, [quoted(true), max_depth(0)]),
+    term_string(Internal.body_a, BodyA, [quoted(true), max_depth(0)]),
+    term_string(Internal.body_b, BodyB, [quoted(true), max_depth(0)]),
+    term_string(Internal.scope_a, ScopeA, [quoted(true), max_depth(0)]),
+    term_string(Internal.scope_b, ScopeB, [quoted(true), max_depth(0)]),
+    Evidence = _{
+        modalityA: Internal.modality_a,
+        modalityB: Internal.modality_b,
+        headA: HeadA,
+        headB: HeadB,
+        bodyA: BodyA,
+        bodyB: BodyB,
+        scopeA: ScopeA,
+        scopeB: ScopeB,
+        validFromA: Internal.valid_from_a,
+        validToA: Internal.valid_to_a,
+        validFromB: Internal.valid_from_b,
+        validToB: Internal.valid_to_b,
+        ruleSchemaA: Internal.rule_schema_a,
+        ruleSchemaB: Internal.rule_schema_b
+    }.
+
+evidence_entity_source(EntityId, Type, Source) :-
+    kb_entity(EntityId, Type, Props),
+    evidence_property_text(Props, source, Source).
+
+evidence_property_text(Props, Key, Text) :-
+    (memberchk(Key=Raw, Props) -> evidence_term_text(Raw, Text) ; Text = '').
+
+evidence_property_integer(Props, Key, Integer) :-
+    (memberchk(Key=Raw, Props), catch(checks_normalize_integer(Raw, Integer), _, fail) -> true ; Integer = -1).
+
+evidence_term_text(Raw, Text) :-
+    (   Raw = ^^(Value, _Type)
+    ->  evidence_term_text(Value, Text)
+    ;   Raw = literal(type(_, Value))
+    ->  evidence_term_text(Value, Text)
+    ;   atom(Raw)
+    ->  Text = Raw
+    ;   string(Raw)
+    ->  atom_string(Text, Raw)
+    ;   term_string(Raw, String), atom_string(Text, String)
+    ).
+
 %% check_strict_req_fact_pairing(-Violations)
 % Finds current requirements attempting strict-lane modeling with incomplete
 % subject/property pairing or wrong-lane fact targets.
@@ -1194,7 +1283,7 @@ inventory_entries(Raw, Entries) :-
     (   is_list(Raw) -> Entries = Raw
     ;   Raw = ^^(Value, _) -> inventory_entries(Value, Entries)
     ;   (atom(Raw) ; string(Raw)),
-        catch(atom_json_term(Raw, JsonEntries, [value_string_as(string)]), _, fail),
+        catch(atom_json_dict(Raw, JsonEntries, [value_string_as(string)]), _, fail),
         is_list(JsonEntries)
     ->  Entries = JsonEntries
     ;   Entries = []
@@ -1319,7 +1408,28 @@ pairs_to_json_pairs([Key-Violations|Rest], [Key-JsonViolations|JsonRest]) :-
 % Converts a violation(Rule, EntityId, Description, Suggestion, Source) term
 % to a JSON-compatible dict.
 violation_to_json(Violation, JsonDict) :-
-    violation_term_to_dict(Violation, JsonDict).
+    violation_term_to_dict(Violation, BaseDict),
+    (   contradiction_violation_witnesses(Violation, Witnesses),
+        Witnesses \= []
+    ->  put_dict(evidence, BaseDict, _{witnesses: Witnesses}, JsonDict)
+    ;   JsonDict = BaseDict
+    ).
+
+contradiction_violation_witnesses(
+    violation('domain-contradictions', EntityId, Description, _Suggestion, _Source),
+    Witnesses
+) :-
+    violation_id_text(EntityId, EntityIdText),
+    violation_text(Description, DescriptionText),
+    check_domain_contradiction_witnesses(AllWitnesses),
+    include(witness_matches_violation(EntityIdText, DescriptionText), AllWitnesses, Witnesses).
+
+witness_matches_violation(EntityIdText, DescriptionText, Witness) :-
+    Witness.requirements = [ReqA, ReqB],
+    format(string(ExpectedEntityId), "~w/~w", [ReqA, ReqB]),
+    ExpectedEntityId == EntityIdText,
+    violation_text(Witness.reason, ReasonText),
+    sub_string(DescriptionText, 0, _, _, ReasonText).
 
 violation_term_to_dict(violation(Rule, EntityId, Description, Suggestion, Source), JsonDict) :-
     violation_text(Rule, RuleText),

package/src/discovery.pl

@@ -4,12 +4,14 @@
 :- module(discovery, [
     find_gaps_json/8,
     coverage_report_json/7,
+    coverage_report_json/10,
     graph_expand_json/8
 ]).
 
 :- use_module(library(http/json)).
 :- use_module(library(aggregate)).
 :- use_module('kb.pl').
+:- use_module('requirement_proof.pl', [requirement_proof_context/1, requirement_proof_context/4, requirement_proof/4]).
 :- use_module('status.pl', [status_meta_dict/1]).
 :- use_module('../schema/relationships.pl', [relationship_type/1]).
 
@@ -27,7 +29,10 @@ find_gaps_json(TypeFilter, MissingRelationships, PresentRelationships, Tags, Sou
     dict_json_string(Response, JsonString).
 
 coverage_report_json(By, Tags, IncludePassing, IncludeTransitive, Limit, Offset, JsonString) :-
-    coverage_rows(By, Tags, IncludePassing, IncludeTransitive, Rows0, Summary),
+    coverage_report_json(By, Tags, IncludePassing, IncludeTransitive, Limit, Offset, unknown, '1970-01-01T00:00:00Z', 604800, JsonString).
+
+coverage_report_json(By, Tags, IncludePassing, IncludeTransitive, Limit, Offset, VerificationSnapshot, CheckedAt, MaxAgeSeconds, JsonString) :-
+    coverage_rows(By, Tags, IncludePassing, IncludeTransitive, VerificationSnapshot, CheckedAt, MaxAgeSeconds, Rows0, Summary),
     sort_dict_rows(Rows0, SortedRows),
     paginate_rows(SortedRows, Offset, Limit, Rows),
     status_meta_dict(Meta),
@@ -95,14 +100,15 @@ relationship_count(Id, Relationship, Count) :-
         (kb_relationship(Relationship, Id, _); kb_relationship(Relationship, _, Id)),
         Count).
 
-coverage_rows(req, Tags, IncludePassing, IncludeTransitive, Rows, Summary) :-
+coverage_rows(req, Tags, IncludePassing, IncludeTransitive, VerificationSnapshot, CheckedAt, MaxAgeSeconds, Rows, Summary) :-
     !,
+    requirement_proof_context(VerificationSnapshot, CheckedAt, MaxAgeSeconds, ProofContext),
     findall(Row,
-        requirement_coverage_row(Tags, IncludeTransitive, Row),
+        requirement_coverage_row(Tags, IncludeTransitive, ProofContext, Row),
         AllRows),
     filter_req_coverage_rows(IncludePassing, AllRows, Rows),
     coverage_summary(AllRows, Summary).
-coverage_rows(symbol, Tags, IncludePassing, _IncludeTransitive, Rows, Summary) :-
+coverage_rows(symbol, Tags, IncludePassing, _IncludeTransitive, _VerificationSnapshot, _CheckedAt, _MaxAgeSeconds, Rows, Summary) :-
     !,
     findall(Row,
         symbol_coverage_row(Tags, Row),
@@ -110,10 +116,23 @@ coverage_rows(symbol, Tags, IncludePassing, _IncludeTransitive, Rows, Summary) :
     filter_symbol_coverage_rows(IncludePassing, AllRows, Rows),
     length(AllRows, Total),
     include(symbol_row_fully_covered, AllRows, CoveredRows),
+    include(symbol_row_uncovered, AllRows, UncoveredRows),
+    include(symbol_row_not_applicable, AllRows, NotApplicableRows),
+    include(symbol_row_mixed_role, AllRows, MixedRoleRows),
     length(CoveredRows, Covered),
-    Uncovered is Total - Covered,
-    Summary = _{total: Total, fullyCovered: Covered, uncovered: Uncovered}.
-coverage_rows(type, _Tags, _IncludePassing, _IncludeTransitive, Rows, Summary) :-
+    length(UncoveredRows, Uncovered),
+    length(NotApplicableRows, NotApplicable),
+    length(MixedRoleRows, MixedRole),
+    Applicable is Total - NotApplicable,
+    Summary = _{
+        total: Total,
+        applicable: Applicable,
+        fullyCovered: Covered,
+        uncovered: Uncovered,
+        notApplicable: NotApplicable,
+        mixedRole: MixedRole
+    }.
+coverage_rows(type, _Tags, _IncludePassing, _IncludeTransitive, _VerificationSnapshot, _CheckedAt, _MaxAgeSeconds, Rows, Summary) :-
     findall(Type-Count,
         type_entity_count(Type, Count),
         Pairs),
@@ -121,7 +140,7 @@ coverage_rows(type, _Tags, _IncludePassing, _IncludeTransitive, Rows, Summary) :
     length(Rows, Total),
     Summary = _{total: Total}.
 
-requirement_coverage_row(Tags, IncludeTransitive, Row) :-
+requirement_coverage_row(Tags, IncludeTransitive, ProofContext, Row) :-
     kb_entity(Id, req, Props),
     matches_tags(Tags, Props),
     entity_title_status_source(Props, Title, Status, _Source),
@@ -132,7 +151,7 @@ requirement_coverage_row(Tags, IncludeTransitive, Row) :-
     count_transitive_symbols(Id, IncludeTransitive, TransitiveSymbolCount),
     requirement_coverage_state(Id, Props, Gaps, Evaluated, CoverageStatus),
     requirement_coverage_depth(Id, ScenarioCount, CoverageDepth, CoverageEvidence),
-    Row = _{
+    BaseRow = _{
         id: Id,
         type: req,
         title: Title,
@@ -151,7 +170,9 @@ requirement_coverage_row(Tags, IncludeTransitive, Row) :-
         scenarioTests: CoverageEvidence.scenarioTests,
         testStatuses: CoverageEvidence.testStatuses,
         verificationScopes: CoverageEvidence.verificationScopes
-    }.
+    },
+    requirement_proof(Id, Props, ProofContext, Proof),
+    put_dict(Proof, BaseRow, Row).
 
 symbol_coverage_row(Tags, Row) :-
     kb_entity(Id, symbol, Props),
@@ -159,19 +180,32 @@ symbol_coverage_row(Tags, Row) :-
     entity_title_status_source(Props, Title, Status, _Source),
     count_direct_requirements(Id, DirectRequirementCount),
     count_direct_tests(Id, TestCount),
-    (   symbol_no_req_coverage(Id, _)
-    ->  Gaps = [missing_requirement],
+    count_executable_tests(Id, ExecutableTestCount),
+    (   mixed_role_symbol(Id)
+    ->  TraceabilityRole = mixed,
+        Gaps = [invalid_mixed_symbol_role],
         CoverageStatus = uncovered
-    ;   Gaps = [],
-        CoverageStatus = fully_covered
+    ;   executable_test_symbol(Id)
+    ->  TraceabilityRole = executable_test,
+        Gaps = [],
+        CoverageStatus = not_applicable
+    ;   TraceabilityRole = production,
+        (   symbol_no_req_coverage(Id, _)
+        ->  Gaps = [missing_requirement],
+            CoverageStatus = uncovered
+        ;   Gaps = [],
+            CoverageStatus = fully_covered
+        )
     ),
     Row = _{
         id: Id,
         type: symbol,
         title: Title,
         status: Status,
+        traceabilityRole: TraceabilityRole,
         directRequirementCount: DirectRequirementCount,
         testCount: TestCount,
+        executableTestCount: ExecutableTestCount,
         gaps: Gaps,
         coverageStatus: CoverageStatus
     }.
@@ -185,6 +219,10 @@ coverage_summary(Rows, Summary) :-
     include(req_row_missing_scenario, Rows, MissingScenarioRows),
     include(req_row_missing_test, Rows, MissingTestRows),
     include(req_row_missing_both, Rows, MissingBothRows),
+    include(req_row_proof_proven, Rows, ProofProvenRows),
+    include(req_row_proof_unresolved, Rows, ProofUnresolvedRows),
+    include(req_row_proof_missing, Rows, ProofMissingRows),
+    include(req_row_proof_not_applicable, Rows, ProofNotApplicableRows),
     length(EvaluatedRows, Evaluated),
     length(FullyCoveredRows, FullyCovered),
     length(UncoveredRows, Uncovered),
@@ -192,6 +230,10 @@ coverage_summary(Rows, Summary) :-
     length(MissingScenarioRows, MissingScenario),
     length(MissingTestRows, MissingTest),
     length(MissingBothRows, MissingScenarioAndTest),
+    length(ProofProvenRows, ProofProven),
+    length(ProofUnresolvedRows, ProofUnresolved),
+    length(ProofMissingRows, ProofMissing),
+    length(ProofNotApplicableRows, ProofNotApplicable),
     Summary = _{
         total: Total,
         evaluated: Evaluated,
@@ -200,7 +242,11 @@ coverage_summary(Rows, Summary) :-
         notApplicable: NotApplicable,
         missingScenario: MissingScenario,
         missingTest: MissingTest,
-        missingScenarioAndTest: MissingScenarioAndTest
+        missingScenarioAndTest: MissingScenarioAndTest,
+        proofProven: ProofProven,
+        proofUnresolved: ProofUnresolved,
+        proofMissing: ProofMissing,
+        proofNotApplicable: ProofNotApplicable
     }.
 
 req_row_fully_covered(Row) :-
@@ -221,10 +267,24 @@ req_row_missing_test(Row) :-
     Row.gaps = [missing_test].
 req_row_missing_both(Row) :-
     Row.gaps = [missing_scenario_and_test].
+req_row_proof_proven(Row) :-
+    Row.proofStatus == proven.
+req_row_proof_unresolved(Row) :-
+    Row.proofStatus == unresolved.
+req_row_proof_missing(Row) :-
+    Row.proofStatus == missing.
+req_row_proof_not_applicable(Row) :-
+    Row.proofStatus == not_applicable.
 
 symbol_row_fully_covered(Row) :-
     CoverageStatus = Row.get(coverageStatus),
     CoverageStatus = fully_covered.
+symbol_row_uncovered(Row) :-
+    Row.coverageStatus == uncovered.
+symbol_row_not_applicable(Row) :-
+    Row.coverageStatus == not_applicable.
+symbol_row_mixed_role(Row) :-
+    Row.traceabilityRole == mixed.
 
 count_distinct_targets(Relationship, Id, source, Count) :-
     !,
@@ -235,7 +295,8 @@ count_distinct_targets(Relationship, Id, source, Count) :-
 requirement_test_count(Id, Count) :-
     findall(TestId, kb_relationship(verified_by, Id, TestId), Verified0),
     findall(TestId, kb_relationship(validates, TestId, Id), Validates0),
-    append(Verified0, Validates0, Combined0),
+    findall(TestId, scenario_requirement_test(Id, TestId), ScenarioTests0),
+    append([Verified0, Validates0, ScenarioTests0], Combined0),
     sort(Combined0, Combined),
     length(Combined, Count).
 
@@ -381,6 +442,11 @@ count_direct_tests(Id, Count) :-
     sort(TestIds0, TestIds),
     length(TestIds, Count).
 
+count_executable_tests(Id, Count) :-
+    findall(TestId, kb_relationship(executable_for, Id, TestId), TestIds0),
+    sort(TestIds0, TestIds),
+    length(TestIds, Count).
+
 requirement_gap_list(Id, [Reason]) :-
     coverage_gap(Id, Reason),
     !.
@@ -399,11 +465,15 @@ requirement_coverage_state(_Id, _Props, [], false, not_applicable).
 
 filter_req_coverage_rows(true, Rows, Rows).
 filter_req_coverage_rows(false, Rows, Filtered) :-
-    exclude(req_row_fully_covered, Rows, Filtered).
+    exclude(req_row_proof_passing, Rows, Filtered).
+
+req_row_proof_passing(Row) :-
+    Status = Row.proofStatus,
+    memberchk(Status, [proven, not_applicable]).
 
 filter_symbol_coverage_rows(true, Rows, Rows).
 filter_symbol_coverage_rows(false, Rows, Filtered) :-
-    exclude(symbol_row_fully_covered, Rows, Filtered).
+    include(symbol_row_uncovered, Rows, Filtered).
 
 entity_priority(Props, Priority) :-
     (   memberchk(priority=PriorityValue, Props)