kibi-core 0.7.1 → 0.8.1

package/package.json

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

package/schema/entities.pl

@@ -30,6 +30,7 @@ entity_property(_, links, list).
 entity_property(_, text_ref, uri).
 entity_property(_, sourceFile, uri).
 entity_property(req, logic_claims, list).
+entity_property(req, semantic_inventory, list).
 
 % Typed fact fields - only valid for fact entities
 entity_property(fact, fact_kind, atom).
@@ -59,6 +60,16 @@ entity_property(fact, argument_descriptions, list).
 entity_property(fact, aliases, list).
 entity_property(fact, examples, list).
 entity_property(fact, predicate_args, list).
+entity_property(fact, rule_ir, string).
+entity_property(fact, rule_hash, string).
+% Rule schema references are JSON strings at the public boundary, but the
+% Prolog peer represents entity identifiers as atoms.  Accept both forms so
+% decoded rule facts validate without losing the typed reference.
+entity_property(fact, rule_schema_id, atom_or_string).
+entity_property(fact, rule_name, string).
+entity_property(fact, semantic_key, string).
+entity_property(fact, claim_span_start, integer).
+entity_property(fact, claim_span_end, integer).
 
 % Typed symbol metadata fields - only valid for symbol entities
 entity_property(symbol, symbol_role, atom).
@@ -84,6 +95,7 @@ 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(req, semantic_inventory).
 optional_property(test, verification_scope).
 optional_property(test, verification_perspective).
 

package/schema/relationships.pl

@@ -19,6 +19,7 @@ relationship_type(supersedes).
 relationship_type(constrains).
 relationship_type(requires_property).
 relationship_type(requires_predicate).
+relationship_type(requires_rule).
 
 % valid_relationship(RelType, FromType, ToType).
 valid_relationship(depends_on, req, req).
@@ -40,6 +41,7 @@ valid_relationship(consumes, symbol, event).
 valid_relationship(constrains, req, fact).
 valid_relationship(requires_property, req, fact).
 valid_relationship(requires_predicate, req, fact).
+valid_relationship(requires_rule, req, fact).
 
 %% supersedes(+NewAdrId, +OldAdrId)
 %% NewAdrId is the decision that replaces OldAdrId.

package/schema/validation.pl

@@ -42,6 +42,7 @@ validate_property_type(Type, Prop, Value) :-
 % check_kind(Kind, Value) succeeds if Value matches Kind
 check_kind(atom, V) :- atom(V).
 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(uri, V) :- string(V).
@@ -106,6 +107,13 @@ is_fact_only_field(argument_descriptions).
 is_fact_only_field(aliases).
 is_fact_only_field(examples).
 is_fact_only_field(predicate_args).
+is_fact_only_field(rule_ir).
+is_fact_only_field(rule_hash).
+is_fact_only_field(rule_schema_id).
+is_fact_only_field(rule_name).
+is_fact_only_field(semantic_key).
+is_fact_only_field(claim_span_start).
+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).
@@ -115,7 +123,7 @@ is_test_only_field(verification_perspective).
 validate_fact_shape(subject, Props) :-
     memberchk(subject_key=_Val, Props),
     valid_optional_fact_enums(Props),
-    valid_strict_polarity_in_props(Props).
+    valid_strict_polarity_in_props(Props), !.
 validate_fact_shape(property_value, Props) :-
     memberchk(subject_key=_Subject, Props),
     memberchk(property_key=_Property, Props),
@@ -126,14 +134,14 @@ validate_fact_shape(property_value, Props) :-
     exactly_one_value_field(Props),
     value_type_matches_field(VT, Props),
     valid_optional_fact_enums(Props),
-    valid_strict_polarity_in_props(Props).
+    valid_strict_polarity_in_props(Props), !.
 validate_fact_shape(observation, Props) :-
     valid_optional_fact_enums(Props),
-    valid_polarity_in_props(Props).
+    valid_polarity_in_props(Props), !.
 validate_fact_shape(meta, Props) :-
     % Meta facts are allowed but don't require full strict property tuple yet
     valid_optional_fact_enums(Props),
-    valid_polarity_in_props(Props).
+    valid_polarity_in_props(Props), !.
 validate_fact_shape(predicate_schema, Props) :-
     memberchk(predicate_name=_Name, Props),
     memberchk(predicate_arity=Arity, Props),
@@ -143,32 +151,39 @@ validate_fact_shape(predicate_schema, Props) :-
     same_length(ArgumentNames, ArgumentTypes),
     length(ArgumentNames, Arity),
     valid_optional_fact_enums(Props),
-    valid_polarity_in_props(Props).
+    valid_polarity_in_props(Props), !.
 validate_fact_shape(predicate, Props) :-
     memberchk(predicate_name=_Name, Props),
     memberchk(predicate_args=Args, Props),
     Args \= [],
     memberchk(canonical_key=_CanonicalKey, Props),
     valid_optional_fact_enums(Props),
-    valid_predicate_polarity_in_props(Props).
+    valid_predicate_polarity_in_props(Props), !.
+validate_fact_shape(rule_schema, Props) :-
+    memberchk(rule_name=_Name, Props),
+    memberchk(argument_names=ArgumentNames, Props),
+    memberchk(argument_types=ArgumentTypes, Props),
+    same_length(ArgumentNames, ArgumentTypes),
+    valid_optional_fact_enums(Props),
+    valid_polarity_in_props(Props), !.
+validate_fact_shape(rule, Props) :-
+    memberchk(rule_ir=RuleIr, Props),
+    nonempty_claim_value(RuleIr),
+    memberchk(rule_hash=_Hash, Props),
+    memberchk(rule_schema_id=_SchemaId, Props),
+    memberchk(semantic_key=_SemanticKey, Props),
+    valid_optional_fact_enums(Props),
+    valid_polarity_in_props(Props), !.
 validate_fact_shape(Kind, _Props) :-
     % Unknown fact_kind values fail validation
-    \+ memberchk(Kind, [subject, property_value, observation, meta, predicate_schema, predicate]),
+    \+ memberchk(Kind, [subject, property_value, observation, meta, predicate_schema, predicate, rule_schema, rule]),
     fail.
 
 % valid_operator(+Op)
-valid_operator(eq).
-valid_operator(neq).
-valid_operator(lt).
-valid_operator(lte).
-valid_operator(gt).
-valid_operator(gte).
+valid_operator(Op) :- memberchk(Op, [eq, neq, lt, lte, gt, gte]), !.
 
 % valid_value_type(+VT)
-valid_value_type(string).
-valid_value_type(int).
-valid_value_type(number).
-valid_value_type(bool).
+valid_value_type(ValueType) :- memberchk(ValueType, [string, int, number, bool]), !.
 
 % valid_polarity_in_props(+Props)
 % Validates polarity if present; succeeds if no polarity in props
@@ -190,8 +205,8 @@ valid_claim_provenance(Props) :-
     ;   \+ memberchk(claim_text=_, Props)
     ).
 
-nonempty_claim_value(Value) :- string(Value), Value \= "".
-nonempty_claim_value(Value) :- atom(Value), Value \= ''.
+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
@@ -206,25 +221,17 @@ valid_optional_test_enums(Props) :-
     ( memberchk(verification_perspective=Perspective, Props) -> valid_verification_perspective(Perspective) ; true ).
 
 % valid_polarity(+P)
-valid_polarity(require).
-valid_polarity(forbid).
-valid_polarity(assert).
-valid_polarity(deny).
+valid_polarity(Polarity) :- memberchk(Polarity, [require, forbid, assert, deny]), !.
 
-valid_strict_polarity(require).
-valid_strict_polarity(forbid).
+valid_strict_polarity(Polarity) :- memberchk(Polarity, [require, forbid]), !.
 
-valid_predicate_polarity(assert).
-valid_predicate_polarity(deny).
+valid_predicate_polarity(Polarity) :- memberchk(Polarity, [assert, deny]), !.
 
 % valid_verification_scope(+Scope)
-valid_verification_scope(unit).
-valid_verification_scope(integration).
-valid_verification_scope(end_to_end).
+valid_verification_scope(Scope) :- memberchk(Scope, [unit, integration, end_to_end]), !.
 
 % valid_verification_perspective(+Perspective)
-valid_verification_perspective(internal).
-valid_verification_perspective(consumer).
+valid_verification_perspective(Perspective) :- memberchk(Perspective, [internal, consumer]), !.
 
 % exactly_one_value_field(+Props)
 exactly_one_value_field(Props) :-

package/src/checks.pl

@@ -19,6 +19,9 @@
     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
+    check_rule_safety/1,
+    check_rule_verifiability/1,
+    check_semantic_completeness/1,
     run_checks_json/0,              % Entry point for JSON output
     violation_id_text/2             % Extract text from entity ID term (exported for testing)
 ]).
@@ -28,6 +31,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]).
 
 % Required fields for all entities
 required_fields([id, title, status, created_at, updated_at, source]).
@@ -35,7 +39,7 @@ required_fields([id, title, status, created_at, updated_at, source]).
 % Relationship types to check for dangling references
 all_relationship_types([
     depends_on, verified_by, validates, specified_by,
-    constrains, requires_property, requires_predicate, supersedes, relates_to
+    constrains, requires_property, requires_predicate, requires_rule, supersedes, relates_to
 ]).
 
 %% check_all(-ViolationsDict)
@@ -56,6 +60,9 @@ check_all(ViolationsDict) :-
     check_strict_readiness(StrictReadiness),
     check_predicate_verifiability(PredicateVerifiability),
     check_logic_coverage(LogicCoverage),
+    check_rule_safety(RuleSafety),
+    check_rule_verifiability(RuleVerifiability),
+    check_semantic_completeness(SemanticCompleteness),
     ViolationsDict = _{
         must_priority_coverage: MustPriority,
         symbol_coverage: SymbolCoverage,
@@ -69,7 +76,10 @@ check_all(ViolationsDict) :-
         strict_req_fact_pairing: StrictReqFactPairing,
         strict_readiness: StrictReadiness,
         predicate_verifiability: PredicateVerifiability,
-        logic_coverage: LogicCoverage
+        logic_coverage: LogicCoverage,
+        rule_safety: RuleSafety,
+        rule_verifiability: RuleVerifiability,
+        semantic_completeness: SemanticCompleteness
     }.
 
 %% check_must_priority_coverage(-Violations)
@@ -408,9 +418,25 @@ strict_fact_shape_violation(violation(
             Description = First,
             Suggestion = "Ensure predicate facts have predicate_name, non-empty predicate_args, canonical_key, and assert/deny polarity when present"
         )
+    ;   Kind = rule_schema
+    ->  findall(Msg, rule_schema_shape_error(Props, Msg), Errors),
+        (   Errors = []
+        ->  fail
+        ;   Errors = [First|_],
+            Description = First,
+            Suggestion = "Ensure rule_schema facts declare rule_name plus same-length argument_names and argument_types"
+        )
+    ;   Kind = rule
+    ->  findall(Msg, rule_shape_error(Props, Msg), Errors),
+        (   Errors = []
+        ->  fail
+        ;   Errors = [First|_],
+            Description = First,
+            Suggestion = "Ensure rule facts contain a safe kibi.logic.v1 rule_ir, full rule_hash, rule_schema_id, rule_name, and semantic_key"
+        )
     ;   % Unknown fact_kind - report as malformed
         format(string(Description), "Unknown fact_kind: ~w", [Kind]),
-        Suggestion = "Use one of: subject, property_value, observation, meta, predicate_schema, predicate"
+        Suggestion = "Use one of: subject, property_value, observation, meta, predicate_schema, predicate, rule_schema, rule"
     ),
     
     (   memberchk(source=Source0, Props)
@@ -503,6 +529,42 @@ predicate_shape_error(Props, "Predicate fact polarity must be assert or deny") :
     normalize_term_atom(RawPolarity, Polarity),
     \+ memberchk(Polarity, [assert, deny]).
 
+rule_schema_shape_error(Props, "Rule schema fact missing required field: rule_name") :-
+    \+ memberchk(rule_name=_, Props).
+rule_schema_shape_error(Props, "Rule schema fact missing required field: argument_names") :-
+    memberchk(rule_name=_, Props),
+    \+ memberchk(argument_names=_, Props).
+rule_schema_shape_error(Props, "Rule schema fact missing required field: argument_types") :-
+    memberchk(argument_names=_, Props),
+    \+ memberchk(argument_types=_, Props).
+rule_schema_shape_error(Props, "Rule schema fact argument_names and argument_types must have equal lengths") :-
+    memberchk(argument_names=RawNames, Props),
+    memberchk(argument_types=RawTypes, Props),
+    checks_normalize_atom_list(RawNames, Names),
+    checks_normalize_atom_list(RawTypes, Types),
+    length(Names, NameCount),
+    length(Types, TypeCount),
+    NameCount =\= TypeCount.
+
+rule_shape_error(Props, "Rule fact missing required field: rule_ir") :-
+    \+ memberchk(rule_ir=_, Props).
+rule_shape_error(Props, "Rule fact missing required field: rule_hash") :-
+    memberchk(rule_ir=_, Props),
+    \+ memberchk(rule_hash=_, Props).
+rule_shape_error(Props, "Rule fact missing required field: rule_schema_id") :-
+    memberchk(rule_hash=_, Props),
+    \+ memberchk(rule_schema_id=_, Props).
+rule_shape_error(Props, "Rule fact missing required field: rule_name") :-
+    memberchk(rule_schema_id=_, Props),
+    \+ memberchk(rule_name=_, Props).
+rule_shape_error(Props, "Rule fact missing required field: semantic_key") :-
+    memberchk(rule_name=_, Props),
+    \+ memberchk(semantic_key=_, Props).
+rule_shape_error(Props, "Rule fact rule_ir failed kibi.logic.v1 safety validation") :-
+    memberchk(rule_ir=_, Props),
+    logic_rule_safety(Props, Errors),
+    Errors \= [].
+
 checks_normalize_integer(Raw, Integer) :-
     (   Raw = ^^(Value, _Type)
     ->  checks_normalize_integer(Value, Integer)
@@ -537,8 +599,41 @@ check_domain_contradictions(Violations) :-
             format(string(EntityId), "~w/~w", [ReqA, ReqB]),
             format(string(Description), "~w [strict-readiness: contradiction-ready]", [Reason])
         ),
-        Violations
-    ).
+        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).
+
+opposing_rule_requirements(ReqA, ReqB, RuleA, RuleB) :-
+    kb:current_req(ReqA),
+    kb:current_req(ReqB),
+    ReqA @< ReqB,
+    kb_relationship(requires_rule, ReqA, FactA),
+    kb_relationship(requires_rule, ReqB, FactB),
+    FactA @< FactB,
+    kb_entity(FactA, fact, PropsA),
+    kb_entity(FactB, fact, PropsB),
+    memberchk(fact_kind=KindA, PropsA),
+    memberchk(fact_kind=KindB, PropsB),
+    normalize_term_atom(KindA, rule),
+    normalize_term_atom(KindB, rule),
+    logic_rule_from_props(PropsA, RuleA),
+    logic_rule_from_props(PropsB, RuleB).
 
 %% check_strict_req_fact_pairing(-Violations)
 % Finds current requirements attempting strict-lane modeling with incomplete
@@ -816,7 +911,7 @@ 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",
+    "Ground every declared claim with a property_value, predicate, or rule fact via its typed relationship, preserving the same claim_key",
     Source
 )) :-
     kb:current_req(ReqId),
@@ -901,6 +996,9 @@ grounded_requirement_claim_fact(ReqId, ClaimKey, FactId) :-
 grounded_requirement_claim_fact(ReqId, ClaimKey, FactId) :-
     kb_relationship(requires_predicate, ReqId, FactId),
     ground_fact_claim_key(FactId, predicate, ClaimKey).
+grounded_requirement_claim_fact(ReqId, ClaimKey, FactId) :-
+    kb_relationship(requires_rule, ReqId, FactId),
+    ground_fact_claim_key(FactId, rule, ClaimKey).
 
 logical_ground_signature(FactId, predicate(Namespace, Name, Args, Polarity)) :-
     kb:predicate_fact(FactId, Namespace, Name, Args, Polarity).
@@ -919,6 +1017,14 @@ logical_ground_signature(
         Scope,
         Polarity
     ).
+logical_ground_signature(FactId, rule(SemanticKey)) :-
+    kb_entity(FactId, fact, Props),
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    (   memberchk(semantic_key=RawKey, Props)
+    ->  normalize_term_atom(RawKey, SemanticKey)
+    ;   memberchk(rule_hash=RawKey, Props), normalize_term_atom(RawKey, SemanticKey)
+    ).
 
 ground_fact_claim_key(FactId, ExpectedKind, ClaimKey) :-
     kb_entity(FactId, fact, Props),
@@ -930,6 +1036,175 @@ ground_fact_claim_key(FactId, ExpectedKind, ClaimKey) :-
     normalize_term_atom(RawClaimText, ClaimText),
     ClaimText \= ''.
 
+%% check_rule_safety(-Violations)
+% Every stored rule must decode through the closed Logic IR vocabulary and
+% pass the independent Prolog-side safety checks.
+check_rule_safety(Violations) :-
+    findall(Violation, rule_safety_violation(Violation), Raw),
+    sort(Raw, Violations).
+
+rule_safety_violation(violation(
+    'rule-safety',
+    FactId,
+    Description,
+    "Use kibi.logic.v1 typed IR; remove raw Prolog, unsafe variables, or unstratified negation",
+    Source
+)) :-
+    kb_entity(FactId, fact, Props),
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    logic_rule_safety(Props, Errors),
+    Errors \= [],
+    format(string(Description), "Rule fact ~w failed safety validation: ~w", [FactId, Errors]),
+    violation_source(FactId, fact, Source).
+
+% Local rule checks cannot detect a negation cycle spanning multiple facts.
+% Run the finite dependency-graph check over the complete stored rule set and
+% report each participating negated rule as infrastructure-grade unsafe IR.
+rule_safety_violation(violation(
+    'rule-safety',
+    FactId,
+    "Stored rules contain an unstratified negation dependency cycle",
+    "Separate the negated dependency into strata or replace it with an explicit closed-world fact",
+    Source
+)) :-
+    findall(Rule, stored_rule_term(Rule), Rules),
+    Rules \= [],
+    \+ logic_rules_stratified(Rules),
+    stored_rule_fact(FactId, _Props, Rule),
+    rule_contains_negation(Rule),
+    violation_source(FactId, fact, Source).
+
+stored_rule_term(Rule) :-
+    kb_entity(_FactId, fact, Props),
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    logic_rule_from_props(Props, Rule).
+
+stored_rule_fact(FactId, Props, Rule) :-
+    kb_entity(FactId, fact, Props),
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    logic_rule_from_props(Props, Rule).
+
+rule_contains_negation(rule(_, _, _Head, Body, Exceptions, _Scope, _From, _To, _Schema, _Variables)) :-
+    ( expression_contains_negation(Body)
+    ; member(Exception, Exceptions), expression_contains_negation(Exception)
+    ),
+    !.
+
+expression_contains_negation(not(_)).
+expression_contains_negation(all(Items)) :- member(Item, Items), expression_contains_negation(Item).
+expression_contains_negation(any(Items)) :- member(Item, Items), expression_contains_negation(Item).
+expression_contains_negation(count(Atom, _Operator, _Value)) :- expression_contains_negation(Atom).
+
+%% check_rule_verifiability(-Violations)
+% A requires_rule edge is meaningful only when it reaches a rule fact whose
+% schema endpoint exists and whose rule IR is safe.
+check_rule_verifiability(Violations) :-
+    findall(Violation, rule_verifiability_violation(Violation), Raw),
+    sort(Raw, Violations).
+
+rule_verifiability_violation(violation(
+    'rule-verifiability',
+    ReqId,
+    Description,
+    "Link requires_rule to fact_kind=rule with a valid rule_schema_id and safe kibi.logic.v1 IR",
+    Source
+)) :-
+    kb:current_req(ReqId),
+    kb_relationship(requires_rule, ReqId, FactId),
+    kb_entity(FactId, fact, Props),
+    rule_verifiability_description(Props, FactId, Description),
+    violation_source(ReqId, req, Source).
+
+rule_verifiability_description(Props, FactId, Description) :-
+    (   memberchk(fact_kind=RawKind, Props)
+    ->  normalize_term_atom(RawKind, Kind)
+    ;   Kind = legacy
+    ),
+    Kind \= rule,
+    format(string(Description), "Requirement uses requires_rule ~w but target is fact_kind=~w", [FactId, Kind]).
+rule_verifiability_description(Props, FactId, Description) :-
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    \+ memberchk(rule_schema_id=_, Props),
+    format(string(Description), "Rule fact ~w has no rule_schema_id", [FactId]).
+rule_verifiability_description(Props, FactId, Description) :-
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    memberchk(rule_schema_id=SchemaId, Props),
+    \+ kb_entity(SchemaId, fact, _),
+    format(string(Description), "Rule fact ~w references missing rule schema ~w", [FactId, SchemaId]).
+rule_verifiability_description(Props, FactId, Description) :-
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    memberchk(rule_schema_id=SchemaId, Props),
+    kb_entity(SchemaId, fact, SchemaProps),
+    \+ valid_rule_schema_props(SchemaProps),
+    format(string(Description), "Rule fact ~w references ~w, which is not a rule_schema fact", [FactId, SchemaId]).
+rule_verifiability_description(Props, FactId, Description) :-
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule),
+    logic_rule_safety(Props, Errors),
+    Errors \= [],
+    format(string(Description), "Rule fact ~w is not safe: ~w", [FactId, Errors]).
+
+valid_rule_schema_props(Props) :-
+    memberchk(fact_kind=RawKind, Props),
+    normalize_term_atom(RawKind, rule_schema),
+    memberchk(rule_name=Name, Props),
+    nonempty_normalized(Name),
+    memberchk(argument_names=RawNames, Props),
+    memberchk(argument_types=RawTypes, Props),
+    checks_normalize_atom_list(RawNames, Names),
+    checks_normalize_atom_list(RawTypes, Types),
+    same_length(Names, Types).
+
+nonempty_normalized(Value) :-
+    normalize_term_atom(Value, Atom),
+    Atom \= ''.
+
+%% check_semantic_completeness(-Violations)
+% The proposition ledger is additive and optional during migration. When it is
+% present, every assertive proposition must either be modeled or explicitly
+% recorded as an unresolved review state; silently missing entries are errors.
+check_semantic_completeness(Violations) :-
+    findall(Violation, semantic_completeness_violation(Violation), Raw),
+    sort(Raw, Violations).
+
+semantic_completeness_violation(violation(
+    'semantic-completeness',
+    ReqId,
+    Description,
+    "Run kb_semantic_advisor again, preserve every proposition span, and model or explicitly classify each assertive proposition",
+    Source
+)) :-
+    kb:current_req(ReqId),
+    kb_entity(ReqId, req, Props),
+    memberchk(semantic_inventory=RawInventory, Props),
+    inventory_entries(RawInventory, Entries),
+    member(Entry, Entries),
+    inventory_entry_status(Entry, Status),
+    memberchk(Status, [missing]),
+    format(string(Description), "Requirement proposition ledger contains an unclassified assertive span (~w)", [Entry]),
+    violation_source(ReqId, req, Source).
+
+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),
+        is_list(JsonEntries)
+    ->  Entries = JsonEntries
+    ;   Entries = []
+    ).
+
+inventory_entry_status(Entry, Status) :-
+    is_dict(Entry), get_dict(status, Entry, Raw), normalize_term_atom(Raw, Status).
+inventory_entry_status(Entry, Status) :-
+    is_list(Entry), memberchk(status=Raw, Entry), normalize_term_atom(Raw, Status).
+
 strict_readiness_has_fact_link(ReqId) :-
     kb_relationship(constrains, ReqId, FactId),
     kb_entity(FactId, fact, _),
@@ -1004,6 +1279,9 @@ check_all_with_options(ViolationsDict, RequireAdr) :-
     check_strict_readiness(StrictReadiness),
     check_predicate_verifiability(PredicateVerifiability),
     check_logic_coverage(LogicCoverage),
+    check_rule_safety(RuleSafety),
+    check_rule_verifiability(RuleVerifiability),
+    check_semantic_completeness(SemanticCompleteness),
     ViolationsDict = _{
         must_priority_coverage: MustPriority,
         symbol_coverage: SymbolCoverage,
@@ -1017,7 +1295,10 @@ check_all_with_options(ViolationsDict, RequireAdr) :-
         strict_req_fact_pairing: StrictReqFactPairing,
         strict_readiness: StrictReadiness,
         predicate_verifiability: PredicateVerifiability,
-        logic_coverage: LogicCoverage
+        logic_coverage: LogicCoverage,
+        rule_safety: RuleSafety,
+        rule_verifiability: RuleVerifiability,
+        semantic_completeness: SemanticCompleteness
     }.
 
 %% violations_dict_to_json(+ViolationsDict, -JsonDict)

package/src/logic_ir.pl

@@ -0,0 +1,629 @@
+% Safe, data-driven interpreter for kibi.logic.v1.
+%
+% This module deliberately parses a small JSON IR into ordinary Prolog terms.
+% It never consults or asserts caller-provided source.  The terms are evaluated
+% by a bounded interpreter and are suitable for proof witnesses.
+:- module(logic_ir, [
+    logic_rule_from_props/2,
+    logic_rule_safety/2,
+    logic_rule_render/2,
+    logic_rule_semantic_key/2,
+    logic_derive/2,
+    logic_rule_conflict/3,
+    logic_rule_conflict_witness/3,
+    logic_atom_signature/2,
+    logic_rules_stratified/1
+]).
+
+:- use_module(library(http/json)).
+:- use_module(library(aggregate)).
+:- use_module(library(clpfd)).
+:- use_module('kb.pl', [kb_entity/3, predicate_fact/5]).
+
+%% logic_rule_from_props(+Props, -Rule)
+% Props is an entity property list from a fact_kind=rule fact.
+logic_rule_from_props(Props, Rule) :-
+    memberchk(rule_ir=Raw, Props),
+    raw_json_atom(Raw, Json),
+    catch(atom_json_dict(Json, Dict, [value_string_as(atom)]), _, fail),
+    json_rule(Dict, Rule).
+
+raw_json_atom(^^(Value, _), Atom) :- !, raw_json_atom(Value, Atom).
+raw_json_atom(literal(type(_, Value)), Atom) :- !, raw_json_atom(Value, Atom).
+raw_json_atom(Value, Atom) :- atom(Value), !, Atom = Value.
+raw_json_atom(Value, Atom) :- string(Value), !, atom_string(Atom, Value).
+
+json_rule(Dict, rule(Kind, Modality, Head, Body, Exceptions, Scope, From, To, SchemaId, Variables)) :-
+    json_rule_keys(Dict),
+    get_dict(version, Dict, Version),
+    json_text(Version, 'kibi.logic.v1'),
+    json_text(Dict.kind, Kind),
+    json_modality(Dict.modality, Modality),
+    ( get_dict(head, Dict, HeadDict) -> json_atom(HeadDict, Head) ; Head = none ),
+    ( get_dict(body, Dict, BodyDict) -> json_expression(BodyDict, Body) ; Body = none ),
+    ( get_dict(exceptions, Dict, ExceptionDicts) -> maplist(json_expression, ExceptionDicts, Exceptions) ; Exceptions = [] ),
+    ( get_dict(scope, Dict, ScopeDict) -> json_scope(ScopeDict, Scope) ; Scope = scope('', '', []) ),
+    ( get_dict(validFrom, Dict, RawFrom) -> json_timestamp(RawFrom, From) ; From = '' ),
+    ( get_dict(validTo, Dict, RawTo) -> json_timestamp(RawTo, To) ; To = '' ),
+    ( get_dict(ruleSchemaId, Dict, RawSchemaId) -> json_atom_name(RawSchemaId, SchemaId), valid_schema_id(SchemaId) ; SchemaId = '' ),
+    ( get_dict(variables, Dict, RawVariables) -> maplist(json_variable, RawVariables, Variables) ; Variables = [] ).
+
+json_rule_keys(Dict) :-
+    dict_pairs(Dict, _Tag, Pairs),
+    forall(member(Key-_, Pairs), memberchk(Key, [version, kind, modality, head, body, variables, exceptions, scope, validFrom, validTo, ruleSchemaId])).
+
+json_variable(Dict, variable(Name, Type, Quantifier)) :-
+    is_dict(Dict),
+    dict_keys_allowed(Dict, [name, type, quantifier]),
+    get_dict(name, Dict, RawName), json_atom_name(RawName, Name),
+    valid_variable_name(Name),
+    get_dict(type, Dict, RawType), json_atom_name(RawType, Type), valid_type_name(Type),
+    ( get_dict(quantifier, Dict, RawQuantifier) -> json_quantifier(RawQuantifier, Quantifier) ; Quantifier = forall ).
+
+json_quantifier(Value, Value) :- memberchk(Value, [forall, exists]), !.
+json_quantifier(Value, Quantifier) :- string(Value), atom_string(Atom, Value), json_quantifier(Atom, Quantifier).
+
+json_modality(Value, Value) :- memberchk(Value, [assert, deny, oblige, permit, forbid]), !.
+json_modality(Value, Value) :- string(Value), atom_string(Atom, Value), json_modality(Atom, Value).
+
+json_atom(Dict, atom(Namespace, Name, Args, Polarity, ClosedWorld)) :-
+    is_dict(Dict),
+    dict_keys_allowed(Dict, [kind, namespace, name, args, polarity, closedWorld]),
+    get_dict(kind, Dict, Kind),
+    json_text(Kind, atom),
+    get_dict(name, Dict, RawName),
+    json_atom_name(RawName, Name), valid_predicate_name(Name),
+    ( get_dict(namespace, Dict, RawNamespace) -> json_atom_name(RawNamespace, Namespace), valid_predicate_name(Namespace) ; Namespace = default ),
+    get_dict(args, Dict, RawArgs),
+    is_list(RawArgs),
+    length(RawArgs, Arity), Arity =< 8,
+    maplist(json_term, RawArgs, Args),
+    ( get_dict(polarity, Dict, RawPolarity) -> json_polarity(RawPolarity, Polarity) ; Polarity = positive ),
+    ( get_dict(closedWorld, Dict, RawClosedWorld) -> memberchk(RawClosedWorld, [true, false]), ClosedWorld = RawClosedWorld ; ClosedWorld = false ).
+
+json_atom_name(Value, Atom) :- atom(Value), !, Atom = Value.
+json_atom_name(Value, Atom) :- string(Value), !, atom_string(Atom, Value).
+
+valid_variable_name(Name) :-
+    atom(Name),
+    atom_chars(Name, [First|Rest]),
+    char_type(First, upper),
+    forall(member(Char, Rest), (char_type(Char, alnum) ; Char == '_')).
+
+valid_type_name(Name) :-
+    atom(Name),
+    atom_chars(Name, [First|Rest]),
+    char_type(First, lower),
+    forall(member(Char, Rest), (char_type(Char, alnum) ; memberchk(Char, ['_', '-', ':', '/', '.']))).
+
+valid_schema_id(Name) :-
+    atom(Name),
+    atom_chars(Name, [First|Rest]),
+    char_type(First, alnum),
+    forall(member(Char, Rest), (char_type(Char, alnum) ; memberchk(Char, ['_', '-', ':', '/', '.']))).
+
+json_timestamp(Value, Timestamp) :-
+    json_atom_name(Value, Timestamp),
+    parse_time(Timestamp, iso_8601, _).
+
+valid_predicate_name(Name) :-
+    atom(Name),
+    atom_chars(Name, [First|Rest]),
+    char_type(First, lower),
+    forall(member(Char, Rest), allowed_predicate_char(Char)).
+
+allowed_predicate_char(Char) :- char_type(Char, alnum), !.
+allowed_predicate_char('_').
+allowed_predicate_char('-').
+allowed_predicate_char('/').
+allowed_predicate_char('.').
+
+json_text(Value, Expected) :- atom(Value), !, Value = Expected.
+json_text(Value, Expected) :- string(Value), atom_string(Expected, Value).
+
+json_polarity(Value, Value) :- memberchk(Value, [positive, negative]), !.
+json_polarity(Value, Polarity) :- string(Value), atom_string(Atom, Value), json_polarity(Atom, Polarity).
+
+json_term(Dict, var(Name, Type)) :-
+    is_dict(Dict), dict_keys_allowed(Dict, [kind, name, type]), get_dict(kind, Dict, Kind), json_text(Kind, var),
+    get_dict(name, Dict, RawName), json_atom_name(RawName, Name), valid_variable_name(Name),
+    get_dict(type, Dict, RawType), json_atom_name(RawType, Type), valid_type_name(Type), !.
+json_term(Dict, const(Value, Type)) :-
+    is_dict(Dict), dict_keys_allowed(Dict, [kind, value, type]), get_dict(kind, Dict, Kind), json_text(Kind, const),
+    get_dict(value, Dict, RawValue), json_atom_name(RawValue, Value),
+    ( get_dict(type, Dict, RawType) -> json_atom_name(RawType, Type) ; Type = string ), !.
+json_term(Dict, number(Value, Unit)) :-
+    is_dict(Dict), dict_keys_allowed(Dict, [kind, value, unit]), get_dict(kind, Dict, Kind), json_text(Kind, number),
+    get_dict(value, Dict, Value), number(Value), Value =:= Value,
+    ( get_dict(unit, Dict, RawUnit) -> json_atom_name(RawUnit, Unit), valid_type_name(Unit) ; Unit = none ), !.
+json_term(Dict, duration(Value, Unit)) :-
+    is_dict(Dict), dict_keys_allowed(Dict, [kind, value, unit]), get_dict(kind, Dict, Kind), json_text(Kind, duration),
+    get_dict(value, Dict, Value), number(Value), Value =:= Value, Value >= 0,
+    get_dict(unit, Dict, RawUnit), json_atom_name(RawUnit, Unit), memberchk(Unit, [ms, s, m, h, d, w]), !.
+json_term(Dict, timestamp(Value)) :-
+    is_dict(Dict), dict_keys_allowed(Dict, [kind, value]), get_dict(kind, Dict, Kind), json_text(Kind, timestamp),
+    get_dict(value, Dict, RawValue), json_timestamp(RawValue, Value), !.
+json_term(Dict, interval(Start, End)) :-
+    is_dict(Dict), dict_keys_allowed(Dict, [kind, start, end]), get_dict(kind, Dict, Kind), json_text(Kind, interval),
+    get_dict(start, Dict, RawStart), json_timestamp(RawStart, Start),
+    get_dict(end, Dict, RawEnd), json_timestamp(RawEnd, End), Start @=< End, !.
+
+json_expression(Dict, Atom) :- is_dict(Dict), dict_keys_allowed(Dict, [kind, namespace, name, args, polarity, closedWorld]), get_dict(kind, Dict, Kind), json_text(Kind, atom), !, json_atom(Dict, Atom).
+json_expression(Dict, all(Items)) :- is_dict(Dict), dict_keys_allowed(Dict, [kind, items]), get_dict(kind, Dict, Kind), json_text(Kind, all), !, get_dict(items, Dict, Raw), is_list(Raw), Raw \= [], length(Raw, Count), Count =< 32, maplist(json_expression, Raw, Items).
+json_expression(Dict, any(Items)) :- is_dict(Dict), dict_keys_allowed(Dict, [kind, items]), get_dict(kind, Dict, Kind), json_text(Kind, any), !, get_dict(items, Dict, Raw), is_list(Raw), Raw \= [], length(Raw, Count), Count =< 32, maplist(json_expression, Raw, Items).
+json_expression(Dict, not(Atom)) :- is_dict(Dict), dict_keys_allowed(Dict, [kind, item]), get_dict(kind, Dict, Kind), json_text(Kind, not), !, get_dict(item, Dict, Raw), json_atom(Raw, Atom).
+json_expression(Dict, compare(Op, Left, Right)) :- is_dict(Dict), dict_keys_allowed(Dict, [kind, operator, left, right]), get_dict(kind, Dict, Kind), json_text(Kind, compare), !, get_dict(operator, Dict, OpRaw), json_atom_name(OpRaw, Op), valid_compare_operator(Op), get_dict(left, Dict, LeftRaw), get_dict(right, Dict, RightRaw), json_term(LeftRaw, Left), json_term(RightRaw, Right).
+json_expression(Dict, count(Atom, Op, Value)) :- is_dict(Dict), dict_keys_allowed(Dict, [kind, atom, operator, value]), get_dict(kind, Dict, Kind), json_text(Kind, count), !, get_dict(atom, Dict, AtomRaw), json_atom(AtomRaw, Atom), get_dict(operator, Dict, OpRaw), json_atom_name(OpRaw, Op), valid_compare_operator(Op), get_dict(value, Dict, Value), integer(Value), Value >= 0.
+json_expression(Dict, temporal(Relation, Left, Right)) :- is_dict(Dict), dict_keys_allowed(Dict, [kind, relation, left, right]), get_dict(kind, Dict, Kind), json_text(Kind, temporal), !, get_dict(relation, Dict, RelationRaw), json_atom_name(RelationRaw, Relation), valid_temporal_relation(Relation), get_dict(left, Dict, LeftRaw), get_dict(right, Dict, RightRaw), json_term(LeftRaw, Left), json_term(RightRaw, Right).
+
+valid_compare_operator(Op) :- memberchk(Op, [eq, neq, lt, lte, gt, gte]).
+valid_temporal_relation(Relation) :- memberchk(Relation, [before, after, during, overlaps, starts, finishes]).
+
+json_scope(Dict, scope(Authority, Name, Tags)) :-
+    dict_keys_allowed(Dict, [authority, name, tags]),
+    ( get_dict(authority, Dict, Authority0) -> json_atom_name(Authority0, Authority) ; Authority = '' ),
+    ( get_dict(name, Dict, Name0) -> json_atom_name(Name0, Name) ; Name = '' ),
+    ( get_dict(tags, Dict, Tags0) -> maplist(json_atom_name, Tags0, Tags) ; Tags = [] ).
+
+dict_keys_allowed(Dict, Allowed) :-
+    dict_pairs(Dict, _Tag, Pairs),
+    forall(member(Key-_, Pairs), memberchk(Key, Allowed)).
+
+%% logic_rule_safety(+Props, -Errors)
+% Independent Prolog-side safety check.  It intentionally rejects anything
+% that the JSON decoder cannot map into the closed IR vocabulary.
+logic_rule_safety(Props, Errors) :-
+    (   logic_rule_from_props(Props, Rule)
+    ->  rule_safety_errors(Rule, Errors)
+    ;   Errors = [malformed_rule_ir]
+    ).
+
+rule_safety_errors(rule(Kind, _Modality, Head, Body, Exceptions, _Scope, _From, _To, _Schema, Variables), Errors) :-
+    findall(Error, rule_shape_error(Kind, Head, Body, Error), ShapeErrors),
+    findall(Error, expression_safety_error(Body, Error), BodyErrors),
+    findall(Error, (member(Exception, Exceptions), expression_safety_error(Exception, Error)), ExceptionErrors),
+    findall(Error, variable_safety_error(Head, Body, Variables, Error), VariableErrors),
+    findall(Error, undeclared_variable_error(Head, Body, Exceptions, Variables, Error), DeclarationErrors),
+    findall(Error, (member(Exception, Exceptions), exception_variable_safety_error(Exception, Body, Error)), ExceptionVariableErrors),
+    findall(Error, rule_term_safety_error(Head, Body, Exceptions, Error), TermErrors),
+    findall(Error, rule_limit_error(Head, Body, Exceptions, Error), LimitErrors),
+    append([ShapeErrors, BodyErrors, ExceptionErrors, VariableErrors, DeclarationErrors, ExceptionVariableErrors, TermErrors, LimitErrors], Errors0),
+    sort(Errors0, Errors).
+
+rule_term_safety_error(Head, Body, Exceptions, invalid_interval) :-
+    member(Term, [Head, Body|Exceptions]),
+    expression_term(Term, interval(Start, End)),
+    Start @> End.
+
+rule_limit_error(Head, Body, Exceptions, too_many_atoms) :-
+    expression_atom_count(Head, HeadCount),
+    expression_atom_count(Body, BodyCount),
+    maplist(expression_atom_count, Exceptions, ExceptionCounts),
+    sum_list([HeadCount, BodyCount|ExceptionCounts], Count),
+    Count > 64.
+rule_limit_error(Head, Body, Exceptions, expression_depth_exceeded) :-
+    member(Term, [Head, Body|Exceptions]),
+    expression_depth(Term, Depth),
+    Depth > 16.
+
+expression_atom_count(none, 0).
+expression_atom_count(atom(_, _, _, _, _), 1).
+expression_atom_count(all(Items), Count) :- maplist(expression_atom_count, Items, Counts), sum_list(Counts, ChildCount), Count is ChildCount.
+expression_atom_count(any(Items), Count) :- maplist(expression_atom_count, Items, Counts), sum_list(Counts, ChildCount), Count is ChildCount.
+expression_atom_count(not(Atom), Count) :- expression_atom_count(Atom, ChildCount), Count is ChildCount.
+expression_atom_count(compare(_, _, _), 0).
+expression_atom_count(count(Atom, _, _), Count) :- expression_atom_count(Atom, Count).
+expression_atom_count(temporal(_, _, _), 0).
+
+expression_depth(none, 0).
+expression_depth(atom(_, _, _, _, _), 1).
+expression_depth(all(Items), Depth) :- maplist(expression_depth, Items, Depths), max_list([0|Depths], ChildDepth), Depth is ChildDepth + 1.
+expression_depth(any(Items), Depth) :- maplist(expression_depth, Items, Depths), max_list([0|Depths], ChildDepth), Depth is ChildDepth + 1.
+expression_depth(not(Atom), Depth) :- expression_depth(Atom, ChildDepth), Depth is ChildDepth + 1.
+expression_depth(compare(_, _, _), 1).
+expression_depth(count(Atom, _, _), Depth) :- expression_depth(Atom, ChildDepth), Depth is ChildDepth + 1.
+expression_depth(temporal(_, _, _), 1).
+
+expression_term(atom(_, _, Args, _, _), Term) :- member(Term, Args).
+expression_term(all(Items), Term) :- member(Item, Items), expression_term(Item, Term).
+expression_term(any(Items), Term) :- member(Item, Items), expression_term(Item, Term).
+expression_term(not(Atom), Term) :- expression_term(Atom, Term).
+expression_term(compare(_, Left, Right), Term) :- member(Term, [Left, Right]).
+expression_term(count(Atom, _, _), Term) :- expression_term(Atom, Term).
+expression_term(temporal(_, Left, Right), Term) :- member(Term, [Left, Right]).
+expression_term(Term, Term) :- Term = interval(_, _).
+
+variable_safety_error(Head, Body, _Variables, head_variable_not_range_restricted(Name)) :-
+    head_variable(Name, Head),
+    \+ positive_variable(Name, Body).
+variable_safety_error(Head, _Body, Variables, existential_head_variable(Name)) :-
+    head_variable(Name, Head),
+    memberchk(variable(Name, _Type, exists), Variables).
+variable_safety_error(_Head, Body, _Variables, body_variable_not_range_restricted(Name)) :-
+    body_variable(Name, Body),
+    \+ positive_variable(Name, Body).
+
+variable_safety_error(Head, Body, Variables, existential_variable_not_body_local(Name)) :-
+    memberchk(variable(Name, _Type, exists), Variables),
+    ( head_variable(Name, Head) ; \+ expression_variable(Body, Name) ).
+
+undeclared_variable_error(Head, Body, Exceptions, Variables, undeclared_variable(Name)) :-
+    member(Expression, [Head, Body|Exceptions]),
+    expression_variable(Expression, Name),
+    \+ memberchk(variable(Name, _Type, _Quantifier), Variables).
+
+exception_variable_safety_error(Exception, Body, exception_variable_not_range_restricted(Name)) :-
+    expression_variable(Exception, Name),
+    \+ positive_variable(Name, Body).
+
+head_variable(Name, atom(_, _, Args, _, _)) :- member(Arg, Args), term_variable(Arg, Name).
+body_variable(Name, Expression) :- expression_variable(Expression, Name).
+positive_variable(Name, atom(_, _, Args, positive, _)) :- member(Arg, Args), term_variable(Arg, Name).
+positive_variable(Name, all(Items)) :- member(Item, Items), positive_variable(Name, Item).
+positive_variable(Name, any(Items)) :- member(Item, Items), positive_variable(Name, Item).
+positive_variable(Name, count(Atom, _, _)) :- positive_variable(Name, Atom).
+positive_variable(_, _) :- fail.
+
+term_variable(var(Name, _), Name).
+expression_variable(atom(_, _, Args, _, _), Name) :- member(Arg, Args), term_variable(Arg, Name).
+expression_variable(all(Items), Name) :- member(Item, Items), expression_variable(Item, Name).
+expression_variable(any(Items), Name) :- member(Item, Items), expression_variable(Item, Name).
+expression_variable(not(Atom), Name) :- expression_variable(Atom, Name).
+expression_variable(compare(_, Left, Right), Name) :- (term_variable(Left, Name) ; term_variable(Right, Name)).
+expression_variable(count(Atom, _, _), Name) :- expression_variable(Atom, Name).
+expression_variable(temporal(_, Left, Right), Name) :- (term_variable(Left, Name) ; term_variable(Right, Name)).
+
+rule_shape_error(atom, none, _Body, missing_head).
+rule_shape_error(atom, _Head, Body, body_for_atom) :- Body \= none.
+rule_shape_error(rule, none, _Body, missing_head).
+rule_shape_error(rule, _Head, none, missing_body).
+rule_shape_error(constraint, _Head, none, missing_body).
+rule_shape_error(constraint, Head, _Body, head_for_constraint) :- Head \= none.
+rule_shape_error(_, _, _, _) :- fail.
+
+expression_safety_error(none, _) :- fail.
+expression_safety_error(not(atom(_, _, _, _, false)), negation_requires_closed_world).
+expression_safety_error(compare(Op, _Left, _Right), invalid_compare_operator) :- \+ valid_compare_operator(Op).
+expression_safety_error(count(_Atom, Op, _Value), invalid_compare_operator) :- \+ valid_compare_operator(Op).
+expression_safety_error(count(_Atom, _Op, Value), invalid_count_value) :- \+ integer(Value) ; Value < 0.
+expression_safety_error(temporal(Relation, _Left, _Right), invalid_temporal_relation) :- \+ valid_temporal_relation(Relation).
+expression_safety_error(all(Items), Error) :- member(Item, Items), expression_safety_error(Item, Error).
+expression_safety_error(any(Items), Error) :- member(Item, Items), expression_safety_error(Item, Error).
+expression_safety_error(not(Atom), Error) :- expression_safety_error(Atom, Error).
+expression_safety_error(_, _) :- fail.
+
+%% logic_rule_render(+Props, -Text)
+logic_rule_render(Props, Text) :-
+    logic_rule_from_props(Props, Rule),
+    render_rule(Rule, Text).
+
+render_rule(rule(_Kind, Modality, Head, none, _Exceptions, _Scope, _From, _To, _Schema, _Variables), Text) :-
+    render_head(Modality, Head, HeadText), format(string(Text), '~w.', [HeadText]).
+render_rule(rule(_Kind, Modality, Head, Body, _Exceptions, _Scope, _From, _To, _Schema, _Variables), Text) :-
+    render_head(Modality, Head, HeadText), render_expression(Body, BodyText), format(string(Text), '~w :- ~w.', [HeadText, BodyText]).
+
+render_head(Modality, none, Text) :- format(string(Text), '~w', [Modality]).
+render_head(Modality, Atom, Text) :- render_atom(Atom, AtomText), format(string(Text), '~w(~w)', [Modality, AtomText]).
+render_atom(atom(Namespace, Name, Args, Polarity, _), Text) :-
+    ( Namespace == default -> Full = Name ; format(atom(Full), '~w:~w', [Namespace, Name]) ),
+    maplist(render_term, Args, Rendered), atomic_list_concat(Rendered, ',', ArgsText),
+    ( Polarity == negative -> format(string(Text), 'negative(~w(~w))', [Full, ArgsText]) ; format(string(Text), '~w(~w)', [Full, ArgsText]) ).
+render_term(var(Name, _), Name).
+render_term(const(Value, _), Value).
+render_term(number(Value, none), Text) :- format(string(Text), '~w', [Value]).
+render_term(number(Value, Unit), Text) :- format(string(Text), '~w~w', [Value, Unit]).
+render_term(duration(Value, Unit), Text) :- format(string(Text), 'duration(~w,~w)', [Value, Unit]).
+render_term(timestamp(Value), Value).
+render_term(interval(Start, End), Text) :- format(string(Text), 'interval(~w,~w)', [Start, End]).
+render_expression(Atom, Text) :- Atom = atom(_, _, _, _, _), !, render_atom(Atom, Text).
+render_expression(all(Items), Text) :- maplist(render_expression, Items, Parts), atomic_list_concat(Parts, ', ', Text).
+render_expression(any(Items), Text) :- maplist(render_expression, Items, Parts), atomic_list_concat(Parts, ' ; ', Inner), format(string(Text), '(~w)', [Inner]).
+render_expression(not(Atom), Text) :- render_atom(Atom, AtomText), format(string(Text), 'not(~w)', [AtomText]).
+render_expression(compare(Op, Left, Right), Text) :- render_term(Left, L), render_term(Right, R), format(string(Text), '~w ~w ~w', [L, Op, R]).
+render_expression(count(Atom, Op, Value), Text) :- render_atom(Atom, AtomText), format(string(Text), 'count(~w,~w,~w)', [AtomText, Op, Value]).
+render_expression(temporal(Relation, Left, Right), Text) :- render_term(Left, L), render_term(Right, R), format(string(Text), 'temporal(~w,~w,~w)', [Relation, L, R]).
+
+logic_rule_semantic_key(Props, Key) :-
+    memberchk(semantic_key=Key, Props), !.
+logic_rule_semantic_key(Props, Key) :-
+    memberchk(rule_hash=Hash, Props), !, Key = Hash.
+
+logic_atom_signature(atom(Namespace, Name, Args, Polarity, _), signature(Namespace, Name, Args, Polarity)).
+
+%% logic_derive(+Goal, -Proof)
+% Goal is atom(Namespace, Name, Args, Polarity), with ground arguments.  Rules
+% are interpreted by a finite, data-driven evaluator; no stored source is
+% consulted and recursive rule chains are bounded.
+logic_derive(Goal, Proof) :-
+    ground(Goal),
+    derive_goal(Goal, [], 0, Proof).
+
+logic_max_depth(16).
+
+derive_goal(Goal, _Seen, _Depth, direct(FactId)) :-
+    Goal = atom(Namespace, Name, Args, Polarity, _),
+    predicate_fact(FactId, Namespace, Name, Args, Polarity), !.
+derive_goal(Goal, Seen, Depth, rule(FactId, BodyProof)) :-
+    logic_max_depth(MaxDepth),
+    Depth < MaxDepth,
+    logic_rule_fact(FactId, StoredRule),
+    materialize_rule(StoredRule, Rule),
+    Rule = rule(rule, _Modality, Head, Body, Exceptions, _Scope, _From, _To, _Schema, _Variables),
+    Goal = Head,
+    atom_signature_for_seen(Head, Signature),
+    \+ memberchk(Signature, Seen),
+    NextDepth is Depth + 1,
+    prove_expression(Body, [Signature|Seen], NextDepth, BodyProof),
+    exceptions_do_not_hold(Exceptions, [Signature|Seen], NextDepth).
+
+logic_rule_fact(FactId, Rule) :-
+    kb_entity(FactId, fact, Props),
+    memberchk(fact_kind=Kind, Props), normalize_atom(Kind, rule),
+    logic_rule_from_props(Props, Rule).
+
+% The JSON decoder keeps variable names as data terms for validation and
+% rendering.  Evaluation reifies those names into fresh Prolog variables so
+% ordinary unification can be used without ever evaluating caller source.
+materialize_rule(
+    rule(Kind, Modality, Head, Body, Exceptions, Scope, From, To, Schema, Variables),
+    rule(Kind, Modality, MaterialHead, MaterialBody, MaterialExceptions, Scope, From, To, Schema, Variables)
+) :-
+    variable_environment(Variables, Environment),
+    materialize_head(Head, Environment, MaterialHead),
+    materialize_expression(Body, Environment, MaterialBody),
+    maplist(materialize_expression_with(Environment), Exceptions, MaterialExceptions).
+
+variable_environment([], []).
+variable_environment([variable(Name, _Type, _Quantifier)|Rest], [Name-_Variable|Environment]) :-
+    variable_environment(Rest, Environment).
+
+materialize_head(none, _Variables, none).
+materialize_head(Head, Variables, MaterialHead) :- materialize_atom(Head, Variables, MaterialHead).
+
+materialize_expression(none, _Variables, none).
+materialize_expression(Expression, Variables, Materialized) :-
+    Expression = atom(_, _, _, _, _), !,
+    materialize_atom(Expression, Variables, Materialized).
+materialize_expression(all(Items), Variables, all(MaterialItems)) :- maplist(materialize_expression_with(Variables), Items, MaterialItems).
+materialize_expression(any(Items), Variables, any(MaterialItems)) :- maplist(materialize_expression_with(Variables), Items, MaterialItems).
+materialize_expression(not(Atom), Variables, not(MaterialAtom)) :- materialize_atom(Atom, Variables, MaterialAtom).
+materialize_expression(compare(Op, Left, Right), Variables, compare(Op, MaterialLeft, MaterialRight)) :-
+    materialize_term(Left, Variables, MaterialLeft), materialize_term(Right, Variables, MaterialRight).
+materialize_expression(count(Atom, Op, Value), Variables, count(MaterialAtom, Op, Value)) :- materialize_atom(Atom, Variables, MaterialAtom).
+materialize_expression(temporal(Relation, Left, Right), Variables, temporal(Relation, MaterialLeft, MaterialRight)) :-
+    materialize_term(Left, Variables, MaterialLeft), materialize_term(Right, Variables, MaterialRight).
+materialize_expression_with(Variables, Expression, Materialized) :- materialize_expression(Expression, Variables, Materialized).
+
+materialize_atom(atom(Namespace, Name, Args, Polarity, ClosedWorld), Variables, atom(Namespace, Name, MaterialArgs, Polarity, ClosedWorld)) :-
+    maplist(materialize_term_with(Variables), Args, MaterialArgs).
+materialize_term(var(Name, _Type), Variables, Variable) :- memberchk(Name-Variable, Variables), !.
+materialize_term(const(Value, Type), _Variables, const(Value, Type)).
+materialize_term(number(Value, Unit), _Variables, number(Value, Unit)).
+materialize_term(duration(Value, Unit), _Variables, duration(Value, Unit)).
+materialize_term(timestamp(Value), _Variables, timestamp(Value)).
+materialize_term(interval(Start, End), _Variables, interval(Start, End)).
+materialize_term_with(Variables, Term, Materialized) :- materialize_term(Term, Variables, Materialized).
+
+prove_expression(Atom, Seen, Depth, Proof) :-
+    Atom = atom(_, _, _, _, _),
+    derive_goal(Atom, Seen, Depth, Proof).
+prove_expression(all(Items), Seen, Depth, all(Proofs)) :- maplist(prove_expression_seen(Seen, Depth), Items, Proofs).
+prove_expression(any(Items), Seen, Depth, Proof) :- member(Item, Items), prove_expression(Item, Seen, Depth, Proof), !.
+prove_expression(not(Atom), Seen, Depth, negated(Atom)) :-
+    Atom = atom(Namespace, Name, Args, Polarity, _),
+    \+ derive_goal(atom(Namespace, Name, Args, Polarity, _), Seen, Depth, _).
+prove_expression(compare(Op, Left, Right), _Seen, _Depth, comparison(Op, Left, Right)) :- compare_terms(Op, Left, Right).
+prove_expression(count(Atom, Op, Value), _Seen, _Depth, count(Atom, Op, Value)) :-
+    Atom = atom(Namespace, Name, Args, Polarity, _),
+    aggregate_all(count, predicate_fact(_, Namespace, Name, Args, Polarity), Count),
+    compare_numbers(Op, Count, Value).
+prove_expression(temporal(Relation, Left, Right), _Seen, _Depth, temporal(Relation, Left, Right)) :- temporal_holds(Relation, Left, Right).
+prove_expression_seen(Seen, Depth, Item, Proof) :- prove_expression(Item, Seen, Depth, Proof).
+
+exceptions_do_not_hold([], _Seen, _Depth).
+exceptions_do_not_hold([Exception|Rest], Seen, Depth) :-
+    \+ prove_expression(Exception, Seen, Depth, _),
+    exceptions_do_not_hold(Rest, Seen, Depth).
+
+atom_signature_for_seen(atom(Namespace, Name, Args, Polarity, _), signature(Namespace, Name, Args, Polarity)).
+
+compare_terms(eq, Left, Right) :- term_value(Left, L), term_value(Right, R), L = R.
+compare_terms(neq, Left, Right) :- term_value(Left, L), term_value(Right, R), L \= R.
+compare_terms(lt, Left, Right) :- term_value(Left, L), term_value(Right, R), L < R.
+compare_terms(lte, Left, Right) :- term_value(Left, L), term_value(Right, R), L =< R.
+compare_terms(gt, Left, Right) :- term_value(Left, L), term_value(Right, R), L > R.
+compare_terms(gte, Left, Right) :- term_value(Left, L), term_value(Right, R), L >= R.
+
+term_value(number(Value, Unit), Normalized) :- normalize_numeric_unit(Value, Unit, Normalized).
+term_value(duration(Value, Unit), Normalized) :- duration_milliseconds(Value, Unit, Normalized).
+term_value(const(Value, _), Number) :- atom_number(Value, Number), !.
+term_value(const(Value, _), Value).
+term_value(Value, Value) :- number(Value).
+
+normalize_numeric_unit(Value, none, Value) :- !.
+normalize_numeric_unit(Value, Unit, Normalized) :-
+    duration_milliseconds(Value, Unit, Normalized).
+
+duration_milliseconds(Value, ms, Value) :- !.
+duration_milliseconds(Value, s, Normalized) :- Normalized is Value * 1000, !.
+duration_milliseconds(Value, m, Normalized) :- Normalized is Value * 60000, !.
+duration_milliseconds(Value, h, Normalized) :- Normalized is Value * 3600000, !.
+duration_milliseconds(Value, d, Normalized) :- Normalized is Value * 86400000, !.
+duration_milliseconds(Value, w, Normalized) :- Normalized is Value * 604800000, !.
+duration_milliseconds(Value, _Unit, Value).
+
+compare_numbers(eq, L, R) :- L =:= R.
+compare_numbers(neq, L, R) :- L =\= R.
+compare_numbers(lt, L, R) :- L < R.
+compare_numbers(lte, L, R) :- L =< R.
+compare_numbers(gt, L, R) :- L > R.
+compare_numbers(gte, L, R) :- L >= R.
+
+temporal_holds(before, Left, Right) :-
+    temporal_end(Left, LeftEnd),
+    temporal_start(Right, RightStart),
+    LeftEnd @< RightStart.
+temporal_holds(after, Left, Right) :-
+    temporal_start(Left, LeftStart),
+    temporal_end(Right, RightEnd),
+    LeftStart @> RightEnd.
+temporal_holds(during, timestamp(Point), interval(Start, End)) :-
+    Point @>= Start,
+    Point @=< End.
+temporal_holds(during, interval(InnerStart, InnerEnd), interval(Start, End)) :-
+    InnerStart @>= Start,
+    InnerEnd @=< End.
+temporal_holds(overlaps, interval(LeftStart, LeftEnd), interval(RightStart, RightEnd)) :-
+    LeftStart @< RightEnd,
+    RightStart @< LeftEnd.
+temporal_holds(starts, interval(LeftStart, _), interval(RightStart, _)) :-
+    LeftStart == RightStart.
+temporal_holds(finishes, interval(_, LeftEnd), interval(_, RightEnd)) :-
+    LeftEnd == RightEnd.
+
+temporal_start(timestamp(Value), Value).
+temporal_start(interval(Start, _), Start).
+temporal_end(timestamp(Value), Value).
+temporal_end(interval(_, End), End).
+
+%% logic_rule_conflict(+RuleA, +RuleB, -Status)
+% Conservative symbolic conflict result.  Identical opposing heads are a
+% proven conflict; different bodies remain unresolved unless their explicit
+% numeric/temporal constraints are disjoint.
+logic_rule_conflict(RuleA, RuleB, contradiction) :-
+    opposing_rule_heads(RuleA, RuleB),
+    compatible_rule_context(RuleA, RuleB),
+    same_rule_body(RuleA, RuleB), !.
+logic_rule_conflict(RuleA, RuleB, unresolved) :-
+    opposing_rule_heads(RuleA, RuleB),
+    compatible_rule_context(RuleA, RuleB), !.
+logic_rule_conflict(_, _, disjoint).
+
+%% logic_rules_stratified(+Rules)
+% Check the finite dependency graph for a negated edge on a cycle.  A single
+% rule can be locally safe while a collection of rules still forms an
+% unstratified negation cycle (p(X) :- not q(X), q(X) :- not p(X)).  The
+% interpreter therefore exposes this collection-level check to the KB
+% validation layer instead of relying on Prolog's negation-as-failure.
+logic_rules_stratified(Rules) :-
+    is_list(Rules),
+    findall(
+        edge(HeadPredicate, BodyPredicate, Sign),
+        ( member(Rule, Rules), rule_dependency_edge(Rule, HeadPredicate, BodyPredicate, Sign) ),
+        Edges
+    ),
+    \+ (
+        member(edge(From, To, negative), Edges),
+        dependency_path(To, From, Edges, [])
+    ).
+
+rule_dependency_edge(
+    rule(rule, _Modality, Head, Body, _Exceptions, _Scope, _From, _To, _Schema, _Variables),
+    HeadPredicate,
+    BodyPredicate,
+    Sign
+) :-
+    logic_predicate_signature(Head, HeadPredicate),
+    expression_dependency(Body, BodyAtom, Sign),
+    logic_predicate_signature(BodyAtom, BodyPredicate).
+
+logic_predicate_signature(atom(Namespace, Name, Args, _Polarity, _ClosedWorld), predicate(Namespace, Name, Arity)) :-
+    length(Args, Arity).
+
+expression_dependency(atom(_Namespace, _Name, _Args, _Polarity, _ClosedWorld), Atom, positive) :-
+    Atom = atom(_, _, _, _, _).
+expression_dependency(not(Atom), Atom, negative).
+expression_dependency(all(Items), Atom, Sign) :- member(Item, Items), expression_dependency(Item, Atom, Sign).
+expression_dependency(any(Items), Atom, Sign) :- member(Item, Items), expression_dependency(Item, Atom, Sign).
+expression_dependency(count(Atom, _Operator, _Value), Atom, positive).
+
+dependency_path(Current, Target, _Edges, Seen) :-
+    Current == Target,
+    \+ memberchk(Current, Seen),
+    !.
+dependency_path(Current, Target, Edges, Seen) :-
+    \+ memberchk(Current, Seen),
+    member(edge(Current, Next, _Sign), Edges),
+    dependency_path(Next, Target, Edges, [Current|Seen]).
+
+%% logic_rule_conflict_witness(+RuleA, +RuleB, -Witness)
+% Return a structured, non-executable witness for an opposing rule result.
+% Consumers can attach requirement IDs and source spans without ever treating
+% the rendered Prolog preview as executable source.
+logic_rule_conflict_witness(RuleA, RuleB, Witness) :-
+    logic_rule_conflict(RuleA, RuleB, Status),
+    RuleA = rule(_KindA, ModalityA, HeadA, BodyA, ExceptionsA, ScopeA, FromA, ToA, SchemaA, _VariablesA),
+    RuleB = rule(_KindB, ModalityB, HeadB, BodyB, ExceptionsB, ScopeB, FromB, ToB, SchemaB, _VariablesB),
+    Witness = witness{
+        status: Status,
+        modality_a: ModalityA,
+        modality_b: ModalityB,
+        head_a: HeadA,
+        head_b: HeadB,
+        body_a: BodyA,
+        body_b: BodyB,
+        exceptions_a: ExceptionsA,
+        exceptions_b: ExceptionsB,
+        scope_a: ScopeA,
+        scope_b: ScopeB,
+        valid_from_a: FromA,
+        valid_to_a: ToA,
+        valid_from_b: FromB,
+        valid_to_b: ToB,
+        rule_schema_a: SchemaA,
+        rule_schema_b: SchemaB
+    }.
+
+opposing_rule_heads(rule(_, ModalityA, HeadA, _, _, _, _, _, _, _), rule(_, ModalityB, HeadB, _, _, _, _, _, _, _)) :-
+    conflicting_modality(ModalityA, ModalityB),
+    copy_term((HeadA, HeadB), (CopyA, CopyB)),
+    CopyA = CopyB.
+
+conflicting_modality(assert, deny).
+conflicting_modality(deny, assert).
+conflicting_modality(oblige, forbid).
+conflicting_modality(forbid, oblige).
+conflicting_modality(permit, forbid).
+conflicting_modality(forbid, permit).
+
+compatible_rule_context(rule(_, _, _, BodyA, _, scope(AuthA, ScopeA, _), FromA, ToA, _, _), rule(_, _, _, BodyB, _, scope(AuthB, ScopeB, _), FromB, ToB, _, _)) :-
+    (AuthA == '' ; AuthB == '' ; AuthA == AuthB),
+    (ScopeA == '' ; ScopeB == '' ; ScopeA == ScopeB),
+    (FromA == '' ; ToB == '' ; FromA @=< ToB),
+    (FromB == '' ; ToA == '' ; FromB @=< ToA),
+    bodies_may_overlap(BodyA, BodyB).
+
+bodies_may_overlap(none, _).
+bodies_may_overlap(_, none).
+bodies_may_overlap(BodyA, BodyB) :-
+    BodyA \= none,
+    BodyB \= none,
+    \+ bodies_definitely_disjoint(BodyA, BodyB).
+
+bodies_definitely_disjoint(BodyA, _BodyB) :- expression_definitely_false(BodyA), !.
+bodies_definitely_disjoint(_BodyA, BodyB) :- expression_definitely_false(BodyB), !.
+
+% Only classify a body as impossible when its finite, ground comparison or
+% temporal constraint can be evaluated to false.  Unknown atoms, variables,
+% and unsupported combinations remain unresolved rather than being treated as
+% disjoint by guesswork.
+expression_definitely_false(compare(Op, Left, Right)) :-
+    ground(compare(Op, Left, Right)),
+    \+ catch(compare_terms(Op, Left, Right), _, fail).
+expression_definitely_false(temporal(Relation, Left, Right)) :-
+    ground(temporal(Relation, Left, Right)),
+    \+ catch(temporal_holds(Relation, Left, Right), _, fail).
+expression_definitely_false(all(Items)) :-
+    member(Item, Items),
+    expression_definitely_false(Item), !.
+expression_definitely_false(any(Items)) :-
+    Items \= [],
+    maplist(expression_definitely_false, Items).
+
+same_rule_body(RuleA, RuleB) :-
+    RuleA = rule(_, _, _, BodyA, ExceptionsA, ScopeA, FromA, ToA, _, _),
+    RuleB = rule(_, _, _, BodyB, ExceptionsB, ScopeB, FromB, ToB, _, _),
+    BodyA == BodyB, ExceptionsA == ExceptionsB, ScopeA == ScopeB, FromA == FromB, ToA == ToB.
+
+normalize_atom(Value, Atom) :- atom(Value), !, Atom = Value.
+normalize_atom(Value, Atom) :- string(Value), atom_string(Atom, Value).