This is the build plan for this decision record, bite by bite, as it was grilled and built. It’s copied from our repository unedited, apart from customer, partner and bank names, which read [redacted]. It was written for the people and agents building the product, so expect internal shorthand, and the mistakes are left in.

ADR-841 — Implementation Plan

Findings for the ADR

Files touched

Bite 1 — the attribute-banded price

Bite 2 — the card attributes and the card fees

Bite 3 — the matrix, the probe, the guide

Prior art

Nothing changed since the grill. The settings commands are the existing ones (F2); the CardPricingAttributes builder is a Cards-internal helper, not a contract.

Interfaces

// src/LedgerTM.Contracts/Pricing/PriceLists/PriceContext.cs — new (D3)
public sealed record PriceContext(IReadOnlyDictionary<string, string> Attributes, decimal? Amount)
{
    public static readonly PriceContext Empty = new(new Dictionary<string, string>(), null);
}
public sealed record PriceQuote(decimal Value, PriceKind Kind, decimal? Minimum, decimal? Maximum, CurrencyId Currency, int MinorUnit)   // the chosen row after the plan's adjustments to Value; MinorUnit from the tenant's currency setting, 2 where unset
{
    // fee(): a zero or negative value or amount is 0; an Amount row is its value; a Rate row is clamp(Value * amount, Minimum, Maximum) rounded MidpointRounding.AwayFromZero to MinorUnit; the rate applies to the whole amount
    public decimal FeeFor(decimal amount);
}

// src/LedgerTM.Contracts/Pricing/PriceLists/IPriceProvider.cs — changed (D3)
decimal GetPrice(string priceType, DateOnly valueDate, PriceContext context);       // the two-argument forms call these with PriceContext.Empty
decimal? TryGetPrice(string priceType, DateOnly valueDate, PriceContext context);
PriceQuote Quote(string priceType, DateOnly valueDate, PriceContext context);       // throws UnpricedOnDateException on a miss, as GetPrice does (ADR-704)
PriceQuote? TryQuote(string priceType, DateOnly valueDate, PriceContext context);

// src/LedgerTM.Contracts/Pricing/PriceLists/IPriceTypeCatalog.cs — changed (D2)
public sealed record PriceSelectorInfo(string Key, IReadOnlyList<string> AllowedValues);
public sealed record PriceTypeInfo(string Key, string Label, PriceKind Kind, bool IsActive, IReadOnlyList<PriceSelectorInfo> Selectors);

// src/LedgerTM.Pricing/PriceLists/Domain/Price.cs — changed (D1)
public class Price
{
    public PriceTypeId PriceType { get; set; }
    public DateOnly EffectiveDate { get; set; }
    public decimal Value { get; set; }                                   // >= 0; a waived fee is 0
    public Dictionary<string, string> Selectors { get; set; } = [];     // lower-case kebab keys and values; empty = the fallback series
    public decimal? FromAmount { get; set; }                            // [From, To): inclusive bottom, exclusive top; null From = no band; null To = open top; From >= 0
    public decimal? ToAmount { get; set; }
    public decimal? Minimum { get; set; }                               // Rate rows only: the fee's floor and cap in the list's currency, dated with the row
    public decimal? Maximum { get; set; }
    public bool Retired { get; set; }                                   // a dated row that ends its series: from its date the series is absent (D1)
    public int Specificity => Selectors.Count + (FromAmount is null ? 0 : 1);
    public bool Matches(PriceContext context) =>
        Selectors.All(s => context.Attributes.TryGetValue(s.Key, out var v) && v == s.Value)
        && (FromAmount is null || (context.Amount is { } a && FromAmount <= a && (ToAmount is null || a < ToAmount)));
    public bool SameSeriesAs(Price other);                              // same selector set and band
    public bool BandOverlaps(Price other);                              // a.From < (b.To ?? ∞) && b.From < (a.To ?? ∞); an unbanded row overlaps every band
}
// PriceList.Quote(PriceTypeId, DateOnly valueDate, PriceContext context): rows of the type with EffectiveDate <= valueDate and Matches(context), grouped by series; a series whose latest row at or before the date is Retired is absent;
//   ordered by Specificity desc then EffectiveDate desc, first row; null when none. GetPrice is Quote?.Value; the old GetPrice(type, date) is GetPrice(type, date, PriceContext.Empty).
// PriceList.ChangePrice(type, value, valueDate, selectors, fromAmount, toAmount, minimum, maximum, retired): replaces the row of the same series and date, else adds. RemovePrice(type, valueDate, selectors, fromAmount, toAmount) likewise.

// src/LedgerTM.Pricing/PriceLists/Domain/PriceSelector.cs — new (D2); PriceTypeEntry.cs — changed
public sealed class PriceSelector { public string Key { get; set; } = ""; public List<string> AllowedValues { get; set; } = []; }   // VocabularyKey.Pattern on both; at least one value
public List<PriceSelector> Selectors { get; set; } = [];   // on PriceTypeEntry

// src/LedgerTM.Pricing/PriceLists/Domain/PriceSettings.cs — the refusals live here (D1, D2, D6), DomainException, 422, the message naming type, selectors, band and date of each row named:
//   PRICE_SELECTOR_MALFORMED (a key or value not lower-case kebab); PRICE_SELECTOR_UNDECLARED (a row names a key the type does not declare); PRICE_SELECTOR_VALUE_UNDECLARED (a value the key does not allow);
//   PRICE_BAND_INVALID (FromAmount < 0, FromAmount >= ToAmount, or a ToAmount with no FromAmount); PRICE_FLOOR_INVALID (Minimum/Maximum on an Amount row, Minimum > Maximum, or a negative); PRICE_VALUE_NEGATIVE;
//   PRICE_FALLBACK_REQUIRED (whole list, per type: the earliest {} unbanded row is on or before the earliest selected or banded row — checked after ChangePrice and RemovePrice, and once per list after an import);
//   PRICE_ROW_TIE (per list, per type: two rows of different series with equal Specificity, selector sets that disagree on no shared key, and BandOverlaps — the fallback never ties — whatever their dates);
//   PRICE_ROW_NOT_FOUND (RemovePrice of a row that does not exist; null Selectors = the empty map = the fallback series); PRICE_SELECTOR_IN_USE (a key or value dropped while a row names it); PRICE_KIND_IN_USE (a Kind changed while rows exist);
//   PRICE_SELECTOR_MALFORMED also covers a declared selector with no values or a duplicate key, and runs before UNDECLARED. Retiring the fallback series while a selected row stands, or removing the last fallback, is PRICE_FALLBACK_REQUIRED. A Retired row's NewPrice is ignored and stored as 0.
//   ChangePrice of an existing series-and-date replaces it; EditPriceTypeCommand with Selectors = null leaves the selectors unchanged. The importer's refusal surfaces as the same DomainException, wrapped as its other refusals are, and writes nothing.
//   PriceList.Quote returns Price?; PriceList.ChangePrice(type, value, valueDate, selectors: Dictionary<string,string>? = null, fromAmount = null, toAmount = null, minimum = null, maximum = null, retired = false). YAML: a price type's `selectors: [{ key, allowedValues: [...] }]`; a price row's `selectors:` map, `fromAmount`, `toAmount`, `minimum`, `maximum`, `retired`. ListPrices' row field is `selectors`.
//   The two-argument IPriceProvider forms are default interface methods over the context forms, so every double keeps compiling and the forms cannot drift.

// src/LedgerTM.Pricing/PriceLists/Application/Settings/… — changed (D1, D2, D6)
public record ChangePriceCommand(PriceListId PriceListId, PriceTypeId PriceType, decimal NewPrice, DateOnly EffectiveDate,
    IReadOnlyDictionary<string, string>? Selectors = null, decimal? FromAmount = null, decimal? ToAmount = null, decimal? Minimum = null, decimal? Maximum = null, bool Retired = false) : ISettingsCommand<PriceSettings>;
public record RemovePriceCommand(PriceListId PriceListId, PriceTypeId PriceType, DateOnly EffectiveDate, IReadOnlyDictionary<string, string>? Selectors = null, decimal? FromAmount = null, decimal? ToAmount = null) : ISettingsCommand<PriceSettings>;
public record AddPriceTypeCommand(string Key, string Label, PriceKind Kind, IReadOnlyList<PriceSelectorInfo>? Selectors = null) : ISettingsCommand<PriceSettings>;
public record EditPriceTypeCommand(string Key, string Label, PriceKind Kind, bool IsActive, IReadOnlyList<PriceSelectorInfo>? Selectors = null) : ISettingsCommand<PriceSettings>;
// ListPrices (the inline endpoint) returns the new fields; its row id is {list}_{type}_{date}_{selectors sorted by key as k=v;…}_{from}-{to} with invariant, normalised decimals (F8).

// src/LedgerTM.Pricing/PricingPlans — changed (D3, F-1796)
public record PriceAdjustment(AdjustmentKind Kind, AdjustmentScope Scope, PriceTypeId? PriceType, decimal Value, DateOnly EffectiveDate, DateOnly? EndDate = null)
{   public bool Applies(PriceTypeId priceType, DateOnly valueDate) => (Scope == Global || PriceType == priceType) && EffectiveDate <= valueDate && (!EndDate.HasValue || EndDate >= valueDate); }
// PricingPlan.ApplyAdjustments(type, basePrice, valueDate): basePrice <= 0 → basePrice unchanged (never on a zero row). OverridePriceCommandValidator: NewPrice > 0; a Rate type's NewPrice above 1 → PRICE_OVERRIDE_RATE_ABOVE_ONE; PRICE_OVERRIDE_ON_WAIVED when the account's list has no positive row of the type, in any series, effective on EffectiveDate (a DomainException from the handler, which reads the list through the account's plan); an override dated before the type's first row is the same refusal.
// PriceProvider.Quote/TryQuote: the list's row, Value adjusted by the plan, Minimum/Maximum as the row has them, MinorUnit from the factory.

// src/LedgerTM.Scripting — changed (D3); Scripting references Infrastructure.Contracts only, so it takes two decimal functions and no quote type:
public sealed class ExpressionPriceProvider(Func<string, DateOnly, decimal?, decimal>? price, Func<string, DateOnly, decimal, decimal>? fee)   // a null function evaluates to 0 (today's "declared but unsupplied" contract); ScriptRuntime.PriceLookup takes the third argument
// price(type, valueDate) and price(type, valueDate, amount): BoundPriceLookup gains an optional Amount node; fee(type, valueDate, amount): BoundFeeLookup, gated by ScriptCatalog.HasPriceLookup (Infrastructure.Contracts, unchanged), arity 3 only; rate() keeps arity 2.
// The Accounts adapter: price = (t, d, a) => provider.GetPrice(t, d, new PriceContext(attributes, a)); fee = (t, d, a) => provider.Quote(t, d, new PriceContext(attributes, a)).FeeFor(a) — the miss throws UnpricedOnDateException from Pricing, as today.

// src/LedgerTM.Contracts/Accounts/ProcessExternalSourceCommands.cs — changed (D3, D4), bite 2
// ProcessCardPurchaseCommand and ProcessCardFeeCommand gain IReadOnlyDictionary<string, string>? PricingAttributes = null (defaulted; every existing caller compiles; System.Text.Json keys survive the outbox). The refund and dispute commands do not.

// src/LedgerTM.Accounts/Application/Workflows/WorkflowInterpreter.cs — changed (D3), bite 2
// WorkflowDispatchContext is unchanged: ExternalSourceDispatcher.DispatchAsync takes pricingAttributes, binds price()/fee() through AccountGuardContextBuilder and merges the "pricing." properties into the dispatch's Properties (shipped with ADR-842's merchant sale).
// The interpreter binds price/fee with the attributes and declares the eight card keys as `$` parameters, camel-cased ($scheme, $cardType, $channel, $entryMode, $crossBorder, $currencyConversion, $originalCurrency, $dcc), bound to "" where the bag has no value;
//   ExternalIntegrationsValidator lists the eight on the card sources (F10); AccountTypesSettingsValidator refuses an operation input of the same name (ACCOUNT_TYPE_INPUT_SHADOWS_PRICING_ATTRIBUTE). TransactionPosted.Properties gains "pricing.<key>" = StringValue (kebab key) on every leg of the dispatch.

// src/LedgerTM.Cards/Domain/CardTypesSettings.cs — changed (D4)
public string? Scheme { get; set; }   // VocabularyKey.Pattern; the validator requires it on save (CARD_TYPE_SCHEME_REQUIRED, a malformed one CARD_TYPE_SCHEME_INVALID); existing rows carry null until edited; left out of the bag when empty; seeded "visa"

// src/LedgerTM.Cards/Application/Pricing/CardPricingAttributes.cs — new (D4), Cards-internal
internal static class CardPricingAttributes
{
    public static IReadOnlyDictionary<string, string> For(CardType type, CardClearingItem line, CurrencyId accountCurrency, IsoCountryCode? domesticCountry);   // the eight keys
    public static IReadOnlyDictionary<string, string> For(CardType type);                                                                                       // scheme, card-type
}
// The clearing post passes line.FinalCurrency as accountCurrency, the currency the line posts in; the bag's `$` parameters are Accounts' CardPricing.With.
// channel: CardChannel in kebab-case (CardPresent → card-present), and "atm" also when line.Mcc is 6011; entry-mode likewise; cross-border: domesticCountry is null, or line.MerchantCountry does not parse as ISO 3166 alpha-2 (IsoCountryCode.TryParse), or equals it → no, else yes;
// currency-conversion: line.Dcc || line.OriginalCurrency == accountCurrency → no, else yes; original-currency: the ISO code lower-case; dcc: yes | no. Every value lower-case kebab.

// src/LedgerTM.Pricing/PriceLists/Application/Queries/GetPriceMatrix.cs — new (D6); GET /api/price/settings/price-lists/{listId}/price-matrix/{typeKey}, the endpoint and the query under one key
[PermissionKey("pricing.view-price-matrix")] public record GetPriceMatrixQuery(PriceListId PriceList, PriceTypeId PriceType) : IQuery<PriceMatrixView>;   // unknown list or type → 404 (PRICE_LIST_UNKNOWN / PRICE_TYPE_UNKNOWN); a type the list does not price → 200, no rows; a deactivated type reads
public sealed record PriceMatrixView(PriceTypeId Type, string Label, PriceKind Kind, CurrencyId Currency, int MinorUnit, IReadOnlyList<PriceSelectorInfo> Selectors, IReadOnlyList<PriceMatrixRow> Rows);   // the fallback series first, then by Specificity then selectors sorted by key; values by date
public sealed record PriceMatrixRow(IReadOnlyDictionary<string, string> Selectors, decimal? FromAmount, decimal? ToAmount, IReadOnlyList<PriceMatrixValue> Series);   // a series is selectors + band
public sealed record PriceMatrixValue(DateOnly EffectiveDate, decimal Value, decimal? Minimum, decimal? Maximum, bool Retired);

// Template (D5) — PriceSettings.yaml, retail price list:
//   priceTypes: card-currency-conversion-fee (Rate, selectors [currency-conversion: yes|no]), card-atm-fee (Rate, [cross-border: yes|no]); card-replacement-fee gains [card-type: debit|virtual-debit|single-account|credit]; card-cash-advance-fee gains [cross-border: yes|no]
//   prices: card-currency-conversion-fee {} 0, { currency-conversion: yes } 0.0275; card-atm-fee {} 0.02 min 10, { cross-border: no } 0.02 min 10, { cross-border: yes } 0.03 min 60;
//           card-replacement-fee {} 150 (as today), { card-type: credit } 0; card-cash-advance-fee {} 50 (as today), { cross-border: yes } 100
//   AccountTypesSettings.yaml, every type carrying cardPurchase: CardCurrencyConversionFeeCharged (Fee; on CreditCard Dr Fees, Dr Outstanding, costOfCreditCategory Fee, taxed as CashAdvanceFeeCharged); the deposit types: CardAtmFeeCharged (Fee);
//     card-purchase gains, after the purchase leg and before any payment allocation: whenCondition price('card-currency-conversion-fee', valueDate, $amount) > 0 → CardCurrencyConversionFeeCharged fee('card-currency-conversion-fee', valueDate, $amount);
//                          deposit types only: whenCondition $channel == 'atm' → CardAtmFeeCharged fee('card-atm-fee', valueDate, $amount)   (the credit card's cash-advance row stands)
//   CardTypesSettings.yaml: scheme: visa on every type, ADR-838's credit type included (the demo customer's credit card is of that type)

Bites

Bite Description Acceptance criterion Status
1 The attribute-banded price: Price selectors, band, floor, cap and retire, PriceTypeEntry selectors with values, PriceContext and PriceQuote with its fee, the lookup with specificity and the series rule, the settings refusals on the aggregate, the dated override (F-1796) and the waived-row refusal, the YAML round-trip, price(type, valueDate, amount) and fee() a price is chosen by its selectors and its band, dated; an undeclared selector, a floor on an amount row and a tie are refused; an override applies from its date and never to a waived row Done
2 The card attributes: CardType.Scheme, the eight attributes on every purchase posting, the $ parameters and pricing. properties, the four card fees priced by attribute in the retail template, the purchase workflow’s currency-conversion and ATM fee rows, the fixture a cross-currency purchase charges the conversion fee and a domestic one nothing; an ATM withdrawal charges the fee cross-border and at home; a replaced credit card is charged nothing and a debit card 150 without a code change; a customer’s override applies to the row chosen Done
3 The matrix on the price list page, the override dialog’s kind, the card types’ scheme on their settings page, the probe, the guide articles, the register row a type’s rows read as a matrix and a new row is entered by its selectors Done

Scenarios

Feature: a price is chosen by the attributes of the thing being priced

# Bite 1
Scenario: a price is chosen by its selectors and its band, dated
  Given a price type declaring the selectors region (home, abroad) and channel (atm, online), with rows: no selectors 10; region abroad 60; region abroad and channel atm 75 from 1 March; region home for amounts 0 to 2 000, 8
  When an abroad ATM price is read on 15 March, an abroad online price, a home price for 500, a home price for 2 000, a home price with no amount, and an abroad ATM price on 1 February
  Then they are 75, 60, 8, 10, 10 and 60
  And the most specific matching row wins, a band counts toward specificity, the band includes its bottom and excludes its top, a banded row needs an amount, and a row dated after the value date is not seen
  And a rate row of 2% with a floor of 10 and a cap of 100 quotes 10 on 200, 50.77 on 2 538.25, and 100 on 10 000, half-up to the cent, and quotes 0 on an amount of 0 or when the rate is 0
  And a three-argument read of an unbanded type equals the two-argument read, a fee read of an amount row is its value on any amount above zero, and a series retired from 1 April falls through to the next row from that date
  # Seen at: route:/settings/price-lists

# Bite 1
Scenario: an undeclared selector, a floor on an amount row and a tie are refused
  Given a price type declaring the selector region with the values home and abroad
  When a row naming the selector channel is saved, a row with region abroad is saved twice on one date, and the type is given a second selector with rows region abroad and channel atm that both match one context
  Then the first is refused naming the selector, the second replaces the first as an edit, and the third is refused as a tie naming both rows
  And a row with the value Abroad is refused as malformed and a row with the value overseas as undeclared, a selected row on a list with no fallback row of its type is refused, a row of 0 is accepted, and a floor on an amount row is refused
  And a dated change in one series is not a tie, bands 0 to 1 000 and 1 000 upward are not a tie, removing a selected row leaves the fallback, and dropping a selector key or value a row still names is refused
  And the rows survive the template's export and import with their selectors, bands, floors, caps and retirements, a card-type key included
  # Seen at: route:/settings/price-lists

# Bite 1
Scenario: an override applies from its date and never to a waived row
  Given an account whose price list prices a fee at 100 and waives another at 0
  When an override of 50 on the first is dated the 10th, and an override on the waived fee is attempted
  Then a read on the 9th is 100 and on the 10th is 50, and the override on the waived fee is refused
  And a percentage discount leaves the waived fee at 0
  # Seen at: route:/accounts/{id}

# Bite 2
Scenario: a cross-currency purchase charges the conversion fee and a domestic one nothing
  Given the demo customer's credit card and a currency-conversion fee of 2.75% where the currency was converted
  When a 100 USD purchase clears billed 1 850.00, a 500 domestic purchase clears, and a 100 USD purchase billed in rand by the merchant clears
  Then the first posts a currency-conversion fee of 50.88 and the other two post no fee
  And the fee posting records that it was priced for a converted currency, and a purchase posted with no attributes at all posts and charges nothing
  # Seen at: route:/accounts/{id}

# Bite 2
Scenario: an ATM withdrawal charges the fee cross-border and at home
  Given a debit card on a current account, a home ATM fee of 2% with a floor of 10, and a cross-border ATM fee of 3% with a floor of 60
  When 200 is withdrawn at home, 3 000 at home, and 90 GBP billed 2 000 abroad
  Then the ATM fees are 10, 60 and 60, and the withdrawal abroad also pays the currency-conversion fee of 55
  And the same withdrawal abroad on the credit card pays the cross-border cash-advance fee of 100 and the conversion fee, and no ATM fee
  And a withdrawal whose line names merchant category 6011 at a card-present terminal charges the ATM fee, and one whose merchant country the processor sent malformed charges the home fee
  # Seen at: route:/accounts/{id}

# Bite 2
Scenario: a replaced credit card is charged nothing and a debit card 150 without a code change
  Given a replacement fee of 150 as the fallback and 0 for the credit card type
  When a credit card and a debit card are each reported stolen and replaced
  Then the credit card's account is charged nothing and the debit card's 150
  # Seen at: route:/accounts/{id}

# Bite 2
Scenario: a customer's override applies to the row chosen
  Given a customer whose pricing plan overrides the currency-conversion fee to 1% from the 3rd
  When a 100 USD purchase dated the 1st clears on the 5th billed 1 850.00, another dated the 4th clears billed 1 850.00, and a 500 domestic purchase clears
  Then the first pays the list rate, the second 18.50, and the domestic purchase still charges nothing
  # Seen at: route:/accounts/{id}

# Bite 3
Scenario: a type's rows read as a matrix and a new row is entered by its selectors
  Given the retail price list's ATM fee rows
  When an operator adds the selector channel with its values to the type and a row for cross-border and ATM
  Then the type reads as a matrix with the fallback first, a column per selector and the band, and the new row sits in it with its value, floor and cap
  # Seen at: route:/settings/price-lists

Scenario → test

Scenario Bite Project Class Method Probe
a price is chosen by its selectors and its band, dated 1 LedgerTM.Tests.Unit AttributeBandedPriceTests a_price_is_chosen_by_its_selectors_and_its_band_dated —
an undeclared selector, a floor on an amount row and a tie are refused 1 LedgerTM.Tests.Component PriceSelectorSettingsTests an_undeclared_selector_a_floor_on_an_amount_row_and_a_tie_are_refused — refusal
an override applies from its date and never to a waived row 1 LedgerTM.Tests.Component PriceSelectorSettingsTests an_override_applies_from_its_date_and_never_to_a_waived_row —
a cross-currency purchase charges the conversion fee and a domestic one nothing 2 LedgerTM.Tests.Component CardFeePricingTests a_cross_currency_purchase_charges_the_conversion_fee_and_a_domestic_one_nothing adr-841-server-probe.ts
an ATM withdrawal charges the fee cross-border and at home 2 LedgerTM.Tests.Component CardFeePricingTests an_atm_withdrawal_charges_the_fee_cross_border_and_at_home adr-841-server-probe.ts
a replaced credit card is charged nothing and a debit card 150 without a code change 2 LedgerTM.Tests.Component CardFeePricingTests a_replaced_credit_card_is_charged_nothing_and_a_debit_card_150_without_a_code_change adr-841-server-probe.ts
a customer’s override applies to the row chosen 2 LedgerTM.Tests.Component CardFeePricingTests a_customers_override_applies_to_the_row_chosen —
a type’s rows read as a matrix and a new row is entered by its selectors 3 LedgerTM.Tests.Component PriceMatrixViewTests a_types_rows_read_as_a_matrix_and_a_new_row_is_entered_by_its_selectors adr-841-server-probe.ts

The bite 1 unit test drives PriceList.Quote and PriceQuote.FeeFor directly, with one ExpressionEvaluator line per scripting arity. Reachability: the bite 3 query is dispatched by PriceMatrixViewTests; the settings commands by PriceSelectorSettingsTests; AccountValuationPriceLookupTests guards the adapter.

UI-surface sweep

Swept src/ui-apps/bank/src for ChangePrice, AddPriceType, EditPriceType, priceType, priceLists, price-lists, PriceSettings, selectors, fromAmount:

Footprint

Feature projects touched: 7 — LedgerTM.Accounts, LedgerTM.Cards, LedgerTM.Contracts, LedgerTM.Pricing, LedgerTM.Scripting, LedgerTM.Seeding.Provisioning, ui-apps

Contracts types: 28 named, 20 changed by this ADR

Files reading each changed type: 20 types

Domain events touched: 0 Aggregates touched: 0

Methods at CRAP 30+ in changed files: 7 (unit coverage at main 413bc4524)

Warnings

At land: 21 files touched, 91 predicted, 7 unplanned. LedgerTM.Tests.Architecture/ShapeGate/stored-shapes.tsv, LedgerTM.Tests.Unit/Seeding/preset-snapshots.txt, src/LedgerTM.Cards/Application/Commands/ChargeCardFee.cs, src/LedgerTM.Cards/Application/DayEnd/PostCardClearingBatch.cs, src/LedgerTM.Cards/Application/Settings/AmendCardTypes.cs, src/LedgerTM.Seeding.Provisioning/tenant-templates/countries/gb/retail-bank/PriceSettings.yaml, src/LedgerTM.Seeding.Provisioning/tenant-templates/countries/za/retail-bank/PriceSettings.yaml

Land batches

Two lands, with a recorded reason: batch A, bites 1 and 3 — the shape, the lookup, fee() and the matrix are demonstrable alone and are the contract the merchant settlement ADR builds its merchant pricing on; batch B, bite 2 — after ADR-836, ADR-838, ADR-839 and ADR-840 land (F1), since it edits their files. reseed: true on both.

Notes

Landing notes