Story: Rework the rates instruments to the instrument table rule

Rework swaps, FRAs, caps and floors, swaptions and the other rates trade types to the instrument table rule of the trade shape investigation (section 14), as the bonds were reworked, with the data-oriented review deciding the tables.

• The family header's trade_type check lists exactly the family's codes, and each product fact table checks its own.
• Every instrument row is keyed by its trade and pinned to the anchor's trade type and party by a composite foreign key.
• The family's trade types route to their tables through the trade-type catalogue, not hand-written code.
• The ORE round trip stays lossless across the family's corpus.
• The blotter's common-date view is generated, mapping each family's dates to common names; this first family creates it and each later family adds to it.

Distilled from design.org, which carries the argument and the evidence. The design stays in this folder as the record of why these decisions are what they are.

• A money member of the ORE binding keeps the digits the document wrote. The FRA's strike and notional are a lexical leaf, patched in by the reapply script, and the mappers read and write the digits. Reason: a bare float holds only the nearest binary value, so 0.005 was stored and exported as 0.00499999989.
• The round trip is proved by comparing stored rows over the corpus. The test imports each rates trade, exports it alone, imports it again and compares the rows the family stores, with a closed set of known differences that is empty. Reason: a document-level comparison hides a field the mapper drops, and the corpus is the only set of real products.
• The family's eventing tests are generated and cover the service. Each model sets the eventing flag, and the fact tables set party_scoped_writes. Reason: the generated test writes, reads and updates a row through the service, so no hand-written repository case is needed.
• A product's list fields are child rows and its schedule is a shared row. FlexiSwap and BalanceGuaranteedSwap carry their bounds, tranches and notionals as child tables keyed by the trade and an ordinal, and the tranche schedule is an instrument_schedule row under the owner role tranches. Reason: it is the shape callable_swap_call_date and the leg children already follow, and a second schedule table would repeat the shared one.
• The anchor pin is a trigger check on the header alone. The trade anchor is versioned and has no unique key a database foreign key could name, so the header declares a Pinned keys row over (trade_id, party_id, trade_type_code). The fact and child tables hold neither column and join through the header (D3). The check runs at insert, so an amendment of the anchor does not re-check the header; the trade model's owner decides whether an amendment re-pins its children.
• The family boundary is the asset class, not the catalogue's product_type. The rates family is the interest_rates codes: Swap, CrossCurrencySwap, FlexiSwap, ForwardRateAgreement, CapFloor, Swaption, BalanceGuaranteedSwap, CallableSwap and KnockOutSwap. RiskParticipationAgreement is a credit product and InflationSwap an inflation product; the refdata asset class catalogue and the two domain notes say so, and product_type is the misnamed column defect 10 records.
• One family header, named rate_instruments. It carries the coverage check over the family's codes, the trade-activity key, the fields every product shares, and the * Delete cascade that owns the family's rows. It is a coverage and ownership device first: nothing owns the family today, so a delete leaves the legs and the children behind.
• No security level. A rates trade has no issuer and no ISIN, so there is no master entity to normalise the economics onto.
• In the target model the legs are re-keyed to the trade and given their schedules. (trade_id, leg_number) replaces the surrogate id as bond_legs is keyed, and amount and rate children carry the amortisation and step schedules the single columns cannot. payer has since joined the row; the re-key itself is deferred behind the compound-key template defect the capture below records.
• netting_set_id leaves the instrument. trade_booking already holds it, as a uuid foreign key where the instrument's copy is bare text.
• The ORE mapping repair is the family's largest unit, not a follow-up. The import never writes the legs it builds, overwrites a cross-currency swap's type to Swap, and leaves seven columns that exist permanently empty.
• RPA is a credit product, and its catalogue row now says so. RiskParticipationAgreement is classified credit and routed to credit_instrument, which is the table the importer always wrote; the credit check gains the code and the trade-types seed carries the class. The old rpa_instruments table is unproduced and is recorded for retirement rather than removed here. Reason: the rpa.org domain note, the refdata instrument codes and the importer all called it credit already, and the routing was the only source that disagreed.
• A leg records its direction, and the import writes the legs it builds. payer joins swap_leg and is mapped both ways, and the handler writes each leg after its instrument and fails the item when a leg fails. A stored swap is an instrument rather than a row.
• The legs keep their surrogate key for now. Re-keying swap_legs to (trade_id, leg_number) fails to compile a generated test: the compound-key path inserts each extra key column's raw domain value where the generated service takes every key part as text. The fix is a template change that regenerates every component under test, so it belongs with the codegen work and the re-key is recorded as a capture. Reason: a family rework should not carry a tree-wide regeneration behind it.
• A leg's notionals and rates are child rows, and they cross the wire. swap_leg_amount and swap_leg_rate hold the schedules; swap_leg no longer carries notional, fixed_rate or spread, because one column cannot hold a schedule. The mapper reads every entry of each ORE list instead of the first, and the carrier and its hand-written codec were extended in the same unit, because the export rebuilds a leg from the payload and nothing else: without that, removing the flat columns would have lost the leg's economics on the way out.
• A common date is declared on the column, and the vocabulary is in the catalogue. The trade-type catalogue lists the four names the blotter reads. A column states which one it holds with :common_date: <name>, and the view for each routed header is generated from those declarations. A date no family owns, the trade date, names its entity and column in the catalogue instead. A later family adds its mapping on its models and edits no view.

• The credit and inflation families' own reworks, which take rpa_instruments and inflation_swap_instruments once they leave.
• The reference tables that turn the family's soft code references into real foreign keys.
• The three unrouted codes' products, which need ORE importer support before a table can hold them.

All fourteen tasks are merged or closed. The rates family sits on its header and fact tables, and the corpus round-trips with equal family rows.

Not closed. An earlier bookkeeping pass closed this story on its tasks' state alone, and that is how five of the design's eight staging units went unwritten: the tasks were done, so the story read as done. The five are tasks now, and this story closes when its acceptance does, not when its task list does.

The acceptance against the tree as unit 3 left it: