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-844 — Implementation Plan

Findings for the ADR

Files touched

Bite 1 — contracts, settings and validation

Bite 2 — the oracle

Bite 3 — the lapsed card

Bite 4 — the corporate administrator

Bite 5 — the screens, the guide, the probe

Prior art

Unchanged since the grill, apart from F1’s CardHold.Channel and the supporting CorporateCardView, CardLimitUse read records, which carry no decision.

Interfaces

// LedgerTM.Contracts/Cards/CardSpendControls.cs — new (D1–D4)
public readonly record struct MerchantCategoryGroupId(string Value) : IStrongId<MerchantCategoryGroupId> { public static MerchantCategoryGroupId FromKey(string key) => StrongId.SlugFor<MerchantCategoryGroupId>(key); … }
public enum CardSpendPeriod { Transaction, Day, Month, Life }
public enum CardSpendChannel { Atm, InStore, Online }   // one classifier, CardSpendChannels.Classify(CardAuthorisationRequest), used by the switch check and the stamp: ATM; card present; card not present
public sealed record CardSpendScope(CardSpendChannel? Channel = null, MerchantCategoryGroupId? CategoryGroup = null) { public static CardSpendScope AllSpend { get; } = new(); }   // at most one set
public sealed record CardSpendLimit(CardSpendScope Scope, CardSpendPeriod Period, decimal? Amount, int? Count);   // billing currency
public enum CardRuleMode { AllowOnly, Block }
public sealed record CardCategoryRule(CardRuleMode Mode, IReadOnlyList<MerchantCategoryGroupId> Groups);
public sealed record CardCountryRule(CardRuleMode Mode, IReadOnlyList<IsoCountryCode> Countries);
public sealed record CardControlBounds(IReadOnlyList<CardSpendLimit> MaxLimits, IReadOnlyList<MerchantCategoryGroupId> AlwaysBlocked);
public enum CardActor { Bank, ClientChannel }   // stored as a string; bank handlers pass Bank, channel handlers ClientChannel
public sealed record CardLimitUse(CardSpendScope Scope, CardSpendPeriod Period, CardSpendLimit? Limit, CardSpendLimit? Bound, decimal Spent, int Count, DateOnly PeriodFrom);
// one row per scope and period where the card's limit or the type's bound is set; Bound = the tightest type bound capping the row at the oracle (its own, a longer period of its scope, or all spend at its period or longer), shown when lower than the card's limit or the card has none; PeriodFrom: trading date (Transaction and Day), month start, issue date; a Transaction row reports Spent 0, Count 0
public sealed record CardAuthorisationLine(CardAuthorisationId Id, DateTimeOffset ReceivedAt, decimal Amount, string MerchantName, CardReceiptOutcome Outcome, CardDeclineReason? Reason, string? DeclinedRule);

// LedgerTM.Contracts/Cards/CardCredential.cs — changed (D1, D3)
public sealed record CardControls(bool OnlineAllowed, bool InStoreAllowed, bool InStoreAbroadAllowed, bool AtmAllowed, bool ContactlessAllowed,
    IReadOnlyList<CardSpendLimit> Limits, CardCategoryRule? Categories = null, CardCountryRule? Countries = null);
// CARD_CONTROLS_INVALID: an allow-only rule with an empty list; amount < 0; count < 1; neither amount nor count; scope with both members; a group id the tenant does not define; scope+period twice; a count on Transaction;
//   within one scope Transaction <= Day <= Month <= Life for amounts and for counts. Cross-scope combinations are accepted and bind at the oracle.
// CARD_CONTROLS_OUT_OF_BOUNDS, only for what an edit adds or raises: a limit above any type bound that would cap it at the oracle (its scope's bound for its period or a longer one, or an
//   all-spend bound for its period or a longer one); an allow-only category rule gaining a group the type always blocks. Removing a limit is never raising. AmendCardTypes validates
//   DefaultControls against Bounds the same way, and refuses a type IssuableFromChannel with no all-spend month bound carrying an amount (CARD_TYPE_BOUNDS_INVALID). A type's own faults — duplicate scope and period, negative,
//   a count on a Transaction bound, a group the tenant does not define in Bounds, AlwaysBlocked or DefaultControls — are CARD_TYPE_BOUNDS_INVALID. "In use" = any card not Closed.

// LedgerTM.Contracts/Cards/CardAuthorisation.cs, CardReceipts.cs, CardSummary.cs, CardHold.cs — changed (D1, D5, D6, D7)
// CardDeclineReason gains MerchantCategoryNotAllowed (57), FrequencyExceeded (65), CardLapsed (54).
// CardAuthorisationDecision gains trailing string? DeclinedRule = null; CardAuthorisationReceipt gains trailing string? DeclinedRule = null; the door copies it.
// CardSummary gains DateOnly? ValidUntil and CardActor? SuspendedBy. CardHold gains CardSpendChannel Channel and List<MerchantCategoryGroupId> CategoryGroups, copied from the event.
// CardProcessorReceiptRow (ListCardProcessorReceipts) gains string? DeclinedRule.

// LedgerTM.Cards/Domain/CardTypesSettings.cs, MerchantCategoryGroupsSettings.cs — changed / new (D2, D4)
public sealed class CardType { …; public CardControlBounds Bounds { get; set; } = new([], []); public bool IssuableFromChannel { get; set; } }
public class MerchantCategoryGroupsSettings : Settings { public List<MerchantCategoryGroup> Groups { get; set; } = []; }
public sealed class MerchantCategoryGroup { public MerchantCategoryGroupId Id { get => Regex.IsMatch(Key, VocabularyKey.Pattern) ? MerchantCategoryGroupId.FromKey(Key) : default; init { } } public string Key { get; set; } = ""; public string Label { get; set; } = ""; public List<MerchantCategoryRange> Ranges { get; set; } = []; }
public sealed record MerchantCategoryRange(MerchantCategoryCode From, MerchantCategoryCode To);   // inclusive
[PermissionKey("cards.amend-merchant-category-groups")] public record AmendMerchantCategoryGroupsCommand(IReadOnlyList<MerchantCategoryGroup> Groups) : ISettingsCommand<MerchantCategoryGroupsSettings>;   // POST /api/settings/merchant-category-groups, whole list
[PermissionKey("cards.view-merchant-category-groups")] public record GetMerchantCategoryGroupsQuery : IQuery<IReadOnlyList<MerchantCategoryGroup>>;   // GET same route
// The key is the identity: a changed key is a removed group and an added one. MERCHANT_CATEGORY_GROUP_IN_USE (async validator, only when a key is removed: the card types document through
//   ISettingsProvider — Bounds and DefaultControls — then open CardSummary documents prefiltered by MatchesSql on the group id and confirmed in memory; closed cards do not count),
//   MERCHANT_CATEGORY_GROUP_KEY_INVALID (naming the key), MERCHANT_CATEGORY_GROUP_DUPLICATE, MERCHANT_CATEGORY_GROUP_EMPTY, MERCHANT_CATEGORY_RANGE_INVERTED; keys VocabularyKey.Pattern. The handler stays void Handle(cmd, settings).
// Seeded: cash 6010–6011; quasi-cash 4829, 6050–6051, 6540; gambling 7800–7802, 7995; airlines 3000–3350, 4511; lodging 3501–3999, 7011; car-hire 3351–3500, 7512; fuel 5541–5542, 5983;
//   dining 5811–5814; groceries 5411, 5422, 5451, 5462, 5499. PackageModel gains MerchantCategoryGroupEntry; CardTypeEntry gains Bounds, IssuableFromChannel, DefaultControls.

// LedgerTM.Cards/Domain/Card.cs, Card.Events.cs — changed (D1, D5, D6)
// Issue(…, DateOnly? validUntil, …); CardIssued gains trailing DateOnly? ValidUntil = null; a ValidUntil before the issue date → CARD_VALID_UNTIL_IN_PAST.
public void SetValidUntil(DateOnly? validUntil, DateOnly on);   // CardVerb.SetValidUntil: Ordered, Active, Suspended (a Live verb, as SetControls); otherwise CARD_STATUS_FORBIDS; before on → CARD_VALID_UNTIL_IN_PAST; null clears
//   → [MessageIdentity("cards.card-valid-until-set")] CardValidUntilSet(CardId Id, DateOnly? ValidUntil, DateOnly On)
public void Suspend(string reason, CardActor by, DateOnly on);  // CardSuspended(CardId Id, string Reason, CardActor By, DateOnly On)
public void Reinstate(CardActor by, DateOnly on);               // ClientChannel on a Bank suspension → CARD_SUSPENDED_BY_BANK; the bank may lift either; SuspendedBy cleared
// PlaceHold — ADR-836's signature on its branch, (authorisation, account, amount, currency, mcc, merchantName, on, expiresOn), plus CardSpendChannel channel and
//   IReadOnlyList<MerchantCategoryGroupId> categoryGroups last and required; CardHoldPlaced likewise gains Channel and CategoryGroups last, no defaults.
// IssueCardCommand gains trailing DateOnly? ValidUntil = null.
[PermissionKey("cards.set-card-valid-until")] public record SetCardValidUntilCommand(CardId Id, DateOnly? ValidUntil) : ICommand { Target ("Card", Id) }   // POST /api/cards/{id}/valid-until

// LedgerTM.Cards/Domain/CardSpend.cs — new (bite 2): the one spend computation
public static class CardSpend { public static IReadOnlyList<CardLimitUse> Use(CardControls controls, CardControlBounds bounds, IReadOnlyList<CardHold> holds, DateOnly tradingDate, DateOnly issuedOn); }
// Σ (OriginalAmount − Reversed) over holds placed in the period whose stamp matches the scope; count = those not fully reversed. The decider, GetCardLimitUse and CorporateCardView call it.

// LedgerTM.Cards/Application/Doors/CardAuthorisationDecider.cs — changed (D3)
// Spend = Σ (CardHold.OriginalAmount — the approved billing amount — less Reversed); a limit breach is final (no partial approval up to the remainder); a bound equal to the card's
//   limit names the card's limit (a bound binds only when strictly lower); contactless with both switches off names the in-store switch; an empty country on a card-present tap is
//   foreign to the domestic check (ADR-836); the authorisations read breaks ties by receipt id.
// Unit of work: open the write session, FetchForWriting<Card>, then load that card's CardHold documents in the same session (Where(h => h.Card == id), PlacedOn >= the earliest period start
//   unless a life limit or bound applies), decide, append; a ConcurrencyException reruns once (RetryingOnce) against fresh spend.
// Order: token, status, valid-until (trading date > ValidUntil → CardLapsed), credential, currency, channel, type's AlwaysBlocked, card's category rule, domestic-country check (skipped under an AllowOnly
//   country rule), card's country rule, then limits by period (Transaction, Day, Month, Life), within a period by scope (all spend, channel, category groups in the tenant's list order), amount
//   before count; the type's bounds bind as limits, the effective limit the lower; funding. A merchant country "" is absent; a category in no group and an absent country pass Block, fail AllowOnly.
// DeclinedRule, invariant culture, ASCII space as thousands separator, '.' decimal, group by key: "{period}, {scope}, {amount}" or "{period}, {scope}, count {n}", with ", the card type's bound"
//   when the bound binds; period: transaction | day | month | life; scope: all spend | channel atm|in store|online | category {key}. Others: "category {key}, blocked by the card type",
//   "category {key}, blocked", "category {mcc}, not in the allow list", "country {cc}, blocked", "country {cc|unknown}, not in the allow list", "in store abroad, not allowed",
//   "channel {online|in store|atm|contactless}, switched off", "valid until {yyyy-MM-dd}, lapsed". Every other decline carries null.
// Worked example: step 4 "transaction, all spend, 2 000.00"; 5 "category gambling, blocked by the card type"; 7 "country US, not in the allow list"; 9 "life, all spend, count 1".

// LedgerTM.Cards/Application/Queries/GetCardLimitUse.cs, ListCardAuthorisations.cs — new (D6, D7; bite 2)
[PermissionKey("cards.view-card-limit-use")] public record GetCardLimitUseQuery(CardId Id) : IQuery<IReadOnlyList<CardLimitUse>>;   // GET /api/cards/{id}/limit-use
[PermissionKey("cards.list-card-authorisations")] public record ListCardAuthorisationsQuery(CardId Id, int Take = 50) : IQuery<IReadOnlyList<CardAuthorisationLine>>;   // GET /api/cards/{id}/authorisations; resolved through the card's tokens, newest first

// LedgerTM.Cards/Application/DayEnd/CloseLapsedCardsStep.cs — new (D5)
public sealed class CloseLapsedCardsStep(IMessageBus bus) : IDayEndStep   // "cards.close-lapsed-cards", 46, PreIncrement, NonCritical, FeatureKey null; after clearing (44) and expiry (45); [ReplaySafe]
[PermissionKey("cards.close-lapsed-cards")] public record CloseLapsedCardsCommand(TenantId Tenant, DateOnly TradingDate) : ICommand, ISystemCommand { Target ("Cards", Tenant) }
// ValidUntil < TradingDate and no open hold → Close("valid-until passed"), mirrored to the processor; the day-end whose clearing or expiry frees the last hold closes it.

// LedgerTM.Cards/Application/Corporate/CorporateCardCommands.cs — new (D6); bus only, no endpoints (as every ADR-695 channel operation); each IChannelOperation, ICommand
[PermissionKey("cards.issue-corporate-card")] public record IssueCorporateCardCommand(CardId Id, AccountId FundingAccount, CardholderReference Cardholder, CardTypeId Type, string DisplayName, CardCredentialKind FirstCredential, CardControls Controls, DateOnly? ValidUntil);   // Target ("Account", FundingAccount); returns CardId
[PermissionKey("cards.set-corporate-card-controls")] public record SetCorporateCardControlsCommand(CardId Id, AccountId FundingAccount, CardControls Controls);   // whole-list replace
[PermissionKey("cards.set-corporate-card-valid-until")] public record SetCorporateCardValidUntilCommand(CardId Id, AccountId FundingAccount, DateOnly? ValidUntil);   // null clears
[PermissionKey("cards.activate-corporate-card")] public record ActivateCorporateCardCommand(CardId Id, AccountId FundingAccount);
[PermissionKey("cards.suspend-corporate-card")] public record SuspendCorporateCardCommand(CardId Id, AccountId FundingAccount, string Reason) : INotFourEyesGated;   // a stolen card is never held for approval
[PermissionKey("cards.reinstate-corporate-card")] public record ReinstateCorporateCardCommand(CardId Id, AccountId FundingAccount);
[PermissionKey("cards.close-corporate-card")] public record CloseCorporateCardCommand(CardId Id, AccountId FundingAccount, string Reason);
[PermissionKey("cards.reveal-corporate-card")] public record RevealCorporateCardCommand(CardId Id, AccountId FundingAccount) : INotFourEyesGated;   // CardRevealKind.CardDetails; non-virtual → CARD_REVEAL_VIRTUAL_ONLY
// All but issue Target ("Card", Id). ResolveChannelScope: Asserts([FundingAccount], amount) — issue and set: the card's own monthly exposure = min(all-spend Month, all-spend Day × 31, all-spend Life);
//   controls with none of the three → CORPORATE_CARD_EXPOSURE_UNBOUNDED (validator); the rest: null. The command's own figure is never below the effective one, so an error refuses, never leaks.
// Handlers: IChannelUserDirectory.IsActingOnChannelAsync false → CORPORATE_CARD_CHANNEL_ONLY; the owner is the funding account's single owner (IAccountOwningPartiesReader; not exactly one → refused);
//   the type IssuableFromChannel (CARD_TYPE_NOT_CHANNEL_ISSUABLE); FundingAccount is the card's whole funding rule (CORPORATE_CARD_ACCOUNT_MISMATCH); the card's verbs directly with
//   CardActor.ClientChannel, never the bank's commands; every change mirrored to the processor as the bank verbs do.
// cards.corporate binds every command but suspend and close, which are run-down (ADR-363 D3); unlicensed, both reads are refused. A card of a type not issuable from the channel →
//   CARD_TYPE_NOT_CHANNEL_ISSUABLE on every operation; a count-only month is unbounded; the asserted account is ScopedAccount.Owned; reveal returns CardRevealSession.

// LedgerTM.Cards/Application/Corporate/CorporateCardQueries.cs — new (D6); IChannelOperation, Asserts([FundingAccount], null); each checks cards.corporate itself
public sealed record CorporateCardView(CardId Id, string DisplayName, CardholderReference Cardholder, CardStatus Status, CardActor? SuspendedBy, AccountId FundingAccount, CardControls Controls, DateOnly? ValidUntil,
    IReadOnlyList<CardLimitUse> Use, IReadOnlyList<CardAuthorisationLine> RecentAuthorisations /* last 20 */);
[PermissionKey("cards.list-corporate-cards")] public record ListCorporateCardsQuery(AccountId FundingAccount) : IQuery<IReadOnlyList<CorporateCardView>>;
[PermissionKey("cards.view-corporate-card")] public record GetCorporateCardQuery(CardId Id, AccountId FundingAccount) : IQuery<CorporateCardView?>;
// An account outside the entitlement is refused by the gate (NotEntitled); a card outside the account or not of an IssuableFromChannel type reads empty or null. ChannelCatalog: ten rows by key.

Bites

Bite Description Acceptance criterion Status
1 Contracts and settings: the limit, rule and bounds types, the controls’ new shape and its validation everywhere it is built, category groups as settings with their seeded rows through the package model, the decline reasons, the receipt’s rule, valid-until, who suspended a card’s controls are set and refused by the limit rules and the type’s bounds; the bank maintains its category groups Done
2 The oracle and its reads: the card locked before spend is read, one spend computation, the total order, category and country rules, limits by scope and period with amount and count, the type’s bounds and always-blocked groups, the hold’s group stamp, CardLapsed, the declining rule, limit use and the card’s authorisations each rule declines with its reason and names itself; a clerk reads a card’s limit use and its authorisations Done
3 The lapsed card: the valid-until verb and the day-end close a virtual card lapses and closes once its holds are gone Done
4 The corporate administrator: the eight channel operations, the two reads, the monthly exposure against the entitlement ceiling, who suspended, cards.corporate an administrator issues and caps a staff card within the entitlement’s ceiling Done
5 The screens and the guide: the controls editor, the category groups page, the card type’s bounds, the declining rule on the authorisation list a clerk sets a card’s limits and rules and reads why a tap was declined Done

Scenarios

Feature: a bank and a corporate's administrator control where and how much a card may spend

# Bite 1
Scenario: a card's controls are set and refused by the limit rules and the type's bounds
  Given a card on a type bounding a month at 50 000.00
  When a clerk sets 2 000.00 a transaction, 5 000.00 a day and 20 000.00 a month, and a cash limit of 2 000.00 a day with a count of 3
  Then the card reads those limits
  And a day limit above the month's, two limits on one scope and period, a count on a transaction limit, and a month of 60 000.00 are each refused
  # Seen at: route:/cards/{id}

# Bite 1
Scenario: the bank maintains its category groups
  Given the template's nine groups and a card blocking cash
  When a clerk adds a group for toll roads, removes an unused group, and tries to remove cash
  Then the groups read back with the new one and without the unused one, and removing cash is refused while the card names it
  # Seen at: route:/settings/merchant-category-groups

# Bite 2
Scenario: each rule declines with its reason and names itself
  Given the worked example's card for J SMITH
  When the worked example's taps arrive
  Then each is approved or declined with the worked example's reason and declining rule
  # Seen at: route:/cards/{id}

# Bite 2
Scenario: a clerk reads a card's limit use and its authorisations
  Given the worked example's card after its taps on 2026-11-02
  When a clerk reads the card's limit use and its authorisations
  Then the day and month read 2 300.00 spent over 2 taps against 5 000.00 and 20 000.00, and each declined tap reads its reason and rule
  # Seen at: route:/cards/{id}

# Bite 3
Scenario: a virtual card lapses and closes once its holds are gone
  Given the worked example's virtual supplier card with an open hold of 11 500.00
  When a tap arrives on 2026-12-01, and day-end runs before and after the hold clears
  Then the tap is declined as lapsed, the card stays open while the hold is open, and closes in the day-end that clears it
  And a clerk moving its valid-until later before it closes revives it
  # Seen at: route:/cards/{id}

# Bite 4
Scenario: an administrator issues and caps a staff card within the entitlement's ceiling
  Given Thandi's entitlement with a ceiling of 25 000.00 over the pooled account
  When she issues J SMITH a card, then raises its month to 30 000.00, then suspends it
  Then the card is issued and suspended, the raise is refused, and a card funded by another account cannot be touched
  And a card the bank suspended cannot be reinstated by her, and she can open the hosted view of a virtual card's details
  And she activates a plastic card on arrival, moves a card's valid-until, closes a card, and reads her cards with each limit's use and recent declines
  # Seen at: route:/cards/{id}

# Bite 5
Scenario: a clerk sets a card's limits and rules and reads why a tap was declined
  Given the worked example's card
  When a clerk opens it, edits its limits and category rule, and opens a declined authorisation
  Then the editor shows each limit with its use this period, and the authorisation shows its declining rule
  # Seen at: route:/cards/{id}

Scenario → test

Scenario Bite Project Class Method Probe
a card’s controls are set and refused by the limit rules and the type’s bounds 1 LedgerTM.Tests.Component CardSpendControlsSettingsTests a_cards_controls_are_set_and_refused_by_the_limit_rules_and_the_types_bounds adr-844-server-probe.ts
the bank maintains its category groups 1 LedgerTM.Tests.Component CardSpendControlsSettingsTests the_bank_maintains_its_category_groups_and_cannot_remove_one_in_use adr-844-server-probe.ts
each rule declines with its reason and names itself 2 LedgerTM.Tests.Component CardSpendControlsDecisionTests each_rule_declines_with_its_reason_and_names_itself adr-844-server-probe.ts
a clerk reads a card’s limit use and its authorisations 2 LedgerTM.Tests.Component CardSpendControlsDecisionTests a_clerk_reads_a_cards_limit_use_and_its_authorisations adr-844-server-probe.ts
a virtual card lapses and closes once its holds are gone 3 LedgerTM.Tests.Component CardLapseTests a_virtual_card_lapses_and_closes_once_its_holds_are_gone adr-844-server-probe.ts
an administrator issues and caps a staff card within the entitlement’s ceiling 4 LedgerTM.Tests.Component CorporateCardChannelTests an_administrator_issues_and_caps_a_staff_card_within_the_entitlements_ceiling adr-844-server-probe.ts
a clerk sets a card’s limits and rules and reads why a tap was declined 5 LedgerTM.Tests.Component CardSpendControlsReadTests the_card_and_authorisation_reads_carry_each_limits_use_and_the_declining_rule adr-844-server-probe.ts

UI-surface sweep

Swept src/ui-apps/bank/src for CardControls, perTransactionCeiling, dailyCeiling, monthlyCeiling, controls, card-types, cards., suspend:

Footprint

Feature projects touched: 8 — LedgerTM.Cards, LedgerTM.ClientChannel, LedgerTM.Contracts, LedgerTM.Hosting, LedgerTM.Infrastructure.Contracts, LedgerTM.Operations, LedgerTM.Seeding.Provisioning, ui-apps

Contracts types: 48 named, 41 changed by this ADR

Files reading each changed type: 41 types

Domain events touched: 1 — CardValidUntilSet Aggregates touched: 1

Methods at CRAP 30+ in changed files: 0 (unit coverage at main f43a82cc0) Permission keys to add: 18 — activate-corporate-card, amend-merchant-category-groups, close-corporate-card, close-lapsed-cards, i, i-system, issue-corporate-card, reinstate-corporate-card, reveal-corporate-card, set-card-valid-until, set-corporate-card-controls, set-corporate-card-valid-until, suspend-corporate-card, get-card-limit-use-query, get-corporate-card-query, get-merchant-category-groups-query, list-card-authorisations-query, list-corporate-cards-query

Warnings

At land: 87 files touched, 81 predicted, 38 unplanned. LedgerTM.Testing.Infrastructure/Cards/CardTestLimits.cs, LedgerTM.Tests.Architecture/CardVocabularyTests.cs, LedgerTM.Tests.Architecture/TenantSettingsFolderTests.cs, LedgerTM.Tests.Architecture/UnitOfWorkTests.cs, LedgerTM.Tests.Architecture/commands-whose-caller-reads-the-record.txt, LedgerTM.Tests.Architecture/contracts-shared-surface-baseline.txt, LedgerTM.Tests.Component/Accounts/AccountsComponentFixture.cs, LedgerTM.Tests.Component/Cards/CardAuthorisationRaceTests.cs, LedgerTM.Tests.Component/Cards/CardControlsAndFundingTests.cs, LedgerTM.Tests.Component/Cards/CardOperationsTests.cs, LedgerTM.Tests.Component/Cards/IssueCardTests.cs, LedgerTM.Tests.Unit/Seeding/preset-snapshots.txt, src/LedgerTM.Cards/Application/Commands/CardHandling.cs, src/LedgerTM.Cards/Application/Commands/MirrorCardToProcessor.cs, src/LedgerTM.Cards/Application/Commands/SetCardControls.cs, src/LedgerTM.Cards/Application/Commands/SuspendCard.cs, src/LedgerTM.Cards/Application/Corporate/CorporateCardHandlers.cs, src/LedgerTM.Cards/Application/Doors/DecideCardAuthorisation.cs, src/LedgerTM.Cards/Application/Processor/PaymentologyInboundMapper.cs, src/LedgerTM.Cards/Application/Queries/ListCardAuthorisations.cs, src/LedgerTM.Cards/Application/Queries/ListCardProcessorReceipts.cs, src/LedgerTM.Cards/Domain/Card.Events.cs, src/LedgerTM.Seeding.Provisioning/CardSpendControlsPackage.cs, src/LedgerTM.Seeding.Provisioning/PackageExporter.cs, src/LedgerTM.Seeding.Provisioning/PackageImporter.cs, src/LedgerTM.Seeding.Provisioning/tenant-templates/packages/retail-bank/CardTypesSettings.yaml, src/ui-apps/bank/src/__tests__/standard-table-rowhref-guard.test.ts, src/ui-apps/bank/src/app.tsx, src/ui-apps/bank/src/features/cards/card-controls-editor.tsx, src/ui-apps/bank/src/features/cards/card-issue-dialog.tsx, src/ui-apps/bank/src/features/cards/card-operation-dialogs.tsx, src/ui-apps/bank/src/features/cards/hooks/cards.ts, src/ui-apps/bank/src/features/cards/hooks/merchant-category-groups.ts, src/ui-apps/bank/src/features/entity-types/merchant-category-groups.tsx, src/ui-apps/bank/src/features/operations/dispatched-homes.ts, src/ui-apps/bank/src/features/settings/category-taxonomy.ts, src/ui-apps/bank/src/features/settings/settings-class-map.ts, src/ui-apps/bank/src/lib/api.ts

Land batches

One land, the whole ADR; reseed: true (the controls’ shape). It starts after ADR-836 lands.

Notes

Landing notes