feat(invoices): named payee accounts and per-invoice choice of bank account (#2233)

* fix(enable-banking): read BBAN from AccountIdentification.other and store it on the account Enable Banking has no top-level `bban` key on AccountIdentification: a Swedish BBAN (clearing + account number) arrives as `other.identification` with `other.scheme_name = 'BBAN'`, or in `all_account_ids`. The client typed `bban?: string` and read `.bban`, so the value was always undefined: no connected account ever carried its clearing + account number, and domestic counterparty accounts on transactions were dropped. Type the identifiers per the OpenAPI spec, add extractBban() and pickAccountIdentifier(), read counterparty identifiers through the scheme list (IBAN, then BBAN/BGNR/PGNR, then anything), and store `bban` on StoredAccount from the OAuth callback. The external_id dedup scope stays IBAN-then-uid and is untouched. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UaZTY21HVN57hJoPXKSLjV * feat(invoices): named payee accounts on cash_accounts with a default per currency A company had exactly one set of payment instructions per invoice currency (company_settings.invoice_payment_accounts), picked by currency alone. A second SEK bank account, or a second bankgiro number, had nowhere to live. cash_accounts is already the per-company bank-account entity. Migration 20260903150000 adds the payee fields (bankgiro, plusgiro, clearing + account number, BBAN, BIC, Swish, foreign routing) plus invoice_payee, a small invoice_payee_defaults table (one default account per currency; one account may be the default for several currencies, a SEK account with an IBAN is the usual EUR payee), and a SECURITY DEFINER mirror that rewrites the legacy map and the SEK bank columns from the default accounts. Every existing reader (PDF, email, reminders, v1, MCP) keeps working; the three writers that only touched legacy columns (PUT /api/settings, v1 settings, MCP update_company_settings) now write through to the default account, so what an agent sets is what the PDF prints. Peppol PaymentMeans is built from the resolver instead of the raw legacy column. bg_pg is dropped (never read or written; NULL on every prod and staging row). Backfill lands only on existing cash accounts (primary, IBAN match, or the only enabled account in the currency). Entries with no target stay in the map as the resolver fallback and get an attach action in settings. New: POST /api/cash-accounts (manual bank account on the next free 19xx), PATCH /api/cash-accounts/[id] payee fields (owner/admin), GET/PUT /api/cash-accounts/payee-defaults. Settings page rewritten as an account list with per-currency defaults. Behandlingshistorik and the full archive cover the new table and columns. Verified on staging: migration applied (11 defaults landed), mirror trigger observed rewriting company_settings from a payee edit. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UaZTY21HVN57hJoPXKSLjV * feat(invoices): choose which bank account an invoice is paid to, frozen at issue Migration 20260903160000 adds invoices.payment_cash_account_id (FK to cash_accounts, SET NULL) and invoices.payment_details, the payee fields frozen when the account is chosen and refreshed at issue. Resolver: resolveInvoicePaymentAccount / companyWithInvoicePaymentAccount / assertInvoicePaymentAccountForRender take an optional override, and hasRequiredInvoicePaymentAccount reads it from the invoice row, so every surface (PDF, Swish QR, email, reminders, payment confirmation, Peppol, recurring, staged MCP send) prints the frozen payee when one exists and the company default per currency otherwise. Invoices that never chose an account behave exactly as before. Issue paths (mark-sent, send, v1 send, v1 mark-sent, Peppol send, recurring, MCP send and mark-sent) refresh the snapshot from the account as it is at issue; a chosen account that is disabled, un-flagged or unusable for the currency blocks with INVOICE_SEND_PAYMENT_ACCOUNT_INVALID. Writers: dashboard POST/PATCH, v1 create/update and MCP create_invoice accept payment_cash_account_id and validate it against the company's payee accounts (INVOICE_PAYEE_ACCOUNT_INVALID). Credit notes inherit the original's payee; copies carry the choice; preview-pdf renders the chosen account. The editor shows "Betalas till" under the currency when the company has two or more usable payee accounts for that currency. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UaZTY21HVN57hJoPXKSLjV * feat(invoices): book manual payments on the invoice's chosen bank account Manual mark-paid (dashboard, v1, MCP gnubok_mark_invoice_as_paid) and the booking dialog's proposed lines debited 1930 regardless of which bank account the invoice asked to be paid to. They now resolve the chosen payee account's ledger account (resolveInvoiceSettlementAccount) and fall back to 1930 only when no account was chosen or the row is gone. Bank-transaction matching keeps debiting the account the money landed on and does not filter by the chosen account; between equal-confidence candidates it prefers the invoice that asked to be paid to the landing account. Scores are untouched, so nothing new auto-matches. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UaZTY21HVN57hJoPXKSLjV * chore(invoices): keep the payload-size and phantom-column ceilings after the payee work Shorten the new gnubok_create_invoice argument description (tools/list payload was 29 bytes over the 60 kB budget), inline the cash-account payee UPDATE/INSERT payloads and the settings select strings as literals so the phantom-column scanner can read their columns, and reuse ACCOUNT_NUMBER_RE instead of a hand-rolled copy. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UaZTY21HVN57hJoPXKSLjV * fix(invoices): harden the payee model after review (admin-only payee columns, separate payee IBAN, company-scoped FK) Review findings from CodeRabbit, Superagent, the Swedish accounting review and three skeptic passes, resolved in one batch: Schema (both migrations are unshipped and edited in place): - cash_accounts.payee_iban: the printed IBAN is its own column. iban stays the bank identity written by every sync and used to re-pair on reconnect, so a sync can no longer rewrite an invoice instruction or resurrect a cleared IBAN. The backfill copies each currency entry verbatim onto the target account (IBAN match first, then primary), so every invoice keeps printing exactly what it printed before; the bank IBAN is never pushed onto invoices that did not carry one. - Payee columns are owner/admin-only at the database (BEFORE trigger, service role exempt): cash_accounts is member-writable for bank sync, and the SECURITY DEFINER mirror would otherwise have let a member rewrite where customers pay. - Revoking an account as payee or disabling it drops its defaults; deleting a default drops that currency from the map and clears the legacy SEK columns (an admin saying "nothing to print" must not keep printing a closed account). The mirror leaves the legacy SEK columns alone when the map has no SEK entry, so legacy-only companies are never wiped by a mirror run for another currency. - Audit and mirror triggers fire on the same column set; anon and authenticated can no longer execute the trigger-only definer functions. - invoices.payment_cash_account_id is a composite same-company FK with SET NULL scoped to the account column. Code: - Only 19xx bank accounts can be payee: PATCH, the defaults PUT (which now also requires enabled, payee-flagged and usable for the currency), resolveInvoicePayeeChoice, and the mark-paid settlement resolver (which also refuses disabled rows and logs every fallback to 1930). - createManualBankAccount excludes every ledger slot any row already holds (findFreeLedgerAccount treats a manual holder as free; this path inserts). - The legacy settings writers (PUT /api/settings, v1, MCP) write through to the account BEFORE updating company_settings and fail the request on error; the account is written before it is adopted as default so the mirror never sees an empty payee. - snapshotInvoicePayee: dry runs no longer persist; a failed snapshot write blocks issue (INVOICE_PAYEE_SNAPSHOT_FAILED). v1 mark-sent/mark-paid projections carry the payee columns; v1 create validates the payee before the dry-run return and echoes it in the preview. - pickAccountIdentifier: supplementary IBAN wins over a primary BBAN, and non-account schemes (card PANs) are never persisted. - Editor shows the payee select for a single usable account with no default; the booking dialog waits for cash accounts before proposing lines; a failed default write no longer hides a created account. - Behandlingshistorik names the account on created/deleted defaults. - Regenerated skills/accounted-api; MCP argument description trimmed under the tools/list payload ceiling. Declined: clearing legacy columns via a forward migration (the mirror now does it on delete); Swedish review's "show the debit account in the mark-paid UI" (the booking dialog already proposes and lets the user edit the debit line); manual ledger collision (UNIQUE exists, and the create path now rejects it with a clear error); Peppol aligning to the PDF value for companies whose legacy column had drifted from the map (the PDF is the customer-facing document; both now agree). Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UaZTY21HVN57hJoPXKSLjV * fix(invoices): read NEW.invoice_payee only on the cash_accounts branch of the mirror trigger trg_mirror_invoice_payee_defaults fires for both tables; plpgsql resolves record fields per expression, so the combined condition failed with "record new has no field invoice_payee" whenever a default row changed, which took down every pg-real case on the payee tables. The revoke/disable check now sits inside its own TG_TABLE_NAME branch. The MCP settings executor test mocks the payee write-through like the settings route test already does. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UaZTY21HVN57hJoPXKSLjV * fix(invoices): keep member disables from revoking payee defaults, gate payee on 1920-1999, fit the MCP payload Cycle 3 of /resolve-pr on #2233. Superagent P1: the SECURITY DEFINER mirror trigger deleted an admin's invoice_payee_defaults rows whenever cash_accounts.enabled flipped to false, and enabled is member-writable (the bank picker's "Synkas ej"), so a member could undo an admin's payee decision. The trigger now drops defaults only on the admin-only invoice_payee true -> false revoke; the mirror trigger's WHEN no longer lists enabled. Disabled accounts stay out of the pick lists and the send gate already refuses an invoice that chose one. Applied to staging as the same function + trigger definition and probed inside a rolled-back block: disable keeps the default and the mirrored bankgiro, revoke clears both. pg-real: the admin-guard test ran three expectations inside one withUserContext transaction; the first raise aborted it and the next statement failed with "current transaction is aborted". One transaction per expectation now, and the member case also flips enabled to prove the column stays member-level. Swedish review: payee eligibility was /^19\d\d$/, which admits 1910 Kassa and the 1911-1919 tills. A customer pays to a giro or bank account, so isBankCashAccount, CreateCashAccountSchema.ledger_account and the PATCH route now require BAS 1920-1999; tests cover 1910 and 1919. Unit tests (3/4): the tools/list payload guard read 60 025, then 60 014 tokens after main merged #2166 and #2163 alongside this branch. The ceiling is not bumped and no read on this surface is a demotion candidate, so gnubok_create_invoice drops payment_cash_account_id; agent-created invoices print the per-currency default and v1 REST plus the editor keep the field. Recorded in DECISIONS.md. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UaZTY21HVN57hJoPXKSLjV * chore(migrations): move invoices_payment_cash_account to 20260903183000 after colliding with main's KPI migration origin/main merged 20260903160000_kpi_monthly_include_reversed_originals while this branch held the same version; identical versions abort the Supabase apply. Staging's schema_migrations row was moved to the new version with the file. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UaZTY21HVN57hJoPXKSLjV * fix(invoices): gate invoice_payee on BAS 1920-1999 at the database, and unblock the typecheck ratchet Cycle 4 of /resolve-pr on #2233, on Emil's go. Swedish review: the 1920-1999 payee rule lived only in the routes. The cash_accounts_payee_admin_only trigger now also refuses invoice_payee on any other ledger (INVOICE_PAYEE_ACCOUNT_INVALID, 23514), whoever writes it, and the backfill only targets giro/bank rows, so a company whose single enabled cash_accounts row is a Stripe clearing account keeps its legacy bankgiro in company_settings instead of landing it on 1686. pg test covers insert and update on 1686 and 1910; the function was applied to staging and probed. Typecheck ratchet: main is red from two merges that landed with failing Checks, and every branch that syncs it inherits the errors. - #2242 added POST(req) calls to the fiscal-periods route test without the route params argument withRouteContext handlers take (25 errors in the file, baseline 23). All 25 calls now pass createMockRouteParams({}). - #2247 made SyncResult.requestedFromDate and historyNarrowed required; the 13 mockedSync results in the enable-banking accounts-route test lacked them. They now carry a fixed date and historyNarrowed: false. Both files' tests pass unchanged in behaviour. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> * chore(migrations): move invoices_payment_cash_account to 20260903193000 after colliding with main's party_promotion origin/main merged 20260903183000_party_promotion while this branch held the same version. Staging's schema_migrations row must follow (pending: the Supabase MCP was disconnected at the time of this commit). Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-03 21:06:45 +02:00
parent 88a5d78594
commit d670fe6663
69 changed files with 4025 additions and 611 deletions
@@ -9,7 +9,18 @@ function makeCashAccount(overrides: Partial<CashAccount> = {}): CashAccount {
    bank_connection_id: null,
    external_uid: null,
    iban: null,
-    bg_pg: null,
+    bban: null,
+    payee_iban: null,
+    bank_name: null,
+    clearing_number: null,
+    account_number: null,
+    bankgiro: null,
+    plusgiro: null,
+    swish: null,
+    bic: null,
+    bank_code: null,
+    foreign_account_number: null,
+    invoice_payee: false,
    name: null,
    currency: 'SEK',
    ledger_account: '1930',
@@ -634,6 +634,15 @@ const CreateInvoiceBaseSchema = z.object({
    .transform((v) => v || undefined)
    .optional(),
  received_date: optionalIsoDate,
+  // Which of the company's bank accounts the invoice asks the customer to pay
+  // to (migration 20260903193000). Omitted/null = the per-currency default.
+  // The route checks the account belongs to the company, is flagged as a
+  // payee and is usable for the invoice currency.
+  payment_cash_account_id: z
+    .union([uuid, z.literal('')])
+    .transform((v) => v || null)
+    .nullable()
+    .optional(),
  items: z.array(CreateInvoiceItemSchema).min(1, 'At least one item is required'),
 })

@@ -2210,6 +2219,35 @@ const InvoicePaymentAccountSchema = z.object({
    .or(z.literal('')),
 })

+/**
+ * PATCH /api/cash-accounts/[id]: the verifikationsserie override plus the
+ * payee fields (migration 20260903150000). Payee keys share the field rules
+ * of InvoicePaymentAccountSchema so the settings form, the legacy settings
+ * writers and this route agree on what a valid bankgiro is.
+ */
+export const UpdateCashAccountSchema = InvoicePaymentAccountSchema.extend({
+  voucher_series: UpdateCashAccountVoucherSeriesSchema.shape.voucher_series.optional(),
+  name: z.string().trim().min(1).max(100).nullable().optional(),
+  invoice_payee: z.boolean().optional(),
+}).strict().refine((body) => Object.keys(body).length > 0, {
+  message: 'Inget att uppdatera',
+})
+
+/** POST /api/cash-accounts: a bank account typed by hand (no bank connection). */
+export const CreateCashAccountSchema = z.object({
+  name: z.string().trim().min(1, 'Ange ett namn').max(100),
+  currency: CurrencySchema,
+  ledger_account: z.string().regex(/^19[2-9]\d$/, 'Bankkonton bokförs på 1920-1999').optional(),
+  invoice_payee: z.boolean().optional(),
+  payee: InvoicePaymentAccountSchema.optional(),
+}).strict()
+
+/** PUT /api/cash-accounts/payee-defaults: which account invoices in a currency pay to. */
+export const SetInvoicePayeeDefaultSchema = z.object({
+  currency: CurrencySchema,
+  cash_account_id: uuid.nullable(),
+}).strict()
+
 const InvoicePaymentAccountsSchema = z
  .partialRecord(CurrencySchema, InvoicePaymentAccountSchema)
  .superRefine((accounts, ctx) => {
@@ -12,7 +12,7 @@
 */

 export const INVOICE_FULL_COLUMNS =
-  'id, invoice_number, customer_id, invoice_date, due_date, delivery_date, status, currency, exchange_rate, exchange_rate_date, subtotal, subtotal_sek, vat_amount, vat_amount_sek, total, total_sek, ore_rounding, vat_treatment, vat_rate, moms_ruta, your_reference, our_reference, invoice_marking, notes, payment_link_url, stripe_payment_link_id, payment_link_auto, reverse_charge_text, credited_invoice_id, document_type, converted_from_id, valid_until, quote_status, quote_decided_at, paid_at, paid_amount, remaining_amount, default_dimensions, deduction_total, deduction_personnummer_last4, created_at, updated_at'
+  'id, invoice_number, customer_id, invoice_date, due_date, delivery_date, status, currency, exchange_rate, exchange_rate_date, subtotal, subtotal_sek, vat_amount, vat_amount_sek, total, total_sek, ore_rounding, vat_treatment, vat_rate, moms_ruta, your_reference, our_reference, invoice_marking, notes, payment_link_url, stripe_payment_link_id, payment_link_auto, payment_cash_account_id, payment_details, reverse_charge_text, credited_invoice_id, document_type, converted_from_id, valid_until, quote_status, quote_decided_at, paid_at, paid_amount, remaining_amount, default_dimensions, deduction_total, deduction_personnummer_last4, created_at, updated_at'

 /**
 * Projection for the v1 PDF download route. Narrower than INVOICE_FULL_COLUMNS
@@ -32,7 +32,10 @@ export const INVOICE_PDF_COLUMNS =
  'id, invoice_number, customer_id, invoice_date, due_date, delivery_date, status, document_type, ' +
  'currency, subtotal, vat_amount, total, ore_rounding, vat_treatment, vat_rate, moms_ruta, ' +
  'reverse_charge_text, your_reference, our_reference, invoice_marking, notes, credited_invoice_id, ' +
-  'paid_amount, remaining_amount, deduction_total, deduction_personnummer_last4'
+  'paid_amount, remaining_amount, deduction_total, deduction_personnummer_last4, ' +
+  // The frozen payee: an issued invoice that chose a bank account must print
+  // that account, not today's company default.
+  'payment_cash_account_id, payment_details'

 export const INVOICE_ITEM_FULL_COLUMNS =
  'id, sort_order, line_type, description, quantity, unit, unit_price, discount_percent, line_total, vat_rate, vat_amount, article_id, revenue_account, deduction_type, deduction_amount, labor_hours, work_type, housing_designation, apartment_number, brf_org_number, dimensions, sales_order_item_id, created_at'
@@ -0,0 +1,224 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { createQueuedMockSupabase } from '@/tests/helpers'
+import type { CashAccount } from '@/types'
+import {
+  cashAccountPayee,
+  createManualBankAccount,
+  isBankCashAccount,
+  isUsableInvoicePayee,
+  propagateLegacyPayeeWrite,
+  updateCashAccountPayee,
+} from '../invoice-payee'
+
+vi.mock('@/lib/import/account-sync', () => ({
+  syncMappedAccounts: vi.fn().mockResolvedValue({ error: null }),
+}))
+
+vi.mock('@/lib/cash-accounts/service', () => ({
+  findFreeLedgerAccount: vi.fn().mockResolvedValue('1931'),
+}))
+
+const { supabase, enqueue, reset, findCalls } = createQueuedMockSupabase()
+
+function account(overrides: Partial<CashAccount> = {}): CashAccount {
+  return {
+    id: 'ca-1',
+    company_id: 'company-1',
+    bank_connection_id: null,
+    external_uid: null,
+    iban: null,
+    bban: null,
+    payee_iban: null,
+    bank_name: null,
+    clearing_number: null,
+    account_number: null,
+    bankgiro: null,
+    plusgiro: null,
+    swish: null,
+    bic: null,
+    bank_code: null,
+    foreign_account_number: null,
+    invoice_payee: true,
+    name: 'Företagskonto',
+    currency: 'SEK',
+    ledger_account: '1930',
+    balance: null,
+    available_balance: null,
+    balance_updated_at: null,
+    enabled: true,
+    is_primary: true,
+    source: 'manual',
+    voucher_series: null,
+    created_at: '2026-01-01T00:00:00Z',
+    updated_at: '2026-01-01T00:00:00Z',
+    ...overrides,
+  }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  reset()
+})
+
+describe('cashAccountPayee', () => {
+  it('normalises IBAN and BIC and passes the giro numbers through', () => {
+    const payee = cashAccountPayee(account({ payee_iban: 'se45 5000 0000 0583 9825 7466', bic: 'esse sess', bankgiro: '5050-1234' }))
+    expect(payee.iban).toBe('SE4550000000058398257466')
+    expect(payee.bic).toBe('ESSESESS')
+    expect(payee.bankgiro).toBe('5050-1234')
+    expect(payee.plusgiro).toBeNull()
+  })
+})
+
+describe('isUsableInvoicePayee', () => {
+  it('needs the payee flag, enabled, and identifiers the currency accepts', () => {
+    expect(isUsableInvoicePayee(account({ bankgiro: '5050-1234' }), 'SEK')).toBe(true)
+    expect(isUsableInvoicePayee(account({ bankgiro: '5050-1234', invoice_payee: false }), 'SEK')).toBe(false)
+    expect(isUsableInvoicePayee(account({ bankgiro: '5050-1234', enabled: false }), 'SEK')).toBe(false)
+    expect(isUsableInvoicePayee(account(), 'SEK')).toBe(false)
+  })
+
+  it('a SEK account with an IBAN is a usable EUR payee; a bankgiro-only one is not', () => {
+    expect(isUsableInvoicePayee(account({ payee_iban: 'SE4550000000058398257466' }), 'EUR')).toBe(true)
+    // The bank-identity iban never prints: only payee_iban counts.
+    expect(isUsableInvoicePayee(account({ iban: 'SE4550000000058398257466' }), 'EUR')).toBe(false)
+    expect(isUsableInvoicePayee(account({ bankgiro: '5050-1234' }), 'EUR')).toBe(false)
+  })
+
+  it('accepts the USD routing triple without an IBAN', () => {
+    expect(isUsableInvoicePayee(
+      account({ currency: 'USD', ledger_account: '1933', bank_code: '021000021', foreign_account_number: '12345678', bic: 'CHASUS33' }),
+      'USD',
+    )).toBe(true)
+  })
+})
+
+describe('isBankCashAccount', () => {
+  it('keeps giro/bank rows (1920-1999) and drops PSP clearing accounts and the cash till', () => {
+    expect(isBankCashAccount({ ledger_account: '1920' })).toBe(true)
+    expect(isBankCashAccount({ ledger_account: '1930' })).toBe(true)
+    expect(isBankCashAccount({ ledger_account: '1945' })).toBe(true)
+    expect(isBankCashAccount({ ledger_account: '1910' })).toBe(false)
+    expect(isBankCashAccount({ ledger_account: '1919' })).toBe(false)
+    expect(isBankCashAccount({ ledger_account: '1686' })).toBe(false)
+    expect(isBankCashAccount({ ledger_account: '1584' })).toBe(false)
+  })
+})
+
+describe('updateCashAccountPayee', () => {
+  it('writes only the supplied keys, clears with null, normalises IBAN/BIC', async () => {
+    enqueue({ data: account({ bankgiro: '5050-1234' }) })
+    await updateCashAccountPayee(supabase as never, 'company-1', 'ca-1', {
+      bankgiro: '5050-1234',
+      plusgiro: null,
+      iban: 'se45 5000 0000 0583 9825 7466',
+      invoice_payee: true,
+    })
+    const [update] = findCalls('cash_accounts', 'update')
+    expect(update[0]).toMatchObject({
+      bankgiro: '5050-1234',
+      plusgiro: null,
+      payee_iban: 'SE4550000000058398257466',
+      invoice_payee: true,
+    })
+    // Untouched keys are undefined (dropped by supabase-js), never null.
+    expect((update[0] as Record<string, unknown>).swish).toBeUndefined()
+    expect((update[0] as Record<string, unknown>).iban).toBeUndefined()
+    const eqCalls = findCalls('cash_accounts', 'eq')
+    expect(eqCalls).toContainEqual(['company_id', 'company-1'])
+    expect(eqCalls).toContainEqual(['id', 'ca-1'])
+  })
+})
+
+describe('createManualBankAccount', () => {
+  it('allocates a free 19xx slot past every row the company already holds, syncs the chart, and inserts a manual payee row', async () => {
+    enqueue({ data: [{ ledger_account: '1930' }] })   // existing rows (the seeded manual 1930)
+    enqueue({ data: account({ id: 'ca-new', ledger_account: '1931', source: 'manual', bankgiro: '5050-1234' }) })
+    const created = await createManualBankAccount(supabase as never, 'company-1', 'user-1', {
+      name: 'Sparkonto',
+      currency: 'sek',
+      payee: { bankgiro: '5050-1234', iban: ' se45 5000 0000 0583 9825 7466 ' },
+    })
+    expect(created.id).toBe('ca-new')
+    const [insert] = findCalls('cash_accounts', 'insert')
+    expect(insert[0]).toMatchObject({
+      company_id: 'company-1',
+      ledger_account: '1931',
+      currency: 'SEK',
+      name: 'Sparkonto',
+      source: 'manual',
+      invoice_payee: true,
+      is_primary: false,
+      bankgiro: '5050-1234',
+      iban: 'SE4550000000058398257466',
+      payee_iban: 'SE4550000000058398257466',
+    })
+    // The seeded 1930 row is manual, which findFreeLedgerAccount treats as
+    // free (the PSD2 path promotes it in place); this path inserts, so it
+    // must be excluded or the insert trips the (company, ledger) UNIQUE.
+    const { findFreeLedgerAccount } = await import('@/lib/cash-accounts/service')
+    expect(findFreeLedgerAccount).toHaveBeenCalledWith(expect.anything(), 'company-1', 'SEK', new Set(['1930']))
+  })
+
+  it('refuses a requested ledger account another row already holds', async () => {
+    enqueue({ data: [{ ledger_account: '1930' }, { ledger_account: '1931' }] })
+    await expect(createManualBankAccount(supabase as never, 'company-1', 'user-1', {
+      name: 'X', currency: 'SEK', ledger_account: '1931',
+    })).rejects.toThrow(/already a cash account/)
+    expect(findCalls('cash_accounts', 'insert')).toHaveLength(0)
+  })
+})
+
+describe('propagateLegacyPayeeWrite', () => {
+  it('writes a legacy SEK column change through to the SEK default account', async () => {
+    enqueue({ data: [{ currency: 'SEK', cash_account_id: 'ca-1' }] }) // defaults
+    enqueue({ data: account({ bankgiro: '5050-1234' }) })                // update
+    const written = await propagateLegacyPayeeWrite(supabase as never, 'company-1', { bankgiro: '5050-1234' })
+    expect(written).toEqual(['SEK'])
+    expect(findCalls('cash_accounts', 'update')).toEqual([[{ invoice_payee: true, bankgiro: '5050-1234' }]])
+    expect(findCalls('invoice_payee_defaults', 'upsert')).toHaveLength(0)
+  })
+
+  it('adopts the primary SEK account when no SEK default exists yet: fields first, then the default', async () => {
+    enqueue({ data: [] })                                                  // defaults: none
+    enqueue({ data: { id: 'ca-primary', ledger_account: '1930' } })        // primary lookup
+    enqueue({ data: account({ id: 'ca-primary', payee_iban: 'SE4550000000058398257466' }) }) // update
+    enqueue({ data: null })                                                // upsert default
+    const written = await propagateLegacyPayeeWrite(supabase as never, 'company-1', {
+      iban: 'SE4550000000058398257466',
+      bic: '',
+    })
+    expect(written).toEqual(['SEK'])
+    expect(findCalls('invoice_payee_defaults', 'upsert')[0][0]).toEqual({
+      company_id: 'company-1',
+      currency: 'SEK',
+      cash_account_id: 'ca-primary',
+    })
+    const [update] = findCalls('cash_accounts', 'update')
+    expect(update[0]).toMatchObject({
+      invoice_payee: true,
+      payee_iban: 'SE4550000000058398257466',
+      bic: null,
+    })
+  })
+
+  it('a full map entry replaces every payee field on the default account; currencies without a default are skipped', async () => {
+    enqueue({ data: [{ currency: 'EUR', cash_account_id: 'ca-1' }] })
+    enqueue({ data: account({ payee_iban: 'SE4550000000058398257466' }) })
+    const written = await propagateLegacyPayeeWrite(supabase as never, 'company-1', {
+      invoice_payment_accounts: {
+        EUR: { iban: 'SE4550000000058398257466', bic: 'ESSESESS' },
+        USD: { iban: 'GB33BUKB20201555555555' },
+      },
+    })
+    expect(written).toEqual(['EUR'])
+    const [payload] = findCalls('cash_accounts', 'update')[0] as [Record<string, unknown>]
+    expect(payload).toMatchObject({ invoice_payee: true, payee_iban: 'SE4550000000058398257466', bic: 'ESSESESS', bankgiro: null, swish: null })
+  })
+
+  it('does nothing when the change carries no payment instructions', async () => {
+    const written = await propagateLegacyPayeeWrite(supabase as never, 'company-1', { email: 'x@y.se' } as never)
+    expect(written).toEqual([])
+    expect(findCalls('invoice_payee_defaults', 'select')).toHaveLength(0)
+  })
+})
@@ -0,0 +1,405 @@
+import type { SupabaseClient } from '@supabase/supabase-js'
+import type {
+  CashAccount,
+  CashAccountPayeeFields,
+  Currency,
+  InvoicePayeeDefault,
+  InvoicePaymentAccount,
+} from '@/types'
+import { createLogger } from '@/lib/logger'
+import { getBASReference } from '@/lib/bookkeeping/bas-reference'
+import { syncMappedAccounts } from '@/lib/import/account-sync'
+import {
+  hasUsableInvoicePaymentAccount,
+  isInvoicePaymentAccountCurrency,
+  normalizeInvoicePaymentAccount,
+} from '@/lib/invoices/payment-accounts'
+import { findFreeLedgerAccount } from '@/lib/cash-accounts/service'
+
+const log = createLogger('cash-accounts/invoice-payee')
+
+export const PAYEE_FIELDS: readonly (keyof CashAccountPayeeFields)[] = [
+  'bank_name',
+  'clearing_number',
+  'account_number',
+  'bankgiro',
+  'plusgiro',
+  'swish',
+  'iban',
+  'bic',
+  'bank_code',
+  'foreign_account_number',
+]
+
+/** A cash account's payee columns: the InvoicePaymentAccount keys, with the printed IBAN in payee_iban. */
+export type CashAccountPayeeSource = Omit<CashAccountPayeeFields, 'iban'> & { payee_iban: string | null }
+
+/**
+ * The payee fields of a cash account in the shape the invoice renderers read.
+ * The printed IBAN is payee_iban, never the bank-identity iban column.
+ */
+export function cashAccountPayee(account: CashAccountPayeeSource): InvoicePaymentAccount {
+  return normalizeInvoicePaymentAccount({
+    bank_name: account.bank_name,
+    clearing_number: account.clearing_number,
+    account_number: account.account_number,
+    bankgiro: account.bankgiro,
+    plusgiro: account.plusgiro,
+    swish: account.swish,
+    iban: account.payee_iban,
+    bic: account.bic,
+    bank_code: account.bank_code,
+    foreign_account_number: account.foreign_account_number,
+  })
+}
+
+/**
+ * Whether the account can be printed on an invoice in `currency`: enabled,
+ * flagged as a payee, and carrying the identifiers that currency needs (an
+ * IBAN for anything but SEK, or the USD/GBP routing triple).
+ */
+export function isUsableInvoicePayee(account: CashAccount, currency: Currency): boolean {
+  return account.enabled
+    && account.invoice_payee
+    && hasUsableInvoicePaymentAccount(cashAccountPayee(account), currency)
+}
+
+/**
+ * Bank-type rows only: Stripe (1686), Woo (1680) and Shopify (1584) also live
+ * in cash_accounts, and so may a till (1910 Kassa, 1911-1919). A customer is
+ * paid to a giro or bank account (BAS 1920-1999), never to a cash till.
+ */
+export function isBankCashAccount(account: Pick<CashAccount, 'ledger_account'>): boolean {
+  return /^19[2-9]\d$/.test(account.ledger_account)
+}
+
+export interface InvoicePayeeState {
+  accounts: CashAccount[]
+  defaults: InvoicePayeeDefault[]
+}
+
+/**
+ * Every bank-type cash account of the company (payee or not: the settings
+ * page lets the user promote one) plus the per-currency defaults.
+ */
+export async function loadInvoicePayeeState(
+  supabase: SupabaseClient,
+  companyId: string,
+): Promise<InvoicePayeeState> {
+  const [accountsRes, defaultsRes] = await Promise.all([
+    supabase
+      .from('cash_accounts')
+      .select('*')
+      .eq('company_id', companyId)
+      .order('is_primary', { ascending: false })
+      .order('ledger_account', { ascending: true }),
+    supabase
+      .from('invoice_payee_defaults')
+      .select('*')
+      .eq('company_id', companyId),
+  ])
+  if (accountsRes.error) {
+    throw new Error(`invoice payee accounts lookup failed: ${accountsRes.error.message}`)
+  }
+  if (defaultsRes.error) {
+    throw new Error(`invoice payee defaults lookup failed: ${defaultsRes.error.message}`)
+  }
+  return {
+    accounts: ((accountsRes.data ?? []) as CashAccount[]).filter(isBankCashAccount),
+    defaults: (defaultsRes.data ?? []) as InvoicePayeeDefault[],
+  }
+}
+
+/** The default payee account for `currency`, or null when none is configured. */
+export async function getDefaultInvoicePayee(
+  supabase: SupabaseClient,
+  companyId: string,
+  currency: Currency,
+): Promise<CashAccount | null> {
+  const { data, error } = await supabase
+    .from('invoice_payee_defaults')
+    .select('cash_account:cash_accounts!invoice_payee_defaults_same_company(*)')
+    .eq('company_id', companyId)
+    .eq('currency', currency)
+    .maybeSingle()
+  if (error) {
+    log.warn('getDefaultInvoicePayee failed', { companyId, currency, error: error.message })
+    return null
+  }
+  const account = (data as { cash_account: CashAccount | CashAccount[] | null } | null)?.cash_account
+  if (!account) return null
+  return Array.isArray(account) ? account[0] ?? null : account
+}
+
+export type PayeeUpdate = Partial<CashAccountPayeeFields> & {
+  name?: string | null
+  invoice_payee?: boolean
+}
+
+/**
+ * Update payee fields on one of the company's cash accounts. Only supplied
+ * keys are written; explicit null clears. The mirror trigger rewrites
+ * company_settings from this row when it is a default for some currency.
+ */
+export async function updateCashAccountPayee(
+  supabase: SupabaseClient,
+  companyId: string,
+  cashAccountId: string,
+  update: PayeeUpdate,
+): Promise<CashAccount | null> {
+  // Literal payload (the phantom-column guard reads literal keys): a key the
+  // caller did not supply stays undefined and is dropped by supabase-js, so
+  // only supplied fields are written and explicit null still clears.
+  const has = (key: keyof PayeeUpdate) => key in update && update[key] !== undefined
+  if (!(Object.keys(update) as (keyof PayeeUpdate)[]).some(has)) {
+    const { data } = await supabase
+      .from('cash_accounts')
+      .select('*')
+      .eq('company_id', companyId)
+      .eq('id', cashAccountId)
+      .maybeSingle()
+    return (data as CashAccount | null) ?? null
+  }
+  const { data, error } = await supabase
+    .from('cash_accounts')
+    .update({
+      bank_name: has('bank_name') ? clean(update.bank_name) : undefined,
+      clearing_number: has('clearing_number') ? clean(update.clearing_number) : undefined,
+      account_number: has('account_number') ? clean(update.account_number) : undefined,
+      bankgiro: has('bankgiro') ? clean(update.bankgiro) : undefined,
+      plusgiro: has('plusgiro') ? clean(update.plusgiro) : undefined,
+      swish: has('swish') ? clean(update.swish) : undefined,
+      payee_iban: has('iban') ? compact(clean(update.iban), true) : undefined,
+      bic: has('bic') ? compact(clean(update.bic), true) : undefined,
+      bank_code: has('bank_code') ? clean(update.bank_code) : undefined,
+      foreign_account_number: has('foreign_account_number') ? clean(update.foreign_account_number) : undefined,
+      name: has('name') ? clean(update.name) : undefined,
+      invoice_payee: update.invoice_payee,
+    })
+    .eq('company_id', companyId)
+    .eq('id', cashAccountId)
+    .select('*')
+    .maybeSingle()
+  if (error) throw new Error(`cash_accounts payee update failed: ${error.message}`)
+  return (data as CashAccount | null) ?? null
+}
+
+/**
+ * Make `cashAccountId` the default payee for `currency`, or clear the
+ * default when null. The account must belong to the company: the composite
+ * FK rejects a foreign id and the caller sees the error.
+ */
+export async function setInvoicePayeeDefault(
+  supabase: SupabaseClient,
+  companyId: string,
+  currency: Currency,
+  cashAccountId: string | null,
+): Promise<void> {
+  if (cashAccountId === null) {
+    const { error } = await supabase
+      .from('invoice_payee_defaults')
+      .delete()
+      .eq('company_id', companyId)
+      .eq('currency', currency)
+    if (error) throw new Error(`invoice_payee_defaults delete failed: ${error.message}`)
+    return
+  }
+  const { error } = await supabase
+    .from('invoice_payee_defaults')
+    .upsert(
+      { company_id: companyId, currency, cash_account_id: cashAccountId },
+      { onConflict: 'company_id,currency' },
+    )
+  if (error) throw new Error(`invoice_payee_defaults upsert failed: ${error.message}`)
+}
+
+export interface CreateManualBankAccountInput {
+  name: string
+  currency: string
+  ledger_account?: string | null
+  payee?: Partial<CashAccountPayeeFields>
+  invoice_payee?: boolean
+}
+
+/**
+ * A bank account the user types in (no PSD2 connection). Allocates the next
+ * free 19xx slot for the currency unless one is given, and makes sure that
+ * number exists in the chart so bookings and pickers can see it.
+ */
+export async function createManualBankAccount(
+  supabase: SupabaseClient,
+  companyId: string,
+  userId: string,
+  input: CreateManualBankAccountInput,
+): Promise<CashAccount> {
+  const currency = input.currency.toUpperCase()
+  // findFreeLedgerAccount treats a slot held by a manual row as free (the
+  // PSD2 path promotes that row in place); this path INSERTS, so every slot
+  // any row holds is taken.
+  const { data: existing, error: existingError } = await supabase
+    .from('cash_accounts')
+    .select('ledger_account')
+    .eq('company_id', companyId)
+  if (existingError) throw new Error(`cash_accounts lookup failed: ${existingError.message}`)
+  const taken = new Set(((existing ?? []) as { ledger_account: string }[]).map((r) => r.ledger_account))
+  const requested = input.ledger_account?.trim()
+  if (requested && taken.has(requested)) {
+    throw new Error(`Ledger account ${requested} is already a cash account of this company`)
+  }
+  const ledger = requested || (await findFreeLedgerAccount(supabase, companyId, currency, taken))
+  if (!ledger) {
+    throw new Error('No free 19xx ledger account for a new bank account')
+  }
+  const chartName = getBASReference(ledger)?.account_name ?? `Bankkonto ${currency}`
+  const sync = await syncMappedAccounts(
+    supabase,
+    companyId,
+    userId,
+    [{
+      sourceAccount: ledger,
+      sourceName: chartName,
+      targetAccount: ledger,
+      targetName: chartName,
+      confidence: 1,
+      matchType: 'exact',
+      isOverride: false,
+    }],
+    false,
+  )
+  if (sync.error) {
+    throw new Error(`chart sync failed for ${ledger}: ${sync.error}`)
+  }
+
+  const payee = input.payee ?? {}
+  const { data, error } = await supabase
+    .from('cash_accounts')
+    .insert({
+      company_id: companyId,
+      ledger_account: ledger,
+      currency,
+      name: input.name.trim(),
+      enabled: true,
+      is_primary: false,
+      source: 'manual',
+      invoice_payee: input.invoice_payee ?? true,
+      bank_name: clean(payee.bank_name),
+      clearing_number: clean(payee.clearing_number),
+      account_number: clean(payee.account_number),
+      bankgiro: clean(payee.bankgiro),
+      plusgiro: clean(payee.plusgiro),
+      swish: clean(payee.swish),
+      // A typed account: the printed IBAN is also the account's identity, so
+      // a later bank connection with the same IBAN promotes this row in place.
+      iban: compact(clean(payee.iban), true),
+      payee_iban: compact(clean(payee.iban), true),
+      bic: compact(clean(payee.bic), true),
+      bank_code: clean(payee.bank_code),
+      foreign_account_number: clean(payee.foreign_account_number),
+    })
+    .select('*')
+    .single()
+  if (error) throw new Error(`cash_accounts insert failed: ${error.message}`)
+  return data as CashAccount
+}
+
+/**
+ * Legacy writers (PUT /api/settings, v1 settings, MCP update_company_settings)
+ * still send payment instructions as company_settings columns or as the
+ * per-currency map. Write them through to the default cash account for each
+ * currency so the account stays the truth; the mirror trigger then rewrites
+ * the map and legacy columns from the account, which is what the caller
+ * asked for. Currencies with no default account are left to the caller's
+ * own company_settings write (the resolver's fallback).
+ *
+ * Returns the currencies that were written through, so callers can decide
+ * whether their own company_settings write still needs those keys.
+ */
+export async function propagateLegacyPayeeWrite(
+  supabase: SupabaseClient,
+  companyId: string,
+  changes: {
+    invoice_payment_accounts?: Partial<Record<string, Partial<InvoicePaymentAccount> | null | undefined>>
+  } & Partial<Record<keyof InvoicePaymentAccount, string | null | undefined>>,
+): Promise<Currency[]> {
+  const entries = new Map<Currency, Partial<InvoicePaymentAccount>>()
+  const map = changes.invoice_payment_accounts
+  if (map) {
+    for (const [currency, account] of Object.entries(map)) {
+      if (!isInvoicePaymentAccountCurrency(currency) || !account) continue
+      entries.set(currency, account)
+    }
+  }
+  const legacyKeys: (keyof InvoicePaymentAccount)[] = [
+    'bank_name', 'clearing_number', 'account_number', 'bankgiro', 'plusgiro', 'swish', 'iban', 'bic',
+  ]
+  if (!entries.has('SEK') && legacyKeys.some((key) => changes[key] !== undefined)) {
+    const partial: Partial<InvoicePaymentAccount> = {}
+    for (const key of legacyKeys) {
+      if (changes[key] !== undefined) partial[key] = changes[key] ?? null
+    }
+    entries.set('SEK', partial)
+  }
+  if (entries.size === 0) return []
+
+  const { data: defaultsData, error: defaultsError } = await supabase
+    .from('invoice_payee_defaults')
+    .select('currency, cash_account_id')
+    .eq('company_id', companyId)
+  if (defaultsError) {
+    throw new Error(`invoice_payee_defaults lookup failed: ${defaultsError.message}`)
+  }
+  const defaults = new Map(
+    ((defaultsData ?? []) as { currency: string; cash_account_id: string }[])
+      .map((row) => [row.currency, row.cash_account_id] as const),
+  )
+
+  const written: Currency[] = []
+  for (const [currency, account] of entries) {
+    let target = defaults.get(currency) ?? null
+    let adopt = false
+    if (!target && currency === 'SEK') {
+      // Every company is seeded with a primary SEK account: adopt it as the
+      // SEK payee so a first-time bank-details save lands on an account.
+      const { data: primary } = await supabase
+        .from('cash_accounts')
+        .select('id, ledger_account')
+        .eq('company_id', companyId)
+        .eq('currency', 'SEK')
+        .eq('enabled', true)
+        .eq('is_primary', true)
+        .maybeSingle()
+      const row = primary as { id: string; ledger_account: string } | null
+      if (row && isBankCashAccount(row)) {
+        target = row.id
+        adopt = true
+      }
+    }
+    if (!target) continue
+    // A full map entry replaces the account's payee (the settings form sends
+    // every field); a partial legacy write only touches the supplied keys.
+    const update: PayeeUpdate = { invoice_payee: true }
+    const full = map?.[currency] !== undefined
+    for (const field of PAYEE_FIELDS) {
+      if (full || field in account) update[field] = account[field] ?? null
+    }
+    // Fields first, default second: the default insert fires the mirror, and
+    // it must see the filled account, never an empty one.
+    await updateCashAccountPayee(supabase, companyId, target, update)
+    if (adopt) await setInvoicePayeeDefault(supabase, companyId, 'SEK', target)
+    written.push(currency)
+  }
+  return written
+}
+
+function clean(value: string | null | undefined): string | null {
+  if (value === undefined || value === null) return null
+  const trimmed = value.trim()
+  return trimmed ? trimmed : null
+}
+
+/** Strip inner whitespace (IBAN, BIC), optionally upper-casing. */
+function compact(value: string | null, upper = false): string | null {
+  if (value === null) return null
+  const stripped = value.replace(/\s/g, '')
+  return upper ? stripped.toUpperCase() : stripped
+}
@@ -44,6 +44,8 @@ export interface UpsertFromPsd2Input {
  currency: string
  ledger_account: string
  iban?: string | null
+  /** Raw BBAN from the ASPSP (Swedish: clearing + account number). */
+  bban?: string | null
  name?: string | null
  balance?: number | null
  available_balance?: number | null
@@ -1172,6 +1174,9 @@ export async function upsertFromPsd2(
    bank_connection_id: input.bank_connection_id,
    external_uid: input.external_uid,
    iban: input.iban ?? null,
+    // Only overwrite when the bank sent one: a typed BBAN must survive a
+    // sync from an ASPSP that reports IBAN only.
+    ...(input.bban ? { bban: input.bban } : {}),
    name: input.name ?? null,
    currency: input.currency.toUpperCase(),
    ledger_account: input.ledger_account,
@@ -231,7 +231,7 @@ function safeBrandingColor(value: string | null | undefined, fallback: string):
 */
 export function generateInvoiceEmailHtml(data: InvoiceEmailData): string {
  const { invoice, customer } = data
-  const company = companyWithInvoicePaymentAccount(data.company, invoice.currency)
+  const company = companyWithInvoicePaymentAccount(data.company, invoice.currency, invoice.payment_details ?? null)

  const lang = resolveLang(customer)
  const L = LABELS[lang]
@@ -396,7 +396,7 @@ export function generateInvoiceEmailHtml(data: InvoiceEmailData): string {
 */
 export function generateInvoiceEmailText(data: InvoiceEmailData): string {
  const { invoice, customer } = data
-  const company = companyWithInvoicePaymentAccount(data.company, invoice.currency)
+  const company = companyWithInvoicePaymentAccount(data.company, invoice.currency, invoice.payment_details ?? null)

  const lang = resolveLang(customer)
  const L = LABELS[lang]
@@ -288,7 +288,7 @@ export function generateReminderEmailHtml(data: ReminderEmailData): string {
  } = data
  // Payment details follow the invoice currency, same as the invoice email
  // and PDF: a EUR reminder must never print the SEK account's IBAN.
-  const company = companyWithInvoicePaymentAccount(data.company, invoice.currency)
+  const company = companyWithInvoicePaymentAccount(data.company, invoice.currency, invoice.payment_details ?? null)
  const config = REMINDER_CONFIG[reminderLevel]
  const interestRatePercent = (interestRate * 100).toLocaleString('sv-SE', {
    minimumFractionDigits: 0,
@@ -492,7 +492,7 @@ export function generateReminderEmailText(data: ReminderEmailData): string {
  } = data
  // Payment details follow the invoice currency, same as the invoice email
  // and PDF: a EUR reminder must never print the SEK account's IBAN.
-  const company = companyWithInvoicePaymentAccount(data.company, invoice.currency)
+  const company = companyWithInvoicePaymentAccount(data.company, invoice.currency, invoice.payment_details ?? null)
  const config = REMINDER_CONFIG[reminderLevel]
  const interestRatePercent = (interestRate * 100).toLocaleString('sv-SE', {
    minimumFractionDigits: 0,
@@ -1151,6 +1151,27 @@ const INVOICE: Record<string, StructuredErrorEntry> = {
    message_sv: 'Företagsinställningar saknas.',
    message_en: 'Company settings are missing.',
  },
+  INVOICE_SEND_PAYMENT_ACCOUNT_INVALID: {
+    httpStatus: 400,
+    message_sv: 'Bankkontot som fakturan ska betalas till kan inte längre användas: det är avstängt, borttaget från kundfakturor eller saknar uppgifter för fakturans valuta. Välj ett annat konto på fakturan eller uppdatera kontot under Inställningar → Fakturering.',
+    message_en: 'The bank account this invoice is to be paid to can no longer be used: it is disabled, no longer shown on customer invoices, or lacks details for the invoice currency. Pick another account on the invoice or update the account under Inställningar → Fakturering (Settings → Invoicing).',
+    remediation: {
+      description: 'Välj ett annat bankkonto på fakturan, eller återaktivera kontot och fyll i dess betaluppgifter under Inställningar → Fakturering.',
+    },
+  },
+  INVOICE_PAYEE_SNAPSHOT_FAILED: {
+    httpStatus: 500,
+    message_sv: 'Betaluppgifterna kunde inte sparas på fakturan. Fakturan skickades inte; försök igen.',
+    message_en: 'The payment details could not be saved on the invoice. The invoice was not sent; try again.',
+  },
+  INVOICE_PAYEE_ACCOUNT_INVALID: {
+    httpStatus: 400,
+    message_sv: 'Bankkontot kan inte användas som betalningsmottagare på fakturan: det tillhör inte företaget, visas inte på kundfakturor eller saknar uppgifter för fakturans valuta.',
+    message_en: 'The bank account cannot be the payee on this invoice: it does not belong to the company, is not shown on customer invoices, or lacks details for the invoice currency.',
+    remediation: {
+      description: 'Välj ett av företagets bankkonton som är markerat "Visas på fakturor" och har betaluppgifter för fakturans valuta.',
+    },
+  },
  INVOICE_SEND_PAYMENT_ACCOUNT_MISSING: {
    httpStatus: 400,
    // Currency-neutral by necessity (the registry has no details). Surfaces
@@ -180,6 +180,24 @@ describe('findMatchingInvoices', () => {
    expect(queued.findCalls('invoices', 'eq')).toContainEqual(['document_type', 'invoice'])
  })

+  it('breaks a confidence tie in favour of the invoice that asked to be paid to the account the money landed on', async () => {
+    const tx = makeTransaction({ amount: 12500, description: 'Betalning', merchant_name: null, cash_account_id: 'ca-1931' })
+    const base = { total: 12500, status: 'sent' as const, remaining_amount: 12500, currency: 'SEK' as const }
+    mockResult({
+      data: [
+        { ...makeInvoice({ id: 'inv-default', invoice_number: 'F-1', ...base }), payment_cash_account_id: null },
+        { ...makeInvoice({ id: 'inv-1931', invoice_number: 'F-2', ...base }), payment_cash_account_id: 'ca-1931' },
+      ],
+      error: null,
+    })
+
+    const result = await findMatchingInvoices(supabase as never, 'company-1', tx)
+    expect(result).toHaveLength(2)
+    // Same score for both (exact amount, no customer name): scores untouched.
+    expect(result[0].confidence).toBe(result[1].confidence)
+    expect(result[0].invoice.id).toBe('inv-1931')
+  })
+
  it('matches by OCR reference with confidence 0.99', async () => {
    const tx = makeTransaction({ amount: 12500, reference: 'F-2024001' })
    mockResult({
@@ -0,0 +1,174 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { createQueuedMockSupabase } from '@/tests/helpers'
+import type { CashAccount } from '@/types'
+import { resolveInvoicePayeeChoice, resolveInvoiceSettlementAccount, snapshotInvoicePayee } from '../invoice-payee'
+
+const { supabase, enqueue, reset, findCalls } = createQueuedMockSupabase()
+
+const CA_1 = '11111111-1111-4111-8111-111111111111'
+
+function account(overrides: Partial<CashAccount> = {}): CashAccount {
+  return {
+    id: CA_1,
+    company_id: 'company-1',
+    bank_connection_id: null,
+    external_uid: null,
+    iban: null,
+    bban: null,
+    payee_iban: null,
+    bank_name: 'Testbanken',
+    clearing_number: null,
+    account_number: null,
+    bankgiro: '5050-1055',
+    plusgiro: null,
+    swish: null,
+    bic: null,
+    bank_code: null,
+    foreign_account_number: null,
+    invoice_payee: true,
+    name: 'Sparkonto',
+    currency: 'SEK',
+    ledger_account: '1931',
+    balance: null,
+    available_balance: null,
+    balance_updated_at: null,
+    enabled: true,
+    is_primary: false,
+    source: 'manual',
+    voucher_series: null,
+    created_at: '2026-01-01T00:00:00Z',
+    updated_at: '2026-01-01T00:00:00Z',
+    ...overrides,
+  }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  reset()
+})
+
+describe('resolveInvoicePayeeChoice', () => {
+  it('no choice clears both columns without touching the database', async () => {
+    const result = await resolveInvoicePayeeChoice(supabase as never, 'company-1', 'SEK', null)
+    expect(result).toEqual({ ok: true, fields: { payment_cash_account_id: null, payment_details: null } })
+    expect(findCalls('cash_accounts', 'select')).toHaveLength(0)
+  })
+
+  it('rejects an account that is not the company\'s, disabled, not a payee, or unusable for the currency', async () => {
+    enqueue({ data: null })
+    expect(await resolveInvoicePayeeChoice(supabase as never, 'company-1', 'SEK', CA_1)).toMatchObject({
+      ok: false, code: 'INVOICE_PAYEE_ACCOUNT_INVALID', details: { reason: 'not_found' },
+    })
+    enqueue({ data: account({ enabled: false }) })
+    expect(await resolveInvoicePayeeChoice(supabase as never, 'company-1', 'SEK', CA_1)).toMatchObject({
+      ok: false, details: { reason: 'disabled' },
+    })
+    enqueue({ data: account({ invoice_payee: false }) })
+    expect(await resolveInvoicePayeeChoice(supabase as never, 'company-1', 'SEK', CA_1)).toMatchObject({
+      ok: false, details: { reason: 'not_payee' },
+    })
+    // A PSP clearing row (Stripe 1686) is never a payee, whatever its flags say.
+    enqueue({ data: account({ ledger_account: '1686' }) })
+    expect(await resolveInvoicePayeeChoice(supabase as never, 'company-1', 'SEK', CA_1)).toMatchObject({
+      ok: false, details: { reason: 'not_bank_account' },
+    })
+    // Bankgiro only: fine for SEK, not for EUR (needs an IBAN).
+    enqueue({ data: account() })
+    expect(await resolveInvoicePayeeChoice(supabase as never, 'company-1', 'EUR', CA_1)).toMatchObject({
+      ok: false, details: { reason: 'unusable_for_currency' },
+    })
+  })
+
+  it('freezes the account payee fields on a valid choice', async () => {
+    enqueue({ data: account({ payee_iban: 'se45 5000 0000 0583 9825 7466' }) })
+    const result = await resolveInvoicePayeeChoice(supabase as never, 'company-1', 'SEK', CA_1)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.fields.payment_cash_account_id).toBe(CA_1)
+    expect(result.fields.payment_details).toMatchObject({
+      bank_name: 'Testbanken',
+      bankgiro: '5050-1055',
+      iban: 'SE4550000000058398257466',
+      plusgiro: null,
+    })
+    const eqCalls = findCalls('cash_accounts', 'eq')
+    expect(eqCalls).toContainEqual(['company_id', 'company-1'])
+    expect(eqCalls).toContainEqual(['id', CA_1])
+  })
+})
+
+describe('snapshotInvoicePayee', () => {
+  it('leaves an invoice without a chosen account alone', async () => {
+    const result = await snapshotInvoicePayee(supabase as never, 'company-1', {
+      id: 'inv-1', currency: 'SEK', payment_cash_account_id: null, payment_details: null,
+    })
+    expect(result).toEqual({ ok: true, payee: null })
+    expect(findCalls('cash_accounts', 'select')).toHaveLength(0)
+  })
+
+  it('skips credit notes and quotes even when they carry a stale account', async () => {
+    const result = await snapshotInvoicePayee(supabase as never, 'company-1', {
+      id: 'kr-1', currency: 'SEK', payment_cash_account_id: CA_1, credited_invoice_id: 'inv-1',
+      payment_details: { bankgiro: '5050-1055' } as never,
+    })
+    expect(result).toMatchObject({ ok: true, payee: { bankgiro: '5050-1055' } })
+    expect(findCalls('cash_accounts', 'select')).toHaveLength(0)
+  })
+
+  it('refreshes and persists the payee from the account as it is at issue', async () => {
+    enqueue({ data: account({ plusgiro: '123456-7' }) })
+    enqueue({ data: null }) // update
+    const result = await snapshotInvoicePayee(supabase as never, 'company-1', {
+      id: 'inv-1', currency: 'SEK', payment_cash_account_id: CA_1,
+      payment_details: { bankgiro: '5050-1055' } as never,
+    })
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.payee).toMatchObject({ bankgiro: '5050-1055', plusgiro: '123456-7' })
+    const [update] = findCalls('invoices', 'update')
+    expect((update[0] as { payment_details: { plusgiro: string } }).payment_details.plusgiro).toBe('123456-7')
+    expect(findCalls('invoices', 'eq')).toContainEqual(['id', 'inv-1'])
+  })
+
+  it('does not rewrite an unchanged snapshot', async () => {
+    const payee = {
+      bank_name: 'Testbanken', clearing_number: null, account_number: null, bankgiro: '5050-1055',
+      plusgiro: null, swish: null, iban: null, bic: null, bank_code: null, foreign_account_number: null,
+    }
+    enqueue({ data: account() })
+    const result = await snapshotInvoicePayee(supabase as never, 'company-1', {
+      id: 'inv-1', currency: 'SEK', payment_cash_account_id: CA_1, payment_details: payee,
+    })
+    expect(result.ok).toBe(true)
+    expect(findCalls('invoices', 'update')).toHaveLength(0)
+  })
+
+  it('blocks issue when the chosen account can no longer be used', async () => {
+    enqueue({ data: account({ invoice_payee: false }) })
+    const result = await snapshotInvoicePayee(supabase as never, 'company-1', {
+      id: 'inv-1', currency: 'SEK', payment_cash_account_id: CA_1, payment_details: null,
+    })
+    expect(result).toMatchObject({ ok: false, code: 'INVOICE_SEND_PAYMENT_ACCOUNT_INVALID' })
+    expect(findCalls('invoices', 'update')).toHaveLength(0)
+  })
+})
+
+describe('resolveInvoiceSettlementAccount', () => {
+  it('defaults to 1930 without a chosen account and never queries', async () => {
+    expect(await resolveInvoiceSettlementAccount(supabase as never, 'company-1', { payment_cash_account_id: null })).toBe('1930')
+    expect(findCalls('cash_accounts', 'select')).toHaveLength(0)
+  })
+
+  it('debits the chosen account\'s ledger account, and falls back to 1930 when the row is gone, disabled, or not a bank account', async () => {
+    enqueue({ data: { ledger_account: '1931', enabled: true } })
+    expect(await resolveInvoiceSettlementAccount(supabase as never, 'company-1', { payment_cash_account_id: CA_1 })).toBe('1931')
+    expect(findCalls('cash_accounts', 'eq')).toContainEqual(['company_id', 'company-1'])
+    enqueue({ data: null })
+    expect(await resolveInvoiceSettlementAccount(supabase as never, 'company-1', { payment_cash_account_id: CA_1 })).toBe('1930')
+    enqueue({ data: { ledger_account: '1931', enabled: false } })
+    expect(await resolveInvoiceSettlementAccount(supabase as never, 'company-1', { payment_cash_account_id: CA_1 })).toBe('1930')
+    // Stripe clearing (1686) is cleared by the payout, never by a bank transfer.
+    enqueue({ data: { ledger_account: '1686', enabled: true } })
+    expect(await resolveInvoiceSettlementAccount(supabase as never, 'company-1', { payment_cash_account_id: CA_1 })).toBe('1930')
+  })
+})
@@ -258,3 +258,40 @@ describe('describeMissingInvoicePaymentAccount (#2126)', () => {
    expect(isInvoicePaymentAccountCurrency(42)).toBe(false)
  })
 })
+
+describe('per-invoice payee override (invoices.payment_details)', () => {
+  const frozen = {
+    bank_name: 'Sparbanken',
+    clearing_number: null,
+    account_number: null,
+    bankgiro: '5050-1055',
+    plusgiro: null,
+    swish: null,
+    iban: null,
+    bic: null,
+    bank_code: null,
+    foreign_account_number: null,
+  }
+
+  it('the invoice\'s frozen payee wins over the company account for the currency', () => {
+    const settings = company({
+      invoice_payment_accounts: {
+        SEK: { ...frozen, bank_name: 'Huvudbanken', bankgiro: '991-2346' },
+      },
+    })
+    expect(resolveInvoicePaymentAccount(settings, 'SEK', frozen)?.bankgiro).toBe('5050-1055')
+    expect(resolveInvoicePaymentAccount(settings, 'SEK', null)?.bankgiro).toBe('991-2346')
+    const rendered = companyWithInvoicePaymentAccount(settings, 'SEK', frozen)
+    expect(rendered.bank_name).toBe('Sparbanken')
+    expect(rendered.iban).toBeNull()
+  })
+
+  it('the send gate reads the frozen payee from the invoice row', () => {
+    const settings = company({ bankgiro: null, iban: null, plusgiro: null, swish: null, clearing_number: null, account_number: null })
+    const invoice = makeInvoice({ currency: 'SEK', document_type: 'invoice', credited_invoice_id: null })
+    expect(hasRequiredInvoicePaymentAccount(settings, invoice)).toBe(false)
+    expect(hasRequiredInvoicePaymentAccount(settings, { ...invoice, payment_details: frozen })).toBe(true)
+    // A frozen bankgiro-only payee is not enough for a EUR invoice.
+    expect(hasRequiredInvoicePaymentAccount(settings, { ...invoice, currency: 'EUR', payment_details: frozen })).toBe(false)
+  })
+})
@@ -71,6 +71,38 @@ function makeValidInput() {
 }

 describe('generatePeppolBisBillingInvoice', () => {
+  it('prints the same payee as the PDF: the resolved SEK payment account, not the raw legacy column', () => {
+    const input = makeValidInput()
+    // Legacy column says one bankgiro, the resolver's SEK entry another (the
+    // state a v1/MCP settings write used to leave behind). The XML must
+    // follow the resolver, like the PDF and the email do.
+    input.company = makeCompanySettings({
+      ...input.company,
+      bankgiro: '991-2346',
+      invoice_payment_accounts: {
+        SEK: {
+          bank_name: null,
+          clearing_number: null,
+          account_number: null,
+          bankgiro: '5050-1055',
+          plusgiro: null,
+          swish: null,
+          iban: null,
+          bic: null,
+          bank_code: null,
+          foreign_account_number: null,
+        },
+      },
+    })
+
+    const result = generatePeppolBisBillingInvoice(input)
+
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.xml).toContain('<cbc:ID>50501055</cbc:ID>')
+    expect(result.xml).not.toContain('9912346')
+  })
+
  it('generates a Swedish Peppol BIS Billing 3 invoice with reconciled VAT groups', () => {
    const result = generatePeppolBisBillingInvoice(makeValidInput())

@@ -47,6 +47,8 @@ export interface InvoiceCopyInitial {
  notes: string
  ore_rounding: boolean | null
  default_dimensions: Record<string, string>
+  /** The bank account the source asked to be paid to; reusable commercial content. */
+  payment_cash_account_id: string | null
  items: InvoiceCopyItem[]
 }

@@ -78,6 +80,7 @@ export function buildInvoiceCopyInitial(source: InvoiceCopySource): InvoiceCopyI
    notes: source.notes ?? '',
    ore_rounding: source.ore_rounding,
    default_dimensions: source.default_dimensions ?? {},
+    payment_cash_account_id: source.payment_cash_account_id ?? null,
    items: [...source.items]
      .sort((a, b) => a.sort_order - b.sort_order)
      .map((item) => ({
@@ -412,8 +412,14 @@ export async function findInvoiceMatchCandidates(
    }
  }

-  // Sort by confidence descending
-  matches.sort((a, b) => b.confidence - a.confidence)
+  // Sort by confidence descending. Ties (two open invoices for the same
+  // amount on the same day) prefer the invoice that asked to be paid to the
+  // account the money landed on. A tie-breaker only: scores are untouched, so
+  // nothing that did not auto-match before starts to.
+  const landedOn = (transaction as { cash_account_id?: string | null }).cash_account_id ?? null
+  const prefers = (m: InvoiceMatch): number =>
+    landedOn && m.invoice.payment_cash_account_id === landedOn ? 1 : 0
+  matches.sort((a, b) => b.confidence - a.confidence || prefers(b) - prefers(a))

  return {
    matches,
@@ -0,0 +1,178 @@
+import type { SupabaseClient } from '@supabase/supabase-js'
+import type { CashAccount, Currency, Invoice, InvoicePaymentAccount } from '@/types'
+import { cashAccountPayee, isBankCashAccount, isUsableInvoicePayee } from '@/lib/cash-accounts/invoice-payee'
+import { invoiceRequiresPaymentAccount } from '@/lib/invoices/payment-accounts'
+import { ACCOUNT_NUMBER_RE } from '@/lib/invariants'
+import { createLogger } from '@/lib/logger'
+
+const log = createLogger('invoices/payee')
+
+export type InvoicePayeeFields = {
+  payment_cash_account_id: string | null
+  payment_details: InvoicePaymentAccount | null
+}
+
+export type InvoicePayeeChoiceResult =
+  | { ok: true; fields: InvoicePayeeFields }
+  | { ok: false; code: 'INVOICE_PAYEE_ACCOUNT_INVALID'; details: Record<string, unknown> }
+
+async function loadPayeeAccount(
+  supabase: SupabaseClient,
+  companyId: string,
+  cashAccountId: string,
+): Promise<CashAccount | null> {
+  const { data, error } = await supabase
+    .from('cash_accounts')
+    .select('*')
+    .eq('company_id', companyId)
+    .eq('id', cashAccountId)
+    .maybeSingle()
+  if (error) throw new Error(`cash_accounts lookup failed: ${error.message}`)
+  return (data as CashAccount | null) ?? null
+}
+
+/**
+ * Validate a draft's choice of payee account and freeze its payee fields.
+ * Used by every invoice create/update path (dashboard, v1, MCP) so the rule
+ * cannot drift: the account must be the company's, flagged as a payee, and
+ * usable for the invoice currency (an IBAN for anything but SEK).
+ *
+ * null/undefined = no choice: both columns are cleared and the invoice
+ * resolves the company's default for its currency at render time.
+ */
+export async function resolveInvoicePayeeChoice(
+  supabase: SupabaseClient,
+  companyId: string,
+  currency: Currency,
+  cashAccountId: string | null | undefined,
+): Promise<InvoicePayeeChoiceResult> {
+  if (!cashAccountId) {
+    return { ok: true, fields: { payment_cash_account_id: null, payment_details: null } }
+  }
+  const account = await loadPayeeAccount(supabase, companyId, cashAccountId)
+  if (!account || !isBankCashAccount(account) || !isUsableInvoicePayee(account, currency)) {
+    return {
+      ok: false,
+      code: 'INVOICE_PAYEE_ACCOUNT_INVALID',
+      details: {
+        cash_account_id: cashAccountId,
+        currency,
+        reason: !account ? 'not_found' : !isBankCashAccount(account) ? 'not_bank_account' : !account.enabled ? 'disabled' : !account.invoice_payee ? 'not_payee' : 'unusable_for_currency',
+      },
+    }
+  }
+  return {
+    ok: true,
+    fields: { payment_cash_account_id: account.id, payment_details: cashAccountPayee(account) },
+  }
+}
+
+export type InvoicePayeeSnapshotResult =
+  | { ok: true; payee: InvoicePaymentAccount | null }
+  | { ok: false; code: 'INVOICE_SEND_PAYMENT_ACCOUNT_INVALID' | 'INVOICE_PAYEE_SNAPSHOT_FAILED'; details: Record<string, unknown> }
+
+export interface SnapshotInvoicePayeeOptions {
+  /** false = validate and return the payee without writing (dry runs). */
+  persist?: boolean
+}
+
+/**
+ * At issue (send, mark-sent, Peppol, recurring): refresh the frozen payee of
+ * an invoice that chose a bank account from the account as it is now, and
+ * persist it. From here on the invoice prints these fields whatever happens
+ * to the account. An account that can no longer be used blocks issue with a
+ * specific error instead of silently printing the company default.
+ *
+ * Invoices without a chosen account are left alone (payee null): they keep
+ * resolving the per-currency default exactly as before this feature.
+ */
+export async function snapshotInvoicePayee(
+  supabase: SupabaseClient,
+  companyId: string,
+  invoice: Pick<Invoice, 'id' | 'currency'>
+    & Partial<Pick<Invoice, 'payment_cash_account_id' | 'payment_details' | 'document_type' | 'credited_invoice_id'>>,
+  opts: SnapshotInvoicePayeeOptions = {},
+): Promise<InvoicePayeeSnapshotResult> {
+  const cashAccountId = invoice.payment_cash_account_id ?? null
+  if (!cashAccountId) return { ok: true, payee: invoice.payment_details ?? null }
+  // Credit notes, proformas, delivery notes and quotes print no payee: a
+  // stale account on them must not block issue.
+  if (!invoiceRequiresPaymentAccount({
+    credited_invoice_id: invoice.credited_invoice_id ?? null,
+    document_type: invoice.document_type ?? 'invoice',
+  })) {
+    return { ok: true, payee: invoice.payment_details ?? null }
+  }
+
+  const account = await loadPayeeAccount(supabase, companyId, cashAccountId)
+  if (!account || !isBankCashAccount(account) || !isUsableInvoicePayee(account, invoice.currency)) {
+    return {
+      ok: false,
+      code: 'INVOICE_SEND_PAYMENT_ACCOUNT_INVALID',
+      details: { cash_account_id: cashAccountId, currency: invoice.currency },
+    }
+  }
+  const payee = cashAccountPayee(account)
+  const current = invoice.payment_details ?? null
+  if (opts.persist !== false && JSON.stringify(current) !== JSON.stringify(payee)) {
+    const { error } = await supabase
+      .from('invoices')
+      .update({ payment_details: payee })
+      .eq('id', invoice.id)
+      .eq('company_id', companyId)
+    if (error) {
+      // Issue must not continue: the document would print a payee the row
+      // does not carry, and a later re-render would disagree with it.
+      log.error('invoice payee snapshot write failed', { invoiceId: invoice.id, error: error.message })
+      return {
+        ok: false,
+        code: 'INVOICE_PAYEE_SNAPSHOT_FAILED',
+        details: { cash_account_id: cashAccountId, invoice_id: invoice.id, pgMessage: error.message },
+      }
+    }
+  }
+  return { ok: true, payee }
+}
+
+/**
+ * The BAS account a manual "mark as paid" debits: the chosen payee account's
+ * ledger account (1930, 1931, ...) when the invoice chose one and the row
+ * still exists, else the 1930 default the generators have always used.
+ * Bank-transaction matches never come here: they debit the account the
+ * money actually landed on (resolveSettlementAccount on the transaction).
+ */
+export async function resolveInvoiceSettlementAccount(
+  supabase: SupabaseClient,
+  companyId: string,
+  invoice: Partial<Pick<Invoice, 'payment_cash_account_id'>>,
+): Promise<string> {
+  const cashAccountId = invoice.payment_cash_account_id ?? null
+  if (!cashAccountId) return '1930'
+  const { data, error } = await supabase
+    .from('cash_accounts')
+    .select('ledger_account, enabled')
+    .eq('company_id', companyId)
+    .eq('id', cashAccountId)
+    .maybeSingle()
+  if (error) {
+    log.warn('settlement account lookup failed; defaulting to 1930', { cashAccountId, error: error.message })
+    return '1930'
+  }
+  const row = data as { ledger_account?: string; enabled?: boolean } | null
+  const ledger = row?.ledger_account
+  // Only a live bank account (19xx) may take the debit: a PSP clearing
+  // account (1686, 1680, 1584) cleared later by a payout must never receive
+  // a bank transfer, and a disabled or deleted account is not where money
+  // lands any more. Both fall back to 1930, and say so: the printed invoice
+  // named another account, so the bookkeeper must know.
+  if (!row || !ledger || !ACCOUNT_NUMBER_RE.test(ledger) || !isBankCashAccount({ ledger_account: ledger }) || row.enabled === false) {
+    log.warn('chosen payee account is not a live bank account; debiting 1930 instead', {
+      cashAccountId,
+      ledger: ledger ?? null,
+      enabled: row?.enabled ?? null,
+      found: Boolean(row),
+    })
+    return '1930'
+  }
+  return ledger
+}
@@ -9,6 +9,7 @@ import type { CustomIssuanceLine } from '@/lib/invoices/issuance-custom-lines'
 import { recordManualInvoiceDelivery } from '@/lib/invoices/invoice-deliveries'
 import { InvoicePDF } from '@/lib/invoices/pdf-template'
 import { prepareInvoicePdfRender, buildSwishQrDataUrl } from '@/lib/invoices/pdf-render-helpers'
+import { snapshotInvoicePayee } from '@/lib/invoices/invoice-payee'
 import { invoicePdfFilename } from '@/lib/invoices/pdf-filename'
 import {
  hasRequiredInvoicePaymentAccount,
@@ -93,7 +94,7 @@ export async function archiveIssuedInvoicePdf(args: {
    const { branding, company: renderCompany } = await prepareInvoicePdfRender(
      settings,
      renderableInvoice.currency,
-      { paymentAccountRequired },
+      { paymentAccountRequired, payee: renderableInvoice.payment_details ?? null },
    )
    const swishQrDataUrl = await buildSwishQrDataUrl(renderCompany, renderableInvoice)
    const pdfBuffer = await renderToBuffer(
@@ -160,6 +161,15 @@ export async function issueAndBookInvoice(
  const customLines = opts.customLines ?? null
  const id = invoice.id

+  // An invoice that chose a bank account freezes that account's payee now,
+  // from the account as it is at issue; a chosen account that can no longer
+  // be used blocks issue instead of silently printing the company default.
+  const payeeSnapshot = await snapshotInvoicePayee(supabase, companyId, invoice as Invoice)
+  if (!payeeSnapshot.ok) {
+    return { ok: false, errorCode: payeeSnapshot.code, details: payeeSnapshot.details }
+  }
+  ;(invoice as Invoice).payment_details = payeeSnapshot.payee
+
  if (!hasRequiredInvoicePaymentAccount(settings, invoice as Invoice)) {
    return {
      ok: false,
@@ -93,10 +93,21 @@ export function normalizeInvoicePaymentAccount(
  }
 }

+/**
+ * The payee an invoice prints, in precedence order:
+ *   1. `override`: the invoice's own frozen payee (invoices.payment_details,
+ *      written when the invoice chose a bank account and refreshed at issue).
+ *   2. The company's payment account for the invoice currency
+ *      (company_settings.invoice_payment_accounts, mirrored from the default
+ *      cash account per currency since migration 20260903150000).
+ *   3. For SEK only, the legacy flat bank columns.
+ */
 export function resolveInvoicePaymentAccount(
  company: CompanySettings,
  currency: Currency,
+  override?: Partial<InvoicePaymentAccount> | null,
 ): InvoicePaymentAccount | null {
+  if (override) return normalizeInvoicePaymentAccount(override)
  const configured = company.invoice_payment_accounts?.[currency]
  if (configured) return normalizeInvoicePaymentAccount(configured)
  return currency === 'SEK' ? legacySekInvoicePaymentAccount(company) : null
@@ -134,11 +145,12 @@ export function invoiceRequiresPaymentAccount(

 export function hasRequiredInvoicePaymentAccount(
  company: CompanySettings,
-  invoice: Pick<Invoice, 'credited_invoice_id' | 'currency' | 'document_type'>,
+  invoice: Pick<Invoice, 'credited_invoice_id' | 'currency' | 'document_type'>
+    & Partial<Pick<Invoice, 'payment_details'>>,
 ): boolean {
  return !invoiceRequiresPaymentAccount(invoice)
    || hasUsableInvoicePaymentAccount(
-      resolveInvoicePaymentAccount(company, invoice.currency),
+      resolveInvoicePaymentAccount(company, invoice.currency, invoice.payment_details ?? null),
      invoice.currency,
    )
 }
@@ -190,10 +202,11 @@ export class InvoicePaymentAccountMissingError extends Error {
 export function assertInvoicePaymentAccountForRender(
  company: CompanySettings,
  currency: Currency,
+  override?: Partial<InvoicePaymentAccount> | null,
 ): void {
  if (
    !hasUsableInvoicePaymentAccount(
-      resolveInvoicePaymentAccount(company, currency),
+      resolveInvoicePaymentAccount(company, currency, override),
      currency,
    )
  ) {
@@ -203,13 +216,16 @@ export function assertInvoicePaymentAccountForRender(

 /**
 * Return invoice render settings with only the matching payment account.
- * Foreign invoices never inherit the legacy SEK payment details.
+ * Foreign invoices never inherit the legacy SEK payment details. `override`
+ * is the invoice's own frozen payee (invoices.payment_details) when it chose
+ * a bank account; the templates keep reading company.bankgiro etc.
 */
 export function companyWithInvoicePaymentAccount(
  company: CompanySettings,
  currency: Currency,
+  override?: Partial<InvoicePaymentAccount> | null,
 ): CompanySettings {
-  const account = resolveInvoicePaymentAccount(company, currency)
+  const account = resolveInvoicePaymentAccount(company, currency, override)
  const updates = Object.fromEntries(
    PAYMENT_FIELDS.map((field) => [field, account?.[field] ?? null]),
  ) as Pick<CompanySettings, keyof InvoicePaymentAccount>
@@ -20,7 +20,7 @@
 */

 import QRCode from 'qrcode'
-import type { CompanySettings, Currency, Invoice } from '@/types'
+import type { CompanySettings, Currency, Invoice, InvoicePaymentAccount } from '@/types'
 import { brandingFromCompanySettings, SHOW_SWISH_ON_INVOICE, type InvoiceBranding } from '@/lib/invoices/pdf-template'
 import { buildSwishQrPayload } from '@/lib/payments/swish'
 import { getAmountToPay } from '@/lib/invoices/rounding'
@@ -53,6 +53,11 @@ export interface InvoicePdfRenderExtras {

 export interface InvoicePdfRenderOptions {
  paymentAccountRequired?: boolean
+  /**
+   * The invoice's own frozen payee (invoices.payment_details) when it chose
+   * a bank account. Null/undefined = the company's default for the currency.
+   */
+  payee?: Partial<InvoicePaymentAccount> | null
 }

 // A company's logo is reused across every invoice render, and twice per send
@@ -236,14 +241,14 @@ export async function prepareInvoicePdfRender(
  options: InvoicePdfRenderOptions = {},
 ): Promise<InvoicePdfRenderExtras> {
  if (currency && options.paymentAccountRequired !== false) {
-    assertInvoicePaymentAccountForRender(company, currency)
+    assertInvoicePaymentAccountForRender(company, currency, options.payee ?? null)
  }
  const branding = await prepareInvoiceFont(
    company,
    brandingFromCompanySettings(company),
  )
  const paymentCompany = currency
-    ? companyWithInvoicePaymentAccount(company, currency)
+    ? companyWithInvoicePaymentAccount(company, currency, options.payee ?? null)
    : company
  if (!paymentCompany.logo_url) return { branding, company: paymentCompany }

@@ -5,6 +5,7 @@ import {
  validatePlusgiroNumber,
 } from '@/lib/bankgiro/luhn'
 import { isSaneDateString, normalizeOrgNumber } from '@/lib/invariants'
+import { resolveInvoicePaymentAccount } from '@/lib/invoices/payment-accounts'
 import { computeLineAmounts, hasLineDiscount } from '@/lib/invoices/line-amounts'
 import { getDisplayTotal } from '@/lib/invoices/rounding'
 import { equalOre, roundOre } from '@/lib/money'
@@ -326,16 +327,19 @@ function prepareInvoice(input: PeppolInvoiceInput):
    phone: customer.phone,
  }, false, issues)

+  // Same payee the PDF and the email print: the resolver, not the raw legacy
+  // columns. Peppol is SEK-only (validated above), so resolve for SEK.
+  const payee = resolveInvoicePaymentAccount(company, 'SEK', invoice.payment_details ?? null)
  let payment: PreparedInvoice['payment'] | null = null
-  if (hasText(company.bankgiro) && validateBankgiroNumber(company.bankgiro)) {
+  if (hasText(payee?.bankgiro) && validateBankgiroNumber(payee.bankgiro)) {
    payment = {
-      accountId: company.bankgiro.replace(/\D/g, ''),
+      accountId: payee.bankgiro.replace(/\D/g, ''),
      branchId: 'SE:BANKGIRO',
      paymentId: generateOcrReference(invoice.invoice_number ?? ''),
    }
-  } else if (hasText(company.plusgiro) && validatePlusgiroNumber(company.plusgiro)) {
+  } else if (hasText(payee?.plusgiro) && validatePlusgiroNumber(payee.plusgiro)) {
    payment = {
-      accountId: company.plusgiro.replace(/\D/g, ''),
+      accountId: payee.plusgiro.replace(/\D/g, ''),
      branchId: 'SE:PLUSGIRO',
      paymentId: generateOcrReference(invoice.invoice_number ?? ''),
    }
@@ -53,6 +53,7 @@ import {
 import {
  hasRequiredInvoicePaymentAccount,
 } from '@/lib/invoices/payment-accounts'
+import { snapshotInvoicePayee } from '@/lib/invoices/invoice-payee'
 import { hasRequiredSellerVatNumber } from '@/lib/invoices/seller-vat-number'
 import { createLogger } from '@/lib/logger'
 import type {
@@ -575,6 +576,15 @@ async function sendInvoiceFromSchedule(
  if (!company) {
    throw new Error('company settings missing: cannot send invoice')
  }
+  const payeeSnapshot = await snapshotInvoicePayee(supabase, companyId, invoice)
+  if (!payeeSnapshot.ok) {
+    log.warn('chosen payee account is no longer usable; recurring schedule cannot auto-send', {
+      invoiceId: invoice.id,
+      ...payeeSnapshot.details,
+    })
+    return false
+  }
+  invoice.payment_details = payeeSnapshot.payee
  if (!hasRequiredInvoicePaymentAccount(company, invoice)) {
    log.warn('invoice currency has no usable payment account; recurring schedule cannot auto-send', {
      invoiceId: invoice.id,
@@ -647,6 +657,7 @@ async function sendInvoiceFromSchedule(
  const { branding, company: renderCompany } = await prepareInvoicePdfRender(
    company,
    renderableInvoice.currency,
+    { payee: renderableInvoice.payment_details ?? null },
  )
  const swishQrDataUrl = await buildSwishQrDataUrl(renderCompany, renderableInvoice)
  const paymentLinkQrDataUrl = await buildPaymentLinkQrDataUrl(renderableInvoice)
@@ -129,7 +129,7 @@ export async function sendReminder(
  // with no payment account for the invoice currency would print nothing to
  // pay to, or (before this gate) the SEK account's IBAN on a EUR invoice.
  const currency = invoice.currency
-  if (!hasUsableInvoicePaymentAccount(resolveInvoicePaymentAccount(company, currency), currency)) {
+  if (!hasUsableInvoicePaymentAccount(resolveInvoicePaymentAccount(company, currency, invoice.payment_details ?? null), currency)) {
    log.warn('Skipping reminder: no payment account configured for invoice currency', {
      invoiceId: invoice.id,
      invoiceNumber: invoice.invoice_number,
@@ -306,7 +306,7 @@ export async function processOverdueReminders(): Promise<ProcessRemindersResult>
    const invoiceCurrency = invoice.currency
    if (
      !hasUsableInvoicePaymentAccount(
-        resolveInvoicePaymentAccount(company as CompanySettings, invoiceCurrency),
+        resolveInvoicePaymentAccount(company as CompanySettings, invoiceCurrency, invoice.payment_details ?? null),
        invoiceCurrency,
      )
    ) {
@@ -1,6 +1,13 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { PendingOperation } from '@/types'
 import { createQueuedMockSupabase } from '@/tests/helpers'
+
+// The payee write-through is its own unit (lib/cash-accounts/__tests__/invoice-payee.test.ts);
+// here it must not consume the queued company_settings results.
+vi.mock('@/lib/cash-accounts/invoice-payee', () => ({
+  propagateLegacyPayeeWrite: vi.fn().mockResolvedValue(['SEK']),
+}))
+
 import { commitPendingOperation } from '../commit'

 function makePendingOp(params: Record<string, unknown>): PendingOperation {
@@ -59,6 +59,7 @@ import { buildInvoicePaymentClearingLines } from '@/lib/bookkeeping/invoice-paym
 import { resolveSekAmount } from '@/lib/bookkeeping/currency-utils'
 import { booksInvoicesOnIssue, cashPartialBlockReason, supplierCreditNoteNeedsJournalEntry } from '@/lib/bookkeeping/booking-mode'
 import { ensureManualCashAccount } from '@/lib/cash-accounts/service'
+import { propagateLegacyPayeeWrite } from '@/lib/cash-accounts/invoice-payee'
 import { createJournalEntry, findFiscalPeriod, getSwedishLocalDate, reverseEntry, validateBalance } from '@/lib/bookkeeping/engine'
 import {
  canApproveSupplierInvoice,
@@ -135,6 +136,7 @@ import { linkToJournalEntry } from '@/lib/core/documents/document-service'
 import { renderToBuffer } from '@react-pdf/renderer'
 import { InvoicePDF } from '@/lib/invoices/pdf-template'
 import { prepareInvoicePdfRender, buildSwishQrDataUrl } from '@/lib/invoices/pdf-render-helpers'
+import { resolveInvoicePayeeChoice, resolveInvoiceSettlementAccount, snapshotInvoicePayee } from '@/lib/invoices/invoice-payee'
 import {
  describeMissingInvoicePaymentAccount,
  hasRequiredInvoicePaymentAccount,
@@ -703,7 +705,17 @@ async function commitUpdateCompanySettings(
    throw err
  }

-  const { data, error } = await supabase
+  // The bank columns mirror the default SEK payee account (migration
+  // 20260903150000): write the change through FIRST so a failure leaves
+  // nothing half-written, and the invoice PDF prints what the agent set.
+  try {
+    await propagateLegacyPayeeWrite(supabase, companyId, validated.changes)
+  } catch (err) {
+    log.error('update_company_settings: payee write-through failed', err as Error)
+    return { error: err instanceof Error ? err.message : 'Payee write-through failed', status: 500 }
+  }
+
+  const { data: row, error } = await supabase
    .from('company_settings')
    .update(validated.changes)
    .eq('company_id', companyId)
@@ -717,22 +729,23 @@ async function commitUpdateCompanySettings(
    return { error: error.message, status: 500 }
  }

+
  return {
    data: {
      company_id: companyId,
-      bank_name: data.bank_name ?? null,
-      clearing_number: data.clearing_number ?? null,
-      account_number: data.account_number ?? null,
-      bankgiro: data.bankgiro ?? null,
-      plusgiro: data.plusgiro ?? null,
-      swish: data.swish ?? null,
-      iban: data.iban ?? null,
-      bic: data.bic ?? null,
-      contact_person: data.default_our_reference ?? null,
-      email: data.email ?? null,
-      phone: data.phone ?? null,
-      website: data.website ?? null,
-      invoice_email_texts: data.invoice_email_texts ?? null,
+      bank_name: row.bank_name ?? null,
+      clearing_number: row.clearing_number ?? null,
+      account_number: row.account_number ?? null,
+      bankgiro: row.bankgiro ?? null,
+      plusgiro: row.plusgiro ?? null,
+      swish: row.swish ?? null,
+      iban: row.iban ?? null,
+      bic: row.bic ?? null,
+      contact_person: row.default_our_reference ?? null,
+      email: row.email ?? null,
+      phone: row.phone ?? null,
+      website: row.website ?? null,
+      invoice_email_texts: row.invoice_email_texts ?? null,
    },
  }
 }
@@ -2123,6 +2136,19 @@ async function commitCreateInvoice(
    quoteNumber = allocated as string
  }

+  // Which bank account the customer pays to; validated against the
+  // company's payee accounts (same rule as the web and v1 routes).
+  const payeeChoice = await resolveInvoicePayeeChoice(
+    supabase,
+    companyId,
+    currency as Currency,
+    typeof params.payment_cash_account_id === 'string' ? params.payment_cash_account_id : null,
+  )
+  if (!payeeChoice.ok) {
+    const entry = getErrorEntry(payeeChoice.code)
+    return { error: entry?.message_sv ?? payeeChoice.code, status: 400, data: payeeChoice.details }
+  }
+
  const { data: invoice, error: invoiceError } = await supabase
    .from('invoices')
    .insert({
@@ -2165,6 +2191,8 @@ async function commitCreateInvoice(
      notes: (params.notes as string) || null,
      payment_link_url: paymentLinkUrl,
      default_dimensions: defaultDimensions ?? {},
+      payment_cash_account_id: payeeChoice.fields.payment_cash_account_id,
+      payment_details: payeeChoice.fields.payment_details,
    })
    .select()
    .single()
@@ -2637,14 +2665,19 @@ async function commitMarkInvoicePaid(
  }

  if (isRealInvoice) {
+    // Debit the bank account the invoice asked to be paid to (1930 when none
+    // was chosen): an agent marking a 1931-invoice paid must not land it on 1930.
+    const settlementAccountNumber = await resolveInvoiceSettlementAccount(supabase, companyId, invoice as Invoice)
    if (useCashEntry) {
      const je = await createInvoiceCashEntry(
-        supabase, companyId, userId, invoice as Invoice, paymentDate, entityType, invoice.customer?.name
+        supabase, companyId, userId, invoice as Invoice, paymentDate, entityType, invoice.customer?.name,
+        settlementAccountNumber,
      )
      journalEntryId = je?.id ?? null
    } else {
      const je = await createInvoicePaymentJournalEntry(
-        supabase, companyId, userId, invoice as Invoice, paymentDate, undefined, invoice.customer?.name
+        supabase, companyId, userId, invoice as Invoice, paymentDate, undefined, invoice.customer?.name,
+        undefined, settlementAccountNumber,
      )
      journalEntryId = je?.id ?? null
    }
@@ -2841,6 +2874,15 @@ async function commitSendInvoice(
  if (companyError || !company) return { error: 'Company settings missing', status: 500 }

  const paymentAccountRequired = invoiceRequiresPaymentAccount(invoice as Invoice)
+  // Freeze the chosen bank account's payee at issue (no-op without a choice).
+  const payeeSnapshot = await snapshotInvoicePayee(supabase, companyId, invoice as Invoice)
+  if (!payeeSnapshot.ok) {
+    return {
+      error: getErrorEntry(payeeSnapshot.code)?.message_sv ?? 'Bankkontot på fakturan kan inte längre användas.',
+      status: 400,
+    }
+  }
+  ;(invoice as Invoice).payment_details = payeeSnapshot.payee
  if (!hasRequiredInvoicePaymentAccount(company as CompanySettings, invoice as Invoice)) {
    return {
      error: describeMissingInvoicePaymentAccount((invoice as Invoice).currency).sv,
@@ -2897,7 +2939,7 @@ async function commitSendInvoice(
      const preflight = await prepareInvoicePdfRender(
        company as CompanySettings,
        (invoice as Invoice).currency,
-        { paymentAccountRequired },
+        { paymentAccountRequired, payee: (invoice as Invoice).payment_details ?? null },
      )
      await renderToBuffer(
        InvoicePDF({
@@ -2954,7 +2996,7 @@ async function commitSendInvoice(
  const { branding, company: renderCompany } = await prepareInvoicePdfRender(
    company as CompanySettings,
    renderableInvoice.currency,
-    { paymentAccountRequired },
+    { paymentAccountRequired, payee: (invoice as Invoice).payment_details ?? null },
  )
  const swishQrDataUrl = await buildSwishQrDataUrl(renderCompany, renderableInvoice)
  const pdfBuffer = await renderToBuffer(
@@ -3096,6 +3138,14 @@ async function commitMarkInvoiceSent(

  if (settingsError || !settings) return { error: 'Company settings missing', status: 500 }

+  const payeeSnapshot = await snapshotInvoicePayee(supabase, companyId, invoice as Invoice)
+  if (!payeeSnapshot.ok) {
+    return {
+      error: getErrorEntry(payeeSnapshot.code)?.message_sv ?? 'Bankkontot på fakturan kan inte längre användas.',
+      status: 400,
+    }
+  }
+  ;(invoice as Invoice).payment_details = payeeSnapshot.payee
  if (!hasRequiredInvoicePaymentAccount(settings as CompanySettings, invoice as Invoice)) {
    return {
      error: describeMissingInvoicePaymentAccount((invoice as Invoice).currency).sv,
@@ -213,6 +213,9 @@ export const AUDITED_TABLES = [
  // the per-account override outranks the per-source-type map above, so it is
  // a behandlingsregel in the same sense.
  'cash_accounts',
+  // Which bank account customer invoices pay to, per currency (migration
+  // 20260903150000).
+  'invoice_payee_defaults',
 ] as const

 /**
@@ -236,7 +239,7 @@ export const GLOBAL_ACTIONS = [
 * names statically; a unit test pins it to AUDITED_TABLES / GLOBAL_ACTIONS.
 */
 export const AUDIT_ROW_FILTER =
-  'table_name.in.(journal_entries,chart_of_accounts,company_settings,fiscal_periods,api_keys,dimensions,dimension_values,account_dimension_rules,accrual_schedules,document_attachments,mapping_rules,categorization_templates,booking_template_library,sie_imports,bank_file_imports,cash_accounts),action.in.(SECURITY_EVENT,INTEGRITY_FAILURE,RETENTION_BLOCK,DOCUMENT_DELETE_BLOCKED)'
+  'table_name.in.(journal_entries,chart_of_accounts,company_settings,fiscal_periods,api_keys,dimensions,dimension_values,account_dimension_rules,accrual_schedules,document_attachments,mapping_rules,categorization_templates,booking_template_library,sie_imports,bank_file_imports,cash_accounts,invoice_payee_defaults),action.in.(SECURITY_EVENT,INTEGRITY_FAILURE,RETENTION_BLOCK,DOCUMENT_DELETE_BLOCKED)'

 const SOURCE_TYPE_LABELS: Record<string, string> = {
  manual: 'Manuell',
@@ -422,6 +425,22 @@ const MAPPING_RULE_FIELDS: Record<string, string> = {
 */
 const CASH_ACCOUNT_FIELDS: Record<string, string> = {
  voucher_series: 'Verifikationsserie',
+  // Payee fields (migration 20260903150000): what customer invoices print.
+  bank_name: 'Bank',
+  clearing_number: 'Clearingnummer',
+  account_number: 'Kontonummer',
+  bankgiro: 'Bankgiro',
+  plusgiro: 'Plusgiro',
+  swish: 'Swish',
+  iban: 'IBAN',
+  bic: 'BIC/SWIFT',
+  bank_code: 'Bankkod',
+  foreign_account_number: 'Kontonummer (utländskt)',
+  invoice_payee: 'Visas på kundfakturor',
+}
+
+const INVOICE_PAYEE_DEFAULT_FIELDS: Record<string, string> = {
+  cash_account_id: 'Bankkonto',
 }

 const CATEGORIZATION_TEMPLATE_FIELDS: Record<string, string> = {
@@ -1149,6 +1168,16 @@ export function auditRowToEvent(
        fields: CASH_ACCOUNT_FIELDS,
        objectKeys: ['name', 'ledger_account'],
      })
+    case 'invoice_payee_defaults':
+      return genericAuditEvent(row, {
+        category: 'installningar',
+        codePrefix: 'invoice_payee_default',
+        noun: 'Standardkonto för kundfakturor',
+        fields: INVOICE_PAYEE_DEFAULT_FIELDS,
+        // Both keys on every action: a created or deleted default must name
+        // the account, not just the currency.
+        objectKeys: ['currency', 'cash_account_id'],
+      })
    case 'salary_payroll_config':
      return payrollConfigAuditEvent(row)
    // The import tables emit their own events from the rows themselves; the
@@ -1605,7 +1634,7 @@ async function fetchAuditRows(
      // Literal on purpose (not AUDIT_ROW_FILTER): the schema guard only
      // resolves string literals here. A test pins the two to each other.
      .or(
-        'table_name.in.(journal_entries,chart_of_accounts,company_settings,fiscal_periods,api_keys,dimensions,dimension_values,account_dimension_rules,accrual_schedules,document_attachments,mapping_rules,categorization_templates,booking_template_library,sie_imports,bank_file_imports,cash_accounts),action.in.(SECURITY_EVENT,INTEGRITY_FAILURE,RETENTION_BLOCK,DOCUMENT_DELETE_BLOCKED)',
+        'table_name.in.(journal_entries,chart_of_accounts,company_settings,fiscal_periods,api_keys,dimensions,dimension_values,account_dimension_rules,accrual_schedules,document_attachments,mapping_rules,categorization_templates,booking_template_library,sie_imports,bank_file_imports,cash_accounts,invoice_payee_defaults),action.in.(SECURITY_EVENT,INTEGRITY_FAILURE,RETENTION_BLOCK,DOCUMENT_DELETE_BLOCKED)',
      )
      .order('created_at', { ascending: true })
      .order('id', { ascending: true })
@@ -1079,6 +1079,9 @@ export const MASTER_DATA_DUMP_TABLES: MasterDataTableSpec[] = [
  { name: 'transaction_voucher_links', file: 'transaction_voucher_links.json' },
  { name: 'bank_file_imports', file: 'bank_file_imports.json', orderBy: 'created_at' },
  { name: 'cash_accounts', file: 'cash_accounts.json' },
+  // Which bank account customer invoices pay to, per currency; the payee
+  // fields themselves are columns on cash_accounts one file up.
+  { name: 'invoice_payee_defaults', file: 'invoice_payee_defaults.json' },
  { name: 'mapping_rules', file: 'mapping_rules.json' },
  { name: 'categorization_templates', file: 'categorization_templates.json' },
  { name: 'booking_template_library', file: 'booking_template_library.json' },