Task: Give every fixing index name an oresmd identity

Every distinct fixing index name in external/ore/examples resolves to an oresmd identifier, so a market_fixing row can carry an oresmd_uri and the identity cutover has a way back for the fixing half of the corpus.

• from_index_name names every distinct index name the corpus carries, asserted by a corpus-driven test whose allowlist is empty. Met: the class list is empty and the census reads 156 of 156 index names.
• Each asset class the corpus puts in the fixing space has a stated mapping, or a recorded reason it has none. Met: the two rows that are not index names are the only ones with a reason, and it is recorded.
• The corpus fixing import creates a series for every fixing row, with no skipped-name warnings. Not met, and not this task's: the import still writes the index name into the series qualifier and never calls from_index_name, which is the identity cutover's work. Review row 11 records it.

Measured over external/ore/examples (every *fixing*.txt and *fixing*.csv outside ExpectedOutput): 158 distinct index names. They fall into seven shapes as first read, and only the first was nameable at that point. COMM- and POWER- are one shape up to the prefix but two classes in the census below, because the prefix is what the class tag is: 25 and 48 names.

The interest-rate 57 split two ways. The ones whose family the enum holds are nameable; 22 of the rest are real benchmark families it does not: BBSW, CAMARA, REPOFIX, CZEONIA, PRIBOR, CIBOR, DKKOIS, CMS, EONIA, FedFunds, NIBOR, SIOR, STIBOR, SIFMA, HIBOR. The twenty-third, JPY-TONAR, is the spelling ORE writes for tona. The identifier already carries index_spelling for exactly this – "the spelling that arrived is carried beside the family so the key reads back as it came" – so a spelling needs an alias beside its family, and the missing families need adding. AONIA is neither: the family token is matched case-insensitively, so it has always resolved to aonia.

Two of the four GENERIC names are not fixings at all. They are GENERIC-MD/EQUITY_OPTION/PRICE/RIC:.SPX/USD/2025-10-03/3300/C and its sibling: market-data keys that appear inside a fixings file, read by the whole-line parser as fixings because that is the file they are in. Whether the reader should refuse a key that is not an index name is part of this task. The other two, GENERIC-JuniorNote and GENERIC-PortfolioBasket#1, are a curve name and a basket name, and need classifying rather than mapping.

Four of the six classes need a field the index name does not carry:

• an equity fixing (EQ-SP5) names a ticker and no currency, and the equity identifier requires one;
• a commodity or power fixing (COMM-NYMEX:CL-2024-12, POWER-ICE:PDQ-2021-01-04-14400-18000) names a contract and no currency, and the commodity identifier requires one;
• an FX fixing (FX-ECB-EUR-USD) names a source as well as a pair, and the FX identifier has no field for one.

Two readings, and they produce different permanent URIs:

1. A fixing's identity does not include a currency. For type=fixing the currency is a property of where the instrument is quoted, not of which index it is, so the grammar should not require it. oresmd://equity/sp5?type=fixing and oresmd://commodity/nymex:cl-2024-12?type=fixing, each carrying a contract as its point where there is one. This is the reading the IR case already follows in reverse – there the currency is in the name, so the identifier has it – and it needs no field the corpus cannot supply.
2. The caller supplies the missing fields. The fixing boundary would look the currency up (refdata knows a ticker's currency) and add ccy to the URI. This keeps the identifier's invariants intact and moves the problem to the import, but it makes the URI depend on reference data: the same file would produce different URIs in two databases that disagree.

The recommendation was the first, with the FX source carried as a spelling beside the pair the way index_spelling carries one. The owner took the first and kept the source as a field rather than a spelling, because a spelling is orthographic and the two sources are two different rates; the decision is recorded under * Decided.

Requiredness follows the entity kind: a fixing and a quote do not share a set of required fields, because they do not answer the same question. A quote says what a thing is worth and in what currency; a fixing says what an index was on a date. So the currency is required of every type that is not a fixing, and not of a fixing – which is what the parser now enforces, with the type carrying it as optional rather than mandatory.

This settles the equity and commodity half of the gap. Still open, and separate:

• the interest-rate families the enum does not hold – EONIA, CIBOR, NIBOR, STIBOR, SIOR, FedFunds, CMS, SIFMA, BBSW, AONIA, CAMARA, REPOFIX and the rest – which is data rather than grammar;
• the FX source (FX-ECB-EUR-USD against FX-TR20H-EUR-USD), which is a field the FX identifier does not have; and
• the power contract-hour shape, which is a shape the grammar does not have.

The FX fixing carries its source, and the pair as it was quoted. The source is a field, not a spelling: FX-ECB-EUR-USD and FX-TR20H-EUR-USD are two different rates, where a spelling difference is two ways of writing one. So source joins the FX identifier, lower-cased, with source_spelling carrying the token as ORE wrote it when the two differ, and both are meaningful only when type=fixing – ORE's FX quote keys carry no source at all.

The pair is never put into a canonical order. A fixing's value is only meaningful in the direction it was published, and the corpus writes FX-TR20H-EUR-GBP and FX-TR20H-GBP-EUR as one rate both ways, on 122 shared dates, reciprocal to about three decimal places and no more. The model brief carries the measured pair of figures. Canonicalising would put two values under one date, and nothing in the import inverts a value.

The last grammar decision. POWER-ICE:PDQ-2021-01-04-14400-18000 arrives as an index name, and ORE writes the grammar for that name down rather than leaving it to be inferred from the corpus.

ORE states the format. OREData/ored/utilities/indexparser.cpp carries a parser of its own for this family, parseIntradayPowerIndex(), standing beside parseCommodityIndex() rather than inside it, and its failure message is the grammar:

Expected format: POWER-COMMNAME[-YYYY-MM-DD[-DELIVERYSTART-DELIVERYEND[-DST]]]

It builds a QuantExt::IntradayPowerIndex, a type of its own, and parseIndex() gives the power parser its own place in the dispatch order. The parser splits the remainder after POWER- on dashes and reads tokens[0] as the commodity name, so the name's boundary is the first dash and a power commodity name carries no dash – ICE:PDQ is whole. It then accepts the remainder only at three token counts: one (the commodity name alone, with no date), four (a name and a date, with no time), and six or seven (a name, a date, a start, an end, and an optional DST, matched case-insensitively). Every power name the corpus carries is the six-token form but for one four-token name, and no name has a shape the grammar does not admit.

The two numbers are seconds from midnight, and the window they name is half-open: the corpus's windows are all 3600 seconds wide and tile a day without a gap.

The date is the delivery date. Every power row carries the same date in the file's first column and in the name, so the power payload alone cannot say which the name's date is. Its sibling settles it: COMM-NYMEX:CL-2025-04 is observed on 2024-12-02, so a period in a name of this family is the delivery period. ORE's own types agree – IntradayPowerIndex takes a deliveryDate, and the trade that consumes it, IntradayPowerForwardData, carries DeliveryDate, DeliveryStart and DeliveryEnd as three separate fields, the last two in seconds.

The window is not an hour. The corpus samples 3600-second windows only, but the trade model carries DeliveryStart 2700 and DeliveryEnd 4500 for the forward it calls "0.45am to 1.15am". The coordinate is therefore a second-resolution window, and "the contract-hour shape" names the corpus's own sampling rather than a rule the model may hardcode.

What the corpus carries. 48 distinct names, every one of them on ICE:PDQ:

The one date-only name is the whole-day contract for 2021-01-04, at 38.75 against 25 to 38 for that day's 23 hourly windows. That day carries 24 rows and 2021-01-01 to 2021-01-03 carry 8 each, so the corpus is not a complete tiling of a day and nothing may assume one window per hour of a delivery date.

The name is an index name and nothing else. Every other class with an index-name prefix in the corpus also appears as a market quote key – FX/RATE on 1372 rows, EQUITY/PRICE on 105, COMMODITY_FWD/PRICE on 2803, BOND/YIELD_SPREAD on 92 – so each of them has a quote key to project as well as a fixing key. POWER does not: the string occurs on the 48 fixing rows and nowhere else, and an intraday power price is quoted as SHAPE_PROFILE/SHAPE_FACTOR/PROFILE/DATE/SECOND/UNIT, which the shape_profile class already owns. So the index name is the only key this class has, and the class has no quote type at all.

The last open question is settled. The four GENERIC names split two ways.

GENERIC- is a prefix ORE resolves in a parser of its own, so GENERIC-JuniorNote and GENERIC-PortfolioBasket#1 are index names like any other, and a generic index's identity is its own name. GENERIC-MD is not the same prefix: it is the market-data wrapper whose inner type and metric name the series, and it is already one of the coverage gate's two recorded exemptions. Its two rows in Products/Input/fixings.csv carry SPX call prices – 2862.29 at the 3300 strike and 2767.41 at 3400, about 95 apart for a 100 strike step – so they are market data in a file whose header declares fixingId for its second column. The owner reads them as errors rather than as fixings to model.

So the target is 156 of 158: the two GENERIC-MD rows are errors, and the other nineteen names are named.

The names are AUCPI, EUHICP, EUHICPXT, FRHICP, UKRPI, USCPI and ZACPI for inflation; EQ-SP5 and seven EQ-RIC: or EQ-FIGI: tickers for equity; BOND-ISIN:IE00BH3SQ895 and its -2025-08 future for security; and GENERIC-JuniorNote and GENERIC-PortfolioBasket#1 for generic.

One row stays unexplained and is not part of this: GENERIC-JuniorNote is valued at 4000000 in Legacy/Example_46/Input/fixings.txt, alone after a blank line among ordinary index fixings. Four million is not a rate or a price, so it should be checked against Example_46's portfolio rather than assumed either way.

GENERIC- is a prefix ORE resolves rather than a spelling of another class, so it gets a class of its own. ORE's parser resolves the prefix, and the name is all the identity there is: a generic index is whatever its producer called it, the corpus carries no other key for either series, and ORE has no market-data key for one. The corpus carries two, GENERIC-JuniorNote in Legacy/Example_46/Input/fixings.txt and GENERIC-PortfolioBasket#1 in Products/Input/fixings.csv, both on fixing rows. So generic joins power as a fixing-only class: it carries no quote type, and quote_key_generic() returns nothing.

Inflation, equity and security are closed, which leaves no class the corpus puts in the fixing space unnamed: 156 of its 158 names in a fixing column resolve, and the other two are the market-data keys.

Inflation is the one class whose index name has no prefix. UKRPI is the whole of the name: there is no INFLATION-, no separator, and nothing in the string says which class the token belongs to. So the class carries the codes it knows, in an Index codes table in inflation_quote_type.org, and the index-name projection names a dash-less token only when it is one of them. A stray token or a header word keeps its name instead of being given an inflation identity, and a code written in another case is refused rather than reshaped – the rule the power delivery date follows, and why the seven codes the corpus carries are all upper-case. The list is data: a code ORE adds is a row.

Equity needs no new field. A fixing carries no currency, which ccy_optional_for_fixing already settles, so the whole projection is EQ-<ticker>. The ticker is the tail ORE writes, its identifier scheme included: the corpus carries EQ-RIC:.SPX and EQ-FIGI:BBG00R251JN8 as fixings beside EQUITY_OPTION/RATE_LNVOL/RIC:.SPX/USD/... as the quote key for the same instrument, so the scheme belongs in the name rather than in a field beside it.

Security reuses delivery. The corpus writes BOND-ISIN:IE00BH3SQ895 for the bond and BOND-ISIN:IE00BH3SQ895-2025-08 for the future that expires in August 2025, so the trailing period is a contract month: the shape commodity already gives its delivery. delivery joins security's Fields table and leaves its Reject keys table, and the shared shape helper becomes contract_month_is_the_shape now that it has a second caller. A quote carries that information inside the name it is quoted under, which is why nothing reads the field for one.

The allowlist is empty and the population is still whole. The two GENERIC-MD/EQUITY_OPTION/PRICE/... rows are not index names, so the census counts them in a bucket of their own, pins them by name and asserts that the projection refuses both. That case replaces the recorded-list entry that used to excuse them, so nothing was dropped to make the list empty.

1. Measure first. Walk every fixing payload with the real fixing reader, report the yield per index-name class, and pin the classes that name nothing. The instrument landed with the interest-rate work rather than after it: the branch this task descends from skipped three quarters of the distinct series with a warning, and no test asked about the names it skipped.
2. Interest rates are data, not grammar. The families and the spellings ORE writes for them go in the Index family table of ir_quote_type.org. The tenor rule moves into that table too, so a family cannot join the enum without being classified, and the hand-written header that held a copy of the rule goes.
3. Then the grammar, one class at a time. The FX source and the power contract-hour shape each need a field or a shape the identifier does not have. Each is a decision taken with a worked example against the corpus, and each shrinks the pinned list by one class.

(Implementation strategy. Written when work starts; key decisions are distilled into the parent story's * Decisions at close, but the plan itself stays — it is the historical record of what we did.)

Every number this task claims about a tree, with the command that produced it and the commit it was measured at. A number without both is not a measurement, because a clean-up record describes a tree and trunk moves under a branch: a consumer count, a gate's component count and a suite's size all change with no code changing, and the reader of a bare number cannot tell which tree it came from. Where the raw output matters, put it in an evidence/ file beside the task and name that file in the Command column.

The test binaries are under build/output/linux-clang-debug-make/publish/bin/. The per-class table is in the WARN output of the [fixing] cases, printed on every run rather than asserted in prose.

The curve-configuration CHECK is a different rule from the index-name one. requires_tenor says whether every index name ORE writes for a family carries a tenor, so that the family is never written bare. The CHECK constraint on ores_synthetic_ir_curve_generation_configs_tbl says which (family, tenor) pairs a synthetic curve may be configured with, and the two disagree for shibor, taibor and tiie: the CHECK wants tenor = '' for them, and the corpus writes CNY-SHIBOR-3M, TWD-TAIBOR-3M and MXN-TIIE-28D. The old is_overnight() kept both rules in one predicate, which is why the hand-kept family list in the parser tests called those three overnight and failed once the corpus was measured.

A family in the enum is not a family synthetic can configure. The same list is written into projects/ores.synthetic/modeling/ores.synthetic.ir_curve_generation_config.org three times – the membership CHECK, the tenor-combo CHECK and a static_combo – and it generates the SQL from there. None of the fifteen families this task adds is in it, so a synthetic curve cannot be configured for them. That is a decision for that component, not a consequence of this table.

ftiie is in the enum and in a migration but not in create/. git grep ftiie finds it in the marketdata enum and in synthetic_ir_curve_generation_configs_add_ftiie_migration.sql, and finds nothing under projects/ores.sql/create/ or in the synthetic model. A database created from create/ therefore rejects a family a migrated one accepts. Recorded here because this task walked the same list; it belongs to ores.synthetic.

The refused fixing file was invisible to every count. Its two names, USD-FedFunds and USD-LIBOR-3M, also appear in files the reader could read, so refusing it changed no total. Only a test that asks about the file can see it, which is why the coverage test asserts on refused payloads and not only on names.

The semicolon separator is read for market data too. tokenize() is shared by parse_fixings() and parse_market_data(), and it normalises separators rather than detecting them, so adding ; widens both readers. Measured: none of the 66 market payloads the coverage test selects contains a semicolon, so the corpus measures the same either way; the widening is the design's own shape rather than a concession to one file, and it is the shape a producer's semicolon-delimited market file would need.

One line of the PlantUML diagram is not this task's. The index_family enum in ores.marketdata.puml was missing ftiie, which the enum has held since an earlier change, and the file lists the enum, so the gap was closed while the table was being extended. Measured: the enum declares 38 values and the diagram now lists the same 38.

A type-gated key is gated by the table now, not by the template. The section took only a key and the template hard-coded quote. It takes a type column; a row that names none is gated on quote, which is what the interest-rate table's one row means.

Three classes do not emit the Reject keys table their model carries. equity (delegate_function), credit and commodity (inline_delegate) route their query validation through the shared check instead, so the rows added to their tables are documentation and the shared check is what refuses the keys. That is pre-existing – their other rows are equally unenforced – and it is why the two new keys went into the shared check as well as the six tables that do emit.

The reciprocal figure took two attempts. The corpus's two GBP-EUR directions were first recorded as reciprocal to six decimal places, from a single sampled date; the correction then read the median of the absolute deviation as a product and said 1.0003. Over all 122 shared dates the median product is 0.9997 and the worst 0.9964, so the two agree to three decimal places and not more, and slightly below one. The decision not to canonicalise does not rest on the precision: two values still land on one date.

A test case a model declares is invisible until a template block emits it. The two fixing-only classes each had eleven: power declared its Projections, Round-trip and Rejection rows in the identity change and no {{#power_*}} block existed to render them, and generic's rows were written beside them in the same state. Neither the C++ suite, the drift check nor the coverage gate said so, because nothing that runs reads a spec's * Test cases table; the table is input to mustache and to nothing else. test_oresmd_spec_test_cases.py now loads every model through the generator's own loader and requires each declared description to appear as a TEST_CASE in the generated sources. Run against the tree before the wiring it names all 22 rows.

The delivery key is gated in the template, because the table cannot reach it. The Type-gated keys table is emitted only for the classes that build a validate_<class>(), so a class that validates inline gets no gate from it, which is the codegen gap the models record for delivery. The gate therefore lives in the shared {{#has_delivery}} block, where every class that names the field passes through it, so commodity, power and security all refuse a delivery off a fixing and the claim that no class accepts the key and drops it is true of all three.

One component file list is stale on main, and it is not this task's. regenerate_cmake_component_files.py --all --check reports projects/ores.workflow/api/src/component_files.cmake stale at 48eb0e27aa, and git diff origin/main shows this branch does not touch ores.workflow at all, so the drift arrives with main. Every component this task edits is clean: the four marketdata parts and ores.codegen each report rc 0 on the same check. Fixing another component's generated list here would put an unrelated regeneration in this pull request, so it is recorded rather than fixed.

Manual QA scenarios (scaffolded via compass add test_scenario) that verify this task. Link new ones here as they're created; the scenario doc itself links back via its "Verifies task" field.

The interest-rate third of the fixing key space is closed. from_index_name names all 57 distinct interest-rate index names the corpus carries, and each projects back to the name it arrived as; before this work it named 34 and round-tripped 28. That is 57 of the corpus's 158 names, so most of the key space is still open, and none of it is wired: import_service still stores the index name in the series qualifier and never calls from_index_name, so the acceptance criterion about the import creating a series for every fixing row belongs to the identity cutover.

Fifteen families joined the enum: BBSW, CIBOR, CMS, HIBOR, NIBOR, PRIBOR, REPOFIX, STIBOR, CAMARA, CZEONIA, DKKOIS, EONIA, FedFunds, SIFMA and SIOR. The two spellings ORE writes differently, ESTER for estr and TONAR for tona, became aliases in the model, and the identifier now carries the spelling a name arrived under so it reads back as it came. The tenor rule left the hand-written oresmd_index_family_utils.hpp for the Index family table, which the generated requires_tenor() and both suite's family lists are built from.

A curve identifier drops the tenor of an overnight family, because the tenor belongs to the curve key; a fixing identifier keeps the tenor the index was published at, because USD-SOFR and USD-SOFR-3M are two series. role is what tells the two apart, and both readings are pinned in the projections tests.

The FX class is closed with it. An FX fixing carries source, lower-cased, and source_spelling for the token as ORE wrote it, both meaningful only when type=fixing; the pair stays the pair as published. All seven FX names the corpus carries name and round-trip, from none, and every other asset class refuses the two keys rather than dropping them. The corpus total is 64 of 158.

The new coverage test walks every fixing payload with the real reader and reports the table per class. It found a fixing file the reader refused: CurveBuilding/Input/fixings_bondyieldshifted.csv is semicolon-separated, is the fixingDataFile its example names, and is a file ORE reads. The reader now reads it, and every one of the 66 payloads is walked.

The power and commodity halves are closed with the next change. ORE states the intraday power index grammar in its own parser rather than leaving it to be inferred, and its commodity parser reads a contract month the same way, so a fixing's delivery period becomes a delivery field of its own rather than a point: point is what a quote or a vol names, and a fixing whose coordinate is a field stays scalar, as the interest-rate tenor already does. Power becomes a class of its own because ORE accepts a bare POWER-ICE:PDQ and a bare COMM-ICE:PDQ, and one class could not write both names back. Power is 48 of 48 and commodity 25 of 25, all round-tripped, which takes the corpus total to 137 of 158. delivery joins the keys the other classes refuse, so no class accepts it and drops it.

Still open, each its own decision: inflation (7 names), equity (8) and security (2). The two GENERIC-MD/EQUITY_OPTION/... rows the corpus puts in a fixing column are errors rather than fixings to model, so the target is 156 of 158 rather than 158, and the census counts them as market-data-key so that the population it walks stays whole.

The generic class is closed with the next change. ORE states the prefix in a parser of its own, so generic joins power as a class the corpus's prefix names: the identifier carries the index name upper-cased and the case ORE wrote it in beside it in name_spelling, which is the FX source_spelling rule. Both names the corpus carries name and round-trip, the second of them through the %23 its # becomes in a URI, and 2 of 2 takes the corpus total to 139 of 158.

The fixing key space is closed with the last three classes. Every class the corpus puts in it resolves and round-trips: interest rates 57, intraday power 48, commodity 25, equity 8, inflation 7, FX 7, security 2 and generic 2, which is 156 of the 158 names in a fixing column. The other two are market-data keys in a fixing column, and the projection refuses them, so the target is 156 of 158 rather than 158: the owner reads them as errors rather than as fixings to model.

The corpus-driven coverage test now names the classes with an empty allowlist, so a class that stops resolving fails it, and the two keys are pinned in a bucket of their own and asserted to project to nothing. Nothing was dropped to make the list empty: the fixing space and the keys misfiled inside it still add up to every distinct name the corpus carries.

What remains is not this task's. The import still stores the index name in the series qualifier and never calls from_index_name, so the acceptance criterion about the import creating a series for every fixing row belongs to the identity cutover, as Review row 11 records.