kibi-core 0.6.4 → 0.7.1

package/package.json

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

package/schema/entities.pl

@@ -29,6 +29,7 @@ entity_property(_, severity, atom).
 entity_property(_, links, list).
 entity_property(_, text_ref, uri).
 entity_property(_, sourceFile, uri).
+entity_property(req, logic_claims, list).
 
 % Typed fact fields - only valid for fact entities
 entity_property(fact, fact_kind, atom).
@@ -47,6 +48,8 @@ entity_property(fact, closed_world, boolean).
 entity_property(fact, valid_from, datetime).
 entity_property(fact, valid_to, datetime).
 entity_property(fact, canonical_key, string).
+entity_property(fact, claim_key, string).
+entity_property(fact, claim_text, string).
 entity_property(fact, predicate_name, string).
 entity_property(fact, predicate_namespace, string).
 entity_property(fact, predicate_arity, integer).
@@ -57,6 +60,10 @@ entity_property(fact, aliases, list).
 entity_property(fact, examples, list).
 entity_property(fact, predicate_args, list).
 
+% Typed symbol metadata fields - only valid for symbol entities
+entity_property(symbol, symbol_role, atom).
+entity_property(symbol, granularity_reason, atom).
+
 % Typed test verification fields - only valid for test entities
 entity_property(test, verification_scope, atom).
 entity_property(test, verification_perspective, atom).
@@ -76,6 +83,7 @@ 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, logic_claims).
 optional_property(test, verification_scope).
 optional_property(test, verification_perspective).
 

package/schema/validation.pl

@@ -59,17 +59,24 @@ validate_entity_shape(fact, Props) :-
     !,
     valid_optional_fact_enums(Props),
     valid_polarity_in_props(Props),
+    valid_claim_provenance(Props),
     ( memberchk(fact_kind=RawKind, Props) -> validate_fact_shape(RawKind, Props) ; true ).
 validate_entity_shape(test, Props) :-
     !,
     valid_optional_test_enums(Props),
     forall(member(Key=_, Props), \+ is_fact_only_field(Key)).
+validate_entity_shape(req, Props) :-
+    !,
+    forall(member(Key=_, Props), \+ is_fact_only_field(Key)),
+    forall(member(Key=_, Props), \+ is_test_only_field(Key)).
 validate_entity_shape(Type, Props) :-
     Type \= fact,
     Type \= test,
+    Type \= req,
     % Non-fact/non-test entities cannot have type-specific fields
     forall(member(Key=_, Props), \+ is_fact_only_field(Key)),
-    forall(member(Key=_, Props), \+ is_test_only_field(Key)).
+    forall(member(Key=_, Props), \+ is_test_only_field(Key)),
+    forall(member(Key=_, Props), Key \= logic_claims).
 
 % is_fact_only_field(+Key) - true if Key is a fact-specific field
 is_fact_only_field(fact_kind).
@@ -88,6 +95,8 @@ is_fact_only_field(closed_world).
 is_fact_only_field(valid_from).
 is_fact_only_field(valid_to).
 is_fact_only_field(canonical_key).
+is_fact_only_field(claim_key).
+is_fact_only_field(claim_text).
 is_fact_only_field(predicate_name).
 is_fact_only_field(predicate_namespace).
 is_fact_only_field(predicate_arity).
@@ -172,6 +181,18 @@ valid_strict_polarity_in_props(Props) :-
 valid_predicate_polarity_in_props(Props) :-
     ( memberchk(polarity=P, Props) -> valid_predicate_polarity(P) ; true ).
 
+% claim_key and claim_text form one auditable provenance pair.
+valid_claim_provenance(Props) :-
+    (   memberchk(claim_key=Key, Props)
+    ->  memberchk(claim_text=Text, Props),
+        nonempty_claim_value(Key),
+        nonempty_claim_value(Text)
+    ;   \+ memberchk(claim_text=_, Props)
+    ).
+
+nonempty_claim_value(Value) :- string(Value), Value \= "".
+nonempty_claim_value(Value) :- atom(Value), Value \= ''.
+
 % valid_optional_fact_enums(+Props)
 % Validates enum-typed fact fields whenever they are present
 valid_optional_fact_enums(Props) :-

package/src/checks.pl

@@ -17,6 +17,8 @@
     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
+    check_predicate_verifiability/1,% Returns list of unverifiable predicate-lane requirement links
+    check_logic_coverage/1,         % Returns list of incomplete declared logical claim manifests
     run_checks_json/0,              % Entry point for JSON output
     violation_id_text/2             % Extract text from entity ID term (exported for testing)
 ]).
@@ -52,6 +54,8 @@ check_all(ViolationsDict) :-
     check_strict_fact_shape(StrictFactShape),
     check_strict_req_fact_pairing(StrictReqFactPairing),
     check_strict_readiness(StrictReadiness),
+    check_predicate_verifiability(PredicateVerifiability),
+    check_logic_coverage(LogicCoverage),
     ViolationsDict = _{
         must_priority_coverage: MustPriority,
         symbol_coverage: SymbolCoverage,
@@ -63,7 +67,9 @@ check_all(ViolationsDict) :-
         domain_contradictions: Contradictions,
         strict_fact_shape: StrictFactShape,
         strict_req_fact_pairing: StrictReqFactPairing,
-        strict_readiness: StrictReadiness
+        strict_readiness: StrictReadiness,
+        predicate_verifiability: PredicateVerifiability,
+        logic_coverage: LogicCoverage
     }.
 
 %% check_must_priority_coverage(-Violations)
@@ -132,7 +138,6 @@ symbol_traceability_violation(RequireAdr, violation(
     Source
 )) :-
     kb_entity(SymbolId, symbol, _),
-    \+ executable_test_symbol(SymbolId),
     % Check if symbol has direct requirement ownership
     (   symbol_owns_requirement(SymbolId, ReqId),
         kb_entity(ReqId, req, _)
@@ -148,6 +153,7 @@ symbol_traceability_violation(RequireAdr, violation(
         )
     ;   HasAdr = true  % Not required, so pass this check
     ),
+    \+ executable_test_symbol(SymbolId),
     % Determine what is missing
     (   HasReq = false, HasAdr = false, RequireAdr = true ->
         Description = "Symbol has no direct requirement ownership and no ADR constraint.",
@@ -307,15 +313,14 @@ missing_required_field(Required, violation(
 )) :-
     kb_entity(EntityId, _Type, Props),
     member(Field, Required),
-    \+ memberchk(Field=_, Props),
-    
-    format(string(Description), "Missing required field: ~w", [Field]),
-    format(string(Suggestion), "Add ~w to entity definition", [Field]),
-    
     (   memberchk(source=Source, Props)
     ->  true
     ;   Source = ""
-    ).
+    ),
+    \+ memberchk(Field=_, Props),
+
+    format(string(Description), "Missing required field: ~w", [Field]),
+    format(string(Suggestion), "Add ~w to entity definition", [Field]).
 
 %% check_deprecated_adrs(-Violations)
 % Finds all deprecated ADRs without successors.
@@ -428,8 +433,7 @@ property_value_shape_error(Props, "Property value fact missing required field: v
     \+ memberchk(value_type=_, Props).
 property_value_shape_error(Props, "Property value fact missing value field (value_string, value_int, value_number, or value_bool)") :-
     memberchk(value_type=_, Props),
-    \+ (memberchk(value_string=_, Props); memberchk(value_int=_, Props); 
-        memberchk(value_number=_, Props); memberchk(value_bool=_, Props)).
+    \+ has_value_field(Props).
 property_value_shape_error(Props, "Property value fact has multiple value fields (should have exactly one)") :-
     findall(F, (member(F=_, Props), is_value_field(F)), Fields),
     length(Fields, Count),
@@ -445,6 +449,11 @@ is_value_field(value_int).
 is_value_field(value_number).
 is_value_field(value_bool).
 
+has_value_field(Props) :- memberchk(value_string=_, Props), !.
+has_value_field(Props) :- memberchk(value_int=_, Props), !.
+has_value_field(Props) :- memberchk(value_number=_, Props), !.
+has_value_field(Props) :- memberchk(value_bool=_, Props), !.
+
 % value_type_matches_field(+ValueType, +Props)
 value_type_matches_field(string, Props) :- memberchk(value_string=_, Props), !.
 value_type_matches_field(int, Props) :- memberchk(value_int=_, Props), !.
@@ -752,6 +761,175 @@ strict_readiness_level(ReqId, traceable) :-
     !.
 strict_readiness_level(_ReqId, prose_only).
 
+%% check_predicate_verifiability(-Violations)
+% Finds requirements whose requires_predicate links do not target ground
+% predicate facts. This keeps ontology-lane prose from looking modeled when the
+% target is still a legacy, observation, meta, schema, or strict-property fact.
+check_predicate_verifiability(Violations) :-
+    findall(
+        Violation,
+        predicate_verifiability_violation(Violation),
+        Violations0
+    ),
+    sort(Violations0, Violations).
+
+predicate_verifiability_violation(violation(
+    'predicate-verifiability',
+    ReqId,
+    Description,
+    "Apply kb_suggest_predicates and link requires_predicate to a fact_kind: predicate fact, or record a review:ontology-gap observation when no predicate fits",
+    Source
+)) :-
+    kb:current_req(ReqId),
+    kb_relationship(requires_predicate, ReqId, FactId),
+    kb_entity(FactId, fact, Props),
+    predicate_verifiability_fact_kind(Props, Kind),
+    Kind \= predicate,
+    predicate_verifiability_kind_label(Kind, KindLabel),
+    format(
+        string(Description),
+        "Requirement uses requires_predicate ~w but target is ~w, not fact_kind=predicate",
+        [FactId, KindLabel]
+    ),
+    violation_source(ReqId, req, Source).
+
+predicate_verifiability_fact_kind(Props, Kind) :-
+    (   memberchk(fact_kind=RawKind, Props)
+    ->  normalize_term_atom(RawKind, Kind)
+    ;   Kind = legacy
+    ).
+
+predicate_verifiability_kind_label(legacy, "a legacy fact without fact_kind").
+predicate_verifiability_kind_label(Kind, Label) :-
+    format(string(Label), "fact_kind=~w", [Kind]).
+
+%% check_logic_coverage(-Violations)
+% Validates explicitly declared atomic requirement claim manifests. Legacy
+% requirements without logic_claims remain eligible for gradual backfill; once
+% a manifest exists, every key must be grounded by a linked strict-property or
+% predicate fact carrying the same claim_key.
+check_logic_coverage(Violations) :-
+    findall(Violation, logic_coverage_violation(Violation), Violations0),
+    sort(Violations0, Violations).
+
+logic_coverage_violation(violation(
+    'logic-coverage',
+    ReqId,
+    Description,
+    "Ground every declared claim with a property_value fact via requires_property or a predicate fact via requires_predicate, preserving the same claim_key",
+    Source
+)) :-
+    kb:current_req(ReqId),
+    requirement_logic_claims(ReqId, ClaimKeys),
+    member(ClaimKey, ClaimKeys),
+    \+ grounded_requirement_claim(ReqId, ClaimKey),
+    format(
+        string(Description),
+        "Requirement declares logical claim ~w but has no matching ground fact",
+        [ClaimKey]
+    ),
+    violation_source(ReqId, req, Source).
+
+logic_coverage_violation(violation(
+    'logic-coverage',
+    ReqId,
+    Description,
+    "Keep a one-to-one mapping between each atomic claim key and its linked ground fact; split compound clauses before grounding",
+    Source
+)) :-
+    kb:current_req(ReqId),
+    grounded_requirement_claim_fact(ReqId, ClaimKey, FactA),
+    grounded_requirement_claim_fact(ReqId, ClaimKey, FactB),
+    FactA @< FactB,
+    format(
+        string(Description),
+        "Requirement grounds logical claim ~w more than once through ~w and ~w",
+        [ClaimKey, FactA, FactB]
+    ),
+    violation_source(ReqId, req, Source).
+
+logic_coverage_violation(violation(
+    'logic-coverage',
+    ReqId,
+    Description,
+    "Remove punctuation or wording variants from the atomic inventory and keep one claim key for each distinct logical term",
+    Source
+)) :-
+    kb:current_req(ReqId),
+    grounded_requirement_claim_fact(ReqId, ClaimA, FactA),
+    grounded_requirement_claim_fact(ReqId, ClaimB, FactB),
+    ClaimA \= ClaimB,
+    FactA @< FactB,
+    logical_ground_signature(FactA, Signature),
+    logical_ground_signature(FactB, Signature),
+    format(
+        string(Description),
+        "Requirement declares duplicate logical ground term ~w through claim keys ~w and ~w",
+        [Signature, ClaimA, ClaimB]
+    ),
+    violation_source(ReqId, req, Source).
+
+logic_coverage_violation(violation(
+    'logic-coverage',
+    ReqId,
+    Description,
+    "Append the linked fact claim_key to the requirement logic_claims manifest, or remove the stale logical link",
+    Source
+)) :-
+    kb:current_req(ReqId),
+    requirement_logic_claims(ReqId, ClaimKeys),
+    grounded_requirement_claim(ReqId, ClaimKey),
+    \+ memberchk(ClaimKey, ClaimKeys),
+    format(
+        string(Description),
+        "Requirement links ground logical claim ~w but omits it from logic_claims",
+        [ClaimKey]
+    ),
+    violation_source(ReqId, req, Source).
+
+requirement_logic_claims(ReqId, ClaimKeys) :-
+    kb_entity(ReqId, req, Props),
+    memberchk(logic_claims=RawClaimKeys, Props),
+    kb:normalize_term_atom_list(RawClaimKeys, ClaimKeys).
+
+grounded_requirement_claim(ReqId, ClaimKey) :-
+    grounded_requirement_claim_fact(ReqId, ClaimKey, _FactId).
+
+grounded_requirement_claim_fact(ReqId, ClaimKey, FactId) :-
+    kb_relationship(requires_property, ReqId, FactId),
+    ground_fact_claim_key(FactId, property_value, ClaimKey).
+grounded_requirement_claim_fact(ReqId, ClaimKey, FactId) :-
+    kb_relationship(requires_predicate, ReqId, FactId),
+    ground_fact_claim_key(FactId, predicate, ClaimKey).
+
+logical_ground_signature(FactId, predicate(Namespace, Name, Args, Polarity)) :-
+    kb:predicate_fact(FactId, Namespace, Name, Args, Polarity).
+logical_ground_signature(
+    FactId,
+    property(Subject, Property, Operator, ValueType, Value, Unit, Scope, Polarity)
+) :-
+    kb:fact_property_tuple(
+        FactId,
+        Subject,
+        Property,
+        Operator,
+        ValueType,
+        Value,
+        Unit,
+        Scope,
+        Polarity
+    ).
+
+ground_fact_claim_key(FactId, ExpectedKind, ClaimKey) :-
+    kb_entity(FactId, fact, Props),
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, ExpectedKind),
+    memberchk(claim_key=RawClaimKey, Props),
+    normalize_term_atom(RawClaimKey, ClaimKey),
+    memberchk(claim_text=RawClaimText, Props),
+    normalize_term_atom(RawClaimText, ClaimText),
+    ClaimText \= ''.
+
 strict_readiness_has_fact_link(ReqId) :-
     kb_relationship(constrains, ReqId, FactId),
     kb_entity(FactId, fact, _),
@@ -824,6 +1002,8 @@ check_all_with_options(ViolationsDict, RequireAdr) :-
     check_strict_fact_shape(StrictFactShape),
     check_strict_req_fact_pairing(StrictReqFactPairing),
     check_strict_readiness(StrictReadiness),
+    check_predicate_verifiability(PredicateVerifiability),
+    check_logic_coverage(LogicCoverage),
     ViolationsDict = _{
         must_priority_coverage: MustPriority,
         symbol_coverage: SymbolCoverage,
@@ -835,7 +1015,9 @@ check_all_with_options(ViolationsDict, RequireAdr) :-
         domain_contradictions: Contradictions,
         strict_fact_shape: StrictFactShape,
         strict_req_fact_pairing: StrictReqFactPairing,
-        strict_readiness: StrictReadiness
+        strict_readiness: StrictReadiness,
+        predicate_verifiability: PredicateVerifiability,
+        logic_coverage: LogicCoverage
     }.
 
 %% violations_dict_to_json(+ViolationsDict, -JsonDict)

package/src/discovery.pl

@@ -131,6 +131,7 @@ requirement_coverage_row(Tags, IncludeTransitive, Row) :-
     count_direct_symbols(Id, DirectSymbolCount),
     count_transitive_symbols(Id, IncludeTransitive, TransitiveSymbolCount),
     requirement_coverage_state(Id, Props, Gaps, Evaluated, CoverageStatus),
+    requirement_coverage_depth(Id, ScenarioCount, CoverageDepth, CoverageEvidence),
     Row = _{
         id: Id,
         type: req,
@@ -143,7 +144,13 @@ requirement_coverage_row(Tags, IncludeTransitive, Row) :-
         transitiveSymbolCount: TransitiveSymbolCount,
         gaps: Gaps,
         evaluated: Evaluated,
-        coverageStatus: CoverageStatus
+        coverageStatus: CoverageStatus,
+        coverageDepth: CoverageDepth,
+        coverage_depth: CoverageDepth,
+        directTests: CoverageEvidence.directTests,
+        scenarioTests: CoverageEvidence.scenarioTests,
+        testStatuses: CoverageEvidence.testStatuses,
+        verificationScopes: CoverageEvidence.verificationScopes
     }.
 
 symbol_coverage_row(Tags, Row) :-
@@ -232,6 +239,125 @@ requirement_test_count(Id, Count) :-
     sort(Combined0, Combined),
     length(Combined, Count).
 
+requirement_coverage_depth(Id, ScenarioCount, CoverageDepth, Evidence) :-
+    requirement_direct_tests(Id, DirectTests),
+    requirement_scenario_tests(Id, ScenarioTests),
+    append(DirectTests, ScenarioTests, AllTests0),
+    sort(AllTests0, AllTests),
+    passing_tests(DirectTests, PassingDirectTests),
+    passing_tests(ScenarioTests, PassingScenarioTests),
+    passing_tests(AllTests, PassingTests),
+    test_statuses(AllTests, TestStatuses),
+    test_scopes(AllTests, VerificationScopes),
+    Evidence = _{
+        directTests: DirectTests,
+        scenarioTests: ScenarioTests,
+        testStatuses: TestStatuses,
+        verificationScopes: VerificationScopes
+    },
+    classify_coverage_depth(
+        ScenarioCount,
+        AllTests,
+        PassingTests,
+        PassingDirectTests,
+        PassingScenarioTests,
+        CoverageDepth
+    ).
+
+requirement_direct_tests(Id, Tests) :-
+    findall(TestId, direct_requirement_test(Id, TestId), Tests0),
+    sort(Tests0, Tests).
+
+direct_requirement_test(Id, TestId) :-
+    kb_relationship(verified_by, Id, TestId),
+    kb_entity(TestId, test, _).
+direct_requirement_test(Id, TestId) :-
+    kb_relationship(validates, TestId, Id),
+    kb_entity(TestId, test, _).
+direct_requirement_test(Id, TestId) :-
+    kb_relationship(covered_by, Id, TestId),
+    kb_entity(TestId, test, _).
+
+requirement_scenario_tests(Id, Tests) :-
+    findall(TestId, scenario_requirement_test(Id, TestId), Tests0),
+    sort(Tests0, Tests).
+
+scenario_requirement_test(Id, TestId) :-
+    kb_relationship(specified_by, Id, ScenarioId),
+    scenario_test(ScenarioId, TestId).
+
+scenario_test(ScenarioId, TestId) :-
+    kb_relationship(validates, TestId, ScenarioId),
+    kb_entity(TestId, test, _).
+scenario_test(ScenarioId, TestId) :-
+    kb_relationship(verified_by, ScenarioId, TestId),
+    kb_entity(TestId, test, _).
+
+passing_tests(Tests, PassingTests) :-
+    include(passing_test, Tests, PassingTests).
+
+passing_test(TestId) :-
+    kb_entity(TestId, test, Props),
+    memberchk(status=StatusRaw, Props),
+    source_value_atom(StatusRaw, passing).
+
+test_statuses(Tests, Statuses) :-
+    findall(Status, (member(TestId, Tests), test_status(TestId, Status)), Statuses0),
+    sort(Statuses0, Statuses).
+
+test_status(TestId, Status) :-
+    kb_entity(TestId, test, Props),
+    memberchk(status=StatusRaw, Props),
+    source_value_atom(StatusRaw, Status).
+
+test_scopes(Tests, Scopes) :-
+    findall(Scope, (member(TestId, Tests), test_scope(TestId, Scope)), Scopes0),
+    sort(Scopes0, Scopes).
+
+test_scope(TestId, Scope) :-
+    kb_entity(TestId, test, Props),
+    (   memberchk(verification_scope=ScopeRaw, Props)
+    ->  source_value_atom(ScopeRaw, Scope)
+    ;   legacy_e2e_test(Props)
+    ->  Scope = end_to_end
+    ;   Scope = unknown
+    ).
+
+legacy_e2e_test(Props) :-
+    legacy_e2e_tag(Props),
+    !.
+legacy_e2e_test(Props) :-
+    memberchk(source=SourceRaw, Props),
+    source_value_atom(SourceRaw, Source),
+    downcase_atom(Source, LowercaseSource),
+    sub_atom(LowercaseSource, _, _, _, 'e2e').
+
+legacy_e2e_tag(Props) :-
+    memberchk(tags=Tags, Props),
+    member(TagRaw, Tags),
+    source_value_atom(TagRaw, Tag),
+    downcase_atom(Tag, e2e).
+
+classify_coverage_depth(_ScenarioCount, _AllTests, _PassingTests, PassingDirectTests, _PassingScenarioTests, direct_passing_e2e) :-
+    member(TestId, PassingDirectTests),
+    test_scope(TestId, end_to_end),
+    !.
+classify_coverage_depth(_ScenarioCount, _AllTests, _PassingTests, _PassingDirectTests, PassingScenarioTests, scenario_passing_e2e) :-
+    member(TestId, PassingScenarioTests),
+    test_scope(TestId, end_to_end),
+    !.
+classify_coverage_depth(_ScenarioCount, _AllTests, PassingTests, _PassingDirectTests, _PassingScenarioTests, unit_only) :-
+    PassingTests \= [],
+    forall(member(TestId, PassingTests), test_scope(TestId, unit)),
+    !.
+classify_coverage_depth(_ScenarioCount, AllTests, _PassingTests, _PassingDirectTests, _PassingScenarioTests, open_or_nonpassing_tests_only) :-
+    AllTests \= [],
+    !.
+classify_coverage_depth(ScenarioCount, _AllTests, _PassingTests, _PassingDirectTests, _PassingScenarioTests, scenario_only_no_test) :-
+    ScenarioCount > 0,
+    !.
+classify_coverage_depth(_ScenarioCount, _AllTests, _PassingTests, _PassingDirectTests, _PassingScenarioTests, no_test_evidence).
+
 count_direct_symbols(Id, Count) :-
     findall(SymbolId, kb_relationship(implements, SymbolId, Id), Symbols0),
     sort(Symbols0, Symbols),

package/src/kb.pl

@@ -45,6 +45,7 @@
     contradicting_reqs/3,
     check_req_contradiction/1,
     normalize_term_atom/2,
+    normalize_term_atom_list/2,
     changeset/4, % Export for testing
     kb_uri/1
 ]).
@@ -636,7 +637,7 @@ value_to_literal(Key, Value, Literal) :-
     ;   string(Value)
     ->  Literal = Value^^'http://www.w3.org/2001/XMLSchema#string'
     ;   is_list(Value)
-    ->  format(atom(ListStr), '~w', [Value]),
+    ->  with_output_to(atom(ListStr), write_term(Value, [quoted(true)])),
         Literal = ListStr^^'http://www.w3.org/2001/XMLSchema#string'
     ;   format(atom(Str), '~w', [Value]),
         Literal = Str^^'http://www.w3.org/2001/XMLSchema#string'
@@ -1005,6 +1006,26 @@ req_conflict(ReqA, ReqB, Reason) :-
     ;   property_conflict(SubjectKey, PropertyKey, OpA, ValTypeA, ValA, UnitA, PolarityA,
                           OpB, ValTypeB, ValB, UnitB, PolarityB, Reason)
     ).
+req_conflict(ReqA, ReqB, Reason) :-
+    effective_req_predicate(ReqA, FactA, Namespace, Name, Args, PolarityA),
+    effective_req_predicate(ReqB, FactB, Namespace, Name, Args, PolarityB),
+    FactA \= FactB,
+    opposite_predicate_polarity(PolarityA, PolarityB),
+    atomic_list_concat(Args, ',', ArgsText),
+    format(
+        string(Reason),
+        "Predicate conflict on ~w:~w(~w): ~w asserts ~w while ~w asserts ~w",
+        [Namespace, Name, ArgsText, ReqA, PolarityA, ReqB, PolarityB]
+    ).
+
+%% effective_req_predicate(+ReqId, -FactId, -Namespace, -Name, -Args, -Polarity)
+% Ground predicate claim required by a requirement.
+effective_req_predicate(ReqId, FactId, Namespace, Name, Args, Polarity) :-
+    kb_relationship(requires_predicate, ReqId, FactId),
+    predicate_fact(FactId, Namespace, Name, Args, Polarity).
+
+opposite_predicate_polarity(assert, deny).
+opposite_predicate_polarity(deny, assert).
 
 %% fact_subject_key(+FactId, -SubjectKey)
 % Extract the normalized subject key for strict subject facts.

package/src/sparql_client.pl

@@ -44,7 +44,10 @@ validate_remote_endpoint(Endpoint) :-
 
 validate_select_query(Query) :-
     normalize_space(atom(Normalized), Query),
-    downcase_atom(Normalized, Lower),
+    split_string(Normalized, "\n", " \t\r", RawLines),
+    strip_sparql_prelude(RawLines, RemainingLines),
+    atomic_list_concat(RemainingLines, ' ', Remainder),
+    downcase_atom(Remainder, Lower),
     sub_atom(Lower, 0, 6, After, 'select'),
     (   After =:= 0
     ;   sub_atom(Lower, 6, 1, _, ' ')
@@ -54,6 +57,25 @@ validate_select_query(Query) :-
 validate_select_query(Query) :-
     throw(error(domain_error(sparql_select_query, Query), _)).
 
+strip_sparql_prelude([], []).
+strip_sparql_prelude([Line | Rest], Result) :-
+    normalize_space(atom(Trimmed), Line),
+    (   Trimmed == ''
+    ->  strip_sparql_prelude(Rest, Result)
+    ;   is_prelude_line(Trimmed)
+    ->  strip_sparql_prelude(Rest, Result)
+    ;   Result = [Trimmed | Rest]
+    ).
+
+is_prelude_line(Line) :-
+    downcase_atom(Line, Lower),
+    split_string(Lower, " ", " \t", Tokens0),
+    exclude(=("") , Tokens0, Tokens),
+    Tokens = [FirstToken | _],
+    (   FirstToken == "prefix"
+    ;   FirstToken == "base"
+    ).
+
 endpoint_host(Endpoint, Host) :-
     strip_endpoint_scheme(Endpoint, WithoutScheme),
     segment_before(WithoutScheme, '/', WithoutPath),

package/src/status.pl

@@ -117,6 +117,8 @@ documentation_markdown_untracked(WorkspaceRoot) :-
 documentation_markdown_file(Path, Path) :-
     exists_file(Path),
     file_name_extension(_, md, Path),
+    entity_documentation_file(Path),
+    \+ ignored_documentation_file(Path),
     !.
 documentation_markdown_file(Path, FilePath) :-
     exists_directory(Path),
@@ -138,6 +140,9 @@ known_source_path(RelativePath) :-
     repo_relative_source(SourceAtom, RelativePath).
 
 directory_tree_newer(Path, SnapshotTime) :-
+    exists_file(Path),
+    entity_documentation_file(Path),
+    \+ ignored_documentation_file(Path),
     time_file(Path, EntryTime),
     EntryTime > SnapshotTime,
     !.
@@ -212,5 +217,15 @@ source_value_atom(Val, Atom) :-
     term_string(Val, Str),
     atom_string(Atom, Str).
 
+ignored_documentation_file(Path) :-
+    file_base_name(Path, 'README.md').
+
+entity_documentation_file(Path) :-
+    read_file_to_string(Path, Content, []),
+    sub_string(Content, 0, 3, _, "---"),
+    sub_string(Content, _, _, _, "id:"),
+    sub_string(Content, _, _, _, "title:"),
+    sub_string(Content, _, _, _, "status:").
+
 dict_json_string(Dict, JsonString) :-
     with_output_to(string(JsonString), json_write_dict(current_output, Dict, [])).