kibi-core 0.14.0 → 0.15.0

package/src/requirement_proof.pl

@@ -18,6 +18,8 @@
 :- use_module('kb.pl').
 :- use_module('checks.pl', [
     check_domain_contradictions_and_witnesses/2,
+    infeasible_scenario/5,
+    scenario_feasibility_outcome/2,
     check_rule_safety/1,
     check_rule_verifiability/1
 ]).
@@ -61,7 +63,7 @@ requirement_proof_context(VerificationSnapshot, CheckedAt, MaxAgeSeconds,
         proofTestBindings: TestBindings
     }.
 
-% implements REQ-kibi-proof-applicability-reason
+% implements REQ-kibi-conservative-requirement-proof
 % Exemption first: a current requirement explicitly marked proof_exempt with a
 % reason is intentionally outside E2E-proof scope and must never fall through
 % to the ladder (which would report misleading receipt gaps).
@@ -78,7 +80,7 @@ requirement_proof(ReqId, _ReqProps, _Context, Proof) :-
 requirement_proof(ReqId, ReqProps, Context, Proof) :-
     semantic_inventory_stage(ReqProps, SemanticStage, Inventory),
     logic_grounding_stage(ReqId, ReqProps, Inventory, Context, LogicStage),
-    contradiction_stage(ReqId, LogicStage.status, Context, ContradictionStage),
+    contradiction_stage(ReqId, LogicStage.status, SemanticStage.status, Context, ContradictionStage),
     scenario_stage(ReqId, ScenarioStage, ScenarioIds),
     scenario_test_stage(ScenarioIds, ScenarioTestStage, ScenarioTests),
     passing_e2e_stage(ScenarioTestStage, Context, PassingE2eStage, PassingE2eTests),
@@ -512,6 +514,21 @@ contradiction_stage(_ReqId, LogicStatus, _Context, Stage) :-
     Stage = _{status: unresolved, outcome: incomplete_grounding, conflicts: []}.
 contradiction_stage(_ReqId, passed, _Context, _{status: passed, outcome: no_conflict_found, conflicts: []}).
 
+%% contradiction_stage(+ReqId, +LogicStatus, +InventoryStatus, +Context, -Stage)
+% implements REQ-kibi-truthful-consistency
+% Absence of a conflict is evidence only when every normative proposition was
+% modeled.  Propositions still marked ambiguous or ontology_gap were never
+% encoded, so the checker cannot have looked at them: report the analysis as
+% incomplete instead of no_conflict_found.  Found conflicts still win.
+contradiction_stage(ReqId, LogicStatus, InventoryStatus, Context, Stage) :-
+    contradiction_stage(ReqId, LogicStatus, Context, Stage0),
+    (   Stage0.outcome == no_conflict_found,
+        InventoryStatus == unresolved
+    ->  Stage = _{status: unresolved, outcome: analysis_incomplete, conflicts: [],
+                  reason: "unresolved_propositions"}
+    ;   Stage = Stage0
+    ).
+
 requirement_contradictions(ReqId, Violations, Conflicts) :-
     include(violation_mentions_requirement(ReqId), Violations, Conflicts0),
     maplist(violation_description, Conflicts0, Conflicts).
@@ -542,16 +559,46 @@ scenario_stage(ReqId, Stage, ScenarioIds) :-
     findall(ScenarioId,
         (member(ScenarioId, ScenarioTargets), \+ existing_scenario(ScenarioId)),
         InvalidScenarioTargets),
-    ((ScenarioIds = [] ; InvalidScenarioTargets \= []) -> Status = missing ; Status = passed),
+    % implements REQ-kibi-scenario-feasibility-v2
+    % A scenario that expects success but whose assumptions cannot hold with
+    % what current requirements require (pairwise or jointly) can never pass,
+    % so the requirement cannot be proven through it.
+    findall(ScenarioId,
+        (member(ScenarioId, ScenarioIds), once(infeasible_scenario(ScenarioId, _, _, _, _))),
+        InfeasibleScenarios),
+    % A success scenario whose feasibility cannot be decided is reported as a
+    % distinct, non-blocking note instead of being counted as feasible.
+    findall(_{scenario: ScenarioId, reason: ReasonText},
+        (   member(ScenarioId, ScenarioIds),
+            once(scenario_feasibility_outcome(ScenarioId, unknown(Reason))),
+            unknown_feasibility_reason(Reason, ReasonText)
+        ),
+        UnknownFeasibility),
+    (   (ScenarioIds = [] ; InvalidScenarioTargets \= [])
+    ->  Status = missing
+    ;   InfeasibleScenarios \= []
+    ->  Status = blocked
+    ;   Status = passed
+    ),
     maplist(entity_source_ref, ScenarioIds, Sources),
     Stage = _{
         status: Status,
         scenarios: ScenarioIds,
         scenarioTargets: ScenarioTargets,
         invalidScenarioTargets: InvalidScenarioTargets,
+        infeasibleScenarios: InfeasibleScenarios,
+        unknownFeasibility: UnknownFeasibility,
         sources: Sources
     }.
 
+unknown_feasibility_reason(no_assumptions, no_assumptions).
+unknown_feasibility_reason(contradictory_assumptions(_), contradictory_assumptions).
+unknown_feasibility_reason(unmatched_assumption(_), unmatched_assumption).
+unknown_feasibility_reason(incomparable_assumption(_), incomparable_assumption).
+unknown_feasibility_reason(conflicting_requirements(_), conflicting_requirements).
+unknown_feasibility_reason(undecided_rule(_), undecided_rule).
+unknown_feasibility_reason(undetermined_validity(_), undetermined_validity).
+
 existing_scenario(ScenarioId) :-
     kb_entity(ScenarioId, scenario, _).
 
@@ -939,10 +986,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)
     ).
@@ -1610,8 +1657,9 @@ receipt_completeness_issue(failed_proof_receipt).
 receipt_completeness_issue(invalid_proof_receipt).
 receipt_completeness_issue(proof_contract_mismatch).
 
-proof_issue_advisory(_Gap, _Stages) :-
-    fail.
+% Unknown scenario feasibility never blocks proof: it is surfaced as an
+% advisory so it is not mistaken for a passed feasibility check.
+proof_issue_advisory(unknown_scenario_feasibility, _Stages).
 
 proof_gap_present(missing_semantic_inventory, Stages) :- Stages.semanticInventory.propositionCount =:= 0.
 proof_gap_present(incomplete_semantic_inventory, Stages) :- Stages.semanticInventory.missingCount > 0.
@@ -1626,7 +1674,11 @@ proof_gap_present(ambiguous_logic_grounding, Stages) :-
 proof_gap_present(blocking_contradiction, Stages) :- Stages.contradictions.status == blocked.
 proof_gap_present(contradiction_check_incomplete, Stages) :- Stages.contradictions.status == unresolved.
 proof_gap_present(missing_scenario, Stages) :- Stages.scenarios.status == missing.
-proof_gap_present(missing_scenario_test, Stages) :- Stages.scenarios.status == passed, Stages.scenarioTests.status == missing.
+proof_gap_present(infeasible_scenario, Stages) :- Stages.scenarios.infeasibleScenarios \= [].
+proof_gap_present(unknown_scenario_feasibility, Stages) :-
+    get_dict(unknownFeasibility, Stages.scenarios, Unknown),
+    Unknown \= [].
+proof_gap_present(missing_scenario_test, Stages) :- memberchk(Stages.scenarios.status, [passed, blocked]), Stages.scenarioTests.status == missing.
 proof_gap_present(missing_passing_e2e, Stages) :- Stages.passingE2e.status == missing.
 proof_gap_present(missing_proof_receipt, Stages) :- Stages.passingE2e.missingReceiptTests \= [].
 proof_gap_present(stale_proof_receipt, Stages) :- Stages.passingE2e.staleReceiptTests \= [].
@@ -1652,7 +1704,9 @@ gap_definition(missing_logic_grounding, 32, logic_grounding, "Ground every model
 gap_definition(ambiguous_logic_grounding, 33, logic_grounding, "Remove duplicate or invalid ground representations and validate linked rules.").
 gap_definition(blocking_contradiction, 40, contradictions, "Supersede or reconcile the conflicting normative requirement.").
 gap_definition(contradiction_check_incomplete, 41, contradictions, "Complete logical grounding before interpreting absence of a conflict as evidence.").
+gap_definition(unknown_scenario_feasibility, 49, scenarios, "Link the property values the success scenario relies on with assumes facts that a current requirement constrains, so its feasibility can be decided.").
 gap_definition(missing_scenario, 50, scenarios, "Add a specified_by scenario for the requirement.").
+gap_definition(infeasible_scenario, 49, scenarios, "Set expects: rejection on the scenario, correct its assumes fact, or record a human-approved exception requirement that exempts the forbidding requirement.").
 gap_definition(missing_scenario_test, 51, scenario_tests, "Link the scenario to a test with verified_by or validates.").
 gap_definition(missing_passing_e2e, 52, passing_e2e, "Record fresh passing end-to-end evidence on a scenario-backed test.").
 gap_definition(missing_proof_receipt, 53, passing_e2e, "Run the configured proof integration through kibi prove and append its kibi.proof-receipt.v1 result for the scenario-backed proof-bearing test.").

package/src/rule_registry.pl

@@ -19,9 +19,16 @@ known_rule('symbol-coverage').
 known_rule('symbol-traceability').
 known_rule('no-dangling-refs').
 known_rule('source-relationship-parity').
+known_rule('source-path-dangling').
 known_rule('no-cycles').
 known_rule('required-fields').
 known_rule('deprecated-adr-no-successor').
+known_rule('superseded-requirement-open').
+known_rule('scenario-feasibility').
+known_rule('scenario-feasibility-unknown').
+known_rule('exception-claim-keys').
+known_rule('numeric-string-value').
+known_rule('rule-key-arguments-missing').
 known_rule('domain-contradictions').
 known_rule('logic-coverage').
 known_rule('rule-safety').
@@ -40,6 +47,13 @@ known_rule('domain-implication').
 known_rule('subject-key-identity').
 known_rule('subject-key-shape').
 known_rule('ontology-quality').
+known_rule('exception-unapproved').
+known_rule('exception-approval-self-attested').
+known_rule('agent-requirement-unapproved').
+known_rule('requirement-rationale-missing').
+known_rule('symbol-owner-superseded').
+known_rule('adr-unlinked').
+known_rule('adr-proposed').
 known_rule('predicate-schema-conformance').
 
 rule_enforcement_class('must-priority-coverage', canonical).
@@ -47,16 +61,23 @@ rule_enforcement_class('symbol-coverage', canonical).
 rule_enforcement_class('symbol-traceability', canonical).
 rule_enforcement_class('no-dangling-refs', canonical).
 rule_enforcement_class('source-relationship-parity', canonical).
+rule_enforcement_class('source-path-dangling', canonical).
 rule_enforcement_class('no-cycles', canonical).
 rule_enforcement_class('required-fields', canonical).
 rule_enforcement_class('deprecated-adr-no-successor', canonical).
+rule_enforcement_class('superseded-requirement-open', canonical).
+rule_enforcement_class('scenario-feasibility', canonical).
+rule_enforcement_class('scenario-feasibility-unknown', advisory).
+rule_enforcement_class('exception-claim-keys', canonical).
+rule_enforcement_class('numeric-string-value', advisory).
+rule_enforcement_class('rule-key-arguments-missing', advisory).
 rule_enforcement_class('domain-contradictions', canonical).
 rule_enforcement_class('logic-coverage', canonical).
 rule_enforcement_class('rule-safety', canonical).
 rule_enforcement_class('rule-verifiability', canonical).
 rule_enforcement_class('query-plan-safety', canonical).
 rule_enforcement_class('req-status-vocabulary', canonical).
-rule_enforcement_class('strict-fact-shape', advisory).
+rule_enforcement_class('strict-fact-shape', canonical).
 rule_enforcement_class('strict-req-fact-pairing', advisory).
 rule_enforcement_class('predicate-verifiability', advisory).
 rule_enforcement_class('strict-readiness', migration).
@@ -68,6 +89,13 @@ 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('exception-unapproved', advisory).
+rule_enforcement_class('exception-approval-self-attested', advisory).
+rule_enforcement_class('agent-requirement-unapproved', advisory).
+rule_enforcement_class('requirement-rationale-missing', advisory).
+rule_enforcement_class('symbol-owner-superseded', advisory).
+rule_enforcement_class('adr-unlinked', advisory).
+rule_enforcement_class('adr-proposed', advisory).
 rule_enforcement_class('predicate-schema-conformance', advisory).
 
 rule_implementation('must-priority-coverage', prolog).
@@ -75,9 +103,16 @@ rule_implementation('symbol-coverage', prolog).
 rule_implementation('symbol-traceability', prolog).
 rule_implementation('no-dangling-refs', prolog).
 rule_implementation('source-relationship-parity', typescript).
+rule_implementation('source-path-dangling', typescript).
 rule_implementation('no-cycles', prolog).
 rule_implementation('required-fields', prolog).
 rule_implementation('deprecated-adr-no-successor', prolog).
+rule_implementation('superseded-requirement-open', prolog).
+rule_implementation('scenario-feasibility', prolog).
+rule_implementation('scenario-feasibility-unknown', prolog).
+rule_implementation('exception-claim-keys', prolog).
+rule_implementation('numeric-string-value', prolog).
+rule_implementation('rule-key-arguments-missing', prolog).
 rule_implementation('domain-contradictions', prolog).
 rule_implementation('logic-coverage', prolog).
 rule_implementation('rule-safety', prolog).
@@ -96,6 +131,13 @@ rule_implementation('domain-implication', prolog).
 rule_implementation('subject-key-identity', prolog).
 rule_implementation('subject-key-shape', prolog).
 rule_implementation('ontology-quality', prolog).
+rule_implementation('exception-unapproved', typescript).
+rule_implementation('exception-approval-self-attested', typescript).
+rule_implementation('agent-requirement-unapproved', typescript).
+rule_implementation('requirement-rationale-missing', typescript).
+rule_implementation('symbol-owner-superseded', prolog).
+rule_implementation('adr-unlinked', prolog).
+rule_implementation('adr-proposed', prolog).
 rule_implementation('predicate-schema-conformance', typescript).
 
 rule_predicate('must-priority-coverage', check_must_priority_coverage).
@@ -105,6 +147,12 @@ rule_predicate('no-dangling-refs', check_no_dangling_refs).
 rule_predicate('no-cycles', check_no_cycles).
 rule_predicate('required-fields', check_required_fields).
 rule_predicate('deprecated-adr-no-successor', check_deprecated_adrs).
+rule_predicate('superseded-requirement-open', check_superseded_requirement_open).
+rule_predicate('scenario-feasibility', check_scenario_feasibility).
+rule_predicate('scenario-feasibility-unknown', check_scenario_feasibility_unknown).
+rule_predicate('exception-claim-keys', check_exception_claim_keys).
+rule_predicate('numeric-string-value', check_numeric_string_values).
+rule_predicate('rule-key-arguments-missing', check_rule_key_arguments_missing).
 rule_predicate('domain-contradictions', check_domain_contradictions).
 rule_predicate('logic-coverage', check_logic_coverage).
 rule_predicate('rule-safety', check_rule_safety).
@@ -122,6 +170,9 @@ 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('symbol-owner-superseded', check_symbol_owner_superseded).
+rule_predicate('adr-unlinked', check_adr_unlinked).
+rule_predicate('adr-proposed', check_adr_proposed).
 
 rule_predicate_arity('must-priority-coverage', 1).
 rule_predicate_arity('symbol-coverage', 1).
@@ -130,6 +181,12 @@ rule_predicate_arity('no-dangling-refs', 1).
 rule_predicate_arity('no-cycles', 1).
 rule_predicate_arity('required-fields', 1).
 rule_predicate_arity('deprecated-adr-no-successor', 1).
+rule_predicate_arity('superseded-requirement-open', 1).
+rule_predicate_arity('scenario-feasibility', 1).
+rule_predicate_arity('scenario-feasibility-unknown', 1).
+rule_predicate_arity('exception-claim-keys', 1).
+rule_predicate_arity('numeric-string-value', 1).
+rule_predicate_arity('rule-key-arguments-missing', 1).
 rule_predicate_arity('domain-contradictions', 1).
 rule_predicate_arity('logic-coverage', 1).
 rule_predicate_arity('rule-safety', 1).
@@ -147,15 +204,25 @@ 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_predicate_arity('symbol-owner-superseded', 1).
+rule_predicate_arity('adr-unlinked', 1).
+rule_predicate_arity('adr-proposed', 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').
 rule_description('symbol-traceability', 'Production symbols must directly implement requirements for ownership; covered_by is coverage only and executable_for is test identity only').
 rule_description('no-dangling-refs', 'All relationship targets must exist in the KB').
 rule_description('source-relationship-parity', 'Authored Markdown and relationship-shard edges must exactly match the compiled KB').
+rule_description('source-path-dangling', 'An authored entity\'s source field must name an existing workspace path (a #anchor suffix is ignored), an existing entity id, or an http(s) URL; a missing source is allowed').
 rule_description('no-cycles', 'No circular dependency chains in requirements').
 rule_description('required-fields', 'All entities must have required fields').
 rule_description('deprecated-adr-no-successor', 'Deprecated ADRs must have a successor ADR that supersedes them').
+rule_description('superseded-requirement-open', 'A requirement that another requirement supersedes must have status closed, and supersedes links between requirements must not form a cycle').
+rule_description('scenario-feasibility', 'A scenario that expects success must not assume property values that cannot hold, alone or together, with what current requirements require through typed property values or rules, unless an approved exception requirement waives that requirement or the listed clauses').
+rule_description('scenario-feasibility-unknown', 'Advisory: a scenario that expects success assumes nothing, assumes values that contradict each other, assumes a property value no governing requirement constrains comparably (type, unit or operator mismatch, or conflicting requirements), leaves a governing rule\'s conditions undecided, or conflicts only with constraints whose validity window may not cover it, so its feasibility cannot be decided').
+rule_description('exception-claim-keys', 'An exception requirement\'s exempts_claims must name claim keys of a requirement it exempts, and requires an exempts link').
+rule_description('numeric-string-value', 'Advisory: a property value stores a numeric-looking string where the comparison is numeric (ordering operator, or an int/number fact on the same property); the finding names the fact and the typed value, without converting it').
+rule_description('rule-key-arguments-missing', 'Advisory: an opposing rule pair stays unresolved only because a body predicate declares no key_arguments; the finding names the predicate and the key positions that would decide the pair').
 rule_description('domain-contradictions', 'Detect contradictions between requirements constraining the same fact').
 rule_description('logic-coverage', 'Require every explicitly declared atomic requirement claim to be grounded by a linked strict-property or predicate fact').
 rule_description('rule-safety', 'Stored Logic IR rules use only the typed, bounded, stratified vocabulary').
@@ -171,7 +238,14 @@ rule_description('proof-contract-symbols', 'Detect unresolved required_proofs.sy
 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('subject-key-identity', 'Subject keys must name a shared component, not be derived from a requirement ID, and one subject or claim must not be minted as several active subject facts or identical property_value facts').
+rule_description('subject-key-shape', 'Subject keys follow dotted component.aspect[.sub] with lowercase snake segments, and property keys name a property rather than a numbered clause (clause_NN)').
 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('exception-unapproved', 'Advisory: a current exception requirement exempts another requirement but has no approved_by, so it exempts nothing until a human approves it').
+rule_description('exception-approval-self-attested', 'Advisory: an agent-authored exception records approved_by but no human corroborated it (origin.approved_by or approval_ref is missing), so a human should confirm the approval').
+rule_description('agent-requirement-unapproved', 'Informational: current requirements authored by an agent (origin.kind agent) that no human has approved (origin.approved_by), listed up to 25 per check').
+rule_description('requirement-rationale-missing', 'Advisory: a current requirement authored by a human or an agent (origin.kind human or agent) states no rationale: no rationale field, no Rationale or Why section in its body, and no link to an ADR; listed up to 25 per check plus one summary finding').
+rule_description('symbol-owner-superseded', 'Advisory: a symbol whose every implements target is superseded or deprecated has no current owning requirement; listed up to 25 per check plus one summary finding').
+rule_description('adr-unlinked', 'Advisory: an accepted ADR that no requirement or other ADR is linked with (relates_to, supersedes or any typed edge, in either direction)').
+rule_description('adr-proposed', 'Informational: an ADR that is still proposed and not superseded, so nobody accepted or withdrew the decision').
 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').

package/src/semantic_quality.pl

@@ -8,8 +8,10 @@
 %   entity-id-style      filename stem must equal the frontmatter id
 %   domain-redundancy    two current requirements ground the same term
 %   domain-implication   one numeric bound implies another (informational)
-%   subject-key-identity subject keys derived from requirement IDs
-%   subject-key-shape    subject keys outside component.aspect[.sub]
+%   subject-key-identity subject keys derived from requirement IDs, and one
+%                        subject or claim minted as several facts
+%   subject-key-shape    subject keys outside component.aspect[.sub], and
+%                        property keys that number a clause
 %   ontology-quality     predicate schemas whose arguments are mostly
 %                        one-off atoms (prose smuggled into atoms)
 %
@@ -356,6 +358,16 @@ implication_witness_violation(Witness, violation(
 %
 % Subject facts are reported; property_value facts are reported only when no
 % subject fact carries the same key (otherwise fixing the subject fixes them).
+%
+% The rule also reports vocabulary fragmentation, where one subject or claim
+% was minted as several facts so requirements about it never meet: more than
+% one active subject fact for the same subject_key, and more than one active
+% property_value fact stating the same claim: the same subject_key,
+% property_key, operator, typed value and unit.  Facts that differ in operator
+% (the two bounds of a range) or in value (two requirements bounding the same
+% property differently) are distinct claims, which domain-contradictions and
+% domain-implication compare.  Each group is reported once, on its first fact
+% id.
 % implements REQ-kibi-subject-vocabulary
 check_subject_key_identity(Violations) :-
     findall(Segment-ReqId, requirement_subject_segment(ReqId, Segment), SegmentPairs0),
@@ -368,7 +380,116 @@ check_subject_key_identity(Violations) :-
         subject_key_identity_violation(Segments, SubjectKeys, Violation),
         Violations0
     ),
-    sort(Violations0, Violations).
+    duplicate_subject_fact_violations(SubjectDuplicates),
+    duplicate_property_fact_violations(PropertyDuplicates),
+    append([Violations0, SubjectDuplicates, PropertyDuplicates], Violations1),
+    sort(Violations1, Violations).
+
+%% duplicate_subject_fact_violations(-Violations)
+duplicate_subject_fact_violations(Violations) :-
+    findall(
+        SubjectKey-FactId,
+        (   fact_subject_key_of_kind(FactId, subject, SubjectKey),
+            active_fact(FactId)
+        ),
+        Pairs0
+    ),
+    sort(Pairs0, Pairs),
+    group_pairs_by_key(Pairs, Groups),
+    findall(
+        violation(
+            'subject-key-identity',
+            FirstId,
+            Description,
+            Suggestion,
+            Source,
+            _{subjectKey: SubjectKey, facts: FactIds}
+        ),
+        (   member(SubjectKey-FactIds, Groups),
+            FactIds = [FirstId, _|_],
+            length(FactIds, Count),
+            atomic_list_concat(FactIds, ', ', FactText),
+            format(string(Description),
+                "~w active subject facts share subject_key ~w (~w), so requirements about this subject are split across facts that never meet",
+                [Count, SubjectKey, FactText]),
+            format(string(Suggestion),
+                "Keep one subject fact for ~w, point every requirement's constrains link at it, and remove the others (kb_delete) once nothing links them",
+                [SubjectKey]),
+            entity_text(FirstId, fact, source, Source)
+        ),
+        Violations
+    ).
+
+%% duplicate_property_fact_violations(-Violations)
+duplicate_property_fact_violations(Violations) :-
+    findall(
+        key(SubjectKey, PropertyKey, Operator, Value)-FactId,
+        (   fact_subject_key_of_kind(FactId, property_value, SubjectKey),
+            kb_entity(FactId, fact, Props),
+            memberchk(property_key=RawProperty, Props),
+            normalize_term_atom(RawProperty, PropertyKey),
+            memberchk(operator=RawOperator, Props),
+            normalize_term_atom(RawOperator, Operator),
+            property_value_signature(Props, Value),
+            active_fact(FactId)
+        ),
+        Pairs0
+    ),
+    sort(Pairs0, Pairs),
+    group_pairs_by_key(Pairs, Groups),
+    findall(
+        violation(
+            'subject-key-identity',
+            FirstId,
+            Description,
+            "Link every requirement to one shared fact and remove the duplicates (kb_delete) once nothing links them",
+            Source,
+            _{subjectKey: SubjectKey, propertyKey: PropertyKey, operator: Operator, facts: FactIds}
+        ),
+        (   member(key(SubjectKey, PropertyKey, Operator, _)-FactIds, Groups),
+            FactIds = [FirstId, _|_],
+            length(FactIds, Count),
+            atomic_list_concat(FactIds, ', ', FactText),
+            format(string(Description),
+                "~w active property_value facts state the same claim on ~w ~w (operator ~w, same value) (~w), so one claim is minted as several facts",
+                [Count, SubjectKey, PropertyKey, Operator, FactText]),
+            entity_text(FirstId, fact, source, Source)
+        ),
+        Violations
+    ).
+
+%% property_value_signature(+Props, -Signature)
+% The typed value and unit of a property_value fact, as Field-Value pairs in a
+% fixed field order, so two facts compare equal only when they store the same
+% value of the same type in the same unit.
+property_value_signature(Props, Signature) :-
+    findall(
+        Field-Value,
+        (   member(Field, [value_type, value_string, value_int, value_number, value_bool, unit]),
+            memberchk(Field=Raw, Props),
+            signature_value(Raw, Value),
+            Value \== ''
+        ),
+        Signature
+    ).
+
+signature_value('^^'(Raw, _), Value) :- !, signature_value(Raw, Value).
+signature_value(literal(type(_, Raw)), Value) :- !, signature_value(Raw, Value).
+signature_value(Raw, Value) :- string(Raw), !, atom_string(Value, Raw).
+signature_value(Raw, Raw).
+
+%% active_fact(+FactId)
+% A fact whose status does not retire it.
+active_fact(FactId) :-
+    entity_text(FactId, fact, status, Status),
+    retired_fact_status(Status, Retired),
+    Retired == false.
+
+retired_fact_status(Status, Retired) :-
+    (   memberchk(Status, ["superseded", "deprecated", "closed", "removed", "retired", "inactive", "archived"])
+    ->  Retired = true
+    ;   Retired = false
+    ).
 
 subject_key_identity_violation(Segments, SubjectKeys, violation(
     'subject-key-identity',
@@ -471,6 +592,33 @@ subject_key_shape_violation(violation(
     \+ valid_subject_key(SubjectKey),
     format(string(Description), "Subject key ~w does not follow the component.aspect[.sub] convention", [SubjectKey]),
     entity_text(FactId, fact, source, Source).
+% A property key that numbers a clause (`clause_03_must_refresh_...`,
+% `contract_clause_2`) names a position in one requirement's prose, not a
+% property other requirements can share, so equal claims never meet.
+subject_key_shape_violation(violation(
+    'subject-key-shape',
+    FactId,
+    Description,
+    "Rename the property key to the property the clause constrains (for example refresh_before_serving), reusing an existing property_key for the same subject when one fits",
+    Source
+)) :-
+    kb_entity(FactId, fact, Props),
+    memberchk(property_key=RawKey, Props),
+    normalize_term_atom(RawKey, PropertyKey),
+    clause_numbered_property_key(PropertyKey),
+    format(string(Description), "Property key ~w numbers a clause instead of naming a property", [PropertyKey]),
+    entity_text(FactId, fact, source, Source).
+
+%% clause_numbered_property_key(+PropertyKey)
+% True when the key contains the word `clause` followed by a number.
+clause_numbered_property_key(PropertyKey) :-
+    atom(PropertyKey),
+    atomic_list_concat(Words, '_', PropertyKey),
+    append(_, [clause, Number|_], Words),
+    atom_codes(Number, Codes),
+    Codes \== [],
+    forall(member(Code, Codes), code_type(Code, digit)),
+    !.
 
 %% valid_subject_key(+SubjectKey)
 valid_subject_key(SubjectKey) :-

package/src/status.pl

@@ -3,7 +3,8 @@
 
 :- module(status, [
     kb_status_json/1,
-    status_meta_dict/1
+    status_meta_dict/1,
+    status_scope_dict/1
 ]).
 
 :- use_module(library(http/json)).
@@ -57,6 +58,19 @@ status_meta_dict(StatusDict) :-
         lastSyncSource: unknown
     }.
 
+%% status_scope_dict(-Scope)
+% implements REQ-kibi-search-answer-layer-v2
+% The snapshot an answer is computed from: the attached snapshot id and when
+% it was synced. Unlike status_meta_dict/1 it skips the freshness scan, so a
+% discovery answer can name its snapshot at no extra cost; kb_status remains
+% the place to ask whether that snapshot is stale.
+status_scope_dict(_{snapshotId: SnapshotId, syncedAt: SyncedAt}) :-
+    attached_kb_info(_Branch, _KbPath, DataFile),
+    !,
+    snapshot_id(SnapshotId),
+    synced_at(DataFile, SyncedAt).
+status_scope_dict(_{snapshotId: unknown, syncedAt: null}).
+
 attached_kb_info(Branch, KbPath, DataFile) :-
     kb:kb_attached(KbPath),
     branch_workspace_from_kb_path(KbPath, Branch, _WorkspaceRoot),
@@ -99,7 +113,8 @@ synced_at(DataFile, SyncedAt) :-
     exists_file(DataFile),
     !,
     time_file(DataFile, Timestamp),
-    format_time(atom(SyncedAt), '%FT%TZ', Timestamp).
+    stamp_date_time(Timestamp, TimestampUTC, 'UTC'),
+    format_time(atom(SyncedAt), '%FT%TZ', TimestampUTC).
 % Before the first successful sync there is no kb.rdf, so the public JSON contract must expose syncedAt: null.
 synced_at(_, null).
 
@@ -263,6 +278,7 @@ directory_tree_newer(Path, SnapshotTime) :-
     !.
 
 directory_tree_newer(Path, SnapshotTime) :-
+    \+ ignored_documentation_file(Path),
     exists_directory(Path),
     directory_files(Path, Entries),
     member(Entry, Entries),
@@ -275,6 +291,7 @@ directory_tree_newer(Path, SnapshotTime) :-
 directory_tree_newer_path(Path, SnapshotTime, Path) :-
     newer_entity_documentation_file(Path, SnapshotTime).
 directory_tree_newer_path(Path, SnapshotTime, ChildPath) :-
+    \+ ignored_documentation_file(Path),
     exists_directory(Path),
     directory_files(Path, Entries),
     member(Entry, Entries),
@@ -377,8 +394,12 @@ ignored_documentation_file(Path) :-
     file_base_name(Path, 'README.md').
 ignored_documentation_file(Path) :-
     sub_atom(Path, _, _, _, '/tests/e2e/').
+ignored_documentation_file(Path) :-
+    sub_atom(Path, _, _, 0, '/tests/e2e').
 ignored_documentation_file(Path) :-
     sub_atom(Path, _, _, _, '/tests/benchmarks/').
+ignored_documentation_file(Path) :-
+    sub_atom(Path, _, _, 0, '/tests/benchmarks').
 
 %% newer_entity_documentation_file(+Path, +SnapshotTime) is semidet.
 % Cheap path and mtime tests run before the file is read, and the content
@@ -395,6 +416,8 @@ newer_entity_documentation_file(Path, SnapshotTime) :-
 entity_documentation_file(Path) :-
     read_file_to_string(Path, Content, []),
     sub_string(Content, 0, 3, _, "---"),
+    % These are existence checks, not generators. Repeated metadata examples
+    % must not multiply freshness reasons or cause Cartesian backtracking.
     once(sub_string(Content, _, _, _, "id:")),
     once(sub_string(Content, _, _, _, "title:")),
     once(sub_string(Content, _, _, _, "status:")).