This is the session in which our founder briefed the AI and the cards proposal and decision records were written. His messages are verbatim; the AI’s replies are its prose only, without tool calls or tool output. It’s taken from the session log, and the names are redacted as described below. It was written for the people and agents building the product, so expect internal shorthand, and the mistakes are left in.
Cards: the session, as it happened
Claude Code session in the LedgerTM repository, 29 September to 3 October 2026. Times are local (+02:00).
Jeremy’s messages are verbatim. The assistant’s replies are its prose text only: tool calls, tool results, internal reasoning, subagent reports and the automatic context-compaction summaries are left out. Messages marked (sent while the assistant was working) were typed mid-turn and delivered into the running turn. Customer, prospect, bank, partner, vendor and person names are replaced with [redacted].
ADR numbers 820 and 821 are the foundation ADRs (processor connectivity and machine identity). ADRs 835 to 844 are the rest of the cards series.
Tuesday 29 September 2026
10:08 Jeremy
with corporate banking we wrote a business proposal rather than starting with an adr. adrs then followed. i would like to do the same with a product suite aimed at cards (credit and debit) issuing and acquiring. when i say card, this also includes non card based payment transactions (i.e wallets, web site plug ins etc etc)
i want to cast the net wide to see what products could be incorporated into the current code base and evaluate what is missing.
for retail banking, it would seem a good option to introduce a credit and debit card product. we have a lot of the supporting functionality in terms of facilities, limits, payment rails, beneficiaries etc. what would be involved in supporting a card issuing environment as part of the retail offerring? how would we support visa, mastercard, amex and third party issuers like they have in china? who offers this sort of card management and is any available as part of a core banking product. its seems logical to have a card account administered within a single counterparty so you can transact across accounts. in my experience the card systems are often stand alone.
we also had some experience with acquirers. we worked with [redacted] to offer a merchant billing system. we would receive a transaction feed from a third party processor (also assume these feeds come from visa/mastercard themselves). these transactions in in different currencies were received with the necessary adornments to indicate things like region, fx, dcc, and a wide range of other information that we then built a pricing engine (our current pricing is based on this experience). so each transaction is priced, transactions generated and then the purchase amount is settled by rail to the merchant. each account and/or counterparty had various parameters that included the T=n delay in settlement, retention amounts and releases and the build up of collateral (to a set value). transactions could occur in one currency and settled in another currency according to merchant preference.
another possibility (perhaps overlapping with corporate) is corporate expense cards, pre loaded with authorisation type controls and expense management.
i want to look at market opportunity, competitor analysis and design wide and implement in stages if this fits the current platform. i know there are specific requirements like physical card issuing, chargebacks, fraud controls and a wide range of others that we need to consider.
Do some preliminary investigation and feedback. My iniital preference would be to include credit and debit cards as part of retail banking (that of course is going to lead to a current account concept as well).
10:08 Claude
Using superpowers:brainstorming since this is a design conversation before any ADR work.
10:09 Claude
Codebase survey is running in the background. Meanwhile I’m reading the business context docs and loading web search for the market and competitor side.
10:11 Claude
The Explore agent has the codebase side. I’ll wait for its report before writing up.
10:11 Claude
The market and business-context side is gathered. The codebase survey agent is still running; when it reports I’ll write up the full preliminary findings (what we own, what’s missing, market and competitors, and a recommended shape).
10:17 Claude
Preliminary findings below. The short version: two of the three products are mostly configuration on top of what we own, one is a genuine capability build, and one structural decision shapes all three.
The decision that shapes everything
A card stack has three roles. The scheme member holds the BIN and carries scheme liability. The issuer processor runs the real-time authorisation switch, the scheme connections, PCI, tokenisation and card production. The card management system and ledger owns the cardholder, the account, limits, statements, pricing and disputes.
Modern cores do not build the middle role. [redacted] partners with [redacted], [redacted] and [redacted] with [redacted] or [redacted]. Only the old monoliths ([redacted], [redacted], [redacted], [redacted]) carry a native card module, and those are the stand-alone card systems you remember. That is the gap: the card account sits in a separate system from the customer’s other accounts.
Recommendation: LedgerTM is the card management system and ledger. It never speaks ISO 8583. It exposes one authorisation oracle endpoint the processor calls per transaction ([redacted]’s “just-in-time funding” shape), answering from the counterparty’s available balance and limits across all its accounts. Every scheme (Visa, Mastercard, Amex, UnionPay, JCB, RuPay) becomes a configuration row on the card product, and the processor carries the message-level difference. Amex and UnionPay outside China are reached through licensed partner banks, which is the same BIN-sponsorship shape as Visa and Mastercard for a non-member. South Africa is mid-reform: PASA recognition is being withdrawn this month and the non-bank issuer directive is still a draft, so BIN sponsorship through a member bank stays the route there too.
Cost: one processor connector behind an anti-corruption layer like Connectivity, plus the oracle endpoint. About 2 sessions. Benefit: “one customer, many accounts, one card, funding chosen per transaction rule” is a claim none of the core-attached modules make. It is also what a corporate pre-loaded card needs. Cheaper option: batch-only. The processor authorises against a balance we push nightly. Covers debit cards badly and credit cards adequately. Half a session, and it is what most small issuers actually run.
What we already own
| Need | State | Where |
|---|---|---|
| Current account | Built, corporate package only | CorporateCurrentAccount in the corporate template. The retail package has none, and no overdraft exists anywhere |
| Revolving credit card product | Dormant | CreditCard and RevolvingCredit in the unused ca-retail template. Statement close, minimum payment, grace period, payment allocation are all sketched and never run |
| Pre-authorisation hold | Right shape | Claim register, ADR-251. Needs decline, partial capture, expiry, many holds per card |
| Limit against unsettled exposure | Built | ADR-794 limit reservations |
| T+n settlement, cleared vs booked | Built | ADR-083, ADR-115 |
| Rails, beneficiaries, nostros, suspense | Built | Payments, ExternalAccounts, Suspense, PostingGroup |
| Feed ingest with AI field mapping | Built | MT940, camt.052/053/054, BAI2, CSV, FormatProfile. Missing the card attribute model (MCC, terminal, auth code, DCC flag) |
| Back-dated reversal with FX cascade | Built | ADR-261. This is the chargeback posting primitive |
| Per-transaction pricing | Flat only | Price by type and date. No banding by region, scheme, card type, currency or amount |
| Retention and rolling reserve | Absent | Collateral has one-shot release, wrong shape |
| Card identity, velocity rules, chargeback lifecycle, merchant type with MCC | Absent | nothing anywhere |
The three products, sized
| Product | Mostly | Net-new | Rough size |
|---|---|---|---|
| Retail debit + credit card | Configuration: promote current account to retail, wake the dormant credit card template, Claims for holds | Card aggregate, oracle endpoint, processor connector, chargeback lifecycle | 8 to 10 sessions |
| Merchant acquiring and billing | Feed ingest, T+n, rails, FX, suspense | Attribute-banded price card, rolling reserve as a scheduled holdback, merchant counterparty with MCC, cross-currency payout preference | 8 to 10 sessions |
| Corporate expense cards | The retail card aggregate plus the corporate client channel (ADR-695/801) | Spend controls per card, pre-load funding rule | 3 to 4 sessions after retail |
Acquiring is where the lived experience and the PSP proof point sit, and its two net-new pieces are generic concepts we should want anyway. The attribute-banded price card is the banded rate card extended to transactions. The rolling reserve is a Claim with a percentage and a release schedule. Both are demoable and priceable. [redacted], [redacted] and [redacted] are software on top of BIN sponsors; a bank offering expense cards natively to its corporate clients is a claim the incumbents cannot make from a stand-alone card module.
Regulatory and operational reality to carry into the proposal
PCI scope stays with the processor as long as we hold only a token and last four. Chargebacks run 120 days from transaction on most reason codes and up to 540 on some, which is why acquirer reserves hold 90 to 180 days and final release runs 270 days after termination. Interchange++ pricing is three components per transaction and the scheme fee tables change twice a year, so the price card must be dated. Physical card production, PIN, 3DS and tokenisation are all processor services and belong outside the boundary.
The one question that decides the design: do you accept “LedgerTM answers authorisations through an oracle endpoint, never owns the switch”, or do you want the batch-only cheaper option as the first cut? My recommendation is the oracle, because it is the claim.
Sources: [redacted] on [redacted], [redacted] cards, [redacted] card management, BIN sponsorship, CMS vs processor, UnionPay International, SA payments reform, [redacted] acquiring, [redacted] merchant management, rolling reserve, Mastercom dispute cycle, Interchange++, [redacted], expense card market, issuing platform market.
10:24 Jeremy
oracle, not batch. and cards inside retail. you make it sound fairly simple. if its a market gap then we should surely take it. so i assume an issuer or aquirer would own the switch (something like [redacted])? and explain tokenisation - we definitely dont want to expose ourselves to PCI compliance if it can be avoided. how do we handle chargebacks, disputes, card issuance, renewals and how would we handle virtual cards, payment gateways etc
10:27 Claude
First, a correction to my own tone. The ledger side is bounded and I stand by the sizing. The critical path is not: a processor contract, a BIN sponsor or scheme membership, and the processor’s scheme certification all sit outside our code and each runs months. The gap is real, but the buyer is a bank that already has a card system, so the first sale is a bank launching a new programme, not one replacing an old ledger.
Who owns the switch
The issuer’s processor owns it, never us. In South Africa the big banks run [redacted] in-house, and [redacted] has a host interface that forwards each authorisation to a “host” and waits for the answer. We are that host. Elsewhere the processor is a service ([redacted], [redacted], [redacted]) and the same call arrives as an HTTPS webhook. On the acquiring side the acquirer’s processor owns its switch and we only ever see the settled feed. Either way the connector is one anti-corruption layer with a simulator, the same shape the corporate proposal set for Connectivity.
Tokenisation and PCI
Two different things share the word.
- Vault tokenisation keeps us out of PCI DSS. The processor stores the PAN and gives us a surrogate reference. We hold that reference, the BIN, the last four digits, the expiry and the embossed name. A truncated PAN is not cardholder data under PCI DSS, so a system holding only that is outside the cardholder data environment. The rule for us is simple: no field, log, event or statement ever carries a full PAN. A build-time test can enforce that on every event contract.
- Network tokenisation is how wallets work. Apple Pay or Google Pay asks the scheme’s token service for a device token. The scheme asks the processor, and the processor asks us one question: may this card go on this device, and does the customer need a one-time code first. We answer and record the device token as a second credential on the same card. An authorisation from a wallet then arrives naming that credential, which matters for disputes and for blocking one device without blocking the plastic.
Lifecycle, disputes, virtual cards, gateways
Issuance and renewal. A card is its own aggregate under the counterparty, funded by an account through a rule. Life is ordered, produced, shipped, activated, active, suspended, lost or stolen, replaced, expired, closed. We send the order to the processor, the processor sends the bureau file, and activation comes back as an event. Renewal keeps the PAN and issues a new expiry; replacement after loss issues a new PAN. Issuance and replacement fees are ordinary priced transactions.
Disputes on the issuing side. The cardholder disputes a transaction. We raise it through the processor into the scheme’s dispute system. Stages are retrieval, first chargeback, representment, pre-arbitration, arbitration, each with a scheme timer. Modelled as a dispute aggregate per transaction with stage and deadline. Provisional credit is a posting on day one, and a loss reverses it through the back-dated reversal cascade we already own.
Disputes on the acquiring side. The chargeback arrives in the feed. We debit the merchant account, or the reserve if the account cannot bear it, price the chargeback fee off the price card, and give the merchant a window to send evidence. Dispute ratios feed the reserve percentage, which is why the reserve must be a scheduled holdback and not a fixed sum.
Virtual cards. Same aggregate, no plastic. The processor generates the PAN on demand. Single-use or multi-use, per supplier or per campaign for corporate use. Funding is where the oracle earns its keep: a corporate virtual card can be funded just in time from a pooled account with a per-card ceiling, so nothing is pre-loaded.
Gateways, plug-ins and wallets. These are acquiring-side and belong to the gateway vendor, never us. What reaches us is the settled feed with a channel attribute: card present, e-commerce, recurring, wallet, or an alternative payment method such as Alipay. The scheme is a vocabulary row on the price card, so a wallet transaction is priced the same way as a Visa one. A website plug-in is the gateway’s product.
The next decision that changes the connector’s shape: do we design the first connector against a bank’s in-house [redacted] host interface, or against an API processor such as [redacted]? My recommendation is [redacted]. It is South African born, global, already on the [redacted], and ships a sandbox we can build the simulator from. A [redacted] host interface needs a bank’s own spec, which we cannot get without the bank.
10:30 Jeremy
[redacted]. write up the proposal like we did for corporate
10:33 Claude
Matching the corporate document’s masthead markup, then writing the cards proposal.
10:40 Claude
The document is written and structurally sound. Rendering it in the browser pane to check the four diagrams and tables, and reading it back once in text for accuracy.
10:41 Claude
One subtitle in the architecture diagram overflows its box. Shortening it, then one screenshot of that figure as proof.
10:41 Claude
The proposal is written at cards-capabilities.html, in the corporate document’s format and stylesheet, twelve sections with four diagrams. It is uncommitted; I have not staged it.
What it commits to, so you can push back before the grill:
- [redacted]’s [redacted] API is the oracle model in its own words. The client holds the balance and authorises. Its Card API keeps the balance at [redacted], and the document refuses that shape.
- Sequencing is retail debit, then acquiring, then credit, then corporate. Acquiring moved ahead of credit because it shares nothing with issuing beyond the price card and the feed, and it is the buyer we can name.
- One current account type, not a retail and a corporate one. The overdraft is the first account type allowed below zero, by facility attachment.
- The hold is a claim and the reserve is a claim. Both reuse ADR-251 with a new origin. The price card absorbs rail fees so ADR-416 does not become a second mechanism.
- The dormant credit card template is wrong on the interest-free rule. It decides at cycle start from the amount due. Real products decide at the due date and back-date. The document says so and the grill must decide whether that is configuration or an engine change.
Two things I did not verify:
- Which [redacted] platform a bank programme sits on. The [redacted] API is documented on the [redacted] portal, which is the prepaid and fintech platform. Section 12 carries this as the first commercial question.
- The screenshot came back blank because the pane renders local files as a static snapshot. Layout was checked in the DOM instead: no console errors, no text overflowing its box after one subtitle fix, tables scroll as designed.
Next step is the grill. Section 12 lists the eleven questions I already know the document cannot answer, ordered by how much each changes the design.
10:55 Jeremy
i’d put aquiring last
10:56 Claude
Reordered. The lanes now run retail debit, retail credit, corporate, acquiring, and every cross-reference moved with them:
- Section 1 recommendation now says acquiring is last because it shares nothing with issuing beyond the price card and the feed, and has no bank customer to ride in on.
- Section 9 renumbers the lanes. The attribute-banded price card moved into the credit lane, first used for card fees, so acquiring inherits it rather than building it.
- Decision 12 reads “retail debit leads, credit second, corporate third, acquiring last”, and the “one pair looks contradictory” paragraph now reconciles last-by-sales-path with already-delivered-once.
Estimates after the move, ledger side only:
| Lane | Sessions |
|---|---|
| Retail debit, seam, oracle | 6 |
| Retail credit, disputes, price card | 5 |
| Corporate spend controls | 3 |
| Acquiring settlement | 7 |
The file is still uncommitted at cards-capabilities.html.
10:56 Jeremy
commit it
10:57 Claude
Committed on main as 4ee0a16fa. Not pushed.
11:09 Jeremy
grill it
11:10 Claude
Verified against the code before asking anything. Four of the proposal’s load-bearing claims move:
- A claim is an event on the Account stream.
RaiseClaimemits to the account, andClaimReleaseStepreleases date-triggered claims at day-end only. So every authorisation is a real-time write to the same stream day-end holds withFetchForWriting, and two taps on one card inside a second are two writers on one stream. The proposal says “the hold is a claim” as if that were free. It is not. - “No account type may go below zero” is wrong. There is no guard in the aggregate. Withdrawal is refused by an
availabilityGuardexpression on the operation, per account type, in YAML. An overdraft is a guard change plus a facility attachment, which already exists on loan types. Cheaper than the proposal says. - Day-end releases holds, not real time. A merchant reversal or an expired hold released only at day-end means the customer’s available balance is wrong until tonight. The claim register has an event trigger, but nothing outside the account fires it during the day.
- The client channel is Shipped (ADR-695, ADR-801). Corporate cards wait on nothing.
Now the demo, walked. A clerk opens Thandi, sees a current account and a card panel that does not exist yet, orders a card. The simulator activates it. The clerk taps in the simulator: 5,000 at a hotel. The oracle must answer in under two seconds. It reads the account, subtracts claims, adds the facility, writes a claim to the account stream, answers. Day-end is walking that account at the same moment. Silence one: what happens to the second writer. Silence two: the customer sees “available 1,200” and the hotel cancels at 14:00, and the balance stays 1,200 until day-end. Silence three: at day-end the clearing line arrives for 2,650 with no clerk involved, and the proposal never says which surface shows the hold becoming a posting.
Grill. Where does the hold live? This decides the timeout, the funding rule and the reuse claim, so it goes first.
- On the Card stream, not the Account stream (recommended). Each card is its own stream, so one card’s authorisations serialise naturally and never contend with day-end. The account’s available balance becomes a read that subtracts card holds from a projection alongside the account’s own claims. Cost: the claim register is no longer the single register, and
AvailableBalance.Projectgains a second input. Benefit: the oracle never waits on a day-end walk, and a hold release fires in real time from the card. - On the Account stream, as drafted. One register, one truth. Cost: every authorisation contends with day-end and with sibling authorisations; the retry lives inside the timeout budget, and a cross-account funding rule touches several streams per tap.
- A separate Authorisation aggregate per hold. Cleanest audit trail, one stream per hold. Cost: the available-balance read aggregates across many small streams, and it is the most new code.
Which do you want, or is there a fourth?
11:15 Jeremy
card stream
11:16 Claude
Recorded: holds live on the Card stream. That resolves the day-end contention and real-time release, and it opens the next question.
The account and facility read models are inline projections, so they are consistent with every write. The oracle can read them without loading the aggregates. What it cannot get from them is the holds of the customer’s other cards on the same account, because those now sit on other card streams.
Grill. How does the oracle learn the account’s total card holds?
- An inline projection keyed by account, fed by every card’s hold events (recommended). Consistent with each hold write, one document read per tap. The account’s available balance read gains this as a second input beside its own claims, and the account UI shows “held by cards” as its own line. Cost: one projection and one field on the available-balance read.
- Load every card with a funding rule naming the account, on each tap. No projection, always correct. Cost: a customer with three cards is three stream loads inside the timeout, and it grows with the cross-account funding rule.
- Ignore sibling cards. Each card is answered from the account balance less its own holds. Cost: two cards on one account can each spend the same money for a day. A real bank would call that a defect on the first double-spend.
Which one?
11:16 Jeremy
inline projection
11:16 Claude
Recorded: an inline projection keyed by account carries every card’s holds.
That makes the funding rule the next thing that cannot stay vague, because with holds on the card the rule decides which account a hold is keyed to and which account the clearing line posts to. The proposal offers “one account, or an ordered list” and section 12 admits it does not know.
Grill. What can a funding rule say, and can one authorisation be split across two accounts?
- An ordered list, whole amount, no split (recommended). The oracle walks the list and places the entire hold on the first account whose available covers it. The clearing line posts to that account. An overdraft is not a list entry; it is the facility on the current account, so “current, then savings” already means “current, then its overdraft, then savings”. Cost: a small list type on the card and a walk in the oracle. Benefit: one hold, one posting, one statement line, and the demo claim survives.
- One account only. Simplest, and every incumbent does it. Cross-account becomes a balance-mode sweep from savings at day-end (ADR-120), which exists. Cost: the card cannot spend savings today, only tomorrow, and the claim in section 1 weakens to “overdraft plus sweep”.
- Split across accounts. The hold splits 4,200 from current and 800 from savings, and the clearing posts two purchases for one receipt. The customer sees a hotel bill in two pieces on two statements, and a chargeback reverses two postings. Nobody sells this.
- An expression. The platform’s habit, and unbounded at authorisation time. It also makes the rule unreadable to the clerk explaining a decline.
Which one?
11:16 Jeremy
ordered list, no split
11:17 Claude
Recorded: an ordered list, whole amount, no split.
The next silence is the one the auditor and the financial director both trip on. A clearing line can exceed what was held: a restaurant adds a tip, an offline terminal clears with no authorisation, a hold expired at day seven and the merchant clears on day nine. The scheme has already settled the money with the processor, so the bank has paid. The proposal says “the clearing line posts” and never says what happens when the account cannot bear it. Every withdrawal today is refused by an availability guard on the operation, and a clearing line is not an operation a clerk performs.
Grill. When the clearing amount exceeds the account’s available, what does the ledger do?
- Post unconditionally; the account goes negative; an unarranged overdraft is a configured fee and rate (recommended). The guard on customer-initiated operations is untouched. A card clearing is a settled fact from a source that outranks the guard, the same standing the instruction settlement step already has (it appends
TransactionPostedwithout running the guards, per ADR-251). The negative position is the abnormal stateAccountNaturealready names, and the collections machinery sees it like any arrears. Cost: a fee schedule row and an accrual on the negative position, both configuration. Benefit: the bank’s ledger says what the bank owes, which is the truth. - Post the shortfall to a card-settlement suspense account and chase the customer. The customer’s account never goes negative. Cost: a second place the money lives, a matching step, and a statement that does not show the purchase. The auditor finds the purchase in suspense six months later.
- Refuse the line as an exception item. Hides a payment the bank has made. Not a real option; listed so it is seen to be rejected.
Which one?
11:29 Jeremy
post unconditionally. i am not a card expert. i will go with your reccomendations unless you are unclear on any
11:30 Claude
Taking positions on the rest, with the reason each time, and flagging where I am not sure. Then I press the set for contradictions with a fresh agent before rewriting.
11:34 Claude
Now the rewrite. Every replacement asserts on the exact text so nothing is spliced blind.
11:36 Claude
Grill done and committed as d24aca302. Section 12 of the proposal is now the record.
What changed, beyond the three you answered directly:
- Hotel example now uses the thirty-day expiry its own rule states.
- Catch-up interest is one posting per cycle, and the mode after it is named. It needs one new expression function, a day-weighted sum over the cycle’s purchases, and no engine change.
- Acquiring GL contradicted itself. The T+n posting moves GL into the merchant payable; the reserve moves nothing.
- Corporate card sits under the corporate counterparty. The employee is a named cardholder, not the owner.
- Currency is converted by the processor before the message reaches us. Every account in a funding rule shares the card’s billing currency.
- Provisional credit is a rule per reason-code class, not one switch. Fraud credits on day one, quality disputes on outcome.
- The processor’s identity is a per-tenant credential dispatched inward as the System identity, ADR-376’s service token with a tenant added.
- Lane one grew from six sessions to seven.
Held under pressure: the oracle, cards inside retail, no PAN, [redacted] first, fraud scoring at the processor, one current account type.
Where I was unsure I recorded a dated deferral rather than a decision:
- Which [redacted] platform a bank credit programme sits on. The adapter is designed against the [redacted] shape; you confirm at the first conversation.
- Amex is a declared gap.
- The first buyer, by name. Yours to call before the first ADR opens.
- The oracle’s timing under a day-end walk wants a measurement in lane one’s first bite.
The proposal is not an ADR, so nothing advanced to Accepted. Next step when you want it is /ltm-design for the first ADR in section 11, the processor contracts and the [redacted] simulator.
11:45 Jeremy
there is no buyer. speculative.
11:45 Claude
Recorded and committed as 3ddde9714. The “first buyer” deferral is gone. Section 12 now states there is no buyer, that this is speculative by design, and that the lanes are ordered by what demonstrates soonest rather than by a prospect.
Three deferrals remain: the [redacted] platform, Amex as a declared gap, and the oracle timing measurement in lane one.
14:14 Jeremy
do we now write the adrs?
14:15 Claude
Yes, one at a time, and the first one now. Design is serial on main, and the second ADR compiles against the contract names the first settles, so writing all ten in one sitting would lock names nobody has grilled.
The order for lane one, each through /ltm-design, then /ltm-design-grill, then /ltm-plan:
- Card Connectivity: the processor contracts and the [redacted] simulator. The four contracts, the adapter, the simulator, the no-PAN build test, the per-tenant credential. Nothing above it can start, and its names are the ones that cannot be renamed later.
- The card aggregate and its credentials.
- The authorisation oracle and the card hold, with the inline holds projection.
- The current account, the overdraft facility and the unconditional clearing post.
Two things the process will demand before the first one is Accepted:
- A model page. The card is a new concept, so
model_required.pywill almost certainly say a page underdocs/business/models/comes first. That page has one writer, you. I can draft it in the design session for you to review like code, and it is the better place to state the hold-on-the-card rule than an ADR, because three ADRs lean on it. - The ADR number is a GitHub issue.
/ltm-designopens it, so the first ADR needs the box reachable.
Say the word and I open the first one.
15:20 Jeremy
write it
15:27 Claude
Syncing ADR-820 to its GitHub issue and the board.
15:28 Claude
ADR-820 is written at ADR-820, issue tvmsoftware/LedgerTM#820 is on the board at Proposed, make adr-check is green, and prior art verifies. The ADR and the regenerated index are uncommitted.
Two things prior art turned up that change the shape from the proposal:
- ADR-694 already decided most of the seam. It is Proposed with a plan, unbuilt. It declares the institution connection row, the statement delivery, the machine-dispatched door, the OAuth2 client-credentials machine identity as the pattern every later external system inherits, and a marker that keeps a machine’s command out of four-eyes. ADR-820 reuses all of it and adds one transport value. The cost is a hard sequencing: ADR-694 lands first or shares the lane. That is recorded in the ADR, not left for the plan.
- “Authorisation” is taken. It means four-eyes here. Every card type carries the
Cardprefix so a purchase authorisation can never be read as an approval of a change.
Ten decisions, seven bites, eleven scenarios, no aggregate and no events. The model script says no page covers cards, so the ADR drafts a card model page in the same land.
Next is /ltm-design-grill ADR-820. Say so, or say commit first.
17:40 Jeremy
commit it then grill it
17:41 Claude
Model check already ran: no model required, no page exists. Verifying the ADR’s dependency claims on ADR-694 before walking the demo.
17:43 Claude
Grilled against the code. Three of the ADR’s claims move before any question is asked:
- The simulator’s clearing file goes through the wrong door. The ADR says it is delivered through ADR-694’s push door. That door takes a parsed delivery, not a file, so the [redacted] reader would never run against the simulator’s output. ADR-337 and ADR-766 already have the right path: the file is received into the inbound file store keyed by purpose and business date, and a day-end step resolves it and imports it through the file door with the reader. The real processor’s file takes the same path, fetched by the adapter into the same store.
Timeoutcannot be a decline reason. A decision that misses the budget sends no decision, so the enum contradicts decision 5.- The tenant is not resolvable from the machine token as ADR-694 stands. It stores the client id on a per-tenant settings row, but settings cannot be read until the tenant is known. That is ADR-694’s gap, not this ADR’s, and it needs a platform-level map from client id to tenant and connection. I have not filed the finding yet.
The demo, walked. An operator opens the za-retail tenant, licenses cards issuing, and finds a processor settings page: kind Simulator, decision budget two seconds. A demo script fires an authorisation; a receipt row appears. The script fires it again; the same row, unchanged. The script sleeps the decider past two seconds. Silence one: what the processor receives over HTTP when we send “nothing”. Silence two: whether anything records that we failed to answer, because tomorrow’s clearing line will arrive with no hold and the reconciliation needs to know why. The operator runs day-end; a clearing file appears on the deliveries page, and nothing on the customer, because no card aggregate exists yet. Silence three: the receipts panel is on the settings page, which is where nobody looks in a demo.
Positions I take unless you object:
- A missed budget answers 503 at once and records a receipt with outcome
NotAnswered. A hanging connection is what the processor’s own timeout is for, but an explicit 503 lets it stand in sooner, and the receipt is what the reconciliation matches a stand-in clearing line against. - The request carries the original amount and currency beside the billing amount. The proposal decided the processor converts; the statement still needs what the cardholder saw.
- Two identical requests in flight at once serialise on the receipt. The receipt is an insert keyed by the authorisation id; the second arrival waits for the first and answers from it.
- A reversal of an authorisation we never saw is recorded and accepted. The processor’s record outranks ours; the receipt says
UnknownAuthorisation. - The receipts panel moves to the connectivity deliveries area, beside the clearing files, where an operator already looks at what came from outside.
ICardProcessorgainsFetchClearingFile(date), and the fetch is a day-end step that receives into the inbound store. The simulator writes into the store directly.
Grill. The one I want your call on: the client-id-to-tenant map is ADR-694’s to decide and it has not decided it. Do I file it as a finding on ADR-694 and let ADR-820 assume the gateway hands the API an identity token carrying the tenant, or do I decide it here in a platform section and hand ADR-694 the decision? My recommendation is the finding: deciding platform identity inside the second consumer of it is how two answers to one question begin.
Wednesday 30 September 2026
05:06 Jeremy
file the finding, go with your positions
05:12 Claude
The coordinator filed the finding as F-1562. Now rewriting the contracts, worked example, bites, scenarios and the grill record in ADR-820.
05:15 Claude
Checks are green and the board is synced. Committing the grilled ADR now.
05:16 Claude
Grill done and committed as 997a7f179. The finding is F-1562 on the queue, allocated by the coordinator and cited in the ADR.
Beyond the positions you approved, the contradiction press found eight pairs and all are folded in. The ones that changed shape:
- Token provisioning gets its own receipt with the same idempotency and budget rules. The draft left the door that puts a live token on a phone with no replay protection.
- Receipt outcomes are one closed list, and a reversal is the one update a receipt ever takes.
- The simulation flag is a guard, not a second switch. The connection kind decides; the validator refuses kind Simulator on a non-simulation tenant.
- The clearing file is keyed by the business date of its items, never the run date, or reconciliation would be off by one.
- “One BIN set per tenant” is gone. The ADR disclaimed BINs and then constrained them.
Held under pressure: the boundary, the Card prefix, the processor as an institution connection, ADR-694’s machine identity, no PAN, no aggregate, no events.
Status stays Proposed. It needs a plan, and Accepted comes after the plan grill. Two things gate the build order:
- ADR-694 lands first, or shares the lane. Bites 2 to 7 compile against its connection row, delivery types and machine identity, and F-1562 has to be resolved inside its bite 14.
- Bite 1 has no dependency and can start any time.
Next is /ltm-plan ADR-820, or the second ADR, the card aggregate, if you would rather keep designing while ADR-694 is unbuilt.
05:18 Jeremy
why is there a dependency on 694?
05:19 Claude
Because ADR-694 already decided three things ADR-820 needs, and building a second version of each is the drift CLAUDE.md forbids:
- The institution connection row. ADR-694 D13 says every institution we exchange with is one settings row with a transport, and that later work “extends this row rather than inventing a second one”. A card processor is an institution.
- Machine identity for an external caller. The platform has none today. ADR-694 D18 chose OAuth2 client credentials as “the pattern every later external system inherits”, and its bite 14 adds the marker that keeps a machine’s command out of four-eyes.
- The canonical statement delivery and the file door. The clearing file is a statement of what the processor did, and ADR-694 reshapes the ingest path into one delivery type with readers attached.
The cost is real. ADR-694 is Proposed, planned, unbuilt: fourteen bites in one land, on the corporate banking stream. If corporate is not next, cards waits on twelve bites it does not need for two it does.
Three ways out:
- Carve the shared platform half out of ADR-694 into a small ADR both series depend on (recommended). Machine identity, the four-eyes marker, the connection row, and F-1562’s client-id-to-tenant map. About three bites. ADR-694 and ADR-820 both then depend on that and not on each other. The clearing file uses today’s statement import path (ADR-094) with a reader, and moves to the canonical delivery when ADR-694 lands, which is a mechanical change inside one reader.
- Keep the dependency and build ADR-694 first. Right if corporate banking is the next lane anyway.
- Decouple entirely. ADR-820 builds its own connection row, its own machine identity and its own file path. Fastest to start, and it hands the corporate stream three duplicates to reconcile later.
Say which and I will either open the platform ADR or replan ADR-820 against it.
05:21 Jeremy
option 1, open the platform adr
05:23 Claude
Writing ADR-821. It carves the connection row, the machine identity and the four-eyes marker out of ADR-694, and resolves F-1562. Then I repoint ADR-820 and leave a note on ADR-694.
05:27 Claude
ADR-821 is written at ADR-821, issue tvmsoftware/LedgerTM#821 is on the board at Proposed, and the ADR checks are green. Uncommitted, with two sibling edits:
- ADR-820 repointed. Its dependency is now ADR-821 bites 1, 2 and 4. Nothing on ADR-694 remains: the clearing reader targets today’s import shape and moves to the canonical delivery when ADR-694 lands.
- ADR-694 carries a note saying D13, D18, D21 and bite 14’s marker moved to ADR-821, and what stays. Its plan is reconciled when it is next touched, because that plan is its own.
What ADR-821 decides, in six:
- The connection row has a generic core and features attach facets keyed by it. ADR-694’s feed authority and formats become its facet; ADR-820’s processor settings already are one.
- A machine principal is a platform record, beside the platform user, binding one client id to one tenant and one connection. Registered by a platform administrator, never in tenant settings or YAML. This closes F-1562.
- The gateway resolves a client-credentials token the way it resolves a person and mints the same identity token with a
connectionclaim. - On the API the caller is a connection frame, and the day-end lock passes its external origin. A processor cannot wait for our day-end, and the receiving feature decides what an external act may touch.
- The marker is a fourth term in four-eyes eligibility, and its keys are grantable to no human.
- A whoami endpoint makes the path demonstrable with nothing above it.
Four bites, ten scenarios. The model script says no page covers connections, so the ADR drafts one at land.
Next is commit, then /ltm-design-grill ADR-821.
05:42 Jeremy
commit it then grill it
05:43 Claude
Verifying ADR-821’s claims against the gateway, the lock and the identity store before walking the demo.
05:45 Claude
Verified against the code. Four of the ADR’s claims move:
- The lock reads a boolean, not an origin.
SystemLockMiddlewarepasses a frame whoseSystemOriginatedis true; there is no origin value to addExternalto. The frame gains an origin kind with three values and the boolean becomes derived, or the ADR’s decision 4 is not buildable as written. - The facet removal guard crosses the dependency rule. The connection settings handler lives in one project; the facets live in Payments, Cards and BankStatements. It cannot see them without a Contracts seam that each feature implements.
- “Registered by a platform administrator” has no surface. There is no platform administration screen anywhere. What exists is the platform role claim from ADR-376 and the provisioning service token, which is how the development member is registered today.
- The gateway is tested.
LedgerTM.Tests/Gatewaydrives it through the dev login, so the client-credentials path is provable there, not only in staging. The component suite hits the API directly, so it proves the frame and the marker by minting the identity token with the signing key, the service-token precedent.
The demo, walked. Someone with the platform role calls the register endpoint for client id app-sim-za. Silence one: with what, since no screen exists and the dev environment has no Entra to issue a token from. The simulator then calls the gateway with a client-credentials token. Silence two: where that token comes from in development. The gateway resolves the principal on every request. Silence three: whether it does that on every authorisation, which adds a call inside the two-second budget ADR-820 promised. The operator revokes the principal. Silence four: how fast the processor is locked out.
Positions I take unless you object:
- The identity frame gains an origin:
Person,System,External. The lock passes the last two.SystemOriginatedbecomes derived so nothing that reads it changes. IInstitutionConnectionFacetin Contracts. Each feature registers one naming its facet; remove asks all of them. The seam also gives the settings page its “facets attached” column.- Registration is API-only in this ADR, guarded by the platform role, no screen. The development and simulation principals are registered at provisioning by the service token, exactly as the development member is.
- A development machine-token endpoint on the gateway, refused outside Development and Testing, mirroring the dev login. It is what the simulator and the demo use. Production uses Entra.
- Whoami is a query, permitted by its key like any query. The marker is for commands.
- A revoked client id can be re-registered, which re-enables the same record. One principal per client id, always.
Grill. The one I want your call on: the gateway caches a resolved principal per client id, so a revoke is not immediate. Do you accept a sixty-second window after revocation, with one resolve call per minute per processor, or must a revoke bite on the next request, which puts one resolve call inside every authorisation? My recommendation is sixty seconds: the processor’s own token already lives an hour, and a resolve per authorisation spends a fifth of the decision budget on a question whose answer changes once a year.
05:46 Jeremy
sixty seconds, go with your positions
05:46 Claude
Contradiction press first, then the rewrite.
05:52 Claude
Grill done and committed as 814f762de. Status stays Proposed; Accepted comes after the plan grill.
Beyond the sixty-second cache you chose and the positions you approved, the contradiction press found six pairs and all are folded in. The ones that changed shape:
- A principal holds no grants. What a connection may dispatch is derived from a new kind on each catalogue entry. That also covers queries, which the command marker could not, and the same kind is what refuses a grant to a human role.
- Register and revoke are not four-eyes gated, because no change set exists outside a tenant. The controls are the platform role and the two events. Platform-level four-eyes is a dated deferral, not a pretence.
- Every resolution attempt is recorded, refused ones included, on the platform store. A refused caller has no tenant, so nothing tenant-scoped could hold it.
- A connection cannot be removed while an enabled principal speaks for it, not only while a facet names it.
- The revoke claim has a test. The gateway suite forces the cache to expire and proves the refusal.
Held: one principal per client id per tenant per connection, resolving through the API, the same identity token with one claim added, the lock passing an external origin, the fourth term.
Where things stand. The cards series now has its foundation ADRs designed and grilled, with build order ADR-821, then ADR-820, both waiting on plans:
| ADR | Status | Next |
|---|---|---|
| ADR-821 platform identity and connections | Proposed, grilled | /ltm-plan ADR-821 |
| ADR-820 card connectivity | Proposed, grilled | /ltm-plan ADR-820 after 821’s plan |
| Card aggregate, oracle, current account | not yet opened | /ltm-design when you want them |
Nothing is pushed.
06:57 Jeremy
plan 821
06:57 Claude
Starting the plan. First the structural facts the file map needs.
07:00 Claude
Structural facts gathered. Writing the plan file now: files touched, interfaces, bites and scenarios moved from the ADR, scenario-to-test map, UI sweep, land shape.
07:10 Claude
Phase A’s findings check out against the code. Saving them for the plan grill and dispatching it now.
07:22 Claude
Both passes are in and they agree on the shape problems. Folding the recommended positions into the ADR and the plan now. Two of them change ADR decisions and I will name them in the report.
07:28 Claude
All gates green. Dispatching phase B: four test authors, one per bite, in one batch.
07:29 Claude
The four test authors are running in the background. Nothing else is independent of their results: the commit bundles the plan with their files, and Accepted follows a green make adr-check over the committed set. Waiting for the four notifications.
07:30 Claude
F-1566 is recorded in the plan’s notes. The four test authors are still running; the commit and the status flip wait on them.
07:36 Claude
Bite 2’s tests are in. Its notes for the plan wait for the other three so the fold is one edit: the add scenario must use a key the template does not seed, bite 2 needs a null principal reader until bite 3 supplies the real one, unknown-id amend and remove refuse, and the two four-eyes capture tests may be struck by the lane if settings commands have no applier.
07:36 Claude
Bite 2’s completion is logged. Still waiting on bites 1, 3 and 4.
07:36 Claude
Bite 1’s tests are in, with four corrections for the fold: the component test path is Infrastructure/AccessControl, the permissions list surface must include pinned queries or the whoami key never appears on the page, Decision 5’s formula omits the not-gated term, and Decision 4’s ForConnection shows four parameters where the interface has five. Waiting on bites 3 and 4.
07:37 Claude
Two of four done. Bites 3 and 4 are still writing.
07:38 Claude
Bite 3’s author is adding the seed-step test and applying the resolved ambiguities. Bite 4 is still writing. Waiting on both.
07:41 Claude
All four authors have reported. Folding their corrections into the ADR and the plan while bite 3’s author finishes its revision.
07:41 Claude
Now the plan fold: findings, files, interfaces, scenarios and mapping.
07:43 Claude
The check caught two things after the commit: a test fixture in the Relies-on table and a missing model picture. Both fixed. Re-running the gates and committing the correction.
07:46 Claude
ADR-821 is planned, grilled, tested and Accepted. Committed as 3707faa45 and e2e609af6, board at Accepted, tree clean, nothing pushed.
What the plan grill changed, beyond what the design grill had settled. Two of these are design changes you should know about:
- The platform acts are minimal APIs under the platform role, not Wolverine commands. The platform store is not integrated with Wolverine, a Wolverine chain needs a tenant frame a platform administrator lacks, and a tenant catalogue key would have let a tenant’s own administrator grant themselves the right to register a machine. Register, revoke, resolve and the two lists now follow the provisioning endpoints’ shape.
- Every connectivity type lives in
LedgerTM.Infrastructure.Contracts. The plan had them split across two projects in a reference cycle. - A machine gets a minted actor. The frame would otherwise have coerced a principal URN into a user id, and audit would have read a machine as a person.
- One static rule decides what a frame may hold, and both permission paths call it. Without it the HTTP path refused every connection and admitted a tenant administrator to the whoami key.
- The client id left the connection row, the removal guard became a validator, the connection frame holds for the first hop only, and the gateway stops proxying the auth resolve endpoints. That last one closes a security finding. [security finding, fixed: detail withheld]
The four test authors wrote twenty scenarios’ worth of tests, uncompiled, each file stating its assumptions. Their corrections are folded, including a seed-step scenario nobody had written and a sub claim that contradicted itself across two decisions.
Gate table for /ltm-partition:
| Gate | State |
|---|---|
| Accepted | yes |
| No live lane | none for 821 |
| Plan exists | yes |
| Every bite has criteria | four bites, twenty scenarios |
| UI sweep recorded | yes |
| Files touched per bite | yes |
Two things to carry: F-1566 may be worth landing ahead of bite 4 as a one-line gateway rule, which is the coordinator’s call, and two of bite 2’s four-eyes capture tests may be struck by the lane if settings commands have no applier, recorded as F9 in the plan.
Next is /ltm-plan ADR-820, which now compiles against these names, or /ltm-partition ADR-821 to cut the lane.
08:38 Jeremy
plan 820
08:39 Claude
Starting the plan for ADR-820. Gathering the file-map facts first: the feature-project reference set, the reader registry, the inbound file store and the day-end step shape.
08:41 Claude
The file map is settled. Writing the plan now, with the clearing reader’s seam and the new feature project recorded as findings for the ADR.
08:46 Claude
Two facts to pin the revised clearing path, then I rewrite bite 6 in the plan.
09:07 Claude
Folding now. Three files change: ADR-820’s decisions and contracts, its plan rewritten around the Cards-owned clearing document, and an additive edit to ADR-821’s plan for the two seams Cards needs.
09:14 Claude
Plan rewritten and internally consistent. Running every gate: prior art on both ADRs, the contracts check, the footprint, the index and the ADR checks.
09:16 Claude
All gates green on both ADRs. Dispatching phase B: seven test authors, one per bite, in one batch.
09:17 Claude
Both issues are synced. The seven test authors are running; the commit, the fold of their corrections and the status flip wait on them. Nothing else is independent of their results.
09:22 Claude
Bite 4’s tests are in. Corrections queued for the fold: the component context must be unsealed with a fixture constructor, the fake clock must be per tenant or the Cards collection’s own, and the provisioning receipt needs a reason so a failed decider is distinguishable from no decider. Six authors still running.
09:22 Claude
One of seven done. Waiting on the other six.
09:24 Claude
Bite 2’s tests are in. Corrections queued: the seven keys bound to the feature, not six, and whether a read key can bind at all through the feature gate; refusal codes as domain exceptions so they survive HTTP; a None kind so an undeclared processor does not read back as [redacted]. Five authors still running.
09:24 Claude
Two of seven done. Waiting on bites 1, 3, 5, 6 and 7.
09:25 Claude
Bite 7’s tests are in. Three more corrections queued: the wire-body templates across bites 3, 4 and 7 must be reconciled into one declared shape in the plan, the scripted decider needs a “none for this tenant” signal the door can read, and the fake clock must not be host-wide. Four authors still running.
09:25 Claude
Three of seven done. Waiting on bites 1, 3, 5 and 6.
09:27 Claude
Bite 5’s tests are in. Corrections queued: four simulate commands and four keys, not three; SystemActingAs still named in the Relies-on table where the decision says ForConnection; the token reference itself can be a Luhn-valid numeric, so the twelve-digit guard must exclude it explicitly; the no-PAN walker’s scope over test code must be stated. Three authors still running.
09:27 Claude
Four of seven done. Waiting on bites 1, 3 and 6.
09:27 Claude
Bite 1’s tests are in. Corrections queued: the clearing mapper files move under Application/Processor/ or the vocabulary test goes red at bite 6, the Card rule is whole-word not prefix, scheme digits are enumerated, and the request log keeps raw bodies so a PAN can reach it before the mapper drops the field. That last one is a finding, not a plan edit. Two authors still running.
09:27 Claude
Five of seven done. Waiting on bites 3 and 6.
[The conversation reached its context limit here and continued from an automatic summary.]
09:31 Claude
Committed the ADR-821 extension as b9ed61a6c; now folding the seven authors’ corrections into the ADR-820 plan, then re-verifying and committing.
09:36 Claude
Regenerating the ADR’s model section, then re-running the check; waiting on the three re-dispatched authors in the background.
09:38 Claude
Check is green. Committing the ADR-820 plan, ADR, tests and index by explicit path, leaving the coordinator’s findings edits alone, then syncing the issue and board.
09:40 Claude
ADR-820 is Accepted and committed on main at 95affc0e1. Issue tvmsoftware/LedgerTM#820 and the board card are synced.
| Gate | Result |
|---|---|
prior_art.py --verify |
OK |
prior_art.py --contracts-check |
one flag, resolved by naming the wire currency fields as codes |
footprint.py --write |
written |
make adr-check |
green, exit 0 |
| Plan lines (excl. scenarios and footprint) | ~553 of 1600 |
What the phase B authors changed, now folded into ADR-820-plan.md and the ADR body:
- One declared wire body per door replaces three guessed ones; bites 3, 4 and 7 were re-dispatched and now post the same shape.
- Four simulate commands and seven
cards.*keys, not three and six. KindNoneon the processor enum. A reason on the provisioning receipt. - Six scenarios added for tests the authors had already written (connection mismatch, missing reference, provisioning with no decider, simulation refused, first fetch from seven days back, trading-date window).
- The ADR-821 symbols left the Relies-on table into a dependency note, because the Accepted check requires every symbol to exist in
src/and that lane has not landed.
Two things for you:
- ADR-821’s plan was extended additively (commit
b9ed61a6c) while its lane was already past bite 1. The coordinator has the sha and will route it to the lane for bite 2. - F-1572 is filed. [security finding, fixed: detail withheld]
Next: /ltm-partition ADR-820 once claude/machine-identity lands, then /ltm-design for the card aggregate and the oracle.
10:13 Claude
Told the coordinator that ADR-820’s Model section was already regenerated on main in 95affc0e1, so the ADR-821 lane must regenerate from a tree that includes that commit or the land will conflict. I will not touch ADR-820’s Prior art or Model on main from here.
Nothing else is pending on my side. ADR-820 stays Accepted, waiting on claude/machine-identity to land before /ltm-partition ADR-820.
Thursday 1 October 2026
08:37 Jeremy
check where we are with implementation and determine next steps
08:39 Claude
Both cards ADRs shipped last night. Here is where the series stands.
Shipped on main
| ADR | Landed | What it gives us |
|---|---|---|
| ADR-821 machine identity and institution connections | 0288fcb7b, 30 Sep | A processor authenticates as a connection; frame, keys, platform endpoints |
| ADR-820 card connectivity | 131d8b780, 30 Sep 22:26 | LedgerTM.Cards project, three doors, [redacted] adapter, simulator, clearing batch, processor page |
ADR-820’s outcome records all seven bites landed as designed, plus F-1572 fixed on the way (the request record now redacts card numbers at capture).
Loose ends from the land, all open in the findings queue
- F-1578 is the real one. A day-end re-run for an already closed date parks forever and nothing refuses it. Platform defect, not cards. Worth a fix item before the next lane leans on day-end.
- F-1584: the land script gated the lane tip, not the integrated tree. That is the coordinator’s process gap and should close before the next land.
- F-1579: the card-number rule now lives in two places (the test walker and the redaction). About 30 minutes to share one rule.
- F-1583: an intermittent red in tenant-secret tests, seen once at the land gate.
- The landing note promised
docs/business/models/card.mdat land. It does not exist. The next ADR’s grill reads the model page first, so it is the first thing to write.
Next steps, in order
- Write the card model page, then
/ltm-designthe card aggregate ADR: lifecycle, plastic, virtual and device credentials, controls, the funding rule. It takesCardCredentialand the deciders’ seams from ADR-820. About one session to design and grill. - Design the oracle ADR straight after, serially on main: check order, reason codes, partial approval, the hold on the card stream with the inline holds projection, real-time release and day-end expiry. This is the two-minute demo. A card without an oracle cannot be shown doing anything, so I would partition the two into one lane.
- Then the current account and overdraft ADR (unconditional clearing post), which the oracle needs for the funding account. It can design in parallel with the oracle’s build.
- Spend an hour on F-1578 and F-1584 before cutting the next lane, so the lane does not meet them at its land.
The proposal’s “clearing feed as a statement” brief is retired: ADR-820 made the clearing batch Cards-owned, and the hold-matching half moves into the oracle ADR. The proposal’s series section still lists it and should be marked so when the next ADR is written.
If you want to start now: say “design the card aggregate” and I will write the model page and open the issue.
08:41 Jeremy
ok, lets sort out 1578 and 1584 first
08:41 Jeremy (sent while the assistant was working)
desk is landing
08:42 Claude
Noted. I will stay off the desk until the land finishes, and do the read-only diagnosis of F-1578 and draft the land-script fix meanwhile. Nothing gets committed until the desk is back on main.
08:47 Claude
Patch and tests are drafted in the scratchpad; one existing test derives a batch id from the saga id and needs the same change. Reading it, then waiting for the desk land to apply everything.
08:47 Claude
Diagnosis and fixes are ready; I’m holding until the desk batch lands (still 41 ahead of main, gate presumably running). The background watch will wake me when uat is back level with main.
F-1578, root cause confirmed. The day-end saga is one document per tenant (day-end-{tenant}), deleted when a walk completes. Every batch step derives its batch id from that saga id plus the date, so a second run over the same date mints the batch id the first run already stored. The batch handler’s existence check then returns without dispatching, and the saga waits forever for a completion that was delivered to the previous run. Abort is a real production route into this: a run that finishes the account batch for a date and is then aborted leaves the date unchanged, and the next run parks.
Fix, in the scratchpad ready to apply: the step context carries the run id, and the four batch ids (account day-end, start-of-day, skipped-watermark lookup, suspense sweep) key on the run instead of the saga. A re-run over a closed date then walks an empty day and completes, which the account handler’s watermark already makes harmless. Repro test: DayEndRerunTests walks a day, sets the date back, walks it again, and expects two completed runs.
I did not add a refusal for re-running a closed date: the trading date can only move backwards through the test stub, so the refusal would fire nowhere in production.
F-1584, fix ready. The land script gains a merge of main into the lane before the gate, refusing on conflict and leaving the lane untouched. A new scripts/ltm-land.test.sh proves the gate is handed the post-merge sha and that a conflict refuses before any gate runs.
Once the desk lands I will enter it, apply both, run the script test and the component tests, and commit on uat.
09:02 Claude
Splitting the red-proof into plain steps for the worktree hook: capture the fix as a patch, revert it, build and run the repro, then restore.
09:02 Claude
Both proofs are running in the background: the whole script-test stage, and the repro test against the unfixed source (expected to fail after its two-minute wait). I will restore the fix, rebuild and commit once they report.
09:03 Claude
The script-test stage is green with the new cases. Waiting on the unfixed-tree repro run; nothing else to request until it reports.
09:06 Claude
Waiting on the second unfixed run to see whether the ten-second disposal repeats; the background task will report when it finishes.
09:07 Claude
Build running; the component and unit runs follow once it reports.
09:09 Claude
Component run in progress; the unit and architecture suites follow after it, since overlapping runs break the timing tests.
09:12 Claude
The one red in the component run is SimulatedSuspenseTests, a sixty-second tracked-window timeout with blank-reason validation failures underneath, which does not touch batch ids. I will re-run it alone once the unit suite finishes, to tell a flake from a regression.
09:14 Claude
The unit test now reads “varies by run and date”; I will run it after the lone suspense re-run reports, to keep the runs from overlapping.
09:14 Claude
The lone suspense re-run passed all eight tests, so the earlier red was the sixty-second tracked window under load, not the batch-id change. Waiting on the corrected unit test, then committing.
09:15 Claude
Both findings are fixed and committed on the uat desk, not pushed. The coordinator has the shas and will close the findings at the desk land.
| Commit | Fix | Proof |
|---|---|---|
| 3a2e7ca82 | F-1578: day-end batches keyed by the run, not the per-tenant saga | DayEndRerunTests red on the unfixed tree (second run stuck Running for two minutes), green fixed |
| 561c56001 | F-1584: the land merges main into the lane before gating, refuses on conflict |
two new cases in scripts/ltm-land.test.sh, red without the fix, whole script-test stage green |
F-1578, what changed. The step context now carries the run id, and the four batch steps (account day-end, start-of-day, the skipped-watermark lookup, the suspense sweep) derive their batch id from it. A re-run over a closed date walks an empty day and completes; the account handler’s watermark already makes that harmless. Abort was a real production route into the park, so this matters beyond the test stub. One existing unit test asserted “varies by saga and date” and now reads “varies by run and date”.
Not done, on purpose. No refusal for re-running a closed date: the trading date can only move backwards through the test stub, so it would fire nowhere in production.
Verification. Build green; the day-end, suspense and card-clearing component filter green except one timing red in the suspense simulation that passed alone (sixty-second tracked window under load, one occurrence, not filed); unit and architecture suites green. A full clean-checkout run is the desk land’s job.
Next: the card model page and /ltm-design for the card aggregate, when you want to start.
09:15 Claude
The coordinator has acknowledged both commits and will gate and land them as the next desk batch, closing F-1578 and F-1584 at that land. Nothing further is pending on my side; the desk is clean and I am still in it, ready for the card model page and the card aggregate design when you say.
14:32 Jeremy
next step?
14:32 Claude
Both fixes landed on main (0b210398e) and the findings are closed. The desk is clean.
Next step: design the card aggregate, the second ADR of the cards series. In order:
- Write the model page
docs/business/models/card.mdfirst. ADR-820’s land promised it and it does not exist. The grill reads the model before the ADR, so without it the design cannot be grilled. /ltm-design“Cards and Authorisation: the card aggregate and its credentials”: lifecycle, plastic, virtual and device credentials, controls, the funding rule. It takesCardCredentialand the two decider seams from ADR-820.- Grill it, plan it, then design the oracle ADR straight after on the same model page, so the two can partition into one lane. The oracle is the two-minute demo; the aggregate alone cannot be shown doing anything.
Design is serial on main, so I would leave the desk and work in the main checkout. Say “go” and I start with the model page.
14:33 Jeremy
go
14:35 Claude
Model page drafted and indexed. Now minting the card aggregate ADR through the design skill.
14:38 Claude
Writing ADR-835 now; every seam it names is confirmed on the contract surface.
14:42 Claude
Adding the operations-engine decision the check surfaced (ADR-744/757: the card’s verbs are linked entries in DispatchedOperations), then re-running the checks.
14:44 Claude
ADR-835 is committed (5dc10baa3), issue tvmsoftware/LedgerTM#835 is on the board at Proposed, and make adr-check is green. Starting the grill.
14:45 Claude
Model read (card.md, drafted today) and the ADR walked screen by screen. Most silences I can close with a position; one is a scope call that changes the oracle too.
Grill — a demo clerk opens a card and the first control they look for is a daily limit, and the ADR offers only a per-transaction ceiling. Options:
- Declare daily and monthly ceilings now (recommended). Extend ADR-820’s
CardControlswithDailyCeilingandMonthlyCeilingas nullable amounts in the billing currency, set and shown here, evaluated by the oracle ADR, which already sums holds on the card’s stream. Cost here: one record change and two form fields. Cost there: one sum per decision. The demo shows a limit, and the spend-controls ADR inherits the shape instead of reshaping it. - Leave velocity to the spend-controls ADR. Smaller now; the first demo question goes unanswered and a later ADR changes a shipped contract type.
Which one?
15:01 Jeremy
option 1 - this in addition to the overall customer credit limit and card facility?
15:02 Jeremy (sent while the assistant was working)
ah - that would be a function of the account, not the card
15:06 Claude
Press found two pairs, both wording; folding them and writing the grill record.
15:08 Claude
Grill done and committed (75cf12df9); ADR-835 stays Proposed until the plan grill. Moving to the plan.
15:08 Jeremy (sent while the assistant was working)
let me grill. i am looking at my [redacted] private banking card. firstly will this allow us (and a customer through the portal) to add virtual cards. if i look at one of my virtual cards it has following
- card display name
- expiry date and cvv (hidden with reveal)
15:08 Jeremy (sent while the assistant was working)
hold for more of my questions
15:08 Claude
Holding the plan. On your first two points:
- Virtual cards: yes, the bank issues them in this ADR (a virtual card is active on issue). A customer adding one through the portal is a client-channel operation, which the proposal puts in the spend-controls ADR; this one builds the record that operation would create. If you want the portal verb in this ADR, say so and I will pull it forward.
- Card display name: we have the embossed name only. A customer-chosen label (“Groceries card”) is missing and cheap to add: a
DisplayNameon the card, editable by the bank now and by the cardholder when the portal verb arrives. I would add it. - Expiry and CVV with reveal: expiry we hold. The CVV we never hold, by design (PCI scope). Reveal works by asking the processor for a short-lived reveal token and showing its hosted view in the app, so the number and CVV cross from the processor to the customer’s screen and never through us. That needs one more seam on
ICardProcessor, a reveal token, which ADR-820 did not declare. I would add it here as an additive change.
Go on with your questions.
15:10 Jeremy
it also has switches for contactless, atm withdrawals, online purchases, local in store, international in store. and use internationally with a start and end date and visiting countries. there is also an option to pause the card. and cancel. and a pin option (I assume to reveal)
15:10 Claude
All of that maps onto the card, and most of it is already there under different names. Here is the mapping, with what I would change:
| [redacted] | Ours today | Change |
|---|---|---|
| Contactless, ATM, online | ContactlessAllowed, AtmAllowed, OnlineAllowed |
none |
| Local in-store, international in-store | one switch, AbroadAllowed |
split into InStoreAllowed and InStoreAbroadAllowed; the oracle reads card-present plus merchant country |
| Use internationally, start and end date, visiting countries | nothing | a travel window on the card: from, to, a list of countries (ISO 3166 alpha-2). Inside the window a card-present transaction in a listed country is allowed even with international in-store off. Set by the bank now, by the cardholder when the portal verb arrives |
| Pause | Suspend by the bank |
the verb exists; the portal exposes it later |
| Cancel | Close, or ReportLostOrStolen then reissue |
the verbs exist |
| PIN | nothing | the same reveal seam as CVV: ask the processor for a short-lived reveal session for PAN, CVV or PIN and show its hosted view; a PIN change is also the processor’s, through the same seam |
So the additions to the ADR from your card so far: a display name, five switches instead of four, a travel window, and one reveal seam on ICardProcessor covering card details and PIN. Every one of them is on the record the portal operations will later read, so pulling them in now costs little and saves a shipped-type change later.
Still holding for the rest.
15:11 Jeremy
thats it
15:12 Claude
Folding your four into the ADR: display name, the five switches, the travel window, and the reveal seam.
15:19 Claude
Plan written and the bites moved out of the ADR. Running the plan’s gates now: footprint, prior-art verify, the contracts check, the scenario-to-criterion check, index and adr-check.
15:19 Claude
All gates are green. The one contracts-check line (Counterparty) is a string literal inside a Target, not a type reference. Dispatching the phase A question pass.
15:25 Claude
Phase A came back with 27 questions and a type census. Most are mine to settle; I am taking positions on all of them and folding them in, then running the plan grill on the folded plan.
15:40 Claude
Fixing one unescaped quote in the fold script, then applying it.
15:42 Claude
Six test authors are writing the acceptance tests for the six bites in the background; all gates on the plan are green (fifteen scenarios, fifteen test rows, 476 counted lines against a cap of 1600). While they run, nothing else depends on them, so I will wait for their hand-backs, fold any assumptions they raise, then set ADR-835 to Accepted, sync and commit.
15:45 Claude
Bite 1 is in (one scenario plus ten unhappy-path methods). Three things from it to fold once the rest land: the row id must not throw for a blank key, three more vocabulary refusals (a type with only device tokens, no fundable types, a cap below one), and one stale “published by the decider” line in the ADR. Waiting on bites 2 to 6.
15:45 Claude
Still waiting on bites 2 to 6; nothing to act on until they report.
15:48 Claude
Bite 2 is in: three scenario methods and twenty unhappy paths. Noted for the fold: the fixture needs a second ZAR call deposit and one non-fundable account for the shape and type refusals, the issue handler must check the stream before calling the processor so a re-sent issue cannot mint twice, controls are validated at issue too, and free text (display name, reasons) refuses anything shaped like a card number. Waiting on bites 3 to 6.
15:48 Claude
Two of six authors are back; waiting on bites 3 to 6 before folding.
15:48 Claude
Bite 5 is in. Fold items noted: the first provisioning request names the device token too; reveal is allowed on Ordered and Active only, so a suspended card cannot reveal its PIN; the door cascades the credential only when the token resolves to a card, so ADR-820’s scripted door tests stay green; a removed device token that re-provisions becomes a new open credential. Waiting on bites 3, 4 and 6.
15:48 Claude
Three of six back (bites 1, 2, 5). Waiting on 3, 4 and 6.
15:49 Claude
Bite 3 is in. Two corrections it surfaced that affect other bites: domain refusals (status, cap, funding) are 422 through the existing exception handler and only validator refusals are 400, so bites 2 and 5 need their status codes aligned; and the status guards become one table equal to the operations menu, with Report lost or stolen offered at Ordered too for plastic lost in the post. Waiting on bites 4 and 6, then one fold and a re-dispatch for the status codes.
15:49 Claude
Four of six back. Waiting on bites 4 and 6.
15:50 Claude
Bite 6 is in with the seed and menu tests. Noted for the fold: statuses for remove-credential and reveal in the menu, a parity test between the menu and the aggregate’s guards (two mechanisms answering one question), the issue chain must carry the command-type header so the card’s history names the act, and the simulator honours the idempotency reference so a re-run seed cannot mint twice. Waiting on bite 4, the last one.
15:51 Claude
Five of six back; only bite 4 outstanding.
15:51 Claude
All six authors are back. Folding their corrections in one pass, then re-dispatching bites 2, 3, 5 and 6 for the two cross-cutting changes: refusal status codes (validator 400, domain 422) and the final status table.
15:54 Claude
The fold is in and the five authors are aligning their files to it; adr-check on my files is green (the one red is another session’s uncommitted ADR-722 edit, reported to the coordinator). Waiting on the authors’ hand-backs, then Accepted, sync and commit.
15:55 Claude
Bite 6 aligned. Waiting on bites 1, 2, 3 and 5.
15:55 Claude
Bites 1 and 6 aligned; the type id now guards on the key pattern. Waiting on bites 2, 3 and 5.
15:56 Claude
Bites 1, 5 and 6 are aligned; bite 3 is flipping one expectation (a suspended card stays suspended through a reissue). Waiting on bites 2 and 3, then Accepted, sync and commit.
15:56 Claude
Waiting on bite 2’s realignment and bite 3’s last added test.
15:56 Claude
Bite 3 complete. Only bite 2’s realignment remains before the Accepted flip.
15:56 Claude
Still waiting on bite 2.
15:59 Claude
ADR-835 is Accepted and committed on main at cb4498e0a. Issue tvmsoftware/LedgerTM#835 and the board card are synced; the coordinator has it for partition.
| Gate | Result |
|---|---|
| Grilled and queued | Accepted |
| Plan exists, every bite has a criterion | yes, six bites |
| UI sweep recorded | yes, no existing surface repointed |
| Files touched per bite | yes |
make adr-check |
green, exit 0 |
| Plan lines counted against the cap | 476 of 1600, excluding scenarios and footprint |
What the planning passes changed, beyond your grill:
- A reveal is a command that leaves
CardDetailsRevealedon the card’s stream, so PCI’s access log exists and the address is redacted from the request record. - The provisioning seam now answers with a reason, and the door records the device credential only after its approved receipt commits. A wallet is approved only when the processor names the device token.
- The status guards and the operations menu are one table, with a parity test. Report lost or stolen is offered for a plastic card still in the post; a suspended card stays suspended through a reissue; Suspend and Report lost are exempt from four-eyes as protective acts.
- Refusals follow the host: 400 for a format validator, 422 for a domain rule. Free text refuses anything shaped like a card number.
- The processor is not told the travel window yet. Recorded as a stand-in gap in the ADR, not hidden.
Tests: six files under docs/adr/ADR-835-tests/, fifteen scenarios plus roughly seventy unhappy-path methods, uncompiled until bite 1 exists. Three of ADR-820’s shipped types change shape two days after landing; nothing stored holds them beyond simulation data.
Next: the oracle ADR, on the same model page, so the two can partition into one lane. Say “design the oracle” when you want to start.
Friday 2 October 2026
14:56 Jeremy
835 is done can we design the rest?
14:57 Claude
Yes. The proposal’s series still has eight ADRs to design after ADR-835. Design is serial, so I will take them in dependency order, one grill at a time with you:
- The authorisation oracle and the card hold (the demo).
- The current account, the overdraft facility and the unconditional clearing post.
- Card renewal and replacement at day-end.
- The revolving credit card, corrected.
- The dispute aggregate.
- Corporate card controls and just-in-time funding (spend controls).
- The attribute-banded price card.
- The merchant and the merchant account, then the rolling reserve (acquiring, last).
Starting with the oracle now.
15:06 Claude
Grill of ADR-836, one question. Model page read; the UAT walk raised one call that is yours, not mine.
Grill — the door’s budget runs out after the oracle has already placed a hold. The processor then falls back to its stand-in rules and may approve the purchase anyway; we never learn which. The draft releases our hold at once (the money is free again, and a stand-in approval arrives days later as an unmatched clearing line). Options:
- Keep the hold when we fail to answer (recommended). It expires by merchant category or clears when the line arrives. Costs the customer up to seven days of committed money on a tap the stand-in may have declined; protects the bank from spending twice. This is what a conservative issuer does.
- Release it at once, as drafted. Frees the customer immediately; the bank wears an unarranged overdraft if the stand-in approved and the account is drained before the line clears.
Which one?
15:12 Jeremy
option 1, go with your recommendations
15:18 Claude
Grill committed (442243a39). Moving to the plan for ADR-836: reading the seams it changes before writing the files-touched list and the interfaces.
15:23 Claude
All gates on the ADR-836 plan are green (twelve scenarios, sixteen test rows, 311 counted lines). Dispatching the phase A question pass.
15:47 Claude
Both halves of the fold are in. Writing the plan-grill record into the ADR and the plan, then re-running every gate.
15:48 Claude
Gates green. Dispatching the six phase B authors in one batch.
15:49 Claude
Six authors are writing ADR-836’s acceptance tests in the background. Nothing else depends on them until they report; I will fold their assumptions, flip the ADR to Accepted, sync and commit when all six are back.
15:54 Claude
Bite 6 is in with eight methods. Noted for the fold: two stale bite-table rows (the dropped documents, the facility), PositionDto.HeldExternally to declare, a released hold’s remaining amount reads zero, and the release names the processor’s reversal reference rather than our id. Waiting on bites 1 to 5.
15:54 Claude
One of six back; waiting on bites 1 to 5.
15:54 Claude
Bite 2 is in with twelve methods. Two things it caught that I will fix in the fold: the plan listed card closure under bite 2’s files while bite 4 owns it, and a reduction’s cause is the processor’s reversal reference as a string, matching bite 6. Waiting on bites 1, 3, 4 and 5.
15:55 Claude
Two of six back; waiting on bites 1, 3, 4 and 5.
15:56 Claude
Bite 1 is in with seventeen methods. Decisions it needs folded: expiry bands stay disjoint (a narrower exception is a split band, not an override), days are capped at thirty-one, the domestic country is nullable and never required, and ADR-820’s merchant-category converter must answer a malformed code as a 400. Waiting on bites 3, 4 and 5.
15:56 Claude
Three of six back; waiting on bites 3, 4 and 5.
15:57 Claude
Bite 4 is in with nine methods and three real findings: the simulator clears every approval the same day, so the demo could never show a hold expiring (the simulate command gains a “does not clear” switch); marking the old reason obsolete would break the build under warnings-as-errors (it stays as a plain member that nothing produces); and the release’s cause is the processor’s reversal reference. Waiting on bites 3 and 5.
15:57 Claude
Four of six back; waiting on bites 3 and 5.
15:58 Claude
Bite 3 is in with twenty-two methods. Positions to fold: presence comes from the request’s card-present flag and the channel only picks the switch; an ATM tap abroad is a card-present tap for the country check; the currency check sits after the credential check in Decision 1’s table; spend counts every hold placed in the period, whatever became of it; the conflict-and-retry path gets a unit test since no component test can reach it. Waiting on bite 5.
15:59 Claude
Five of six back; only bite 5 (the clearing post) outstanding.
16:00 Claude
All six authors are back. Folding their corrections in one pass, then re-dispatching bites 2, 4, 5 and 6 for the cross-cutting rulings.
[The conversation reached its context limit here and continued from an automatic summary.]
16:05 Claude
Two new names in ## Changed need prior-art rows. Adding them.
16:06 Claude
Gates green. Bite 6 is back. Waiting on 2, 4, 5 before flipping to Accepted.
16:06 Claude
Bite 2 done. Waiting on 4 (correction) and 5.
16:07 Claude
All six aligned. Flipping to Accepted, re-gating, syncing the board, committing.
16:07 Claude
Gates green. Syncing issue #836 and the board, then committing.
16:09 Claude
Committed. Telling the coordinator it is partitionable.
16:09 Claude
ADR-836 is Accepted and committed at 02fb3134b. Starting the next ADR in the series: the current account, the overdraft facility and the clearing post that outranks the guard.
16:13 Claude
Design reading for the current-account ADR is nearly done. Checking the last mechanics: how facility usage reads a liability position going negative, and where the honouring fee can attach.
16:17 Claude
Reading finished. Minting is done: issue 837 is the ADR number. Checking the tag vocabulary and the demo customer’s name, then writing the ADR.
16:23 Claude
Self-grilling ADR-837 while the contradiction press runs. Checking two things the grill turned up: whether the regime vocabulary resolves for the GB preset, and whether a lookup property can default.
16:24 Claude
Grill positions are drafted. Waiting for the contradiction press on ADR-837 before writing the grill section and moving to the plan.
Status so far:
- ADR-836 is Accepted and committed at 02fb3134b with its plan and 17 cold tests. The coordinator has been told it is partitionable.
- ADR-837 (current account, overdraft facility, unconditional clearing post) is drafted, gated green and committed at 88523ec0b as Proposed, with issue 837 and its board card.
Two grill findings I have already taken a position on, for you to overrule if you disagree:
- Which limit is the overdraft. The corporate proposal reads the customer’s credit limit as “an overdraft”. I chose a
Facilityof typeOverdraftwired to the current account, with the credit limit wired to the same position so it sees the exposure too. Reason: the overdraft is a priced product limit, the credit limit is the customer’s overall cap. - A shared facility under-counts excess. A facility is per customer, so two overdrawn current accounts in one currency each read their excess against the whole limit. I accept this with the expectation of one current account per customer per currency, and name the per-account facility as the fix.
16:25 Claude
The press found one real defect: Current + FacilityAvailable double-counts the draw once the balance is negative. Fixing the symbol definitions and folding the nine pairs into the grill section.
16:28 Claude
Grill folded and gates green. Committing the grilled ADR, then starting /ltm-plan ADR-837.
16:32 Claude
Plan written, bites moved. Running the plan gates: footprint, contracts check, prior-art verify, the criterion-naming check, index and adr-check.
16:33 Claude
The plan draft for ADR-837 is committed. Phase A (the cold author’s question pass) is running; the plan grill follows it, then phase B writes the tests. I will fold the answers, flip ADR-837 to Accepted, and commit when all three are back.
16:41 Claude
Phase A is back with 27 questions and a type census. Ruling on them now; two need a quick code check first.
16:45 Claude
The Write was refused because footprint.py had touched the file. Re-reading and writing the plan again, then re-running the gates.
16:49 Claude
Phase A is folded and committed. The plan grill is running on the signatures. When it returns I fold its press points, dispatch the six phase B test authors, then flip ADR-837 to Accepted, sync and commit.
16:56 Claude
The plan grill returned 14 press points, several real (the fee replay under revaluation, the reader’s tenancy, usage from the balance rather than the delta). Ruling and folding now.
16:59 Claude
All gates green: 16 scenarios, 18 test rows, 324 counted lines. Committing the folded plan and dispatching the six phase B authors in one batch.
17:00 Claude
Six phase B authors are writing ADR-837’s cold tests, one per bite. When all six are back I fold their assumptions, flip ADR-837 to Accepted, sync the issue and board, and commit.
17:04 Claude
Bite 4 is back with two ambiguities I will rule on in the fold: a hold never reserves on the facility (ADR-836’s reductions sit on the account), and the guard bag already subtracts card holds, so screen, teller guard and oracle agree. Waiting on bites 1, 2, 3, 5 and 6.
17:04 Claude
Noted. Still waiting on bites 1, 2, 3, 5 and 6 before folding.
17:06 Claude
Bite 1 is back. Two of its findings go into the fold: the day count lives on the rate rows, not the type (the YAML key I wrote has no home), and the current account needs the call deposit’s servicingUnit and tax-reporting properties. Waiting on 2, 3, 5 and 6.
17:06 Claude
Noted. Four authors still writing.
17:08 Claude
Bite 6 is back. Rulings for the fold: a frozen facility shows its amount with a frozen flag rather than a bare zero, the detail test moves to bite 5 (it would be green before bite 6 starts), and bite 6’s own test becomes a viewer test of the tiles. Waiting on bites 2, 3 and 5.
17:08 Claude
Noted. Three authors remain.
17:09 Claude
Bite 3 is back with six extra scenarios worth keeping. Rulings for the fold: asks land on the lines that cross zero, a transfer past zero with no facility is refused as a missing facility, an owner change carries the drawn 800 to the new owner’s overdraft. Waiting on bites 2 and 5.
17:09 Claude
Noted. Bites 2 and 5 remain.
17:10 Claude
Bite 2 is back with one real catch: on this platform a debit order is the bank collecting into the account, so the outbound scenario must be the standing order. That and a day-walk scenario for bite 2 go into the fold. Waiting on bite 5.
17:10 Claude
Noted. Only bite 5 is still writing.
17:14 Claude
All six authors are back. Bite 5 found a real seam defect: the revaluation cascade fires only for a value date strictly before the last processed day, so a posting dated the closed day never re-walks it. That also undercuts ADR-836’s day-late clearing claim. Folding all six reports now.
17:16 Claude
Folded. Re-dispatching bites 1, 2, 5 and 6 for the corrections that touch their files, running the gates, and telling the coordinator about the revaluation finding, all in parallel.
17:17 Claude
Gates green: 26 scenarios, 28 test rows, 403 counted lines. Four authors are aligning their files; when they are back I flip ADR-837 to Accepted, sync and commit.
17:18 Claude
F-1791 recorded in the plan. Waiting on the four re-dispatched authors.
17:18 Claude
Ruled: the shown limit is the facility’s amount, shared or not. Bite 6 is done; three authors remain.
17:20 Claude
Pinning down where named rates like Call are seeded, so the plan names the right file for the overdraft rates.
17:22 Claude
Rate ruling folded and sent to bites 1, 2 and 5. Running the gates on the folded plan while they align.
17:22 Claude
Gates green: 28 scenarios, 418 counted lines. Waiting on bites 1, 2 and 5 to hand back; then Accepted, sync, commit.
17:22 Claude
Bite 1 done. Two remain.
17:22 Claude
Noted. Waiting on bites 2 and 5.
17:22 Claude
Bite 5 done. Only bite 2 remains.
17:22 Claude
Noted. Waiting on bite 2.
17:22 Claude
All six aligned. Flipping ADR-837 to Accepted, re-gating, syncing the issue and board, and committing.
17:23 Claude
Gates green at Accepted. Syncing the issue body and the board, then committing.
17:24 Claude
Next in the series is the revolving credit card. Reading the dormant template, the proposal’s credit-card section and the existing statement, allocation and rate-cap mechanisms before designing it.
17:29 Claude
Reading is done. Writing ADR-838 (the revolving credit card) now, then the gates, the board card and the commit.
17:31 Claude
Gates green for ADR-838 as Proposed. Syncing the issue and board, committing, and launching the contradiction press in parallel.
17:34 Claude
Self-grill fold applied (the catch-up now prices the due day too, and the day-walk binds each schedule’s last and previous occurrence). Waiting for the contradiction press before writing the grill section and committing.
17:35 Claude
Grill folded, gates green. Committing the grilled ADR-838 and starting its plan.
17:38 Claude
Plan gates green (Transaction only appears inside an Accounts-internal signature, so the contracts check is clean). Committing the plan draft and dispatching phase A.
17:39 Claude
ADR-838’s plan draft is committed and phase A is running. Progress so far this session:
- ADR-836 Accepted at 02fb3134b (oracle and hold).
- ADR-837 Accepted at e9e0c2a37 (current account and overdraft), with F-1791 filed against the revaluation seam.
- ADR-838 (revolving credit card) is Proposed and grilled at b678e0efa, plan draft at 64fa09a4a; phase A, the plan grill and phase B follow, then Accepted.
Two positions I took on ADR-838 you may want to overrule:
- One new expression function,
positionDays. The day-weighted balance of a position over a period. It makes the interest-free catch-up one row of configuration and prices any average-daily-balance product. The cheaper option was a hard-coded catch-up step in Accounts, which only credit cards could use. - The revolving limit is wired to a roll-up
Outstandingposition. A limit integration wires one position, and a credit card has three balances. The alternative was a list of positions on the integration, a contract change every loan would carry.
17:48 Claude
Phase A for ADR-838 is back with four real design catches: the catch-up window double-charges a previous statement paid in full inside it, the card’s available must net the account’s own draw on a Raise wire, the arrears move double-counts as on the microloan, and the NCA permits no over-limit fee. Ruling and folding.
17:51 Claude
Phase A folded; gates green. Committing and dispatching the plan grill.
17:52 Claude
The plan grill for ADR-838 is running. When it returns I fold its press points, dispatch the five phase B authors, then flip ADR-838 to Accepted, sync and commit.
18:01 Claude
The plan grill found two structural defects: triggered rows only run inside the day-walk, so a live payment would never allocate, and positionDays replays history that a re-walk cannot reproduce. Taking the grill’s cheaper option: deferred interest accrued daily into memorandum positions and released at the due date, which drops the new function entirely. Rewriting the affected decisions and the plan.
18:06 Claude
Gates green: 11 scenarios, 287 counted lines. Committing and dispatching the five phase B authors in one batch.
18:07 Claude
Holding main at the coordinator’s request while their push gates. The five ADR-838 phase B authors are writing; when they are back and the hold lifts, I fold, flip ADR-838 to Accepted, sync and commit.
18:08 Claude
Main is open again. Waiting on the five phase B authors for ADR-838.
18:12 Claude
Bite 5 is back. Rulings for the fold: headline lives on the type’s position binding and is served by the account-type read, the detail’s facility figure for an asset type is the oracle’s figure (holds included) with a parity scenario tying the two, and ADR-837 ships overdraft while ADR-838’s bite 1 renames it to facilityHeadroom. Waiting on bites 1 to 4.
18:12 Claude
Noted. Four authors remain.
18:14 Claude
Bite 4 is back. Rulings for the fold: a waiting credit is spendable (available adds it back), the cash branch drains fees before the cash advance so a credit never strands the fee, the annual fee first falls a year after opening, and a load-time check will refuse a roll-up wire with a missing Outstanding leg. Waiting on bites 1, 2 and 3.
18:15 Claude
Noted. Three authors remain.
18:15 Claude
Bite 2 is back; its rulings join the fold: the first annual fee falls a year after opening, the due figures fall by the whole payment, a close posts its statement rows even at zero, and the cycle’s set and reset rows belong to bite 2. Waiting on bites 1 and 3.
18:15 Claude
Noted. Bites 1 and 3 remain.
18:16 Claude
Bite 1 is back; it caught a wrong figure in my scenario (the symbol reads the full 100 000; the 40 000 is the headroom after the draw). Rulings for the fold: a named rate that cannot be priced on the agreement date refuses activation rather than failing open, and each named rate reference is checked on its own. Waiting on bite 3.
18:16 Claude
Noted. Only bite 3 is still writing.
18:17 Claude
All five ADR-838 authors are back. Bite 3 caught a rounding fact: the deferred rows round to four decimals, so the catch-up is 302.46, not 302.47. Folding all five reports now.
18:22 Claude
Phase B is folded into ADR-838 (gates green, 23 scenarios). Three authors are aligning their files; when back I flip ADR-838 to Accepted, sync and commit.
18:22 Claude
Bite 5 aligned (the waiting-credit term is covered by bite 4’s scenario). Waiting on bites 3 and 4.
18:22 Claude
Noted. Bites 3 and 4 remain.
18:23 Claude
Bite 4 aligned (the plan file now carries F21 to F30 on disk, so its citations will match). Waiting on bite 3.
18:23 Claude
Noted. Only bite 3 remains.
18:24 Claude
All five aligned. Fixing the two figures bite 3 caught (325.48; the next minimum adds whatever arrears still stands at the close), then Accepted, sync and commit.
18:25 Claude
Gates green at Accepted. Syncing issue 838 and the board, committing, and telling the coordinator.
18:26 Claude
ADR-838 is Accepted and committed. Starting the next ADR in the series: card renewal and replacement at day-end. Reading what ADR-820 and ADR-835 already give a credential’s life.
18:31 Claude
ADR-839 is committed as Proposed and its contradiction press is running. Gathering the last file locations for its plan while the press works.
18:34 Claude
ADR-839 is grilled and committed as Proposed with its plan draft; phase A is running. Nothing else to request until it returns.
Series status this session:
| ADR | Subject | State |
|---|---|---|
| 836 | authorisation oracle and card hold | Accepted |
| 837 | current account, overdraft, unconditional clearing post | Accepted (owns F-1791) |
| 838 | revolving credit card | Accepted |
| 839 | renewal, replacement, card fees at day-end | Proposed, plan drafted, phase A running |
Two positions I took on ADR-839 that you may want to overrule:
- A fee never blocks a card act. Replacement, issuance and renewal fees are cascaded after the card’s commit to the first funding account, and a refused fee dead-letters rather than undoing a renewal. The cheaper option was posting the fee inside the handler, which would make a closed funding account block a lost-card replacement.
- The simulated tenant renews monthly. A simulated credential life of one month on the processor facet lets a prospect watch a renewal on day two; a live processor ignores the field.
18:40 Claude
Phase A for ADR-839 is back with 24 questions; several are real: the external-source dispatcher binds no price lookup, a virtual card is issued already active so it would never pay an issuance fee, device tokens keep the old expiry on renewal, and the one-month simulated life cannot show a renewal on day two. Ruling and folding.
18:42 Claude
Phase A folded, gates green. Committing and dispatching the plan grill.
18:43 Claude
The plan grill for ADR-839 is running; nothing else is needed until it returns. After it, I fold, dispatch three phase B authors, then flip ADR-839 to Accepted, sync and commit.
18:49 Claude
The plan grill found real seams: the renewal needs its own verb (the status table refuses a same-number reissue on a suspended card), fee ids derive from facts not a version, the external-source path binds neither price nor value date, and moving device-token expiries would change ADR-835’s event meaning — so the oracle will skip expiry on device tokens instead. Folding.
18:51 Claude
Gates green. Committing the fold and dispatching the three phase B authors in one batch.
18:53 Claude
The three ADR-839 phase B authors are writing. When they are back I fold their assumptions, flip ADR-839 to Accepted, sync the issue and board, commit, and tell the coordinator. Nothing else can usefully run until then.
19:01 Claude
Bite 3 is back. Rulings for the fold: one clock for every simulated expiry (the trading date), the step’s record count is the renewals with refusals in the note, both the card-type and the facet amend check the lead against the simulated life, the seed runs the same validator and orders itself before the sample cards, and the simulator keeps each card’s life for its reissue. Waiting on bites 1 and 2.
19:01 Claude
Bite 1 is back and caught stale lines from the earlier folds that I will correct; one ruling for the auditor’s seat: a fee forgone on a closed account is recorded as a card event, not just a log line. Waiting on bite 2.
19:01 Claude
Noted. Bite 2 is the last author still writing.
19:02 Claude
All three authors are back. Folding their reports, including the stale lines they caught from earlier folds, then re-dispatching bites 1 and 2 for the two rulings that change their assertions.
19:04 Claude
Gates green with 17 scenarios. Re-dispatching bites 1 and 2 for the two rulings that change their assertions; bite 3 needs no change.
19:04 Claude
Two authors are aligning their files. When both are back I flip ADR-839 to Accepted, sync and commit.
19:05 Claude
Bite 2 aligned. Waiting on bite 1.
19:05 Claude
Noted. Only bite 1 remains.
19:06 Claude
All three aligned. Flipping ADR-839 to Accepted, re-gating, syncing and committing.
19:07 Claude
ADR-839 is Accepted and committed. Starting the next ADR in the series: disputes and chargebacks. Reading what the proposal, ADR-261 and ADR-836 already give a dispute.
19:13 Claude
ADR-840 (disputes) is committed as Proposed and its press is running. Writing its plan draft now, since the plan does not depend on the press result.
[The conversation reached its context limit here and continued from an automatic summary.]
19:21 Claude
Press folded into ADR-840 and the plan is drafted; gates green. Committing the draft, then dispatching phase A.
19:22 Claude
ADR-840’s press is folded (12 pairs) and the plan is drafted and committed at d99528430. Phase A is running.
What the press changed:
- The won reversal is the credit. Under
OnOutcomenothing posts before the outcome;Neverwas the same thing and is gone. - A lapse belongs to whoever let it. The merchant’s lapse is the cardholder’s win, the bank’s is the merchant’s. Day-end only marks
Overdue; the processor’s word closes. - What may be disputed: any clearing-line posting, never more than the line less refunds, never past the filing limit. A chargeback clearing line is settlement, posts nothing.
- A clawback on a closed funding account is recorded as forgone and raises a task.
Next: fold phase A, plan grill, phase B, Accepted, board sync, coordinator.
19:32 Claude
Phase A returned 39 questions. Ruling on them and folding into ADR-840 and the plan now.
19:37 Claude
Gates green. Committing the phase A fold and dispatching the plan grill.
19:38 Claude
Phase A folded and committed at b7b70c61a. The plan grill is running; nothing else to do until it reports.
What phase A changed:
- The won purchase is credited back-dated, not reversed. ADR-261’s reversal ignores an amount, so a partial dispute could never use it.
- The bank’s Accept closes
Lost;Acceptedis the merchant’s concession, reported by the processor. - The clearing post keeps an index of its postings, so the raise can find the card and the line.
- Tasks only on the bank’s windows; a merchant’s lapse is a win, not a deadline.
- A dispute posting on an inactive account is forgone and tasked, the raise is not refused.
19:51 Claude
Now the plan: rewriting Files touched, Interfaces, Bites, Scenarios, Scenario → test, Notes and Landing notes in full.
19:55 Claude
Plan grill folded and committed at 9a9c7df91. Dispatching phase B: six authors, one per bite.
19:56 Claude
ADR-840’s plan grill is folded and committed at 9a9c7df91. Six phase B authors are writing the cold tests now.
What the grill changed, in money terms:
- One credit, value-dated as the purchase. The plan had a provisional credit today, a won credit back-dated, and a reversal between them. On a credit card that would have left 12 000 unallocated while the re-walk charged catch-up interest and a late fee on a dispute the customer won. Now the credit is back-dated whenever it posts, is final on a win, and a loss re-debits today as the schemes do.
- The chargeback line records settlement and never closes. The scheme moves the money a day after the raise, so closing on it would have won every dispute on day two.
ConcedenotAccept; parity in whole currency units;onRevaluation: AsRecordedas a generic row flag;AttachmentIdmoves to Contracts.
One thing for you: the AsRecorded row flag is engine configuration reusable beyond disputes. It stays in ADR-840 as bite 1 for now; it could be split into a small engine ADR if you prefer the separate-ADR route.
20:04 Claude
Bite 6’s author is back; waiting for the other five before folding.
20:04 Claude
Still waiting on bites 1 to 5.
20:05 Claude
Bite 3 is back too. Three of six in; waiting on bites 1, 2, 4 and 5.
20:05 Claude
Still waiting on bites 1, 2, 4 and 5.
20:05 Claude
Bite 5 in. Waiting on bites 1, 2 and 4.
20:05 Claude
Waiting on bites 1, 2 and 4.
20:06 Claude
Bite 2 in. Waiting on bites 1 and 4.
20:06 Claude
Waiting on bites 1 and 4.
20:09 Claude
Bite 1 in. Only bite 4 outstanding.
20:09 Claude
Waiting on bite 4.
20:12 Claude
All six authors are back. Folding phase B now; the one design-level finding is that PSD2 Article 73 wants a won fraud dispute to restore the account fully, grace included, which the AsRecorded flag would block.
20:15 Claude
Phase B folded; gates green. Bites 1 and 4 are being re-authored for the KeepHigher grace rule. Committing the fold and the four finished test files now so nothing is lost while they run.
20:15 Claude
Committed at 4b90dd253. When the two re-authored files land I will commit them, set ADR-840 to Accepted, write the model section, sync the board and tell the coordinator.
20:25 Claude
Now Accepted: status flip, model section, gates, commit, board sync.
20:26 Claude
ADR-840 is Accepted and committed. Telling the coordinator, with the two findings for it to allocate ids.
20:26 Claude
ADR-840 (disputes and chargebacks) is Accepted at 078c117b0: six bites, one land, 14 scenarios, 86 cold tests. Board card moved; coordinator told.
What the pipeline changed since Proposed:
- One credit, value-dated as the purchase; a loss re-debits today. The draft reversed postings through ADR-261, which would have charged catch-up interest and a late fee on a dispute the customer won.
- PSD2 Article 73 restores the account. The grace-status row is marked
KeepHigher, so a re-walk may give back an interest-free period the fraud alone cost and never takes one away. - The chargeback clearing line records settlement and never closes; the processor’s word does.
ConcedenotAccept; parity in whole units; the reason-code validator compared a key to a URN and would have refused the template.
Two things for you:
- Late presentment on a credit card (filed with the coordinator): a purchase presented after a paid statement re-walks the due-date rows and charges catch-up, late fee and arrears for a line the customer never saw. Needs a ruling before ADR-838 lands.
- The
onRevaluationrow flag stays in ADR-840 bite 1; say if you want it as its own small engine ADR.
Next in the series: the price card, then merchant settlement and acquiring.
20:29 Claude
Gathering the last facts for the price card ADR (card type scheme, home country, tag groups), then drafting it.
20:33 Claude
ADR-841 (the price card) is drafted and gates are green. Syncing the board, committing, and dispatching its contradiction press.
20:36 Claude
ADR-841’s plan is drafted. Moving the bites out of the ADR body, fixing its command names, and running the plan gates.
20:38 Claude
The press found 14 pairs, most around the ATM fee’s min/cap composition and the tie rule. Folding with a cleaner shape: a rate row carries its own floor and cap, and a band counts toward specificity.
20:43 Claude
ADR-841 (the price card) is Proposed at 40a1f9d94 with its press folded and plan drafted; phase A is running.
What the press changed:
- A rate row carries its own floor and cap, and a new
fee()computes the charge. The draft composed a minimum from two price types in script, which defeated per-customer overrides and contradicted its own wording. - A band counts toward specificity, so a banded row beats an unbanded one; the tie check considers bands.
- Every flat row seeded today stays as the fallback, so a standard card prices exactly as before; only the gold card and the two new fees answer differently.
- A foreign ATM withdrawal pays the markup too, as at every bank; a DCC purchase pays none unless the tenant adds a row.
Next: fold phase A, plan grill, phase B, Accepted, then merchant settlement.
20:57 Claude
ADR-841’s phase A is folded and committed at 0f12f4adf; the plan grill is running and three pre-existing pricing defects went to the coordinator for ids.
What phase A changed:
- A selected type must carry its fallback row on every list, so a lookup with attributes never misses where the plain one hits.
- Bands are inclusive at the bottom, exclusive at the top, open-topped, a deliberate deviation from the rate cards so adjacent bands never tie.
- The floor lifts a charge and never creates one; an override never turns a waived row into a charge.
- The annual fee is out. It is scheduled on the account, where no card attribute exists.
- The card type that prices differently is ADR-838’s
credit, not an invented gold type.
Nothing to do until the grill reports.
20:58 Claude
Finding ids F-1796 to F-1799 recorded in ADR-841’s plan at 4ce435ce0. The plan grill is still running; nothing else to do until it reports.
21:11 Claude
Writing the plan-grill fold for ADR-841 now: renaming the keys, moving the fee formula into Contracts, and rewriting the plan’s sections.
21:16 Claude
ADR-841’s plan grill is folded and committed at fe488970a; three phase B authors are writing its cold tests.
What the grill changed, the ones that freeze names:
cross-borderandcurrency-conversionreplaceregionandcurrency. The schemes’ own words, andcurrency: foreignwas not a currency. The fee is nowcard-currency-conversion-fee.- A selector declares its allowed values, so a typo can never silently charge the fallback.
- The fee formula lives on the quote in Contracts, beside the row that defines it; the minor unit comes from the tenant’s currency setting.
- A series is retired by a marked row; a row of 0 waives, it does not retire.
- An override on a waived fee is refused rather than silently ignored, and the retroactive-override defect F-1796 is fixed in bite 1 since this ADR rides that seam.
- Two lands: bites 1 and 3 first, demonstrable alone and the contract merchant settlement builds on; bite 2 after the four card ADRs.
Waiting on the three authors, then Accepted.
21:22 Claude
Bite 3’s author is back. Holding its findings until bites 1 and 2 report, then folding all three together.
21:22 Claude
Waiting on bites 1 and 2.
21:30 Claude
Bite 1 in. Waiting on bite 2, then one fold for all three.
21:30 Claude
All three authors are back. Folding their findings, then Accepted.
21:33 Claude
ADR-841 is Accepted at 6f57c2b97. Starting the next design, merchant settlement and acquiring, by gathering the proposal’s brief and the seams it rests on.
21:36 Claude
Gathering the last two facts for the merchant settlement design: how the uncleared-funds hold is placed on a deposit, and how an institution connection is typed.
21:41 Claude
ADR-842 drafted and gates green. Fixing the one contract name, then syncing the board, committing and dispatching the press.
21:43 Claude
All facts in hand. Writing ADR-842’s plan now while the press runs.
21:52 Claude
The operator asked, through the coordinator, for three model sections on the card page. Writing them now in the page’s style while ADR-842’s phase A runs.
21:52 Claude
The card model page is updated and committed at 783ed9d15; the coordinator has it for F-1800. ADR-842’s phase A is still running, and nothing else is pending until it reports.
22:02 Claude
Phase A returned 27 questions; several are structural (the payout role no longer exists, the account cannot be opened from Acquiring, the hold date has no interface). Checking those facts before ruling.
22:02 Claude
The precedent for the payout is ProcessStandingOrderPaymentCommand: the caller resolves the value date and names the external account. Checking how another feature opens an account.
22:02 Claude
ProvisionAccountCommand is the Contracts seam that opens and activates an account. Checking how the pricing plan picks its list on opening.
22:03 Claude
No calendar seam exists, a post-increment step reads TradingDate + 1, and closing is only a workflow step. Ruling and folding all 27 questions now.
22:05 Claude
Now the plan: four bites (feed and posting merged so bite 2’s scenario can go green), the interfaces rewritten to the rulings.
22:08 Claude
Phase A folded and committed at 6a5018b5e. Dispatching ADR-842’s plan grill.
22:08 Claude
ADR-842’s phase A is folded and committed at 6a5018b5e. Its plan grill is running now.
What phase A changed:
- The payout names its own external account and value date, the way a standing-order payment does. The draft relied on a
payout-accountrole, but the platform removed that role. The agreement now holds the payout account itself, so the workflow raises a real instruction over the rail. - The pricing model is a price-card selector,
pricing-model. Both models now sit on one list per currency. A dated model switch through a pricing plan was impossible, because a plan’s list change is not value-dated. - Settlement accounts are opened through Accounts’ existing provision command, open and active in one call. The draft named a command that only creates a draft account, from a project Acquiring cannot reference.
- The hold is the net the sale credited, floored at zero. A sale whose charges exceed it holds nothing. The release date comes from a new
AddBusinessDaysmethod on the settlement-date resolver, since that is the only seam that owns rail calendars. - The plan is down to four bites. The feed and the posting merged, so the feed scenario can pass in its own bite.
On your instruction through the coordinator, I wrote the card model page’s sections for disputes, card pricing and acquiring under F-1800, committed at 783ed9d15.
22:09 Jeremy
carry on with the series
22:10 Claude
Carrying on: ADR-842’s plan grill is still running in the background, so I’m starting the next in the series — the rolling reserve and the acquiring side of chargebacks (ADR-843). First, the seams it rests on.
22:11 Claude
Claims can’t be raised or partly consumed from another feature today, and ClaimId is Accounts-only. That shapes ADR-843. Minting the number and drafting.
22:14 Claude
I’m carrying on with the series. ADR-843 (the rolling reserve and the acquiring side of chargebacks) is drafted, gated green and committed at 0030ea57d as Proposed, with its board card added. Its contradiction press and ADR-842’s plan grill are both running.
What ADR-843 decides:
- Another feature may hold, partly consume and release a claim on an account. It names the claim by its own id. No such seam exists today, and every claim is raised by Accounts itself. The reserve is the third user of the generic “dated hold”, after notices and uncleared funds.
- The reserve is a rule on the agreement’s dated terms, either rolling or fixed, and its basis is gross sales. It is withheld on the day that day’s T+n hold releases, so the reserve and the hold never hold the same money twice. This also leaves ADR-842’s sale posting untouched.
- A chargeback is its own aggregate, opened by the feed. The free balance bears it first, then the reserve, oldest day first. A merchant’s win comes back as a reversal line, and the chargeback fee stands.
- The issuer’s reason-code vocabulary from ADR-840 is read through a Contracts reader, so the dispute windows are one set and cannot drift.
- A merchant over both monitoring thresholds has its reserve stepped up by rule from the first business day of the month. Stepping it back down is a clerk’s dated amendment.
One scale point is noted in the ADR. A large merchant’s account carries one hold claim per sale for T+n days. Per-day holds are the likely refinement once a buyer’s volumes are known.
When the two agents report, I fold them and carry 842 and 843 on toward Accepted. Spend controls and corporate cards come after.
22:18 Claude
The press found 20 pairs on ADR-843. Ruling and folding them.
22:20 Claude
The fold aborted before writing, so the ADR is untouched. Fixing the one anchor.
22:21 Claude
Press folded at fdb2656ed. Writing ADR-843’s plan; first the claim code’s reach.
22:23 Claude
ADR-843’s plan passes its gates; committing it. Then folding ADR-842’s 22-point plan grill.
22:24 Claude
Ruling on all 22 points. One is a Marten fact (does Insert refuse a duplicate id), which I check against the docs rather than memory.
22:24 Claude
Marten’s docs confirm Insert throws DocumentAlreadyExistsException on a duplicate id, so a reservation document can enforce identifier uniqueness. Folding the 842 plan grill.
22:25 Claude
Folding the grill into ADR-842’s plan: rewriting its Interfaces section whole, and tightening its findings, files and scenarios.
22:27 Claude
The warm-checkout hook read src/ paths inside the heredoc as edits. Writing the script with the file tool instead, then running it.
22:29 Claude
The commit went in with one adr-check failure: the checker read “gains Currency” as a type claim. Fixing the wording.
22:30 Claude
Gates green at df3987dd9. Cascading 842’s renames into 843, then dispatching 842’s phase B and 843’s phase A together.
22:31 Claude
ADR-842’s plan grill is folded. ADR-843 is planned and now follows 842’s renames. Five agents are running: four writing 842’s cold tests (phase B) and one asking 843’s phase A questions.
What 842’s plan grill changed, in money terms:
- A payout account per settlement currency, owned by the merchant and in that currency. The draft had one payout account for every currency, which would have paid euros into a rand account. It also never checked who owned the account, which leaves the door open to the classic payout-change fraud.
- The hold basis is named on each posting command. The draft’s general “hold the net credited” rule would have silently dropped the hold on every forward-valued debit order. The debit order now keeps holding its amount.
- The provisioned settlement account gets books, an owner, a priced plan and an account number. The command used to open it was built for system accounts. Without a posting group, no posting would have reached the general ledger.
- The feature key is
cards.acquiring, a sibling ofcards.issuing, so onecardsswitch turns both halves off. - An agreement closes no earlier than 120 days after termination, the schemes’ common filing limit. A line arriving later for that merchant gets a final “agreement closed” outcome. It is never routed to a new merchant holding the same identifier.
One commit went in with a failing check: 884f4070c. The checker read “gains Currency” as a type claim. The rewording at df3987dd9 makes the check green again.
When the five agents report, I fold them and bring 842 to Accepted. 843 then goes through its plan grill and phase B. Spend controls and corporate cards come after that.
22:38 Claude
The phase A report found something that changes ADR-843’s core: ADR-836 already ships a generic “held by another feature” mechanism. Checking it before ruling.
22:38 Claude
I’ll rewrite ADR-843’s Decisions 1–6 whole, plus its contracts and prior art, through a script written with the file tool.
22:40 Claude
Now rewriting ADR-843’s plan to match: new findings, a bite 1 built on the reductions, and interfaces without the claim seam.
22:42 Claude
ADR-843’s phase A fold passes its gates; committing it and filing the pre-existing finding.
22:42 Claude
ADR-843’s phase A fold is committed at c7f3fe6bf. The finding went to the coordinator for an id.
The ruling that changed ADR-843: the reserve joins the existing mechanism for money held on an account by another feature, and the draft’s new claim seam is dropped. ADR-836’s card-hold design (IAvailableBalanceReductionsReader) was built so a second holder could join it. The draft’s seam into Accounts would have been a second mechanism answering the same question. It also opened four money holes:
- a reduce with no key, so a retry could consume the reserve twice;
- any feature could release or consume any claim, including payout instructions;
- a repeated raise would silently overwrite a claim;
- nothing would record when a rolling reserve was released.
With the existing mechanism, Accounts changes by one figure: its availability read gains the uncleared-funds total.
The finding I filed is pre-existing, from before this work: the account detail screen never shows a hold as unbacked.
Two of ADR-842’s four phase B authors (bites 2 and 3) are still running. When they report, I fold all four bites and bring 842 to Accepted. Then 843 goes through its plan grill and phase B.
22:43 Claude
Bite 3’s author reports a possible defect on main today: a standing order redelivered before it settles could be paid twice. Verifying before I file it.
22:43 Claude
I found what looks like a real defect on main, outside the cards work: a standing order delivered twice before it settles can send the money twice. I have filed it with the coordinator as a likely P1. I confirmed it by reading the code, but no test has proved it yet.
How it happens:
- The double-payment guard looks only at posted transactions. A standing order whose rail date is in the future does not post. It raises a payment instruction, and the rail fires as soon as that instruction is raised.
- A second delivery therefore gets past the guard. If the same standing-order command arrives again before the value date, the platform raises a second instruction under the same transaction id. The money goes out twice, while the ledger probably records it once.
I suggested a fix: the guard should also stop when an outstanding instruction already carries that transaction id. I also asked for the test to be written first. ADR-842’s merchant payout has the same shape, so it depends on this fix. I will name the finding in 842’s landing notes once it has an id.
Three of 842’s four phase B authors have reported; bite 2’s author is still running. When it reports, I fold all four bites and bring 842 to Accepted.
22:47 Claude
All four of ADR-842’s phase B authors are in. Folding their findings and taking 842 to Accepted. I’ll append the rulings to each decision rather than splice sentences, which is safer against the many edits already made.
[The conversation reached its context limit here and continued from an automatic summary.]
22:51 Claude
ADR-842, merchant settlement and acquiring, is now Accepted and committed. It has four bites in one land, with 58 tests written ahead of the code. Its board card is in Accepted and the coordinator knows. Nothing is pushed.
What changed in the last review round:
- A merchant agreement can start up to thirty days in the past, for a merchant onboarded after its first sales.
- The merchant’s charges carry VAT.
- When an agreement ends, the final payout waits until the merchant’s last hold releases.
One test will stay red until a fix on main lands. A standing order or merchant payout dated in the future can pay twice if the payment message is delivered again. The test for that case fails until the fix lands. I filed the defect with the coordinator and am waiting for its finding number. I am also waiting for the number of a smaller defect: the account detail screen does not mark a hold that the balance no longer covers.
Next: ADR-843, the rolling reserve and acquiring chargebacks, is in its plan review now. When the review comes back I fold it in. Then the test authors write its tests and it goes to Accepted. Spend controls and corporate cards follow.
23:03 Claude
Folding the ADR-843 plan grill now: 29 points, all taken on the grill’s recommendations. First checking which day-end step slots are free.
23:04 Claude
Writing the plan-grill fold for ADR-843: new interfaces, scenarios, and the ADR’s rulings.
23:06 Claude
Now the fold script.
23:08 Claude
The Rate hit is a field name, not a type. Committing, then dispatching phase B.
23:09 Claude
ADR-843 is not Accepted yet. Six test writers, one per bite, are drafting its tests now. ADR-842 is Accepted and committed, and its board card is moved. Nothing is pushed.
The plan review of ADR-843 raised 29 points. I took every recommendation and committed the changes. The ones that matter for money:
- A payout could be held back forever. The reserve was tracked as a share of each day’s sales. A rounding cent, a fixed target or a terminated agreement could leave a day never fully reserved, which blocked the payout for good. The reserve is now tracked in money per day, so each day is either fully reserved or closed.
- Two chargebacks on one account in one feed could take too much reserve. The second one did not see what the first had already taken. In the review’s example, a 100.00 reserve lost 80.00 to two chargebacks when 50.00 was right, and the extra 30.00 would have been paid out. Each chargeback line is now handled and saved on its own, in file order.
- A refused reversal could still credit the merchant. The checks ran after the money moved. They now run first, and a retry after a half-failed post keeps its fee.
- Switching acquiring off froze the reserve. Releasing the reserve and watching chargeback deadlines are wind-down work, so they now run whatever the switch says. ADR-842’s payout step had the same flaw, so I added a correction to its plan and told the coordinator.
- A chargeback on a closed agreement booked nothing and told no one. It now opens its case without moving money and raises a task for the disputes team.
Two smaller fixes also went in. The reason code is now stored as ADR-840’s typed id instead of a string. The win/lost outcome is named for the merchant’s side, so it cannot be misread as the cardholder’s.
When the six test writers finish, I fold in their findings and bring ADR-843 to Accepted. Spend controls and corporate cards come next. I am still waiting on the coordinator for the finding numbers of the double-payment defect and the unbacked-hold defect.
23:17 Claude
ADR-842’s own bite-4 test still asserts a last-batch field that its phase B ruling removed. Correcting it to the ruled next-payout read and noting it.
23:17 Claude
The bite 6 tests for ADR-843 are written: eight test methods for the chargeback, chargebacks list and reserve screens. The other five test writers are still running. When all six are back, I fold their findings into the ADR and plan, then bring ADR-843 to Accepted.
These are the decisions I will fold from bite 6:
- Follow a case to its reserve day. The case screen will show which reserve day each chargeback took money from, not only the amount.
- Show the scheme’s raw reason code. It appears even when the code is unknown to us, and the feed line is marked as having an unknown code.
- Show shortfalls. A day whose reserve could not be fully withheld, for lack of free money, will appear on the reserve screen. Today it would be invisible.
- Show fixed reserve days as fixed. Each will show its own release period after termination.
- Name a reserve day by its business date. The worked example’s “10-07 day” becomes “the 10-05 day, withheld 10-07”.
- Keep the screens behind the acquiring switch. They match ADR-842’s screens. Only the background steps that release reserve and watch chargeback deadlines keep running when acquiring is switched off.
The bite 6 test writer also found a defect in ADR-842’s already-Accepted tests. Two checks still expected a “last batch” date that ADR-842’s own test review had removed. I replaced them with the “next payout date” check that review ruled in, and added a note to ADR-842’s plan. That correction is not committed yet; it goes in with the ADR-843 commit.
23:19 Claude
ADR-836 does make the balance resolver read the reductions, so that test assumption holds. Recording bite 1’s positions.
23:19 Claude
ADR-843’s bite 1 test writer is done, with 18 tests in its file. Two of the six bites are now written, bites 1 and 6. The writers for bites 2 to 5 are still running.
These are the rulings I will fold in from bite 1:
- Reserve rule checks. A rule is refused if it mixes rolling and fixed settings, or if a target is zero or below. It is also refused for two targets in one currency, a target in a currency the merchant is not settled in, or step-up thresholds out of range. When an agreement has both a zero settlement delay and a bad rule, the delay refusal is reported first.
- Adding a settlement currency to a fixed reserve. The new currency is checked against every set of terms in force from its start date, not only today’s.
- The reserve never lapses. Its hold on the available balance applies even with acquiring switched off. Switching acquiring off can never let a payout carry the reserve away.
- Reason codes. A scheme name from the feed matches however it is capitalised.
The bite 1 writer also found that ADR-842’s Accepted tests use different names for the same test setup across bites 2, 3 and 4. A note on ADR-842 will tell its builder to settle on one set of names when copying the tests in. It is a rename only.
Two safeguards nothing checks today will go to the coordinator as findings when ADR-843 reaches Accepted. Nothing stops a wind-down day-end step from being put behind a feature switch. Nothing stops a stored document from holding a field the database silently drops.
23:21 Claude
Bite 5’s tests for ADR-843 are written: 16 tests covering monthly dispute monitoring. The writers for bites 2, 3 and 4 are still running.
These are the rulings I will fold in from bite 5:
- Start date of a step-up. It runs from the first trading day after the month ends, which is the date day-end is processing.
- Counting chargebacks. They count in the month of the business date of the feed batch that opened the case. A month is recorded once. A batch that arrives after that month is recorded is deliberately not counted again, since the schemes’ monitoring programmes count what was processed in the month.
- Months with no sales. A month with chargebacks and no sales gets a row with no ratio. Ratios are rounded half-up to six decimal places.
- When a step-up is skipped. It is skipped only if the reserve in force is the same kind and at least as strict on every measure. A reserve of the other kind, or no reserve, is stepped up.
- Which agreements are monitored. Only active and suspended agreements are monitored. Each is processed separately, so one failing agreement does not stop the others.
- No second approval. The step-up is the system’s own action under the terms the bank already approved, so it never waits for four-eyes approval.
- Auditor’s view. The step-up record now names the month that triggered it, so a run covering two months stays traceable.
23:22 Claude
The tests for ADR-843 bite 4 are written: 17 tests covering representment, accepting a case, and the deadline clock. The writers for bites 2 and 3 are still running. When they report, I fold all six into ADR-843 and bring it to Accepted.
Two gaps from this report matter most:
- The bank’s reason for accepting a case was being lost. When a clerk accepts a chargeback for the merchant, the merchant gives up the money, but the clerk’s reason never reached the record. It now goes on the closing event, so an auditor can see why the bank gave the money up.
- Recording a representment had no route to the scheme’s response window. The handler could not look up a reason code by its stored id. The reason-code lookup gains a find-by-id, so the date the scheme’s answer is expected can be worked out.
Smaller rulings from this report:
- Accepting a reversed or closed case is refused when the clerk submits it. The clerk sees the refusal at once, instead of it surfacing after a second clerk approves.
- “Received” means the business date of the line that opened the case. A representment may not be dated before it.
- A reversed case that was never represented still has an expected date. It waits for the scheme’s final word, due the response window after the reversal.
- Two lines in the ADR contradicted the plan-review rulings. One gated the deadline watch behind the acquiring switch. The other made recording a representment need a second approval. Both get corrected.
Three findings go to the coordinator at Accepted:
- No check stops a wind-down step from being gated behind a feature switch. This is now the second occurrence, after ADR-842’s payout step.
- No check confirms that a four-eyes command’s reason reaches the record.
- A new task type can be added without a link to its screen.
23:22 Claude
The bite 2 author found a real defect. With acquiring switched off, withholding stops while the payout waits for withholding, so payouts strand. The fix: withholding is also wind-down. It only ever reserves sales already posted under the agreement’s own terms, so it runs ungated too. Recording that, then asking the author to revise the two tests it affects.
23:23 Claude
While the three agents finish, I’m drafting the phase B fold.
23:25 Claude
The interface changes from phase B touch bites 1, 4, 5 and 6 too, so I’m sending each author its delta.
23:26 Claude
Bites 2 and 3 are revised and the fold passes the ADR gates. Still waiting on the bite 1, 4, 5 and 6 revisions and the ADR-842 VAT correction.
23:26 Claude
The bite 6 test revision is done. That makes three of the six test files revised for ADR-843: bites 2, 3 and 6. I’m still waiting on the revisions for bites 1, 4 and 5, and on the correction of ADR-842’s tests for VAT on merchant charges. When those land, I set ADR-843 to Accepted, commit it, move its board card and tell the coordinator.
23:26 Claude
Bite 6 has finished. I’m still waiting on three ADR-843 test revisions, for bites 1, 4 and 5, and on the correction of ADR-842’s tests for VAT.
23:27 Claude
Bite 1’s tests are revised to the phase B rulings, which makes four of the six ADR-843 test files done. I’m still waiting on the revisions for bites 4 and 5, and on the VAT correction to ADR-842’s tests.
23:27 Claude
Bite 1’s test revision is in. ADR-843 now waits on two test revisions, bites 4 and 5. A separate correction to ADR-842’s tests, for VAT on the merchant charges, is also still running.
23:27 Claude
Bite 4’s tests are revised to the phase B rulings. Five of the six ADR-843 test files are now done. I’m still waiting on bite 5, and on the VAT correction to ADR-842’s tests.
23:27 Claude
Bite 4 is done. ADR-843 is still waiting on two things: the bite 5 test revision, and the VAT correction to ADR-842’s tests.
23:30 Claude
All test files are in. Next, I’m marking ADR-842’s remaining pre-VAT figures, then bringing ADR-843 to Accepted.
23:31 Claude
ADR-843 is Accepted. Next in the series is spend controls and corporate cards. First I’m checking how the cards proposal splits that work.
23:32 Claude
Reading the shipped card and oracle work before drafting the spend-controls ADR.
23:33 Claude
Still recon for the spend-controls ADR. Next is how the client channel declares operations.
23:34 Claude
I have enough context. Minting the issue for the spend-controls ADR.
23:34 Claude
Writing the ADR-844 draft.
23:36 Claude
The channel gate already checks an amount against the entitlement ceiling, so the commands reuse it directly. Fixing the ADR’s contract wording to match.
23:37 Claude
Gates pass. Committing the draft; the post-commit hook syncs the issue and board.
23:38 Claude
ADR-844’s draft is committed at Proposed. Next is the design grill, starting with whether a client-channel screen exists to demo the administrator.
23:38 Claude
No client-channel UI exists for any channel operation yet, so the administrator stays API-only here; I’ll record that as scope. Dispatching the contradiction press.
23:38 Claude
While the press runs, I’m recording my own grill positions.
23:39 Claude
I’ve recorded eight grill positions of my own for ADR-844. When the contradiction press reports, I fold both into the ADR and carry on to its plan.
23:42 Claude
The press found 15 contradictions and nine gaps. Folding them with my eight positions into ADR-844 now.
23:44 Claude
ADR-844’s grill is committed. Next I’m writing its plan.
23:45 Claude
Writing ADR-844’s plan; reading the issue command’s full signature first.
23:46 Claude
Plan written and gates pass. Committing, then dispatching phase A.
23:47 Claude
ADR-843 is Accepted. ADR-844, spend controls and the corporate card, is drafted, grilled and planned, but stays Proposed until its plan review and tests are done. Nothing is pushed.
ADR-843, the rolling reserve and acquiring chargebacks:
- Accepted and committed with tests for all six bites, about 110 in total. Its board card is moved to Accepted.
- Biggest change from the test writers: withholding the reserve now runs even with acquiring switched off. Before, switching acquiring off would have stopped every payout for merchants with a reserve.
- ADR-842’s tests corrected in the same commit. ADR-842’s own rulings put VAT on the merchant charges and removed a “last batch” date, but its tests still assumed neither. The test figures now include the VAT.
- The coordinator has three new findings to number. In each case nothing checks the rule today:
- A day-end step that releases or pays money must never sit behind a feature switch. This has now happened twice.
- A stored record must never hold a field the database silently drops.
- A four-eyes approval’s reason must reach the record.
ADR-844, spend controls and the corporate card:
- What it decides:
- One spend limit covers any part of spend (all of it, a channel, or a merchant category group), counts value or transactions, and runs per transaction, day, month or the card’s life. The card’s existing three ceilings become such limits.
- Merchant category groups the bank can name, and allow-only or block rules for categories and countries.
- Product-level bounds the bank sets on each card type, which every card of that type must stay within.
- A valid-until date, which makes single-use supplier cards possible.
- A corporate administrator who can issue, cap, suspend, reinstate, close and reveal staff cards through the client channel.
- What the grill caught: a check of the decisions against each other found 15 contradictions, all resolved. The worst: a card with only a daily limit could have spent about thirty times the administrator’s monthly cap. The cap now applies to the card’s total monthly spend.
- Demo gap: there is no client-channel screen for any operation yet, so the administrator’s actions are API calls only. A demo can show the bank’s card screen and the API calls behind it.
- Next: a test writer is listing open questions on the plan. A plan review follows, then tests for the five bites, then Accepted.
I am still waiting on the coordinator for finding numbers for the likely payout double-pay defect, the unbacked-hold defect, and the three new ones above.
23:56 Claude
Phase A returned 24 questions. Folding my answers into ADR-844 and its plan now.
23:56 Claude
Now the new interfaces and the fold script.
23:59 Claude
Phase A is folded into ADR-844 and the gates pass. Committing, then dispatching the plan grill.
Saturday 3 October 2026
00:00 Claude
ADR-844 is still Proposed. The test writer’s 24 questions on the plan are answered and committed, and an independent review of the plan is now running. Nothing is pushed.
These are the answers that changed the design:
- Channel limits follow how the tap is classified. A limit scoped to ATM, in store or online uses the same classification as the card’s on/off switches. A phone wallet used in a shop therefore counts as in store.
- A hold keeps its categories forever. The merchant categories a hold matched are recorded when it is placed. Rebuilding the records later can never re-count past spend.
- A category group is identified by its key. Changing a key removes one group and adds another. The removal is refused while a card type or an open card still uses the old group.
- Every decline names its rule in fixed wording. Each kind of decline has set text, such as “transaction, all spend, 2 000.00”. Figures are written the same way whatever the locale. The text names a group by its key, not its label, so renaming a label never changes a stored record.
- Two operations join the client channel. The administrator can now set a card’s valid-until date and activate a plastic card. The date has its own operation, so editing a supplier card’s countries can never wipe it.
- The administrator’s monthly cap reflects the product’s limits. A card’s monthly exposure, measured against that cap, now includes the card type’s own day and lifetime limits.
- Bank and corporate screens share one “spend used” calculation. The bank gets its own query for how much of each limit a card has used, and the corporate view reuses it, so the two cannot drift.
The test writer also found a defect in ADR-836’s code on the cards lane, which has not shipped yet. On every card tap, the code loads every card hold in the bank, not just that card’s. I asked the coordinator to file it and pass it to the cards lane. ADR-844 replaces that code, but ADR-836 will ship first.
When the review reports, I fold it in. Next come the tests for the five bites, then Accepted.
00:12 Claude
The plan grill returned 18 points. Three would let money be spent: a channel card’s monthly cap could not see the product’s limits, two simultaneous taps could both pass a limit, and the seeded product’s bounds would be silently dropped. I’m taking every recommendation and rewriting the interfaces.
00:14 Claude
Plan grill folded and committed. Dispatching phase B: five test authors, one per bite.
00:15 Claude
ADR-844 is not Accepted yet. Its plan grill is folded and committed, and five test writers, one per bite, are writing its tests now. I fold their findings next, then set it to Accepted. Nothing is pushed.
The plan grill’s 18 points are all taken. The changes that matter:
- A monthly-cap hole is closed. The client channel can’t read the product’s settings when it checks the administrator’s cap. So a card issued with no limits of its own would have passed a 25 000.00 cap and spent up to the product’s 50 000.00. Every card issued through the channel must now state its own monthly figure, and the cap judges that.
- Two simultaneous taps can no longer both pass a limit. Today’s card code reads spend before locking the card. A single-use card could therefore be approved twice. The card is now locked first.
- The seeded corporate card type is protected. Its product bounds and its gambling block would have been dropped when a tenant is set up, with no warning. A test now proves they arrive.
- The client channel has no web interface. The administrator’s actions are internal requests only, as every client-channel action is today. A demo shows the bank’s screens, and the test script covers only the bank’s side.
- Suspending and closing outlive the corporate licence. If the licence lapses, a corporate can still stop a stolen card. Suspension never waits for a second approval.
- Decline reasons are visible. Bank staff can read a card’s taps with the rule that declined each one. The administrator sees recent taps on the card.
The first two problems also exist in ADR-836’s code on the cards lane, which ships before ADR-844. I asked the coordinator to file them for the cards lane:
- Double approval (likely serious). Two simultaneous taps can both pass a daily or monthly ceiling.
- Slow reads. Every tap loads every open card hold in the bank, not just the card’s own.
00:26 Claude
ADR-844 now has its first test files for bites 1 and 5, drafted but not yet committed. Each writer is revising its file against my rulings. Bites 2, 3 and 4 are still being written.
For bite 1, most rulings matched what the writer had already chosen. The real changes:
- One refusal code for a card type’s bad limits. A faulty product limit on a card type now always gives the same refusal code.
- Lost or stolen cards count as open. A category group such a card uses cannot be removed.
- An allow-only rule must name something. An empty allow list is refused; “allow nothing” is what suspending the card is for.
- A badly formed group key gets its own refusal code, and the message names the key.
For bite 5, the main ruling is what the “product bound” next to each limit shows. It shows the tightest product limit that would actually stop a tap, but only when that is lower than the card’s own limit, or when the card has no limit there.
Two smaller items came up:
- Bite 2’s tests must call the two new bank reads over the web interface. Those are a card’s limit use and its authorisations. The bite that adds them has to exercise them.
- The script that works out an ADR’s footprint lists permission keys wrongly. It derives them from class names and ignores the declared keys. ADR-843 had the same problem, so I’ll send it to the coordinator as a finding.
00:26 Claude
The bite 5 revision is in. ADR-844 still waits on four items: the bite 1 and bite 3 revisions, and the bite 2 and bite 4 tests.
00:27 Claude
The bite 1 tests are revised to match the rulings. ADR-844 is still waiting on three test files: the bite 3 revision and the first drafts for bites 2 and 4.
00:27 Claude
The bite 3 test revision is in. The writer also found that Decision 5 still lets anyone change valid-until on any card that is not closed, which the new ruling contradicts. I’ll correct that in the phase B fold.
ADR-844 is now waiting on two test files: bites 2 and 4.
00:27 Claude
While bites 2 and 4 are still running, I’m drafting the phase B fold from the rulings so far.
00:28 Claude
Bite 4 is revised; bite 2’s revision is still running. Meanwhile I’m writing the phase B section for ADR-844.
00:28 Claude
Waiting on the bite 2 test writer’s revision before folding phase B into ADR-844.
00:29 Claude
All five test files are in. Folding phase B and bringing ADR-844 to Accepted.
00:30 Claude
The cards series is designed. ADR-840, 841, 842, 843 and 844 are all Accepted, committed and on the board at Accepted. Nothing is pushed.
ADR-844, spend controls and the corporate card, is the last of the series. It has five bites in one land and 142 tests, written before any code. It builds after ADR-836, which is still in progress on the cards lane. What it gives a bank:
- One spend limit. It can cover all spend, one channel or one merchant category group; count money or transactions; and run per transaction, day, month or the card’s life. The card’s existing three ceilings become such limits.
- Merchant category groups the bank can name, with allow-only or block rules for categories and countries.
- Product bounds on each card type that every card must stay within, including categories the bank always blocks.
- A valid-until date, which makes single-use supplier cards possible.
- A corporate administrator in the client channel. The administrator can issue, cap, set dates, activate, suspend, reinstate, close and reveal staff cards, capped by their entitlement. There is no client-channel screen yet, so a demo shows the bank’s screens.
Defects found along the way, already passed to the coordinator:
- Possible double payment (likely serious). If a standing order or merchant payout dated in the future is delivered twice, it can pay twice.
- Possible double approval in ADR-836’s code (likely serious). Two simultaneous taps can both pass a daily or monthly limit, because spend is read before the card is locked.
- Every tap loads every hold in the bank. In ADR-836’s code, the approval check and the available-balance read each load all open holds, not just the card’s or account’s own.
- ADR-842’s own tests were stale, against VAT on merchant charges and a removed “last batch” field. I corrected them.
Waiting on the coordinator: finding numbers for about a dozen findings, including the two serious ones above. One of them asks you to update the card model page’s Controls section, which ADR-844 has made out of date. That page is yours to edit.
04:11 Claude
All twelve findings now have numbers, and the eight that concern the cards ADRs are named in their plans. That is committed; nothing is pushed.
The coordinator has passed the four cards-lane defects to that lane now. You have ruled that the lane fixes the double payment first.
| Finding | What it is |
|---|---|
| F-1802 (serious) | A future-dated standing order or merchant payout delivered twice can pay twice. |
| F-1806 (serious) | Two simultaneous taps can both pass a card’s daily or monthly limit. |
| F-1807 | Every tap loads every card hold in the bank, not just that card’s. |
| F-1808 | Every available-balance read loads every open card hold in the bank, not just that account’s. |
The other eight are recorded for later:
- F-1801: the account detail screen never shows a hold as unbacked.
- F-1803: nothing stops a wind-down day-end step from being put behind a feature switch.
- F-1804: nothing stops a stored record from holding a field the database silently drops.
- F-1805: nothing checks that a four-eyes approval’s reason reaches the record.
- F-1809: the footprint script lists permission keys wrongly.
- F-1810: the client channel cannot check that a card an administrator acts on belongs to the account they named.
- F-1811: the Controls section of the card model page is out of date, and that page is yours to update.
- F-1812: tenant setup bypasses rules that only the edit screens enforce.
The cards series is complete: ADRs 840 to 844 are all Accepted and on the board.
After ADR-844
The session ends here, at 06:11 on 3 October, with ADRs 835 to 844 all designed, grilled, planned and Accepted, cold tests written for every bite, and the findings raised along the way numbered by the coordinator session. Nothing after this point was transcribed because nothing followed in this session: the building of the ADRs happened in separate lane sessions.