ORE Domain Roundtrip Check (Thing 3)

The existing "Thing 2" check (ore_coverage_check.py) compares element names in manually-maintained golden files against ORE example files. It catches structural coverage gaps but has two blind spots: it only covers Products/Example_Trades/ (~198 files) and it never exercises the C++ mapper code, so a field declared in the golden file but silently dropped by the mapper goes undetected.

"Thing 3" closes both gaps by exercising the full mapper roundtrip using the same ores.ore import and export code the server-side workflow uses:

external/ore/examples/**/*.xml
     │
     │  importer::import_portfolio_with_context(path)
     │    → vector<trade_import_item>  (instrument_mapping_result)
     │
     │  to_export_result() bridge
     │    → vector<trade_export_item>  (instrument_export_result)
     │
     │  exporter::export_portfolio(items)
     │    → XML string
     │
     │  written to mirrored path under output_dir
     ▼
assets/test_data/domain_roundtrip/**/*.xml   ← committed to repo
     │
     │  python3 scripts/ore_domain_roundtrip_check.py
     │  (diff committed outputs against originals — pure Python, no binary)
     ▼
CI report: per-trade-type fidelity, field gaps, coverage %

The import and export functions are exactly what the server-side ORE import workflow calls; the only new code is the in-memory bridge between them (bypassing the DB that normally sits in between) and a thin CLI entry point. The committed output files also serve as a regression net: any PR that changes a mapper produces a visible diff on those files.

CI runs the Python diff only — no C++ build required — so it replaces Thing 2 at zero additional CI cost.

1. Add a to_export_result() bridge in ores.ore that converts instrument_mapping_result (import-side type) to instrument_export_result (export-side type) entirely in memory, enabling the two existing halves to be composed without touching the DB.
2. Add exporter::roundtrip_portfolio(input_dir, output_dir) which composes importer::import_portfolio_with_context() + bridge + exporter::export_portfolio() and writes mirrored outputs.
3. Wire ores.cli ore roundtrip <input-dir> --output-dir <dir> in host.cpp as a DB-free command that calls the above. Minimum CLI-specific code: one call, print summary, return.
4. Write scripts/ore_domain_roundtrip_check.py (Thing 3): Python script that diffs committed outputs against ORE originals and reports per-file and per-trade-type fidelity.
5. Add CMake target ore-domain-roundtrip for dev regeneration.
6. Generate and commit the initial baseline outputs for all 1501 example files.
7. Replace ore_coverage_check.py (Thing 2) with Thing 3 in CI and delete the old script and its golden dataset.

• No changes to the mapper logic itself (separate per-family work).
• No database involvement: the roundtrip is purely a file-level operation.
• No automatic regeneration in CI: CI only diffs committed files; regeneration is a dev action.

• Use existing import and export code: importer::import_portfolio_with_context and exporter::export_portfolio are called unmodified. No roundtrip-specific mapping logic is written; the bridge is purely a type-adaptation layer between two structs that hold identical inner data.
• Minimum CLI code: host.cpp calls one function (exporter::roundtrip_portfolio) and prints the returned summary. All logic lives in ores.ore, not ores.cli.
• Unmapped trades pass through unchanged: for any trade whose type is std::monostate in the instrument_mapping_result, the original XSD trade is written unmodified into the output portfolio. This keeps the output structurally complete and lets the Python diff distinguish passthrough trades from mapper-touched ones.
• Non-portfolio XMLs are skipped silently: files whose root element is not <Portfolio> are ignored; no output file is written.
• Output tree mirrors input tree: the path under output_dir replicates the path relative to input_dir. For example: external/ore/examples/Products/Example_Trades/FX_Forward.xml → assets/test_data/domain_roundtrip/Products/Example_Trades/FX_Forward.xml.
• CI is non-strict initially: the Python check reports gaps but does not fail the build. --strict is added once agreed coverage thresholds are reached.
• Thing 2 is retired in full: ore_coverage_check.py, its golden dataset (assets/test_data/golden_dataset/), and the CI step that invokes it are all deleted in Phase 6.

As of PR #728 (import/export cleanup), the import and export sides share a single unified instrument carrier type:

trade_instrument = std::variant<
    std::monostate,
    swap_instrument_data,       // with_legs<rates_instrument_variant, swap_leg>
    fx_instrument_variant,
    bond_instrument,
    credit_instrument,
    equity_instrument_variant,
    commodity_instrument,
    composite_instrument_data,  // with_legs<composite_instrument, composite_leg>
    scripted_instrument>

Both trade_import_item and trade_export_item carry a trade_instrument field. There is no longer any type conversion required between the import and export sides — the bridge is a trivial struct copy:

trade_export_item ei;
ei.trade      = item.trade;
ei.instrument = item.instrument;

The original bridge design (with separate *_mapping_result / *_export_result types) is obsolete.

• ores.ore builds clean with the new bridge function and roundtrip_portfolio method.
• ores.cli builds clean with the new subcommand.

• Running:

  ores.cli ore roundtrip external/ore/examples \
      --output-dir assets/test_data/domain_roundtrip
  

  produces output files for all portfolio XMLs and prints a sensible summary.

• ore_domain_roundtrip_check.py runs without error against the committed baseline and produces a readable coverage report.
• CI passes on the PR that introduces Phase 6.
• ore_coverage_check.py and assets/test_data/golden_dataset/ are gone from the repo.