fix(lance-graph-ontology): resolve Codex PR #407 P1 + P2 review findings

P1 — SKR03 Bau no longer overwrites canonical SKR03 slot:

  Before: hydrate_skr03_bau registered into OGIT::SKR03_V1 (same slot
  as canonical), so a caller that hydrated both lost the canonical
  4-digit account set on the second call. The test only invoked Bau
  alone so the silent overwrite went undetected.

  After: SKR 03 Bau hydrates into its OWN G slot OGIT::SKR03BAU_V1=42,
  with inherits_from: Some(OGIT::SKR03_V1.0) to make the structural
  dependency on canonical SKR 03 explicit. Mixed consumers can now
  hold canonical SKR 03 (4-digit, slot 40) AND Bau (6-digit, slot 42)
  in the same OntologyRegistry without interference.

  - crates/lance-graph-contract/build.rs: allocates SKR03BAU=42
  - crates/lance-graph-ontology/src/hydrators/skr_datev.rs: hydrate_skr03_bau
    writes to OGIT::SKR03BAU_V1.0 with the new inherits_from
  - modules/skr03-bau/manifest.yaml: declares 5 anchor trade-specific
    accounts (Sand- und Kiesausbeute, Bauliche Anlagen für stationäre
    Fertigung, Bauten auf dem Bauhof) with stable u16 entity IDs
  - tests: skr03_bau_extensions_hydrate_into_skr03_slot renamed to
    skr03_bau_extensions_hydrate_into_dedicated_slot (expects slot 42)
  - NEW REGRESSION TEST: skr03_canonical_and_bau_coexist_in_one_registry
    hydrates both schemes in sequence, asserts:
      - canonical bundle still has 1400+ entities (not dropped)
      - canonical SKR 03/1000 (Kasse) resolves in canonical bundle
      - Bau /007510 (Sand- und Kiesausbeute) resolves in Bau bundle
      - Bau IRIs do NOT resolve in canonical bundle (and vice versa)

P2 — Schematron Event::Empty no longer leaks state into later text:

  Before: <assert .../>, <report .../>, <pattern .../> (self-closing)
  emitted Event::Empty handled with the same branch as Event::Start
  and set in_assert_or_report = true. Self-closing elements never
  emit a matching Event::End, so the flag stayed stuck true and the
  parser scanned later unrelated text body as rule message text,
  producing spurious /rule/... IRIs.

  After: Event::Start and Event::Empty are split into separate match
  arms. Empty interns the @id only (no body to collect) and does NOT
  touch in_assert_or_report. Start sets the flag; End extracts rule
  IDs from current_text_buf and resets state. Self-closing elements
  no longer affect state.

  - crates/lance-graph-ontology/src/hydrators/schematron.rs
  - NEW REGRESSION TEST: self_closing_assert_does_not_capture_later_text
    constructs a fixture with a self-closing <assert/> followed by
    a non-assert <bar> element containing "[BR-99]" text, then a
    normal Start/End assert containing "[BR-42]":
      - A-EMPTY-001 and A-NORMAL-001 assert IRIs both resolve
      - BR-42 (real rule from message body) resolves
      - BR-99 (from stray text outside any assert) does NOT resolve

Side fix: replaced `if !map.contains_key(&iri) { map.insert(iri, id) }`
in SkrHydrator with the Entry::Vacant pattern to clear a clippy
`map_entry` warning. Clippy back to 5 warnings (all pre-existing
oxrdf deprecation warnings, no new ones).

All 116 lance-graph-ontology tests pass (was 114; +2 regression tests);
downstream consumers build clean.

Author: claude

crates/lance-graph-contract/build.rs

@@ -55,6 +55,12 @@ const CANONICAL_SLOTS: &[(&str, u32)] = &[
     // in SKR 04 but "Kasse" in SKR 03).
     ("SKR03", 40),
     ("SKR04", 41),
+    // SKR 03 Bau und Handwerk (Branchenpaket 19606) — trade-specific
+    // 6-digit extensions on top of canonical SKR 03 (Sand- und
+    // Kiesausbeute, Bauliche Anlagen, etc.). Hydrates into its OWN G
+    // slot rather than the canonical SKR03_V1 slot so mixed consumers
+    // can hold both account sets in one OntologyRegistry.
+    ("SKR03BAU", 42),
 ];
 
 fn canonical_slot(token: &str) -> Option<u32> {

crates/lance-graph-ontology/src/hydrators/schematron.rs

@@ -128,7 +128,7 @@ fn walk_sch(
                 });
             }
             Ok(Event::Eof) => break,
-            Ok(Event::Start(e)) | Ok(Event::Empty(e)) => {
+            Ok(Event::Start(e)) => {
                 let qname = e.name();
                 let local: Vec<u8> = local_name(qname.as_ref()).to_vec();
                 let id = attr_value(&e, b"id");
@@ -158,6 +158,38 @@ fn walk_sch(
                     _ => {}
                 }
             }
+            // Self-closing `<assert .../>` / `<report .../>` / `<pattern .../>`
+            // emit Event::Empty WITHOUT a matching Event::End. We MUST NOT set
+            // `in_assert_or_report = true` here — there is no text body to
+            // collect, and leaving the flag stuck true causes downstream
+            // unrelated text to be scanned as rule text and produce spurious
+            // `/rule/...` IRIs (Codex P2 finding, PR #407 review).
+            Ok(Event::Empty(e)) => {
+                let qname = e.name();
+                let local: Vec<u8> = local_name(qname.as_ref()).to_vec();
+                let id = attr_value(&e, b"id");
+                match local.as_slice() {
+                    b"assert" => {
+                        if let Some(id) = id.as_deref() {
+                            let iri = format!("{base_iri}/assert/{id}");
+                            intern(iri, iri_to_id, next_id);
+                        }
+                    }
+                    b"report" => {
+                        if let Some(id) = id.as_deref() {
+                            let iri = format!("{base_iri}/report/{id}");
+                            intern(iri, iri_to_id, next_id);
+                        }
+                    }
+                    b"pattern" => {
+                        if let Some(id) = id.as_deref() {
+                            let iri = format!("{base_iri}/pattern/{id}");
+                            intern(iri, iri_to_id, next_id);
+                        }
+                    }
+                    _ => {}
+                }
+            }
             Ok(Event::Text(t)) if in_assert_or_report => {
                 if let Ok(s) = std::str::from_utf8(t.as_ref()) {
                     current_text_buf.push_str(s);
@@ -348,4 +380,66 @@ mod tests {
         let ids = extract_business_rule_ids(s);
         assert_eq!(ids, vec!["BR-45".to_string()]);
     }
+
+    const SELF_CLOSING_SCH: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
+<schema xmlns="http://purl.oclc.org/dsdl/schematron" queryBinding="xslt2">
+  <pattern id="P-empty">
+    <rule context="//foo">
+      <!-- Self-closing assert: no message body, no End event. -->
+      <assert id="A-EMPTY-001" test="bar"/>
+      <!-- After the self-closing assert, this stray text mentioning
+           [BR-99] in a non-assert/non-report context MUST NOT be
+           picked up as a rule IRI. -->
+      <bar>Stray [BR-99] text outside any assert</bar>
+      <!-- Normal Start/End assert AFTER the empty: must work as usual. -->
+      <assert id="A-NORMAL-001" test="baz">[BR-42]-Real rule.</assert>
+    </rule>
+  </pattern>
+</schema>
+"#;
+
+    #[test]
+    fn self_closing_assert_does_not_capture_later_text() {
+        // Regression test for the Codex P2 finding (PR #407 review):
+        // `<assert .../>` emits Event::Empty with no matching End. Before
+        // the fix, `in_assert_or_report` was set true and never reset,
+        // so subsequent text bodies were scanned as rule message text
+        // and produced spurious /rule/... IRIs.
+        let dir = tempdir().unwrap();
+        let path = dir.path().join("self-closing.sch");
+        let mut f = std::fs::File::create(&path).unwrap();
+        f.write_all(SELF_CLOSING_SCH.as_bytes()).unwrap();
+        drop(f);
+
+        let reg = OntologyRegistry::new_in_memory();
+        let h = SchematronHydrator {
+            g: 6666,
+            version: 1,
+            domain_name: "self-closing".to_string(),
+            inherits_from: None,
+            starting_entity_id: 100,
+            base_iri: "urn:schematron:test".to_string(),
+        };
+        h.hydrate_many(&[&path], &reg).expect("hydrate");
+
+        let bundle = reg.bundle_for(6666).expect("bundle");
+
+        // Assert IDs from both the empty and the normal assert resolve.
+        assert!(bundle.resolve_iri("urn:schematron:test/assert/A-EMPTY-001").is_some());
+        assert!(bundle.resolve_iri("urn:schematron:test/assert/A-NORMAL-001").is_some());
+        assert!(bundle.resolve_iri("urn:schematron:test/pattern/P-empty").is_some());
+
+        // BR-42 from the NORMAL assert's body must resolve (positive control).
+        assert!(
+            bundle.resolve_iri("urn:schematron:test/rule/BR-42").is_some(),
+            "BR-42 from the normal assert's message body must resolve"
+        );
+
+        // BR-99 from text OUTSIDE any assert/report must NOT resolve.
+        assert!(
+            bundle.resolve_iri("urn:schematron:test/rule/BR-99").is_none(),
+            "BR-99 was in stray text outside an assert; must NOT have been \
+             interned as a rule IRI (this was the P2 corruption case)"
+        );
+    }
 }

crates/lance-graph-ontology/src/hydrators/skr.rs

@@ -91,10 +91,10 @@ impl SkrHydrator {
                 continue;
             }
             let iri = format!("{}/{}", self.iri_prefix, account_number);
-            if !iri_to_id.contains_key(&iri) {
+            if let std::collections::hash_map::Entry::Vacant(slot) = iri_to_id.entry(iri) {
                 let id = next_id;
                 next_id += 1;
-                iri_to_id.insert(iri, id);
+                slot.insert(id);
             }
         }
 

crates/lance-graph-ontology/src/hydrators/skr_datev.rs

@@ -1,17 +1,21 @@
-//! Wiring for the two DATEV SKR schemes.
+//! Wiring for the DATEV SKR schemes.
 //!
 //! - `hydrate_skr03` → `OGIT::SKR03_V1`, base IRI `urn:datev:skr03:account`.
 //!   Reads `data/ontologies/skr-datev/skr03.csv` (canonical 4-digit accounts).
 //! - `hydrate_skr04` → `OGIT::SKR04_V1`, base IRI `urn:datev:skr04:account`.
 //!   Reads `data/ontologies/skr-datev/skr04.csv`.
-//! - `hydrate_skr03_bau` → also `OGIT::SKR03_V1`, but with the 6-digit Bau
-//!   variant. Test-only entry point; the default `hydrate_skr03` uses the
-//!   canonical 4-digit form because cross-scheme alignment (FIBO, ZUGFeRD)
-//!   anchors to 4-digit numbers.
+//! - `hydrate_skr03_bau` → `OGIT::SKR03BAU_V1` (slot 42), base IRI
+//!   `urn:datev:skr03-bau:account`. Reads
+//!   `data/ontologies/skr-datev/skr03-bau.csv` with the 6-digit Bau-und-Handwerk
+//!   trade-specific subdivisions. Lives in its OWN G slot (not SKR03_V1)
+//!   so callers can hold BOTH canonical SKR 03 AND Bau extensions in one
+//!   `OntologyRegistry` without one overwriting the other. The Bau slot
+//!   declares `inherits_from: Some(OGIT::SKR03_V1.0)` to make the
+//!   structural dependency explicit.
 //!
-//! Both schemes declare `inherits_from: Some(OGIT::DOLCE_V1.0)` — accounts
-//! are abstract economic objects, anchored to DUL Object via the cognitive
-//! shader's downstream alignment axioms (not baked in here).
+//! SKR 03 and SKR 04 each declare `inherits_from: Some(OGIT::DOLCE_V1.0)` —
+//! accounts are abstract economic objects, anchored to DUL Object via the
+//! cognitive shader's downstream alignment axioms (not baked in here).
 
 use std::path::{Path, PathBuf};
 
@@ -64,15 +68,15 @@ pub fn hydrate_skr03_bau_from(
     registry: &OntologyRegistry,
 ) -> Result<u32, HydrateErr> {
     let h = SkrHydrator {
-        g: OGIT::SKR03_V1.0,
-        version: OGIT::SKR03_V1.1,
+        g: OGIT::SKR03BAU_V1.0,
+        version: OGIT::SKR03BAU_V1.1,
         domain_name: "skr03-bau".to_string(),
-        inherits_from: Some(OGIT::DOLCE_V1.0),
+        inherits_from: Some(OGIT::SKR03_V1.0),
         starting_entity_id: 100,
         iri_prefix: SKR03_BAU_IRI_PREFIX.to_string(),
     };
     h.hydrate(csv_path, registry)?;
-    Ok(OGIT::SKR03_V1.0)
+    Ok(OGIT::SKR03BAU_V1.0)
 }
 
 /// Hydrate SKR 04 (4-digit accounts, balance-sheet-oriented) as `OGIT::SKR04_V1`.

crates/lance-graph-ontology/tests/skr_hydrator_smoke.rs

@@ -146,16 +146,24 @@ fn skr03_and_skr04_are_separate_slots() {
 }
 
 #[test]
-fn skr03_bau_extensions_hydrate_into_skr03_slot() {
-    // The Bau variant uses a SEPARATE IRI prefix (urn:datev:skr03-bau:…) so
-    // its 6-digit accounts coexist with the canonical 4-digit set. Bau
-    // extensions appear at sub-account numbers like 007510 (Sand- und
-    // Kiesausbeute), 010010 (Bauliche Anlagen für stationäre Fertigung).
+fn skr03_bau_extensions_hydrate_into_dedicated_slot() {
+    // Bau hydrates into ITS OWN G slot (OGIT::SKR03BAU_V1 = 42), NOT the
+    // canonical SKR03_V1 slot, so a caller that hydrates BOTH canonical
+    // and Bau in the same OntologyRegistry holds both bundles
+    // independently without one overwriting the other. The Bau bundle
+    // declares inherits_from: Some(OGIT::SKR03_V1.0) to make the
+    // structural dependency on canonical SKR 03 explicit.
     let registry = OntologyRegistry::new_in_memory();
     let g = hydrate_skr03_bau(&registry).expect("SKR 03 Bau hydrates");
-    assert_eq!(g, OGIT::SKR03_V1.0);
+    assert_eq!(g, OGIT::SKR03BAU_V1.0);
 
     let bundle = registry.bundle_for(g).expect("bundle");
+    assert_eq!(bundle.domain_name, "skr03-bau");
+    assert_eq!(
+        bundle.inherits_from,
+        Some(OGIT::SKR03_V1.0),
+        "Bau must inherit from canonical SKR 03"
+    );
     // 1686 in the Bau CSV. Allow a bit of slack.
     assert!(
         bundle.entity_count() >= 1600,
@@ -171,3 +179,44 @@ fn skr03_bau_extensions_hydrate_into_skr03_slot() {
         );
     }
 }
+
+#[test]
+fn skr03_canonical_and_bau_coexist_in_one_registry() {
+    // Regression test for the Codex P1 finding (PR #407 review):
+    // hydrate_skr03 + hydrate_skr03_bau in sequence must populate TWO
+    // distinct G slots, not overwrite each other. Before the fix the
+    // second call dropped the canonical 4-digit accounts because both
+    // hydrators registered into OGIT::SKR03_V1.
+    let registry = OntologyRegistry::new_in_memory();
+    hydrate_skr03(&registry).expect("canonical SKR 03");
+    hydrate_skr03_bau(&registry).expect("SKR 03 Bau");
+
+    let canonical = registry.bundle_for(OGIT::SKR03_V1.0).expect("canonical bundle");
+    let bau = registry.bundle_for(OGIT::SKR03BAU_V1.0).expect("Bau bundle");
+
+    // Canonical bundle: 4-digit IRI base, includes load-bearing accounts.
+    assert!(
+        canonical.resolve_iri(&format!("{SKR03_IRI_PREFIX}/1000")).is_some(),
+        "canonical SKR 03 / 1000 Kasse must still resolve after Bau hydration"
+    );
+    assert!(
+        canonical.entity_count() >= 1400,
+        "canonical SKR 03 must retain its full account set after Bau hydration"
+    );
+
+    // Bau bundle: 6-digit IRI base, includes trade-specific extensions.
+    assert!(
+        bau.resolve_iri(&format!("{SKR03_BAU_IRI_PREFIX}/007510")).is_some(),
+        "Bau extension 007510 must resolve in Bau bundle"
+    );
+
+    // Cross-resolve: Bau IRI must NOT resolve in canonical bundle and vice versa.
+    assert!(
+        canonical.resolve_iri(&format!("{SKR03_BAU_IRI_PREFIX}/007510")).is_none(),
+        "Bau IRI must not resolve in canonical SKR 03 bundle"
+    );
+    assert!(
+        bau.resolve_iri(&format!("{SKR03_IRI_PREFIX}/1000")).is_none(),
+        "canonical SKR 03 IRI must not resolve in Bau bundle"
+    );
+}

modules/skr03-bau/manifest.yaml

@@ -0,0 +1,30 @@
+ogit_g: SKR03BAU
+version: 1
+domain_name: skr03-bau
+inert_when_consumer_absent: true
+
+# DATEV SKR 03 Bau und Handwerk (Branchenpaket Art.-Nr. 19606, 2026
+# edition). 6-digit account format: NNNN + 2-digit trade-specific
+# subdivision. The full Bau CSV has 1880 accounts; 210 of these are
+# trade-specific extensions (NN > 00) on top of the canonical 1623
+# 4-digit accounts that ship in OGIT::SKR03_V1.
+#
+# Hydrates into its OWN G slot (NOT SKR03_V1) so mixed consumers can
+# hold both canonical SKR 03 AND Bau extensions in one OntologyRegistry.
+#
+# Anchor accounts here are trade-specific load-bearing entries.
+entity_types:
+  # Substanzverzehr (raw-material extraction — Sand/Kies pits, quarries)
+  Account_007510: u16=4200   # Sand- und Kiesausbeute
+  Account_007511: u16=4201   # Grundstücke mit Substanzverzehr (Bau variant)
+  # Bauliche Anlagen (construction-specific buildings)
+  Account_010010: u16=4202   # Bauliche Anlagen für stationäre Fertigung
+  Account_010011: u16=4203   # Fabrikbauten (Bau variant)
+  # Bauten auf dem Bauhof (yard buildings)
+  Account_011510: u16=4204   # Bauten auf dem Bauhof
+
+rbac_policy: ~
+stack_profile: ~
+action_capabilities: {}
+actor: ~
+inherits_from: skr03