chore(submodules): pin ontology-management-base to gx 2.2.1 + range-inference fix (#144)

* chore(submodules): pin ontology-management-base to gx 2.2.1 + range-inference fix

Advances the OMB pin over its PR #83 squash: gx artifacts refreshed to
service-characteristics v2.2.1 (adds gx:ComplianceCredential; removes
gx:ServiceEntity, gx:spiffeId, gx:trustDomain, gx:operatedBy) and the
upstream validators' rdfs:range entailment now covers blank-node
objects.

Full validate ran green against these artifacts (11 typecheck + 19
test tasks): schema graph loads, the term index builds with the new gx
term set, retrieval/fragment/reference suites pass, prompt-size bounds
hold. Nothing here referenced the removed gx terms — the retrieval
surface is discovery-driven by design.

Signed-off-by: jdsika <carlo.van-driesten@vdl.digital>

* fix(ontology,llm): adapt discovery, validation, and prompt bounds to the OMB refresh

The OMB pin (eb49b92 -> 0dc1a42) advances 32 upstream commits, restructuring the
artifacts well beyond the gx 2.2.1 bump: ISO-34503 ODD hierarchy, openlabel-v2
v1-v2 gap closure, and hdmap constraint reshaping. Three downstream assumptions
broke -- two surfaced in CI; the third (llm) was masked because turbo cancels
siblings once the ontology task fails first.

- domain-registry mis-selected openlabel-v2's primary asset class. The new ISO
  34503 ODD annotation shapes (OddDynamicElements, OddEnvironment, OddScenery)
  are declared AHEAD of Scenario, and "first-declared non-sub-component" is
  order-fragile. Select the composition ROOT instead -- the target class whose
  shape references the most other target classes -- an order-independent,
  ontology-name-free signal (computeCompositionScores). Scenario composes five
  sub-shapes; the standalone ODD shapes compose zero. [SHACL 2.3]

- shacl-validator sh:in happy path. hdmap roadTypes' enum moved onto the
  version-conditional SEQUENCE path ( hasContent roadTypes ); sequence/inverse
  paths are intentionally out of scope for bare-value slot validation, so the
  enum test is re-pinned to hdmap:trafficDirection (a simple-path sh:in still in
  the validator's remit).

- prompt-composer boundedness. Enlarged shapes plus new cross-domain references
  lift the retrieved tail ~3x (~61k chars, still an order of magnitude under a
  ~300k whole-file dump). Raise the calibration thresholds; boundedness -- not a
  specific size -- stays pinned.

Adds submodule-independent regression tests for composition-root selection.
Full `pnpm run validate` green on the new pin (19 tasks).

Signed-off-by: Carlo van Driesten <carlo.van-driesten@bmw.de>

---------

Signed-off-by: jdsika <carlo.van-driesten@vdl.digital>
Signed-off-by: Carlo van Driesten <carlo.van-driesten@bmw.de>

Author: jdsika

packages/llm/src/__tests__/prompt-composer.test.ts

@@ -121,12 +121,16 @@ describe('buildRequestPrompt (integration)', () => {
 
     const core = buildStaticCore()
     expect(prompt.startsWith(core)).toBe(true)
-    // Measured on the shipped 22-domain ontology: tail ≈ 21k chars (default
-    // budgets: 40 property fragments + full catalog), total ≈ 40k. The
-    // thresholds carry headroom over the measurement so an ontology edit
-    // doesn't flake the suite; boundedness is what's pinned.
-    expect(tail.length).toBeLessThan(30_000)
-    expect(prompt.length).toBeLessThan(50_000)
+    // Measured on the pinned OMB ontology: this card-derived query routes to
+    // `environment-model` plus its transitive references (`hdmap`, `ositrace`),
+    // ~69 fragments, tail ≈ 61k / total ≈ 80k. The service-characteristics /
+    // ISO-34503 refresh enlarged individual shapes and added cross-domain
+    // references, so the tail is ~3× the pre-refresh measurement — still an
+    // order of magnitude under a whole-file SHACL dump (~300k). The thresholds
+    // keep headroom over the measurement so a further ontology edit doesn't
+    // flake the suite; BOUNDEDNESS (not a specific size) is what's pinned.
+    expect(tail.length).toBeLessThan(80_000)
+    expect(prompt.length).toBeLessThan(100_000)
     expect(retrieved.confidence).toBeGreaterThan(0)
     expect(retrieved.domains).toContain(card!.domain)
   })

packages/ontology/src/__tests__/domain-registry-parse.test.ts

@@ -16,7 +16,15 @@
  */
 import { describe, expect, it } from 'vitest'
 
-import { extractNamespace, extractTargetClasses, parseTtl } from '../domain-registry-parse.js'
+import {
+  computeCompositionScores,
+  extractCompositionAdjacency,
+  extractNamespace,
+  extractShapeTargets,
+  extractTargetClasses,
+  parseTtl,
+  selectPrimaryAssetClass,
+} from '../domain-registry-parse.js'
 
 const NS = 'http://example.org/v1/'
 
@@ -105,3 +113,62 @@ scenario:X a sh:NodeShape ; sh:targetClass scenario:X .`
     expect(extractNamespace(parseTtl(ttl), 'nomatch')).toBeNull()
   })
 })
+
+/**
+ * Regression: a domain's primary asset class must be its composition ROOT (the
+ * shape aggregating the domain's sub-shapes), NOT merely the first-declared
+ * target class. This defends against SHACL declaration-order changes upstream —
+ * e.g. ISO-34503 ODD annotation shapes (`OddDynamicElements`, …) that
+ * `openlabel-v2` now declares AHEAD of `Scenario`. Before composition scoring,
+ * `selectPrimaryAssetClass` returned the first-declared `Leaf` here; it must now
+ * return `Root`, which references `Leaf` and thus scores higher.
+ */
+describe('domain-registry-parse — composition-root primary selection', () => {
+  // `Leaf` is declared first but composes nothing; `Root` is declared second and
+  // references `Leaf` via a property shape (sh:node). Neither is a sub-component.
+  const ttl = `@prefix sh: <http://www.w3.org/ns/shacl#> .
+@prefix ex: <${NS}> .
+
+ex:Leaf a sh:NodeShape ; sh:targetClass ex:Leaf ;
+  sh:property [ sh:path ex:label ; sh:minCount 1 ] .
+
+ex:Root a sh:NodeShape ; sh:targetClass ex:Root ;
+  sh:property [ sh:path ex:hasLeaf ; sh:node ex:Leaf ] .`
+
+  function scoresFor(parsed: ReturnType<typeof parseTtl>) {
+    const targets = extractTargetClasses(parsed, NS)
+    return computeCompositionScores(
+      extractCompositionAdjacency(parsed.quads),
+      extractShapeTargets(parsed.quads),
+      new Set(targets.map((t) => t.iri))
+    )
+  }
+
+  it('scores the aggregating shape above the leaf it composes', () => {
+    const scores = scoresFor(parseTtl(ttl))
+    expect(scores.get(`${NS}Root`)).toBe(1)
+    expect(scores.get(`${NS}Leaf`) ?? 0).toBe(0)
+  })
+
+  it('selects the composition root even though the leaf is declared first', () => {
+    const parsed = parseTtl(ttl)
+    const targets = extractTargetClasses(parsed, NS)
+    expect(targets.map((t) => t.localName)).toEqual(['Leaf', 'Root'])
+
+    const primary = selectPrimaryAssetClass(
+      targets,
+      'somedomain',
+      new Set(),
+      new Map(),
+      scoresFor(parsed)
+    )
+    expect(primary?.localName).toBe('Root')
+  })
+
+  it('without scores, falls back to first-declared (documents prior behavior)', () => {
+    const parsed = parseTtl(ttl)
+    const targets = extractTargetClasses(parsed, NS)
+    const primary = selectPrimaryAssetClass(targets, 'somedomain', new Set(), new Map())
+    expect(primary?.localName).toBe('Leaf')
+  })
+})

packages/ontology/src/__tests__/shacl-validator.test.ts

@@ -18,6 +18,13 @@ import { ShaclValidator } from '../shacl-validator.js'
 
 const GEOREF_COUNTRY = 'https://w3id.org/ascs-ev/envited-x/georeference/v5/country'
 const HDMAP_ROAD_TYPES = 'https://w3id.org/ascs-ev/envited-x/hdmap/v6/roadTypes'
+// A simple-path `sh:in` enum ("left-hand"/"right-hand"). `roadTypes` also has an
+// `sh:in`, but upstream now expresses it on the version-conditional SEQUENCE path
+// `( hdmap:hasContent hdmap:roadTypes )`; sequence/inverse paths are deliberately
+// out of scope for bare-value slot validation (see shacl-validator-loader.ts),
+// so the enum happy-path is pinned to a property still constrained on a simple
+// path — the validator capability under test.
+const HDMAP_TRAFFIC_DIRECTION = 'https://w3id.org/ascs-ev/envited-x/hdmap/v6/trafficDirection'
 
 describe('ShaclValidator', () => {
   it('builds from the workspace ontology and exposes covered properties', async () => {
@@ -52,7 +59,7 @@ describe('ShaclValidator', () => {
 
   it('rejects a value outside an sh:in enumeration', async () => {
     const validator = await ShaclValidator.fromWorkspace()
-    const result = await validator.validateValue(HDMAP_ROAD_TYPES, 'spaceway')
+    const result = await validator.validateValue(HDMAP_TRAFFIC_DIRECTION, 'diagonal')
 
     expect(result.conforms).toBe(false)
     const constraints = result.violations.map((v) => v.sourceConstraintComponent)
@@ -61,7 +68,7 @@ describe('ShaclValidator', () => {
 
   it('accepts a value inside an sh:in enumeration', async () => {
     const validator = await ShaclValidator.fromWorkspace()
-    const result = await validator.validateValue(HDMAP_ROAD_TYPES, 'motorway')
+    const result = await validator.validateValue(HDMAP_TRAFFIC_DIRECTION, 'left-hand')
 
     expect(result.conforms).toBe(true)
     expect(result.violations).toEqual([])

packages/ontology/src/domain-registry-parse.ts

@@ -21,6 +21,27 @@ const OWL_ONTOLOGY = `${RDF_PREFIXES.owl}Ontology`
 const RDFS_SUBCLASS_OF = `${RDF_PREFIXES.rdfs}subClassOf`
 const SH_TARGET_CLASS = `${RDF_PREFIXES.sh}targetClass`
 
+// Composition-graph predicates: a NodeShape "composes" the shapes and classes
+// it references through its property shapes. Following these edges — the direct
+// structural links (sh:property, sh:node, sh:class, sh:qualifiedValueShape), the
+// logical combinators (sh:and/sh:or/sh:xone/sh:not), and the rdf:first/rdf:rest
+// list plumbing those combinators use — reconstructs which shapes nest which
+// [SHACL §2.3]. Used to pick a domain's primary asset class as the composition
+// ROOT (the shape aggregating the domain's sub-shapes) rather than by SHACL
+// declaration order.
+const COMPOSITION_PREDICATES: ReadonlySet<string> = new Set([
+  `${RDF_PREFIXES.sh}property`,
+  `${RDF_PREFIXES.sh}node`,
+  `${RDF_PREFIXES.sh}class`,
+  `${RDF_PREFIXES.sh}qualifiedValueShape`,
+  `${RDF_PREFIXES.sh}and`,
+  `${RDF_PREFIXES.sh}or`,
+  `${RDF_PREFIXES.sh}xone`,
+  `${RDF_PREFIXES.sh}not`,
+  `${RDF_PREFIXES.rdf}first`,
+  `${RDF_PREFIXES.rdf}rest`,
+])
+
 /** A parsed Turtle document: resolved quads plus its declared prefix map. */
 export interface ParsedTtl {
   quads: Quad[]
@@ -255,22 +276,114 @@ export function computeComponentBases(
   return bases
 }
 
+/**
+ * Build the composition adjacency for a set of quads: subject term value →
+ * object term values, for every edge whose predicate continues a
+ * shape-composition traversal ({@link COMPOSITION_PREDICATES}). Blank-node
+ * identifiers are kept so nested property shapes and `sh:or`/`sh:xone`
+ * alternative lists are walked; the caller resolves reached nodes back to
+ * target classes [SHACL §2.3].
+ */
+export function extractCompositionAdjacency(quads: Quad[]): Map<string, string[]> {
+  const adjacency = new Map<string, string[]>()
+  for (const q of quads) {
+    if (!COMPOSITION_PREDICATES.has(q.predicate.value)) continue
+    const list = adjacency.get(q.subject.value)
+    if (list) list.push(q.object.value)
+    else adjacency.set(q.subject.value, [q.object.value])
+  }
+  return adjacency
+}
+
+/**
+ * Map every shape subject to the target class(es) it declares via
+ * `sh:targetClass` [SHACL §2.1.3.3]. A shape may target several classes and a
+ * class may be targeted by several shapes, so values are arrays. Lets a
+ * composition-reachable shape node be resolved back to the asset class(es) it
+ * stands for.
+ */
+export function extractShapeTargets(quads: Quad[]): Map<string, string[]> {
+  const map = new Map<string, string[]>()
+  for (const q of quads) {
+    if (q.predicate.value !== SH_TARGET_CLASS || q.object.termType !== 'NamedNode') continue
+    const list = map.get(q.subject.value)
+    if (list) list.push(q.object.value)
+    else map.set(q.subject.value, [q.object.value])
+  }
+  return map
+}
+
+/**
+ * Score each target class by how many OTHER target classes its shape composes
+ * (references transitively through the composition graph). A domain's primary
+ * asset is the composition ROOT — the shape that aggregates the domain's
+ * sub-shapes — which scores highest; standalone leaf/annotation shapes score
+ * zero. This makes primary-asset selection independent of SHACL declaration
+ * order (a shape reordered or newly inserted upstream cannot displace the
+ * asset). Pure over its inputs (adjacency + shape→target map + the set of all
+ * target-class IRIs), so it is unit-testable without I/O.
+ */
+export function computeCompositionScores(
+  adjacency: Map<string, string[]>,
+  shapeTargets: Map<string, string[]>,
+  targetClassIris: ReadonlySet<string>
+): Map<string, number> {
+  const reachedByTarget = new Map<string, Set<string>>()
+
+  for (const [subject, targets] of shapeTargets) {
+    // Depth-first walk of the composition graph from this shape subject,
+    // collecting reachable target classes — either a target-class IRI reached
+    // directly (sh:class) or a shape node that itself declares a target class
+    // (sh:node / sh:qualifiedValueShape). A path-agnostic `seen` set bounds the
+    // walk on cyclic shape graphs.
+    const reached = new Set<string>()
+    const seen = new Set<string>([subject])
+    const stack = [...(adjacency.get(subject) ?? [])]
+    while (stack.length) {
+      const node = stack.pop()!
+      if (seen.has(node)) continue
+      seen.add(node)
+      if (targetClassIris.has(node)) reached.add(node)
+      for (const t of shapeTargets.get(node) ?? []) reached.add(t)
+      for (const next of adjacency.get(node) ?? []) stack.push(next)
+    }
+    for (const target of targets) {
+      const set = reachedByTarget.get(target) ?? new Set<string>()
+      for (const r of reached) if (r !== target) set.add(r)
+      reachedByTarget.set(target, set)
+    }
+  }
+
+  const scores = new Map<string, number>()
+  for (const [target, set] of reachedByTarget) scores.set(target, set.size)
+  return scores
+}
+
 /**
  * Select a domain's primary asset class. PascalCase-of-domain match wins
- * first, otherwise the first declared target class that is not a sub-component
- * — with "sub-component" derived structurally from
+ * first, otherwise the non-sub-component target class that composes the most
+ * of the domain's other shapes — with "sub-component" derived structurally from
  * {@link computeComponentBases} instead of a hard-coded name list. A class is
  * a sub-component when it is, or transitively subclasses, a component-base; an
  * asset class (e.g. `<prefix>:<Class>`) subclasses an asset base instead, so
- * it survives the filter even when not named after its domain. `targetClasses`
- * keeps its SHACL declaration order so the
- * first-non-sub-component fallback is deterministic and matches prior behavior.
+ * it survives the filter even when not named after its domain.
+ *
+ * Among the surviving candidates the composition ROOT wins: the class whose
+ * shape references the most other target classes ({@link computeCompositionScores}),
+ * i.e. the top of the domain's containment tree. This is order-independent — a
+ * standalone annotation shape declared before the asset (as upstream ISO-34503
+ * ODD shapes now are, ahead of `Scenario`) cannot displace it. `targetClasses`
+ * keeps its SHACL declaration order, so ties — including the all-zero case where
+ * no candidate composes another target class — fall back to the first-declared
+ * candidate, matching prior behavior. When no scores are supplied the selection
+ * is exactly the previous first-non-sub-component rule.
  */
 export function selectPrimaryAssetClass(
   targetClasses: { localName: string; iri: string }[],
   domainName: string,
   componentBases: Set<string>,
-  superOf: Map<string, Set<string>>
+  superOf: Map<string, Set<string>>,
+  compositionScore?: ReadonlyMap<string, number>
 ): { localName: string; iri: string } | null {
   if (targetClasses.length === 0) return null
 
@@ -293,6 +406,21 @@ export function selectPrimaryAssetClass(
   const exact = targetClasses.find((tc) => tc.localName === domainPascalCase(domainName))
   if (exact) return exact
 
-  // Otherwise the first declared non-sub-component target class.
-  return targetClasses.find((tc) => !isSubComponent(tc.iri)) ?? targetClasses[0] ?? null
+  // Otherwise the composition root among non-sub-components (falling back to all
+  // target classes if every candidate is a sub-component). Iterating in SHACL
+  // declaration order and replacing only on a STRICTLY higher score keeps the
+  // first-declared winner on ties and when no scores disambiguate.
+  const candidates = targetClasses.filter((tc) => !isSubComponent(tc.iri))
+  const pool = candidates.length > 0 ? candidates : targetClasses
+  let best = pool[0]!
+  let bestScore = compositionScore?.get(best.iri) ?? 0
+  for (let i = 1; i < pool.length; i++) {
+    const tc = pool[i]!
+    const score = compositionScore?.get(tc.iri) ?? 0
+    if (score > bestScore) {
+      best = tc
+      bestScore = score
+    }
+  }
+  return best
 }

packages/ontology/src/domain-registry.ts

@@ -13,12 +13,16 @@
  */
 import { OntologySourcesError } from '@ontology-search/core/errors'
 import { RDF_PREFIXES } from '@ontology-search/core/rdf/prefixes'
+import type { Quad } from '@rdfjs/types'
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
 import { join } from 'path'
 
 import {
   computeComponentBases,
+  computeCompositionScores,
+  extractCompositionAdjacency,
   extractNamespace,
+  extractShapeTargets,
   extractSubClassOfEdges,
   extractTargetClasses,
   extractVersion,
@@ -119,6 +123,8 @@ export async function buildDomainRegistry(): Promise<DomainRegistry> {
     filePrefixes: Record<string, string>
     targetClasses: { localName: string; iri: string }[]
     subClassEdges: { sub: string; super: string }[]
+    /** Parsed SHACL quads — retained so pass 2 can score composition roots. */
+    shaclQuads: Quad[]
   }
   const raw: RawDomain[] = []
 
@@ -194,6 +200,7 @@ export async function buildDomainRegistry(): Promise<DomainRegistry> {
         filePrefixes,
         targetClasses,
         subClassEdges,
+        shaclQuads: shacl.quads,
       })
     }
   }
@@ -211,8 +218,26 @@ export async function buildDomainRegistry(): Promise<DomainRegistry> {
   }
   const componentBases = computeComponentBases(allEdges, targetClassDomain)
 
+  // Composition scores are global (an asset may reference another domain's
+  // shapes) and structural — derived from the whole shapes graph, independent of
+  // per-file declaration order. `selectPrimaryAssetClass` uses them to prefer a
+  // domain's composition root over a standalone shape that merely happens to be
+  // declared first.
+  const allShaclQuads = raw.flatMap((d) => d.shaclQuads)
+  const compositionScore = computeCompositionScores(
+    extractCompositionAdjacency(allShaclQuads),
+    extractShapeTargets(allShaclQuads),
+    new Set(targetClassDomain.keys())
+  )
+
   for (const d of raw) {
-    const primaryClass = selectPrimaryAssetClass(d.targetClasses, d.entry, componentBases, superOf)
+    const primaryClass = selectPrimaryAssetClass(
+      d.targetClasses,
+      d.entry,
+      componentBases,
+      superOf,
+      compositionScore
+    )
     if (!primaryClass) continue
 
     domains.set(d.entry, {