expressir 2.4.3 → 2.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b0fe8cde3b24a7a4ce39599fa68b61b02d3f8af45c1a8f5e45ce2607a213922
-  data.tar.gz: 869991a150512a7b12fb94f18f97e66bc6954317c311f630b3fac41d55d001b0
+  metadata.gz: faa2eff1343ffba0a34111f1b9c48f2ea65fc8585da64b15844e39cd413b067f
+  data.tar.gz: 34ad23a65dabd3806206cf741c4e19d468bad9f6c566b89c0af10c594e0ca99b
 SHA512:
-  metadata.gz: d04f62c906dc98f43a469f88ec56382decf8636407766c94b1248f94fbc21a2667144cc421a021dda592ea5d56987937ca20ea819a4300540589ea935c2767c2
-  data.tar.gz: eeaa19435f4e66921136fbe3cee4ac729f5dfd5fa4f5731cc5b88a601639518c6be3ebfa70af4d29ef8f78500e80586a50df7636a88892a03f93787d9bee2182
+  metadata.gz: 05d55fe19517184f73d6f97815be45fef28a7c8d84360ee8a83288e2d0de63671f8fd5715bd4e14c0154cc731d3531871ebeccf83a52c41d6dc1f6dc412e433f
+  data.tar.gz: fc4a6d27fde05257a4b8023ed7507caecdbbb6f79a28f32085ce17c79d1f30428bae762d70b80906f3b6e1e8a46237e7fe5a6ab2d67f407b8fc5cf0c86bf8864

data/.cargo/config.toml

@@ -0,0 +1,3 @@
+# Git deps fetch over SSH by the system git CLI (cargo HTTPS auth fails locally).
+[net]
+git-fetch-with-cli = true

data/.github/workflows/rust-ext.yml

@@ -0,0 +1,41 @@
+name: rust-ext
+
+on:
+  push:
+    branches: [master, main]
+  pull_request:
+
+jobs:
+  build-ext:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+      - name: Build the expressir-core extension
+        working-directory: ext/expressir_core
+        run: |
+          gem install rb_sys
+          ruby extconf.rb
+          RB_SYS_CARGO_PROFILE=release make
+      - name: Smoke test the bridge
+        run: |
+          bundle exec ruby -e '
+            require "expressir"
+            require "expressir/express/core"
+            raise "native unavailable" unless Expressir::Express::Core::NATIVE_AVAILABLE
+            src = File.read("spec/syntax/multiple.exp")
+            m = Expressir::Express::Core.parse_to_model_hash(src, "multiple.exp")
+            raise "bad model" unless m["schemas"].first["id"] == "multiple_schema"
+            puts "bridge OK"
+          '
+      # The default `rake` CI job covers the pure-Ruby parse path (no
+      # extension built there); this job pins the core parse path: with the
+      # extension present the parser defaults to it, so the whole suite runs
+      # against the Rust wire hydration.
+      - name: Run the suite on the core parse path
+        run: |
+          bundle exec rspec spec/expressir spec/syntax --tag ~production_scale

data/.github/workflows/verify_remarks.yml

@@ -0,0 +1,33 @@
+name: "verify_remarks"
+
+permissions:
+  contents: read
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.ref }}'
+  cancel-in-progress: true
+
+jobs:
+  remarks:
+    name: Verify remark conservation
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Ruby
+        uses: ruby/setup-ruby@master
+        with:
+          ruby-version: "3.2"
+          bundler-cache: true
+          cache-version: 0 # Increment this number if you need to re-download cached gems
+
+      - name: Verify remark conservation
+        run: bundle exec rake verify:remarks

data/.gitignore

@@ -42,3 +42,9 @@ Gemfile.local.lock
 Gemfile.original
 benchmark/
 CLAUDE.md
+
+# Rust workspace
+/target/
+Cargo.lock
+/ext/expressir_core/target/
+/ext/expressir_core/*.bundle

data/.rubocop.yml

@@ -12,3 +12,7 @@ AllCops:
   NewCops: enable
   Exclude:
     - 'vendor/**/*'
+    - 'metanorma-mirror-*/**/*'
+
+Lint/UnusedMethodArgument:
+  AllowUnusedKeywordArguments: true

data/.rubocop_todo.yml

@@ -144,6 +144,7 @@ Performance/MapMethodChain:
 RSpec/AnyInstance:
   Exclude:
     - 'spec/expressir/commands/package_edge_cases_spec.rb'
+    - 'spec/expressir/express/remark_attacher_performance_spec.rb'
 
 # Offense count: 11
 # Configuration parameters: Prefixes, AllowedPatterns.

data/Cargo.toml

@@ -0,0 +1,7 @@
+[workspace]
+resolver = "2"
+members = ["crates/expressir-core"]
+
+[workspace.package]
+edition = "2021"
+license = "MIT"

data/README.adoc

@@ -211,10 +211,13 @@ Commands:
   expressir benchmark-cache FILE_OR_YAML       # Benchmark schema loading with caching
   expressir changes SUBCOMMAND                 # Commands for EXPRESS Changes files
   expressir clean PATH                         # Strip remarks and prettify EXPRESS schema at PATH
+  expressir expand PATH                        # Concatenate the interface closure into one .exp
+  expressir flatten PATH                       # Flatten the interface closure into an ISO 10303-11:1994 longform schema
   expressir format PATH                        # pretty print EXPRESS schema located at PATH
   expressir help [COMMAND]                     # Describe available commands or one specific command
   expressir validate load *PATH                # validate EXPRESS schema located at PATH
   expressir validate ascii PATH                # Validate EXPRESS files for ASCII-only content (excluding remarks)
+  expressir validate check *PATHS              # eeng check-p11 semantic checks
   expressir coverage *PATH                     # List EXPRESS entities and check documentation coverage
   expressir version                            # Expressir Version
 ----
@@ -508,6 +511,48 @@ expressir clean schemas/resources/action_schema/action_schema.exp --output clean
 | `--output PATH` | Path to save the cleaned schema (optional, defaults to stdout)
 |===
 
+=== Expand schema (concatenated artifact)
+
+The `expand` command flattens the interface closure of a root EXPRESS schema
+into a single concatenated artifact (one section per source schema, ordered
+alphabetically — the same shape eeng emits for `--concat_schema`).
+
+[source, sh]
+----
+expressir expand schemas/resources/action_schema/action_schema.exp \
+  --output action-concatenated.exp
+----
+
+[options="header"]
+|===
+| Option | Description
+| `--output PATH`, `-o PATH` | Write the artifact to PATH (defaults to stdout)
+|===
+
+The closure is resolved by scanning `USE FROM` / `REFERENCE FROM` names in the
+root source and looking them up in the same directory.
+
+=== Flatten schema (SHTOLO longform)
+
+The `flatten` command converts a STEPmod-style multi-schema root into a single
+ISO 10303-11:1994 "longform" schema (expressir#32). It runs the Annex G
+conversion locally: interface-closure copy with rename resolution and name
+munging, then extensible enum/select resolution, subtype-constraint
+elimination, RENAMED→DERIVE, GENERIC_ENTITY→GENERIC.
+
+[source, sh]
+----
+expressir flatten schemas/resources/action_schema/action_schema.exp \
+  --output action_lf.exp --longform_name action_schema_lf
+----
+
+[options="header"]
+|===
+| Option | Description
+| `--output PATH`, `-o PATH` | Write the longform schema to PATH (defaults to stdout)
+| `--longform_name ID` | Identifier for the resulting SCHEMA (default: `<root>_lf`)
+|===
+
 === Validate schema
 
 The `validate load` command performs validation checks on EXPRESS schema files.
@@ -536,6 +581,26 @@ The command reports any schemas that:
 
 If all validations pass, it will display "Validation passed for all EXPRESS schemas."
 
+=== Validate semantic checks (eeng check-p11)
+
+The `validate check` command runs the eeng `check-p11` note subset
+implemented in `Expressir::Express::Checker`: redundant interfaces,
+duplicate interface resources, unresolved interface schema/resource
+refs, SUBTYPE OF targets, SELECT/ENUM BASED_ON targets, and WHERE/UNIQUE
+label patterns.
+
+[source, sh]
+----
+# Check a single file
+expressir validate check schemas/resources/action_schema/action_schema.exp
+
+# Check all .exp files under a directory
+expressir validate check schemas/resources/
+
+# Exit 1 when any :error note fires
+expressir validate check schemas/resources/action_schema/action_schema.exp
+----
+
 === Validate ASCII content
 
 The `validate ascii` command validates that EXPRESS schema files contain only

data/Rakefile

@@ -14,3 +14,15 @@ task default: %i[spec rubocop]
 require "yard"
 
 YARD::Rake::YardocTask.new
+
+Dir.glob(File.expand_path("lib/tasks/*.rake", __dir__)).each { |task| load task }
+
+desc "Regenerate the EXPRESS grammar JSON embedded in expressir-rs"
+task :"expressir:grammar:dump" do
+  require "expressir/express/grammar/parser"
+  json = Expressir::Express::Grammar::Parser.cached_grammar_json
+  dir = ENV.fetch("EXPRESSIR_RS_DIR", File.expand_path("../expressir-rs", __dir__))
+  path = File.join(dir, "assets", "express-grammar.json")
+  File.write(path, "#{json}\n")
+  puts "wrote #{path}"
+end

data/TODO.parity-ee/00-overview.md

@@ -0,0 +1,58 @@
+# Parity with Express Engine (eeng) — SHTOLO and algorithms
+
+**Status: PLANNED (2026-09-21)**
+
+## Mission
+
+1. **SHTOLO** (expressir#32): SHort-TO-LOng — generate ISO 10303-11:1994
+   "long form EXPRESS" (one self-contained schema) from the STEPmod
+   multi-schema structure (edition 2: shared files, USE FROM /
+   REFERENCE FROM). The normative conversion rules are
+   **ISO 10303-11:2004 Annex G** — local sources:
+   `~/src/mn/iso-10303-11/sources/sections/ag-single-schema.adoc`.
+2. **Concatenation** (expressir#247, metanorma/iso-10303#539): the SHTOLO
+   precursor — a dependency-closure concatenation of all interfaced
+   schemas into one publication artifact (`.exp`), plus SMRL index.
+3. **Validation** of both, against the reference implementation:
+   Express Engine (`~/src/external/exp-engine-engine`, Common Lisp),
+   whose `qualify.sh` runs the full operation catalog over the exact
+   SMRL corpus we already load (`resources.lst`/`modules.lst` ==
+   our SRL manifests).
+
+## Reference implementation map
+
+| eeng source | operation (qualify.sh) | task |
+|---|---|---|
+| `plugins/p11/wo-pretty.lisp` | Pretty Print `.exp` + compare | 08 |
+| `plugins/p11/wo-flat.lisp` + `run-op :flat` | **Flatten to long form** | 05 |
+| mode `:concatenated` (`kernel/engine.lisp`) | **Concatenate schema** | 04 |
+| `plugins/p11/wo-list.lisp` | List declarations | 09 |
+| `plugins/p11/wo-smrl-xml.lisp` | SMRL index XML | 09 |
+| `kernel/dot-graph.lisp` | Dot interface graph | 10 |
+| `kernel/check.lisp` (835 lines) | semantic checks | 07 |
+| `plugins/p11/schedule-*.lisp`, `kernel/resolve-interface.lisp` | load/resolution scheduling | 06 |
+| `kernel/compute-inheritance.lisp`, `supertypes.lisp`, `derive-attrs.lisp`, `inverse-attrs.lisp` | entity computations | 02/07 |
+
+## What we already have (expressir)
+
+Compiled schema set (batch + EXSCS1 artifact + overlays), repository
+indexes + reference graph (37.7k subtype edges, interfaces, closures),
+`Schema#interfaced_items`, resolver, formatter (clean/hyperlink),
+`RepositoryValidator`, Part 21 parser = **not started** (see 02).
+
+## Task index
+
+01 Annex G rule extraction · 02 eeng algorithm inventory (what we do
+differently) · 03 eeng oracle harness · 04 concatenation (#247) ·
+05 SHTOLO longform flatten (#32) · 06 interface scheduling parity ·
+07 semantic checks port · 08 pretty-print round-trip gate ·
+09 SMRL index + listing · 10 interface dot graph ·
+11 import the eeng test suite (scripts/ drivers, docs/issues bugs,
+SHTOLO paper, BNFs, DTDs)
+
+## Additional eeng assets (via 11)
+
+`scripts/*.sh` — 14 release-suite drivers (qual/pretty/xml/dot);
+`docs/issues/` — bug corpus incl. a shtolo old-vs-new differential;
+`docs/` — SHTOLO paper PDF, Part 11/14/21 BNFs, XML DTDs,
+interface/qualify notes; `00check.txt` — check design notes.

data/TODO.parity-ee/01-annex-g-rule-extraction.md

@@ -0,0 +1,41 @@
+# 01 — Annex G rule extraction (executable spec for SHTOLO)
+
+**Status: NOT STARTED**
+
+## Goal
+
+Turn `~/src/mn/iso-10303-11/sources/sections/ag-single-schema.adoc`
+(1957 lines) into an executable checklist: every conversion rule with
+an identifier, inputs, outputs, and a fixture that exercises it. This
+is the contract both for our implementation (05) and for judging
+eeng's coverage.
+
+## Source structure (verified)
+
+- Fundamentals: multi-schema → intermediate single "artifact" schema →
+  rewrite using 1994-only constructs; subtype/supertype graph pruning;
+  interface knowledge (visibility + instantiability) becomes rules;
+  total_over constraints become rules.
+- **Name munging**: name-clash policy; identifiers-as-strings.
+- **Stage 1 (multi → intermediate)**: primary population (per
+  interfaced item: artifact-schema rule + function capturing
+  visibility/instantiability), secondary population, **prune** rules
+  (rules whose parameters are not all visible are deleted, etc.).
+- Stage 2 (intermediate → 1994 longform): rewrite of constructs not in
+  the 1994 edition.
+
+## Steps
+
+1. Read the full annex; number every rule `G.<n>` with a one-line
+   statement, inputs/outputs, and stage.
+2. Build a fixture matrix: for each rule, the smallest STEPmod schema
+   pair(s) that trigger it (mine the SMRL corpus for real cases).
+3. Cross-reference which rules eeng implements (grep its sources for
+   the mechanisms) and mark: implemented-in-eeng / our-gap / both-gap.
+4. Encode the checklist as a spec document under
+   `spec/fixtures/shtolo/rules.md` (or adoc) that 05's suite cites.
+
+## Acceptance
+
+Every rule in Annex G has an id, a fixture, and an eeng-coverage flag;
+no rule left "uncategorized".

data/TODO.parity-ee/02-eeng-algorithm-inventory.md

@@ -0,0 +1,8 @@
+# 02 — eeng algorithm inventory: what they do vs what we do differently
+
+**Status: SHIPPED (2026-09-21) — see parity-matrix.md for the audit and
+expressir#373 for the bug the audit surfaced.**
+
+See `parity-matrix.md` (same directory) for the full algorithm-by-
+algorithm comparison: resolution scoping, interface scheduling,
+entity computations, writers, and the concrete expressir gaps found.

data/TODO.parity-ee/03-eeng-oracle-harness.md

@@ -0,0 +1,33 @@
+# 03 — Build and run eeng as a differential oracle
+
+**Status: NOT STARTED**
+
+## Goal
+
+A working `eengine` binary (SBCL build) we can run over the SMRL corpus
+to produce reference outputs (pretty, flat, concatenated, list,
+smrl-xml, dot, checks) for differential validation of our ports.
+
+## Steps
+
+1. Install/locate SBCL; build: `sbcl --load sbcl/compile` then
+   `sbcl --load sbcl/deliver` (per README.txt) → `eengine`.
+2. Reproduce `qualify.sh` flow for a handful of modules from
+   `qualify-mod.txt` (their lists == our SRL corpus names).
+3. Golden corpus: run all qualify operations for the full
+   `resources.lst` + `modules.lst`; commit distilled outputs (not the
+   whole tree) under `spec/fixtures/eeng-oracle/` (LFS-sized check
+   first).
+4. Script `script/eeng-oracle` (or Rake task) exposing one-command
+   regeneration; document known eeng bugs/limitations found while
+   driving it (feeds 01's coverage flags).
+
+## Acceptance
+
+One command regenerates the golden corpus; at least arm/mim pretty +
+flat + concatenated outputs exist for 10 modules and 10 resources.
+
+## Tests
+
+Refreshes the expected outputs consumed by 11's imported specs; the
+qual-* drivers are the oracle's entry points.

data/TODO.parity-ee/04-shtolo-concatenate.md

@@ -0,0 +1,44 @@
+# 04 — Concatenated EXPRESS artifact (expressir#247)
+
+**Status: SHIPPED (2026-09-21)** — `Expressir::Express::Concatenator`
+(closure + writer + one-call `call`), eeng-semantics ordering and
+section format (alphabetical, `-- NAME (file)` separators, verbatim
+source copies); specs: synthetic closure/round-trip + ENV-gated eeng
+differential (byte-identical sections vs `--concat_schema` for
+description_assignment ARM). Golden oracle outputs committed for ARM
+and MIM. During this stage the small-input USE FROM parse bug was
+found and reported as expressir#373.
+
+## Goal
+
+`expressir` command producing a **concatenated** `.exp`: the root
+schema followed by every USE FROM / REFERENCE FROM dependency
+(non-circular closure), each as plain EXPRESS (no remarks), with an
+SRL publication header listing the schemas. This is the SHTOLO
+precursor and a WG12 qualification/provenance artifact.
+
+## Reference
+
+- eeng mode `(:arm/:mim :concatenated)` — `kernel/engine.lisp` mode
+  table, `plugins/p11/top-level.lisp` (concatenated handling +
+  `arm_concatenated.exp` outputs in qualify.sh), SMRL index hook at
+  wo-smrl-xml.
+- Our graph: dependency closure via `Repository#reference_index`
+  (interface edges) + topological, cycle-safe ordering already
+  demonstrated by the item-graph work.
+
+## Design sketch
+
+- `Expressir::Express::Concatenator.call(repository, root_schema)` →
+  model-level ordered schema list (respect eeng's ordering rules —
+  read their code in 02 first).
+- Writer: plain schemas (no remarks) + banner comment enumerating
+  sources (schema name, file, copyright per SRL conventions).
+- CLI: `expressir concatenate <manifest/root.exp> -o out.exp`.
+
+## Acceptance
+
+- Output parses back with our parser (self round-trip).
+- Diff vs eeng `arm_concatenated.exp`/`mim_concatenated.exp` for the
+  03 golden set: schema set + order identical (formatting differences
+  documented, ideally zero after 08).

data/TODO.parity-ee/05-shtolo-longform-flatten.md

@@ -0,0 +1,53 @@
+# 05 — SHTOLO longform flatten (expressir#32) — the core port
+
+**Status: NOT STARTED**
+
+## Goal
+
+Port eeng's flatten (Annex G) into expressir: convert the STEPmod
+multi-schema web into ONE ISO 10303-11:1994 longform schema — no
+interfaces, no name clashes, interface visibility/instantiability
+preserved as rules, pruned unreachable declarations.
+
+## Sources to port
+
+- **Spec**: `ag-single-schema.adoc` (see 01's rule ids).
+- **eeng**: `run-op (:flat)` + `print-flatten`
+  (`plugins/p11/top-level.lisp:847`), writer `plugins/p11/wo-flat.lisp`
+  (373 lines; note: eeng's flat output keeps structure and lowercases
+  identifiers — verify how much of Annex G eeng actually implements
+  before treating it as gospel; where eeng and the standard disagree,
+  the standard wins and the difference goes into 02's matrix).
+- **Model surgery**: `add-declaration.lisp`, `remove-declaration.lisp`,
+  `copy-object.lisp`, `cleanup-interface.lisp`.
+
+## Design sketch
+
+1. Model-level `Expressir::Express::Flattener` operating on the
+   resolved repository (compiled set warm model): build the artifact
+   schema per Annex G — primary population (per interfaced item:
+   visibility/instantiability rules + generated function), secondary
+   population, name munging (clash policy), prune pass (rules whose
+   parameters are not all visible; unreachable subtype branches),
+   total_over → rules, then the 1994-construct rewrite.
+2. Writer: reuse the formatter with a "flat/1994" encoder profile
+   (no interfaces section; artifact rules emitted per Annex G).
+3. Validation gates:
+   - Annex G rule fixtures from 01 (each rule exercised).
+   - Differential: flatten output vs eeng `.flat` over the 03 golden
+     corpus; divergences classified standard-vs-eeng.
+   - Output parses as 1994 (no edition-2-only constructs — the
+     grammar-level edition profile check).
+4. SMRL-scale run: all 132 SRL resources + module arm/mim set; memory
+   via the compiled-set warm model.
+
+## Acceptance
+
+- All Annex G fixtures green; SMRL corpus flatten completes with zero
+  unexplained diffs vs the 1994 profile.
+- `expressir shtolo <manifest> -o longform.exp` ships.
+
+## Tests
+
+bug39's shtolo old-vs-new outputs (see 11) are an additional
+differential: eeng shtolo vs stepcode exppp vs us.

data/TODO.parity-ee/06-interface-scheduling-parity.md

@@ -0,0 +1,47 @@
+# 06 — Interface loading/resolution parity with eeng scheduling
+
+**Status: SHIPPED (2026-09-21) — the resolution-side fix.**
+`Schema#interfaced_items` is now repository-aware (foreign schemas
+found through the parent chain into the enclosing repository) and
+transitively USE-aware (items USEd by the foreign schema are visible,
+unfiltered per the implicit-interfacing rule, cycle-guarded by a
+visited-schema set). Probe results before/after: direct cross-file
+item ref resolved; transitive-USE item resolved; interface cycle
+terminates. Spec: `interface_visibility_spec.rb` (3 examples);
+express suite 321/0. Remaining: unresolved-resource diagnostics and
+USE-vs-REFERENCE error severity (eeng hard-errors; we warn) — folded
+into 07's checker.
+
+## Goal
+
+Match eeng's multi-schema load semantics: which declarations are
+visible where, transitive USE FROM (implicit interfacing), rename
+(AS) handling, and error cases ("Resource '~A' not found").
+
+## Differences already known
+
+- eeng `resolve-interface.lisp`: USE FROM resolves **only**
+  entity+type; REFERENCE FROM resolves constant/entity/function/
+  procedure/type; unresolved resource = hard error. Our resolver
+  stamps base_path but never errors on unresolved interfaces.
+- eeng runs interface **scheduling** (schedule-interfaces.lisp) so a
+  USE FROM can pull schemas already loaded in the session
+  (schemata/schemata1/schemata2) — closest to our repository + graph.
+- Implicit interfacing (11-interface_specification.adoc): items
+  visible through USE FROM chains; our `interfaced_items` is
+  single-hop — verify transitive semantics.
+
+## Steps
+
+1. From 02's matrix, list each semantic difference with a fixture
+   (rename chains, transitively used items, interface cycles,
+   missing resource).
+2. Fix expressir resolution where we are wrong (spec wins), or
+   document deliberate divergence.
+3. Add unresolved-interface reporting (warning set) — SHTOLO's prune
+   stage consumes it.
+
+## Acceptance
+
+Fixture suite covering rename/transitive/cycle/missing passes on both
+paths (Ruby parser + core path byte-parity preserved).

data/TODO.parity-ee/07-semantic-checks-port.md

@@ -0,0 +1,35 @@
+# 07 — Port eeng semantic checks (kernel/check.lisp)
+
+**Status: NOT STARTED**
+
+## Goal
+
+A `check` operation in expressir that walks a schema/repository and
+reports the same diagnostics eeng's check-p11 passes produce — the
+validation half of the SHTOLO mission (inputs must be sound before
+flattening).
+
+## Source catalog (check.lisp, 835 lines)
+
+Per-node `check-p11` methods: schema, use-from/reference-from,
+constant, local, entity (explicit/derive/inverse attributes),
+function/procedure/rule parameters, subtype_constraint, type, plus
+expression/statement checks. Also `check-notes.lisp` (note
+collection) and `compare.lisp` (schema comparison — two loaded
+sessions).
+
+## Design
+
+- `Expressir::Express::Checker` modeled on our visitor infra; each
+  eeng check becomes one rule with the eeng note id preserved for
+  cross-referencing oracle output.
+- Wire into `Repository#validate` (RepositoryValidator today is
+  interface-level only).
+- Run order: checks → report (eeng note ids + our explanation) →
+  nonzero exit on error-class notes (eeng error severity model).
+
+## Acceptance
+
+Golden-diff check reports vs eeng for the 03 corpus subset; any
+divergent verdict justified against Part 11 clause text
+(`~/src/mn/iso-10303-11/sources/sections/`).

data/TODO.parity-ee/08-pretty-roundtrip-gate.md

@@ -0,0 +1,27 @@
+# 08 — Pretty-printer parity gate (eeng wo-pretty)
+
+**Status: NOT STARTED**
+
+## Goal
+
+qualify.sh's core self-check, adopted for us: `.exp` → pretty `.exp`
+→ re-parse → identical model; plus diff vs eeng's `-pretty.exp` over
+the golden corpus so SHTOLO outputs (04/05) can target eeng-stable
+formatting.
+
+## Steps
+
+1. Read `plugins/p11/wo-pretty.lisp` encoder (spacing, casing,
+   remark policy, schema ordering) → document deltas vs our
+   `Formatter` (clean mode).
+2. Add `parser → formatter → parser` identity spec across the SMRL
+   corpus (model-level to_hash equality, not bytes, first; byte mode
+   only where eeng parity is wanted).
+3. Byte-diff our pretty vs eeng pretty on the 03 corpus; decide
+   adopt-eeng-format vs keep-ours (default: keep ours for rendering,
+   eeng profile as an encoder option for SHTOLO artifacts).
+
+## Acceptance
+
+Corpus-wide round-trip identity green; eeng-profile diffs either zero
+or explained line-by-line.

data/TODO.parity-ee/09-smrl-index-and-listing.md

@@ -0,0 +1,22 @@
+# 09 — SMRL index XML + declaration listing (wo-list, wo-smrl-xml)
+
+**Status: NOT STARTED**
+
+## Goal
+
+The SRL publication byproducts eeng generates: declaration listings
+(`-list.txt`) and the SMRL index XML for longform/concatenated files
+(`<concatenated_express_file_content_list>`), emitted from the same
+model that powers 04/05.
+
+## Sources
+
+`plugins/p11/wo-list.lisp`, `wo-smrl-xml.lisp` (element names:
+concatenated_express_file_content_list, per-schema content entries),
+top-level.lisp:748-793 (when the index is generated: XML output +
+longform/concatenated modes).
+
+## Acceptance
+
+Index/list output for the 03 golden set structurally identical
+(element-for-element) to eeng's; wired into the same CLI as 04.

data/TODO.parity-ee/10-interface-dot-graph.md

@@ -0,0 +1,21 @@
+# 10 — Interface dependency dot graph (kernel/dot-graph.lisp)
+
+**Status: NOT STARTED**
+
+## Goal
+
+Emit GraphViz dot for schema interface dependencies exactly like eeng
+(qualify.sh "Generate Dot File (interface)"), from our compiled
+reference graph (already computes interface edges + closures over the
+full SMRL).
+
+## Notes
+
+eeng's dot generation honors the concatenated mode (root-schema
+subgraph); replicate node/edge/styling choices so WG12 visual
+diffing stays stable. Trivial once 02 documents their exact output
+shape — deliberately last in the queue.
+
+## Acceptance
+
+Byte-comparable dot output vs eeng for arm/mim of the golden modules.