feat(ar_shape): 5 sibling concepts land on real OSB+Odoo corpora — TaxPolicy / CommercialDocument / BillingParty / CurrencyPolicy / PaymentRecord (CanonicalConcept enum 1→6)

claude · claude · commit a77d9b71418f · 2026-06-20T17:35:44.000Z
Operator "continue with opensource-billing <> odoo" (2026-06-19). Each concept promotion is gated by ≥2-curator evidence on the real harvested corpora (OSB ndjson fixture + workspace Odoo manifest), not pre-emptively added. New shared helper: - declared_classes(triples, ns) — returns class IRIs surfaced as (class, rdf:type, ogit:ObjectType). Filters out method/field IRIs. 5 sibling lexical-shape detectors: - classes_matching_commercial_document_shape_canonical Ends-with(invoice|move|order) AND NOT contains("line"). Surfaces Invoice + account_move. Filters out InvoiceLineItem / account_move_line (those are CommercialLineItem, not Document). - classes_matching_tax_policy_shape_canonical Ends-with("tax"). Surfaces Tax + account_tax. Excludes TaxGroup / account_tax_group (lowercased "taxgroup" / "account_tax_group" don't end with "tax"). - classes_matching_billing_party_shape_canonical Ends-with(client|customer|partner). Surfaces Client + res_partner. - classes_matching_currency_policy_shape_canonical Ends-with("currency"). Surfaces Currency + res_currency. - classes_matching_payment_record_shape_canonical Ends-with("payment"). Surfaces Payment + account_payment (also CreditPayment as expected sub-type; downstream ranking picks primary). 5 corpus-driven tests matching operator's naming convention: - open_source_billing_invoice_and_odoo_account_move_overlap_as_commercial_document - open_source_billing_tax_and_odoo_tax_overlap_as_tax_policy - open_source_billing_client_and_odoo_res_partner_overlap_as_billing_party - open_source_billing_currency_and_odoo_res_currency_overlap_as_currency_policy - open_source_billing_payment_and_odoo_account_payment_overlap_as_payment_record Each loads the OSB ndjson fixture (1195 triples) + workspace Odoo manifest (2.8 MB) and asserts the expected class IRI appears on each side via lexical shape on declared OGIT ObjectTypes. Plus all 14 prior tests still green → 19/19 total. Scope discipline: - Lexical class-shape is the minimal viable detector. Structural refinement (incoming OGIT canonical relations FROM line-items for TaxPolicy; outgoing has_many to line-items for CommercialDocument) is the natural follow-up — not added pre-emptively. - CanonicalConcept enum at 6 variants: CommercialLineItem, CommercialDocument, TaxPolicy, BillingParty, PaymentRecord, CurrencyPolicy. SalesOrder / SalesOrderLine / ProductOffering / FulfillmentFlow / InventoryMovement / ProjectWorkItem / BillableWorkEntry stay deferred — operator smoke target B needs a Spree harvest; target C needs Project::TimeEntry + materialization rules. Cross-repo alignment with AdaWorldAPI/OGAR#61: the merged PR introduced const CODEBOOK: &[(&str, u16)] minting stable u16 ClassIds for promoted canonical concepts (today: project, project_work_item, billable_work_entry). The ar_shape CanonicalConcept enum is the upstream candidate set — concepts get promoted into OGAR's CODEBOOK once they clear the ≥2-curator gate AND OGAR-side review. Each new variant in this commit is a candidate row for a future OGAR CODEBOOK assignment. EPIPHANIES E-OGAR-AR-SHAPE-SMOKE-4 prepended. Cross-refs: - crates/lance-graph-ontology/src/ar_shape.rs (5 detectors + declared_classes helper + 5 tests; 19/19 green) - E-OGAR-AR-SHAPE-SMOKE-3 (OGIT canonical predecessor) - E-OGAR-AR-SHAPE-SMOKE-2 (predicate-vocabulary divergence finding) - E-OGAR-AR-SHAPE-SMOKE-1 (hand-fixture predecessor) - AdaWorldAPI/OGAR#61 (upstream u16 CODEBOOK registry — candidate promotion target for each ar_shape::CanonicalConcept variant) Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Xzyc27Nx3f8WC5KzwfWfjx
diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md
@@ -302,6 +302,30 @@ The local-scan `memberof` (#this-branch) is the **in-mailbox special case** of "
 **Three threads are ONE structure:** basin-tree (1→4→16…) = Morton tile pyramid (quadtree subdivision) = `perturbation-sim` L1-L4 cascade levels = the field perturbation-learning runs over. Distance = hop count = pyramid level = cascade round — **one number, three readings**.
 
 **Wiring (gated on the 5+3 council for the SoA-ownership commitment):** add `row_for_member_index` to the contract (basin-node → member row); wire the EdgeBlock out-family slot → sibling basin-node via ClassView (Options 1+2); reclassify **CHAODA as a unary `node_anomaly`** (point↔manifold LFD), NOT a pairwise `DistanceMeans` — it never belonged in the hop-distance dispatch. The `node_distance(PrefixDepth)` tree-hop is already the basin-tree distance; no new means needed for the structural tier. Cross-refs: `E-PANCAKES-IS-RADIX-IS-HHTL` (radix subtree = basin), `E-COARSE-QUANTIZER-IS-SCALE-FREE-ROUTER` (basin-node = IVF coarse centroid = parent SoA), `E-CLAM-IS-THE-MANIFOLD-ENGINE` (CHAODA = unary anomaly), `E-WHT-META-AWARENESS-AND-KRONECKER-LOOKUP` (pyramid energy = the field summary), `E-GUID-IS-THE-GRAPH`, canon node 512 B, `perturbation-sim::{sketch::walsh_pyramid_energy, chaoda}`, OGAR "256×256 centroid tile" + "perturbation = (exponent, location, phase, magnitude)".
+## 2026-06-19 — E-OGAR-AR-SHAPE-SMOKE-4 — five more OSB↔Odoo synergies land on real corpora: TaxPolicy / CommercialDocument / BillingParty / CurrencyPolicy / PaymentRecord (lexical class-shape on OGIT-declared types); CanonicalConcept enum at 6 variants
+
+**Status:** FINDING (operator-directed "continue with opensource-billing <> odoo", 2026-06-19; 19/19 ar_shape tests green including 5 new sibling-concept corpus-driven tests). Extends `E-OGAR-AR-SHAPE-SMOKE-3` (OGIT canonical + codebooks) with five more harvest-proven `CanonicalConcept` variants per the operator's named smoke targets.
+
+**What landed:**
+
+- `CanonicalConcept` enum extended from 1 → 6 variants. Each new variant — `CommercialDocument`, `TaxPolicy`, `BillingParty`, `PaymentRecord`, `CurrencyPolicy` — corresponds to an operator-named concept from the smoke pass spec, and each is gated by ≥2-curator evidence on the real corpora (the OSB harvest fixture + the workspace Odoo manifest), not pre-emptively added.
+- Shared `declared_classes(triples, ns) -> BTreeSet<String>` helper returns class IRIs that surface as `(class, rdf:type, ogit:ObjectType)` — filters out method / field IRIs.
+- 5 sibling lexical-shape detectors built on the helper:
+  - `classes_matching_commercial_document_shape_canonical` — lowercase ends with `invoice`/`move`/`order` AND does NOT contain `line` (the line filter discriminates `InvoiceLineItem` / `account_move_line` from documents). Surfaces `Invoice` (OSB) + `account_move` (Odoo).
+  - `classes_matching_tax_policy_shape_canonical` — lowercase ends with `tax`. Surfaces `Tax` + `account_tax`. Filters out `TaxGroup` / `account_tax_group` (lowercased neither ends with `tax`).
+  - `classes_matching_billing_party_shape_canonical` — lowercase ends with `client`/`customer`/`partner`. Surfaces `Client` + `res_partner`.
+  - `classes_matching_currency_policy_shape_canonical` — lowercase ends with `currency`. Surfaces `Currency` + `res_currency`.
+  - `classes_matching_payment_record_shape_canonical` — lowercase ends with `payment`. Surfaces `Payment` + `account_payment` (also `CreditPayment` as expected sub-type; downstream ranking picks the primary).
+- 5 corpus-driven tests with names matching the operator's convention (e.g. `open_source_billing_tax_and_odoo_tax_overlap_as_tax_policy`). Each loads the OSB ndjson fixture (`tests/fixtures/osb_ruby_spo.ndjson`, 1195 triples) + the workspace Odoo manifest (`crates/lance-graph/src/graph/spo/odoo_ontology.spo.ndjson`, 2.8 MB) and asserts the expected class IRI appears on each side.
+
+**Scope discipline (carried).** Lexical class-shape is the minimal viable detector. Structural-shape refinement (incoming OGIT canonical relations FROM line-items for TaxPolicy; outgoing has_many to line-items for CommercialDocument; etc.) is the natural follow-up. Each concept promotion is one named test on real data, not a class hierarchy hand-built up-front. The `CanonicalConcept` enum still doesn't include SalesOrder / SalesOrderLine / ProductOffering / FulfillmentFlow / InventoryMovement / ProjectWorkItem / BillableWorkEntry — those land when ≥2-curator evidence appears (operator smoke target B needs a Spree harvest; smoke target C needs Project::TimeEntry + materialization rules).
+
+**Cross-repo alignment with `AdaWorldAPI/OGAR#61`.** The merged `OGAR#61` introduced the `const CODEBOOK: &[(&str, u16)]` registry minting stable `u16` ClassIds for promoted canonical concepts (today: `project`, `project_work_item`, `billable_work_entry`). The ar_shape `CanonicalConcept` enum is the UPSTREAM candidate set — concepts get promoted into OGAR's CODEBOOK once they've cleared the ≥2-curator gate AND the OGAR-side review. Each `CanonicalConcept::CommercialLineItem`/`CommercialDocument`/`TaxPolicy`/`BillingParty`/`PaymentRecord`/`CurrencyPolicy` is a candidate row for a future OGAR CODEBOOK assignment.
+
+**Cross-refs:** `crates/lance-graph-ontology/src/ar_shape.rs` (5 new detectors + `declared_classes` helper + 5 new tests; 19/19 green); `E-OGAR-AR-SHAPE-SMOKE-3` (OGIT canonical predecessor); `E-OGAR-AR-SHAPE-SMOKE-2` (predicate-vocabulary divergence finding); `E-OGAR-AR-SHAPE-SMOKE-1` (hand-fixture predecessor); `AdaWorldAPI/OGAR#61` (the upstream u16 CODEBOOK registry; each ar_shape canonical concept is a candidate for promotion into it).
+
+---
+
 ## 2026-06-19 — E-OGAR-AR-SHAPE-SMOKE-3 — OGIT is the canonical predicate vocabulary; OGAR consumes canonical via per-extractor codebooks; `translate_rails_to_ogit` + `translate_odoo_to_ogit` fold curator vocabularies into `ogit:includes/isMemberOf/contains/isPartOf`
 
 **Status:** FINDING (operator-directed clarification, 2026-06-19; 14/14 ar_shape tests green including 4 new OGIT-canonical ones). **Closes the predicate-vocabulary divergence from `E-OGAR-AR-SHAPE-SMOKE-2`** by naming what the convergence target IS, not just describing the divergence.
diff --git a/crates/lance-graph-ontology/src/ar_shape.rs b/crates/lance-graph-ontology/src/ar_shape.rs
@@ -121,6 +121,24 @@ pub enum CanonicalConcept {
     /// Promoted from `{ osb:InvoiceLineItem, odoo:account.move.line }`
     /// pair on 2026-06-19.
     CommercialLineItem,
+    /// `CommercialDocument` — the parent commercial document (invoice,
+    /// journal entry, sales order). Promoted from
+    /// `{ osb:Invoice, odoo:account.move }` on 2026-06-19.
+    CommercialDocument,
+    /// `TaxPolicy` — a named, rate-bearing tax binding. Promoted from
+    /// `{ osb:Tax, odoo:account.tax }` on 2026-06-19.
+    TaxPolicy,
+    /// `BillingParty` — a counterparty (customer / supplier / partner).
+    /// Promoted from `{ osb:Client, odoo:res.partner }` on 2026-06-19.
+    BillingParty,
+    /// `PaymentRecord` — an amount-bearing event tied to a commercial
+    /// document. Promoted from `{ osb:Payment, odoo:account.payment }`
+    /// on 2026-06-19.
+    PaymentRecord,
+    /// `CurrencyPolicy` — a named currency carrying a code (ISO 4217)
+    /// and a label. Promoted from `{ osb:Currency, odoo:res.currency }`
+    /// on 2026-06-19.
+    CurrencyPolicy,
 }
 
 /// A typed fixture for one curator's class declaration. Hand-built today;
@@ -467,6 +485,132 @@ pub fn classes_matching_commercial_line_item_shape_canonical(
     has_doc_assoc.intersection(&has_tax_assoc).cloned().collect()
 }
 
+// ─── Sibling concept detectors (lexical class-name shape on declared OGIT
+// ObjectTypes) ─────────────────────────────────────────────────────────
+//
+// Each of the five sibling detectors below answers "which classes in
+// this corpus are shaped like <CanonicalConcept>?" by combining two
+// signals:
+//
+// 1. The class must be DECLARED — surfaces as the subject of an
+//    `(s, rdf:type, ogit:ObjectType)` triple. This filters out method /
+//    field IRIs (e.g. `Foo.bar`) and unrelated namespaces.
+// 2. The class IRI matches a concept-specific lexical hint
+//    (e.g. ends_with `"tax"` for TaxPolicy). Hints converge across
+//    Rails (PascalCase: `Tax`, `Invoice`, `Client`, `Currency`,
+//    `Payment`) and Odoo (snake_case underscored: `account_tax`,
+//    `account_move`, `res_partner`, `res_currency`, `account_payment`)
+//    because both serialize the canonical concept name in the class
+//    leaf.
+//
+// Structural-shape refinement (incoming/outgoing OGIT canonical
+// relations) is the natural follow-up — today's lexical shape is the
+// minimal viable detector that lets the ≥2-curator promotion rule fire
+// per concept. Each promotion is gated by a dedicated test on the real
+// OSB + Odoo corpora.
+
+/// Return the set of class IRIs declared as `rdf:type ogit:ObjectType`
+/// in this triple set, with `namespace_prefix` stripped. Filters out
+/// non-class subjects (anything containing `.`).
+#[must_use]
+pub fn declared_classes(
+    triples: &[Triple],
+    namespace_prefix: &str,
+) -> std::collections::BTreeSet<String> {
+    triples
+        .iter()
+        .filter(|t| t.p == "rdf:type" && t.o == "ogit:ObjectType")
+        .filter_map(|t| t.s.strip_prefix(namespace_prefix).map(String::from))
+        .filter(|c| !c.contains('.'))
+        .collect()
+}
+
+/// Find class IRIs in a triple set shaped like a `CommercialDocument`
+/// (the parent of line items): class-IRI's lowercased form ends with
+/// `"invoice"` (`osb:Invoice`), `"move"` (`odoo:account_move`), or
+/// `"order"` (`odoo:sale_order`), and the IRI does NOT contain `"line"`
+/// (to filter out `InvoiceLineItem` / `account_move_line` which are
+/// CommercialLineItem candidates, not document candidates).
+#[must_use]
+pub fn classes_matching_commercial_document_shape_canonical(
+    triples: &[Triple],
+    namespace_prefix: &str,
+) -> Vec<String> {
+    declared_classes(triples, namespace_prefix)
+        .into_iter()
+        .filter(|c| {
+            let lower = c.to_lowercase();
+            if lower.contains("line") {
+                return false;
+            }
+            lower.ends_with("invoice")
+                || lower.ends_with("move")
+                || lower.ends_with("order")
+        })
+        .collect()
+}
+
+/// Find class IRIs shaped like a `TaxPolicy`: class IRI's lowercased
+/// form ends with `"tax"`. Catches `osb:Tax` and `odoo:account_tax`;
+/// excludes `TaxGroup` / `account_tax_group` (lowercased `"taxgroup"`,
+/// `"account_tax_group"` — neither ends with `"tax"`).
+#[must_use]
+pub fn classes_matching_tax_policy_shape_canonical(
+    triples: &[Triple],
+    namespace_prefix: &str,
+) -> Vec<String> {
+    declared_classes(triples, namespace_prefix)
+        .into_iter()
+        .filter(|c| c.to_lowercase().ends_with("tax"))
+        .collect()
+}
+
+/// Find class IRIs shaped like a `BillingParty`: lowercased ends with
+/// `"client"`, `"customer"`, or `"partner"`. Catches `osb:Client` and
+/// `odoo:res_partner`.
+#[must_use]
+pub fn classes_matching_billing_party_shape_canonical(
+    triples: &[Triple],
+    namespace_prefix: &str,
+) -> Vec<String> {
+    declared_classes(triples, namespace_prefix)
+        .into_iter()
+        .filter(|c| {
+            let lower = c.to_lowercase();
+            lower.ends_with("client") || lower.ends_with("customer") || lower.ends_with("partner")
+        })
+        .collect()
+}
+
+/// Find class IRIs shaped like a `CurrencyPolicy`: lowercased ends with
+/// `"currency"`. Catches `osb:Currency` and `odoo:res_currency`.
+#[must_use]
+pub fn classes_matching_currency_policy_shape_canonical(
+    triples: &[Triple],
+    namespace_prefix: &str,
+) -> Vec<String> {
+    declared_classes(triples, namespace_prefix)
+        .into_iter()
+        .filter(|c| c.to_lowercase().ends_with("currency"))
+        .collect()
+}
+
+/// Find class IRIs shaped like a `PaymentRecord`: lowercased ends with
+/// `"payment"`. Catches `osb:Payment` and `odoo:account_payment`. Also
+/// catches `osb:CreditPayment` (a sub-type) — that's expected; the
+/// detector returns multiple candidates and downstream ranking picks
+/// the primary one.
+#[must_use]
+pub fn classes_matching_payment_record_shape_canonical(
+    triples: &[Triple],
+    namespace_prefix: &str,
+) -> Vec<String> {
+    declared_classes(triples, namespace_prefix)
+        .into_iter()
+        .filter(|c| c.to_lowercase().ends_with("payment"))
+        .collect()
+}
+
 // ─── Triple-based detection on real ruff-harvested corpora ──────────────
 //
 // The hand-fixture path above remains as the structural CLAIM. The Triple
@@ -1000,6 +1144,135 @@ mod tests {
         );
     }
 
+    // ─── Five sibling-concept corpus-driven tests ───────────────────
+
+    /// `open_source_billing_invoice_and_odoo_account_move_overlap_as_commercial_document`
+    /// — the strongest accounting pair after CommercialLineItem.
+    #[test]
+    fn open_source_billing_invoice_and_odoo_account_move_overlap_as_commercial_document() {
+        let osb_bytes = include_bytes!("../tests/fixtures/osb_ruby_spo.ndjson");
+        let odoo_bytes = include_bytes!(
+            "../../lance-graph/src/graph/spo/odoo_ontology.spo.ndjson"
+        );
+        let osb = load_triples_ndjson(osb_bytes).unwrap();
+        let odoo = load_triples_ndjson(odoo_bytes).unwrap();
+
+        let osb_c = classes_matching_commercial_document_shape_canonical(&osb, "openproject:");
+        let odoo_c = classes_matching_commercial_document_shape_canonical(&odoo, "odoo:");
+
+        assert!(
+            osb_c.iter().any(|c| c == "Invoice"),
+            "OSB candidates missing Invoice; got {osb_c:?}",
+        );
+        assert!(
+            odoo_c.iter().any(|c| c == "account_move"),
+            "Odoo candidates missing account_move; got first 5: {:?}",
+            odoo_c.iter().take(5).collect::<Vec<_>>(),
+        );
+        // CommercialLineItem candidates (Invoice*Line* / account_move_line)
+        // must NOT promote as CommercialDocument — the "line" filter
+        // discriminates them.
+        assert!(!osb_c.iter().any(|c| c == "InvoiceLineItem"));
+        assert!(!odoo_c.iter().any(|c| c == "account_move_line"));
+    }
+
+    /// `open_source_billing_tax_and_odoo_tax_overlap_as_tax_policy` —
+    /// the operator's named second smoke test.
+    #[test]
+    fn open_source_billing_tax_and_odoo_tax_overlap_as_tax_policy() {
+        let osb_bytes = include_bytes!("../tests/fixtures/osb_ruby_spo.ndjson");
+        let odoo_bytes = include_bytes!(
+            "../../lance-graph/src/graph/spo/odoo_ontology.spo.ndjson"
+        );
+        let osb = load_triples_ndjson(osb_bytes).unwrap();
+        let odoo = load_triples_ndjson(odoo_bytes).unwrap();
+
+        let osb_c = classes_matching_tax_policy_shape_canonical(&osb, "openproject:");
+        let odoo_c = classes_matching_tax_policy_shape_canonical(&odoo, "odoo:");
+
+        assert!(
+            osb_c.iter().any(|c| c == "Tax"),
+            "OSB candidates missing Tax; got {osb_c:?}",
+        );
+        assert!(
+            odoo_c.iter().any(|c| c == "account_tax"),
+            "Odoo candidates missing account_tax; got first 5: {:?}",
+            odoo_c.iter().take(5).collect::<Vec<_>>(),
+        );
+    }
+
+    /// `open_source_billing_client_and_odoo_res_partner_overlap_as_billing_party`.
+    #[test]
+    fn open_source_billing_client_and_odoo_res_partner_overlap_as_billing_party() {
+        let osb_bytes = include_bytes!("../tests/fixtures/osb_ruby_spo.ndjson");
+        let odoo_bytes = include_bytes!(
+            "../../lance-graph/src/graph/spo/odoo_ontology.spo.ndjson"
+        );
+        let osb = load_triples_ndjson(osb_bytes).unwrap();
+        let odoo = load_triples_ndjson(odoo_bytes).unwrap();
+
+        let osb_c = classes_matching_billing_party_shape_canonical(&osb, "openproject:");
+        let odoo_c = classes_matching_billing_party_shape_canonical(&odoo, "odoo:");
+
+        assert!(
+            osb_c.iter().any(|c| c == "Client"),
+            "OSB candidates missing Client; got {osb_c:?}",
+        );
+        assert!(
+            odoo_c.iter().any(|c| c == "res_partner"),
+            "Odoo candidates missing res_partner; got first 5: {:?}",
+            odoo_c.iter().take(5).collect::<Vec<_>>(),
+        );
+    }
+
+    /// `open_source_billing_currency_and_odoo_res_currency_overlap_as_currency_policy`.
+    #[test]
+    fn open_source_billing_currency_and_odoo_res_currency_overlap_as_currency_policy() {
+        let osb_bytes = include_bytes!("../tests/fixtures/osb_ruby_spo.ndjson");
+        let odoo_bytes = include_bytes!(
+            "../../lance-graph/src/graph/spo/odoo_ontology.spo.ndjson"
+        );
+        let osb = load_triples_ndjson(osb_bytes).unwrap();
+        let odoo = load_triples_ndjson(odoo_bytes).unwrap();
+
+        let osb_c = classes_matching_currency_policy_shape_canonical(&osb, "openproject:");
+        let odoo_c = classes_matching_currency_policy_shape_canonical(&odoo, "odoo:");
+
+        assert!(
+            osb_c.iter().any(|c| c == "Currency"),
+            "OSB candidates missing Currency; got {osb_c:?}",
+        );
+        assert!(
+            odoo_c.iter().any(|c| c == "res_currency"),
+            "Odoo candidates missing res_currency; got first 5: {:?}",
+            odoo_c.iter().take(5).collect::<Vec<_>>(),
+        );
+    }
+
+    /// `open_source_billing_payment_and_odoo_account_payment_overlap_as_payment_record`.
+    #[test]
+    fn open_source_billing_payment_and_odoo_account_payment_overlap_as_payment_record() {
+        let osb_bytes = include_bytes!("../tests/fixtures/osb_ruby_spo.ndjson");
+        let odoo_bytes = include_bytes!(
+            "../../lance-graph/src/graph/spo/odoo_ontology.spo.ndjson"
+        );
+        let osb = load_triples_ndjson(osb_bytes).unwrap();
+        let odoo = load_triples_ndjson(odoo_bytes).unwrap();
+
+        let osb_c = classes_matching_payment_record_shape_canonical(&osb, "openproject:");
+        let odoo_c = classes_matching_payment_record_shape_canonical(&odoo, "odoo:");
+
+        assert!(
+            osb_c.iter().any(|c| c == "Payment"),
+            "OSB candidates missing Payment; got {osb_c:?}",
+        );
+        assert!(
+            odoo_c.iter().any(|c| c == "account_payment"),
+            "Odoo candidates missing account_payment; got first 5: {:?}",
+            odoo_c.iter().take(5).collect::<Vec<_>>(),
+        );
+    }
+
     /// Hand-fixture detection (the `overlap_commercial_line_item` path
     /// committed in the prior smoke) and the harvest detection
     /// (`classes_matching_commercial_line_item_shape`) must agree on
