diff --git a/.claude/agent-memory/backend-developer/MEMORY.md b/.claude/agent-memory/backend-developer/MEMORY.md
index f20bfabaa..9a980c22a 100644
--- a/.claude/agent-memory/backend-developer/MEMORY.md
+++ b/.claude/agent-memory/backend-developer/MEMORY.md
@@ -193,12 +193,13 @@ Key files added/modified:
 - `server/src/errors/AppError.ts` — added CircularDependencyError (409)
 
 CPM Dependency Math (ADR-014):
-| Type | Forward ES | Backward LF |
-|------|-----------|-------------|
-| FS | PredEF + LL | SucLS - LL |
-| SS | PredES + LL | (SucLS - LL) + predDur |
-| FF | (PredEF + LL) - succDur | SucLF - LL |
-| SF | (PredES + LL) - succDur | (SucLF - LL) + predDur |
+
+| Type | Forward ES              | Backward LF            |
+| ---- | ----------------------- | ---------------------- |
+| FS   | PredEF + LL             | SucLS - LL             |
+| SS   | PredES + LL             | (SucLS - LL) + predDur |
+| FF   | (PredEF + LL) - succDur | SucLF - LL             |
+| SF   | (PredES + LL) - succDur | (SucLF - LL) + predDur |
 
 Engine is a pure function with injectable `today` parameter for testability.
 Cascade mode uses BFS from anchor to collect all downstream successors.
diff --git a/.claude/agent-memory/e2e-test-engineer/MEMORY.md b/.claude/agent-memory/e2e-test-engineer/MEMORY.md
index fa5b9e16c..501de0af1 100644
--- a/.claude/agent-memory/e2e-test-engineer/MEMORY.md
+++ b/.claude/agent-memory/e2e-test-engineer/MEMORY.md
@@ -4,7 +4,7 @@
 
 ## Topic files
 
-- [general-e2e-patterns.md](general-e2e-patterns.md) — cross-cutting waits/timing, viewport timeouts, strict-mode anti-patterns, DataTable migration fallout, Gantt touch, breadcrumbs, print, dashboard cards, key file locations.
+- [general-e2e-patterns.md](general-e2e-patterns.md) — cross-cutting waits/timing, viewport timeouts, strict-mode anti-patterns, DataTable migration fallout, Gantt touch, breadcrumbs, print, dashboard cards, headless-shell PDF-iframe limitation → CSP header+console verification pattern (blob-fetch leg removed, connect-src pitfall), key file locations.
 - [e2e-pom-patterns.md](e2e-pom-patterns.md) — Page Object Model conventions and stable-locator strategies.
 - [e2e-parallel-isolation.md](e2e-parallel-isolation.md) — `testPrefix` fixture, parallel-safe data isolation, serial-mode tests.
 - [known-flakes-and-regressions.md](known-flakes-and-regressions.md) — triaged log of flaky tests, pre-existing CI failures, and production regressions caught by E2E. **Check this before re-triaging a failure.**
@@ -23,8 +23,11 @@
 - [story-1876-deposit-refunds.md](story-1876-deposit-refunds.md) — deposit `entryType` refunds; DataTable hidden-column read pattern (`getColumnCellText`), table+card dual-DOM visible-filter pitfall.
 - [story-1877-contact-fields-attachment-typing.md](story-1877-contact-fields-attachment-typing.md) — budget-source contact fields, household settings singleton (needs `mode:'serial'`, not just try/finally), document-link attachment typing; route-mock last-registered-runs-first ordering hazard; sandbox lint/tsc caveats.
 - [story-1879-report-wizard.md](story-1879-report-wizard.md) — Bank Report Wizard POM/spec; Blocker bug #1886 (budgetSources envelope crash blocks all progress past step 1) + compile errors/missing i18n keys found via `tsc`; source-report E2E seeding pattern (WI budget → invoice-budget-line link).
+- [story-1891-wizard-followup.md](story-1891-wizard-followup.md) — expandable invoice rows, CSP `blob:` frame-src hardened preview check (SUPERSEDED TWICE — `page.frames()` proof, then in-page blob fetch → now header+console-only, see general-e2e-patterns.md), deposit budget-source tagging; 2 filed bugs (#1892 full-exclusion display, #1893 missing deposit-default heuristic); sandbox CAN now build+boot the full container stack (see `sandbox-live-verification.md`) but browser binary download is still network-policy-blocked.
+- [sandbox-live-verification.md](sandbox-live-verification.md) — **dhi.io build access is sandbox-dependent, re-check each session**: this session successfully built `cornerstone:e2e` and booted the full container stack (app+OIDC+proxy all healthy), a first — but Playwright's own browser binary download (`playwright.download.prss.microsoft.com`/`cdn.playwright.dev`) is blocked by network policy, and Ubuntu's `chromium-browser` apt package is a non-functional snap stub (no snapd) — no way found yet to get an actual live browser run in this sandbox class.
 
 ## Open follow-ups to flag to orchestrator
 
 - No Paperless-ngx testcontainer exists yet (story-epic08-e2e.md) — all Paperless E2E coverage is `page.route()` mocked, not real integration. Add the container when Paperless work resumes.
-- Full containerized E2E verification is not possible in sandboxes without `dhi.io` (Docker Hardened Images) registry credentials — building `cornerstone:e2e` fails with `401 Unauthorized`. This is an environment limitation, not a code issue; verification in such sandboxes must fall back to static checks (lint/prettier/tsc-diff/`playwright --list`) plus post-merge CI observation.
+- **Filed bugs from Story #1891, unresolved**: #1892 (fully-excluding all budget lines on an invoice removes it from the report wizard's step-3 list instead of showing €0.00 — display-only, PDF/claim unaffected) and #1893 (deposit budget-source auto-default 0/1/>1-source heuristic is entirely unimplemented — `InvoiceDepositsSection.tsx` never receives the invoice's budget lines).
+- Containerized E2E verification capability varies by sandbox instance — **do not assume the old "no dhi.io creds" note still applies**; re-attempt `docker build -t cornerstone:e2e .` each session before falling back to static-only verification. See `sandbox-live-verification.md` for the current state and the remaining browser-binary blocker.
diff --git a/.claude/agent-memory/e2e-test-engineer/general-e2e-patterns.md b/.claude/agent-memory/e2e-test-engineer/general-e2e-patterns.md
index 227c2e146..1da173d16 100644
--- a/.claude/agent-memory/e2e-test-engineer/general-e2e-patterns.md
+++ b/.claude/agent-memory/e2e-test-engineer/general-e2e-patterns.md
@@ -18,6 +18,7 @@ metadata:
 - After `fill(query)` in a search box, add `page.waitForURL(url => url.searchParams.get('q') === query)` BEFORE `waitForResponse` — confirms the debounce fired and React committed state. Don't call `waitForLoaded()` after the response for search — it can resolve on stale DOM from a WebKit clear-event race; let the assertion's own retry converge.
 - Dashboard reload: register `waitForResponse('/api/users/me/preferences')` BEFORE reload, but prefer `page.waitForLoadState('networkidle')` AFTER the heading is visible for "dismissed card stays hidden" — LocaleContext's GET resolves first and `usePreferences`'s second GET (which applies hiddenCards) arrives later.
 - Count assertions with parallel workers sharing one DB are fragile — use `>=` / `not.toContain(name)` instead of exact equality.
+- **One-shot `page.frames().find(...)` (or any raw one-shot read of live browsing-context state) right after a "done" signal (overlay hidden, attribute set) is a race, not a proof.** `frame.url()` only reflects a navigation that has already completed — there's a real gap between the DOM signaling "done" and the nested browsing context actually finishing navigation. Wrap it in `await expect(async () => {...}).toPass({timeout: N})`, re-deriving the expected value on every retry (don't capture it once before the poll — a value that can legitimately change mid-wait, e.g. a regenerated blob URL, needs re-reading each attempt). Found via CI PR #1894 (`ReportWizardPage.assertFrameActuallyNavigated`) — see story-1891-wizard-followup.md for the full writeup and the "zero console messages alongside the failure" diagnostic that proved it was a timing race, not the CSP guard it was built to detect.
 
 ## Viewport timeouts (Playwright projects)
 
@@ -94,6 +95,63 @@ After `setLanguage(page,'de')` + `page.goto()`, always `page.reload()` before as
 
 AreaPicker has two DOM states: unselected (input visible, `placeholder="Select an area"`) vs selected (`[class*="selectedDisplay"]` visible, input gone). After selection, URL gets `?areaId=<id>`; clearing removes it. Use `waitForResponse` BEFORE selection.
 
+## Headless Chromium shell has no PDF viewer plugin — `<iframe>`-to-`blob:`-PDF navigation is unverifiable via `page.frames()` (Story #1891 TEST_ENVIRONMENT fix, 2026-07-29)
+
+CI run 30530648400 (shard 2) proved that `page.frames().find(f => f.url() === blobSrc)` — even
+wrapped in a 10s `expect(...).toPass()` poll (see `story-1891-wizard-followup.md`'s earlier
+"one-shot race" fix) — **never** matches when the target is a PDF `blob:` URL, and **zero**
+CSP-violation console messages fire either. Root cause: Playwright's bundled headless Chromium
+shell has no built-in PDF viewer plugin. An `<iframe src="blob:...">` pointed at a PDF silently
+aborts/blanks (stays effectively at `about:blank`) **without any CSP violation being logged** —
+this happens identically whether or not the CSP `frame-src` directive actually permits `blob:`.
+So the "prove a frame navigated to the blob src" technique cannot distinguish a correctly
+configured CSP from a broken one in this CI environment, regardless of how it's polled — it's
+not a timing bug, it's a structural gap in the headless shell's rendering capability for PDFs.
+**General lesson: don't use `page.frames()`/iframe-navigation matching to prove anything about
+an `<iframe>` whose target content type the headless Chromium shell can't natively render (PDF
+is the known case; likely also true for other browser-plugin-dependent content).**
+
+**Replacement pattern — verify the CSP contract server-side, not the browser's enforcement of it:**
+1. **Direct CSP header assertion** (the deterministic core): `page.request.get(route)` (shares
+   the page's cookie jar/session automatically) then read
+   `response.headers()['content-security-policy']`, regex out the specific directive
+   (`frame-src`, `script-src`, whatever's relevant), and assert the required source token is
+   present. This is a server-side contract check — it fails/passes by construction based on the
+   actual `helmetPlugin.ts` config, completely independent of what any given browser does when
+   asked to render the content. This is the primary, CI-reliable regression guard now.
+2. Keep a zero-CSP-console-violation assertion as defense in depth — real (non-headless-shell)
+   browsers still log synchronously on a block, so this remains a meaningful second signal even
+   though it can't be the *only* signal in CI.
+3. Do NOT try to fetch the iframe's `blob:` src from within the page as a third signal — see the
+   "blob: fetch is connect-src-governed, not frame-src" entry immediately below for why that's a
+   dead end, not just an unnecessary extra.
+
+See `ReportWizardPage.ts`'s `assertPreviewHardened`/`fetchCspFrameSrcDirective` for the reference
+implementation, and `story-1891-wizard-followup.md` for the full before/after narrative (this
+superseded that story's own earlier `page.frames()`-polling fix, which turned out to just be
+racing an unwinnable race).
+
+## blob: fetch is connect-src-governed, not frame-src — don't add an in-page `fetch(blobSrc)` as a "prove the blob is genuine" check (Story #1891 second TEST_ENVIRONMENT fix, 2026-07-30)
+
+An earlier revision of the pattern above (item 3, since removed) tried to compensate for the
+headless shell's inability to render PDF iframes by having the PAGE itself `fetch()` the blob:
+URL from `page.evaluate` and inspect the resulting `Blob`'s `size`/`type`. This looked reasonable
+but is a dead end: `fetch()`/`XHR` to a URL — including a `blob:` URL — is governed by the page's
+`connect-src` CSP directive, not `frame-src`. Cornerstone's `connect-src` is (correctly)
+`'self'` only, with no `blob:` token, because the application itself never fetches its own
+preview blob — the browser resolves `<iframe src="blob:...">` internally without going through
+`fetch`/`XHR` at all. So the in-page fetch was blocked by the exact CSP it was trying to
+characterize, and CI (run 30531695763, shard 2) showed every wizard scenario failing in ~2s with
+`page.evaluate: TypeError: Failed to fetch`. **Do not loosen `connect-src` to accommodate this
+test technique** — it would weaken production CSP for no product reason, since the app has no
+legitimate need to fetch blob: URLs itself. The fix was simply to delete the blob-fetch check
+(`fetchPreviewBlobInfo` in `ReportWizardPage.ts`) and rely on the two signals above (CSP header +
+zero console violations) plus the plain "src attribute starts with `blob:`" check callers already
+did. **General lesson: when a CSP directive blocks something, don't assume any other in-page
+technique that touches network/fetch is a safe workaround — check which specific directive
+(`connect-src` vs `frame-src` vs `script-src`, etc.) governs the technique you're about to add,
+since they're independently configured and a fix for one doesn't imply permission under another.**
+
 ## Key file locations
 
 - Test fixtures: `e2e/fixtures/auth.ts` (testPrefix, authenticatedPage)
diff --git a/.claude/agent-memory/e2e-test-engineer/sandbox-live-verification.md b/.claude/agent-memory/e2e-test-engineer/sandbox-live-verification.md
new file mode 100644
index 000000000..8beaabc4c
--- /dev/null
+++ b/.claude/agent-memory/e2e-test-engineer/sandbox-live-verification.md
@@ -0,0 +1,123 @@
+---
+name: sandbox-live-verification
+description: What live/containerized E2E verification is actually possible from inside a sandbox session — re-check every session, this has changed at least once.
+metadata:
+  type: project
+---
+
+## Status as of Story #1891 (2026-07-30 session)
+
+Prior memory (and several earlier story files) documented that sandboxes cannot build
+`cornerstone:e2e` because `dhi.io` (Docker Hardened Images) registry credentials aren't
+available — every earlier attempt failed with `401 Unauthorized` on `docker pull
+dhi.io/node:...`. **That was true in those sessions but is not a fixed property of "the
+sandbox" in general** — in this session:
+
+```bash
+docker pull dhi.io/node:24-alpine3.23-dev   # succeeded, no auth prompt
+docker build -t cornerstone:e2e --build-arg APP_VERSION=pr-1891-verify .   # succeeded, ~2 min
+```
+
+The full app image built cleanly, and running `npx playwright test <spec> --project=desktop`
+against it actually spun up the whole stack via `e2e/containers/setup.ts`:
+
+```
+🐳 Starting E2E test containers...
+✅ Created Docker network: ...
+🔐 Starting OIDC server...
+✅ OIDC server ready at http://localhost:.../default
+🏗️  Starting Cornerstone application and reverse proxy...
+✅ Cornerstone app ready at http://localhost:...
+✅ Reverse proxy ready at http://localhost:...
+✅ All containers ready for E2E testing
+```
+
+i.e. `mock-oauth2-server`, the built `cornerstone:e2e` app container, and the `nginx:alpine`
+reverse proxy all pulled/started/health-checked correctly. **This is a first** — no prior
+story session got this far.
+
+**Action for future sessions**: always attempt `docker pull dhi.io/node:24-alpine3.23-dev`
+(or just `docker build -t cornerstone:e2e .`) early, in the background, rather than assuming
+it will fail from stale memory. If it succeeds, a genuine live CI-equivalent run becomes
+possible for the AC verification steps that ask for one (e.g. a MANDATORY red/green proof).
+
+## The remaining blocker: no usable browser binary
+
+Even with the container stack fully working, `npx playwright test` still fails at the
+`auth-setup` project because no Chromium binary is available:
+
+1. **Playwright's own download is network-policy-blocked.** `npx playwright install chromium`
+   (with or without `--with-deps`) tries `playwright.download.prss.microsoft.com`,
+   `cdn.playwright.dev`, and one more mirror, in that order — all three returned HTTP 403
+   `Blocked by network policy: ... no matching allow rule — blocked by default deny policy`.
+   This is a `sbx policy allow network <domain>` decision for the user/host, not something to
+   work around unilaterally.
+2. **Ubuntu's `chromium-browser` apt package is a non-functional snap stub.** `apt-get install
+   chromium-browser` succeeds and installs `/usr/bin/chromium-browser`, but running it (even
+   pointed to via a local `playwright.config.ts` override's `use.launchOptions.executablePath`)
+   fails immediately:
+   ```
+   Command '/usr/bin/chromium-browser' requires the chromium snap to be installed.
+   Please install it with: snap install chromium
+   ```
+   `snap install chromium` in turn fails because `snapd` isn't running in this sandbox
+   (`dial unix /run/snapd.socket: connect: no such file or directory`), and there is no `apt`
+   package named plain `chromium` (only the snap-transitional `chromium-browser` stub) on this
+   Ubuntu release. No other route to a real browser binary was found in this session
+   (no cached `~/.cache/ms-playwright` binaries, no `google-chrome`/`firefox` either).
+
+**Net effect**: a fully live Playwright *browser* run is still not achievable in this sandbox
+class, even though the *container/app* side now works. If a future story's AC needs an actual
+red/green browser proof, either (a) ask the user to `sbx policy allow network
+playwright.download.prss.microsoft.com,cdn.playwright.dev` for that session, or (b) fall back
+to the established pattern: build+boot the containers to prove the app-level behavior (e.g. the
+CSP header itself, via a raw `curl`/`page.request` HTTP check that doesn't need a browser),
+plus code-reasoning for the browser-rendering part, and document the CI expectation explicitly
+— this is what Story #1891's CSP-hardening verification did.
+
+## Practical technique: overriding the browser executable without touching committed config
+
+If a real Chromium binary ever IS available (e.g. `sbx policy allow` was granted, or a cached
+binary exists), don't edit `e2e/playwright.config.ts` — create a scratch, **never-committed**
+sibling config that imports and extends it, point `use.launchOptions.executablePath` at the
+real binary for BOTH the `auth-setup` and `desktop` projects (auth-setup has its own separate
+`use` block — overriding only `desktop` leaves `auth-setup` still trying to launch the missing
+bundled headless-shell binary), run with `--config=<scratch file>`, then delete it before
+finishing. Example that worked mechanically (blocked only by the missing real binary, see
+above):
+
+```ts
+// e2e/playwright.local-verify.config.ts — SCRATCH ONLY, delete before finishing
+import { defineConfig } from '@playwright/test';
+import base from './playwright.config.js';
+
+const CHROME_OVERRIDE = { executablePath: '/path/to/chromium', args: ['--no-sandbox'] };
+
+export default defineConfig(base, {
+  projects: (base.projects || [])
+    .filter((p) => p.name === 'auth-setup' || p.name === 'desktop')
+    .map((p) => ({
+      ...p,
+      use: { ...p.use, launchOptions: { ...(p.use?.launchOptions || {}), ...CHROME_OVERRIDE } },
+    })),
+});
+```
+
+Must live inside `e2e/` (not `/tmp`) so the relative `@playwright/test` / `./playwright.config.js`
+module resolution works — a file outside the workspace fails with `Cannot find module
+'@playwright/test'` even though the import looks correct.
+
+## Cleanup checklist after any live-verification attempt
+
+- `rm` any scratch `playwright.*.config.ts` file.
+- `rm -rf e2e/e2e/ e2e/playwright-output/ e2e/playwright-report/ e2e/test-results/` — a
+  misconfigured `--config` path or an interrupted run can leave a nested `e2e/e2e/test-results/
+  .state/containers.json` artifact (from `containers/setup.ts`'s state file) that `git status`
+  won't flag as tracked but that still clutters the worktree.
+- `docker images` / `docker rmi cornerstone:e2e` if you built a throwaway/deliberately-broken
+  image for a red-test proof — a stale local image with the wrong config baked in will silently
+  get reused by the next `docker build`'s layer cache or by a teammate's next test run in the
+  same sandbox if left in place.
+- Confirm `docker ps -a` and `docker network ls` have no leftover test containers/networks —
+  the suite's own `globalTeardown` (`e2e/containers/teardown.ts`) handles this on a normal run,
+  but verify after any run that errored before reaching teardown.
diff --git a/.claude/agent-memory/e2e-test-engineer/story-1891-wizard-followup.md b/.claude/agent-memory/e2e-test-engineer/story-1891-wizard-followup.md
new file mode 100644
index 000000000..b86ae70a9
--- /dev/null
+++ b/.claude/agent-memory/e2e-test-engineer/story-1891-wizard-followup.md
@@ -0,0 +1,245 @@
+---
+name: story-1891-wizard-followup
+description: Bank Report Wizard follow-up (Story #1891) — expandable invoice rows, CSP blob: frame-src hardened preview check (superseded TWICE — page.frames() then in-page blob fetch — now header+console-only per two TEST_ENVIRONMENT fixes, see general-e2e-patterns.md), deposit budget-source tagging; 2 filed production bugs.
+metadata:
+  type: project
+---
+
+## SUPERSEDED AGAIN 2026-07-30: the in-page `fetch(blobSrc)` leg was removed
+
+The "header+blob based" design described in the section below (added 2026-07-29) was itself
+short-lived. CI run 30531695763 (shard 2) showed every wizard scenario failing in ~2s with
+`page.evaluate: TypeError: Failed to fetch` — the new `fetchPreviewBlobInfo()` in-page
+`fetch(blobSrc)` is blocked by the app's own CSP `connect-src 'self'` (no `blob:` token, and
+correctly so: the app itself never fetches its own preview blob — the browser resolves
+`<iframe src="blob:...">` internally, not via `fetch`/`XHR`). Loosening `connect-src` to
+accommodate this test technique would weaken production CSP for no product reason, so the fix
+was to remove `fetchPreviewBlobInfo()` and the blob-fetch leg from `assertPreviewHardened`
+entirely, not to touch the CSP config.
+
+**Current (and hopefully final) design**: `assertPreviewHardened()` now checks exactly two
+signals — (1) the CSP header's `frame-src` directive contains both `'self'` and `blob:`
+(`fetchCspFrameSrcDirective()`, the deterministic server-side contract check) and (2) zero
+CSP-violation console messages were captured. The plain "overlay hidden + iframe visible + src
+is a `blob:` URL" check that callers already did before invoking `assertPreviewHardened` was
+kept as-is (it never depended on the blob-fetch). See `general-e2e-patterns.md`'s "blob: fetch
+is connect-src-governed, not frame-src" entry for the reusable lesson — **do not re-add an
+in-page fetch of a blob: URL as a verification technique; it will always be CSP-blocked by
+design.**
+
+## SUPERSEDED (2026-07-29): the `page.frames()` frame-navigation proof
+
+Everything under "CSP hardened-check design" and its "Follow-up fix" subsection below describes
+the ORIGINAL implementation, which is now **historical** — CI proved the whole
+`page.frames().find(...)` technique (one-shot AND polled) is structurally unverifiable in this
+project's headless Chromium shell for PDF `blob:` iframes (no PDF viewer plugin → silent
+about:blank stall, zero CSP console violations, either way). `ReportWizardPage.ts` was reworked
+to prove the same AC via `fetchCspFrameSrcDirective()` (direct CSP response-header assertion —
+the deterministic primary signal) plus the same zero-CSP-violation-message check. (An
+intermediate version also added an in-page `fetchPreviewBlobInfo()` blob-content check — see the
+"SUPERSEDED AGAIN" section above for why that was removed too.) See `general-e2e-patterns.md`'s
+"Headless Chromium shell has no PDF viewer plugin" section for the full pattern write-up (this is
+a reusable lesson, not specific to this story) — keeping the narrative below for historical
+context on why the polling fix was tried first and why it still wasn't enough.
+
+## Files
+
+- `e2e/tests/budget/reportWizardExpansion.spec.ts` — new, 7 scenarios (CSP headline, chip
+  width, line-exclusion → row/total/PDF, full-exclusion, deposit tagged to zero-line source,
+  claim warning count, regression sweep of `reportWizard.spec.ts` selectors against the new
+  grid).
+- `e2e/pages/ReportWizardPage.ts` — extended: `invoiceExpandToggle`, `expansionPanel`,
+  `itemsSubTable`/`depositsSubTable` (structural `.nth(0)`/`.nth(1)`, NOT text-based — both
+  sub-tables always render in this DOM order whether populated or `EmptyState`),
+  `itemRow`/`itemExclusionCheckbox`/`depositRow`, `invoiceRowAmount` (class filter trick below),
+  `markClaimedWarningBlock`. Hardened `waitForPreviewReady`/`waitForPreviewRegenerated` per the
+  story AC — see "CSP hardened-check design" below.
+- `e2e/pages/InvoiceDetailPage.ts` — added `depositBudgetSourceSelect` (`#deposit-budgetSource`)
+  and `depositBudgetSourceHint`.
+
+## `invoiceRowAmount` locator trick
+
+`ReportInvoiceList.tsx`'s amount cell has THREE classes containing the substring "amount":
+`.amountColumn` (outer wrapper), `.amount` (the value itself), `.amountNegative` (refund
+modifier, combined with `.amount` on the same element). To land on just the value element:
+
+```ts
+invoiceRow(...).locator('[class*="amount"]:not([class*="Column"])').first()
+```
+
+`:not([class*="Column"])` excludes only the wrapper (its class contains "Column", capital C);
+both `.amount` and `.amount.amountNegative` still match `[class*="amount"]` and pass the
+`:not()`. This general pattern (grep for which OTHER classes in the same component share a
+target substring before trusting a bare `[class*="X"]` locator) is worth checking any time a
+new locator is added against `ReportInvoiceList.module.css` or similarly-named sibling classes
+elsewhere.
+
+## Expansion panel is a DOM SIBLING, not a descendant
+
+`ReportInvoiceList.tsx` renders `<div key={invoiceId}><div class="invoiceRow">...</div>
+{isExpanded && <div class="expansionPanel" id="invoice-expand-{id}">...</div>}</div>` — the
+panel is a sibling of the row, both children of the same per-invoice wrapper. Reach it with a
+relative xpath from the row locator:
+
+```ts
+invoiceRow(...).locator('xpath=following-sibling::*[contains(@class,"expansionPanel")]')
+```
+
+## CSP hardened-check design (the story's headline AC)
+
+The bug this hardens against: React sets `<iframe src="blob:...">` in the DOM regardless of
+whether the browser actually allowed the navigation — if `helmetPlugin.ts`'s CSP `frameSrc`
+directive doesn't include `blob:`, Chromium silently blocks the frame-src navigation and the
+iframe's browsing context stays at `about:blank` forever, while the DOM `src` attribute still
+reads as the (never-navigated) blob URL. A locator-only check (`getAttribute('src')` starts
+with `blob:`) therefore CANNOT tell working from broken.
+
+The fix: `page.frames().find(f => f.url() === src)` — `frame.url()` reflects the REAL navigated
+URL of a browsing context, not a DOM attribute. If CSP blocked the navigation, no frame in
+`page.frames()` will ever have `url() === src` (the iframe's frame stays at `about:blank`).
+Combined defense-in-depth: a `page.on('console', ...)` listener registered in the POM
+**constructor** (before any `goto()`, so an early violation is never missed — same convention as
+`invoice-auto-itemize-page.spec.ts` Scenario 18's "Refused to frame" capture) collecting any
+`'error'`-type message matching `/content security policy/i`; the hardened check also asserts
+zero such messages were captured.
+
+Both `waitForPreviewReady()` and `waitForPreviewRegenerated()` run this check internally now;
+Scenario 1 additionally re-asserts it explicitly at the test level (not just trusting the POM
+helper) per the story AC's literal wording.
+
+### Follow-up fix: one-shot `page.frames().find()` is a race, not a proof (CI PR #1894, shard 2)
+
+The FIRST shipped version of `assertFrameActuallyNavigated(src: string)` did a single, immediate
+`page.frames().find(f => f.url() === src)` right after the loading overlay hid / the src
+attribute was read. This is a **reusable anti-pattern**: `frame.url()` only reflects a navigation
+that has _already completed_ — there is a real gap between "the loading overlay hides" / "the src
+attribute changed" and "the nested browsing context has actually finished navigating to it".
+Reading `page.frames()` exactly once right after either signal races that navigation. CI caught
+this: 3 scenarios across `reportWizard.spec.ts`/`reportWizardExpansion.spec.ts` failed
+consistently at ~2.6-3.2s with "no browsing-context frame has actually navigated" — but ZERO
+CSP-violation console messages were ever captured in those failures, which is the tell: if CSP
+were actually blocking the frame-src navigation, the console listener (registered in the
+constructor) would have fired synchronously with the block. Zero console messages + a
+`page.frames()` miss = the navigation just hadn't finished yet, not "blocked".
+
+**Fix**: turned `assertFrameActuallyNavigated` into a poller — it now takes a `getExpectedSrc: ()
+=> Promise<string>` callback (not a static `src` string) and wraps the frame lookup in `await
+expect(async () => {...}).toPass({ timeout: 10_000 })`, re-invoking the callback on every retry.
+Re-reading src on every retry (not capturing it once before the poll) also matters for
+`waitForPreviewRegenerated` specifically — a fast-arriving further regeneration mid-poll would
+otherwise get asserted against a now-stale captured src. Both `waitForPreviewReady` and
+`waitForPreviewRegenerated` now share this single polling helper; the CSP-violation-count check
+still runs once, after the poll resolves, preserving the "either signal alone would catch a
+regression" defense-in-depth property.
+
+**General lesson**: any `page.frames().find(...)` (or similarly, a raw one-shot check against
+live browsing-context state that isn't itself an auto-retrying Playwright locator/`expect`) taken
+immediately after a UI-visible "done" signal (overlay hidden, attribute set) is a latent race —
+wrap it in `expect(async () => {...}).toPass()` rather than trusting the single read, even when
+the surrounding steps already used proper waits.
+
+## MANDATORY red-test verification — what was actually done
+
+The AC required manually reverting `helmetPlugin.ts`'s `frameSrc` to `["'self'"]` (no `blob:`)
+and confirming the hardened check goes red before restoring the file. What happened:
+
+1. Found `helmetPlugin.ts`'s `frameSrc: ["'self'", 'blob:']` was itself an **uncommitted**
+   working-tree change (part of this story's in-progress backend work, not yet committed) —
+   `git diff` (no ref = working tree vs index) showed the `blob:` addition as unstaged.
+   Reverting it to `["'self'"]` therefore made `git diff HEAD` show NO diff (working tree now
+   matched HEAD, which never had the fix) — a useful sanity check that the revert really
+   targeted the intended line, but a trap if you assume "no diff vs HEAD" means "back to where
+   I started": the correct restore target was the ORIGINAL WORKING TREE state (with `blob:`),
+   not HEAD.
+2. Attempted a REAL browser run against the reverted config. Unexpectedly, this sandbox
+   session had `dhi.io` registry access (see `sandbox-live-verification.md` — first time this
+   worked in any recorded session) — `docker build -t cornerstone:e2e .` succeeded and the full
+   container stack (OIDC + app + proxy) booted and passed health checks with the BROKEN CSP
+   config live and serving traffic. The only remaining blocker was Playwright's browser binary
+   download being network-policy-blocked, and Ubuntu's `chromium-browser` apt package being a
+   non-functional snap stub with no snapd running — full detail in
+   `sandbox-live-verification.md`. No actual Playwright-driven browser assertion could be
+   executed.
+3. Given (2), fell back to the explicitly pre-authorized alternative: **code-reasoning +
+   documented CI expectation**, reasoned through in detail:
+   - Chromium's CSP enforcement for `frame-src` blocks the nested browsing context's
+     navigation and logs a console error of the form `Refused to frame 'blob:...' because it
+violates the following Content Security Policy directive: "frame-src 'self'".` — this is
+     standard, spec-defined CSP behavior (Content-Security-Policy Level 3 §6.4, "navigate-to"
+     analog for frame-src), not app-specific behavior that could vary.
+   - With `frameSrc: ["'self'"]` (no `blob:`), the preview iframe's blocked navigation leaves
+     its frame at `about:blank`, so `page.frames().find(f => f.url() === src)` returns
+     `undefined` — the hardened check's first assertion throws.
+   - The console listener registered in the constructor (before `goto()`) would also have
+     captured the "Refused to frame... Content Security Policy..." message — the second
+     assertion (`cspViolationMessages.length > 0`) would independently also throw.
+   - Both failure paths are asserted in the SAME hardened check (`assertFrameActuallyNavigated`)
+     — either one alone is sufficient proof the pre-fix config genuinely breaks the test; having
+     both is deliberate defense-in-depth (documented in the method's own docstring) so a future
+     Chromium wording change to the console message doesn't silently disable the guard.
+4. Restored `helmetPlugin.ts` to its exact prior working-tree state (`frameSrc: ["'self'",
+'blob:']`) and confirmed via `git diff` matching the diff observed at the start of the
+   session, byte-for-byte.
+5. Cleaned up all verification-run side effects: removed the throwaway `cornerstone:e2e` Docker
+   image (built against the deliberately-broken config — must not be silently reused by a later
+   `docker build` layer cache or another session), the scratch
+   `e2e/playwright.local-verify.config.ts`, and stray runtime artifacts
+   (`e2e/e2e/test-results/`, `e2e/playwright-output/`, `e2e/playwright-report/`,
+   `e2e/test-results/`) left behind by the interrupted runs. Confirmed `docker ps -a` /
+   `docker network ls` had no leftover containers/networks.
+
+**CI expectation**: on the actual PR, CI's `E2E Tests` job builds `cornerstone:e2e` with the
+FIXED `helmetPlugin.ts` (via the normal DHI-authenticated `docker/build-push-action` step) and
+runs the full matrix with a real Chromium — Scenario 1 (and every other scenario that reaches
+Step 4) will exercise the hardened check for real there. If a future regression reintroduces
+`frameSrc: ["'self'"]` (drops `blob:`), Scenario 1 is expected to fail with exactly the
+`assertFrameActuallyNavigated` error thrown from the missing-frame branch (see method docstring
+in `ReportWizardPage.ts`).
+
+## Two production bugs found and filed (not fixed — out of E2E scope)
+
+- **#1892 (Major)** — `applyLineExclusions()` correctly clamps a fully-line-excluded invoice's
+  `allocatedAmount` to exactly `0` (never negative), but `ReportInvoiceList.tsx`'s
+  `allocatedInvoices` filter (`inv.allocatedAmount > 0 || inv.lineKind === 'refund-adjustment'`)
+  then drops that invoice from the visible Step-3 list entirely instead of rendering it at
+  €0.00 — a net-zero non-refund invoice satisfies neither condition. Removes the only UI path
+  back to un-excluding those lines (the row's own expand toggle disappears with the row). PDF
+  export and claim submission are unaffected (both use `excludedInvoiceIds` against the
+  original unfiltered `report`, not the filtered display list) — display-only regression.
+  Scenario 4 in the new spec asserts the spec-conformant behavior (row visible, €0.00, TriState
+  unchecked) and is EXPECTED TO FAIL in CI until fixed, per the project's test-failure-debugging
+  protocol.
+- **#1893 (Major)** — the deposit budget-source auto-default heuristic (Frontend Spec item 9:
+  0 sources → null/HintNone, 1 source → that source/HintSingle, >1 sources → largest-sum
+  source/HintLargest) is entirely unimplemented. `InvoiceDepositsSectionProps` never receives
+  the invoice's budget lines at all (structurally impossible to compute the default),
+  `openAddModal()` always resets to `budgetSourceId: null`, and the hint JSX only ever branches
+  None-vs-Single (the `budgetSourceHintLargest` i18n key exists but is dead code, confirmed via
+  grep — never referenced from any `.tsx`/`.ts`). The MANUAL path (user picks a source
+  themselves via the select) works correctly and round-trips through the API — Scenario 5 in
+  the new spec only exercises the manual path (tag via API + assert it surfaces correctly in
+  the report), so it does NOT depend on this bug and is expected to pass. Filed separately since
+  it's a real AC gap orthogonal to the E2E spec's own scope.
+
+## Seeding pattern additions
+
+- `seedInvoiceWithTwoLines()` (local helper, mirrors `seedAllocatedInvoice`'s established
+  pattern) — creates an invoice with TWO separate `work_item_budgets` rows (two different work
+  items) each linked via its own `invoiceBudgetLine`, so `budgetLines[]` in the report has two
+  distinguishable rows. `description` must be set on the `work_item_budget` (via
+  `createWorkItemBudgetViaApi`'s `description` param) — the report's `line_description` comes
+  from `COALESCE(wib.description, hib.description)`, NOT from the invoice-budget-line's own
+  `description` column (that field exists in the schema but isn't what the report reads).
+- Deposit→source tagging: `POST /api/invoices/:id/deposits` accepts `budgetSourceId: string |
+null` directly in the body (added this story) — no separate endpoint. A deposit tagged to a
+  source with ZERO budget lines for that invoice still surfaces the invoice in that source's
+  report via Rail B (`sumTaggedDepositContributionsByInvoice`), with `budgetLines: []` for that
+  invoice specifically (scoped to the report's own source, not the invoice's other sources).
+
+## Regression-sweep gotcha: `SelectionActionBar`'s "Reset selection" semantics
+
+`clearSelectionButton` (POM, text "Reset selection") calls `onToggleAll(false)`, which CLEARS
+`excludedInvoiceIds` (selects everything) — it is NOT a "deselect all" button despite what
+"Clear selection" might suggest from the name alone. `onToggleAll(true)` (exclude all) is only
+reachable via the select-all checkbox when everything is currently selected. Don't assume the
+button excludes; verify against the actual `onClear` wiring before asserting a post-click count.
diff --git a/.claude/agent-memory/product-architect/MEMORY.md b/.claude/agent-memory/product-architect/MEMORY.md
index 2f80cc707..d05d99e3e 100644
--- a/.claude/agent-memory/product-architect/MEMORY.md
+++ b/.claude/agent-memory/product-architect/MEMORY.md
@@ -1,168 +1,76 @@
 # Product Architect Memory
 
-## Tech Stack (Accepted)
-
-- Server: Fastify 5.x (ADR-001), Client: React 19 + React Router 7 (ADR-002)
-- DB: SQLite via better-sqlite3 + Drizzle ORM (ADR-003), Bundler: Webpack 5.x (ADR-004)
-- Tests: Jest 30.x + Playwright (ADR-005), Styling: CSS Modules (ADR-006)
-- Structure: npm workspaces monorepo (ADR-007), TypeScript ~5.9, Node.js 24 LTS
-
-## Project Layout
-
-- `shared/` -> `client/` -> `server/` (build order)
-- All plugins use `fastify-plugin` (fp), registration: config -> errorHandler -> compress -> cookie -> db -> auth -> routes -> static
-
-## Key Patterns
-
-- All API endpoints under `/api/` prefix, error shape: `{ error: { code, message, details? } }`
-- Offset pagination: page (1-indexed), pageSize (default 25, max 100)
-- Areas/trades/users NOT paginated (small collections)
-- Junction tables use composite PKs (no surrogate id) -- EXCEPT invoice_budget_lines which uses surrogate UUID (carries itemized_amount, needs individual CRUD)
-
-## Naming Conventions
+## Topic Files
 
-- DB: snake_case | TS vars: camelCase | TS types: PascalCase | Files: camelCase.ts (React: PascalCase.tsx) | API: kebab-case | Env: UPPER_SNAKE_CASE
+- [Recurring patterns & traps](recurring-patterns.md) — polymorphic FK cleanup, XOR CHECK vs SET NULL, forked-function drift, test smells, accepted N+1 sites
+- [Dual-rail aggregation](dual-rail-aggregation.md) — Rail A/B tagged-deposit invariants (#1891/PR #1894), residual-denominator rule, isSplit UNION
+- [Story reviews](story-reviews.md) — per-story and per-PR review log
+- [Client PDF pipeline](client-pdf-pipeline.md) — ADR-034 report PDF generation
+- [Diary drafts pattern](diary-drafts-pattern.md) — ADR-022 draft lifecycle via status column on parent table
+- [EPIC-03 refinement](epic03-refinement.md) — 40 consolidated refinement items
+- [EPIC-04 household items](epic04-household-items.md) · [EPIC-05 budget](epic05-budget.md) · [EPIC-17 i18n](epic17-i18n.md) · [EPIC-18 areas & trades](epic18-areas-trades.md)
 
-## Migrations (18 total)
+## Tech Stack (Accepted)
 
-- 0001-0009: Auth, work items, budget, milestones, deps, actual dates, document_links
-- 0010: household_items + 5 supporting tables (EPIC-04)
-- 0011: household_item_budget_id FK + index on invoices (EPIC-04)
-- 0012: household_item_deps + delivery date columns
-- 0013-0016: HI dep cleanup, status rename, delivery date redesign, HI categories
-- 0017: invoice_budget_lines junction table (EPIC-15, ADR-018)
-- 0018: areas + trades, vendor trade_id, WI area_id + assigned_vendor_id, HI area_id, drop tags (EPIC-18, ADR-028)
+- Fastify 5.x (ADR-001) · React 19 + React Router 7 (ADR-002) · SQLite/better-sqlite3 + Drizzle (ADR-003)
+- Webpack 5.x (ADR-004) · Jest 30.x + Playwright (ADR-005) · CSS Modules (ADR-006) · npm workspaces (ADR-007)
+- TypeScript ~6.0, Node.js 24 LTS. Canonical table lives in CLAUDE.md — trust it over this file.
 
-## ADRs (ADR-001 through ADR-028)
+## Project Layout
 
-- ADR-001-009: Tech stack + error handling
-- ADR-010: Auth (sessions + OIDC + scrypt)
-- ADR-011: E2E (Playwright + Testcontainers)
-- ADR-012: Pagination conventions
-- ADR-013: Gantt chart (custom SVG)
-- ADR-014: Scheduling engine (server-side CPM)
-- ADR-015: Paperless-ngx integration (proxy + polymorphic links)
-- ADR-016: Household items (separate entity with parallel structure)
-- ADR-018: Invoice-budget-line junction table (M:N with XOR CHECK, ON DELETE CASCADE)
-- ADR-022: Diary drafts via status column on diary_entries (issue #1426). See [[diary-drafts-pattern]]
-- ADR-028: Areas & Trades (structured dimensions replacing tags)
+- Build order `shared/` -> `client/` -> `server/`
+- All plugins use `fastify-plugin` (fp). Registration: config -> errorHandler -> compress -> cookie -> db -> auth -> routes -> static
+- Root: package.json, tsconfig.base.json, eslint.config.js, .prettierrc, jest.config.ts
+- Server: `src/db/schema.ts`, migrations in `src/db/migrations/`. Client: `webpack.config.cjs` (proxies /api to :3000)
 
-## EPIC Status
+## Key Conventions
 
-- EPIC-01 Auth: Complete (promoted to main)
-- EPIC-03 Work Items: Complete (promoted to main)
-- EPIC-05 Budget: Complete (promoted to main, v1.9.0)
-- EPIC-06 Timeline/Gantt: Complete (promoted to main, v1.10.0)
-- EPIC-08 Documents: Complete (promoted to main, v1.11.0)
-- EPIC-04 Household Items: Complete (promoted to main, v1.12.0)
-- EPIC-15 Budget-Line Invoice Linking: Complete (promoted to main, v1.14.0)
-- EPIC-18 Areas & Trades: In progress (ADR-028, Schema, API Contract designed)
+- All endpoints under `/api/`; error shape `{ error: { code, message, details? } }`
+- Offset pagination: `page` (1-indexed), `pageSize` (default 25, max 100). Small collections (areas, trades, users) NOT paginated
+- Junction tables use composite PKs — EXCEPT `invoice_budget_lines` (surrogate UUID: carries `itemized_amount`, needs individual CRUD)
+- Naming: DB snake_case | TS vars camelCase | TS types PascalCase | files camelCase.ts (React PascalCase.tsx) | API kebab-case | env UPPER_SNAKE_CASE
 
 ## GitHub Wiki
 
-- Wiki is git submodule at `wiki/`. Sync: `git submodule update --init wiki && git -C wiki pull origin master`
-- ADR-001 through ADR-028, Architecture, Schema, API-Contract, Home, ADR-Index, Style-Guide, Security-Audit
-- **Always push wiki before creating PR** -- submodule ref must be committed in feature branch
+- Git submodule at `wiki/`. Sync: `git submodule update --init wiki && git -C wiki pull origin master`
+- Submodule is normally in **detached HEAD** at origin/master — push with `git push origin HEAD:master`
+- Pages: Architecture, Schema, API-Contract, Home, ADR-Index, ADR-NNN-*, Style-Guide (ux-designer), Security-Audit (security-engineer)
+- **Always push wiki before creating the PR** — the submodule ref must be committed on the feature branch. If you push wiki content outside the branch, flag that the PR's ref needs bumping.
 
 ### Wiki Update Discipline (CRITICAL)
 
-The wiki MUST be updated as part of story implementation, not caught at review time.
-
-- New endpoint -> API-Contract.md
-- New/changed table/column -> Schema.md
-- Architectural decision -> ADR-NNN-\*.md + ADR-Index.md
-
-## EPIC-04 Household Items (Latest Work)
+Update the wiki as part of story implementation, never as a review catch:
+new endpoint -> API-Contract.md · new/changed table or column -> Schema.md · decision -> ADR-NNN-*.md + ADR-Index.md.
+On any wiki/implementation divergence, fix the wiki and append a **Deviation Log** row (each page has one at the bottom).
 
-See `epic04-household-items.md` for full details.
+## ADRs
 
-- 6 new tables, 21 API endpoints (includes reverse WI->HI GET), ADR-016
-- Reuses shared tags, vendors, budget_categories, budget_sources, subsidy_programs
-- document_links already supports household_item entity_type
-- Budget overview must aggregate both work_item_budgets and household_item_budgets
+ADR-001..034. Notable: 010 auth (sessions + OIDC + scrypt) · 011 E2E (Playwright + Testcontainers) · 012 pagination ·
+013 Gantt (custom SVG) · 014 scheduling (server-side CPM) · 015 Paperless-ngx (proxy + polymorphic links) ·
+016 household items · 018 invoice_budget_lines (M:N, XOR CHECK, ON DELETE CASCADE) · 022 diary drafts ·
+028 areas & trades · 034 client-side report PDF. Wiki ADR-Index is authoritative.
 
-## Known Wiki Documentation Gaps
-
-- Migration 0007 (work_item_milestone_deps) not documented in Schema.md
-- Wiki sandbox worktrees have persistent permission issues with `.git/objects/pack/`
-- API-Contract.md household items POST says 404 for vendor/tag not found, but work items says 400 — implementation uses 400 (consistent with work items). Wiki needs harmonization.
-- **PR #402**: `GET /api/work-items/:workItemId/household-items` -- RESOLVED, added to API-Contract.md wiki
-
-## Sandbox Limitations (not real project issues)
-
-- esbuild SIGILL on emulated aarch64; Docker build fails due to TLS firewall
-- 4GB RAM: Jest OOM mitigated with --maxWorkers=2, --max-old-space-size=2048
-
-## N+1 Queries (Accepted at Current Scale)
-
-- `getAllMilestones`: per-row countLinkedWorkItems + getCreatedByUser (acceptable <50 milestones)
-
-## PR Review Notes
+## Migrations
 
-- Cannot `gh pr review --approve` own PRs -- use `--comment` instead
-- Root `typecheck` script builds shared first
-
-## Config Files
-
-- Root: package.json, tsconfig.base.json, eslint.config.js, .prettierrc, jest.config.ts
-- Server: schema in src/db/schema.ts, migrations in src/db/migrations/
-- Client: webpack.config.cjs (proxies /api to localhost:3000)
+Sequential SQL in `server/src/db/migrations/`, currently through **0044** (deposit `budget_source_id`).
+Read the directory rather than trusting a list here. Known gap: migration 0007 (`work_item_milestone_deps`)
+is still undocumented in Schema.md.
 
 ## CI/CD (ADR-008)
 
 - GitHub Actions + semantic-release + Docker Hub + Docker Scout + Dependabot
-- Feature PR -> beta (squash merge); beta -> main (merge commit)
-
-## Topic Files
-
-- `story-reviews.md` -- detailed review notes per story
-- `epic03-refinement.md` -- 40 consolidated refinement items from EPIC-03
-- `epic05-budget.md` -- EPIC-05 budget management details
-- `epic04-household-items.md` -- EPIC-04 household items architecture
-- `epic18-areas-trades.md` -- EPIC-18 areas & trades structured dimensions
-- `diary-drafts-pattern.md` -- ADR-022 draft entity lifecycle pattern (status column on parent table, applicable beyond diary)
-
-## EPIC-04 Review Summary (see story-reviews.md for details)
-
-- PR #399 (4.4): Request Changes -- missing quantity field
-- PR #401 (4.6): Request Changes -- confidence margin display bug (fractions not percentages)
-- PR #402 (4.7): Comment -- 1 medium (wiki gap, resolved)
-- PR #414 (4.9): Request Changes -- missing invoice delete guard, wiki gaps
-- PR #416 (4.10): Request Changes -- orphaned deps on WI/milestone delete, deleted 1060-line test file, wiki not updated
-
-### Recurring Pattern: Polymorphic FK Cleanup
-
-When using polymorphic FKs (no DB-level constraint), ALL services that delete the referenced entity must manually clean up. Applies to `document_links` and `household_item_deps`.
-
-### Recurring Pattern: CONFIDENCE_MARGINS
+- Feature PR -> `beta` (squash merge); `beta` -> `main` (merge commit)
+- Beta PRs gate on `Quality Gates` only; `main` also requires `E2E Gates`
 
-Values are fractions (0.2, 0.1, 0.05, 0), NOT percentages. Frontend must multiply by 100 for display.
-
-## PR #460 Review (2026-03-04)
-
-Fix for inline status selector. Auto-sets actualDeliveryDate when status → 'arrived' and date is null.
-
-**Finding**: API Contract wiki was not updated to document the auto-set behavior. Backend/frontend/tests are correct; wiki doc gap identified and flagged.
-
-## PR #612 Review (2026-03-08) -- EPIC-15 Story 15.1
-
-Invoice-budget-line junction table (migration 0017). Request changes:
-
-- CRITICAL: Broken test assertions -- `MutuallyExclusiveBudgetLinkError` tests retained but validation removed from service. CI red.
-- HIGH: Wiki Schema.md says ON DELETE SET NULL for budget FKs, but migration/Drizzle/ADR-018 use ON DELETE CASCADE.
-- MEDIUM: InvoiceBudgetLineSummary shared type diverges from wiki API Contract shape. Defer reconciliation to Story 15.2.
-
-### Key Lesson: XOR CHECK + ON DELETE SET NULL Incompatibility (Bug #611)
-
-SQLite enforces CHECK constraints during FK SET NULL actions. If a table has `CHECK((a IS NOT NULL AND b IS NULL) OR ...)` and `ON DELETE SET NULL` on column `a`, deleting the referenced row triggers SET NULL which violates the XOR CHECK. Fix: use ON DELETE CASCADE instead.
+## PR Review Notes
 
-## PR #1150 Review (2026-03-22) -- EPIC-19 Backup & Restore
+- Cannot `gh pr review --approve` your own PR — use `gh pr comment` instead
+- Root `typecheck` script builds `shared` first
+- Verdicts: `--request-changes` for critical/high only; `--approve` with findings noted for medium/low
 
-Request changes (2 critical, 3 high, 2 medium):
+## Sandbox Limitations (not real project issues)
 
-- CRITICAL: Wiki not updated (API-Contract.md, Architecture.md) -- zero wiki changes in PR
-- CRITICAL: CLAUDE.md env var table missing BACKUP_DIR, BACKUP_CADENCE, BACKUP_RETENTION
-- HIGH: stopScheduler() never called on app close -- needs onClose hook
-- HIGH: Module-level mutable state (operationInProgress, cronTask) -- testing concern
-- MEDIUM: process.exit(0) bypasses Fastify graceful shutdown
-- MEDIUM: createError state set but never rendered in UI (bug #1164)
+- esbuild SIGILL on emulated aarch64; Docker build fails behind the TLS firewall
+- 4GB RAM: Jest OOM mitigated with `--maxWorkers=2 --max-old-space-size=2048`
+- Stale worktrees under `.claude/worktrees/` cause jest-haste-map duplicate-package failures.
+  Work around with `npx jest <file> --modulePathIgnorePatterns='/.claude/worktrees/'`
diff --git a/.claude/agent-memory/product-architect/dual-rail-aggregation.md b/.claude/agent-memory/product-architect/dual-rail-aggregation.md
new file mode 100644
index 000000000..2e33b3baa
--- /dev/null
+++ b/.claude/agent-memory/product-architect/dual-rail-aggregation.md
@@ -0,0 +1,42 @@
+---
+name: dual-rail-aggregation
+description: Rail A/Rail B tagged-deposit aggregation invariants for source reports (#1891/PR #1894) — the residual-denominator rule and the review heuristics that caught it
+metadata:
+  type: project
+---
+
+# Dual-Rail Deposit Aggregation (Story #1891, PR #1894)
+
+Source reports allocate an invoice to a budget source via two independent rails.
+`server/src/services/shared/depositAggregateUtils.ts` + `sourceReportService.ts`.
+
+## The load-bearing invariant
+
+**A tagged deposit loses only its pro-rata line apportionment. It stays in the residual denominator.**
+
+- Rail A (`splitByDepositsExcludingTagged`): `residualFraction = (invoiceAmount − Σ non-refund deposit amounts) / invoiceAmount` over **all** deposits, tagged or not — byte-identical expression to legacy `splitByDeposits`. The `isTagged` filter applies **only** to the emitted `depositFractions`.
+- Rail B (`sumTaggedDepositContributions*`): tagged deposits count 100% to their own source, signed by `entryType`.
+
+**Why:** Rail B already credits the tagged money. Dropping it from the denominator too lets the residual re-absorb it → double-count. Original bug shipped a 1000€ invoice as 1400€ to the bank.
+
+**Testable consequence:** summing `allocatedAmount` across all sources on a fully-line-covered invoice reconstructs the invoice amount exactly. Canonical fixture: 1000€ invoice, 600€ line→A, 400€ line→B, 150€ deposit tagged A ⇒ residual 0.85, A = 600×0.85+150 = 660, B = 400×0.85 = 340, Σ = 1000. Pin this invariant on any change here.
+
+**Non-obvious corollary:** the residual fraction is *invoice-level*, so a deposit tagged to source A also reduces the Rail A share of a source-B line on the same invoice. That looks wrong at first glance; it is exactly what makes the rails reconcile.
+
+## `isSplit`
+
+UNION over two arms (budget-line sources via `work_item_budgets`/`household_item_budgets`, and `invoice_deposits.budget_source_id`), both `IS NOT NULL`-filtered, then `COUNT(DISTINCT source_id) > 1`. `UNION` not `UNION ALL` — a source reachable both ways must collapse to one.
+
+## Review heuristics that earned their keep
+
+1. **When a function is forked into an `XExcludingY` variant, diff its core formula against the original line by line.** The residual expression was the only divergence and the only bug. ~200 lines of near-duplicate logic, one of two copies wrong.
+2. **A combined-rail test that puts the two rails on *different* invoices proves nothing.** The original suite had exactly that and passed while the same-invoice case was off by 40%. Always demand the same-entity crossing case.
+3. **Additive-only diffs (`@@ -N,3 +N,269 @@`, zero deletions) are strong containment** — verify with `git diff origin/beta...HEAD -- <file>` — but they only bound the blast radius to *new* code paths. They say nothing about whether the new path is correct.
+4. **Tests that assert a surprising number with a long apologetic comment are a smell.** The pre-fix test literally said "1400 … is intentionally MORE than the invoice amount". That comment was the bug report.
+
+## Open follow-ups
+
+- Collapse `splitByDeposits` / `splitByDepositsExcludingTagged` (and the two `computeStatusContribution*` pairs) behind `options.excludeTagged` once soaked. This round is the argument: the residual formula had to be verified in two places and only one was wrong.
+- M1: N+1 in `getSourceReport` step j/d (per-invoice deposit + vendor fetches). Tolerable at scale, wrong pattern to copy.
+- M3: `unallocatedInvoices` `NOT EXISTS` guard on tagged deposits is not status-qualified → an invoice whose only tagged deposit is out-of-slice appears nowhere. Visibility gap, not a money error.
+- #1895 (HIGH) `markInvoicesClaimed` is invoice-scoped not source-scoped; #1896 quotation+pending-deposit 409s the batch; #1897 budget-lines drill-down is deposit-blind.
diff --git a/.claude/agent-memory/product-architect/recurring-patterns.md b/.claude/agent-memory/product-architect/recurring-patterns.md
new file mode 100644
index 000000000..81a9c03b3
--- /dev/null
+++ b/.claude/agent-memory/product-architect/recurring-patterns.md
@@ -0,0 +1,49 @@
+---
+name: recurring-patterns
+description: Cross-cutting correctness traps in Cornerstone that have bitten more than once — polymorphic FK cleanup, CONFIDENCE_MARGINS units, SQLite XOR CHECK vs SET NULL, N+1 sites accepted at current scale
+metadata:
+  type: project
+---
+
+# Recurring Patterns & Traps
+
+## Polymorphic FK cleanup
+
+Polymorphic FKs carry no DB-level constraint, so **every** service that deletes the referenced entity
+must clean up manually. Applies to `document_links` and `household_item_deps`. Caught as a defect on
+PR #416 (orphaned deps on work-item/milestone delete). Check this on any new polymorphic reference.
+
+## CONFIDENCE_MARGINS are fractions, not percentages
+
+Values are `0.2 / 0.1 / 0.05 / 0`. The frontend must multiply by 100 for display. Shipped as a display
+bug once (PR #401).
+
+## SQLite: XOR CHECK is incompatible with ON DELETE SET NULL (bug #611)
+
+SQLite enforces CHECK constraints *during* the FK SET NULL action. Given
+`CHECK((a IS NOT NULL AND b IS NULL) OR (b IS NOT NULL AND a IS NULL))` plus `ON DELETE SET NULL` on `a`,
+deleting the referenced row fires SET NULL, which then violates the XOR CHECK and aborts.
+**Use ON DELETE CASCADE instead.** This is why `invoice_budget_lines` (ADR-018) cascades.
+
+## Forked-function drift
+
+When a function is forked into an `XExcludingY` / `XWithZ` variant rather than parameterised, diff the
+core formula against the original line by line — that divergence is where the bug will be. Seen on
+`splitByDepositsExcludingTagged` (PR #1894), where the residual expression was the sole difference and
+the sole defect. Prefer an options flag over a fork; when a fork ships anyway, file the collapse follow-up.
+
+## Test smells worth escalating in review
+
+- A combined-path test that places the two interacting entities on **different** parents proves nothing
+  about the crossing case. Demand the same-parent fixture.
+- An assertion of a surprising number wrapped in a long apologetic comment is usually a bug report in
+  disguise (pre-fix #1894 test literally said "1400 … is intentionally MORE than the invoice amount").
+- Additive-only diffs (`@@ -N,3 +N,269 @@`, zero deletions) bound blast radius to new code paths but say
+  nothing about the new path's correctness. Verify with `git diff origin/beta...HEAD -- <file>`.
+
+## N+1 queries accepted at current scale (<5 users)
+
+Not bugs, but do not let them become the copied pattern:
+
+- `getAllMilestones`: per-row `countLinkedWorkItems` + `getCreatedByUser`
+- `sourceReportService.getSourceReport` steps d/j: per-invoice deposit fetch + per-Rail-B-invoice vendor lookup (PR #1894 M1)
diff --git a/.claude/agent-memory/product-architect/story-reviews.md b/.claude/agent-memory/product-architect/story-reviews.md
index c8781af0e..9fd55a60d 100644
--- a/.claude/agent-memory/product-architect/story-reviews.md
+++ b/.claude/agent-memory/product-architect/story-reviews.md
@@ -164,3 +164,44 @@ When using polymorphic FKs (no DB-level constraint), ALL services that delete th
 
 4. Client allows `itemizedAmount >= 0` but API requires `> 0`.
 5. `loadBudgetLines` not memoized -- eslint exhaustive-deps warning risk.
+
+---
+
+# Review Log (migrated from MEMORY.md index, 2026-07-30)
+
+## EPIC-04 Household Items
+
+- PR #399 (4.4): Request Changes -- missing quantity field
+- PR #401 (4.6): Request Changes -- confidence margin display bug (fractions not percentages)
+- PR #402 (4.7): Comment -- 1 medium (wiki gap, resolved; `GET /api/work-items/:id/household-items` added to API-Contract.md)
+- PR #414 (4.9): Request Changes -- missing invoice delete guard, wiki gaps
+- PR #416 (4.10): Request Changes -- orphaned deps on WI/milestone delete, deleted 1060-line test file, wiki not updated
+
+## PR #460 (2026-03-04) -- inline status selector
+
+Auto-sets `actualDeliveryDate` when status -> 'arrived' and date is null. Backend/frontend/tests correct;
+API Contract wiki not updated to document the auto-set behaviour. Doc gap flagged.
+
+## PR #612 (2026-03-08) -- EPIC-15 Story 15.1, invoice_budget_lines (migration 0017)
+
+Request changes:
+
+- CRITICAL: broken test assertions -- `MutuallyExclusiveBudgetLinkError` tests retained but validation removed from service. CI red.
+- HIGH: wiki Schema.md said ON DELETE SET NULL for budget FKs; migration/Drizzle/ADR-018 use ON DELETE CASCADE.
+- MEDIUM: `InvoiceBudgetLineSummary` shared type diverged from wiki API Contract shape. Deferred to Story 15.2.
+
+## PR #1150 (2026-03-22) -- EPIC-19 Backup & Restore
+
+Request changes (2 critical, 3 high, 2 medium):
+
+- CRITICAL: wiki not updated (API-Contract.md, Architecture.md) -- zero wiki changes in PR
+- CRITICAL: CLAUDE.md env var table missing BACKUP_DIR, BACKUP_CADENCE, BACKUP_RETENTION
+- HIGH: `stopScheduler()` never called on app close -- needs onClose hook
+- HIGH: module-level mutable state (`operationInProgress`, `cronTask`) -- testing concern
+- MEDIUM: `process.exit(0)` bypasses Fastify graceful shutdown
+- MEDIUM: `createError` state set but never rendered in UI (bug #1164)
+
+## PR #1894 (2026-07-30) -- Story #1891 dual-rail deposit aggregation
+
+Round 1 CHANGES_REQUIRED (1 critical: Rail A/B double-count), round 2 APPROVED after commit 86a9770a.
+Full invariants and review heuristics in `dual-rail-aggregation.md`.
diff --git a/.claude/agent-memory/product-owner/MEMORY.md b/.claude/agent-memory/product-owner/MEMORY.md
index 9d9ae44df..0730e2004 100644
--- a/.claude/agent-memory/product-owner/MEMORY.md
+++ b/.claude/agent-memory/product-owner/MEMORY.md
@@ -37,6 +37,7 @@ Full detail in [standalone-bugs-and-stories.md](standalone-bugs-and-stories.md)
 - Auto-itemize: #1545/#1546/#1547 mini-epic (2026-05-21), #1600 (2026-05-26), **#1833 duplicate budget lines on commit retry (2026-07-07)**
 - Diary: #1426 critical photo data loss (2026-05-15)
 - Photo: #1723 lightbox picker UX (2026-06-16)
+- **Bank Report Wizard mini-epic** (no parent epic): #1876 refunds (PR #1880) → #1877 contact/household/attachment typing (PR #1883) → #1878 report backend → #1879 wizard+PDF (PR #1887, CHANGES_REQUIRED then **APPROVED** round 2, 2026-07-30). Domain decisions, contract facts (refund sign, `isSplit`, `totalAmount` scope) and deferrals in [bank-report-wizard.md](bank-report-wizard.md). Open: **#1891** user-verification follow-up (Todo, PR #1894 **APPROVED** 32/32 round 2, 2026-07-30 — 2 wiki MUST FIX outstanding); **#1888** stage-matched attachment indicator (Backlog, blocked-by #1879); **#1895** HIGH claim close-out cross-source sweep, **#1896** quotation-deposit 409 (blocked-by #1895), **#1897** deposit-blind drill-down — all Backlog, from the #1891 architect audit; E2E shard 5 pre-existing flake must be triaged before promoting to `main`.
 
 ## Requirements Coverage
 
@@ -62,4 +63,4 @@ Full detail in [standalone-bugs-and-stories.md](standalone-bugs-and-stories.md)
 
 ## PR Review
 
-Detailed checklist, recurring violations, and per-PR findings in [pr-review-patterns.md](pr-review-patterns.md). Top recurring items to check FIRST: dependency pinning (exact versions), keyboard :focus indicators (WCAG AA), test authorship (QA not devs), E2E gate for "Automated (E2E)" scenarios, raw-value display bugs (formatDate/percent/"—" placeholder). Verdict matrix: `--request-changes` for functional AC gaps; `--comment` "MUST FIX" for display/formatting; `--approve` when all met.
+Detailed checklist, recurring violations, and per-PR findings in [pr-review-patterns.md](pr-review-patterns.md). Top recurring items to check FIRST: **CI shard status (`Quality Gates` green ≠ E2E green)**, **test doubles hiding defects (wrong-sign fixtures / key-echoing `t` mocks / mocked libs)**, **every `t()` path actually resolves in `en/<ns>.json`**, dependency pinning (exact versions), keyboard :focus indicators (WCAG AA), test authorship (QA not devs), E2E gate for "Automated (E2E)" scenarios, raw-value display bugs (formatDate/percent/"—" placeholder). Verdict matrix: `--request-changes` for functional AC gaps; `--comment` "MUST FIX" for display/formatting; `--approve` when all met.
diff --git a/.claude/agent-memory/product-owner/bank-report-wizard.md b/.claude/agent-memory/product-owner/bank-report-wizard.md
index 161b4778c..011ca2f6e 100644
--- a/.claude/agent-memory/product-owner/bank-report-wizard.md
+++ b/.claude/agent-memory/product-owner/bank-report-wizard.md
@@ -16,12 +16,30 @@ metadata:
 - **#1876 — Deposit refunds with negative claim adjustments.** Merged to `beta` via PR #1880 (2026-07-29). Landed first deliberately: riskiest, touches shared rollup logic, fully testable standalone. Spec ref: `bank-report-wizard-plan.md` §2a-0, §1, §6 item 1.
 - **#1877 — Source contact fields, household sender setting & document attachment typing.** APPROVED by PO on PR #1883 (2026-07-29), all 9 ACs met. Spec ref: `bank-report-wizard-plan.md` §2a-0, §1, §6 item 2.
 - **#1878 — Source report backend** (`getSourceReport`, `markInvoicesClaimed`). Merged. Contract in `shared/src/types/sourceReport.ts`.
-- **#1879 — Wizard frontend, PDF pipeline & claim flow.** PR #1887 reviewed 2026-07-30 → **CHANGES_REQUIRED** (see below). Final story of the mini-epic.
+- **#1879 — Wizard frontend, PDF pipeline & claim flow.** PR #1887 reviewed 2026-07-30 → CHANGES_REQUIRED, then **APPROVED** round 2 (see below).
+- **#1891 — User-verification follow-up** (created 2026-07-30, `user-story`, board **Todo**, blocked-by #1879): `blob:` CSP fix for the preview, status-chip sizing, expandable step-3 invoice rows, and the deposit `budget_source_id` domain change. PR #1894 reviewed 2026-07-30 → CHANGES_REQUIRED (31/32, AC 4.6), then **APPROVED** round 2 at `74289586` (32/32). Decisions section below.
+- **#1888 — stage-matched attachment indicator** (Backlog, deferred from #1879).
+- **#1895 / #1896 / #1897 — claim close-out defects** from the product-architect audit of #1891's dual-rail deposit aggregation (PR #1894). All Backlog, created 2026-07-30. See §"Claim close-out defects" below.
+
+## Claim close-out defects found auditing #1891 (2026-07-30)
+
+The architect audit of the dual-rail aggregation confirmed **budget totals conserve correctly** — every defect found is in the **claim close-out** path, not the money math. Keep that distinction when triaging: conservation and close-out are separate correctness domains here, and a green conservation check says nothing about close-out.
+
+- **#1895 (bug, HIGH / Must Have)** — `markInvoicesClaimed` (`sourceReportService.ts:506`) takes only `invoiceIds`: it flips every listed invoice `pending|paid`→`claimed` and sweeps EVERY deposit on them, with no `budget_source_id` and no report-slice filter. Confirming source A's claim permanently blocks source B's residual claim AND inflates `computeClaimedAmount(B)`. Also subsumes: step-3 line exclusions shrink the report amount but mark-claimed still claims the whole invoice → excluded portion permanently unclaimable. Fix direction: require `sourceId` + explicit `depositIds`; deposit-only close-out when the invoice stays claimable for another source (the arm at `:565-566` already supports it). Needs API Contract wiki update, possibly an ADR amendment. **Breaking API change.** No test covered the cross-source sweep.
+- **#1896 (bug, MEDIUM / Should Have, blocked-by #1895)** — `createDeposit` has no parent-invoice-status guard, so a `quotation` invoice can carry a pending deposit, enter the claim slice via that deposit, then get rejected by the claimability check → `InvoicesNotClaimableError` rolls back the ENTIRE batch (asserted by `sourceReportService.test.ts` scenario 27 — the rollback is intended; the slice membership is the bug). Resolves naturally once #1895's deposit-only close-out lands. Interim UX: surface `err.error.details.invoiceIds`. Open domain question logged on the issue: should `createDeposit` reject deposits on quotation invoices outright, or is "deposit against a quote" legitimate?
+- **#1897 (bug, MEDIUM / Should Have)** — `GET /api/budget-sources/:id/budget-lines` is deposit-blind (`budgetSourceService.ts:812-848` / `:850-888` attribute the whole itemized amount by parent-invoice status), while the work-item page uses the deposit-aware `budgetServiceFactory.getInvoiceAggregates`. Display divergence only, **predates #1891**. Rider in the same issue: `budgetSourceService.ts:387-390` coerces any non-`'claimed'` status arg to `'paid'` via ternary — latent, fix is `new Set([status])`.
+
+The `isSplit` fix from the same audit was folded into PR #1894 directly — deliberately **no** issue for it.
+
+**Outstanding wiki MUST FIX from the PR #1894 approval** (documentation only, must land before merge to satisfy AC 4.11): `API-Contract.md:4186` Rail A text still says tagged deposits are "excluded from the pro-rata pool entirely" and the residual uses "the remaining deposits" — that describes the fixed defect, not the code. `API-Contract.md:3609` still defines `isSplit` as line-derived only. Architect owns line 4186; **line 3609 was surfaced separately by me** and is easy to miss.
+
+**#1895 and #1896 are pre-existing in kind since #1878** (line-split invoices); #1891's deposit tagging only widened #1895's blast radius. Neither blocks PR #1894.
 
 ## Contract facts downstream stories must respect
 
 - **`SourceReportInvoice.allocatedAmount` is NEGATIVE for `lineKind: 'refund-adjustment'`** — server derives `lineKind = roundedAmount > 0 ? 'invoice' : 'refund-adjustment'`, so the sign and the kind are the same fact. Never re-negate at display time. This tripped up PR #1887 in four places.
-- **`isSplit` is a server field** meaning "budget lines reference >1 distinct source". It is NOT `allocatedAmount < invoiceAmount` (that's partial allocation to one source — a different question). Don't recompute it client-side.
+- **`isSplit` is a server field** meaning "the invoice's funding spans 2+ distinct budget sources across **budget lines AND tagged deposits**" (widened in PR #1894; a `UNION` sub-query, still server-derived). It is NOT `allocatedAmount < invoiceAmount` (that's partial allocation to one source — a different question). Don't recompute it client-side.
+- **Tagged-deposit aggregation is REDIRECT, not ADD** (the AC 4.6 blocker on PR #1894). In `splitByDepositsExcludingTagged`, a tagged deposit is excluded from the emitted `depositFractions` (Rail A) but **still subtracted from the residual denominator** — its money leaves Rail A and is re-added whole by Rail B. Rail A + Rail B across all sources must reconstruct exactly the invoice amount. Any future change here needs a conservation assertion (`A + B === invoiceAmount`), not just a per-source number.
 - **`report.totalAmount` is the server's total over ALL invoices** in the status slice, already netting refunds. It is _not_ valid as the grand total once the user excludes invoices client-side.
 
 ## PR #1887 review outcome (2026-07-30) — CHANGES_REQUIRED
@@ -37,8 +55,33 @@ metadata:
 
 **Lesson recorded in [[pr-review-patterns]]:** all six were invisible in a green unit suite — wrong-sign fixtures, key-echoing `t` mocks, and mocked PDF libs. Check the E2E artifacts, not the unit tests, for anything involving a third-party runtime pipeline.
 
+### Round 2 (commits fdba5cd8/0bf8e674/09600edb/f6dbacfc) — **APPROVED** 2026-07-30
+
+All 6 blockers + 7 MUST-FIX verified fixed at the root, independently re-checked against the diff. Notable outcomes worth reusing:
+
+- Fix was `pdfMake.addVirtualFileSystem()` + `addFonts({ Roboto: {normal, bold: 'Roboto-Medium.ttf', …} })` — the missing piece was **font-family registration**, not the vfs assignment.
+- **`realRender.test.ts` is the pattern to demand** for any third-party rendering pipeline: mocks nothing, real i18n bundles (en+de), real formatters, stubs only `fetch` with genuine pdf-lib bytes, asserts every bold style renders and that excluded rows are absent from the total. Ask for this by name in future PDF/canvas/export stories.
+- Split footnotes re-modelled with **two marker namespaces** (`†N` splits, `*N` skipped docs) — reuse when a document needs independent footnote families.
+- `includedTotal` computed in `merge.ts` and threaded into _both_ overview and cover letter.
+- Accepted decision: the refund row's _Invoice Amount_ column shows the gross **positive** amount in the refund colour (the invoice's amount genuinely is positive; the refund is the contribution). The negative allocated amount + `(refund)` note carry the sign. Do not "fix" this back.
+
+**Deferred AC → #1888** (standalone user-story, Backlog, blocked-by #1879): "stage-matched" attachment indicator. Deferred deliberately, not missed — `attachmentType` is invoice-only and frequently `null` (#1877), so a naive match rule would _hide_ the paperclip for legitimately attached docs. The `null` rule must be decided first; #1888's first AC captures that.
+
+**Not attributable to this PR:** E2E shard 5 red on `invoices.spec.ts` "Effective Amount"/"Remaining Amount" (known #1876-era flake: singleton `table.invoices.columns` preference + debounced save leaking across retries; its fix has regressed) and `navigation/dashboard` "card is dismissed". Same two tests failed pre-fix. **Must be triaged before this mini-epic is promoted — `E2E Gates` is required on `main`.**
+
 German report-type nouns approved (Verwendungsnachweis, Einreichung) — reasoning in [[glossary-decisions]].
 
+## Domain decisions locked in by #1891 (user-verification follow-up to #1879)
+
+Raised by the user after verifying PR #1887 on a real deployment. Four bundled points (2 bugs, 1 feature, 1 domain change), **all confirmed with the user — do not re-scope**.
+
+- **Deposits carry an optional, DIRECT `budget_source_id`** (nullable, migration 0044, no backfill). USER-DECIDED: the link goes deposit → source, deliberately **not** routed via budget lines. Contradictions between a deposit's tagged source and what the invoice's budget lines imply are **explicitly accepted**. Do not add validation to reconcile them, and do not "fix" this into a line-derived path later.
+- **New aggregation rule (locked in):** a _source-tagged_ deposit's status-sliced contribution counts **100%** toward its tagged source — even when the invoice has **no** budget lines for that source. _Untagged_ deposits keep the existing pro-rata apportionment. Applies uniformly to `budgetSourceService` rollups **and** `GET /api/source-reports`. This narrows, but does not replace, the #1876 `splitByDeposits` semantics — the pro-rata path in `computeStatusContributionByInvoice` remains the default for untagged rows.
+- **Deposit form source picker default:** the invoice's only source; if multiple, the dominant-by-allocation one; if the invoice has no budget lines, no default and empty is valid.
+- **Claiming stays invoice-level.** Step-3 line exclusions refine `allocatedAmount` / running total / PDF amounts only. An included invoice with excluded items must trigger an explicit warning in the mark-claimed confirmation. Do not let anyone turn line exclusion into partial claiming.
+- **Report response gains** a per-invoice budget-line breakdown (line id, item name, work/household item link, per-line allocated portion) plus the invoice's deposits/refunds list — both exist to power the step-3 row expansion.
+- **CSP bug worth remembering:** `frame-src 'self'` does **not** cover `blob:` URLs; the wizard preview iframe was blocked in every real deployment while CI stayed green, because the E2E assertion only checked that `src` was a non-empty `blob:` string. Any future "preview renders" AC must assert the frame **renders content**, not that a URL was assigned.
+
 ## Domain decisions locked in by #1877
 
 - **`app_settings` is a new app-scoped key/value table** (migration 0043). The AC said "existing app-settings mechanism" but none existed — `user_preferences` is per-user. Household name/address live here. Reuse this table for future app-scoped settings; do not add another mechanism.
diff --git a/.claude/agent-memory/product-owner/pr-review-patterns.md b/.claude/agent-memory/product-owner/pr-review-patterns.md
index 7da095bb1..24696b13c 100644
--- a/.claude/agent-memory/product-owner/pr-review-patterns.md
+++ b/.claude/agent-memory/product-owner/pr-review-patterns.md
@@ -30,6 +30,17 @@ metadata:
 - **Test authorship**: developer agents MUST NOT write tests. Check `Co-Authored-By` trailer in test commits. Caused BLOCKING in PR #152 (all 211 tests by frontend-developer).
 - **E2E gate**: any UAT scenario marked "Automated (E2E)" MUST have Playwright coverage in `e2e/tests/` before PO approval. Caused BLOCKING in PRs #152 and #157 (CI showed "E2E Tests: SKIPPED").
 - **Raw value display (formatDate / percent / placeholder)**: the single most recurring functional bug. See "Display formatting" cluster below.
+- **Tests that ENCODE the defect**: a test named "does NOT do X" that asserts X, or a test comment containing unresolved reasoning ("— wait, actually…"). Green CI then certifies the bug. Grep new/changed test files for hedging words in comments; a title contradicting its own assertion is the tell. Caught the AC 4.6 blocker on PR #1894 (asserted €1400 on a €1000 invoice).
+- **Conservation assertions for money math**: for any split/apportionment logic, demand a test that the parts sum to the whole across ALL consumers — not just a per-consumer number. Per-source numbers can each look plausible while the total is inflated (PR #1894).
+
+## Dual desktop/mobile rendering (responsive card-list pattern)
+
+When a PR adds a mobile card list beside a desktop table, re-check rather than assume:
+
+- Both copies must call the **same handler** — two exclusion/toggle paths can diverge silently.
+- Confirm the hidden copy uses `display: none` (removed from the a11y tree), not just visual hiding — otherwise duplicate accessible names.
+- jsdom renders BOTH, so `getByRole` becomes ambiguous. `getAllByRole(...)[0]` is the accepted convention here — legitimate disambiguation, not a weakened test. But `getByText` → `getAllByText(...).length > 0` does drop the "exactly one" guarantee; `within(desktopTable)` keeps both properties.
+- Check any scoped CSS-class fix (e.g. a `justify-self` chip fix) is not overridden or bypassed by the new media query, and that a shared wrapper class (`.tableWrapper`) hidden on mobile isn't also used by an unrelated always-visible region.
 
 ## Display-formatting cluster (verdict = `--comment` "MUST FIX", non-blocking)
 
diff --git a/.claude/agent-memory/qa-integration-tester/MEMORY.md b/.claude/agent-memory/qa-integration-tester/MEMORY.md
index 22496cfc7..bd5911169 100644
--- a/.claude/agent-memory/qa-integration-tester/MEMORY.md
+++ b/.claude/agent-memory/qa-integration-tester/MEMORY.md
@@ -15,7 +15,8 @@
 
 ## Recent bug/story notes (2026-07)
 
-- [Story #1879 — report wizard frontend](story-1879-report-wizard-frontend.md) (2026-07-29, updated 2026-07-30 — round 6) — CRITICAL: production files edited by a concurrent process mid-session; jsdom Blob/URL polyfill gaps; i18next dot-vs-colon cross-namespace bug family (recurred 4 rounds — grep `t('common\.` AND check for missing keys after colon-fixing); ESM jest.spyOn-on-namespace workaround. Round 4: 6/7 bugs fixed for real; `common:retry` (step-3, distinct from ReportPdfPreview's) still open. Round 5 (69 tsc errors from further prod changes — appendix-once-per-invoice, step-4 cached-bytes reuse, WizardStepper dual-tree, Step4Options prop swap, shouldRegenerate removed): fixed all test tsc errors (jest.fn<typeof realFn>() typing, PaperlessStatusResponse.paperlessUrl/filterTag fixtures, `!` for noUncheckedIndexedAccess); found NEW BLOCKER — `loader.ts`'s `const pdfMake = pdfMakeModule` assigns the frozen dynamic-import() namespace object (not `.default`, the real CJS export) — `.vfs=` assignment throws `TypeError: Cannot add property vfs, object is not extensible` on every call, whole PDF-generation feature broken against real pdfmake package; rewrote loader.test.ts to assert the real rejection. Rewrote WizardStepper.test.tsx for CSS-only dual-tree responsive (no more JS-viewport-conditional assumption); dropped its now-obsolete internal focus-mgmt block (moved to ReportWizardPage.tsx). Added 2 merge.test.ts regression tests (appendix-once-per-invoice, step-4 fetch-once-per-doc caching). `i18n.parity.test.ts` still red for en/de gaps — translator-owned, flagged not fixed. Round 5 final: 17/17 suites, 354/354 tests, lint/prettier clean; 2 residual tsc errors in merge.ts confirmed real prod bugs. Round 6: frontend fixed round-5's namespace-object bug (`pdfMakeModule.default`) + merge.ts's getBlob() to promise-based — verified for real via standalone node repro before touching tests; updated loader.test.ts's 2 rejection-pinning tests to assert success, updated merge.test.ts's mockGetBlob to promise style. Found a NEW, deeper, still-open blocker underneath: `pdfMake.fonts` defaults to `{ Roboto }` only, 'Helvetica' (merge.ts's actual defaultStyle font) is never registered anywhere, so `getBlob()` rejects on every real render — independent of the (also still-open) vfs-shape bug. Gotcha: `createPdf()` is lazy and doesn't throw sync — wrapping it in `expect(() => ...).toThrow()` crashes the whole Jest worker process instead of failing the assertion; must `await expect(pdfDoc.getBlob()).rejects.toThrow(...)` instead. Round 6 final: 17/17 suites, 355/355 tests, tsc clean, i18n parity 46/46, lint/prettier clean.
+- [Story #1891 — bank report wizard follow-up](story-1891-report-wizard-followup.md) (2026-07-30) — 2 confirmed production bugs (sourceReportService `isSplit` hardcoded false — regression, breaks split badge; ReportWizardPage runaway PDF-regen loop still unresolved across rounds); 2nd occurrence of concurrent-production-file-edit-mid-session (always re-read before filing a bug or final pass); NEW: AJV `coerceTypes:true` silently stringifies numbers for `type:['string','null']` fields (use object/array to test type-rejection, not a number); byte-identical Rail-A/B regression-proof pattern (direct old-fn-vs-new-fn comparison, not just "old tests still pass"); `flushBudgetDataLoad()` extra-`act()`-microtask-flush pattern for components that read async-loaded state synchronously inside a click handler (waitFor "has been called" alone races ahead of the state update)
+- [Story #1879 — report wizard frontend](story-1879-report-wizard-frontend.md) (2026-07-29, updated 2026-07-30 — round 7) — CRITICAL: production files edited by a concurrent process mid-session; jsdom Blob/URL polyfill gaps; i18next dot-vs-colon cross-namespace bug family (recurred 4 rounds — grep `t('common\.` AND check for missing keys after colon-fixing); ESM jest.spyOn-on-namespace workaround. Round 4: 6/7 bugs fixed for real; `common:retry` (step-3, distinct from ReportPdfPreview's) still open. Round 5 (69 tsc errors from further prod changes — appendix-once-per-invoice, step-4 cached-bytes reuse, WizardStepper dual-tree, Step4Options prop swap, shouldRegenerate removed): fixed all test tsc errors (jest.fn<typeof realFn>() typing, PaperlessStatusResponse.paperlessUrl/filterTag fixtures, `!` for noUncheckedIndexedAccess); found NEW BLOCKER — `loader.ts`'s `const pdfMake = pdfMakeModule` assigns the frozen dynamic-import() namespace object (not `.default`, the real CJS export) — `.vfs=` assignment throws `TypeError: Cannot add property vfs, object is not extensible` on every call, whole PDF-generation feature broken against real pdfmake package; rewrote loader.test.ts to assert the real rejection. Rewrote WizardStepper.test.tsx for CSS-only dual-tree responsive (no more JS-viewport-conditional assumption); dropped its now-obsolete internal focus-mgmt block (moved to ReportWizardPage.tsx). Added 2 merge.test.ts regression tests (appendix-once-per-invoice, step-4 fetch-once-per-doc caching). `i18n.parity.test.ts` still red for en/de gaps — translator-owned, flagged not fixed. Round 5 final: 17/17 suites, 354/354 tests, lint/prettier clean; 2 residual tsc errors in merge.ts confirmed real prod bugs. Round 6: frontend fixed round-5's namespace-object bug (`pdfMakeModule.default`) + merge.ts's getBlob() to promise-based — verified for real via standalone node repro before touching tests; updated loader.test.ts's 2 rejection-pinning tests to assert success, updated merge.test.ts's mockGetBlob to promise style. Found a NEW, deeper, still-open blocker underneath: `pdfMake.fonts` defaults to `{ Roboto }` only, 'Helvetica' (merge.ts's actual defaultStyle font) is never registered anywhere, so `getBlob()` rejects on every real render — independent of the (also still-open) vfs-shape bug. Gotcha: `createPdf()` is lazy and doesn't throw sync — wrapping it in `expect(() => ...).toThrow()` crashes the whole Jest worker process instead of failing the assertion; must `await expect(pdfDoc.getBlob()).rejects.toThrow(...)` instead. Round 6 final: 17/17 suites, 355/355 tests, tsc clean, i18n parity 46/46, lint/prettier clean. Round 7 (PR #1887 QA fix spec, 6 items): vfs/font blocker resolved via real `addVirtualFileSystem()`/`addFonts()` API — `pdfMake.virtualfs.existsSync(...)` (lowercase, not camelCase) is the correct probe, confirmed by reading node_modules/pdfmake source. Rewrote overviewPdf/coverLetterPdf tests for the new `formatters`/`includedTotal` params and dual `*`/`†` marker model; fixed ReportInvoiceList's `"total"` vs `"totalAmount"` regex bug (independent of the refund-sign rewrite) and its `getByLabelText`→`getByText` paperclip fix (sr-only span, not aria-label); added NEW realRender.test.ts (fully unmocked, real i18next+formatters+pdfmake+pdf-lib). CRITICAL still-open bug found: ReportWizardPage's regen effect has `previewBlob` in its own deps array → infinite regeneration loop in real usage (repro: 1→3→7 calls in 3s) — item 2's "kill the loop" fix did not remove this dependency; left the new no-runaway-regeneration test failing on purpose. Round 7 final: 13/13 suites except this 1 known-bad test (211/212 tests), tsc clean, i18n parity 46/46, lint/prettier clean.
 - [Story #1878 — source report backend](story-1878-source-report-backend.md) (2026-07-29, updated) — 6 confirmed production bugs incl. a NEW one found on async-fix follow-up: getSourceReport's `for (const doc of docs)` iterates a Map's [key,value] tuples instead of `.values()`, so ASN/title enrichment silently never populates (issue #1884, test `it.skip`'d not weakened); async/await test-suite conversion pattern; branch-coverage-ceiling reasoning (Record<Status,...> type guarantees make some optional-chain fallbacks unreachable-by-design, don't chase them)
 - [Story #1877 — contact fields, household settings, attachment typing](story-1877-contact-fields-attachment-typing.md) (2026-07-29) — coverage-tooling artifact confirmed on `if (!request.user) throw` guard clauses (systemic, not a real gap — cross-checked against pre-existing preferences.ts); diff-vs-baseline triage reconfirmed on 4 large files; 2 ripple files found only via `tsc --noEmit` (converters.test.ts's `$inferSelect`-typed row builder, missed by BudgetSource-type grep); new app_settings key-value table pattern (first app-wide, non-per-user settings table); dynamic pre-migration-file-list technique (replaces hardcoded list per migration test)
 - [Story #1876 — deposit refunds](story-1876-deposit-refunds.md) (2026-07-29) — spec claimed PATCH-immutable-field 400, actual is 200 silent strip (confirmed real Wiki Accuracy bug in API-Contract.md); refund/negative-fraction pattern for depositAggregateUtils; new DataTable column-visibility test pattern (no prior precedent); diff-vs-baseline coverage triage technique for large legacy files (~78-82% isolated % with 100% diff coverage, confirmed via git-diff-hunk cross-reference)
diff --git a/.claude/agent-memory/qa-integration-tester/story-1891-report-wizard-followup.md b/.claude/agent-memory/qa-integration-tester/story-1891-report-wizard-followup.md
new file mode 100644
index 000000000..05f66cbc1
--- /dev/null
+++ b/.claude/agent-memory/qa-integration-tester/story-1891-report-wizard-followup.md
@@ -0,0 +1,142 @@
+# Story #1891 — Bank report wizard follow-up (CSP blob:, chip sizing, expandable rows, deposit budget source)
+
+Date: 2026-07-30. Branch `feat/1891-wizard-followup` (work already in place from backend/frontend
+when QA started — production files pre-existed and were edited by a concurrent process AGAIN
+mid-session, same pattern as story #1879 round 1 — see below).
+
+## Two confirmed production bugs (structured failure reports filed, tests NOT weakened)
+
+1. **`sourceReportService.ts` `getSourceReport`: `isSplit` hardcoded to `false`.** The #1891
+   backend rewrite removed the entire `isSplitMap`/`splitRows` query (which counted distinct
+   budget sources per invoice) and replaced the field with a literal `isSplit: false` plus a
+   comment "isSplit stays line-derived only" — but never restored the computation. Confirmed via
+   the PRE-EXISTING (unmodified) test `sourceReportService.test.ts` scenario 11 ("invoice split
+   across two sources → isSplit true"), which now fails deterministically:
+   `expect(result.invoices[0]!.isSplit).toBe(true)` receives `false`. Left this test untouched
+   (per protocol) — it is correct and pins the real behavior. This breaks the "split" badge in
+   `ReportInvoiceList.tsx` for every invoice, permanently.
+2. **`ReportWizardPage.tsx`: runaway PDF-regeneration loop, still unresolved across multiple
+   rounds.** The pre-existing (not authored this round) test
+   `'does not keep re-triggering generateReportPdf once settled (no runaway regeneration loop)'`
+   still fails — `mockGenerateReportPdf` called 3-4 times instead of pinned at 1, over a 1300ms
+   idle window. Root cause (per prior round's investigation, still true): `regeneratePdf`
+   (`useCallback`) depends on `effectiveReport`, and the debounced regen `useEffect` also depends
+   on `effectiveReport` + `regeneratePdf` — some render path re-creates `effectiveReport`'s
+   identity even with zero exclusions (`applyLineExclusions` returns the same object when
+   `excludedLineIds.size===0`, so the loop source must be state churn elsewhere, e.g.
+   `previewBlob`/`isRegenerating` toggling causing a re-render that indirectly changes a
+   `useCallback` dep — not fully re-diagnosed this round, just reconfirmed still broken). Left the
+   test untouched (it's correct, from a prior QA round, documenting a real unresolved bug).
+
+## CRITICAL: production files were edited by a concurrent process mid-session (2nd time this story)
+
+Read `InvoiceDepositsSection.tsx` early in the session (per spec/diff) and it had NO auto-default
+logic wired — the "3-case default" behavior described in the dev-team-lead spec (group
+`invoice.budgetLines` by `budgetSourceId`, sum `itemizedAmount`, default null/single/largest) was
+entirely absent (`openAddModal` just called `getEmptyForm()` unconditionally, no
+`fetchInvoiceBudgetLines` import, no `sourceStats`). Was about to file this as a bug. Before
+writing the bug report, ran the test file and got `setBudgetLines is not a function` / act()
+warnings referencing code that didn't exist in my read — re-read the file and found the frontend
+agent had ADDED the entire feature (imports, `budgetLines` state, `sourceStats` computation,
+`openAddModal` 3-case logic, picker JSX with 3 hint variants) in the time between my first read and
+running tests. **Lesson (reconfirmed): always re-read a production file immediately before writing
+its bug report or its final test pass — do not trust an earlier read in a long QA session,
+especially on files under active frontend development.** Wasted ~10 min chasing a phantom bug;
+caught it via the test-run error stack trace naming a function (`setBudgetLines`) that "shouldn't
+exist" per my stale read.
+
+## AJV `coerceTypes: true` gotcha (new, not previously documented)
+
+Fastify's schema compiler defaults to `coerceTypes: true` (in addition to the previously-documented
+`removeAdditional: true`). A JSON **number** payload value for a `type: ['string', 'null']` field
+(e.g. `budgetSourceId: 12345`) is **silently coerced to the string `"12345"`** and PASSES AJV
+validation — it does NOT produce a 400. If the coerced string isn't a real FK target and the
+service performs no existence check (the documented "FK-reliant, no existence validation"
+convention used here and in `workItemBudgetService`), the request proceeds to the DB layer and
+trips the SQLite FK constraint, which is **unhandled** and surfaces as a raw `500` (not a clean
+400/404 API error) — verified via a throwaway probe test capturing the actual server log
+(`SqliteError: FOREIGN KEY constraint failed`, `code: SQLITE_CONSTRAINT_FOREIGNKEY`, unhandled
+error handler emits 500). **To reliably test "wrong type" rejection for a nullable-string field,
+use an object or array payload, not a number** — those are not coercible and correctly 400. Pin the
+number-coercion case as its own test asserting 500 (documents current behavior), not lump it in
+with the "rejected" test.
+
+## Byte-identical regression proof pattern for additive Rail A/B refactors
+
+When a service is rewired to add a parallel "Rail B" computation path (deposits tagged directly to
+a budget source) alongside an existing "Rail A" (line-derived pro-rata split), and the new
+functions are literal copies of the old ones with one extra filter branch
+(`splitByDepositsExcludingTagged` vs `splitByDeposits`), the most convincing regression proof is a
+**direct comparison test**: run the SAME untagged fixture through both the legacy fn and the new
+`*ExcludingTagged` sibling (adding `deposit_budget_source_id: null` to every row) and assert
+`toEqual`/`toBeCloseTo` equality — not just "the old tests still pass unmodified" (which only
+proves the OLD function wasn't touched, not that the NEW function behaves identically on the
+untagged subset). Did this for `splitByDepositsExcludingTagged` vs `splitByDeposits`,
+`computeStatusContributionExcludingTagged` vs `computeStatusContribution`, and
+`computeLineContributionsExcludingTagged`'s per-ibl sum vs `computeStatusContributionByInvoice`'s
+per-invoice sum (grouped after the fact). Got depositAggregateUtils.ts to 100%/95.33%/100%/100%.
+
+## Test infra gotchas specific to this story
+
+- `InvoiceDepositsSection.tsx` gained TWO new async data dependencies this round
+  (`fetchBudgetSources` — already existed from an earlier story but was unmocked in the test file
+  until now — and NEW `fetchInvoiceBudgetLines`). Both needed fresh `jest.unstable_mockModule`
+  blocks; missing either causes real network calls through the mocked (but unimplemented)
+  `apiClient.get` which the component's own `try/catch` swallows silently — tests still pass but
+  with `act()` warnings and stale/empty picker state.
+- **Race condition**: `await waitFor(() => expect(mockFetchInvoiceBudgetLines).toHaveBeenCalled())`
+  is NOT sufficient to guarantee the subsequent `setBudgetSources`/`setBudgetLines` state updates
+  have landed — `waitFor` resolves on its first successful check, which can fire before the mocked
+  promise's `.then` continuation (the `Promise.all(...)` in the component) has actually run. Since
+  `openAddModal`'s auto-default is computed **synchronously at click time** from already-rendered
+  state (not reactively), opening the modal too early captures a stale (empty) `sourceStats` and
+  the default silently comes out wrong — intermittently, not on every run. Fixed by adding a
+  `flushBudgetDataLoad()` helper: `await act(async () => { await Promise.resolve(); await
+Promise.resolve(); await Promise.resolve(); });` called AFTER the mock-called `waitFor`, before
+  opening the modal. Use this pattern (extra microtask-flushing `act()`) whenever a component reads
+  async-loaded state synchronously inside a click handler.
+- `OverflowMenu`'s trigger button accessible name is exactly `triggerAriaLabel` (no literal "menu"
+  substring) — for `InvoiceDepositsSection`'s deposit row menu it resolves to `"Deposit actions for
+{description-or-entryTypeLabel}"` (e.g. `"Deposit actions for Deposit"` for a null-description
+  deposit-type deposit). Don't guess `/menu/i` — check the real i18n string and the component's
+  `triggerAriaLabel={...}` expression first.
+- Real i18n (not a fake `t`) is used in `ReportWizardPage.test.tsx` — cross-referenced exact English
+  strings via `python3 -c "import json; ..."` against `client/src/i18n/en/budget.json` rather than
+  guessing (e.g. `sourceReports.expand.excludeItemAriaLabel` → `"Exclude {{name}} from report"`).
+- `ReportInvoiceList.tsx`'s expand/collapse chevron `<button>` has **no accessible name at all**
+  (no `aria-label`, the SVG child is `aria-hidden`) despite the translator having added
+  `sourceReports.expand.expandInvoice`/`collapseInvoice` keys per the dev-team-lead spec's
+  Translator Spec section — those two keys are dead/unwired. Queried the button via
+  `container.querySelector('[aria-controls="invoice-expand-${id}"]')` instead of
+  `getByRole('button', {name})`. Worth a minor a11y note if asked, not filed as a blocking bug
+  (spec's Compliance section didn't explicitly require an aria-label on this element).
+- `formatCurrency` test mocks in this codebase are typically `(n) => \`€${n.toFixed(2)}...\``—
+for a negative number this produces`"€-75.00"`(minus AFTER the currency symbol), not`"-€75.00"`. Don't assume sign placement; check the mock's actual `toFixed` composition.
+- Migration 0044 test followed the established `0043_app_settings.test.ts` dynamic
+  pre-migration-file-list pattern exactly (see `test-infra-reference.md`) — added FK-specific
+  cases (invalid FK → `FOREIGN KEY constraint failed`, `ON DELETE SET NULL` → row survives with
+  null, not cascade-deleted) since this migration's column is the first `invoice_deposits` FK
+  besides `invoice_id`.
+
+## Coverage achieved (final, all touched files)
+
+| File                                     | Stmts                                                                                                       | Branch                                   | New tests                                                                        |
+| ---------------------------------------- | ----------------------------------------------------------------------------------------------------------- | ---------------------------------------- | -------------------------------------------------------------------------------- |
+| `depositAggregateUtils.ts`               | 100%                                                                                                        | 95.33%                                   | +59 (106 total in file)                                                          |
+| migration `0044...test.ts` (new)         | n/a (SQL)                                                                                                   | —                                        | 8                                                                                |
+| `reportExclusions.ts` (new)              | 100%                                                                                                        | 100%                                     | 12                                                                               |
+| `sourceReportService.ts`                 | 100%                                                                                                        | 91.3% (defensive FK-guard branches only) | +12 (44 total, 1 known pre-existing fail)                                        |
+| `budgetSourceService.ts`                 | modified fns (114-400) fully covered; file-wide 67% (huge pre-existing untested surface, out of scope)      | —                                        | +11 (172 total)                                                                  |
+| `invoiceDepositService.ts`               | 97.31%                                                                                                      | 89.47%                                   | +9 (90 total)                                                                    |
+| `invoiceDeposits.ts` route               | 85.71% (gaps are pre-existing `!request.user` guards)                                                       | 50%                                      | +14 (41 total)                                                                   |
+| `sourceReports.ts` route                 | n/a                                                                                                         | —                                        | +1 (15 total)                                                                    |
+| `helmetPlugin.ts`                        | 100%                                                                                                        | 100%                                     | +2 (8 total)                                                                     |
+| `ReportInvoiceList.tsx`                  | 100%                                                                                                        | 92.77%                                   | +26 (51 total)                                                                   |
+| `ReportWizardPage.tsx`                   | 97.02%                                                                                                      | 86.3%                                    | +8 (41 total, 1 known pre-existing fail)                                         |
+| `InvoiceDepositsSection.tsx`             | 84.92% file-wide (new code 104-200/1007-1044 fully covered; gaps are pre-existing form-validation branches) | 80.39%                                   | +19 (87 total)                                                                   |
+| `SelectionActionBar.tsx`                 | 100%                                                                                                        | 100%                                     | +2 (9 total)                                                                     |
+| Ripple fixture-only fixes (no new tests) | —                                                                                                           | —                                        | `invoiceDepositsApi.test.ts`, `reportPdf/{merge,overviewPdf,realRender}.test.ts` |
+
+All server tsc (`--noEmit`) and client tsc (`--noEmit`) clean at session end. i18n parity
+(`i18n.parity.test.ts`) 46/46 green — translator had already landed full en/de parity for all new
+`sourceReports.expand.*`/`invoiceDetail.deposits.form.budgetSource*` keys before QA started.
diff --git a/.claude/agent-memory/translator/MEMORY.md b/.claude/agent-memory/translator/MEMORY.md
index c1a902ffc..488d20784 100644
--- a/.claude/agent-memory/translator/MEMORY.md
+++ b/.claude/agent-memory/translator/MEMORY.md
@@ -73,3 +73,17 @@ Found and fixed pre-existing (not newly introduced) glossary violations while au
 Established de pattern for `"<X> section navigation"` aria labels (SubNav component instances) is the compound `"<X>-Abschnittsnavigation"` — confirmed from `schedule.json`'s `navigation.ariaLabel`: en "Schedule section navigation" → de "Zeitplan-Abschnittsnavigation". Applied same pattern for `budget.json` `sourceReports.subNavAriaLabel`: en "Budget section navigation" → de "Budget-Abschnittsnavigation". Note: `DashboardPage.tsx` ("Project section navigation") and `VendorsPage.tsx` ("Settings section navigation") hardcode this string directly in JSX rather than using `t()` — not a translator concern, but means those two instances have no de counterpart to check against; only use schedule.json as the reference pattern.
 
 Also confirmed: "allocated" vocabulary in de/budget.json is consistently `zugeordnet`/`Zuordnung` (e.g. `allocatedAmount` → "Zugeordneter Betrag", `unallocatedExplained` → "...nicht zugeordnet"). Used for new `sourceReports.table.splitFootnote`: "Amount shown reflects only the portion allocated to this source." → "Der angezeigte Betrag umfasst nur den dieser Quelle zugeordneten Anteil."
+
+## Dash Convention: en dash "–" not em dash "—" (Issue #1891, 2026-07-30)
+
+`en/*.json` source text uses em dash "—" for parenthetical asides (e.g. `budgetSourceHintSingle`: "Defaulted to {{name}} — this invoice's only budget source."). Confirmed de/budget.json convention (grep for "–"/"—" across the file) consistently uses a spaced en dash "–" instead, never em dash — e.g. `revertNetworkError`: "Netzwerkfehler – Status...", `coverLetterDisabledReason`: "...Referenz – ein Anschreiben...". Always substitute "–" for en's "—" when translating, don't copy the em dash verbatim.
+
+## Report-Wizard Expand/Deposit-Tagging Keys (Issue #1891, 2026-07-30)
+
+New `sourceReports.expand.*` (chevron-expand sub-tables for budget lines + deposits in the report wizard invoice list) and `invoiceDetail.deposits.form.budgetSource*` (deposit→source picker) keys translated. Judgment calls, useful as precedent for future column-header/table keys:
+- `itemColumnHeader`: "Item" (generic table header for a budget-line description) → "Position" — parallels German invoicing convention where each line is a "Position"; distinct from `itemsHeading` "Budgetpositionen" (glossary Budget Line plural) which is the sub-table's section heading, not the column.
+- `datesColumnHeader`: "Dates" (column stacking due/paid/claimed dates) → "Termine", not "Daten" (which reads as "data" in modern German, not "dates").
+- `linkedColumnHeader`: "Linked to" → "Verknüpft mit" (consistent with existing `linkedItem`/`linkedItemLegend` → "Verknüpftes Element").
+- `budgetSourceNone`: "None (pro-rated)" → "Keine (anteilig)" — reused "anteilig" from the existing `splitBadge`: "anteilig {{allocated}} von {{total}}" rather than inventing a new word for "pro-rated".
+- `confirmClaimExcludedItemsWarning`: matched the sibling `confirmClaimBody`'s "Rechnung(en)" pluralization-count pattern and "eingereicht" (this locale's established word for "claimed", not "beansprucht").
+- Full flatten-diff parity (0/0) and `i18n.parity.test.ts` (46/46) both green after the change.
diff --git a/.claude/agent-memory/ux-designer/feature-spec-history.md b/.claude/agent-memory/ux-designer/feature-spec-history.md
index ce6aa2b14..a131dcb3d 100644
--- a/.claude/agent-memory/ux-designer/feature-spec-history.md
+++ b/.claude/agent-memory/ux-designer/feature-spec-history.md
@@ -77,6 +77,16 @@ See `story-4-9-invoice-linking-hi.md`. Entity type toggle (`role="group"` + `rol
 - Modal width for edit with picker visible: `min(640px, calc(100vw - 2rem))`
 - Focus auto-advance: use `requestAnimationFrame` (not `setTimeout`) for React 19 concurrent rendering
 
+## Issue #1891 — Bank Report Wizard follow-up (status chip, expandable rows, deposit source)
+
+- **Grid-item stretch bug pattern**: a `Badge` (or any `display:inline-flex` element) placed as a **direct CSS Grid item** still stretches to fill its column under default `justify-items: stretch` — `inline-flex` on the element itself does NOT prevent this; only `justify-self: start` on the grid item does. Native `<table>`/`<td>` layouts (e.g. `DataTable`) never have this problem, which is why `InvoicesPage`'s identical `Badge` usage looked fine while `ReportInvoiceList`'s (a CSS Grid row) stretched. Check for this specific failure mode whenever a `Badge`/pill sits directly inside a `grid-template-columns` row rather than a `<td>` or flex child.
+- Root cause in `ReportInvoiceList.module.css`: `grid-template-columns: auto 1fr auto auto auto` (5 tracks) but the checkbox+vendor content was merged into ONE `<label>` grid item, so it silently consumed only the first `auto` track and the `Badge` fell into the `1fr` track meant for vendor content. Fix: `grid-column: span 2` on the merged label + `justify-self: start` on the badge — restores correct column-to-content mapping AND prevents stretch.
+- **Tri-state checkbox design call**: when a parent-invoice checkbox needs to reflect item-level exclusions (some-but-not-all budget lines within an included invoice excluded), use `TriStateCheckbox` with `indeterminate` = "included but reduced by item exclusions" — but keep the click handler wired to the SAME whole-invoice include/exclude toggle as before. Never give indeterminate state its own new click semantics — that would blur "claiming stays invoice-level" into looking like partial-claim UI.
+- Deposit/refund **entry type** as an explicit table column (not just implied by badge omission): unlike `InvoiceDepositsSection`'s convention (only refund gets a badge, deposit is unmarked), when an AC explicitly lists "entry type" as a required displayed field, give BOTH values a visible `Badge` (`Deposit` → `BadgeStyles.info`, `Refund` → local `.refund` class) rather than relying on the omission-implies-deposit shortcut.
+- `MassMoveModal.tsx`/`.module.css` (`.warningBlock`/`.warningIconContainer`/`.warningIcon`, amber triangle SVG, `role="alert"`) is the richer icon+heading+body warning pattern — prefer it over `InvoiceDepositsSection`'s plain-text `.warningBanner` when the warning is about a consequential/irreversible action. Both are currently component-scoped duplicates of the same CSS; flagged as a future `shared.module.css` promotion candidate, not yet blocking.
+- `SelectionActionBar`'s count `<span>` has no `aria-live` — pre-existing gap, worth fixing opportunistically (shared component) whenever a story adds more granular controls that drive its total.
+- Deposit status badges can reuse the SAME `.pending`/`.paid`/`.claimed` classes already defined for invoice-status badges within the SAME file, when the value domains match — check for existing same-file classes before adding new ones or reaching for another file's copy.
+
 ## Story #1804 — Backup Scheduler Status (node-cron 4.5 adoption)
 
 - Spec posted on issue #1804; implemented in PR #1834 (approved — see [pr-review-findings.md](pr-review-findings.md))
diff --git a/client/src/components/SelectionActionBar/SelectionActionBar.test.tsx b/client/src/components/SelectionActionBar/SelectionActionBar.test.tsx
index 82c538779..255b8f645 100644
--- a/client/src/components/SelectionActionBar/SelectionActionBar.test.tsx
+++ b/client/src/components/SelectionActionBar/SelectionActionBar.test.tsx
@@ -90,4 +90,32 @@ describe('SelectionActionBar', () => {
       ),
     ).not.toThrow();
   });
+
+  // ─── Story #1891: aria-live announcement of the running count/total ───────
+
+  it('the count span has aria-live="polite" and aria-atomic="true" (Story #1891)', () => {
+    render(
+      <SelectionActionBar countLabel="2 selected" onClear={jest.fn()} clearLabel="Clear selection">
+        <button type="button">Merge</button>
+      </SelectionActionBar>,
+    );
+    const countSpan = screen.getByText('2 selected');
+    expect(countSpan).toHaveAttribute('aria-live', 'polite');
+    expect(countSpan).toHaveAttribute('aria-atomic', 'true');
+  });
+
+  it('re-rendering with an updated countLabel keeps the aria-live attributes on the same span', () => {
+    const { rerender } = render(
+      <SelectionActionBar countLabel="2 selected" onClear={jest.fn()} clearLabel="Clear selection">
+        <button type="button">Merge</button>
+      </SelectionActionBar>,
+    );
+    rerender(
+      <SelectionActionBar countLabel="5 selected" onClear={jest.fn()} clearLabel="Clear selection">
+        <button type="button">Merge</button>
+      </SelectionActionBar>,
+    );
+    const countSpan = screen.getByText('5 selected');
+    expect(countSpan).toHaveAttribute('aria-live', 'polite');
+  });
 });
diff --git a/client/src/components/SelectionActionBar/SelectionActionBar.tsx b/client/src/components/SelectionActionBar/SelectionActionBar.tsx
index 6d3ecb3cc..23ffb71a3 100644
--- a/client/src/components/SelectionActionBar/SelectionActionBar.tsx
+++ b/client/src/components/SelectionActionBar/SelectionActionBar.tsx
@@ -24,7 +24,9 @@ export function SelectionActionBar({
 }: SelectionActionBarProps) {
   return (
     <div className={`${styles.bar} ${className ?? ''}`}>
-      <span className={styles.count}>{countLabel}</span>
+      <span className={styles.count} aria-live="polite" aria-atomic="true">
+        {countLabel}
+      </span>
       <div className={styles.actions}>
         <button type="button" className={sharedStyles.btnSecondaryCompact} onClick={onClear}>
           {clearLabel}
diff --git a/client/src/components/reports/ReportInvoiceList.module.css b/client/src/components/reports/ReportInvoiceList.module.css
index 55538269f..864152dd5 100644
--- a/client/src/components/reports/ReportInvoiceList.module.css
+++ b/client/src/components/reports/ReportInvoiceList.module.css
@@ -9,7 +9,7 @@
 
 .listHeader {
   display: grid;
-  grid-template-columns: auto 1fr auto auto auto;
+  grid-template-columns: 1.5rem auto 1fr auto auto auto;
   gap: var(--spacing-3);
   align-items: center;
   padding: var(--spacing-3) var(--spacing-4);
@@ -34,7 +34,7 @@
 
 .invoiceRow {
   display: grid;
-  grid-template-columns: auto 1fr auto auto auto;
+  grid-template-columns: 1.5rem auto 1fr auto auto auto;
   gap: var(--spacing-3);
   align-items: center;
   padding: var(--spacing-3) var(--spacing-4);
@@ -48,6 +48,7 @@
   gap: var(--spacing-3);
   cursor: pointer;
   min-height: 44px;
+  grid-column: span 2;
 }
 
 .invoiceRow:hover {
@@ -216,3 +217,195 @@
   white-space: nowrap;
   border-width: 0;
 }
+
+/* ---- Expand Button & Chevron ---- */
+
+.expandButton {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  height: 100%;
+  background-color: transparent;
+  border: none;
+  cursor: pointer;
+  padding: 10px;
+  margin: -10px;
+  transition: background-color var(--transition-fast);
+  color: var(--color-text-primary);
+  min-height: 44px;
+}
+
+.expandButton:hover {
+  background-color: var(--color-bg-tertiary);
+}
+
+.expandButton:focus-visible {
+  outline: none;
+  box-shadow: inset 0 0 0 2px var(--color-primary);
+  border-radius: var(--radius-sm);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .chevron {
+    transition: none;
+  }
+}
+
+/* ---- Status Chip Fix ---- */
+
+.statusChip {
+  justify-self: start;
+}
+
+/* ---- Expansion Panel ---- */
+
+.expansionPanel {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-4);
+  padding: var(--spacing-4);
+  background-color: var(--color-bg-secondary);
+  border-bottom: 1px solid var(--color-border);
+  outline: none;
+}
+
+.subTableSection {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-3);
+}
+
+.subTableHeading {
+  margin: 0;
+  font-size: var(--font-size-base);
+  font-weight: var(--font-weight-semibold);
+  color: var(--color-text-primary);
+}
+
+.tableWrapper {
+  overflow-x: auto;
+}
+
+.table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: var(--font-size-sm);
+}
+
+.table thead {
+  background-color: var(--color-bg-primary);
+  border-bottom: 1px solid var(--color-border);
+}
+
+.table th {
+  padding: var(--spacing-2) var(--spacing-3);
+  text-align: left;
+  font-weight: var(--font-weight-semibold);
+  color: var(--color-text-primary);
+}
+
+.table td {
+  padding: var(--spacing-2) var(--spacing-3);
+  border-bottom: 1px solid var(--color-border);
+  color: var(--color-text-primary);
+}
+
+.table tbody tr:hover {
+  background-color: var(--color-bg-tertiary);
+}
+
+.linkedItemLink {
+  color: var(--color-primary);
+  text-decoration: none;
+  cursor: pointer;
+}
+
+.linkedItemLink:hover {
+  text-decoration: underline;
+}
+
+.linkedItemLink:focus-visible {
+  outline: none;
+  box-shadow: inset 0 0 0 2px var(--color-primary);
+  border-radius: var(--radius-sm);
+}
+
+.subTableSeparated {
+  margin-top: var(--spacing-4);
+  padding-top: var(--spacing-4);
+  border-top: 1px solid var(--color-border);
+}
+
+.depositAmountContainer {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-2);
+}
+
+.depositDatesCell {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-1);
+  font-size: var(--font-size-xs);
+}
+
+/* ---- Mobile Card List ---- */
+
+.mobileCardList {
+  display: none;
+  flex-direction: column;
+  gap: var(--spacing-3);
+}
+
+/* ---- Mobile Responsive ---- */
+
+@media (max-width: 767px) {
+  .tableWrapper {
+    display: none;
+  }
+
+  .mobileCardList {
+    display: flex;
+  }
+
+  .mobileCard {
+    background-color: var(--color-bg-primary);
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-md);
+    padding: var(--spacing-3);
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacing-2);
+  }
+
+  .mobileCardTopRow {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: var(--spacing-2);
+  }
+
+  .mobileCardHeading {
+    font-size: var(--font-size-xs);
+    font-weight: var(--font-weight-medium);
+    color: var(--color-text-muted);
+  }
+
+  .mobileCardRow {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacing-1);
+  }
+
+  .mobileCardRow label {
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-2);
+    cursor: pointer;
+  }
+
+  .depositDatesCell {
+    font-size: var(--font-size-xs);
+  }
+}
diff --git a/client/src/components/reports/ReportInvoiceList.test.tsx b/client/src/components/reports/ReportInvoiceList.test.tsx
index de9fc61b3..d2c39ef22 100644
--- a/client/src/components/reports/ReportInvoiceList.test.tsx
+++ b/client/src/components/reports/ReportInvoiceList.test.tsx
@@ -30,10 +30,11 @@
  * (`.srOnly`) `<span>` sibling of the paperclip SVG — it's asserted via `getByText`, not
  * `getByLabelText` (a plain, non-form `<div>` has no label association for RTL's label query).
  */
-import { render, screen, fireEvent, within } from '@testing-library/react';
+import { screen, fireEvent, within } from '@testing-library/react';
 import { describe, it, expect, jest, beforeAll } from '@jest/globals';
 import type { TFunction } from 'i18next';
 import type { SourceReportResponse, SourceReportInvoice } from '@cornerstone/shared';
+import { renderWithRouter } from '../../test/testUtils.js';
 import type { ReportInvoiceList as ReportInvoiceListType } from './ReportInvoiceList.js';
 
 const t = ((key: string, opts?: Record<string, unknown>) =>
@@ -70,6 +71,8 @@ function makeInvoice(overrides: Partial<SourceReportInvoice> = {}): SourceReport
     lineKind: 'invoice',
     isSplit: false,
     documents: [],
+    budgetLines: [],
+    deposits: [],
     ...overrides,
   };
 }
@@ -96,11 +99,13 @@ function makeReport(
 
 describe('ReportInvoiceList', () => {
   it('renders EmptyState when there are no allocated and no unallocated invoices', () => {
-    render(
+    renderWithRouter(
       <ReportInvoiceList
         report={makeReport([])}
         excludedInvoiceIds={new Set()}
+        excludedLineIds={new Set()}
         onToggle={jest.fn()}
+        onToggleLine={jest.fn()}
         onToggleAll={jest.fn()}
         t={t}
       />,
@@ -113,11 +118,13 @@ describe('ReportInvoiceList', () => {
       makeInvoice({ invoiceId: 'inv-1', vendorName: 'ACME' }),
       makeInvoice({ invoiceId: 'inv-2', vendorName: 'Beta Corp', invoiceNumber: 'INV-002' }),
     ]);
-    render(
+    renderWithRouter(
       <ReportInvoiceList
         report={report}
         excludedInvoiceIds={new Set()}
+        excludedLineIds={new Set()}
         onToggle={jest.fn()}
+        onToggleLine={jest.fn()}
         onToggleAll={jest.fn()}
         t={t}
       />,
@@ -132,11 +139,13 @@ describe('ReportInvoiceList', () => {
       makeInvoice({ invoiceId: 'inv-1' }),
       makeInvoice({ invoiceId: 'inv-2' }),
     ]);
-    render(
+    renderWithRouter(
       <ReportInvoiceList
         report={report}
         excludedInvoiceIds={new Set(['inv-2'])}
+        excludedLineIds={new Set()}
         onToggle={jest.fn()}
+        onToggleLine={jest.fn()}
         onToggleAll={jest.fn()}
         t={t}
       />,
@@ -150,11 +159,13 @@ describe('ReportInvoiceList', () => {
   it('calls onToggle(invoiceId, true) when unchecking an included row', () => {
     const onToggle = jest.fn();
     const report = makeReport([makeInvoice({ invoiceId: 'inv-1' })]);
-    render(
+    renderWithRouter(
       <ReportInvoiceList
         report={report}
         excludedInvoiceIds={new Set()}
+        excludedLineIds={new Set()}
         onToggle={onToggle}
+        onToggleLine={jest.fn()}
         onToggleAll={jest.fn()}
         t={t}
       />,
@@ -167,11 +178,13 @@ describe('ReportInvoiceList', () => {
   it('calls onToggle(invoiceId, false) when re-checking an excluded row', () => {
     const onToggle = jest.fn();
     const report = makeReport([makeInvoice({ invoiceId: 'inv-1' })]);
-    render(
+    renderWithRouter(
       <ReportInvoiceList
         report={report}
         excludedInvoiceIds={new Set(['inv-1'])}
+        excludedLineIds={new Set()}
         onToggle={onToggle}
+        onToggleLine={jest.fn()}
         onToggleAll={jest.fn()}
         t={t}
       />,
@@ -187,11 +200,13 @@ describe('ReportInvoiceList', () => {
         makeInvoice({ invoiceId: 'inv-1' }),
         makeInvoice({ invoiceId: 'inv-2' }),
       ]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -206,11 +221,13 @@ describe('ReportInvoiceList', () => {
         makeInvoice({ invoiceId: 'inv-1' }),
         makeInvoice({ invoiceId: 'inv-2' }),
       ]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set(['inv-2'])}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -222,11 +239,13 @@ describe('ReportInvoiceList', () => {
     it('clicking select-all when fully selected excludes everything (onToggleAll(true))', () => {
       const onToggleAll = jest.fn();
       const report = makeReport([makeInvoice({ invoiceId: 'inv-1' })]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={onToggleAll}
           t={t}
         />,
@@ -242,11 +261,13 @@ describe('ReportInvoiceList', () => {
         makeInvoice({ invoiceId: 'inv-1' }),
         makeInvoice({ invoiceId: 'inv-2' }),
       ]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set(['inv-2'])}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={onToggleAll}
           t={t}
         />,
@@ -258,11 +279,13 @@ describe('ReportInvoiceList', () => {
 
     it('the select-all checkbox has a translated accessible name', () => {
       const report = makeReport([makeInvoice({ invoiceId: 'inv-1' })]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -279,11 +302,13 @@ describe('ReportInvoiceList', () => {
         makeInvoice({ invoiceId: 'inv-1', allocatedAmount: 300 }),
         makeInvoice({ invoiceId: 'inv-2', allocatedAmount: 200 }),
       ]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -301,11 +326,13 @@ describe('ReportInvoiceList', () => {
           invoiceAmount: 100,
         }),
       ]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -325,11 +352,13 @@ describe('ReportInvoiceList', () => {
         }),
       ]);
 
-      const { rerender } = render(
+      const { rerender } = renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -342,7 +371,9 @@ describe('ReportInvoiceList', () => {
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set(['inv-refund'])}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -361,11 +392,13 @@ describe('ReportInvoiceList', () => {
           invoiceAmount: 1000,
         }),
       ]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -384,11 +417,13 @@ describe('ReportInvoiceList', () => {
           invoiceAmount: 1000,
         }),
       ]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -405,11 +440,13 @@ describe('ReportInvoiceList', () => {
           invoiceAmount: 1000,
         }),
       ]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -429,11 +466,13 @@ describe('ReportInvoiceList', () => {
           invoiceAmount: 100,
         }),
       ]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -452,11 +491,13 @@ describe('ReportInvoiceList', () => {
           ],
         }),
       ]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -469,11 +510,13 @@ describe('ReportInvoiceList', () => {
 
     it('shows "no document" text when the invoice has zero documents', () => {
       const report = makeReport([makeInvoice({ invoiceId: 'inv-1', documents: [] })]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -494,11 +537,13 @@ describe('ReportInvoiceList', () => {
           ],
         }),
       ]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -517,11 +562,13 @@ describe('ReportInvoiceList', () => {
           documents: [],
         }),
       ]);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -546,11 +593,13 @@ describe('ReportInvoiceList', () => {
 
     it('renders a collapsible unallocated group header with the count, collapsed by default', () => {
       const report = makeReport([], unallocated);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -562,11 +611,13 @@ describe('ReportInvoiceList', () => {
 
     it('expands to show unallocated rows on click, with no selection checkbox', () => {
       const report = makeReport([], unallocated);
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -585,11 +636,13 @@ describe('ReportInvoiceList', () => {
         [makeInvoice({ invoiceId: 'inv-1', allocatedAmount: 300 })],
         unallocated,
       );
-      render(
+      renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -601,11 +654,13 @@ describe('ReportInvoiceList', () => {
   describe('SelectionActionBar clear button', () => {
     it('renders a "clear" button with a translated label', () => {
       const report = makeReport([makeInvoice({ invoiceId: 'inv-1' })]);
-      const { container } = render(
+      const { container } = renderWithRouter(
         <ReportInvoiceList
           report={report}
           excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
           onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
           onToggleAll={jest.fn()}
           t={t}
         />,
@@ -615,5 +670,641 @@ describe('ReportInvoiceList', () => {
       expect(clearBtn).toBeDefined();
       expect(clearBtn?.textContent).toBe('sourceReports.resetSelection');
     });
+
+    it('clicking the "clear" button calls onToggleAll(false)', () => {
+      const onToggleAll = jest.fn();
+      const report = makeReport([makeInvoice({ invoiceId: 'inv-1' })]);
+      const { container } = renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={onToggleAll}
+          t={t}
+        />,
+      );
+      const buttons = within(container).getAllByRole('button');
+      const clearBtn = buttons.find((b) => b.className.includes('btnSecondaryCompact'))!;
+      fireEvent.click(clearBtn);
+      expect(onToggleAll).toHaveBeenCalledWith(false);
+    });
+  });
+
+  // ─── Story #1891: expand/collapse, sub-tables, tri-state, onToggleLine ─────
+
+  describe('statusChip class (Story #1891 chip-width fix)', () => {
+    it('applies the statusChip class to the invoice status Badge', () => {
+      const report = makeReport([makeInvoice({ invoiceId: 'inv-1', status: 'paid' })]);
+      renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+      const statusEl = screen.getByText('sources.lines.invoiceStatus.paid');
+      expect(statusEl.className).toContain('statusChip');
+    });
+  });
+
+  describe('expand/collapse (chevron, aria contract, sub-tables)', () => {
+    const budgetLine = {
+      id: 'line-1',
+      description: 'Foundation work',
+      allocatedPortion: 400,
+      linkedItem: null,
+    };
+    const workItemLine = {
+      id: 'line-2',
+      description: 'Roofing',
+      allocatedPortion: 200,
+      linkedItem: { type: 'work_item' as const, id: 'wi-1', name: 'Roof Replacement' },
+    };
+    const householdItemLine = {
+      id: 'line-3',
+      description: 'Cabinet',
+      allocatedPortion: 100,
+      linkedItem: { type: 'household_item' as const, id: 'hi-1', name: 'Kitchen Cabinet' },
+    };
+    const deposit = {
+      id: 'dep-1',
+      amount: 50,
+      status: 'pending' as const,
+      entryType: 'deposit' as const,
+      dueDate: '2026-02-01',
+      paidDate: null,
+      claimedDate: null,
+      budgetSourceId: null,
+    };
+
+    function findExpandButton(container: HTMLElement, invoiceId: string): HTMLElement {
+      const btn = container.querySelector(`[aria-controls="invoice-expand-${invoiceId}"]`);
+      expect(btn).not.toBeNull();
+      return btn as HTMLElement;
+    }
+
+    it('renders NO chevron/expand button for an invoice with zero budgetLines and zero deposits', () => {
+      const report = makeReport([
+        makeInvoice({ invoiceId: 'inv-1', budgetLines: [], deposits: [] }),
+      ]);
+      const { container } = renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+      expect(container.querySelector('[aria-controls="invoice-expand-inv-1"]')).toBeNull();
+    });
+
+    it('renders a chevron/expand button when the invoice has at least one budgetLine', () => {
+      const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [budgetLine] })]);
+      const { container } = renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+      expect(findExpandButton(container, 'inv-1')).toBeInTheDocument();
+    });
+
+    it('renders a chevron/expand button when the invoice has at least one deposit (even with zero budgetLines)', () => {
+      const report = makeReport([
+        makeInvoice({ invoiceId: 'inv-1', budgetLines: [], deposits: [deposit] }),
+      ]);
+      const { container } = renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+      expect(findExpandButton(container, 'inv-1')).toBeInTheDocument();
+    });
+
+    it('aria-expanded starts false, and the expansion panel is not rendered before clicking', () => {
+      const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [budgetLine] })]);
+      const { container } = renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+      const btn = findExpandButton(container, 'inv-1');
+      expect(btn).toHaveAttribute('aria-expanded', 'false');
+      expect(container.querySelector('#invoice-expand-inv-1')).toBeNull();
+    });
+
+    it('clicking the chevron sets aria-expanded=true and renders a panel with matching id, tabIndex -1, and focuses it', () => {
+      const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [budgetLine] })]);
+      const { container } = renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+      const btn = findExpandButton(container, 'inv-1');
+      fireEvent.click(btn);
+
+      expect(btn).toHaveAttribute('aria-expanded', 'true');
+      const panel = container.querySelector('#invoice-expand-inv-1');
+      expect(panel).not.toBeNull();
+      expect(panel).toHaveAttribute('tabindex', '-1');
+      expect(document.activeElement).toBe(panel);
+    });
+
+    it('clicking the chevron again collapses the panel (aria-expanded=false, panel removed)', () => {
+      const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [budgetLine] })]);
+      const { container } = renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+      const btn = findExpandButton(container, 'inv-1');
+      fireEvent.click(btn);
+      fireEvent.click(btn);
+
+      expect(btn).toHaveAttribute('aria-expanded', 'false');
+      expect(container.querySelector('#invoice-expand-inv-1')).toBeNull();
+    });
+
+    it('Enter and Space keys on the chevron toggle expansion (keyboard operability)', () => {
+      const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [budgetLine] })]);
+      const { container } = renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+      const btn = findExpandButton(container, 'inv-1');
+      fireEvent.keyDown(btn, { key: 'Enter' });
+      expect(btn).toHaveAttribute('aria-expanded', 'true');
+      fireEvent.keyDown(btn, { key: ' ' });
+      expect(btn).toHaveAttribute('aria-expanded', 'false');
+    });
+
+    it('the expand button has a translated accessible name that flips to the collapse variant after expanding (Story #1891 follow-up: aria-label fix)', () => {
+      const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [budgetLine] })]);
+      renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+
+      // Reachable by role + accessible name (the t-mock returns the bare key when called
+      // with no interpolation options, which is how expandInvoice/collapseInvoice are used).
+      const expandBtn = screen.getByRole('button', {
+        name: 'sourceReports.expand.expandInvoice',
+      });
+      expect(expandBtn).toBeInTheDocument();
+
+      fireEvent.click(expandBtn);
+
+      // The label must flip to the collapse variant — same element, new accessible name —
+      // and the expand-variant name must no longer resolve any button.
+      expect(
+        screen.getByRole('button', { name: 'sourceReports.expand.collapseInvoice' }),
+      ).toBeInTheDocument();
+      expect(
+        screen.queryByRole('button', { name: 'sourceReports.expand.expandInvoice' }),
+      ).not.toBeInTheDocument();
+    });
+
+    describe('items sub-table', () => {
+      it('renders a row per budgetLine with description, allocated portion, and a linked-item link', () => {
+        const report = makeReport([
+          makeInvoice({ invoiceId: 'inv-1', budgetLines: [budgetLine, workItemLine] }),
+        ]);
+        const { container } = renderWithRouter(
+          <ReportInvoiceList
+            report={report}
+            excludedInvoiceIds={new Set()}
+            excludedLineIds={new Set()}
+            onToggle={jest.fn()}
+            onToggleLine={jest.fn()}
+            onToggleAll={jest.fn()}
+            t={t}
+          />,
+        );
+        fireEvent.click(findExpandButton(container, 'inv-1'));
+
+        expect(screen.getAllByText('Foundation work').length).toBeGreaterThan(0);
+        expect(screen.getAllByText('€400.00').length).toBeGreaterThan(0);
+        const links = screen.getAllByRole('link', { name: 'Roof Replacement' });
+        expect(links[0]).toHaveAttribute('href', '/project/work-items/wi-1');
+      });
+
+      it('renders a household_item linkedItem with the correct href', () => {
+        const report = makeReport([
+          makeInvoice({ invoiceId: 'inv-1', budgetLines: [householdItemLine] }),
+        ]);
+        const { container } = renderWithRouter(
+          <ReportInvoiceList
+            report={report}
+            excludedInvoiceIds={new Set()}
+            excludedLineIds={new Set()}
+            onToggle={jest.fn()}
+            onToggleLine={jest.fn()}
+            onToggleAll={jest.fn()}
+            t={t}
+          />,
+        );
+        fireEvent.click(findExpandButton(container, 'inv-1'));
+
+        const links = screen.getAllByRole('link', { name: 'Kitchen Cabinet' });
+        expect(links[0]).toHaveAttribute('href', '/household-items/hi-1');
+      });
+
+      it('renders an "unassigned" badge instead of a link when linkedItem is null', () => {
+        const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [budgetLine] })]);
+        const { container } = renderWithRouter(
+          <ReportInvoiceList
+            report={report}
+            excludedInvoiceIds={new Set()}
+            excludedLineIds={new Set()}
+            onToggle={jest.fn()}
+            onToggleLine={jest.fn()}
+            onToggleAll={jest.fn()}
+            t={t}
+          />,
+        );
+        fireEvent.click(findExpandButton(container, 'inv-1'));
+
+        expect(screen.getAllByText('sourceReports.unassigned').length).toBeGreaterThan(0);
+      });
+
+      it('falls back to "unnamedLine" text when description is null', () => {
+        const report = makeReport([
+          makeInvoice({
+            invoiceId: 'inv-1',
+            budgetLines: [{ ...budgetLine, description: null }],
+          }),
+        ]);
+        const { container } = renderWithRouter(
+          <ReportInvoiceList
+            report={report}
+            excludedInvoiceIds={new Set()}
+            excludedLineIds={new Set()}
+            onToggle={jest.fn()}
+            onToggleLine={jest.fn()}
+            onToggleAll={jest.fn()}
+            t={t}
+          />,
+        );
+        fireEvent.click(findExpandButton(container, 'inv-1'));
+
+        expect(screen.getAllByText('sourceReports.expand.unnamedLine').length).toBeGreaterThan(0);
+      });
+
+      it('renders an EmptyState for the items sub-table when budgetLines is empty (deposit-only invoice)', () => {
+        const report = makeReport([
+          makeInvoice({ invoiceId: 'inv-1', budgetLines: [], deposits: [deposit] }),
+        ]);
+        const { container } = renderWithRouter(
+          <ReportInvoiceList
+            report={report}
+            excludedInvoiceIds={new Set()}
+            excludedLineIds={new Set()}
+            onToggle={jest.fn()}
+            onToggleLine={jest.fn()}
+            onToggleAll={jest.fn()}
+            t={t}
+          />,
+        );
+        fireEvent.click(findExpandButton(container, 'inv-1'));
+
+        expect(screen.getByText('sourceReports.expand.itemsEmpty')).toBeInTheDocument();
+      });
+
+      it('calls onToggleLine(lineId, true) when unchecking an included line, and does NOT call onToggle', () => {
+        const onToggleLine = jest.fn();
+        const onToggle = jest.fn();
+        const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [budgetLine] })]);
+        const { container } = renderWithRouter(
+          <ReportInvoiceList
+            report={report}
+            excludedInvoiceIds={new Set()}
+            excludedLineIds={new Set()}
+            onToggle={onToggle}
+            onToggleLine={onToggleLine}
+            onToggleAll={jest.fn()}
+            t={t}
+          />,
+        );
+        fireEvent.click(findExpandButton(container, 'inv-1'));
+
+        const lineCheckbox = screen.getAllByRole('checkbox', {
+          name: /excludeItemAriaLabel/,
+        })[0];
+        fireEvent.click(lineCheckbox!);
+
+        expect(onToggleLine).toHaveBeenCalledWith('line-1', true);
+        expect(onToggle).not.toHaveBeenCalled();
+      });
+
+      it('calls onToggleLine(lineId, false) when re-checking an excluded line', () => {
+        const onToggleLine = jest.fn();
+        const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [budgetLine] })]);
+        const { container } = renderWithRouter(
+          <ReportInvoiceList
+            report={report}
+            excludedInvoiceIds={new Set()}
+            excludedLineIds={new Set(['line-1'])}
+            onToggle={jest.fn()}
+            onToggleLine={onToggleLine}
+            onToggleAll={jest.fn()}
+            t={t}
+          />,
+        );
+        fireEvent.click(findExpandButton(container, 'inv-1'));
+
+        const lineCheckbox = screen.getAllByRole('checkbox', {
+          name: /excludeItemAriaLabel/,
+        })[0] as HTMLInputElement;
+        expect(lineCheckbox.checked).toBe(false);
+        fireEvent.click(lineCheckbox);
+
+        expect(onToggleLine).toHaveBeenCalledWith('line-1', false);
+      });
+    });
+
+    describe('deposits sub-table', () => {
+      it('renders a row per deposit with amount, status, dates, and entry type', () => {
+        const report = makeReport([
+          makeInvoice({
+            invoiceId: 'inv-1',
+            budgetLines: [],
+            deposits: [{ ...deposit, status: 'paid', paidDate: '2026-01-20' }],
+          }),
+        ]);
+        const { container } = renderWithRouter(
+          <ReportInvoiceList
+            report={report}
+            excludedInvoiceIds={new Set()}
+            excludedLineIds={new Set()}
+            onToggle={jest.fn()}
+            onToggleLine={jest.fn()}
+            onToggleAll={jest.fn()}
+            t={t}
+          />,
+        );
+        fireEvent.click(findExpandButton(container, 'inv-1'));
+
+        expect(screen.getAllByText('€50.00').length).toBeGreaterThan(0);
+        expect(screen.getAllByText('sources.lines.invoiceStatus.paid').length).toBeGreaterThan(0);
+        expect(screen.getAllByText('sourceReports.expand.entryTypeDeposit').length).toBeGreaterThan(
+          0,
+        );
+      });
+
+      it('displays a refund badge and negates the amount for a refund-type deposit', () => {
+        const report = makeReport([
+          makeInvoice({
+            invoiceId: 'inv-1',
+            budgetLines: [],
+            deposits: [{ ...deposit, amount: 75, entryType: 'refund' }],
+          }),
+        ]);
+        const { container } = renderWithRouter(
+          <ReportInvoiceList
+            report={report}
+            excludedInvoiceIds={new Set()}
+            excludedLineIds={new Set()}
+            onToggle={jest.fn()}
+            onToggleLine={jest.fn()}
+            onToggleAll={jest.fn()}
+            t={t}
+          />,
+        );
+        fireEvent.click(findExpandButton(container, 'inv-1'));
+
+        expect(screen.getAllByText('€-75.00').length).toBeGreaterThan(0);
+        expect(screen.getAllByText('sourceReports.expand.entryTypeRefund').length).toBeGreaterThan(
+          0,
+        );
+      });
+
+      it("shows a source badge when the deposit is tagged to the report's own source", () => {
+        const report = makeReport([
+          makeInvoice({
+            invoiceId: 'inv-1',
+            budgetLines: [],
+            deposits: [{ ...deposit, budgetSourceId: 'src-1' }],
+          }),
+        ]);
+        const { container } = renderWithRouter(
+          <ReportInvoiceList
+            report={report}
+            excludedInvoiceIds={new Set()}
+            excludedLineIds={new Set()}
+            onToggle={jest.fn()}
+            onToggleLine={jest.fn()}
+            onToggleAll={jest.fn()}
+            t={t}
+          />,
+        );
+        fireEvent.click(findExpandButton(container, 'inv-1'));
+
+        // The report's own source name ("Home Loan" per makeReport fixture) is used as the badge label.
+        expect(screen.getAllByText('Home Loan').length).toBeGreaterThan(0);
+      });
+
+      it('renders an em-dash instead of a badge when a deposit is untagged (budgetSourceId null)', () => {
+        const report = makeReport([
+          makeInvoice({
+            invoiceId: 'inv-1',
+            budgetLines: [],
+            deposits: [{ ...deposit, budgetSourceId: null }],
+          }),
+        ]);
+        const { container } = renderWithRouter(
+          <ReportInvoiceList
+            report={report}
+            excludedInvoiceIds={new Set()}
+            excludedLineIds={new Set()}
+            onToggle={jest.fn()}
+            onToggleLine={jest.fn()}
+            onToggleAll={jest.fn()}
+            t={t}
+          />,
+        );
+        fireEvent.click(findExpandButton(container, 'inv-1'));
+
+        expect(screen.getByText('—')).toBeInTheDocument();
+      });
+
+      it('renders an EmptyState for the deposits sub-table when deposits is empty', () => {
+        const report = makeReport([
+          makeInvoice({ invoiceId: 'inv-1', budgetLines: [budgetLine], deposits: [] }),
+        ]);
+        const { container } = renderWithRouter(
+          <ReportInvoiceList
+            report={report}
+            excludedInvoiceIds={new Set()}
+            excludedLineIds={new Set()}
+            onToggle={jest.fn()}
+            onToggleLine={jest.fn()}
+            onToggleAll={jest.fn()}
+            t={t}
+          />,
+        );
+        fireEvent.click(findExpandButton(container, 'inv-1'));
+
+        expect(screen.getByText('sourceReports.expand.depositsEmpty')).toBeInTheDocument();
+      });
+    });
+  });
+
+  describe('parent TriStateCheckbox (invoice-level, driven by line exclusions)', () => {
+    const lineA = { id: 'line-a', description: 'A', allocatedPortion: 300, linkedItem: null };
+    const lineB = { id: 'line-b', description: 'B', allocatedPortion: 200, linkedItem: null };
+
+    it('state 1 (checked): invoice not excluded and no lines excluded', () => {
+      const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [lineA, lineB] })]);
+      renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+      const rowCheckboxes = screen.getAllByRole('checkbox') as HTMLInputElement[];
+      // index 0 = header, index 1 = the single invoice row's parent checkbox
+      expect(rowCheckboxes[1]!.checked).toBe(true);
+      expect(rowCheckboxes[1]!.indeterminate).toBe(false);
+    });
+
+    it('state 2 (indeterminate): invoice not excluded, SOME (not all) lines excluded', () => {
+      const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [lineA, lineB] })]);
+      renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set(['line-a'])}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+      const rowCheckboxes = screen.getAllByRole('checkbox') as HTMLInputElement[];
+      expect(rowCheckboxes[1]!.indeterminate).toBe(true);
+      expect(rowCheckboxes[1]!.checked).toBe(false);
+    });
+
+    it('state 3 (unchecked, but invoice remains included): ALL lines excluded, invoice itself not excluded — checkbox reads unchecked, not indeterminate', () => {
+      const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [lineA, lineB] })]);
+      renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set(['line-a', 'line-b'])}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+      const rowCheckboxes = screen.getAllByRole('checkbox') as HTMLInputElement[];
+      expect(rowCheckboxes[1]!.checked).toBe(false);
+      expect(rowCheckboxes[1]!.indeterminate).toBe(false);
+      // The invoice is still present in the (allocated, selectable) list — not moved to
+      // excluded/unallocated — since excludedInvoiceIds does not contain it.
+      expect(screen.getByText('ACME Builders')).toBeInTheDocument();
+    });
+
+    it('clicking the parent checkbox calls onToggle for the INVOICE, never onToggleLine — even with lines excluded', () => {
+      const onToggle = jest.fn();
+      const onToggleLine = jest.fn();
+      const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [lineA, lineB] })]);
+      renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set(['line-a'])}
+          onToggle={onToggle}
+          onToggleLine={onToggleLine}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+      const rowCheckboxes = screen.getAllByRole('checkbox');
+      // The parent checkbox reflects the indeterminate/unchecked visual state (some lines
+      // excluded), so clicking it fires a native checked=true change event — which maps to
+      // onToggle(id, false) (i.e. "un-exclude the invoice"). The key assertion here is that
+      // ONLY onToggle fires (never onToggleLine), regardless of direction.
+      fireEvent.click(rowCheckboxes[1]!);
+
+      expect(onToggle).toHaveBeenCalledWith('inv-1', false);
+      expect(onToggleLine).not.toHaveBeenCalled();
+    });
+
+    it('an invoice with zero budgetLines is always in the "checked" tri-state (excludedLineCount === 0 vacuously)', () => {
+      const report = makeReport([makeInvoice({ invoiceId: 'inv-1', budgetLines: [] })]);
+      renderWithRouter(
+        <ReportInvoiceList
+          report={report}
+          excludedInvoiceIds={new Set()}
+          excludedLineIds={new Set()}
+          onToggle={jest.fn()}
+          onToggleLine={jest.fn()}
+          onToggleAll={jest.fn()}
+          t={t}
+        />,
+      );
+      const rowCheckboxes = screen.getAllByRole('checkbox') as HTMLInputElement[];
+      expect(rowCheckboxes[1]!.checked).toBe(true);
+      expect(rowCheckboxes[1]!.indeterminate).toBe(false);
+    });
   });
 });
diff --git a/client/src/components/reports/ReportInvoiceList.tsx b/client/src/components/reports/ReportInvoiceList.tsx
index c838d15e9..ce176f503 100644
--- a/client/src/components/reports/ReportInvoiceList.tsx
+++ b/client/src/components/reports/ReportInvoiceList.tsx
@@ -1,4 +1,5 @@
-import { useMemo, useState } from 'react';
+import { useMemo, useState, useEffect, useRef } from 'react';
+import { Link } from 'react-router-dom';
 import type { TFunction } from 'i18next';
 import type { SourceReportResponse, InvoiceStatus } from '@cornerstone/shared';
 import type { BadgeVariantMap } from '../Badge/Badge.js';
@@ -8,26 +9,34 @@ import { SelectionActionBar } from '../SelectionActionBar/SelectionActionBar.js'
 import { Tooltip } from '../Tooltip/Tooltip.js';
 import { EmptyState } from '../EmptyState/EmptyState.js';
 import { useFormatters } from '../../lib/formatters.js';
+import { getSourceBadgeStyleKey } from '../../lib/budgetSourceColors.js';
 import BadgeStyles from '../Badge/Badge.module.css';
 import styles from './ReportInvoiceList.module.css';
 
 interface ReportInvoiceListProps {
   report: SourceReportResponse;
   excludedInvoiceIds: Set<string>;
+  excludedLineIds: Set<string>;
   onToggle: (invoiceId: string, excluded: boolean) => void;
   onToggleAll: (excludeAll: boolean) => void;
+  onToggleLine: (lineId: string, excluded: boolean) => void;
   t: TFunction;
 }
 
 export function ReportInvoiceList({
   report,
   excludedInvoiceIds,
+  excludedLineIds,
   onToggle,
   onToggleAll,
+  onToggleLine,
   t,
 }: ReportInvoiceListProps) {
-  const { formatCurrency } = useFormatters();
+  const { formatCurrency, formatDate } = useFormatters();
   const [unallocatedExpanded, setUnallocatedExpanded] = useState(false);
+  const [expandedInvoiceIds, setExpandedInvoiceIds] = useState<Set<string>>(() => new Set());
+  const lastExpandedIdRef = useRef<string | null>(null);
+  const expandPanelRefsRef = useRef<Map<string, HTMLDivElement>>(new Map());
 
   // Invoice status badge variants
   const invoiceStatusVariants = useMemo((): BadgeVariantMap => {
@@ -45,7 +54,11 @@ export function ReportInvoiceList({
   const allocatedInvoices = useMemo(
     () =>
       report.invoices.filter(
-        (inv) => inv.allocatedAmount > 0 || inv.lineKind === 'refund-adjustment',
+        (inv) =>
+          inv.allocatedAmount > 0 ||
+          inv.lineKind === 'refund-adjustment' ||
+          inv.budgetLines.length > 0 ||
+          inv.deposits.length > 0,
       ),
     [report.invoices],
   );
@@ -72,6 +85,39 @@ export function ReportInvoiceList({
     onToggleAll(selectedCount === allocatedInvoices.length);
   };
 
+  const toggleExpand = (invoiceId: string) => {
+    setExpandedInvoiceIds((prev) => {
+      const next = new Set(prev);
+      const isCurrentlyOpen = next.has(invoiceId);
+      if (isCurrentlyOpen) {
+        next.delete(invoiceId);
+      } else {
+        next.add(invoiceId);
+        // Only update lastExpandedIdRef when opening (not closing)
+        lastExpandedIdRef.current = invoiceId;
+      }
+      return next;
+    });
+  };
+
+  const handleExpandKeyDown = (e: React.KeyboardEvent, invoiceId: string) => {
+    if (e.key === 'Enter' || e.key === ' ') {
+      e.preventDefault();
+      toggleExpand(invoiceId);
+    }
+  };
+
+  // Focus panel on genuine open transition (not on collapse)
+  useEffect(() => {
+    const lastExpandedId = lastExpandedIdRef.current;
+    if (lastExpandedId && expandedInvoiceIds.has(lastExpandedId)) {
+      const panelRef = expandPanelRefsRef.current.get(lastExpandedId);
+      if (panelRef) {
+        panelRef.focus();
+      }
+    }
+  }, [expandedInvoiceIds]);
+
   if (allocatedInvoices.length === 0 && unallocatedInvoices.length === 0) {
     return (
       <EmptyState
@@ -85,7 +131,8 @@ export function ReportInvoiceList({
     <div className={styles.invoiceListContainer}>
       {/* Header with select-all */}
       <div className={styles.listHeader}>
-        <div className={styles.headerCheckbox}>
+        <span aria-hidden="true" />
+        <div className={`${styles.headerCheckbox} ${styles.checkboxWithContent}`}>
           <TriStateCheckbox
             checked={selectedCount === allocatedInvoices.length && allocatedInvoices.length > 0}
             indeterminate={selectedCount > 0 && selectedCount < allocatedInvoices.length}
@@ -100,69 +147,36 @@ export function ReportInvoiceList({
       {allocatedInvoices.map((invoice) => {
         const isExcluded = excludedInvoiceIds.has(invoice.invoiceId);
         const hasDocuments = (invoice.documents && invoice.documents.length > 0) || false;
+        const isExpanded = expandedInvoiceIds.has(invoice.invoiceId);
+        const isExpandable = invoice.budgetLines.length > 0 || invoice.deposits.length > 0;
 
-        return (
-          <div key={invoice.invoiceId} className={styles.invoiceRow}>
-            <label className={styles.checkboxWithContent}>
-              <input
-                type="checkbox"
-                className={styles.checkbox}
-                checked={!isExcluded}
-                onChange={(e) => onToggle(invoice.invoiceId, !e.target.checked)}
-                aria-label={t('sourceReports.toggleInvoice', {
-                  vendor: invoice.vendorName,
-                  number: invoice.invoiceNumber,
-                })}
-              />
-
-              <div className={styles.vendorInfo}>
-                <div className={styles.vendorName}>{invoice.vendorName}</div>
-                <div className={styles.invoiceDate}>
-                  {t('sourceReports.table.invoiceNumber')}: {invoice.invoiceNumber}
-                </div>
-              </div>
-            </label>
-
-            <Badge variants={invoiceStatusVariants} value={invoice.status} />
+        // Tri-state logic: indeterminate if some but not all lines are excluded
+        const excludedLineCount = invoice.budgetLines.filter((l) =>
+          excludedLineIds.has(l.id),
+        ).length;
+        const isTriStateIndeterminate =
+          !isExcluded && excludedLineCount > 0 && excludedLineCount < invoice.budgetLines.length;
+        const isTriStateChecked = !isExcluded && excludedLineCount === 0;
 
-            <div className={styles.amountColumn}>
-              {invoice.lineKind === 'refund-adjustment' ? (
-                <div>
-                  <Badge
-                    variants={{
-                      refund: { label: t('sourceReports.refund'), className: styles.refund },
-                    }}
-                    value="refund"
-                  />
-                  <div className={`${styles.amount} ${styles.amountNegative}`}>
-                    {formatCurrency(invoice.allocatedAmount)}
-                  </div>
-                </div>
-              ) : (
-                <div className={styles.amount}>{formatCurrency(invoice.allocatedAmount)}</div>
-              )}
-            </div>
-
-            <div className={styles.attachmentColumn}>
-              {invoice.isSplit && (
-                <Tooltip content={t('sourceReports.splitTooltip')}>
-                  <Badge
-                    variants={{
-                      split: {
-                        label: t('sourceReports.splitBadge', {
-                          allocated: formatCurrency(invoice.allocatedAmount),
-                          total: formatCurrency(invoice.invoiceAmount),
-                        }),
-                        className: BadgeStyles.info,
-                      },
-                    }}
-                    value="split"
-                  />
-                </Tooltip>
-              )}
-              {hasDocuments ? (
-                <div className={styles.paperclip}>
+        return (
+          <div key={invoice.invoiceId}>
+            <div className={styles.invoiceRow}>
+              {isExpandable ? (
+                <button
+                  type="button"
+                  onClick={() => toggleExpand(invoice.invoiceId)}
+                  onKeyDown={(e) => handleExpandKeyDown(e, invoice.invoiceId)}
+                  className={styles.expandButton}
+                  aria-expanded={isExpanded}
+                  aria-controls={`invoice-expand-${invoice.invoiceId}`}
+                  aria-label={
+                    isExpanded
+                      ? t('sourceReports.expand.collapseInvoice')
+                      : t('sourceReports.expand.expandInvoice')
+                  }
+                >
                   <svg
+                    className={`${styles.chevron} ${isExpanded ? styles.chevronOpen : ''}`}
                     width="16"
                     height="16"
                     viewBox="0 0 24 24"
@@ -171,14 +185,451 @@ export function ReportInvoiceList({
                     strokeWidth="2"
                     aria-hidden="true"
                   >
-                    <path d="M21.5 2v6h-6M2.5 22v-6h6M2 11.5a10 10 0 0 1 18.8-4.3M22 12.5a10 10 0 0 1-18.8 2.2" />
+                    <polyline points="6 9 12 15 18 9" />
                   </svg>
-                  <span className={styles.srOnly}>{t('sourceReports.hasAttachment')}</span>
-                </div>
+                </button>
               ) : (
-                <div className={styles.noDocument}>{t('sourceReports.noDocument')}</div>
+                <span aria-hidden="true" />
               )}
+
+              <label className={styles.checkboxWithContent}>
+                <TriStateCheckbox
+                  checked={isTriStateChecked}
+                  indeterminate={isTriStateIndeterminate}
+                  onChange={(checked) => onToggle(invoice.invoiceId, !checked)}
+                  label=""
+                />
+
+                <div className={styles.vendorInfo}>
+                  <div className={styles.vendorName}>{invoice.vendorName}</div>
+                  <div className={styles.invoiceDate}>
+                    {t('sourceReports.table.invoiceNumber')}: {invoice.invoiceNumber}
+                  </div>
+                </div>
+              </label>
+
+              <Badge
+                className={styles.statusChip}
+                variants={invoiceStatusVariants}
+                value={invoice.status}
+              />
+
+              <div className={styles.amountColumn}>
+                {invoice.lineKind === 'refund-adjustment' ? (
+                  <div>
+                    <Badge
+                      variants={{
+                        refund: { label: t('sourceReports.refund'), className: styles.refund },
+                      }}
+                      value="refund"
+                    />
+                    <div className={`${styles.amount} ${styles.amountNegative}`}>
+                      {formatCurrency(invoice.allocatedAmount)}
+                    </div>
+                  </div>
+                ) : (
+                  <div className={styles.amount}>{formatCurrency(invoice.allocatedAmount)}</div>
+                )}
+              </div>
+
+              <div className={styles.attachmentColumn}>
+                {invoice.isSplit && (
+                  <Tooltip content={t('sourceReports.splitTooltip')}>
+                    <Badge
+                      variants={{
+                        split: {
+                          label: t('sourceReports.splitBadge', {
+                            allocated: formatCurrency(invoice.allocatedAmount),
+                            total: formatCurrency(invoice.invoiceAmount),
+                          }),
+                          className: BadgeStyles.info,
+                        },
+                      }}
+                      value="split"
+                    />
+                  </Tooltip>
+                )}
+                {hasDocuments ? (
+                  <div className={styles.paperclip}>
+                    <svg
+                      width="16"
+                      height="16"
+                      viewBox="0 0 24 24"
+                      fill="none"
+                      stroke="currentColor"
+                      strokeWidth="2"
+                      aria-hidden="true"
+                    >
+                      <path d="M21.5 2v6h-6M2.5 22v-6h6M2 11.5a10 10 0 0 1 18.8-4.3M22 12.5a10 10 0 0 1-18.8 2.2" />
+                    </svg>
+                    <span className={styles.srOnly}>{t('sourceReports.hasAttachment')}</span>
+                  </div>
+                ) : (
+                  <div className={styles.noDocument}>{t('sourceReports.noDocument')}</div>
+                )}
+              </div>
             </div>
+
+            {/* Expansion panel - items sub-table */}
+            {isExpanded && isExpandable && (
+              <div
+                className={styles.expansionPanel}
+                id={`invoice-expand-${invoice.invoiceId}`}
+                tabIndex={-1}
+                ref={(el) => {
+                  if (el) expandPanelRefsRef.current.set(invoice.invoiceId, el);
+                }}
+              >
+                {/* Items sub-table */}
+                {invoice.budgetLines.length > 0 ? (
+                  <div className={styles.subTableSection}>
+                    <h4
+                      className={styles.subTableHeading}
+                      id={`items-heading-${invoice.invoiceId}`}
+                    >
+                      {t('sourceReports.expand.itemsHeading')}
+                    </h4>
+                    {/* Desktop table */}
+                    <div className={styles.tableWrapper}>
+                      <table
+                        className={styles.table}
+                        aria-labelledby={`items-heading-${invoice.invoiceId}`}
+                      >
+                        <thead>
+                          <tr>
+                            <th>{t('sourceReports.expand.itemColumnHeader')}</th>
+                            <th>{t('sourceReports.expand.linkedColumnHeader')}</th>
+                            <th>{t('sourceReports.expand.allocatedColumnHeader')}</th>
+                            <th>{t('sourceReports.expand.includeColumnHeader')}</th>
+                          </tr>
+                        </thead>
+                        <tbody>
+                          {invoice.budgetLines.map((line) => {
+                            const isLineExcluded = excludedLineIds.has(line.id);
+                            return (
+                              <tr key={line.id}>
+                                <td>{line.description || t('sourceReports.expand.unnamedLine')}</td>
+                                <td>
+                                  {line.linkedItem ? (
+                                    <Link
+                                      to={
+                                        line.linkedItem.type === 'work_item'
+                                          ? `/project/work-items/${line.linkedItem.id}`
+                                          : `/household-items/${line.linkedItem.id}`
+                                      }
+                                      className={styles.linkedItemLink}
+                                    >
+                                      {line.linkedItem.name}
+                                    </Link>
+                                  ) : (
+                                    <Badge
+                                      variants={{
+                                        unassigned: {
+                                          label: t('sourceReports.unassigned'),
+                                          className: BadgeStyles.iblUnassigned,
+                                        },
+                                      }}
+                                      value="unassigned"
+                                    />
+                                  )}
+                                </td>
+                                <td>{formatCurrency(line.allocatedPortion)}</td>
+                                <td>
+                                  <input
+                                    type="checkbox"
+                                    className={styles.checkbox}
+                                    checked={!isLineExcluded}
+                                    onChange={(e) => onToggleLine(line.id, !e.target.checked)}
+                                    aria-label={t('sourceReports.expand.excludeItemAriaLabel', {
+                                      name:
+                                        line.description || t('sourceReports.expand.unnamedLine'),
+                                    })}
+                                  />
+                                </td>
+                              </tr>
+                            );
+                          })}
+                        </tbody>
+                      </table>
+                    </div>
+                    {/* Mobile card list */}
+                    <div className={styles.mobileCardList} role="list">
+                      {invoice.budgetLines.map((line) => {
+                        const isLineExcluded = excludedLineIds.has(line.id);
+                        return (
+                          <div key={line.id} className={styles.mobileCard} role="listitem">
+                            <div className={styles.mobileCardTopRow}>
+                              <span className={styles.mobileCardHeading}>
+                                {line.description || t('sourceReports.expand.unnamedLine')}
+                              </span>
+                              <span className={styles.amount}>
+                                {formatCurrency(line.allocatedPortion)}
+                              </span>
+                            </div>
+                            <div className={styles.mobileCardRow}>
+                              <span className={styles.mobileCardHeading}>
+                                {t('sourceReports.expand.linkedColumnHeader')}
+                              </span>
+                              {line.linkedItem ? (
+                                <Link
+                                  to={
+                                    line.linkedItem.type === 'work_item'
+                                      ? `/project/work-items/${line.linkedItem.id}`
+                                      : `/household-items/${line.linkedItem.id}`
+                                  }
+                                  className={styles.linkedItemLink}
+                                >
+                                  {line.linkedItem.name}
+                                </Link>
+                              ) : (
+                                <Badge
+                                  variants={{
+                                    unassigned: {
+                                      label: t('sourceReports.unassigned'),
+                                      className: BadgeStyles.iblUnassigned,
+                                    },
+                                  }}
+                                  value="unassigned"
+                                />
+                              )}
+                            </div>
+                            <div className={styles.mobileCardRow}>
+                              <label>
+                                <input
+                                  type="checkbox"
+                                  className={styles.checkbox}
+                                  checked={!isLineExcluded}
+                                  onChange={(e) => onToggleLine(line.id, !e.target.checked)}
+                                  aria-label={t('sourceReports.expand.excludeItemAriaLabel', {
+                                    name: line.description || t('sourceReports.expand.unnamedLine'),
+                                  })}
+                                />
+                                <span>{t('sourceReports.expand.includeColumnHeader')}</span>
+                              </label>
+                            </div>
+                          </div>
+                        );
+                      })}
+                    </div>
+                  </div>
+                ) : (
+                  <div className={styles.subTableSection}>
+                    <h4 className={styles.subTableHeading}>
+                      {t('sourceReports.expand.itemsHeading')}
+                    </h4>
+                    <EmptyState message={t('sourceReports.expand.itemsEmpty')} />
+                  </div>
+                )}
+
+                {/* Deposits sub-table */}
+                {invoice.deposits.length > 0 ? (
+                  <div className={`${styles.subTableSection} ${styles.subTableSeparated}`}>
+                    <h4
+                      className={styles.subTableHeading}
+                      id={`deposits-heading-${invoice.invoiceId}`}
+                    >
+                      {t('sourceReports.expand.depositsHeading')}
+                    </h4>
+                    {/* Desktop table */}
+                    <div className={styles.tableWrapper}>
+                      <table
+                        className={styles.table}
+                        aria-labelledby={`deposits-heading-${invoice.invoiceId}`}
+                      >
+                        <thead>
+                          <tr>
+                            <th>{t('sourceReports.expand.amountColumnHeader')}</th>
+                            <th>{t('sourceReports.expand.statusColumnHeader')}</th>
+                            <th>{t('sourceReports.expand.datesColumnHeader')}</th>
+                            <th>{t('sourceReports.expand.entryTypeColumnHeader')}</th>
+                            <th>{t('sourceReports.expand.allocatedSourceColumnHeader')}</th>
+                          </tr>
+                        </thead>
+                        <tbody>
+                          {invoice.deposits.map((deposit) => (
+                            <tr key={deposit.id}>
+                              <td>
+                                <div className={styles.depositAmountContainer}>
+                                  {deposit.entryType === 'refund' && (
+                                    <Badge
+                                      variants={{
+                                        refund: {
+                                          label: t('sourceReports.expand.entryTypeRefund'),
+                                          className: styles.refund,
+                                        },
+                                      }}
+                                      value="refund"
+                                    />
+                                  )}
+                                  {formatCurrency(
+                                    deposit.entryType === 'refund'
+                                      ? -deposit.amount
+                                      : deposit.amount,
+                                  )}
+                                </div>
+                              </td>
+                              <td>
+                                <Badge
+                                  variants={{
+                                    [deposit.status]: {
+                                      label: t(`sources.lines.invoiceStatus.${deposit.status}`),
+                                      className: styles[deposit.status]!,
+                                    },
+                                  }}
+                                  value={deposit.status}
+                                />
+                              </td>
+                              <td className={styles.depositDatesCell}>
+                                <div>
+                                  {t('sourceReports.expand.dueDate')}: {formatDate(deposit.dueDate)}
+                                </div>
+                                {deposit.paidDate && (
+                                  <div>
+                                    {t('sourceReports.expand.paidDate')}:{' '}
+                                    {formatDate(deposit.paidDate)}
+                                  </div>
+                                )}
+                                {deposit.claimedDate && (
+                                  <div>
+                                    {t('sourceReports.expand.claimedDate')}:{' '}
+                                    {formatDate(deposit.claimedDate)}
+                                  </div>
+                                )}
+                              </td>
+                              <td>
+                                <Badge
+                                  variants={{
+                                    [deposit.entryType]: {
+                                      label:
+                                        deposit.entryType === 'deposit'
+                                          ? t('sourceReports.expand.entryTypeDeposit')
+                                          : t('sourceReports.expand.entryTypeRefund'),
+                                      className:
+                                        deposit.entryType === 'deposit'
+                                          ? BadgeStyles.info
+                                          : styles.refund,
+                                    },
+                                  }}
+                                  value={deposit.entryType}
+                                />
+                              </td>
+                              <td>
+                                {deposit.budgetSourceId ? (
+                                  <Badge
+                                    variants={{
+                                      [deposit.budgetSourceId]: {
+                                        label: report.source.name,
+                                        className:
+                                          BadgeStyles[
+                                            getSourceBadgeStyleKey(deposit.budgetSourceId)
+                                          ] || BadgeStyles.default,
+                                      },
+                                    }}
+                                    value={deposit.budgetSourceId}
+                                  />
+                                ) : (
+                                  <span>—</span>
+                                )}
+                              </td>
+                            </tr>
+                          ))}
+                        </tbody>
+                      </table>
+                    </div>
+                    {/* Mobile card list */}
+                    <div className={styles.mobileCardList} role="list">
+                      {invoice.deposits.map((deposit) => (
+                        <div key={deposit.id} className={styles.mobileCard} role="listitem">
+                          <div className={styles.mobileCardTopRow}>
+                            <span className={styles.amount}>
+                              {formatCurrency(
+                                deposit.entryType === 'refund' ? -deposit.amount : deposit.amount,
+                              )}
+                            </span>
+                            <Badge
+                              variants={{
+                                [deposit.status]: {
+                                  label: t(`sources.lines.invoiceStatus.${deposit.status}`),
+                                  className: styles[deposit.status]!,
+                                },
+                              }}
+                              value={deposit.status}
+                            />
+                          </div>
+                          <div className={styles.mobileCardRow}>
+                            <span className={styles.mobileCardHeading}>
+                              {t('sourceReports.expand.entryTypeColumnHeader')}
+                            </span>
+                            <Badge
+                              variants={{
+                                [deposit.entryType]: {
+                                  label:
+                                    deposit.entryType === 'deposit'
+                                      ? t('sourceReports.expand.entryTypeDeposit')
+                                      : t('sourceReports.expand.entryTypeRefund'),
+                                  className:
+                                    deposit.entryType === 'deposit'
+                                      ? BadgeStyles.info
+                                      : styles.refund,
+                                },
+                              }}
+                              value={deposit.entryType}
+                            />
+                          </div>
+                          <div className={styles.mobileCardRow}>
+                            <span className={styles.mobileCardHeading}>
+                              {t('sourceReports.expand.datesColumnHeader')}
+                            </span>
+                            <div className={styles.depositDatesCell}>
+                              <div>
+                                {t('sourceReports.expand.dueDate')}: {formatDate(deposit.dueDate)}
+                              </div>
+                              {deposit.paidDate && (
+                                <div>
+                                  {t('sourceReports.expand.paidDate')}:{' '}
+                                  {formatDate(deposit.paidDate)}
+                                </div>
+                              )}
+                              {deposit.claimedDate && (
+                                <div>
+                                  {t('sourceReports.expand.claimedDate')}:{' '}
+                                  {formatDate(deposit.claimedDate)}
+                                </div>
+                              )}
+                            </div>
+                          </div>
+                          {deposit.budgetSourceId && (
+                            <div className={styles.mobileCardRow}>
+                              <span className={styles.mobileCardHeading}>
+                                {t('sourceReports.expand.allocatedSourceColumnHeader')}
+                              </span>
+                              <Badge
+                                variants={{
+                                  [deposit.budgetSourceId]: {
+                                    label: report.source.name,
+                                    className:
+                                      BadgeStyles[getSourceBadgeStyleKey(deposit.budgetSourceId)] ||
+                                      BadgeStyles.default,
+                                  },
+                                }}
+                                value={deposit.budgetSourceId}
+                              />
+                            </div>
+                          )}
+                        </div>
+                      ))}
+                    </div>
+                  </div>
+                ) : (
+                  <div className={`${styles.subTableSection} ${styles.subTableSeparated}`}>
+                    <h4 className={styles.subTableHeading}>
+                      {t('sourceReports.expand.depositsHeading')}
+                    </h4>
+                    <EmptyState message={t('sourceReports.expand.depositsEmpty')} />
+                  </div>
+                )}
+              </div>
+            )}
           </div>
         );
       })}
diff --git a/client/src/i18n/de/budget.json b/client/src/i18n/de/budget.json
index 324cf5682..0920a7fce 100644
--- a/client/src/i18n/de/budget.json
+++ b/client/src/i18n/de/budget.json
@@ -658,7 +658,12 @@
         "required": "*",
         "entryType": "Eintragsart",
         "entryTypeLabel": "Eintragsart",
-        "refundAmountHint": "Rückerstattungsbeträge werden als positive Zahl eingegeben."
+        "refundAmountHint": "Rückerstattungsbeträge werden als positive Zahl eingegeben.",
+        "budgetSource": "Budgetquelle",
+        "budgetSourceNone": "Keine (anteilig)",
+        "budgetSourceHintSingle": "Standardmäßig auf {{name}} gesetzt – die einzige Budgetquelle dieser Rechnung.",
+        "budgetSourceHintLargest": "Standardmäßig auf {{name}} gesetzt, die Quelle mit dem größten zugeordneten Anteil dieser Rechnung.",
+        "budgetSourceHintNone": "Diese Rechnung hat keine Budgetpositionen – wählen Sie eine Quelle aus, oder lassen Sie das Feld leer, um diese Abschlagszahlung anteilig zu belassen."
       },
       "entryTypeLabels": {
         "deposit": "Abschlagszahlung",
@@ -1207,7 +1212,33 @@
       "savings": "Ersparnisse",
       "other": "Sonstiges",
       "discretionary": "Diskretionär"
-    }
+    },
+    "expand": {
+      "expandInvoice": "Rechnungsdetails einblenden",
+      "collapseInvoice": "Rechnungsdetails ausblenden",
+      "itemsHeading": "Budgetpositionen",
+      "depositsHeading": "Abschlagszahlungen & Rückerstattungen",
+      "itemsEmpty": "Keine Budgetpositionen für diese Rechnung",
+      "depositsEmpty": "Keine Abschlagszahlungen oder Rückerstattungen für diese Rechnung",
+      "excludeItemAriaLabel": "{{name}} vom Bericht ausschließen",
+      "unnamedLine": "(Unbenannte Budgetposition)",
+      "linkedColumnHeader": "Verknüpft mit",
+      "itemColumnHeader": "Position",
+      "allocatedColumnHeader": "Zugeordnet",
+      "includeColumnHeader": "Einbeziehen",
+      "amountColumnHeader": "Betrag",
+      "statusColumnHeader": "Status",
+      "datesColumnHeader": "Termine",
+      "entryTypeColumnHeader": "Eintragsart",
+      "allocatedSourceColumnHeader": "Zugeordnete Quelle",
+      "entryTypeDeposit": "Abschlagszahlung",
+      "entryTypeRefund": "Rückerstattung",
+      "dueDate": "Fällig",
+      "paidDate": "Bezahlt",
+      "claimedDate": "Eingereicht"
+    },
+    "unassigned": "Nicht zugewiesen",
+    "confirmClaimExcludedItemsWarning": "{{count}} Rechnung(en) werden vollständig als eingereicht markiert, obwohl einige Positionen von diesem Bericht ausgeschlossen wurden."
   },
   "common": {
     "loading": "Wird geladen...",
diff --git a/client/src/i18n/en/budget.json b/client/src/i18n/en/budget.json
index fb94ab48d..557ef5e12 100644
--- a/client/src/i18n/en/budget.json
+++ b/client/src/i18n/en/budget.json
@@ -778,7 +778,12 @@
         "required": "*",
         "entryType": "Entry type",
         "entryTypeLabel": "Entry type",
-        "refundAmountHint": "Refund amounts are entered as a positive number."
+        "refundAmountHint": "Refund amounts are entered as a positive number.",
+        "budgetSource": "Budget source",
+        "budgetSourceNone": "None (pro-rated)",
+        "budgetSourceHintSingle": "Defaulted to {{name}} — this invoice's only budget source.",
+        "budgetSourceHintLargest": "Defaulted to {{name}}, this invoice's largest allocated source.",
+        "budgetSourceHintNone": "This invoice has no budget lines — pick a source, or leave blank to keep this deposit pro-rated."
       },
       "entryTypeLabels": {
         "deposit": "Deposit",
@@ -1207,7 +1212,33 @@
       "savings": "Savings",
       "other": "Other",
       "discretionary": "Discretionary"
-    }
+    },
+    "expand": {
+      "expandInvoice": "Expand invoice details",
+      "collapseInvoice": "Collapse invoice details",
+      "itemsHeading": "Budget Lines",
+      "depositsHeading": "Deposits & Refunds",
+      "itemsEmpty": "No budget lines for this invoice",
+      "depositsEmpty": "No deposits or refunds for this invoice",
+      "excludeItemAriaLabel": "Exclude {{name}} from report",
+      "unnamedLine": "(Unnamed budget line)",
+      "linkedColumnHeader": "Linked to",
+      "itemColumnHeader": "Item",
+      "allocatedColumnHeader": "Allocated",
+      "includeColumnHeader": "Include",
+      "amountColumnHeader": "Amount",
+      "statusColumnHeader": "Status",
+      "datesColumnHeader": "Dates",
+      "entryTypeColumnHeader": "Entry Type",
+      "allocatedSourceColumnHeader": "Allocated Source",
+      "entryTypeDeposit": "Deposit",
+      "entryTypeRefund": "Refund",
+      "dueDate": "Due",
+      "paidDate": "Paid",
+      "claimedDate": "Claimed"
+    },
+    "unassigned": "Unassigned",
+    "confirmClaimExcludedItemsWarning": "{{count}} invoice(s) will be claimed in full even though some line items are excluded from this report."
   },
   "common": {
     "loading": "Loading...",
diff --git a/client/src/lib/invoiceDepositsApi.test.ts b/client/src/lib/invoiceDepositsApi.test.ts
index 2cef9ea79..d69623a47 100644
--- a/client/src/lib/invoiceDepositsApi.test.ts
+++ b/client/src/lib/invoiceDepositsApi.test.ts
@@ -38,6 +38,7 @@ describe('invoiceDepositsApi', () => {
     description: 'Initial deposit',
     status: 'pending',
     entryType: 'deposit',
+    budgetSourceId: null,
     createdBy: null,
     createdAt: '2026-01-15T10:00:00.000Z',
     updatedAt: '2026-01-15T10:00:00.000Z',
diff --git a/client/src/lib/reportExclusions.test.ts b/client/src/lib/reportExclusions.test.ts
new file mode 100644
index 000000000..1cf7c6c75
--- /dev/null
+++ b/client/src/lib/reportExclusions.test.ts
@@ -0,0 +1,303 @@
+import { describe, it, expect } from '@jest/globals';
+import type { SourceReportResponse, SourceReportInvoice } from '@cornerstone/shared';
+import { applyLineExclusions } from './reportExclusions.js';
+
+// ─── Fixture helpers ────────────────────────────────────────────────────────
+
+function makeInvoice(overrides: Partial<SourceReportInvoice> = {}): SourceReportInvoice {
+  return {
+    invoiceId: 'inv-1',
+    vendorId: 'vendor-1',
+    vendorName: 'Test Vendor',
+    invoiceNumber: 'INV-001',
+    date: '2026-01-15',
+    status: 'paid',
+    invoiceAmount: 1000,
+    allocatedAmount: 1000,
+    lineKind: 'invoice',
+    isSplit: false,
+    documents: [],
+    budgetLines: [],
+    deposits: [],
+    ...overrides,
+  };
+}
+
+function makeReport(invoices: SourceReportInvoice[]): SourceReportResponse {
+  return {
+    type: 'claim',
+    source: {
+      id: 'src-1',
+      name: 'Test Source',
+      sourceType: 'bank_loan',
+      reference: null,
+      contactAddress: null,
+    },
+    invoices,
+    totalAmount: invoices.reduce((s, i) => s + i.allocatedAmount, 0),
+    unallocatedInvoices: [],
+    generatedAt: '2026-01-20T00:00:00.000Z',
+  };
+}
+
+describe('applyLineExclusions', () => {
+  it('no-op: empty excludedLineIds returns the exact same report object reference', () => {
+    const report = makeReport([
+      makeInvoice({
+        budgetLines: [
+          { id: 'line-1', description: 'Foundation', allocatedPortion: 500, linkedItem: null },
+        ],
+      }),
+    ]);
+
+    const result = applyLineExclusions(report, new Set());
+
+    expect(result).toBe(report); // same reference, not just deep-equal
+  });
+
+  it('single exclusion: subtracts the excluded line portion from allocatedAmount', () => {
+    const report = makeReport([
+      makeInvoice({
+        invoiceId: 'inv-1',
+        allocatedAmount: 1000,
+        budgetLines: [
+          { id: 'line-1', description: 'Foundation', allocatedPortion: 300, linkedItem: null },
+          { id: 'line-2', description: 'Roofing', allocatedPortion: 700, linkedItem: null },
+        ],
+      }),
+    ]);
+
+    const result = applyLineExclusions(report, new Set(['line-1']));
+
+    expect(result).not.toBe(report);
+    expect(result.invoices[0]!.allocatedAmount).toBe(700);
+    expect(result.invoices[0]!.lineKind).toBe('invoice');
+  });
+
+  it('all-excluded: subtracting every line drops allocatedAmount to exactly 0', () => {
+    const report = makeReport([
+      makeInvoice({
+        invoiceId: 'inv-1',
+        allocatedAmount: 1000,
+        budgetLines: [
+          { id: 'line-1', description: 'Foundation', allocatedPortion: 400, linkedItem: null },
+          { id: 'line-2', description: 'Roofing', allocatedPortion: 600, linkedItem: null },
+        ],
+      }),
+    ]);
+
+    const result = applyLineExclusions(report, new Set(['line-1', 'line-2']));
+
+    expect(result.invoices[0]!.allocatedAmount).toBe(0);
+    // 0 is not negative, so lineKind stays 'invoice' (the newAmount < 0 check is strict)
+    expect(result.invoices[0]!.lineKind).toBe('invoice');
+  });
+
+  it('sign recompute: excluding a large-enough line flips lineKind to refund-adjustment when the remainder goes negative', () => {
+    const report = makeReport([
+      makeInvoice({
+        invoiceId: 'inv-1',
+        allocatedAmount: 200,
+        budgetLines: [
+          {
+            id: 'line-1',
+            description: 'Overpaid deposit',
+            allocatedPortion: 500,
+            linkedItem: null,
+          },
+        ],
+      }),
+    ]);
+
+    const result = applyLineExclusions(report, new Set(['line-1']));
+
+    expect(result.invoices[0]!.allocatedAmount).toBe(-300);
+    expect(result.invoices[0]!.lineKind).toBe('refund-adjustment');
+  });
+
+  it('an already-negative (refund-adjustment) invoice becomes more negative when a line is excluded', () => {
+    const report = makeReport([
+      makeInvoice({
+        invoiceId: 'inv-1',
+        allocatedAmount: -300,
+        lineKind: 'refund-adjustment',
+        budgetLines: [
+          { id: 'line-1', description: 'Extra item', allocatedPortion: 100, linkedItem: null },
+        ],
+      }),
+    ]);
+
+    const result = applyLineExclusions(report, new Set(['line-1']));
+
+    expect(result.invoices[0]!.allocatedAmount).toBe(-400);
+    expect(result.invoices[0]!.lineKind).toBe('refund-adjustment');
+  });
+
+  it('an invoice with no matching excluded lines is passed through unchanged (same object reference)', () => {
+    const uninvolvedInvoice = makeInvoice({
+      invoiceId: 'inv-2',
+      allocatedAmount: 500,
+      budgetLines: [
+        { id: 'line-9', description: 'Unrelated', allocatedPortion: 500, linkedItem: null },
+      ],
+    });
+    const targetInvoice = makeInvoice({
+      invoiceId: 'inv-1',
+      allocatedAmount: 1000,
+      budgetLines: [
+        { id: 'line-1', description: 'Target', allocatedPortion: 300, linkedItem: null },
+      ],
+    });
+    const report = makeReport([targetInvoice, uninvolvedInvoice]);
+
+    const result = applyLineExclusions(report, new Set(['line-1']));
+
+    // The unrelated invoice keeps its exact object reference (excludedPortion === 0 early-return).
+    expect(result.invoices[1]).toBe(uninvolvedInvoice);
+    expect(result.invoices[0]).not.toBe(targetInvoice);
+    expect(result.invoices[0]!.allocatedAmount).toBe(700);
+  });
+
+  it('an invoice with zero budgetLines (deposit-only) is passed through unchanged even with a non-matching excludedLineIds set', () => {
+    const depositOnlyInvoice = makeInvoice({
+      invoiceId: 'inv-3',
+      allocatedAmount: 400,
+      budgetLines: [],
+      deposits: [
+        {
+          id: 'dep-1',
+          amount: 400,
+          status: 'paid',
+          entryType: 'deposit',
+          dueDate: '2026-01-01',
+          paidDate: '2026-01-05',
+          claimedDate: null,
+          budgetSourceId: 'src-1',
+        },
+      ],
+    });
+    const report = makeReport([depositOnlyInvoice]);
+
+    const result = applyLineExclusions(report, new Set(['some-other-line']));
+
+    expect(result.invoices[0]).toBe(depositOnlyInvoice);
+    expect(result.invoices[0]!.allocatedAmount).toBe(400);
+  });
+
+  it('rounds the recomputed amount to 2 decimal places (avoids floating point drift)', () => {
+    const report = makeReport([
+      makeInvoice({
+        invoiceId: 'inv-1',
+        allocatedAmount: 100.1,
+        budgetLines: [
+          { id: 'line-1', description: 'Line A', allocatedPortion: 33.33, linkedItem: null },
+        ],
+      }),
+    ]);
+
+    const result = applyLineExclusions(report, new Set(['line-1']));
+
+    // 100.1 - 33.33 = 66.77 exactly at 2dp (floating point without rounding would drift)
+    expect(result.invoices[0]!.allocatedAmount).toBe(66.77);
+  });
+
+  it('passthrough of other fields: vendorName, invoiceNumber, status, documents, isSplit, deposits remain untouched', () => {
+    const report = makeReport([
+      makeInvoice({
+        invoiceId: 'inv-1',
+        vendorName: 'Acme Builders',
+        invoiceNumber: 'INV-42',
+        status: 'claimed',
+        isSplit: true,
+        documents: [
+          {
+            documentId: 99,
+            archiveSerialNumber: 5,
+            title: 'Invoice PDF',
+            attachmentType: 'invoice',
+          },
+        ],
+        deposits: [
+          {
+            id: 'dep-1',
+            amount: 50,
+            status: 'pending',
+            entryType: 'deposit',
+            dueDate: '2026-02-01',
+            paidDate: null,
+            claimedDate: null,
+            budgetSourceId: null,
+          },
+        ],
+        allocatedAmount: 1000,
+        budgetLines: [{ id: 'line-1', description: null, allocatedPortion: 200, linkedItem: null }],
+      }),
+    ]);
+
+    const result = applyLineExclusions(report, new Set(['line-1']));
+    const inv = result.invoices[0]!;
+
+    expect(inv.vendorName).toBe('Acme Builders');
+    expect(inv.invoiceNumber).toBe('INV-42');
+    expect(inv.status).toBe('claimed');
+    expect(inv.isSplit).toBe(true);
+    expect(inv.documents).toHaveLength(1);
+    expect(inv.deposits).toHaveLength(1);
+    expect(inv.allocatedAmount).toBe(800);
+  });
+
+  it('report-level fields (type, source, totalAmount, unallocatedInvoices, generatedAt) are copied through via spread', () => {
+    const report = makeReport([
+      makeInvoice({
+        allocatedAmount: 1000,
+        budgetLines: [{ id: 'line-1', description: null, allocatedPortion: 100, linkedItem: null }],
+      }),
+    ]);
+
+    const result = applyLineExclusions(report, new Set(['line-1']));
+
+    expect(result.type).toBe(report.type);
+    expect(result.source).toBe(report.source);
+    expect(result.generatedAt).toBe(report.generatedAt);
+    // Note: totalAmount is NOT recomputed by applyLineExclusions itself — it is a pure
+    // subtraction-source utility; totalAmount recomputation (if needed) is the caller's
+    // responsibility. This test pins the current (pass-through) behavior.
+    expect(result.totalAmount).toBe(report.totalAmount);
+  });
+
+  it('multiple invoices with mixed exclusions: only affected invoices get new object references', () => {
+    const invA = makeInvoice({
+      invoiceId: 'inv-A',
+      allocatedAmount: 500,
+      budgetLines: [{ id: 'line-A1', description: null, allocatedPortion: 200, linkedItem: null }],
+    });
+    const invB = makeInvoice({
+      invoiceId: 'inv-B',
+      allocatedAmount: 300,
+      budgetLines: [{ id: 'line-B1', description: null, allocatedPortion: 100, linkedItem: null }],
+    });
+    const report = makeReport([invA, invB]);
+
+    const result = applyLineExclusions(report, new Set(['line-A1']));
+
+    expect(result.invoices[0]).not.toBe(invA);
+    expect(result.invoices[0]!.allocatedAmount).toBe(300);
+    expect(result.invoices[1]).toBe(invB);
+    expect(result.invoices[1]!.allocatedAmount).toBe(300);
+  });
+
+  it('excluding a lineId that matches no line on any invoice is a full no-op on amounts (but not a reference no-op, since size > 0)', () => {
+    const invoice = makeInvoice({
+      allocatedAmount: 1000,
+      budgetLines: [{ id: 'line-1', description: null, allocatedPortion: 500, linkedItem: null }],
+    });
+    const report = makeReport([invoice]);
+
+    const result = applyLineExclusions(report, new Set(['line-does-not-exist']));
+
+    // excludedLineIds.size > 0, so the top-level early-return doesn't trigger, but the
+    // invoice-level early-return (excludedPortion === 0) does — same invoice reference.
+    expect(result.invoices[0]).toBe(invoice);
+    expect(result.invoices[0]!.allocatedAmount).toBe(1000);
+  });
+});
diff --git a/client/src/lib/reportExclusions.ts b/client/src/lib/reportExclusions.ts
new file mode 100644
index 000000000..3ae9357b4
--- /dev/null
+++ b/client/src/lib/reportExclusions.ts
@@ -0,0 +1,38 @@
+import type { SourceReportResponse } from '@cornerstone/shared';
+
+/**
+ * Applies line-level exclusions to a source report, adjusting invoice amounts.
+ * Pure function: returns the same object reference if no exclusions, preventing unnecessary re-renders.
+ *
+ * @param report The source report to filter
+ * @param excludedLineIds Set of budget line IDs to exclude from calculations
+ * @returns A new report with adjusted amounts, or the original report if no exclusions
+ */
+export function applyLineExclusions(
+  report: SourceReportResponse,
+  excludedLineIds: Set<string>,
+): SourceReportResponse {
+  if (excludedLineIds.size === 0) return report;
+
+  return {
+    ...report,
+    invoices: report.invoices.map((inv) => {
+      // Calculate total portion of excluded lines for this invoice
+      const excludedPortion = inv.budgetLines
+        .filter((l) => excludedLineIds.has(l.id))
+        .reduce((s, l) => s + l.allocatedPortion, 0);
+
+      // If no exclusions affect this invoice, return it unchanged
+      if (excludedPortion === 0) return inv;
+
+      // Recalculate allocated amount and lineKind based on new amount
+      const newAmount = Math.round((inv.allocatedAmount - excludedPortion) * 100) / 100;
+
+      return {
+        ...inv,
+        allocatedAmount: newAmount,
+        lineKind: newAmount < 0 ? 'refund-adjustment' : 'invoice',
+      };
+    }),
+  };
+}
diff --git a/client/src/lib/reportPdf/merge.test.ts b/client/src/lib/reportPdf/merge.test.ts
index a921bd316..8263ad487 100644
--- a/client/src/lib/reportPdf/merge.test.ts
+++ b/client/src/lib/reportPdf/merge.test.ts
@@ -172,6 +172,8 @@ function makeInvoice(overrides: Partial<SourceReportInvoice> = {}): SourceReport
     lineKind: 'invoice',
     isSplit: false,
     documents: [],
+    budgetLines: [],
+    deposits: [],
     ...overrides,
   };
 }
diff --git a/client/src/lib/reportPdf/overviewPdf.test.ts b/client/src/lib/reportPdf/overviewPdf.test.ts
index de0bf7029..0fd8caed2 100644
--- a/client/src/lib/reportPdf/overviewPdf.test.ts
+++ b/client/src/lib/reportPdf/overviewPdf.test.ts
@@ -55,6 +55,8 @@ function makeInvoice(overrides: Partial<SourceReportInvoice> = {}): SourceReport
     lineKind: 'invoice',
     isSplit: false,
     documents: [],
+    budgetLines: [],
+    deposits: [],
     ...overrides,
   };
 }
diff --git a/client/src/lib/reportPdf/realRender.test.ts b/client/src/lib/reportPdf/realRender.test.ts
index ebf5aae0a..62abc8dc0 100644
--- a/client/src/lib/reportPdf/realRender.test.ts
+++ b/client/src/lib/reportPdf/realRender.test.ts
@@ -103,6 +103,8 @@ function makeInvoice(overrides: Partial<SourceReportInvoice> = {}): SourceReport
     lineKind: 'invoice',
     isSplit: false,
     documents: [],
+    budgetLines: [],
+    deposits: [],
     ...overrides,
   };
 }
diff --git a/client/src/pages/InvoiceDetailPage/InvoiceDepositsSection.test.tsx b/client/src/pages/InvoiceDetailPage/InvoiceDepositsSection.test.tsx
index 9359bc421..d21b31c26 100644
--- a/client/src/pages/InvoiceDetailPage/InvoiceDepositsSection.test.tsx
+++ b/client/src/pages/InvoiceDetailPage/InvoiceDepositsSection.test.tsx
@@ -4,8 +4,14 @@
 import { jest, describe, it, expect, beforeEach, afterEach } from '@jest/globals';
 import { render, screen, waitFor, fireEvent, act } from '@testing-library/react';
 import type * as InvoiceDepositsApiTypes from '../../lib/invoiceDepositsApi.js';
+import type * as BudgetSourcesApiTypes from '../../lib/budgetSourcesApi.js';
+import type * as InvoiceBudgetLinesApiTypes from '../../lib/invoiceBudgetLinesApi.js';
 import type * as InvoiceDepositsSectionTypes from './InvoiceDepositsSection.js';
-import type { InvoiceDeposit } from '@cornerstone/shared';
+import type {
+  InvoiceDeposit,
+  BudgetSource,
+  InvoiceBudgetLineDetailResponse,
+} from '@cornerstone/shared';
 
 // ─── Module-scope mock functions ───────────────────────────────────────────────
 
@@ -23,6 +29,21 @@ jest.unstable_mockModule('../../lib/invoiceDepositsApi.js', () => ({
   deleteDeposit: mockDeleteDeposit,
 }));
 
+// ─── Mock: budgetSourcesApi (Story #1891 — deposit budget-source picker) ──────
+
+const mockFetchBudgetSources = jest.fn<typeof BudgetSourcesApiTypes.fetchBudgetSources>();
+jest.unstable_mockModule('../../lib/budgetSourcesApi.js', () => ({
+  fetchBudgetSources: mockFetchBudgetSources,
+}));
+
+// ─── Mock: invoiceBudgetLinesApi (Story #1891 — auto-default source logic) ────
+
+const mockFetchInvoiceBudgetLines =
+  jest.fn<typeof InvoiceBudgetLinesApiTypes.fetchInvoiceBudgetLines>();
+jest.unstable_mockModule('../../lib/invoiceBudgetLinesApi.js', () => ({
+  fetchInvoiceBudgetLines: mockFetchInvoiceBudgetLines,
+}));
+
 // ─── Mock: apiClient (provides ApiClientError class) ──────────────────────────
 
 class MockApiClientError extends Error {
@@ -169,6 +190,7 @@ function makeDeposit(id: string, overrides: Partial<InvoiceDeposit> = {}): Invoi
     description: null,
     status: 'pending',
     entryType: 'deposit',
+    budgetSourceId: null,
     createdBy: null,
     createdAt: '2026-01-01T00:00:00Z',
     updatedAt: '2026-01-01T00:00:00Z',
@@ -176,6 +198,35 @@ function makeDeposit(id: string, overrides: Partial<InvoiceDeposit> = {}): Invoi
   };
 }
 
+function makeBudgetSource(id: string, overrides: Partial<BudgetSource> = {}): BudgetSource {
+  return {
+    id,
+    name: `Source ${id}`,
+    sourceType: 'bank_loan',
+    totalAmount: 100000,
+    usedAmount: 0,
+    availableAmount: 100000,
+    claimedAmount: 0,
+    unclaimedAmount: 0,
+    paidAmount: 0,
+    actualAvailableAmount: 100000,
+    projectedAmount: 0,
+    projectedMinAmount: 0,
+    projectedMaxAmount: 0,
+    interestRate: null,
+    terms: null,
+    notes: null,
+    reference: null,
+    contactAddress: null,
+    status: 'active',
+    isDiscretionary: false,
+    createdBy: null,
+    createdAt: '2026-01-01T00:00:00.000Z',
+    updatedAt: '2026-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
 function renderSection(
   deposits: InvoiceDeposit[] = [],
   opts: {
@@ -203,10 +254,46 @@ function renderSection(
 
 // ─── Setup ────────────────────────────────────────────────────────────────────
 
+function makeInvoiceBudgetLine(
+  id: string,
+  overrides: Partial<InvoiceBudgetLineDetailResponse> = {},
+): InvoiceBudgetLineDetailResponse {
+  return {
+    id,
+    invoiceId: INVOICE_ID,
+    workItemBudgetId: 'wib-1',
+    householdItemBudgetId: null,
+    itemizedAmount: 100,
+    budgetLineDescription: null,
+    plannedAmount: 100,
+    confidence: 'own_estimate',
+    categoryId: null,
+    categoryName: null,
+    categoryColor: null,
+    categoryTranslationKey: null,
+    parentItemId: null,
+    parentItemTitle: null,
+    parentItemType: 'work_item',
+    parentItemArea: null,
+    quantity: null,
+    unit: null,
+    unitPrice: null,
+    includesVat: false,
+    vendorId: null,
+    budgetSourceId: null,
+    createdAt: '2026-01-01T00:00:00.000Z',
+    updatedAt: '2026-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
 beforeEach(async () => {
   const mod = await import('./InvoiceDepositsSection.js');
   InvoiceDepositsSection = mod.InvoiceDepositsSection;
   jest.clearAllMocks();
+  // Default: no budget sources / budget lines configured. Individual picker tests override this.
+  mockFetchBudgetSources.mockResolvedValue({ budgetSources: [] });
+  mockFetchInvoiceBudgetLines.mockResolvedValue({ budgetLines: [], remainingAmount: 0 });
 });
 
 afterEach(() => {
@@ -1566,4 +1653,454 @@ describe('InvoiceDepositsSection', () => {
       expect(matched).toBe(true);
     });
   });
+
+  // ─── Story #1891: budget-source picker + auto-default logic ────────────────
+
+  describe('budget-source picker (Story #1891)', () => {
+    async function flushBudgetDataLoad() {
+      // Both fetchBudgetSources and fetchInvoiceBudgetLines resolve on the microtask queue;
+      // waiting only for "has been called" can race ahead of the state updates that follow
+      // (setBudgetSources/setBudgetLines), which openAddModal's auto-default logic reads
+      // synchronously at click time. Flush pending microtasks/effects inside act() so the
+      // component has fully settled before any test opens the Add modal.
+      await act(async () => {
+        await Promise.resolve();
+        await Promise.resolve();
+        await Promise.resolve();
+      });
+    }
+
+    function openAddModalAfterLoad() {
+      const addBtn = screen
+        .getAllByRole('button')
+        .find(
+          (b) =>
+            b.getAttribute('aria-label')?.includes('deposit') ?? b.textContent?.includes('deposit'),
+        )!;
+      fireEvent.click(addBtn);
+    }
+
+    it('fetches budget sources and budget lines on mount', async () => {
+      mockFetchBudgetSources.mockResolvedValue({ budgetSources: [makeBudgetSource('src-1')] });
+      mockFetchInvoiceBudgetLines.mockResolvedValue({ budgetLines: [], remainingAmount: 1000 });
+
+      renderSection([]);
+
+      await waitFor(() => {
+        expect(mockFetchBudgetSources).toHaveBeenCalledTimes(1);
+        expect(mockFetchInvoiceBudgetLines).toHaveBeenCalledWith(INVOICE_ID);
+      });
+    });
+
+    it('populates the picker <select> with every fetched budget source, plus a "None" option', async () => {
+      mockFetchBudgetSources.mockResolvedValue({
+        budgetSources: [
+          makeBudgetSource('src-1', { name: 'Bank Loan' }),
+          makeBudgetSource('src-2', { name: 'Savings' }),
+        ],
+      });
+      renderSection([]);
+      await flushBudgetDataLoad();
+
+      openAddModalAfterLoad();
+
+      const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+      const optionLabels = Array.from(select.options).map((o) => o.textContent);
+      expect(optionLabels).toEqual(['None (pro-rated)', 'Bank Loan', 'Savings']);
+    });
+
+    describe('default case 1: zero sources (no budget lines) → null default + HintNone', () => {
+      it('defaults budgetSourceId to null and shows the "no budget lines" hint', async () => {
+        mockFetchBudgetSources.mockResolvedValue({ budgetSources: [makeBudgetSource('src-1')] });
+        mockFetchInvoiceBudgetLines.mockResolvedValue({ budgetLines: [], remainingAmount: 1000 });
+
+        renderSection([]);
+        await flushBudgetDataLoad();
+
+        openAddModalAfterLoad();
+
+        const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+        expect(select.value).toBe('');
+        expect(
+          screen.getByText(
+            'This invoice has no budget lines — pick a source, or leave blank to keep this deposit pro-rated.',
+          ),
+        ).toBeInTheDocument();
+      });
+
+      it('all-unassigned budget lines (no real source on any line) also default to null (treated as zero real sources)', async () => {
+        mockFetchBudgetSources.mockResolvedValue({ budgetSources: [makeBudgetSource('src-1')] });
+        mockFetchInvoiceBudgetLines.mockResolvedValue({
+          budgetLines: [
+            makeInvoiceBudgetLine('ibl-1', { budgetSourceId: null, itemizedAmount: 500 }),
+          ],
+          remainingAmount: 500,
+        });
+
+        renderSection([]);
+        await flushBudgetDataLoad();
+
+        openAddModalAfterLoad();
+
+        const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+        expect(select.value).toBe('');
+      });
+    });
+
+    describe('default case 2: exactly one real source → defaults to it + HintSingle{name}', () => {
+      it("defaults budgetSourceId to the invoice's single budget-line source", async () => {
+        mockFetchBudgetSources.mockResolvedValue({
+          budgetSources: [makeBudgetSource('src-1', { name: 'Bank Loan' })],
+        });
+        mockFetchInvoiceBudgetLines.mockResolvedValue({
+          budgetLines: [
+            makeInvoiceBudgetLine('ibl-1', { budgetSourceId: 'src-1', itemizedAmount: 700 }),
+          ],
+          remainingAmount: 300,
+        });
+
+        renderSection([]);
+        await flushBudgetDataLoad();
+
+        openAddModalAfterLoad();
+
+        const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+        expect(select.value).toBe('src-1');
+        expect(
+          screen.getByText("Defaulted to Bank Loan — this invoice's only budget source."),
+        ).toBeInTheDocument();
+      });
+
+      it('a single real source PLUS an unassigned (null) line still counts as exactly one real source', async () => {
+        mockFetchBudgetSources.mockResolvedValue({
+          budgetSources: [makeBudgetSource('src-1', { name: 'Bank Loan' })],
+        });
+        mockFetchInvoiceBudgetLines.mockResolvedValue({
+          budgetLines: [
+            makeInvoiceBudgetLine('ibl-1', { budgetSourceId: 'src-1', itemizedAmount: 500 }),
+            makeInvoiceBudgetLine('ibl-2', { budgetSourceId: null, itemizedAmount: 200 }),
+          ],
+          remainingAmount: 300,
+        });
+
+        renderSection([]);
+        await flushBudgetDataLoad();
+
+        openAddModalAfterLoad();
+
+        const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+        expect(select.value).toBe('src-1');
+      });
+    });
+
+    describe('default case 3: multiple real sources → defaults to the largest-sum one + HintLargest{name}', () => {
+      it('defaults budgetSourceId to the source with the largest summed itemizedAmount', async () => {
+        mockFetchBudgetSources.mockResolvedValue({
+          budgetSources: [
+            makeBudgetSource('src-1', { name: 'Bank Loan' }),
+            makeBudgetSource('src-2', { name: 'Savings' }),
+          ],
+        });
+        mockFetchInvoiceBudgetLines.mockResolvedValue({
+          budgetLines: [
+            makeInvoiceBudgetLine('ibl-1', { budgetSourceId: 'src-1', itemizedAmount: 300 }),
+            makeInvoiceBudgetLine('ibl-2', { budgetSourceId: 'src-2', itemizedAmount: 700 }),
+          ],
+          remainingAmount: 0,
+        });
+
+        renderSection([]);
+        await flushBudgetDataLoad();
+
+        openAddModalAfterLoad();
+
+        const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+        expect(select.value).toBe('src-2'); // 700 > 300
+        expect(
+          screen.getByText("Defaulted to Savings, this invoice's largest allocated source."),
+        ).toBeInTheDocument();
+      });
+
+      it('sums MULTIPLE lines under the same source before comparing (largest-SUM, not largest single line)', async () => {
+        mockFetchBudgetSources.mockResolvedValue({
+          budgetSources: [
+            makeBudgetSource('src-1', { name: 'Bank Loan' }),
+            makeBudgetSource('src-2', { name: 'Savings' }),
+          ],
+        });
+        mockFetchInvoiceBudgetLines.mockResolvedValue({
+          budgetLines: [
+            // src-1: two small lines summing to 600
+            makeInvoiceBudgetLine('ibl-1', { budgetSourceId: 'src-1', itemizedAmount: 300 }),
+            makeInvoiceBudgetLine('ibl-2', { budgetSourceId: 'src-1', itemizedAmount: 300 }),
+            // src-2: one line of 500 (individually larger than either src-1 line, but the SUM
+            // for src-1 (600) exceeds src-2's single line (500))
+            makeInvoiceBudgetLine('ibl-3', { budgetSourceId: 'src-2', itemizedAmount: 500 }),
+          ],
+          remainingAmount: 0,
+        });
+
+        renderSection([]);
+        await flushBudgetDataLoad();
+
+        openAddModalAfterLoad();
+
+        const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+        expect(select.value).toBe('src-1'); // 600 > 500
+      });
+    });
+
+    describe('mixed real+unassigned sources where the UNASSIGNED sum is largest (Story #1891 follow-up fix)', () => {
+      it('single real source + a larger unassigned sum: still defaults to the real source and shows HintSingle with its real name (never "—")', async () => {
+        mockFetchBudgetSources.mockResolvedValue({
+          budgetSources: [makeBudgetSource('src-1', { name: 'Bank Loan' })],
+        });
+        mockFetchInvoiceBudgetLines.mockResolvedValue({
+          budgetLines: [
+            makeInvoiceBudgetLine('ibl-1', { budgetSourceId: 'src-1', itemizedAmount: 200 }),
+            // Unassigned line sum (800) is larger than the real source's sum (200), but
+            // unassigned lines must never compete for — or win — the "largest" default.
+            makeInvoiceBudgetLine('ibl-2', { budgetSourceId: null, itemizedAmount: 800 }),
+          ],
+          remainingAmount: 0,
+        });
+
+        renderSection([]);
+        await flushBudgetDataLoad();
+        openAddModalAfterLoad();
+
+        const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+        expect(select.value).toBe('src-1');
+        expect(
+          screen.getByText("Defaulted to Bank Loan — this invoice's only budget source."),
+        ).toBeInTheDocument();
+        expect(screen.queryByText('—')).not.toBeInTheDocument();
+      });
+
+      it('multiple real sources + a much larger unassigned sum: defaults to the largest REAL source and shows HintLargest with its real name (never "—")', async () => {
+        mockFetchBudgetSources.mockResolvedValue({
+          budgetSources: [
+            makeBudgetSource('src-1', { name: 'Bank Loan' }),
+            makeBudgetSource('src-2', { name: 'Savings' }),
+          ],
+        });
+        mockFetchInvoiceBudgetLines.mockResolvedValue({
+          budgetLines: [
+            makeInvoiceBudgetLine('ibl-1', { budgetSourceId: 'src-1', itemizedAmount: 200 }),
+            makeInvoiceBudgetLine('ibl-2', { budgetSourceId: 'src-2', itemizedAmount: 300 }),
+            // Unassigned sum (1000) dwarfs both real sources but must be excluded entirely
+            // from the "largest source" comparison.
+            makeInvoiceBudgetLine('ibl-3', { budgetSourceId: null, itemizedAmount: 1000 }),
+          ],
+          remainingAmount: 0,
+        });
+
+        renderSection([]);
+        await flushBudgetDataLoad();
+        openAddModalAfterLoad();
+
+        const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+        expect(select.value).toBe('src-2'); // 300 > 200 among REAL sources only
+        expect(
+          screen.getByText("Defaulted to Savings, this invoice's largest allocated source."),
+        ).toBeInTheDocument();
+        expect(screen.queryByText('—')).not.toBeInTheDocument();
+      });
+    });
+
+    describe('all-unassigned budget lines → HintNone + null default', () => {
+      it('every budget line is unassigned (no real source anywhere on the invoice): defaults budgetSourceId to null and shows the HintNone text', async () => {
+        mockFetchBudgetSources.mockResolvedValue({
+          budgetSources: [makeBudgetSource('src-1', { name: 'Bank Loan' })],
+        });
+        mockFetchInvoiceBudgetLines.mockResolvedValue({
+          budgetLines: [
+            makeInvoiceBudgetLine('ibl-1', { budgetSourceId: null, itemizedAmount: 400 }),
+            makeInvoiceBudgetLine('ibl-2', { budgetSourceId: null, itemizedAmount: 600 }),
+          ],
+          remainingAmount: 0,
+        });
+
+        renderSection([]);
+        await flushBudgetDataLoad();
+        openAddModalAfterLoad();
+
+        const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+        expect(select.value).toBe('');
+        expect(
+          screen.getByText(
+            'This invoice has no budget lines — pick a source, or leave blank to keep this deposit pro-rated.',
+          ),
+        ).toBeInTheDocument();
+      });
+    });
+
+    describe('edit mode: populates from the existing deposit, not the auto-default', () => {
+      it('openEditModal sets budgetSourceId from the deposit being edited, ignoring the auto-default logic entirely', async () => {
+        mockFetchBudgetSources.mockResolvedValue({
+          budgetSources: [
+            makeBudgetSource('src-1', { name: 'Bank Loan' }),
+            makeBudgetSource('src-2', { name: 'Savings' }),
+          ],
+        });
+        // The auto-default would pick src-2 (largest sum) if this were an ADD — but this is
+        // an EDIT of a deposit that's tagged to src-1, which must win instead.
+        mockFetchInvoiceBudgetLines.mockResolvedValue({
+          budgetLines: [
+            makeInvoiceBudgetLine('ibl-1', { budgetSourceId: 'src-2', itemizedAmount: 900 }),
+          ],
+          remainingAmount: 100,
+        });
+
+        const deposits = [makeDeposit('dep-1', { budgetSourceId: 'src-1' })];
+        renderSection(deposits);
+        await flushBudgetDataLoad();
+
+        // Open the edit modal via the row's overflow menu.
+        const menuTriggers = screen.getAllByRole('button', { name: /Deposit actions/i });
+        fireEvent.click(menuTriggers[0]!);
+        const editItem = screen.getByText(/^Edit$/);
+        fireEvent.click(editItem);
+
+        const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+        expect(select.value).toBe('src-1');
+      });
+
+      it('the picker remains editable (not disabled) while editing a claimed deposit', async () => {
+        mockFetchBudgetSources.mockResolvedValue({
+          budgetSources: [makeBudgetSource('src-1', { name: 'Bank Loan' })],
+        });
+        const deposits = [
+          makeDeposit('dep-1', {
+            status: 'claimed',
+            paidDate: '2026-01-10',
+            claimedDate: '2026-01-15',
+            budgetSourceId: null,
+          }),
+        ];
+        renderSection(deposits);
+        await flushBudgetDataLoad();
+
+        const menuTriggers = screen.getAllByRole('button', { name: /Deposit actions/i });
+        fireEvent.click(menuTriggers[0]!);
+        const editItem = screen.getByText(/^Edit$/);
+        fireEvent.click(editItem);
+
+        const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+        expect(select).not.toBeDisabled();
+
+        fireEvent.change(select, { target: { value: 'src-1' } });
+        expect(select.value).toBe('src-1');
+      });
+    });
+
+    describe('clearing back to null', () => {
+      it('selecting the "None" option sets budgetSourceId back to null', async () => {
+        mockFetchBudgetSources.mockResolvedValue({
+          budgetSources: [makeBudgetSource('src-1', { name: 'Bank Loan' })],
+        });
+        mockFetchInvoiceBudgetLines.mockResolvedValue({
+          budgetLines: [
+            makeInvoiceBudgetLine('ibl-1', { budgetSourceId: 'src-1', itemizedAmount: 500 }),
+          ],
+          remainingAmount: 0,
+        });
+
+        renderSection([]);
+        await flushBudgetDataLoad();
+        openAddModalAfterLoad();
+
+        const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+        expect(select.value).toBe('src-1'); // auto-defaulted
+
+        fireEvent.change(select, { target: { value: '' } });
+        expect(select.value).toBe('');
+      });
+
+      it('submitting with a cleared (null) budgetSourceId sends budgetSourceId: null to createDeposit', async () => {
+        mockFetchBudgetSources.mockResolvedValue({
+          budgetSources: [makeBudgetSource('src-1', { name: 'Bank Loan' })],
+        });
+        mockFetchInvoiceBudgetLines.mockResolvedValue({
+          budgetLines: [
+            makeInvoiceBudgetLine('ibl-1', { budgetSourceId: 'src-1', itemizedAmount: 500 }),
+          ],
+          remainingAmount: 0,
+        });
+        mockCreateDeposit.mockResolvedValueOnce({
+          deposit: makeDeposit('new-dep'),
+        } as Awaited<ReturnType<typeof mockCreateDeposit>>);
+
+        renderSection([]);
+        await flushBudgetDataLoad();
+        openAddModalAfterLoad();
+
+        const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+        fireEvent.change(select, { target: { value: '' } });
+
+        fireEvent.change(screen.getByLabelText(/amount/i), { target: { value: '300' } });
+        fireEvent.change(screen.getByLabelText(/due date/i), { target: { value: '2026-03-01' } });
+
+        const form = screen.getByRole('dialog').querySelector('form')!;
+        await act(async () => {
+          fireEvent.submit(form);
+        });
+
+        await waitFor(() => {
+          expect(mockCreateDeposit).toHaveBeenCalledWith(
+            INVOICE_ID,
+            expect.objectContaining({ budgetSourceId: null }),
+          );
+        });
+      });
+
+      it('submitting with the auto-defaulted budgetSourceId still set sends the real source id to createDeposit', async () => {
+        mockFetchBudgetSources.mockResolvedValue({
+          budgetSources: [makeBudgetSource('src-1', { name: 'Bank Loan' })],
+        });
+        mockFetchInvoiceBudgetLines.mockResolvedValue({
+          budgetLines: [
+            makeInvoiceBudgetLine('ibl-1', { budgetSourceId: 'src-1', itemizedAmount: 500 }),
+          ],
+          remainingAmount: 0,
+        });
+        mockCreateDeposit.mockResolvedValueOnce({
+          deposit: makeDeposit('new-dep'),
+        } as Awaited<ReturnType<typeof mockCreateDeposit>>);
+
+        renderSection([]);
+        await flushBudgetDataLoad();
+        openAddModalAfterLoad();
+
+        fireEvent.change(screen.getByLabelText(/amount/i), { target: { value: '300' } });
+        fireEvent.change(screen.getByLabelText(/due date/i), { target: { value: '2026-03-01' } });
+
+        const form = screen.getByRole('dialog').querySelector('form')!;
+        await act(async () => {
+          fireEvent.submit(form);
+        });
+
+        await waitFor(() => {
+          expect(mockCreateDeposit).toHaveBeenCalledWith(
+            INVOICE_ID,
+            expect.objectContaining({ budgetSourceId: 'src-1' }),
+          );
+        });
+      });
+    });
+
+    it('a network failure fetching budget sources/lines silently falls back to empty (no crash, no error banner)', async () => {
+      mockFetchBudgetSources.mockRejectedValue(new Error('network down'));
+      mockFetchInvoiceBudgetLines.mockRejectedValue(new Error('network down'));
+
+      expect(() => renderSection([])).not.toThrow();
+
+      await flushBudgetDataLoad();
+      openAddModalAfterLoad();
+
+      const select = screen.getByLabelText('Budget source') as HTMLSelectElement;
+      expect(select.value).toBe('');
+      expect(select.options).toHaveLength(1); // just "None"
+    });
+  });
 });
diff --git a/client/src/pages/InvoiceDetailPage/InvoiceDepositsSection.tsx b/client/src/pages/InvoiceDetailPage/InvoiceDepositsSection.tsx
index b57c9a6e2..331e2cd9a 100644
--- a/client/src/pages/InvoiceDetailPage/InvoiceDepositsSection.tsx
+++ b/client/src/pages/InvoiceDetailPage/InvoiceDepositsSection.tsx
@@ -1,12 +1,16 @@
 import { useState, useRef, useEffect, type FormEvent } from 'react';
 import { useTranslation } from 'react-i18next';
 import type {
+  BudgetSource,
   InvoiceDeposit,
   InvoiceDepositStatus,
   InvoiceDepositEntryType,
   InvoiceStatus,
+  InvoiceBudgetLineDetailResponse,
 } from '@cornerstone/shared';
 import { createDeposit, updateDeposit, deleteDeposit } from '../../lib/invoiceDepositsApi.js';
+import { fetchBudgetSources } from '../../lib/budgetSourcesApi.js';
+import { fetchInvoiceBudgetLines } from '../../lib/invoiceBudgetLinesApi.js';
 import { ApiClientError } from '../../lib/apiClient.js';
 import { useFormatters } from '../../lib/formatters.js';
 import { translateApiError } from '../../lib/errorTranslation.js';
@@ -34,6 +38,7 @@ interface DepositFormState {
   claimedDate: string;
   description: string;
   entryType: InvoiceDepositEntryType;
+  budgetSourceId: string | null;
 }
 
 type ModalMode = 'add' | 'edit' | 'delete' | null;
@@ -54,6 +59,7 @@ const getEmptyForm = (): DepositFormState => {
     claimedDate: today,
     description: '',
     entryType: 'deposit',
+    budgetSourceId: null,
   };
 };
 
@@ -75,6 +81,12 @@ export function InvoiceDepositsSection({
   const [mutatingDepositId, setMutatingDepositId] = useState<string | null>(null);
   const [stateConfirmDeposit, setStateConfirmDeposit] = useState<StateConfirmState | null>(null);
 
+  // Budget sources
+  const [budgetSources, setBudgetSources] = useState<BudgetSource[]>([]);
+
+  // Budget lines (for auto-default logic)
+  const [budgetLines, setBudgetLines] = useState<InvoiceBudgetLineDetailResponse[]>([]);
+
   // Form state
   const [depositForm, setDepositForm] = useState<DepositFormState>(() => getEmptyForm());
   const [formError, setFormError] = useState<string>('');
@@ -89,6 +101,25 @@ export function InvoiceDepositsSection({
   // Focus management
   const addButtonRef = useRef<HTMLButtonElement>(null);
 
+  // Fetch budget sources and budget lines
+  useEffect(() => {
+    const loadData = async () => {
+      try {
+        const [sourcesResult, budgetLinesResult] = await Promise.all([
+          fetchBudgetSources(),
+          fetchInvoiceBudgetLines(invoiceId),
+        ]);
+        setBudgetSources(sourcesResult.budgetSources);
+        setBudgetLines(budgetLinesResult.budgetLines);
+      } catch {
+        // Silently fail - sources and budget lines are optional for this feature
+        setBudgetSources([]);
+        setBudgetLines([]);
+      }
+    };
+    void loadData();
+  }, [invoiceId]);
+
   const showRevertError = (msg: string) => {
     if (revertErrorTimerRef.current) clearTimeout(revertErrorTimerRef.current);
     setRevertError(msg);
@@ -117,9 +148,54 @@ export function InvoiceDepositsSection({
     },
   };
 
+  // Compute source map and stats from budget lines (for auto-default and hint display)
+  const sourceStats = (() => {
+    const sourceMap = new Map<string | null, number>();
+    for (const line of budgetLines) {
+      const sourceId = line.budgetSourceId ?? null;
+      sourceMap.set(sourceId, (sourceMap.get(sourceId) ?? 0) + line.itemizedAmount);
+    }
+
+    // Count distinct sources (null and actual IDs)
+    const sourceIds = Array.from(sourceMap.keys()).filter((id) => id !== null);
+    const hasNullSource = sourceMap.has(null);
+    const distinctSources = sourceIds.length + (hasNullSource ? 1 : 0);
+
+    // Find the largest source (only among real, non-null sources)
+    let largestSourceId: string | null = null;
+    let maxAmount = -1;
+    for (const sourceId of sourceIds) {
+      const amount = sourceMap.get(sourceId) ?? 0;
+      if (amount > maxAmount) {
+        maxAmount = amount;
+        largestSourceId = sourceId;
+      }
+    }
+
+    return {
+      sourceMap,
+      distinctSources,
+      sourceIds,
+      hasNullSource,
+      largestSourceId,
+    };
+  })();
+
   const openAddModal = () => {
     setSelectedDeposit(null);
-    setDepositForm(getEmptyForm());
+
+    let defaultSourceId: string | null = null;
+    if (sourceStats.sourceIds.length === 1) {
+      // Exactly one real source (not null): default to that source
+      defaultSourceId = sourceStats.sourceIds[0]!;
+    } else if (sourceStats.sourceIds.length > 1) {
+      // Multiple real sources: default to the source with the largest sum
+      defaultSourceId = sourceStats.largestSourceId;
+    }
+    // If sourceIds.length === 0 (all unassigned), keep defaultSourceId as null
+
+    const emptyForm = getEmptyForm();
+    setDepositForm({ ...emptyForm, budgetSourceId: defaultSourceId });
     setFormError('');
     setModalMode('add');
   };
@@ -134,6 +210,7 @@ export function InvoiceDepositsSection({
       claimedDate: deposit.claimedDate ? deposit.claimedDate.slice(0, 10) : '',
       description: deposit.description ?? '',
       entryType: deposit.entryType,
+      budgetSourceId: deposit.budgetSourceId ?? null,
     });
     setFormError('');
     setModalMode('edit');
@@ -197,6 +274,7 @@ export function InvoiceDepositsSection({
           status: depositForm.status as InvoiceDepositStatus,
           entryType: depositForm.entryType,
           description: depositForm.description.trim() || null,
+          budgetSourceId: depositForm.budgetSourceId ?? null,
           ...(depositForm.status !== 'pending' ? { paidDate: depositForm.paidDate || null } : {}),
           ...(depositForm.status === 'claimed'
             ? { claimedDate: depositForm.claimedDate || null }
@@ -209,6 +287,7 @@ export function InvoiceDepositsSection({
           dueDate: depositForm.dueDate,
           status: depositForm.status as InvoiceDepositStatus,
           description: depositForm.description.trim() || null,
+          budgetSourceId: depositForm.budgetSourceId ?? null,
           ...(depositForm.status !== 'pending' ? { paidDate: depositForm.paidDate || null } : {}),
           ...(depositForm.status === 'claimed'
             ? { claimedDate: depositForm.claimedDate || null }
@@ -484,6 +563,9 @@ export function InvoiceDepositsSection({
           onClose={closeModal}
           error={formError}
           isMutating={isMutating}
+          budgetSources={budgetSources}
+          budgetLineSourceCount={sourceStats.sourceIds.length}
+          largestBudgetSourceId={sourceStats.largestSourceId}
           t={t}
         />
       )}
@@ -824,6 +906,9 @@ interface AddEditDepositModalProps {
   onClose: () => void;
   error: string;
   isMutating: boolean;
+  budgetSources: BudgetSource[];
+  budgetLineSourceCount: number; // Number of distinct sources in invoice's budget lines (for hint display)
+  largestBudgetSourceId: string | null; // The source with the largest sum (for hint display)
   t: (key: string, opts?: Record<string, unknown>) => string;
 }
 
@@ -835,6 +920,9 @@ function AddEditDepositModal({
   onClose,
   error,
   isMutating,
+  budgetSources,
+  budgetLineSourceCount,
+  largestBudgetSourceId,
   t,
 }: AddEditDepositModalProps) {
   const isEdit = mode === 'edit';
@@ -917,6 +1005,43 @@ function AddEditDepositModal({
           </div>
         </div>
 
+        {/* Budget source picker */}
+        <div className={styles.formField}>
+          <label htmlFor="deposit-budgetSource" className={styles.label}>
+            {t('budget:invoiceDetail.deposits.form.budgetSource')}
+          </label>
+          <select
+            id="deposit-budgetSource"
+            value={form.budgetSourceId || ''}
+            onChange={(e) =>
+              onFormChange({
+                ...form,
+                budgetSourceId: e.target.value ? e.target.value : null,
+              })
+            }
+            className={sharedStyles.select}
+            disabled={isMutating}
+          >
+            <option value="">{t('budget:invoiceDetail.deposits.form.budgetSourceNone')}</option>
+            {budgetSources.map((source) => (
+              <option key={source.id} value={source.id}>
+                {source.name}
+              </option>
+            ))}
+          </select>
+          <div className={styles.charCounter}>
+            {budgetLineSourceCount === 0
+              ? t('budget:invoiceDetail.deposits.form.budgetSourceHintNone')
+              : budgetLineSourceCount === 1
+                ? t('budget:invoiceDetail.deposits.form.budgetSourceHintSingle', {
+                    name: budgetSources.find((s) => s.id === form.budgetSourceId)?.name || '—',
+                  })
+                : t('budget:invoiceDetail.deposits.form.budgetSourceHintLargest', {
+                    name: budgetSources.find((s) => s.id === largestBudgetSourceId)?.name || '—',
+                  })}
+          </div>
+        </div>
+
         {/* Row 1: amount + due date */}
         <div className={styles.formRow}>
           <div className={styles.formField}>
diff --git a/client/src/pages/ReportWizardPage/ReportWizardPage.module.css b/client/src/pages/ReportWizardPage/ReportWizardPage.module.css
index ebd54f6a9..9c707ad64 100644
--- a/client/src/pages/ReportWizardPage/ReportWizardPage.module.css
+++ b/client/src/pages/ReportWizardPage/ReportWizardPage.module.css
@@ -250,6 +250,37 @@
   justify-content: flex-end;
 }
 
+/* ---- Warning Block (ported from MassMoveModal) ---- */
+
+.warningBlock {
+  display: flex;
+  gap: var(--spacing-3);
+  background-color: var(--color-warning-bg);
+  border: 1px solid var(--color-warning);
+  border-radius: var(--radius-md);
+  padding: var(--spacing-3) var(--spacing-4);
+  margin-top: var(--spacing-4);
+}
+
+.warningIconContainer {
+  flex-shrink: 0;
+  padding-top: var(--spacing-1);
+}
+
+.warningIcon {
+  width: 1.25rem;
+  height: 1.25rem;
+  color: var(--color-warning);
+  flex-shrink: 0;
+}
+
+.warningBody {
+  margin: 0;
+  font-size: var(--font-size-sm);
+  color: var(--color-text-secondary);
+  line-height: 1.5;
+}
+
 /* ---- Responsive ---- */
 
 @media (max-width: 860px) {
diff --git a/client/src/pages/ReportWizardPage/ReportWizardPage.test.tsx b/client/src/pages/ReportWizardPage/ReportWizardPage.test.tsx
index 046d3cddd..71283443b 100644
--- a/client/src/pages/ReportWizardPage/ReportWizardPage.test.tsx
+++ b/client/src/pages/ReportWizardPage/ReportWizardPage.test.tsx
@@ -182,6 +182,8 @@ function makeReport(overrides: Partial<SourceReportResponse> = {}): SourceReport
         lineKind: 'invoice',
         isSplit: false,
         documents: [],
+        budgetLines: [],
+        deposits: [],
       },
     ],
     totalAmount: 1000,
@@ -557,6 +559,8 @@ describe('ReportWizardPage', () => {
           lineKind: 'invoice',
           isSplit: false,
           documents: [],
+          budgetLines: [],
+          deposits: [],
         },
       ],
     });
@@ -1098,4 +1102,274 @@ describe('ReportWizardPage', () => {
     });
     expect(mockMarkInvoicesClaimed).not.toHaveBeenCalled();
   });
+
+  // ─── Story #1891: line exclusions feed the amount-adjusted effectiveReport ─
+
+  describe('line exclusions (Story #1891)', () => {
+    function makeReportWithLines(): SourceReportResponse {
+      return makeReport({
+        invoices: [
+          {
+            invoiceId: 'inv-1',
+            vendorId: 'vend-1',
+            vendorName: 'ACME',
+            invoiceNumber: 'INV-001',
+            date: '2026-01-10',
+            status: 'pending',
+            invoiceAmount: 1000,
+            allocatedAmount: 1000,
+            lineKind: 'invoice',
+            isSplit: false,
+            documents: [],
+            budgetLines: [
+              {
+                id: 'line-1',
+                description: 'Foundation work',
+                allocatedPortion: 600,
+                linkedItem: null,
+              },
+              { id: 'line-2', description: 'Roofing', allocatedPortion: 400, linkedItem: null },
+            ],
+            deposits: [],
+          },
+        ],
+        totalAmount: 1000,
+      });
+    }
+
+    it('excluding a budget line via the item checkbox regenerates the PDF with the amount-ADJUSTED effectiveReport, not the raw report', async () => {
+      mockFetchBudgetSources.mockResolvedValue({ budgetSources: [makeSource()] });
+      mockGetSourceReport.mockResolvedValue(makeReportWithLines());
+      mockGenerateReportPdf.mockResolvedValue({ blob: new Blob(['pdf']), skippedDocuments: [] });
+
+      renderPage();
+      const user = userEvent.setup();
+      await goToStep3(user);
+      await waitFor(() => expect(mockGenerateReportPdf).toHaveBeenCalledTimes(1));
+
+      // First (initial) call receives the report with the FULL, un-adjusted amount.
+      const firstCallReport = mockGenerateReportPdf.mock.calls[0]![0];
+      expect(firstCallReport.invoices[0]!.allocatedAmount).toBe(1000);
+
+      // Expand the invoice row and exclude "Foundation work" (600).
+      const expandButton = document.querySelector(
+        '[aria-controls="invoice-expand-inv-1"]',
+      ) as HTMLElement;
+      await user.click(expandButton);
+      // The expansion panel renders both a desktop table and a mobile card list for the same
+      // budget lines (CSS hides one per viewport; jsdom has no layout engine, so both are in the
+      // DOM) — select the desktop instance, matching the convention in ReportInvoiceList.test.tsx.
+      const excludeCheckbox = screen.getAllByRole('checkbox', {
+        name: 'Exclude Foundation work from report',
+      })[0]!;
+      await user.click(excludeCheckbox);
+
+      await waitFor(
+        () => {
+          expect(mockGenerateReportPdf).toHaveBeenCalledTimes(2);
+        },
+        { timeout: 2000 },
+      );
+
+      // The regenerated call must receive the ADJUSTED effectiveReport: 1000 - 600 = 400.
+      const secondCallReport =
+        mockGenerateReportPdf.mock.calls[mockGenerateReportPdf.mock.calls.length - 1]![0];
+      expect(secondCallReport.invoices[0]!.allocatedAmount).toBe(400);
+      expect(secondCallReport.invoices[0]!.lineKind).toBe('invoice');
+    });
+
+    it('excluding a line large enough to flip the sign passes a negative allocatedAmount / refund-adjustment lineKind to generateReportPdf', async () => {
+      mockFetchBudgetSources.mockResolvedValue({ budgetSources: [makeSource()] });
+      mockGetSourceReport.mockResolvedValue(
+        makeReport({
+          invoices: [
+            {
+              invoiceId: 'inv-1',
+              vendorId: 'vend-1',
+              vendorName: 'ACME',
+              invoiceNumber: 'INV-001',
+              date: '2026-01-10',
+              status: 'pending',
+              invoiceAmount: 1000,
+              allocatedAmount: 200,
+              lineKind: 'invoice',
+              isSplit: false,
+              documents: [],
+              budgetLines: [
+                {
+                  id: 'line-1',
+                  description: 'Overpaid deposit',
+                  allocatedPortion: 500,
+                  linkedItem: null,
+                },
+              ],
+              deposits: [],
+            },
+          ],
+          totalAmount: 200,
+        }),
+      );
+      mockGenerateReportPdf.mockResolvedValue({ blob: new Blob(['pdf']), skippedDocuments: [] });
+
+      renderPage();
+      const user = userEvent.setup();
+      await goToStep3(user);
+      await waitFor(() => expect(mockGenerateReportPdf).toHaveBeenCalledTimes(1));
+
+      const expandButton = document.querySelector(
+        '[aria-controls="invoice-expand-inv-1"]',
+      ) as HTMLElement;
+      await user.click(expandButton);
+      // Desktop instance — see the comment on the "Foundation work" test above for why this is
+      // ambiguous under jsdom (both desktop table and mobile card list render simultaneously).
+      const excludeCheckbox = screen.getAllByRole('checkbox', {
+        name: 'Exclude Overpaid deposit from report',
+      })[0]!;
+      await user.click(excludeCheckbox);
+
+      await waitFor(
+        () => {
+          expect(mockGenerateReportPdf).toHaveBeenCalledTimes(2);
+        },
+        { timeout: 2000 },
+      );
+
+      const secondCallReport =
+        mockGenerateReportPdf.mock.calls[mockGenerateReportPdf.mock.calls.length - 1]![0];
+      expect(secondCallReport.invoices[0]!.allocatedAmount).toBe(-300);
+      expect(secondCallReport.invoices[0]!.lineKind).toBe('refund-adjustment');
+    });
+
+    it('zero exclusions: effectiveReport passed to generateReportPdf is identical to the server report (no drift)', async () => {
+      mockFetchBudgetSources.mockResolvedValue({ budgetSources: [makeSource()] });
+      const report = makeReportWithLines();
+      mockGetSourceReport.mockResolvedValue(report);
+      mockGenerateReportPdf.mockResolvedValue({ blob: new Blob(['pdf']), skippedDocuments: [] });
+
+      renderPage();
+      const user = userEvent.setup();
+      await goToStep4(user);
+      await waitFor(() => expect(mockGenerateReportPdf).toHaveBeenCalledTimes(1));
+
+      const callReport = mockGenerateReportPdf.mock.calls[0]![0];
+      expect(callReport.invoices[0]!.allocatedAmount).toBe(1000);
+      expect(callReport.invoices[0]!.lineKind).toBe('invoice');
+    });
+  });
+
+  // ─── Story #1891: claim-confirm modal warning for excluded items ──────────
+
+  describe('claim confirmation modal — excluded-items warning (Story #1891)', () => {
+    function makeReportWithLines(): SourceReportResponse {
+      return makeReport({
+        invoices: [
+          {
+            invoiceId: 'inv-1',
+            vendorId: 'vend-1',
+            vendorName: 'ACME',
+            invoiceNumber: 'INV-001',
+            date: '2026-01-10',
+            status: 'pending',
+            invoiceAmount: 1000,
+            allocatedAmount: 1000,
+            lineKind: 'invoice',
+            isSplit: false,
+            documents: [],
+            budgetLines: [
+              {
+                id: 'line-1',
+                description: 'Foundation work',
+                allocatedPortion: 600,
+                linkedItem: null,
+              },
+            ],
+            deposits: [],
+          },
+        ],
+        totalAmount: 1000,
+      });
+    }
+
+    it('does NOT show the warning when no lines are excluded', async () => {
+      mockFetchBudgetSources.mockResolvedValue({ budgetSources: [makeSource()] });
+      mockGetSourceReport.mockResolvedValue(makeReportWithLines());
+      mockGenerateReportPdf.mockResolvedValue({ blob: new Blob(['pdf']), skippedDocuments: [] });
+
+      renderPage();
+      const user = userEvent.setup();
+      await goToStep4(user);
+      await waitFor(() => expect(mockGenerateReportPdf).toHaveBeenCalledTimes(1));
+
+      await user.click(screen.getByRole('button', { name: /Mark [0-9]+ invoices as claimed/ }));
+      await waitFor(() => screen.getByRole('button', { name: 'Confirm' }));
+
+      expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+    });
+
+    it('shows the warning with the correct count when an included invoice has an excluded line', async () => {
+      mockFetchBudgetSources.mockResolvedValue({ budgetSources: [makeSource()] });
+      mockGetSourceReport.mockResolvedValue(makeReportWithLines());
+      mockGenerateReportPdf.mockResolvedValue({ blob: new Blob(['pdf']), skippedDocuments: [] });
+
+      renderPage();
+      const user = userEvent.setup();
+      await goToStep3(user);
+      await waitFor(() => expect(mockGenerateReportPdf).toHaveBeenCalledTimes(1));
+
+      const expandButton = document.querySelector(
+        '[aria-controls="invoice-expand-inv-1"]',
+      ) as HTMLElement;
+      await user.click(expandButton);
+      // Desktop instance — see the "Foundation work" test in the "line exclusions" describe
+      // block above for why getAllByRole(...)[0] is required here.
+      await user.click(
+        screen.getAllByRole('checkbox', { name: 'Exclude Foundation work from report' })[0]!,
+      );
+      await waitFor(() => expect(mockGenerateReportPdf).toHaveBeenCalledTimes(2), {
+        timeout: 2000,
+      });
+
+      await clickNext(user); // step 3 -> 4
+      await user.click(screen.getByRole('button', { name: /Mark [0-9]+ invoices as claimed/ }));
+      await waitFor(() => screen.getByRole('button', { name: 'Confirm' }));
+
+      const warning = screen.getByRole('alert');
+      expect(warning).toHaveTextContent('1 invoice(s) will be claimed in full');
+    });
+
+    it('does NOT show the warning when the only invoice with an excluded line is itself invoice-level excluded', async () => {
+      mockFetchBudgetSources.mockResolvedValue({ budgetSources: [makeSource()] });
+      mockGetSourceReport.mockResolvedValue(makeReportWithLines());
+      mockGenerateReportPdf.mockResolvedValue({ blob: new Blob(['pdf']), skippedDocuments: [] });
+
+      renderPage();
+      const user = userEvent.setup();
+      await goToStep3(user);
+      await waitFor(() => expect(mockGenerateReportPdf).toHaveBeenCalledTimes(1));
+
+      // Exclude the WHOLE invoice at the parent (tri-state) checkbox level FIRST — while
+      // checked (no lines excluded yet), clicking transitions checked=true -> false, which
+      // is the deterministic "exclude" direction (onToggle(id, true)).
+      await user.click(screen.getByRole('checkbox', { name: /ACME/ }));
+
+      // Then also exclude a line within it (independent state — excludedLineIds is not
+      // gated on the invoice-level exclusion).
+      const expandButton = document.querySelector(
+        '[aria-controls="invoice-expand-inv-1"]',
+      ) as HTMLElement;
+      await user.click(expandButton);
+      // Desktop instance — same dual-DOM ambiguity as above.
+      await user.click(
+        screen.getAllByRole('checkbox', { name: 'Exclude Foundation work from report' })[0]!,
+      );
+
+      // With the sole invoice excluded, excludedInvoiceIds.size === report.invoices.length,
+      // so step 3's own "Next" button is disabled (title: sourceReports.selectAtLeastOne) —
+      // the wizard cannot even reach step 4's claim modal, so no warning can be shown at all.
+      const nextButtons = screen
+        .getAllByRole('button')
+        .filter((b) => b.className.includes('btnPrimary'));
+      expect(nextButtons[nextButtons.length - 1]).toBeDisabled();
+    });
+  });
 });
diff --git a/client/src/pages/ReportWizardPage/ReportWizardPage.tsx b/client/src/pages/ReportWizardPage/ReportWizardPage.tsx
index 431a6ca42..29c7cc937 100644
--- a/client/src/pages/ReportWizardPage/ReportWizardPage.tsx
+++ b/client/src/pages/ReportWizardPage/ReportWizardPage.tsx
@@ -7,6 +7,7 @@ import { fetchHouseholdSettings } from '../../lib/settingsApi.js';
 import { getSourceReport, markInvoicesClaimed } from '../../lib/sourceReportsApi.js';
 import { getPaperlessStatus } from '../../lib/paperlessApi.js';
 import { useFormatters } from '../../lib/formatters.js';
+import { applyLineExclusions } from '../../lib/reportExclusions.js';
 import {
   generateReportPdf,
   downloadPdf,
@@ -74,6 +75,9 @@ export function ReportWizardPage() {
   // Invoice selection
   const [excludedInvoiceIds, setExcludedInvoiceIds] = useState<Set<string>>(new Set());
 
+  // Line-level exclusions
+  const [excludedLineIds, setExcludedLineIds] = useState<Set<string>>(new Set());
+
   // PDF generation
   const [attachDocuments, setAttachDocuments] = useState(true);
   const [includeCoverLetter, setIncludeCoverLetter] = useState(false);
@@ -156,6 +160,7 @@ export function ReportWizardPage() {
     (sid: string) => {
       setSourceId(sid);
       setExcludedInvoiceIds(new Set());
+      setExcludedLineIds(new Set());
       setMaxReachedStep(3);
       setReportStatus('loading');
 
@@ -187,23 +192,28 @@ export function ReportWizardPage() {
   // Regenerate PDF on options change (debounced)
   const debounceTimerRef = useRef<NodeJS.Timeout | null>(null);
 
+  // regeneratePdf depends on raw inputs (report, excludedLineIds) not the derived effectiveReport memo
+  // This prevents the effect loop where effectiveReport memo identity changes → regeneratePdf recreated → effect re-fires
   const regeneratePdf = useCallback(async () => {
     // Allow regeneration if we have report+useCase (for retries after errors or option changes)
     if (!report || !useCase) return;
 
+    // Compute effectiveReport internally to avoid depending on the memo
+    const currentEffectiveReport = applyLineExclusions(report, excludedLineIds);
+
     // Capture current generation ID to detect stale results
     const myGenerationId = ++generationIdRef.current;
 
     setIsRegenerating(true);
     try {
       const included = new Set(
-        report.invoices
+        currentEffectiveReport.invoices
           .filter((inv) => !excludedInvoiceIds.has(inv.invoiceId))
           .map((inv) => inv.invoiceId),
       );
 
       const result = await generateReportPdf(
-        report,
+        currentEffectiveReport,
         included,
         useCase,
         { attachDocuments, includeCoverLetter },
@@ -237,9 +247,22 @@ export function ReportWizardPage() {
     } finally {
       setIsRegenerating(false);
     }
-  }, [report, useCase, excludedInvoiceIds, attachDocuments, includeCoverLetter, household, t]);
+  }, [
+    report,
+    useCase,
+    excludedLineIds,
+    excludedInvoiceIds,
+    attachDocuments,
+    includeCoverLetter,
+    household,
+    formatters,
+    t,
+  ]);
 
   // PDF generation: immediate on first load, debounced on option changes
+  // Depend ONLY on raw inputs (report, useCase, reportStatus, etc.), NOT on regeneratePdf or derived effectiveReport memo.
+  // This prevents effect re-fires from regeneratePdf's dependencies (formatters, t, household) changing.
+  // The effect calls regeneratePdf(), which is captured in the closure and will be the latest version.
   useEffect(() => {
     if (!report || !useCase || reportStatus !== 'ready') return;
 
@@ -264,15 +287,15 @@ export function ReportWizardPage() {
         }
       };
     }
+    // eslint-disable-next-line @eslint-react/exhaustive-deps
   }, [
     report,
     useCase,
     reportStatus,
-    household,
     attachDocuments,
     includeCoverLetter,
     excludedInvoiceIds,
-    regeneratePdf,
+    excludedLineIds,
   ]);
 
   // Handle claim
@@ -493,56 +516,73 @@ export function ReportWizardPage() {
                 </button>
               </div>
             )}
-            {reportStatus === 'ready' && report && (
-              <>
-                <ReportInvoiceList
-                  report={report}
-                  excludedInvoiceIds={excludedInvoiceIds}
-                  onToggle={(id, excluded) => {
-                    const newSet = new Set(excludedInvoiceIds);
-                    if (excluded) {
-                      newSet.add(id);
-                    } else {
-                      newSet.delete(id);
-                    }
-                    setExcludedInvoiceIds(newSet);
-                  }}
-                  onToggleAll={(excludeAll) => {
-                    if (excludeAll) {
-                      setExcludedInvoiceIds(new Set(report.invoices.map((inv) => inv.invoiceId)));
-                    } else {
-                      setExcludedInvoiceIds(new Set());
-                    }
-                  }}
-                  t={t}
-                />
-                <div className={styles.buttonRow}>
-                  <button
-                    type="button"
-                    className={sharedStyles.btnSecondary}
-                    onClick={() => setCurrentStep(2)}
-                  >
-                    {t('common:button.back')}
-                  </button>
-                  <button
-                    type="button"
-                    className={sharedStyles.btnPrimary}
-                    onClick={() => {
-                      setMaxReachedStep((s) => Math.max(s, 4));
-                      setCurrentStep(4);
-                    }}
-                    disabled={excludedInvoiceIds.size === report.invoices.length}
-                    title={
-                      excludedInvoiceIds.size === report.invoices.length
-                        ? t('sourceReports.selectAtLeastOne')
-                        : undefined
-                    }
-                  >
-                    {t('common:button.next')}
-                  </button>
-                </div>
-              </>
-            )}
+            {reportStatus === 'ready' &&
+              report &&
+              (() => {
+                const effectiveReport = applyLineExclusions(report, excludedLineIds);
+                return (
+                  <>
+                    <ReportInvoiceList
+                      report={effectiveReport}
+                      excludedInvoiceIds={excludedInvoiceIds}
+                      excludedLineIds={excludedLineIds}
+                      onToggle={(id, excluded) => {
+                        const newSet = new Set(excludedInvoiceIds);
+                        if (excluded) {
+                          newSet.add(id);
+                        } else {
+                          newSet.delete(id);
+                        }
+                        setExcludedInvoiceIds(newSet);
+                      }}
+                      onToggleAll={(excludeAll) => {
+                        if (excludeAll) {
+                          setExcludedInvoiceIds(
+                            new Set(report.invoices.map((inv) => inv.invoiceId)),
+                          );
+                        } else {
+                          setExcludedInvoiceIds(new Set());
+                        }
+                      }}
+                      onToggleLine={(lineId, excluded) => {
+                        const newSet = new Set(excludedLineIds);
+                        if (excluded) {
+                          newSet.add(lineId);
+                        } else {
+                          newSet.delete(lineId);
+                        }
+                        setExcludedLineIds(newSet);
+                      }}
+                      t={t}
+                    />
+                    <div className={styles.buttonRow}>
+                      <button
+                        type="button"
+                        className={sharedStyles.btnSecondary}
+                        onClick={() => setCurrentStep(2)}
+                      >
+                        {t('common:button.back')}
+                      </button>
+                      <button
+                        type="button"
+                        className={sharedStyles.btnPrimary}
+                        onClick={() => {
+                          setMaxReachedStep((s) => Math.max(s, 4));
+                          setCurrentStep(4);
+                        }}
+                        disabled={excludedInvoiceIds.size === report.invoices.length}
+                        title={
+                          excludedInvoiceIds.size === report.invoices.length
+                            ? t('sourceReports.selectAtLeastOne')
+                            : undefined
+                        }
+                      >
+                        {t('common:button.next')}
+                      </button>
+                    </div>
+                  </>
+                );
+              })()}
           </div>
         )}
 
@@ -658,6 +698,35 @@ export function ReportWizardPage() {
               ).length,
             })}
           </p>
+
+          {(() => {
+            // Find invoices with excluded lines (and not excluded at invoice level)
+            const invoicesWithExcludedItems = report.invoices.filter(
+              (inv) =>
+                !excludedInvoiceIds.has(inv.invoiceId) &&
+                inv.budgetLines.some((line) => excludedLineIds.has(line.id)),
+            );
+
+            return invoicesWithExcludedItems.length > 0 ? (
+              <div className={styles.warningBlock} role="alert">
+                <div className={styles.warningIconContainer}>
+                  <svg
+                    className={styles.warningIcon}
+                    viewBox="0 0 24 24"
+                    fill="currentColor"
+                    aria-hidden="true"
+                  >
+                    <path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z" />
+                  </svg>
+                </div>
+                <p className={styles.warningBody}>
+                  {t('sourceReports.confirmClaimExcludedItemsWarning', {
+                    count: invoicesWithExcludedItems.length,
+                  })}
+                </p>
+              </div>
+            ) : null;
+          })()}
         </Modal>
       )}
     </PageLayout>
diff --git a/e2e/pages/InvoiceDetailPage.ts b/e2e/pages/InvoiceDetailPage.ts
index 58c354f7c..a316b0dee 100644
--- a/e2e/pages/InvoiceDetailPage.ts
+++ b/e2e/pages/InvoiceDetailPage.ts
@@ -251,6 +251,24 @@ export class InvoiceDetailPage {
   /** Confirm delete button inside the delete deposit modal */
   readonly deleteDepositConfirmButton: Locator;
 
+  /**
+   * Budget-source `<select id="deposit-budgetSource">` in the add/edit deposit modal
+   * (Story #1891) — links a deposit directly to a budget source (independent of budget
+   * lines). Empty option value `""` = "None (pro-rated)". On the ADD modal only (not edit),
+   * this defaults per `invoice.budgetLines` grouped by `budgetSourceId`: 0 sources → `null`
+   * + `budgetSourceHintNone`; 1 source → that source + `budgetSourceHintSingle`; >1 sources
+   * → the largest-sum source + `budgetSourceHintLargest`. Always editable (gated only on
+   * `isMutating`, unlike the entry-type radios which are edit-mode-disabled).
+   */
+  readonly depositBudgetSourceSelect: Locator;
+
+  /**
+   * The hint text below the budget-source select — reuses `.charCounter` styling (Story
+   * #1891). Text is one of `budgetSourceHintNone`/`budgetSourceHintSingle`/
+   * `budgetSourceHintLargest`, only rendered on the ADD modal (default-selection hint).
+   */
+  readonly depositBudgetSourceHint: Locator;
+
   /** Final payment row at the bottom of the deposits table */
   readonly finalPaymentRow: Locator;
 
@@ -739,6 +757,15 @@ export class InvoiceDetailPage {
     // Delete deposit confirm button — stable data-testid added in #1407
     this.deleteDepositConfirmButton = page.getByTestId('deposit-delete-confirm');
 
+    // Budget-source select in the add/edit deposit modal (Story #1891) — page-scoped for the
+    // same reason as the other form inputs above (the deposit modal renders via a portal).
+    this.depositBudgetSourceSelect = page.locator('#deposit-budgetSource');
+
+    // Hint text (reuses .charCounter styling) below the budget-source select.
+    this.depositBudgetSourceHint = page
+      .locator('label[for="deposit-budgetSource"]')
+      .locator('xpath=parent::div//*[contains(@class,"charCounter")]');
+
     // Final payment row (always visible when deposits.length > 0)
     this.finalPaymentRow = page.locator('[class*="finalPaymentRow"]');
 
diff --git a/e2e/pages/ReportWizardPage.ts b/e2e/pages/ReportWizardPage.ts
index 5a5d0f11b..862659c4b 100644
--- a/e2e/pages/ReportWizardPage.ts
+++ b/e2e/pages/ReportWizardPage.ts
@@ -46,6 +46,50 @@
  *   `[class*="pdfPreviewWrapper"]`.
  * - Claim confirmation modal: `role="dialog"` (name "Mark Invoices as Claimed?").
  * - Claim success: `[class*="bannerSuccess"]` banner (replaces the action buttons in Step 4).
+ *
+ * Story #1891 follow-up additions (`ReportInvoiceList.tsx`):
+ * - Each allocated invoice row is a `<div class*="invoiceRow">` on a `1.5rem auto 1fr auto
+ *   auto auto` grid: [chevron|non-interactive span] [TriState checkbox + vendor info]
+ *   [status Badge `class*="statusChip"`] [amount] [attachment column]. The row is only
+ *   expandable (chevron rendered as a real `<button class*="expandButton">` with
+ *   `aria-expanded`/`aria-controls="invoice-expand-{invoiceId}"`) when
+ *   `budgetLines.length > 0 || deposits.length > 0`; otherwise a bare `aria-hidden` span
+ *   fills the grid cell and there is nothing to expand.
+ * - The expansion panel (`class*="expansionPanel"`, `id="invoice-expand-{invoiceId}"`) is a
+ *   DOM SIBLING immediately after the row's own `invoiceRow` div (both children of the same
+ *   per-invoice wrapper `<div key={invoice.invoiceId}>`), not a descendant — locators below
+ *   reach it via `xpath=following-sibling::*`.
+ * - Inside the panel: an items sub-table (`class*="subTableSection"` #1, budget lines, else
+ *   `EmptyState`) then a deposits sub-table (`class*="subTableSection"` #2, else
+ *   `EmptyState`) — always in this DOM order, so `.nth(0)`/`.nth(1)` disambiguates without
+ *   depending on i18n heading text.
+ * - Each budget-line row's exclusion checkbox has `aria-label="Exclude {name} from report"`
+ *   (`sourceReports.expand.excludeItemAriaLabel`, `name` = line description or
+ *   `t('sourceReports.expand.unnamedLine')`). Toggling it updates `excludedLineIds`
+ *   (`ReportWizardPage.tsx`), which is applied PURELY client-side via
+ *   `applyLineExclusions()` (`client/src/lib/reportExclusions.ts`) — it subtracts the
+ *   excluded lines' `allocatedPortion` from the invoice's `allocatedAmount` for display/PDF
+ *   purposes only. It NEVER touches `excludedInvoiceIds` — the invoice is still submitted in
+ *   full to `markInvoicesClaimed` regardless of line exclusions (hence the claim-confirm
+ *   modal's warning block, see `markClaimedWarningBlock` below).
+ * - **Fixed regression (#1892)**: `applyLineExclusions` clamps a fully-excluded invoice's
+ *   `allocatedAmount` to exactly `0`. `ReportInvoiceList`'s `allocatedInvoices` filter is
+ *   `inv.allocatedAmount > 0 || inv.lineKind === 'refund-adjustment' || inv.budgetLines.length > 0
+ *   || inv.deposits.length > 0` — the added `budgetLines.length > 0 || deposits.length > 0`
+ *   clauses keep a fully-line-excluded invoice (net exactly 0, `lineKind` stays `'invoice'`)
+ *   visible as a `€0.00` row instead of being filtered out, which also preserves the only UI
+ *   path back to un-excluding those lines (the row's own expand toggle). The PDF and the actual
+ *   claim submission were never affected either way (both operate on `excludedInvoiceIds`, not
+ *   the filtered display list) — this was a display-only regression. See
+ *   `reportWizardExpansion.spec.ts` Scenario 4 for the regression-guard test.
+ * - Deposits sub-table's "Allocated Source" column renders a source-colored Badge only when
+ *   `deposit.budgetSourceId === report.source.id` (the CURRENTLY viewed source); any other
+ *   value (including a different source's id) renders a plain `—` — deposits tagged to a
+ *   different source are never shown as tagged in someone else's report.
+ * - Claim confirm modal warning block: `[role="alert"]` (`class*="warningBlock"`) rendered
+ *   inside the modal ONLY when at least one included (non invoice-excluded) invoice has one
+ *   or more excluded lines — text is `sourceReports.confirmClaimExcludedItemsWarning`
+ *   ("{{count}} invoice(s) will be claimed in full even though...").
  */
 
 import { expect, type Page, type Locator, type Download } from '@playwright/test';
@@ -115,9 +159,30 @@ export class ReportWizardPage {
   // Data-loading error
   readonly errorLoadingDataBanner: Locator;
 
+  // Story #1891: expandable rows, items/deposits sub-tables, claim warning
+  readonly markClaimedWarningBlock: Locator;
+
+  /**
+   * Console messages captured since construction whose text matches
+   * `/content security policy/i`. Registered in the constructor — NOT lazily on first use —
+   * so a violation that fires before/during `goto()` is never missed (mirrors the established
+   * convention in `invoice-auto-itemize-page.spec.ts` Scenario 18's `page.on('console', ...)`
+   * CSP-error capture). A blocked `frame-src` navigation for the report preview `<iframe>`
+   * surfaces here as a Chromium-emitted `'error'`-type console message, e.g.
+   * `Refused to frame 'blob:...' because it violates the following Content Security Policy
+   * directive: "frame-src 'self'".`
+   */
+  private readonly cspViolationMessages: string[] = [];
+
   constructor(page: Page) {
     this.page = page;
 
+    page.on('console', (msg) => {
+      if (msg.type() === 'error' && /content security policy/i.test(msg.text())) {
+        this.cspViolationMessages.push(msg.text());
+      }
+    });
+
     this.heading = page.getByRole('heading', { level: 1 });
 
     this.stepListDesktop = page.locator('[class*="stepList"]');
@@ -175,6 +240,10 @@ export class ReportWizardPage {
     this.claimConfirmCancelButton = this.claimConfirmModal.locator('[class*="btnSecondary"]');
 
     this.errorLoadingDataBanner = page.locator('[class*="metadataCard"] [role="alert"]').first();
+
+    // Warning block ([role="alert"], class*="warningBlock") shown inside the claim-confirm
+    // modal only when an included invoice has excluded lines (see class docstring above).
+    this.markClaimedWarningBlock = this.claimConfirmModal.locator('[role="alert"]');
   }
 
   async goto(sourceId?: string): Promise<void> {
@@ -251,6 +320,98 @@ export class ReportWizardPage {
     await this.invoiceRowCheckbox(vendorName, invoiceNumber).click();
   }
 
+  /**
+   * The row's own displayed amount element — `[class*="amount"]` WITHOUT the `Column`
+   * substring, so it excludes the `.amountColumn` grid-cell wrapper (which also contains
+   * "amount" as a substring) and resolves to the innermost `.amount`/`.amount.amountNegative`
+   * div regardless of whether the row is a plain invoice or a refund-adjustment (which nests
+   * an extra unstyled wrapper `<div>` around a Badge + this same element).
+   */
+  invoiceRowAmount(vendorName: string, invoiceNumber: string): Locator {
+    return this.invoiceRow(vendorName, invoiceNumber)
+      .locator('[class*="amount"]:not([class*="Column"])')
+      .first();
+  }
+
+  /**
+   * The chevron expand/collapse button for an allocated invoice row (Story #1891). Only
+   * present when the invoice has budget lines and/or deposits — see class docstring.
+   */
+  invoiceExpandToggle(vendorName: string, invoiceNumber: string): Locator {
+    return this.invoiceRow(vendorName, invoiceNumber).locator('[class*="expandButton"]');
+  }
+
+  /**
+   * The expansion panel for an allocated invoice row — a DOM SIBLING of the row's own
+   * `invoiceRow` div (both children of the same per-invoice wrapper), not a descendant, so
+   * this is reached via a relative `following-sibling::` xpath rather than `.locator()`
+   * descendant search. Only present in the DOM while `isExpanded` is true.
+   */
+  expansionPanel(vendorName: string, invoiceNumber: string): Locator {
+    return this.invoiceRow(vendorName, invoiceNumber).locator(
+      'xpath=following-sibling::*[contains(@class,"expansionPanel")]',
+    );
+  }
+
+  /**
+   * The items (budget lines) sub-table section — always the FIRST `class*="subTableSection"`
+   * child of the expansion panel, whether it renders the real `<table>` or the `EmptyState`
+   * fallback (`budgetLines.length === 0`). Structural indexing avoids depending on i18n
+   * heading text.
+   */
+  itemsSubTable(vendorName: string, invoiceNumber: string): Locator {
+    return this.expansionPanel(vendorName, invoiceNumber)
+      .locator('[class*="subTableSection"]')
+      .nth(0);
+  }
+
+  /**
+   * The deposits sub-table section — always the SECOND `class*="subTableSection"` child of
+   * the expansion panel (see `itemsSubTable` docstring for the same structural-order
+   * rationale).
+   */
+  depositsSubTable(vendorName: string, invoiceNumber: string): Locator {
+    return this.expansionPanel(vendorName, invoiceNumber)
+      .locator('[class*="subTableSection"]')
+      .nth(1);
+  }
+
+  /**
+   * A specific budget-line row within the items sub-table, matched by its description text
+   * (or `t('sourceReports.expand.unnamedLine')` for an unnamed line).
+   */
+  itemRow(vendorName: string, invoiceNumber: string, lineDescription: string): Locator {
+    return this.itemsSubTable(vendorName, invoiceNumber)
+      .locator('tbody tr')
+      .filter({ hasText: lineDescription });
+  }
+
+  /**
+   * The "Include" checkbox for a specific budget line, matched by its
+   * `aria-label="Exclude {name} from report"` (`sourceReports.expand.excludeItemAriaLabel`).
+   * Unchecking it excludes the line from the display/PDF amount (never from claim eligibility
+   * — see class docstring).
+   */
+  itemExclusionCheckbox(
+    vendorName: string,
+    invoiceNumber: string,
+    lineDescription: string,
+  ): Locator {
+    return this.itemsSubTable(vendorName, invoiceNumber).getByRole('checkbox', {
+      name: `Exclude ${lineDescription} from report`,
+    });
+  }
+
+  /**
+   * A specific deposit row within the deposits sub-table, matched by its formatted amount
+   * text (e.g. from `useFormatters().formatCurrency`).
+   */
+  depositRow(vendorName: string, invoiceNumber: string, formattedAmount: string): Locator {
+    return this.depositsSubTable(vendorName, invoiceNumber)
+      .locator('tbody tr')
+      .filter({ hasText: formattedAmount });
+  }
+
   async toggleSelectAll(): Promise<void> {
     await this.selectAllCheckbox.click();
   }
@@ -307,11 +468,111 @@ export class ReportWizardPage {
   }
 
   /**
-   * Waits for PDF generation to settle: the loading overlay disappears AND the preview
-   * iframe has a non-empty `blob:` src. PDF generation (pdfmake + pdf-lib, both loaded via
-   * dynamic `import()`) can be slow, especially on the first call of a test (cold chunk
-   * load) — callers should pair this with `test.slow()` and rely on Playwright's default
-   * generous `expect()` timeout rather than a short custom one.
+   * Copy of all Content-Security-Policy violation console messages captured since this POM
+   * was constructed (see `cspViolationMessages` field docstring). Exposed for tests that want
+   * to assert on it directly rather than only through `waitForPreviewReady`/
+   * `waitForPreviewRegenerated`'s implicit check.
+   */
+  getCspViolations(): string[] {
+    return [...this.cspViolationMessages];
+  }
+
+  /**
+   * Fetches the report wizard page's own HTTP response and returns the CSP header's
+   * `frame-src` directive as its space-separated source tokens (e.g. `["'self'", 'blob:']`).
+   * Throws if the header or the directive is missing.
+   *
+   * This is a direct server-side contract check — it fails deterministically against a
+   * pre-fix `frameSrc: ["'self'"]` `helmetPlugin.ts` config (no `blob:` token) and passes
+   * deterministically once `blob:` is added, entirely independent of what a given browser
+   * (headless or not) actually does when asked to navigate an `<iframe>` to a `blob:` PDF URL.
+   * See `assertPreviewHardened`'s docstring for why this replaced the earlier
+   * `page.frames()`-based navigation-matching technique.
+   */
+  async fetchCspFrameSrcDirective(): Promise<string[]> {
+    const response = await this.page.request.get(REPORT_WIZARD_ROUTE);
+    const cspHeader = response.headers()['content-security-policy'];
+    if (!cspHeader) {
+      throw new Error(
+        `Expected a Content-Security-Policy response header on ${REPORT_WIZARD_ROUTE}, got none.`,
+      );
+    }
+    const frameSrcMatch = cspHeader.match(/frame-src\s+([^;]+)/i);
+    const frameSrcValue = frameSrcMatch?.[1];
+    if (!frameSrcValue) {
+      throw new Error(`Expected a frame-src directive in the CSP header, got: "${cspHeader}"`);
+    }
+    return frameSrcValue.trim().split(/\s+/);
+  }
+
+  /**
+   * HARDENED proof that the report preview is genuinely permitted — Story #1891 AC, reworked
+   * TWICE per two separate TEST_ENVIRONMENT-fix follow-ups (see below for why).
+   *
+   * ATTEMPT 1 (superseded): polling `page.frames()` for a browsing-context frame whose live
+   * `url()` matched the iframe's `blob:` src attribute, treating a match as proof the
+   * navigation actually completed (as opposed to being silently CSP-blocked while the DOM
+   * `src` attribute still got set by React). That technique turned out to be UNVERIFIABLE in
+   * this project's CI environment: Playwright's bundled headless Chromium shell has no
+   * built-in PDF viewer plugin, so an `<iframe>` pointed at a PDF `blob:` URL aborts/blanks
+   * WITHOUT ever completing a navigation or firing a CSP violation — `page.frames()` never
+   * contains a matching frame REGARDLESS of whether the CSP frame-src directive is correct.
+   * Confirmed via CI run 30530648400 (shard 2): even with a 10s poll, zero frame matches AND
+   * zero CSP console violations, on a build where the `blob:` fix was already present.
+   *
+   * ATTEMPT 2 (superseded): replaced the frame-navigation check with an in-page
+   * `fetch(blobSrc)` (inside `page.evaluate`) that read the blob's size/MIME type, reasoning
+   * that a genuinely-resolvable non-empty PDF blob was proof enough on its own. That ALSO
+   * turned out to be a dead end, for a different reason: the app's own CSP `connect-src` is
+   * `'self'` and does not (and must not) include `blob:` — `fetch()`/`XHR` to a `blob:` URL is
+   * itself a `connect-src`-governed request, so the in-page fetch was blocked by the exact
+   * policy this test exists to verify. The application itself never fetches its own preview
+   * blob (the browser resolves `<iframe src="blob:...">` internally, not via `fetch`), so
+   * loosening `connect-src` to accommodate this test technique would weaken production CSP for
+   * no product reason — rejected. Confirmed via CI run 30531695763 (shard 2): every scenario
+   * failed in ~2s with `page.evaluate: TypeError: Failed to fetch`.
+   *
+   * CURRENT APPROACH — two independent, headless-safe signals, both of which must pass here,
+   * plus the plain src-attribute check callers already do before calling this method:
+   *  1. Direct CSP header assertion (`fetchCspFrameSrcDirective`) — the deterministic core. A
+   *     server-side contract check that fails against a pre-fix `frameSrc: ["'self'"]` config
+   *     and passes against the fixed `["'self'", 'blob:']` config, regardless of browser
+   *     behavior.
+   *  2. Zero CSP-violation console messages (`cspViolationMessages`) — defense in depth for
+   *     real (non-headless-shell) browsers, where a frame-src block always also logs a console
+   *     error synchronously with the blocked navigation.
+   *
+   * See the e2e-test-engineer agent memory (`general-e2e-patterns.md`) for the investigation
+   * record of both superseded attempts, and the connect-src pitfall specifically, so a future
+   * refactor doesn't re-add an in-page blob fetch.
+   */
+  private async assertPreviewHardened(): Promise<void> {
+    const frameSrcValues = await this.fetchCspFrameSrcDirective();
+    if (!frameSrcValues.includes("'self'") || !frameSrcValues.includes('blob:')) {
+      throw new Error(
+        "Expected CSP frame-src directive to include both 'self' and blob:, got: " +
+          `[${frameSrcValues.join(', ')}]`,
+      );
+    }
+
+    if (this.cspViolationMessages.length > 0) {
+      throw new Error(
+        `Detected ${this.cspViolationMessages.length} Content-Security-Policy violation ` +
+          `console message(s) while loading the report preview: ` +
+          `${this.cspViolationMessages.join('; ')}`,
+      );
+    }
+  }
+
+  /**
+   * Waits for PDF generation to settle: the loading overlay disappears, the preview iframe
+   * has a non-empty `blob:` src, AND (Story #1891 hardening) that src is proven safe — see
+   * `assertPreviewHardened`'s docstring for why the src attribute alone is not sufficient
+   * proof and why a browsing-context navigation match isn't either, in this environment. PDF
+   * generation (pdfmake + pdf-lib, both loaded via dynamic `import()`) can be slow, especially
+   * on the first call of a test (cold chunk load) — callers should pair this with
+   * `test.slow()` and rely on Playwright's default generous `expect()` timeout rather than a
+   * short custom one.
    */
   async waitForPreviewReady(): Promise<void> {
     await this.previewLoadingOverlay.waitFor({ state: 'hidden' });
@@ -320,6 +581,7 @@ export class ReportWizardPage {
     if (!src || !src.startsWith('blob:')) {
       throw new Error(`Expected preview iframe src to be a blob: URL, got "${src}"`);
     }
+    await this.assertPreviewHardened();
   }
 
   /** Current preview iframe `blob:` src, for detecting a regeneration via a src change. */
@@ -341,6 +603,9 @@ export class ReportWizardPage {
   async waitForPreviewRegenerated(previousSrc: string): Promise<void> {
     await this.previewLoadingOverlay.waitFor({ state: 'hidden' });
     await this.previewIframe.waitFor({ state: 'visible' });
+    // Poll until the src attribute actually changes from previousSrc (a fresh regeneration can
+    // race the overlay hiding), then run the same Story #1891 hardened checks — see
+    // assertPreviewHardened's docstring — once the new src has settled.
     await expect(async () => {
       const src = await this.getPreviewSrc();
       if (!src.startsWith('blob:')) {
@@ -349,7 +614,8 @@ export class ReportWizardPage {
       if (src === previousSrc) {
         throw new Error('Preview src has not changed yet — regeneration still pending');
       }
-    }).toPass();
+    }).toPass({ timeout: 10_000 });
+    await this.assertPreviewHardened();
   }
 
   async download(): Promise<Download> {
diff --git a/e2e/tests/budget/reportWizardExpansion.spec.ts b/e2e/tests/budget/reportWizardExpansion.spec.ts
new file mode 100644
index 000000000..d5d93f79d
--- /dev/null
+++ b/e2e/tests/budget/reportWizardExpansion.spec.ts
@@ -0,0 +1,790 @@
+/**
+ * E2E tests for the Bank Report Wizard follow-up (Story #1891 — expandable invoice rows,
+ * CSP `blob:` frame-src hardening, status-chip sizing fix, deposit→budget-source tagging).
+ *
+ * Covers:
+ * - Scenario 1: CSP headline — the report wizard page's own CSP response header is asserted to
+ *   have a `frame-src` directive containing both `'self'` and `blob:` (the deterministic,
+ *   headless-safe core of this proof), zero CSP-violation console messages were captured, and
+ *   the preview overlay/iframe/src reach their expected settled state (overlay hidden, iframe
+ *   visible, src is a `blob:` URL). This does NOT fetch the blob's bytes from within the page:
+ *   an in-page `fetch(blobSrc)` is itself governed by the app's CSP `connect-src 'self'` (which
+ *   does not, and must not, include `blob:` — the app itself never fetches its own preview
+ *   blob, the browser resolves `<iframe src="blob:...">` internally), so that technique is a
+ *   dead end and production CSP will not be loosened to accommodate a test. (This also replaced
+ *   an earlier `page.frames()` navigation-match technique that turned out to be unverifiable in
+ *   CI's headless Chromium shell — see `ReportWizardPage.ts`'s `assertPreviewHardened`
+ *   docstring for the full history of both superseded attempts.)
+ * - Scenario 2: Status chip width — a short label ("Paid") and a long label ("Quotation")
+ *   render at genuinely different widths, proving the chip sizes to its content instead of
+ *   stretching to a fixed grid-column width.
+ * - Scenario 3: Expand → exclude a budget line → the row's own amount, the
+ *   `SelectionActionBar` running total, AND the regenerated PDF preview all reflect the
+ *   exclusion.
+ * - Scenario 4: Full-exclusion (all lines on an invoice excluded) — the design intent (see
+ *   `ReportWizardPage.ts` class docstring, "Design decision" in the story's Frontend Spec) is
+ *   that the row clamps to €0.00 (never negative), its TriState checkbox renders unchecked
+ *   (not indeterminate), and the invoice remains counted as included for claiming/PDF
+ *   purposes. This is a regression-guard for the fixed bug #1892 (see the note below and in
+ *   `ReportWizardPage.ts`) — the row now stays visible at €0.00 instead of being filtered out
+ *   of the list entirely.
+ * - Scenario 5: A deposit tagged directly to a budget source that has ZERO budget lines for
+ *   an invoice still surfaces that invoice in the tagged source's report (Rail B), with the
+ *   deposit's "Allocated Source" column showing a tagged badge in the expansion panel, and an
+ *   empty items sub-table (proving it really is a zero-line source for this invoice).
+ * - Scenario 6: The claim-confirmation modal's warning block reports the correct count
+ *   ("1 invoice(s) will be claimed in full even though...") when an included invoice has a
+ *   partially-excluded line set (TriState indeterminate case).
+ * - Scenario 7: Regression sweep — the pre-existing `reportWizard.spec.ts` locators
+ *   (`selectAllCheckbox`, `regularInvoiceRow`, `refundRow`, `invoiceRowCheckbox`,
+ *   `clearSelectionButton`, `selectionCountLabel`) still resolve correctly against the new
+ *   `1.5rem auto 1fr auto auto auto` grid (leading chevron column added by this story).
+ *
+ * FIXED REGRESSION #1892 (Scenario 4): `applyLineExclusions()`
+ * (`client/src/lib/reportExclusions.ts`) clamps a fully-line-excluded invoice's
+ * `allocatedAmount` to exactly `0` (never negative). `ReportInvoiceList.tsx`'s
+ * `allocatedInvoices` filter now reads
+ * `inv.allocatedAmount > 0 || inv.lineKind === 'refund-adjustment' || inv.budgetLines.length > 0
+ * || inv.deposits.length > 0` — the added `budgetLines.length`/`deposits.length` clauses keep a
+ * net-zero non-refund invoice with budget lines or deposits visible as a `€0.00` row instead of
+ * being filtered out, which also preserves the only UI path back to un-excluding those lines
+ * (the row's own expand toggle). The PDF export and the actual claim submission were never
+ * affected either way — both operate on `excludedInvoiceIds` against the ORIGINAL (unfiltered)
+ * report, not the filtered display list — so this was a display-only regression, not a
+ * data-integrity one. Scenario 4 below is the regression guard for this fix.
+ *
+ * PDF generation (pdfmake + pdf-lib via dynamic `import()`) can be slow, especially on a cold
+ * chunk load — every scenario that reaches Step 4 uses `test.slow()`.
+ */
+
+import { test, expect } from '../../fixtures/auth.js';
+import type { Page } from '@playwright/test';
+import { ReportWizardPage } from '../../pages/ReportWizardPage.js';
+import {
+  createVendorViaApi,
+  deleteVendorViaApi,
+  createBudgetSourceViaApi,
+  deleteBudgetSourceViaApi,
+  createWorkItemViaApi,
+  deleteWorkItemViaApi,
+} from '../../fixtures/apiHelpers.js';
+import { API } from '../../fixtures/testData.js';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// API helpers (local — mirrors the established pattern in reportWizard.spec.ts /
+// invoices.spec.ts / invoice-deposits.spec.ts; these endpoints don't have shared
+// fixtures/apiHelpers.ts entries yet)
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface InvoiceApiResponse {
+  id: string;
+  invoiceNumber: string | null;
+  amount: number;
+  status: string;
+  vendorId: string;
+}
+
+async function createInvoiceViaApi(
+  page: Page,
+  vendorId: string,
+  data: {
+    invoiceNumber?: string;
+    amount: number;
+    date: string;
+    status?: 'pending' | 'paid' | 'claimed' | 'quotation';
+  },
+): Promise<InvoiceApiResponse> {
+  const response = await page.request.post(`${API.vendors}/${vendorId}/invoices`, {
+    data: { status: 'pending', ...data },
+  });
+  expect(response.ok(), `POST invoice failed: ${response.status()}`).toBeTruthy();
+  const body = (await response.json()) as { invoice: InvoiceApiResponse };
+  return body.invoice;
+}
+
+async function createWorkItemBudgetViaApi(
+  page: Page,
+  workItemId: string,
+  data: { plannedAmount: number; budgetSourceId: string; description?: string },
+): Promise<string> {
+  const response = await page.request.post(`${API.workItems}/${workItemId}/budgets`, {
+    data: { confidence: 'own_estimate', ...data },
+  });
+  expect(response.ok(), `POST work item budget for ${workItemId}`).toBeTruthy();
+  const body = (await response.json()) as { budget: { id: string } };
+  return body.budget.id;
+}
+
+async function linkInvoiceToBudgetLineViaApi(
+  page: Page,
+  invoiceId: string,
+  data: { workItemBudgetId: string; itemizedAmount: number },
+): Promise<void> {
+  const response = await page.request.post(`/api/invoices/${invoiceId}/budget-lines`, {
+    data,
+  });
+  expect(response.ok(), `POST invoice budget line for ${invoiceId}`).toBeTruthy();
+}
+
+/** Creates an invoice fully allocated (single budget line, no split) to `sourceId`. */
+async function seedAllocatedInvoice(
+  page: Page,
+  workItemId: string,
+  vendorId: string,
+  sourceId: string,
+  data: {
+    invoiceNumber: string;
+    amount: number;
+    date: string;
+    status: 'pending' | 'paid' | 'claimed' | 'quotation';
+  },
+): Promise<InvoiceApiResponse> {
+  const invoice = await createInvoiceViaApi(page, vendorId, data);
+  const budgetId = await createWorkItemBudgetViaApi(page, workItemId, {
+    plannedAmount: data.amount,
+    budgetSourceId: sourceId,
+  });
+  await linkInvoiceToBudgetLineViaApi(page, invoice.id, {
+    workItemBudgetId: budgetId,
+    itemizedAmount: data.amount,
+  });
+  return invoice;
+}
+
+/**
+ * Creates an invoice allocated to `sourceId` via TWO separate budget lines (one per work
+ * item, each with its own `description` so the items sub-table has distinguishable rows).
+ * Used by scenarios that exercise line-level exclusion (partial or full).
+ */
+async function seedInvoiceWithTwoLines(
+  page: Page,
+  vendorId: string,
+  sourceId: string,
+  workItemAId: string,
+  workItemBId: string,
+  data: { invoiceNumber: string; date: string; status: 'pending' | 'paid' | 'claimed' },
+  lineA: { amount: number; description: string },
+  lineB: { amount: number; description: string },
+): Promise<InvoiceApiResponse> {
+  const invoice = await createInvoiceViaApi(page, vendorId, {
+    invoiceNumber: data.invoiceNumber,
+    date: data.date,
+    status: data.status,
+    amount: lineA.amount + lineB.amount,
+  });
+  const budgetAId = await createWorkItemBudgetViaApi(page, workItemAId, {
+    plannedAmount: lineA.amount,
+    budgetSourceId: sourceId,
+    description: lineA.description,
+  });
+  await linkInvoiceToBudgetLineViaApi(page, invoice.id, {
+    workItemBudgetId: budgetAId,
+    itemizedAmount: lineA.amount,
+  });
+  const budgetBId = await createWorkItemBudgetViaApi(page, workItemBId, {
+    plannedAmount: lineB.amount,
+    budgetSourceId: sourceId,
+    description: lineB.description,
+  });
+  await linkInvoiceToBudgetLineViaApi(page, invoice.id, {
+    workItemBudgetId: budgetBId,
+    itemizedAmount: lineB.amount,
+  });
+  return invoice;
+}
+
+async function createDepositViaApi(
+  page: Page,
+  invoiceId: string,
+  data: {
+    amount: number;
+    dueDate: string;
+    status?: 'pending' | 'paid' | 'claimed';
+    entryType?: 'deposit' | 'refund';
+    budgetSourceId?: string | null;
+  },
+): Promise<{ id: string }> {
+  const response = await page.request.post(`/api/invoices/${invoiceId}/deposits`, {
+    data: { status: 'pending', ...data },
+  });
+  expect(response.ok(), `POST deposit failed: ${response.status()}`).toBeTruthy();
+  const body = (await response.json()) as { deposit: { id: string } };
+  return body.deposit;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Scenario 1: CSP headline
+// ─────────────────────────────────────────────────────────────────────────────
+
+test.describe('Report wizard expansion — CSP frame-src headline (Scenario 1)', () => {
+  test('CSP frame-src header allows blob:, zero CSP violations, and the preview settles on a blob: src', async ({
+    page,
+    testPrefix,
+  }) => {
+    test.slow();
+    const wizard = new ReportWizardPage(page);
+
+    let vendorId = '';
+    let sourceId = '';
+    let workItemId = '';
+    try {
+      vendorId = await createVendorViaApi(page, { name: `${testPrefix} CSP Vendor` });
+      sourceId = await createBudgetSourceViaApi(page, {
+        name: `${testPrefix} CSP Source`,
+        totalAmount: 10000,
+      });
+      workItemId = await createWorkItemViaApi(page, { title: `${testPrefix} WI CSP` });
+      const invoice = await seedAllocatedInvoice(page, workItemId, vendorId, sourceId, {
+        invoiceNumber: `${testPrefix}-CSP-001`,
+        amount: 200,
+        date: '2026-04-01',
+        status: 'pending',
+      });
+
+      await wizard.goto();
+      await wizard.selectUseCase('claim');
+      await wizard.goNextFromStep1();
+      await wizard.selectSource(sourceId);
+      await wizard.goNextFromStep2();
+      await expect(
+        wizard.regularInvoiceRow(`${testPrefix} CSP Vendor`, invoice.invoiceNumber!),
+      ).toBeVisible();
+      await wizard.goNextFromStep3();
+
+      // waitForPreviewReady() already runs the hardened CSP-header + zero-CSP-message proof
+      // internally (see ReportWizardPage.ts's assertPreviewHardened docstring) — this scenario
+      // ALSO re-asserts explicitly per the story's AC, so a future refactor of the POM's
+      // internal check can't silently drop this specific proof from coverage.
+      await wizard.waitForPreviewReady();
+
+      // (3) Overlay hidden + iframe visible + src is a blob: URL — already true by construction
+      // once waitForPreviewReady() resolves, re-asserted here per the story's AC.
+      const src = await wizard.getPreviewSrc();
+      expect(src).toMatch(/^blob:/);
+
+      // (1) Direct CSP header assertion — the deterministic core of this proof. Fetches the
+      // report wizard page's own HTTP response and reads its `content-security-policy`
+      // header's `frame-src` directive. This fails by construction against a pre-fix
+      // `frameSrc: ["'self'"]` helmet config (missing the `blob:` token) and passes against
+      // the fixed `["'self'", 'blob:']` config — a server-side contract check, independent of
+      // whatever a given browser does when actually asked to navigate an iframe to it.
+      const frameSrcValues = await wizard.fetchCspFrameSrcDirective();
+      expect(frameSrcValues).toContain("'self'");
+      expect(frameSrcValues).toContain('blob:');
+
+      // (2) Zero CSP-violation console messages — defense in depth for real (non-headless-
+      // shell) browsers, where a frame-src block always also logs a console error
+      // synchronously with the blocked navigation.
+      //
+      // We deliberately do NOT assert on `page.frames()` matching the iframe's own browsing
+      // context, and we deliberately do NOT `fetch()` the blob's bytes from within the page:
+      // Playwright's bundled headless Chromium shell has no built-in PDF viewer plugin, so an
+      // `<iframe src="blob:...pdf">` aborts/blanks WITHOUT ever completing navigation or firing
+      // a CSP violation, REGARDLESS of whether frame-src is correct (confirmed via CI run
+      // 30530648400, shard 2) — that frame-navigation technique is unverifiable in this
+      // environment. And an in-page `fetch(blobSrc)` is itself governed by the app's CSP
+      // `connect-src 'self'` (no `blob:` token, by design — the app never fetches its own
+      // preview blob), so it is blocked by the very policy this test verifies (confirmed via CI
+      // run 30531695763, shard 2: every scenario failed in ~2s with `page.evaluate: TypeError:
+      // Failed to fetch`). See ReportWizardPage.ts's assertPreviewHardened docstring for the
+      // full history.
+      expect(wizard.getCspViolations()).toEqual([]);
+    } finally {
+      if (workItemId) await deleteWorkItemViaApi(page, workItemId);
+      if (sourceId) await deleteBudgetSourceViaApi(page, sourceId);
+      if (vendorId) await deleteVendorViaApi(page, vendorId);
+    }
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Scenario 2: Status chip width
+// ─────────────────────────────────────────────────────────────────────────────
+
+test.describe('Report wizard expansion — status chip width (Scenario 2)', () => {
+  test('A short status label and a long status label render at genuinely different widths', async ({
+    page,
+    testPrefix,
+  }) => {
+    const wizard = new ReportWizardPage(page);
+
+    let vendorId = '';
+    let sourceId = '';
+    let workItemId = '';
+    try {
+      vendorId = await createVendorViaApi(page, { name: `${testPrefix} Chip Vendor` });
+      sourceId = await createBudgetSourceViaApi(page, {
+        name: `${testPrefix} Chip Source`,
+        totalAmount: 10000,
+      });
+      workItemId = await createWorkItemViaApi(page, { title: `${testPrefix} WI Chip` });
+
+      // budget-overview includes quotation+pending+paid+claimed — needed to see both a
+      // "Paid" (short) and a "Quotation" (long) status chip in the same report.
+      const paid = await seedAllocatedInvoice(page, workItemId, vendorId, sourceId, {
+        invoiceNumber: `${testPrefix}-CHIP-001`,
+        amount: 150,
+        date: '2026-04-02',
+        status: 'paid',
+      });
+      const quotation = await seedAllocatedInvoice(page, workItemId, vendorId, sourceId, {
+        invoiceNumber: `${testPrefix}-CHIP-002`,
+        amount: 150,
+        date: '2026-04-03',
+        status: 'quotation',
+      });
+
+      await wizard.goto();
+      await wizard.selectUseCase('budget-overview');
+      await wizard.goNextFromStep1();
+      await wizard.selectSource(sourceId);
+      await wizard.goNextFromStep2();
+
+      const vendorName = `${testPrefix} Chip Vendor`;
+      const paidChip = wizard
+        .regularInvoiceRow(vendorName, paid.invoiceNumber!)
+        .locator('[class*="statusChip"]');
+      const quotationChip = wizard
+        .regularInvoiceRow(vendorName, quotation.invoiceNumber!)
+        .locator('[class*="statusChip"]');
+      await expect(paidChip).toBeVisible();
+      await expect(quotationChip).toBeVisible();
+
+      const paidBox = await paidChip.boundingBox();
+      const quotationBox = await quotationChip.boundingBox();
+      expect(paidBox, 'Paid chip must have a bounding box').not.toBeNull();
+      expect(quotationBox, 'Quotation chip must have a bounding box').not.toBeNull();
+
+      // "Quotation" (9 chars) must render measurably wider than "Paid" (4 chars) — proves the
+      // chip sizes to its own content (justify-self: start) instead of stretching to fill a
+      // fixed grid-column width (which would make both chips identically wide regardless of
+      // label length — the pre-fix bug).
+      expect(quotationBox!.width - paidBox!.width).toBeGreaterThan(10);
+    } finally {
+      if (workItemId) await deleteWorkItemViaApi(page, workItemId);
+      if (sourceId) await deleteBudgetSourceViaApi(page, sourceId);
+      if (vendorId) await deleteVendorViaApi(page, vendorId);
+    }
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Scenario 3: Expand → exclude item → row amount + SelectionActionBar + regenerated PDF
+// ─────────────────────────────────────────────────────────────────────────────
+
+test.describe('Report wizard expansion — line exclusion updates row, total, and PDF (Scenario 3)', () => {
+  test('Excluding one of two budget lines updates the row amount, running total, and regenerates the PDF preview', async ({
+    page,
+    testPrefix,
+  }) => {
+    test.slow();
+    const wizard = new ReportWizardPage(page);
+
+    let vendorId = '';
+    let sourceId = '';
+    let workItemAId = '';
+    let workItemBId = '';
+    try {
+      vendorId = await createVendorViaApi(page, { name: `${testPrefix} Excl Vendor` });
+      sourceId = await createBudgetSourceViaApi(page, {
+        name: `${testPrefix} Excl Source`,
+        totalAmount: 10000,
+      });
+      workItemAId = await createWorkItemViaApi(page, { title: `${testPrefix} WI Excl A` });
+      workItemBId = await createWorkItemViaApi(page, { title: `${testPrefix} WI Excl B` });
+
+      const invoice = await seedInvoiceWithTwoLines(
+        page,
+        vendorId,
+        sourceId,
+        workItemAId,
+        workItemBId,
+        { invoiceNumber: `${testPrefix}-EXCL-001`, date: '2026-04-04', status: 'pending' },
+        { amount: 300, description: `${testPrefix} Line A` },
+        { amount: 200, description: `${testPrefix} Line B` },
+      );
+
+      const vendorName = `${testPrefix} Excl Vendor`;
+      await wizard.goto();
+      await wizard.selectUseCase('claim');
+      await wizard.goNextFromStep1();
+      await wizard.selectSource(sourceId);
+      await wizard.goNextFromStep2();
+
+      await expect(wizard.regularInvoiceRow(vendorName, invoice.invoiceNumber!)).toBeVisible();
+      await expect(wizard.invoiceRowAmount(vendorName, invoice.invoiceNumber!)).toContainText(
+        '500',
+      );
+
+      // Expand and verify both line rows are present before excluding anything.
+      await wizard.invoiceExpandToggle(vendorName, invoice.invoiceNumber!).click();
+      await expect(
+        wizard.itemsSubTable(vendorName, invoice.invoiceNumber!).locator('tbody tr'),
+      ).toHaveCount(2);
+      await expect(
+        wizard.itemRow(vendorName, invoice.invoiceNumber!, `${testPrefix} Line A`),
+      ).toContainText('300');
+      await expect(
+        wizard.itemRow(vendorName, invoice.invoiceNumber!, `${testPrefix} Line B`),
+      ).toContainText('200');
+
+      // Reach step 4 once to capture a baseline preview src.
+      await wizard.goNextFromStep3();
+      await wizard.waitForPreviewReady();
+      const previousSrc = await wizard.getPreviewSrc();
+
+      // Back to step 3 — ReportInvoiceList remounts (resetting local expand state) but
+      // excludedLineIds/excludedInvoiceIds live in ReportWizardPage and persist across the
+      // step navigation.
+      await wizard.goBack();
+      await wizard.invoiceExpandToggle(vendorName, invoice.invoiceNumber!).click();
+      await wizard
+        .itemExclusionCheckbox(vendorName, invoice.invoiceNumber!, `${testPrefix} Line B`)
+        .click();
+
+      // Row amount updates instantly (client-side applyLineExclusions, no network round trip).
+      await expect(wizard.invoiceRowAmount(vendorName, invoice.invoiceNumber!)).toContainText(
+        '300',
+      );
+      // Running total in the SelectionActionBar reflects the same 500 -> 300 drop.
+      await expect(wizard.selectionCountLabel).toContainText('300');
+
+      // Advancing to step 4 again proves the PDF preview regenerated for the new exclusion
+      // state (new blob: src, hardened frame-navigation + zero-CSP proof).
+      await wizard.goNextFromStep3();
+      await wizard.waitForPreviewRegenerated(previousSrc);
+    } finally {
+      if (workItemAId) await deleteWorkItemViaApi(page, workItemAId);
+      if (workItemBId) await deleteWorkItemViaApi(page, workItemBId);
+      if (sourceId) await deleteBudgetSourceViaApi(page, sourceId);
+      if (vendorId) await deleteVendorViaApi(page, vendorId);
+    }
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Scenario 4: Full-exclusion — zero not negative, TriState unchecked, still included
+// ─────────────────────────────────────────────────────────────────────────────
+
+test.describe('Report wizard expansion — full line exclusion (Scenario 4)', () => {
+  test('Excluding every line on an invoice clamps its amount to zero, renders TriState unchecked, and keeps it counted as included', async ({
+    page,
+    testPrefix,
+  }) => {
+    const wizard = new ReportWizardPage(page);
+
+    let vendorId = '';
+    let sourceId = '';
+    let workItemAId = '';
+    let workItemBId = '';
+    try {
+      vendorId = await createVendorViaApi(page, { name: `${testPrefix} FullExcl Vendor` });
+      sourceId = await createBudgetSourceViaApi(page, {
+        name: `${testPrefix} FullExcl Source`,
+        totalAmount: 10000,
+      });
+      workItemAId = await createWorkItemViaApi(page, { title: `${testPrefix} WI FullExcl A` });
+      workItemBId = await createWorkItemViaApi(page, { title: `${testPrefix} WI FullExcl B` });
+
+      const invoice = await seedInvoiceWithTwoLines(
+        page,
+        vendorId,
+        sourceId,
+        workItemAId,
+        workItemBId,
+        { invoiceNumber: `${testPrefix}-FULLEXCL-001`, date: '2026-04-05', status: 'pending' },
+        { amount: 300, description: `${testPrefix} Full Line A` },
+        { amount: 200, description: `${testPrefix} Full Line B` },
+      );
+
+      const vendorName = `${testPrefix} FullExcl Vendor`;
+      await wizard.goto();
+      await wizard.selectUseCase('claim');
+      await wizard.goNextFromStep1();
+      await wizard.selectSource(sourceId);
+      await wizard.goNextFromStep2();
+
+      await expect(wizard.regularInvoiceRow(vendorName, invoice.invoiceNumber!)).toBeVisible();
+
+      await wizard.invoiceExpandToggle(vendorName, invoice.invoiceNumber!).click();
+      await wizard
+        .itemExclusionCheckbox(vendorName, invoice.invoiceNumber!, `${testPrefix} Full Line A`)
+        .click();
+      await wizard
+        .itemExclusionCheckbox(vendorName, invoice.invoiceNumber!, `${testPrefix} Full Line B`)
+        .click();
+
+      // ── Regression guard for fixed bug #1892 (see file-level docstring + ReportWizardPage.ts
+      // class docstring) ── These assertions encode the SPEC-CONFORMANT behavior (row stays
+      // visible at €0.00, never negative): ReportInvoiceList.tsx's `allocatedInvoices` filter
+      // now keeps a net-zero non-refund invoice with budget lines or deposits in the list
+      // instead of dropping it, so the row renders at €0.00 rather than disappearing.
+      const row = wizard.invoiceRow(vendorName, invoice.invoiceNumber!);
+      await expect(row).toBeVisible();
+      const amountEl = wizard.invoiceRowAmount(vendorName, invoice.invoiceNumber!);
+      await expect(amountEl).toContainText('0');
+      await expect(amountEl).not.toContainText('-');
+
+      const parentCheckbox = wizard.invoiceRowCheckbox(vendorName, invoice.invoiceNumber!);
+      await expect(parentCheckbox).not.toBeChecked();
+      expect(
+        await parentCheckbox.evaluate((el) => (el as HTMLInputElement).indeterminate),
+        'Fully-excluded invoice must render a plain UNCHECKED TriState (not indeterminate) — ' +
+          'design spec explicitly forbids two-way sync between line and invoice exclusion',
+      ).toBe(false);
+
+      // The invoice is still counted as included (excludedInvoiceIds never touched by line
+      // exclusion) — Next must not be forward-locked by the "all invoices excluded" guard.
+      await expect(wizard.step3NextButton).toBeEnabled();
+    } finally {
+      if (workItemAId) await deleteWorkItemViaApi(page, workItemAId);
+      if (workItemBId) await deleteWorkItemViaApi(page, workItemBId);
+      if (sourceId) await deleteBudgetSourceViaApi(page, sourceId);
+      if (vendorId) await deleteVendorViaApi(page, vendorId);
+    }
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Scenario 5: Deposit tagged to a zero-line source
+// ─────────────────────────────────────────────────────────────────────────────
+
+test.describe('Report wizard expansion — deposit tagged to a zero-line source (Scenario 5)', () => {
+  test("A deposit tagged directly to a source with no budget lines for the invoice still surfaces it in that source's report, with a tagged badge and an empty items sub-table", async ({
+    page,
+    testPrefix,
+  }) => {
+    test.slow();
+    const wizard = new ReportWizardPage(page);
+
+    let vendorId = '';
+    let sourceAId = '';
+    let sourceBId = '';
+    let workItemId = '';
+    try {
+      vendorId = await createVendorViaApi(page, { name: `${testPrefix} Tag Vendor` });
+      sourceAId = await createBudgetSourceViaApi(page, {
+        name: `${testPrefix} Tag Source A`,
+        totalAmount: 10000,
+      });
+      // Source B has ZERO budget lines for this invoice — it only ever gets contribution via
+      // the tagged deposit (Rail B).
+      sourceBId = await createBudgetSourceViaApi(page, {
+        name: `${testPrefix} Tag Source B`,
+        totalAmount: 10000,
+      });
+      workItemId = await createWorkItemViaApi(page, { title: `${testPrefix} WI Tag` });
+
+      const invoice = await seedAllocatedInvoice(page, workItemId, vendorId, sourceAId, {
+        invoiceNumber: `${testPrefix}-TAG-001`,
+        amount: 1000,
+        date: '2026-04-06',
+        status: 'paid',
+      });
+      await createDepositViaApi(page, invoice.id, {
+        amount: 150,
+        dueDate: '2026-04-10',
+        status: 'paid',
+        entryType: 'deposit',
+        budgetSourceId: sourceBId,
+      });
+
+      const vendorName = `${testPrefix} Tag Vendor`;
+      await wizard.goto();
+      await wizard.selectUseCase('claim');
+      await wizard.goNextFromStep1();
+      await wizard.selectSource(sourceBId);
+      await wizard.goNextFromStep2();
+
+      // Invoice appears in Source B's report purely via the tagged deposit.
+      const row = wizard.invoiceRow(vendorName, invoice.invoiceNumber!);
+      await expect(row).toBeVisible();
+      await expect(wizard.invoiceRowAmount(vendorName, invoice.invoiceNumber!)).toContainText(
+        '150',
+      );
+
+      await wizard.invoiceExpandToggle(vendorName, invoice.invoiceNumber!).click();
+
+      // Items sub-table is empty — Source B genuinely has zero budget lines for this invoice.
+      await expect(wizard.itemsSubTable(vendorName, invoice.invoiceNumber!)).toContainText(
+        'No budget lines for this invoice',
+      );
+
+      // Deposits sub-table shows the one tagged deposit with a Source-B badge (not a plain
+      // "—") in the "Allocated Source" column.
+      const depositsTable = wizard.depositsSubTable(vendorName, invoice.invoiceNumber!);
+      const depositRowLocator = depositsTable.locator('tbody tr').first();
+      await expect(depositRowLocator).toContainText('150');
+      await expect(depositRowLocator).toContainText(`${testPrefix} Tag Source B`);
+      await expect(depositRowLocator.locator('td').last()).not.toHaveText('—');
+    } finally {
+      if (workItemId) await deleteWorkItemViaApi(page, workItemId);
+      if (sourceBId) await deleteBudgetSourceViaApi(page, sourceBId);
+      if (sourceAId) await deleteBudgetSourceViaApi(page, sourceAId);
+      if (vendorId) await deleteVendorViaApi(page, vendorId);
+    }
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Scenario 6: Claim warning count
+// ─────────────────────────────────────────────────────────────────────────────
+
+test.describe('Report wizard expansion — claim warning count (Scenario 6)', () => {
+  test('Claim confirmation shows a warning naming exactly 1 invoice when it has a partially-excluded line set', async ({
+    page,
+    testPrefix,
+  }) => {
+    test.slow();
+    const wizard = new ReportWizardPage(page);
+
+    let vendorId = '';
+    let sourceId = '';
+    let workItemAId = '';
+    let workItemBId = '';
+    try {
+      vendorId = await createVendorViaApi(page, { name: `${testPrefix} Warn Vendor` });
+      sourceId = await createBudgetSourceViaApi(page, {
+        name: `${testPrefix} Warn Source`,
+        totalAmount: 10000,
+      });
+      workItemAId = await createWorkItemViaApi(page, { title: `${testPrefix} WI Warn A` });
+      workItemBId = await createWorkItemViaApi(page, { title: `${testPrefix} WI Warn B` });
+
+      // Partial exclusion (one of two lines) keeps the net amount > 0, so the row stays
+      // visible via the normal (unaffected-by-the-Scenario-4-bug) path, and exercises the
+      // TriState INDETERMINATE case rather than full exclusion.
+      const invoice = await seedInvoiceWithTwoLines(
+        page,
+        vendorId,
+        sourceId,
+        workItemAId,
+        workItemBId,
+        { invoiceNumber: `${testPrefix}-WARN-001`, date: '2026-04-07', status: 'pending' },
+        { amount: 250, description: `${testPrefix} Warn Line A` },
+        { amount: 250, description: `${testPrefix} Warn Line B` },
+      );
+
+      const vendorName = `${testPrefix} Warn Vendor`;
+      await wizard.goto();
+      await wizard.selectUseCase('claim');
+      await wizard.goNextFromStep1();
+      await wizard.selectSource(sourceId);
+      await wizard.goNextFromStep2();
+
+      await expect(wizard.regularInvoiceRow(vendorName, invoice.invoiceNumber!)).toBeVisible();
+
+      await wizard.invoiceExpandToggle(vendorName, invoice.invoiceNumber!).click();
+      await wizard
+        .itemExclusionCheckbox(vendorName, invoice.invoiceNumber!, `${testPrefix} Warn Line A`)
+        .click();
+      await expect(wizard.invoiceRowAmount(vendorName, invoice.invoiceNumber!)).toContainText(
+        '250',
+      );
+
+      // Parent TriState is indeterminate (some but not all lines excluded), invoice itself is
+      // still included (not invoice-level excluded).
+      const parentCheckbox = wizard.invoiceRowCheckbox(vendorName, invoice.invoiceNumber!);
+      await expect(parentCheckbox).not.toBeChecked();
+      expect(await parentCheckbox.evaluate((el) => (el as HTMLInputElement).indeterminate)).toBe(
+        true,
+      );
+
+      await wizard.goNextFromStep3();
+      await wizard.waitForPreviewReady();
+
+      await wizard.clickMarkClaimed();
+      await expect(wizard.markClaimedWarningBlock).toBeVisible();
+      await expect(wizard.markClaimedWarningBlock).toHaveText(
+        /^1 invoice\(s\) will be claimed in full even though/,
+      );
+
+      await wizard.cancelClaimConfirm();
+    } finally {
+      if (workItemAId) await deleteWorkItemViaApi(page, workItemAId);
+      if (workItemBId) await deleteWorkItemViaApi(page, workItemBId);
+      if (sourceId) await deleteBudgetSourceViaApi(page, sourceId);
+      if (vendorId) await deleteVendorViaApi(page, vendorId);
+    }
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Scenario 7: Regression sweep — reportWizard.spec.ts locators against the new grid
+// ─────────────────────────────────────────────────────────────────────────────
+
+test.describe('Report wizard expansion — regression sweep of pre-existing selectors (Scenario 7)', () => {
+  test('selectAllCheckbox, refundRow, invoiceRowCheckbox, clearSelectionButton, and selectionCountLabel still resolve correctly against the new leading-chevron grid', async ({
+    page,
+    testPrefix,
+  }) => {
+    test.slow();
+    const wizard = new ReportWizardPage(page);
+
+    let vendorId = '';
+    let sourceId = '';
+    let workItemId = '';
+    try {
+      vendorId = await createVendorViaApi(page, { name: `${testPrefix} Sweep Vendor` });
+      sourceId = await createBudgetSourceViaApi(page, {
+        name: `${testPrefix} Sweep Source`,
+        totalAmount: 10000,
+      });
+      workItemId = await createWorkItemViaApi(page, { title: `${testPrefix} WI Sweep` });
+
+      const plain = await seedAllocatedInvoice(page, workItemId, vendorId, sourceId, {
+        invoiceNumber: `${testPrefix}-SWEEP-001`,
+        amount: 400,
+        date: '2026-04-08',
+        status: 'pending',
+      });
+      const refunded = await seedAllocatedInvoice(page, workItemId, vendorId, sourceId, {
+        invoiceNumber: `${testPrefix}-SWEEP-002`,
+        amount: 400,
+        date: '2026-04-09',
+        status: 'claimed', // out of 'claim' scope on its own — only its refund is in scope
+      });
+      await createDepositViaApi(page, refunded.id, {
+        amount: 100,
+        dueDate: '2026-04-12',
+        status: 'paid',
+        entryType: 'refund',
+      });
+
+      const vendorName = `${testPrefix} Sweep Vendor`;
+      await wizard.goto();
+      await wizard.selectUseCase('claim');
+      await wizard.goNextFromStep1();
+      await wizard.selectSource(sourceId);
+      await wizard.goNextFromStep2();
+
+      // Both rows present, both checked by default (select-all default).
+      await expect(wizard.regularInvoiceRow(vendorName, plain.invoiceNumber!)).toBeVisible();
+      const refundRow = wizard.refundRow(vendorName, refunded.invoiceNumber!);
+      await expect(refundRow).toBeVisible();
+      await expect(refundRow).toContainText('Refund');
+      await expect(wizard.invoiceRowCheckbox(vendorName, plain.invoiceNumber!)).toBeChecked();
+      await expect(refundRow.locator('input[type="checkbox"]')).toBeChecked();
+
+      // selectAllCheckbox reflects "all checked" -> then "some checked" (indeterminate) after
+      // one toggle.
+      await expect(wizard.selectAllCheckbox).toBeChecked();
+      await wizard.toggleInvoiceExclusion(vendorName, plain.invoiceNumber!);
+      expect(
+        await wizard.selectAllCheckbox.evaluate((el) => (el as HTMLInputElement).indeterminate),
+      ).toBe(true);
+
+      // clearSelectionButton ("Reset selection") clears all exclusions, restoring both
+      // invoices to included and the count back to 2 of 2.
+      await wizard.clearSelectionButton.click();
+      await expect(wizard.selectionCountLabel).toContainText('2 of 2');
+      await expect(wizard.invoiceRowCheckbox(vendorName, plain.invoiceNumber!)).toBeChecked();
+      await expect(refundRow.locator('input[type="checkbox"]')).toBeChecked();
+      await expect(wizard.selectAllCheckbox).toBeChecked();
+    } finally {
+      if (workItemId) await deleteWorkItemViaApi(page, workItemId);
+      if (sourceId) await deleteBudgetSourceViaApi(page, sourceId);
+      if (vendorId) await deleteVendorViaApi(page, vendorId);
+    }
+  });
+});
diff --git a/server/src/db/migrations/0044_invoice_deposit_budget_source.sql b/server/src/db/migrations/0044_invoice_deposit_budget_source.sql
new file mode 100644
index 000000000..485ac6247
--- /dev/null
+++ b/server/src/db/migrations/0044_invoice_deposit_budget_source.sql
@@ -0,0 +1,7 @@
+-- Migration 0044: Add budget_source_id to invoice_deposits
+-- Story #1891: direct optional deposit→source link (deliberately NOT via budget lines).
+-- Nullable, no backfill. Tagged deposit contributes 100% to its source in status-sliced
+-- rollups even with zero budget lines for that source (see depositAggregateUtils.ts).
+-- ROLLBACK: ALTER TABLE invoice_deposits DROP COLUMN budget_source_id;
+ALTER TABLE invoice_deposits ADD COLUMN budget_source_id TEXT REFERENCES budget_sources(id) ON DELETE SET NULL;
+CREATE INDEX idx_invoice_deposits_budget_source_id ON invoice_deposits (budget_source_id);
diff --git a/server/src/db/migrations/0044_invoice_deposit_budget_source.test.ts b/server/src/db/migrations/0044_invoice_deposit_budget_source.test.ts
new file mode 100644
index 000000000..6e091f2fc
--- /dev/null
+++ b/server/src/db/migrations/0044_invoice_deposit_budget_source.test.ts
@@ -0,0 +1,272 @@
+/**
+ * Migration integration tests for 0044_invoice_deposit_budget_source.sql
+ *
+ * Tests that:
+ *   1. Applies without error and adds budget_source_id (nullable) to invoice_deposits
+ *   2. Existing rows are unaffected (no backfill) — budget_source_id defaults to NULL
+ *   3. INSERT with a valid budget_source_id succeeds and persists
+ *   4. budget_source_id accepts NULL (deliberately not backfilled)
+ *   5. An invalid (non-existent) budget_source_id is rejected via the FK constraint
+ *      (foreign_keys pragma ON, as in production)
+ *   6. Deleting the referenced budget_source SETS NULL on invoice_deposits.budget_source_id
+ *      (ON DELETE SET NULL), not a cascade delete of the deposit
+ *   7. The idx_invoice_deposits_budget_source_id index is created
+ *   8. Applying the migration a second time is a no-op (tracked via _migrations, idempotent)
+ *
+ * Story: #1891 Bank report wizard follow-up
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import Database from 'better-sqlite3';
+import {
+  mkdtempSync,
+  symlinkSync,
+  unlinkSync,
+  existsSync,
+  readFileSync,
+  readdirSync,
+} from 'node:fs';
+import { join, dirname } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { randomUUID } from 'node:crypto';
+import { runMigrations } from '../migrate.js';
+
+const MIGRATIONS_DIR = dirname(fileURLToPath(import.meta.url));
+const TARGET_MIGRATION = '0044_invoice_deposit_budget_source.sql';
+
+/**
+ * Apply every migration that sorts before TARGET_MIGRATION (derived dynamically from the
+ * real migrations directory, so this stays correct as new migrations are added over time).
+ */
+function setupPreMigrationDb(db: Database.Database): void {
+  const allFiles = readdirSync(MIGRATIONS_DIR)
+    .filter((f) => f.endsWith('.sql'))
+    .sort();
+  const preFiles = allFiles.filter((f) => f < TARGET_MIGRATION);
+
+  const tempDir = mkdtempSync(join(tmpdir(), 'cs-mig-0044-test-'));
+  const symlinks: string[] = [];
+
+  for (const file of preFiles) {
+    const linkPath = join(tempDir, file);
+    symlinkSync(join(MIGRATIONS_DIR, file), linkPath);
+    symlinks.push(linkPath);
+  }
+
+  try {
+    runMigrations(db, tempDir);
+  } finally {
+    for (const linkPath of symlinks) {
+      if (existsSync(linkPath)) {
+        unlinkSync(linkPath);
+      }
+    }
+  }
+}
+
+/** Apply the target migration directly on a DB that already has its predecessors applied. */
+function runTargetMigration(db: Database.Database): void {
+  const sql = readFileSync(join(MIGRATIONS_DIR, TARGET_MIGRATION), 'utf-8');
+  db.exec(sql);
+  db.prepare('INSERT OR IGNORE INTO _migrations (name) VALUES (?)').run(TARGET_MIGRATION);
+}
+
+function columnExists(db: Database.Database, table: string, column: string): boolean {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return rows.some((r) => r.name === column);
+}
+
+function indexExists(db: Database.Database, indexName: string): boolean {
+  const result = db
+    .prepare(`SELECT name FROM sqlite_master WHERE type='index' AND name=?`)
+    .get(indexName) as { name: string } | undefined;
+  return result !== undefined;
+}
+
+describe('Migration 0044: Add budget_source_id to invoice_deposits', () => {
+  let sqlite: Database.Database;
+  let counter = 0;
+
+  beforeEach(() => {
+    sqlite = new Database(':memory:');
+    sqlite.pragma('journal_mode = WAL');
+    sqlite.pragma('foreign_keys = ON');
+    const originalWarn = console.warn;
+    console.warn = () => undefined;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- stash original console.warn for restore
+    (sqlite as any).__originalWarn = originalWarn;
+    counter = 0;
+  });
+
+  afterEach(() => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- restore stashed console.warn
+    const originalWarn = (sqlite as any).__originalWarn;
+    if (originalWarn) console.warn = originalWarn;
+    sqlite.close();
+  });
+
+  function ts(): string {
+    return new Date(Date.now() + counter++).toISOString();
+  }
+
+  function insertBudgetSource(): string {
+    const id = `src-${++counter}`;
+    const now = ts();
+    sqlite
+      .prepare(
+        `INSERT INTO budget_sources (id, name, source_type, total_amount, status, created_at, updated_at)
+         VALUES (?, ?, 'bank_loan', 100000, 'active', ?, ?)`,
+      )
+      .run(id, 'Test Source', now, now);
+    return id;
+  }
+
+  function insertVendor(): string {
+    const id = `vendor-${++counter}`;
+    const now = ts();
+    sqlite
+      .prepare(`INSERT INTO vendors (id, name, created_at, updated_at) VALUES (?, ?, ?, ?)`)
+      .run(id, 'Test Vendor', now, now);
+    return id;
+  }
+
+  function insertInvoice(vendorId: string): string {
+    const id = `inv-${++counter}`;
+    const now = ts();
+    sqlite
+      .prepare(
+        `INSERT INTO invoices (id, vendor_id, amount, date, status, created_at, updated_at)
+         VALUES (?, ?, 1000, '2026-01-15', 'pending', ?, ?)`,
+      )
+      .run(id, vendorId, now, now);
+    return id;
+  }
+
+  function insertDeposit(invoiceId: string, budgetSourceId: string | null = null): string {
+    const id = randomUUID();
+    const now = ts();
+    sqlite
+      .prepare(
+        `INSERT INTO invoice_deposits
+           (id, invoice_id, amount, due_date, status, entry_type, budget_source_id, created_at, updated_at)
+         VALUES (?, ?, 100, '2026-01-01', 'pending', 'deposit', ?, ?, ?)`,
+      )
+      .run(id, invoiceId, budgetSourceId, now, now);
+    return id;
+  }
+
+  it('applies without error and adds a nullable budget_source_id column', () => {
+    setupPreMigrationDb(sqlite);
+    expect(columnExists(sqlite, 'invoice_deposits', 'budget_source_id')).toBe(false);
+
+    expect(() => {
+      runTargetMigration(sqlite);
+    }).not.toThrow();
+
+    expect(columnExists(sqlite, 'invoice_deposits', 'budget_source_id')).toBe(true);
+  });
+
+  it('no backfill: a deposit inserted BEFORE the migration has budget_source_id = NULL afterward', () => {
+    setupPreMigrationDb(sqlite);
+    const vendorId = insertVendor();
+    const invoiceId = insertInvoice(vendorId);
+    const now = ts();
+    const depositId = randomUUID();
+    sqlite
+      .prepare(
+        `INSERT INTO invoice_deposits (id, invoice_id, amount, due_date, status, entry_type, created_at, updated_at)
+         VALUES (?, ?, 250, '2026-01-01', 'pending', 'deposit', ?, ?)`,
+      )
+      .run(depositId, invoiceId, now, now);
+
+    runTargetMigration(sqlite);
+
+    const row = sqlite
+      .prepare('SELECT budget_source_id FROM invoice_deposits WHERE id = ?')
+      .get(depositId) as { budget_source_id: string | null };
+    expect(row.budget_source_id).toBeNull();
+  });
+
+  it('INSERT with a valid budget_source_id succeeds and persists', () => {
+    setupPreMigrationDb(sqlite);
+    runTargetMigration(sqlite);
+
+    const sourceId = insertBudgetSource();
+    const vendorId = insertVendor();
+    const invoiceId = insertInvoice(vendorId);
+
+    const depositId = insertDeposit(invoiceId, sourceId);
+
+    const row = sqlite
+      .prepare('SELECT budget_source_id FROM invoice_deposits WHERE id = ?')
+      .get(depositId) as { budget_source_id: string | null };
+    expect(row.budget_source_id).toBe(sourceId);
+  });
+
+  it('budget_source_id accepts NULL explicitly (untagged deposit remains the default)', () => {
+    setupPreMigrationDb(sqlite);
+    runTargetMigration(sqlite);
+
+    const vendorId = insertVendor();
+    const invoiceId = insertInvoice(vendorId);
+
+    expect(() => insertDeposit(invoiceId, null)).not.toThrow();
+  });
+
+  it('an invalid (non-existent) budget_source_id is rejected by the FK constraint', () => {
+    setupPreMigrationDb(sqlite);
+    runTargetMigration(sqlite);
+
+    const vendorId = insertVendor();
+    const invoiceId = insertInvoice(vendorId);
+
+    expect(() => insertDeposit(invoiceId, 'does-not-exist')).toThrow(
+      /FOREIGN KEY constraint failed/i,
+    );
+  });
+
+  it('ON DELETE SET NULL: deleting the referenced budget source un-tags the deposit instead of deleting it', () => {
+    setupPreMigrationDb(sqlite);
+    runTargetMigration(sqlite);
+
+    const sourceId = insertBudgetSource();
+    const vendorId = insertVendor();
+    const invoiceId = insertInvoice(vendorId);
+    const depositId = insertDeposit(invoiceId, sourceId);
+
+    sqlite.prepare('DELETE FROM budget_sources WHERE id = ?').run(sourceId);
+
+    const row = sqlite
+      .prepare('SELECT id, budget_source_id FROM invoice_deposits WHERE id = ?')
+      .get(depositId) as { id: string; budget_source_id: string | null } | undefined;
+
+    // The deposit row must still exist (not cascade-deleted)...
+    expect(row).toBeDefined();
+    // ...but its budget_source_id is now NULL.
+    expect(row!.budget_source_id).toBeNull();
+  });
+
+  it('creates the idx_invoice_deposits_budget_source_id index', () => {
+    setupPreMigrationDb(sqlite);
+    runTargetMigration(sqlite);
+
+    expect(indexExists(sqlite, 'idx_invoice_deposits_budget_source_id')).toBe(true);
+  });
+
+  it('applying the migration a second time is a no-op (idempotent via _migrations)', () => {
+    setupPreMigrationDb(sqlite);
+    runTargetMigration(sqlite);
+
+    expect(() => {
+      runMigrations(sqlite);
+    }).not.toThrow();
+
+    const appliedCount = (
+      sqlite
+        .prepare('SELECT COUNT(*) AS cnt FROM _migrations WHERE name = ?')
+        .get(TARGET_MIGRATION) as { cnt: number }
+    ).cnt;
+    expect(appliedCount).toBe(1);
+  });
+});
diff --git a/server/src/db/schema.ts b/server/src/db/schema.ts
index 00e921700..7dae32338 100644
--- a/server/src/db/schema.ts
+++ b/server/src/db/schema.ts
@@ -486,12 +486,16 @@ export const invoiceDeposits = sqliteTable(
     entryType: text('entry_type', { enum: ['deposit', 'refund'] })
       .notNull()
       .default('deposit'),
+    budgetSourceId: text('budget_source_id').references(() => budgetSources.id, {
+      onDelete: 'set null',
+    }),
     createdBy: text('created_by').references(() => users.id, { onDelete: 'set null' }),
     createdAt: text('created_at').notNull(),
     updatedAt: text('updated_at').notNull(),
   },
   (table) => ({
     invoiceIdIdx: index('idx_invoice_deposits_invoice_id').on(table.invoiceId),
+    budgetSourceIdIdx: index('idx_invoice_deposits_budget_source_id').on(table.budgetSourceId),
   }),
 );
 
diff --git a/server/src/plugins/helmetPlugin.test.ts b/server/src/plugins/helmetPlugin.test.ts
index 1f9a4140e..28048c5ab 100644
--- a/server/src/plugins/helmetPlugin.test.ts
+++ b/server/src/plugins/helmetPlugin.test.ts
@@ -92,6 +92,61 @@ describe('Helmet Plugin — security headers', () => {
     expect(csp).not.toContain("frame-src 'none'");
   });
 
+  // Story #1891: blob: URLs are used for the client-side-generated PDF preview iframe
+  // (pdfmake produces a Blob, rendered via URL.createObjectURL). Without 'blob:' in
+  // frame-src, the browser blocks navigation to the blob: URL and the iframe silently
+  // stays blank (this is exactly what e2e-test-engineer's hardened waitForPreviewReady/
+  // waitForPreviewRegenerated assertions in reportWizardExpansion.spec.ts are designed
+  // to catch — see the QA spec for #1891).
+  it("CSP header's frame-src directive contains exactly \"'self' blob:\" in that order (exact emitted serialization)", async () => {
+    const response = await app.inject({
+      method: 'GET',
+      url: '/api/health',
+    });
+
+    const csp = response.headers['content-security-policy'] as string;
+    expect(csp).toBeDefined();
+    // helmet/CSP serializes each directive as "directive-name value1 value2; ..." — assert
+    // the exact frame-src clause (not just substring containment of 'blob:' anywhere in
+    // the header, which could pass even if blob: leaked into an unrelated directive).
+    const frameSrcClause = csp
+      .split(';')
+      .map((c) => c.trim())
+      .find((c) => c.startsWith('frame-src'));
+    expect(frameSrcClause).toBe("frame-src 'self' blob:");
+  });
+
+  it('CSP header directives other than frame-src are unchanged by the blob: addition', async () => {
+    const response = await app.inject({
+      method: 'GET',
+      url: '/api/health',
+    });
+
+    const csp = response.headers['content-security-policy'] as string;
+    const clauses = new Map(
+      csp
+        .split(';')
+        .map((c) => c.trim())
+        .filter(Boolean)
+        .map((c) => {
+          const [name, ...rest] = c.split(' ');
+          return [name!, rest.join(' ')];
+        }),
+    );
+
+    expect(clauses.get('default-src')).toBe("'self'");
+    expect(clauses.get('script-src')).toBe("'self'");
+    expect(clauses.get('style-src')).toBe("'self' 'unsafe-inline'");
+    expect(clauses.get('img-src')).toBe("'self' data: blob:");
+    expect(clauses.get('font-src')).toBe("'self'");
+    expect(clauses.get('connect-src')).toBe("'self'");
+    expect(clauses.get('object-src')).toBe("'none'");
+    expect(clauses.get('base-uri')).toBe("'self'");
+    expect(clauses.get('form-action')).toBe("'self'");
+    // upgrade-insecure-requests must still be absent (directive removed via `null`)
+    expect(csp).not.toContain('upgrade-insecure-requests');
+  });
+
   it("CSP header contains object-src 'none' (no <object>/<embed> allowed)", async () => {
     const response = await app.inject({
       method: 'GET',
diff --git a/server/src/plugins/helmetPlugin.ts b/server/src/plugins/helmetPlugin.ts
index 2bf25218d..e7e13da88 100644
--- a/server/src/plugins/helmetPlugin.ts
+++ b/server/src/plugins/helmetPlugin.ts
@@ -15,7 +15,7 @@ export default fp(
           // 'self' allows same-origin iframes (e.g. /api/paperless/.../preview on the auto-itemize page).
           // X-Frame-Options: SAMEORIGIN (set below via frameguard) prevents third parties from embedding
           // our app. These two directives are complementary, not redundant.
-          frameSrc: ["'self'"],
+          frameSrc: ["'self'", 'blob:'],
           objectSrc: ["'none'"],
           baseUri: ["'self'"],
           formAction: ["'self'"],
diff --git a/server/src/routes/invoiceDeposits.test.ts b/server/src/routes/invoiceDeposits.test.ts
index 0c33b479c..2d9e2f90c 100644
--- a/server/src/routes/invoiceDeposits.test.ts
+++ b/server/src/routes/invoiceDeposits.test.ts
@@ -843,4 +843,220 @@ describe('Invoice Deposit Routes', () => {
       expect(body.deposit.entryType).toBe('deposit'); // unchanged — immutable
     });
   });
+
+  // ─── budgetSourceId schema validation (Story #1891) ─────────────────────────
+
+  describe('budgetSourceId AJV schema (Story #1891)', () => {
+    function createTestBudgetSource(name = 'Test Source'): string {
+      const id = `src-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+      const ts = new Date(Date.now() + tsOffset++).toISOString();
+      app.db
+        .insert(schema.budgetSources)
+        .values({
+          id,
+          name,
+          sourceType: 'bank_loan',
+          totalAmount: 50000,
+          isDiscretionary: false,
+          status: 'active',
+          createdAt: ts,
+          updatedAt: ts,
+        })
+        .run();
+      return id;
+    }
+
+    it('POST accepts a string budgetSourceId and persists it', async () => {
+      const { cookie } = await createUserWithSession('user20@test.com', 'Test User', 'password123');
+      const vendorId = createTestVendor();
+      const invoiceId = createTestInvoice(vendorId, 1000);
+      const sourceId = createTestBudgetSource();
+
+      const response = await app.inject({
+        method: 'POST',
+        url: `/api/invoices/${invoiceId}/deposits`,
+        headers: { cookie },
+        payload: { amount: 200, dueDate: '2026-02-01', budgetSourceId: sourceId },
+      });
+
+      expect(response.statusCode).toBe(201);
+      const body = response.json<{ deposit: { budgetSourceId: string | null } }>();
+      expect(body.deposit.budgetSourceId).toBe(sourceId);
+    });
+
+    it('POST accepts an explicit null budgetSourceId', async () => {
+      const { cookie } = await createUserWithSession('user21@test.com', 'Test User', 'password123');
+      const vendorId = createTestVendor();
+      const invoiceId = createTestInvoice(vendorId, 1000);
+
+      const response = await app.inject({
+        method: 'POST',
+        url: `/api/invoices/${invoiceId}/deposits`,
+        headers: { cookie },
+        payload: { amount: 200, dueDate: '2026-02-01', budgetSourceId: null },
+      });
+
+      expect(response.statusCode).toBe(201);
+      const body = response.json<{ deposit: { budgetSourceId: string | null } }>();
+      expect(body.deposit.budgetSourceId).toBeNull();
+    });
+
+    it('POST omitting budgetSourceId entirely still succeeds and defaults to null', async () => {
+      const { cookie } = await createUserWithSession('user22@test.com', 'Test User', 'password123');
+      const vendorId = createTestVendor();
+      const invoiceId = createTestInvoice(vendorId, 1000);
+
+      const response = await app.inject({
+        method: 'POST',
+        url: `/api/invoices/${invoiceId}/deposits`,
+        headers: { cookie },
+        payload: { amount: 200, dueDate: '2026-02-01' },
+      });
+
+      expect(response.statusCode).toBe(201);
+      const body = response.json<{ deposit: { budgetSourceId: string | null } }>();
+      expect(body.deposit.budgetSourceId).toBeNull();
+    });
+
+    // NOTE: a bare number (e.g. `12345`) is NOT a suitable "wrong type" probe here — Fastify's
+    // AJV compiler runs with the default `coerceTypes: true`, which silently stringifies a
+    // JSON number into `"12345"` for a `type: ['string', 'null']` field (schema validation
+    // passes). An object/array is not coercible to a string, so it reliably reaches the AJV
+    // type-mismatch 400 path instead.
+    it('POST rejects a non-string, non-null, non-coercible budgetSourceId (e.g. an object) with 400', async () => {
+      const { cookie } = await createUserWithSession('user23@test.com', 'Test User', 'password123');
+      const vendorId = createTestVendor();
+      const invoiceId = createTestInvoice(vendorId, 1000);
+
+      const response = await app.inject({
+        method: 'POST',
+        url: `/api/invoices/${invoiceId}/deposits`,
+        headers: { cookie },
+        payload: { amount: 200, dueDate: '2026-02-01', budgetSourceId: { nested: 'object' } },
+      });
+
+      expect(response.statusCode).toBe(400);
+    });
+
+    it('POST with a number budgetSourceId is coerced to a string by AJV (not rejected) — and then fails the FK constraint as an unhandled 500, since the service layer performs no existence check (documented FK-reliant convention)', async () => {
+      const { cookie } = await createUserWithSession(
+        'user23b@test.com',
+        'Test User',
+        'password123',
+      );
+      const vendorId = createTestVendor();
+      const invoiceId = createTestInvoice(vendorId, 1000);
+
+      const response = await app.inject({
+        method: 'POST',
+        url: `/api/invoices/${invoiceId}/deposits`,
+        headers: { cookie },
+        payload: { amount: 200, dueDate: '2026-02-01', budgetSourceId: 12345 },
+      });
+
+      // Pins the CURRENT (FK-reliant, no service-level existence check) behavior: AJV
+      // coerces 12345 -> "12345", which is not a real budget source id, so the INSERT
+      // trips the SQLite FK constraint and the error propagates as an unhandled 500
+      // rather than a clean 400/404 API error. This mirrors workItemBudgetService's
+      // documented "no existence validation" convention that this story's spec follows.
+      expect(response.statusCode).toBe(500);
+    });
+
+    it('PATCH accepts a string budgetSourceId and updates it', async () => {
+      const { userId, cookie } = await createUserWithSession(
+        'user24@test.com',
+        'Test User',
+        'password123',
+      );
+      const vendorId = createTestVendor();
+      const invoiceId = createTestInvoice(vendorId, 1000);
+      const depositId = createTestDeposit(invoiceId, userId, 200, 'pending');
+      const sourceId = createTestBudgetSource();
+
+      const response = await app.inject({
+        method: 'PATCH',
+        url: `/api/invoices/${invoiceId}/deposits/${depositId}`,
+        headers: { cookie },
+        payload: { budgetSourceId: sourceId },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = response.json<{ deposit: { budgetSourceId: string | null } }>();
+      expect(body.deposit.budgetSourceId).toBe(sourceId);
+    });
+
+    it('PATCH accepts an explicit null to clear budgetSourceId', async () => {
+      const { userId, cookie } = await createUserWithSession(
+        'user25@test.com',
+        'Test User',
+        'password123',
+      );
+      const vendorId = createTestVendor();
+      const invoiceId = createTestInvoice(vendorId, 1000);
+      const sourceId = createTestBudgetSource();
+      const depositId = createTestDeposit(invoiceId, userId, 200, 'pending');
+      // Tag it first via PATCH
+      await app.inject({
+        method: 'PATCH',
+        url: `/api/invoices/${invoiceId}/deposits/${depositId}`,
+        headers: { cookie },
+        payload: { budgetSourceId: sourceId },
+      });
+
+      const response = await app.inject({
+        method: 'PATCH',
+        url: `/api/invoices/${invoiceId}/deposits/${depositId}`,
+        headers: { cookie },
+        payload: { budgetSourceId: null },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = response.json<{ deposit: { budgetSourceId: string | null } }>();
+      expect(body.deposit.budgetSourceId).toBeNull();
+    });
+
+    it('PATCH rejects a non-string, non-null budgetSourceId (e.g. an array) with 400', async () => {
+      const { userId, cookie } = await createUserWithSession(
+        'user26@test.com',
+        'Test User',
+        'password123',
+      );
+      const vendorId = createTestVendor();
+      const invoiceId = createTestInvoice(vendorId, 1000);
+      const depositId = createTestDeposit(invoiceId, userId, 200, 'pending');
+
+      const response = await app.inject({
+        method: 'PATCH',
+        url: `/api/invoices/${invoiceId}/deposits/${depositId}`,
+        headers: { cookie },
+        payload: { budgetSourceId: ['not', 'a', 'string'] },
+      });
+
+      expect(response.statusCode).toBe(400);
+    });
+
+    it('budgetSourceId can be tagged on a claimed deposit via PATCH (no status/edit-mode gating)', async () => {
+      const { userId, cookie } = await createUserWithSession(
+        'user27@test.com',
+        'Test User',
+        'password123',
+      );
+      const vendorId = createTestVendor();
+      const invoiceId = createTestInvoice(vendorId, 1000);
+      const sourceId = createTestBudgetSource();
+      const depositId = createTestDeposit(invoiceId, userId, 200, 'claimed');
+
+      const response = await app.inject({
+        method: 'PATCH',
+        url: `/api/invoices/${invoiceId}/deposits/${depositId}`,
+        headers: { cookie },
+        payload: { budgetSourceId: sourceId },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = response.json<{ deposit: { status: string; budgetSourceId: string | null } }>();
+      expect(body.deposit.status).toBe('claimed'); // status unaffected
+      expect(body.deposit.budgetSourceId).toBe(sourceId);
+    });
+  });
 });
diff --git a/server/src/routes/invoiceDeposits.ts b/server/src/routes/invoiceDeposits.ts
index 27094b5c1..490a04077 100644
--- a/server/src/routes/invoiceDeposits.ts
+++ b/server/src/routes/invoiceDeposits.ts
@@ -27,6 +27,7 @@ const createDepositSchema = {
       entryType: { type: 'string', enum: ['deposit', 'refund'] },
       paidDate: { type: ['string', 'null'] },
       claimedDate: { type: ['string', 'null'] },
+      budgetSourceId: { type: ['string', 'null'] },
     },
     additionalProperties: false,
   },
@@ -50,6 +51,7 @@ const updateDepositSchema = {
       status: { type: 'string', enum: ['pending', 'paid', 'claimed'] },
       paidDate: { type: ['string', 'null'] },
       claimedDate: { type: ['string', 'null'] },
+      budgetSourceId: { type: ['string', 'null'] },
     },
     additionalProperties: false,
     minProperties: 1,
diff --git a/server/src/routes/sourceReports.test.ts b/server/src/routes/sourceReports.test.ts
index f545ea3d6..7345a6fed 100644
--- a/server/src/routes/sourceReports.test.ts
+++ b/server/src/routes/sourceReports.test.ts
@@ -271,6 +271,34 @@ describe('Source Report Routes', () => {
       expect(body.report.totalAmount).toBeCloseTo(500);
     });
 
+    // Story #1891: response shape now includes budgetLines[]/deposits[] per invoice.
+    it('populated invoices include budgetLines[] and deposits[] arrays in the response shape', async () => {
+      const { cookie } = await createUserWithSession();
+      const sourceId = insertSource();
+      const vendorId = insertVendor();
+      const budgetId = insertWorkItemBudget(sourceId);
+      const invId = insertInvoice(vendorId, { status: 'paid', amount: 500 });
+      insertInvoiceBudgetLine(invId, budgetId, 500);
+
+      const response = await app.inject({
+        method: 'GET',
+        url: `/api/source-reports?type=claim&sourceId=${sourceId}`,
+        headers: { cookie },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = response.json<{ report: SourceReportResponse }>();
+      expect(body.report.invoices).toHaveLength(1);
+      const invoice = body.report.invoices[0]!;
+      expect(Array.isArray(invoice.budgetLines)).toBe(true);
+      expect(invoice.budgetLines).toHaveLength(1);
+      expect(invoice.budgetLines[0]).toMatchObject({
+        allocatedPortion: expect.any(Number),
+      });
+      expect(Array.isArray(invoice.deposits)).toBe(true);
+      expect(invoice.deposits).toEqual([]);
+    });
+
     it('silently strips unknown query parameters (Fastify/AJV removeAdditional default) rather than rejecting with 400', async () => {
       // @fastify/ajv-compiler defaults to removeAdditional: true — additionalProperties:
       // false STRIPS unknown properties instead of returning 400. See qa-integration-tester
diff --git a/server/src/services/budgetSourceService.test.ts b/server/src/services/budgetSourceService.test.ts
index b1725933c..d697bf7e6 100644
--- a/server/src/services/budgetSourceService.test.ts
+++ b/server/src/services/budgetSourceService.test.ts
@@ -2701,6 +2701,7 @@ describe('Budget Source Service', () => {
         amount: number;
         status: 'pending' | 'paid' | 'claimed';
         entryType?: 'deposit' | 'refund';
+        budgetSourceId?: string | null;
       },
     ): string {
       const id = `dep-src-${++workItemCounter}`;
@@ -2713,6 +2714,7 @@ describe('Budget Source Service', () => {
           dueDate: '2026-03-01',
           status: opts.status,
           entryType: opts.entryType ?? 'deposit',
+          budgetSourceId: opts.budgetSourceId ?? null,
           createdAt: ts,
           updatedAt: ts,
         })
@@ -3017,4 +3019,308 @@ describe('Budget Source Service', () => {
       });
     });
   });
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // Story #1891: Rail B — deposits tagged directly to a budget source
+  // contribute to claimed/unclaimed/discretionary amounts even with ZERO
+  // budget lines referencing that source.
+  // ═══════════════════════════════════════════════════════════════════════
+
+  describe('Rail B — tagged deposits (Story #1891)', () => {
+    function insertStandaloneInvoiceNoLines(
+      invoiceAmount: number,
+      status: 'pending' | 'paid' | 'claimed' | 'quotation',
+    ): string {
+      const ts = new Date(Date.now() + workItemCounter).toISOString();
+      const vendorId = `vendor-railb-${++workItemCounter}`;
+      db.insert(schema.vendors)
+        .values({ id: vendorId, name: `Rail B Vendor ${vendorId}`, createdAt: ts, updatedAt: ts })
+        .run();
+      const invoiceId = `inv-railb-${workItemCounter}`;
+      db.insert(schema.invoices)
+        .values({
+          id: invoiceId,
+          vendorId,
+          amount: invoiceAmount,
+          date: '2026-01-01',
+          status,
+          createdAt: ts,
+          updatedAt: ts,
+        })
+        .run();
+      return invoiceId;
+    }
+
+    function insertTaggedDeposit(
+      invoiceId: string,
+      opts: {
+        amount: number;
+        status: 'pending' | 'paid' | 'claimed';
+        entryType?: 'deposit' | 'refund';
+        budgetSourceId: string | null;
+      },
+    ): string {
+      const id = `dep-railb-${++workItemCounter}`;
+      const ts = new Date(Date.now() + workItemCounter).toISOString();
+      db.insert(schema.invoiceDeposits)
+        .values({
+          id,
+          invoiceId,
+          amount: opts.amount,
+          dueDate: '2026-03-01',
+          status: opts.status,
+          entryType: opts.entryType ?? 'deposit',
+          budgetSourceId: opts.budgetSourceId,
+          createdAt: ts,
+          updatedAt: ts,
+        })
+        .run();
+      return id;
+    }
+
+    it('a deposit tagged directly to a source with ZERO budget lines contributes to claimedAmount', () => {
+      // Source has no work_item_budgets / household_item_budgets referencing it at all —
+      // Rail A alone would report claimedAmount = 0. Rail B must still surface the tagged
+      // deposit's claimed contribution.
+      const raw = insertRawSource({ name: 'Zero-Line Tagged Source', totalAmount: 50000 });
+      const invoiceId = insertStandaloneInvoiceNoLines(1000, 'pending');
+      insertTaggedDeposit(invoiceId, { amount: 250, status: 'claimed', budgetSourceId: raw.id });
+
+      const result = budgetSourceService.getBudgetSourceById(db, raw.id);
+      expect(result.claimedAmount).toBeCloseTo(250);
+    });
+
+    it('a deposit tagged directly to a source with ZERO budget lines contributes to unclaimedAmount when paid', () => {
+      const raw = insertRawSource({ name: 'Zero-Line Unclaimed Source', totalAmount: 50000 });
+      const invoiceId = insertStandaloneInvoiceNoLines(1000, 'pending');
+      insertTaggedDeposit(invoiceId, { amount: 150, status: 'paid', budgetSourceId: raw.id });
+
+      const result = budgetSourceService.getBudgetSourceById(db, raw.id);
+      expect(result.unclaimedAmount).toBeCloseTo(150);
+      expect(result.claimedAmount).toBe(0);
+    });
+
+    it('a pending-status tagged deposit contributes to neither claimedAmount nor unclaimedAmount', () => {
+      const raw = insertRawSource({ name: 'Zero-Line Pending Source', totalAmount: 50000 });
+      const invoiceId = insertStandaloneInvoiceNoLines(1000, 'pending');
+      insertTaggedDeposit(invoiceId, { amount: 400, status: 'pending', budgetSourceId: raw.id });
+
+      const result = budgetSourceService.getBudgetSourceById(db, raw.id);
+      expect(result.claimedAmount).toBe(0);
+      expect(result.unclaimedAmount).toBe(0);
+    });
+
+    it('a deposit tagged to a DIFFERENT source does not leak into this source’s claimedAmount', () => {
+      const sourceA = insertRawSource({ name: 'Rail B Source A', totalAmount: 50000 });
+      const sourceB = insertRawSource({ name: 'Rail B Source B', totalAmount: 50000 });
+      const invoiceId = insertStandaloneInvoiceNoLines(1000, 'pending');
+      insertTaggedDeposit(invoiceId, {
+        amount: 500,
+        status: 'claimed',
+        budgetSourceId: sourceB.id,
+      });
+
+      const resultA = budgetSourceService.getBudgetSourceById(db, sourceA.id);
+      expect(resultA.claimedAmount).toBe(0);
+      const resultB = budgetSourceService.getBudgetSourceById(db, sourceB.id);
+      expect(resultB.claimedAmount).toBeCloseTo(500);
+    });
+
+    it('a refund entry tagged directly to a source nets negative against a tagged deposit in claimedAmount', () => {
+      const raw = insertRawSource({ name: 'Rail B Refund Source', totalAmount: 50000 });
+      const invoiceId = insertStandaloneInvoiceNoLines(1000, 'pending');
+      insertTaggedDeposit(invoiceId, {
+        amount: 500,
+        status: 'claimed',
+        entryType: 'deposit',
+        budgetSourceId: raw.id,
+      });
+      insertTaggedDeposit(invoiceId, {
+        amount: 200,
+        status: 'claimed',
+        entryType: 'refund',
+        budgetSourceId: raw.id,
+      });
+
+      const result = budgetSourceService.getBudgetSourceById(db, raw.id);
+      expect(result.claimedAmount).toBeCloseTo(300);
+    });
+
+    it('Rail A (line) + Rail B (tagged deposit) combine additively for the same source', () => {
+      const raw = insertRawSource({ name: 'Combined Rail Source', totalAmount: 50000 });
+      const { budgetId } = insertRawWorkItemWithSource(raw.id, 1000);
+      const ts = new Date().toISOString();
+      const vendorId = `vendor-combined-${++workItemCounter}`;
+      db.insert(schema.vendors)
+        .values({ id: vendorId, name: `Combined Vendor`, createdAt: ts, updatedAt: ts })
+        .run();
+      const invoiceId = `inv-combined-${workItemCounter}`;
+      db.insert(schema.invoices)
+        .values({
+          id: invoiceId,
+          vendorId,
+          amount: 1000,
+          date: '2026-01-01',
+          status: 'paid', // Rail A: 1000 residual, status 'paid' → claimed target excludes it
+          createdAt: ts,
+          updatedAt: ts,
+        })
+        .run();
+      db.insert(schema.invoiceBudgetLines)
+        .values({
+          id: randomUUID(),
+          invoiceId,
+          workItemBudgetId: budgetId,
+          itemizedAmount: 1000,
+          createdAt: ts,
+          updatedAt: ts,
+        })
+        .run();
+      // Rail B: a SEPARATE deposit tagged to this source on a DIFFERENT invoice.
+      const otherInvoiceId = insertStandaloneInvoiceNoLines(500, 'pending');
+      insertTaggedDeposit(otherInvoiceId, {
+        amount: 100,
+        status: 'claimed',
+        budgetSourceId: raw.id,
+      });
+
+      const result = budgetSourceService.getBudgetSourceById(db, raw.id);
+      // claimedAmount: Rail A contributes 0 (invoice paid, not claimed) + Rail B 100 = 100
+      expect(result.claimedAmount).toBeCloseTo(100);
+      // unclaimedAmount: Rail A contributes 1000 (paid, untagged, undeposited residual) + Rail B 0 = 1000
+      expect(result.unclaimedAmount).toBeCloseTo(1000);
+    });
+
+    it("canonical same-invoice case: a tagged deposit combines additively with the SAME invoice's residual to net exactly the invoice amount, and the untagged/legacy path is unaffected", () => {
+      // Canonical repro (Story #1891 double-count bug): a €1000 paid invoice, a €1000 line to
+      // source S, and a €400 claimed deposit tagged to S — all on the SAME invoice (unlike the
+      // "combine additively" test above, which uses two different invoices).
+      const raw = insertRawSource({ name: 'Canonical Same-Invoice Source', totalAmount: 50000 });
+      const { budgetId } = insertRawWorkItemWithSource(raw.id, 1000);
+      const ts = new Date().toISOString();
+      const vendorId = `vendor-canonical-${++workItemCounter}`;
+      db.insert(schema.vendors)
+        .values({ id: vendorId, name: `Canonical Vendor`, createdAt: ts, updatedAt: ts })
+        .run();
+      const invoiceId = `inv-canonical-${workItemCounter}`;
+      db.insert(schema.invoices)
+        .values({
+          id: invoiceId,
+          vendorId,
+          amount: 1000,
+          date: '2026-01-01',
+          status: 'paid',
+          createdAt: ts,
+          updatedAt: ts,
+        })
+        .run();
+      db.insert(schema.invoiceBudgetLines)
+        .values({
+          id: randomUUID(),
+          invoiceId,
+          workItemBudgetId: budgetId,
+          itemizedAmount: 1000,
+          createdAt: ts,
+          updatedAt: ts,
+        })
+        .run();
+      insertTaggedDeposit(invoiceId, { amount: 400, status: 'claimed', budgetSourceId: raw.id });
+
+      const result = budgetSourceService.getBudgetSourceById(db, raw.id);
+
+      // Rail B (tagged deposit) counts 100% toward claimedAmount: deposit status 'claimed' → 400.
+      // Rail A (line share) still has the tagged deposit subtracted from its residual
+      // denominator (even though it's omitted from Rail A's depositFractions):
+      // residual = (1000 - 400) / 1000 = 0.6. Invoice status 'paid' → residual contributes to
+      // unclaimedAmount: 1000 * 0.6 = 600.
+      expect(result.claimedAmount).toBeCloseTo(400);
+      expect(result.unclaimedAmount).toBeCloseTo(600);
+      // paidAmount = claimedAmount + unclaimedAmount = 400 + 600 = 1000, exactly the invoice
+      // amount — NOT 1400 (what the pre-fix bug produced by treating the tagged deposit as if
+      // it didn't exist at all in Rail A's residual computation, so nothing was subtracted).
+      expect(result.paidAmount).toBeCloseTo(1000);
+
+      // Legacy path: prove the fix leaves UNTAGGED deposits untouched. Same fixture shape,
+      // but the deposit is left untagged (budgetSourceId: null) — this exercises the exact
+      // computeStatusContributionExcludingTagged code path that behaves byte-identically to
+      // the pre-#1891 computeStatusContribution for untagged rows (see the "regression:
+      // untagged fixtures produce byte-identical output" tests in depositAggregateUtils.test.ts).
+      const legacyRaw = insertRawSource({ name: 'Canonical Legacy Source', totalAmount: 50000 });
+      const { budgetId: legacyBudgetId } = insertRawWorkItemWithSource(legacyRaw.id, 1000);
+      const legacyVendorId = `vendor-legacy-${++workItemCounter}`;
+      db.insert(schema.vendors)
+        .values({ id: legacyVendorId, name: `Legacy Vendor`, createdAt: ts, updatedAt: ts })
+        .run();
+      const legacyInvoiceId = `inv-legacy-${workItemCounter}`;
+      db.insert(schema.invoices)
+        .values({
+          id: legacyInvoiceId,
+          vendorId: legacyVendorId,
+          amount: 1000,
+          date: '2026-01-01',
+          status: 'paid',
+          createdAt: ts,
+          updatedAt: ts,
+        })
+        .run();
+      db.insert(schema.invoiceBudgetLines)
+        .values({
+          id: randomUUID(),
+          invoiceId: legacyInvoiceId,
+          workItemBudgetId: legacyBudgetId,
+          itemizedAmount: 1000,
+          createdAt: ts,
+          updatedAt: ts,
+        })
+        .run();
+      insertTaggedDeposit(legacyInvoiceId, {
+        amount: 400,
+        status: 'claimed',
+        budgetSourceId: null,
+      });
+
+      const legacyResult = budgetSourceService.getBudgetSourceById(db, legacyRaw.id);
+      // Untagged deposit: residual and deposit fraction both derive from the same source's own
+      // lines, so claimedAmount(400)/unclaimedAmount(600) split identically here — the point is
+      // that paidAmount still nets to exactly 1000, proving legacy (untagged) behavior is
+      // unaffected by the Rail A/Rail B tagging fix.
+      expect(legacyResult.paidAmount).toBeCloseTo(1000);
+    });
+
+    describe('discretionary variant: tagged deposit on the discretionary source', () => {
+      it('a deposit tagged directly to the discretionary source contributes to discretionary claimedAmount', () => {
+        const invoiceId = insertStandaloneInvoiceNoLines(1000, 'pending');
+        insertTaggedDeposit(invoiceId, {
+          amount: 350,
+          status: 'claimed',
+          budgetSourceId: 'discretionary-system',
+        });
+
+        const disc = getDiscretionarySource();
+        expect(disc.claimedAmount).toBeCloseTo(350);
+      });
+
+      it('a deposit tagged directly to the discretionary source contributes to discretionary unclaimedAmount when paid', () => {
+        const invoiceId = insertStandaloneInvoiceNoLines(1000, 'pending');
+        insertTaggedDeposit(invoiceId, {
+          amount: 200,
+          status: 'paid',
+          budgetSourceId: 'discretionary-system',
+        });
+
+        const disc = getDiscretionarySource();
+        expect(disc.unclaimedAmount).toBeCloseTo(200);
+        expect(disc.claimedAmount).toBe(0);
+      });
+
+      it('a deposit tagged to a NON-discretionary source does not leak into discretionary amounts', () => {
+        const raw = insertRawSource({ name: 'Non-Discretionary Tag Target', totalAmount: 50000 });
+        const invoiceId = insertStandaloneInvoiceNoLines(1000, 'pending');
+        insertTaggedDeposit(invoiceId, { amount: 300, status: 'claimed', budgetSourceId: raw.id });
+
+        const disc = getDiscretionarySource();
+        expect(disc.claimedAmount).toBe(0);
+      });
+    });
+  });
 });
diff --git a/server/src/services/budgetSourceService.ts b/server/src/services/budgetSourceService.ts
index cfd874fea..5744f78fd 100644
--- a/server/src/services/budgetSourceService.ts
+++ b/server/src/services/budgetSourceService.ts
@@ -15,8 +15,9 @@ import {
 } from '../db/schema.js';
 import { deleteLinksForEntity } from './documentLinkService.js';
 import {
-  computeStatusContribution,
-  splitByDeposits,
+  computeStatusContributionExcludingTagged,
+  splitByDepositsExcludingTagged,
+  sumTaggedDepositContributions,
   type DepositAwareRow,
 } from './shared/depositAggregateUtils.js';
 import type {
@@ -124,12 +125,14 @@ function computeUsedAmount(db: DbType, sourceId: string): number {
 
 /**
  * Compute the claimed amount for a budget source.
+ * Story #1891: Rail A (line-derived via ExcludingTagged) + Rail B (tagged deposits).
  * Sums claimed contributions from invoice budget lines linked to this source,
- * including deposits split proportionally by amount.
- * Returns 0 if no claimed invoices exist.
+ * plus direct contributions from deposits tagged to this source.
+ * Returns 0 if no claimed invoices/deposits exist.
  */
 function computeClaimedAmount(db: DbType, sourceId: string): number {
-  const rows = db.all<DepositAwareRow>(
+  // Rail A: invoice budget lines (excluding tagged deposits)
+  const railARows = db.all<DepositAwareRow & { deposit_budget_source_id: string | null }>(
     sql`SELECT
       ibl.id              AS ibl_id,
       ibl.itemized_amount AS itemized_amount,
@@ -139,7 +142,8 @@ function computeClaimedAmount(db: DbType, sourceId: string): number {
       d.id                AS deposit_id,
       d.amount            AS deposit_amount,
       d.status            AS deposit_status,
-      d.entry_type        AS deposit_entry_type
+      d.entry_type        AS deposit_entry_type,
+      d.budget_source_id  AS deposit_budget_source_id
     FROM invoice_budget_lines ibl
     INNER JOIN invoices i ON i.id = ibl.invoice_id
     LEFT JOIN invoice_deposits d ON d.invoice_id = i.id
@@ -156,17 +160,37 @@ function computeClaimedAmount(db: DbType, sourceId: string): number {
     )`,
   );
 
-  return computeStatusContribution(rows, 'claimed');
+  const railAAmount = computeStatusContributionExcludingTagged(railARows, 'claimed');
+
+  // Rail B: deposits tagged to this source
+  const railBRows = db.all<{
+    amount: number;
+    status: string;
+    entryType: string;
+  }>(
+    sql`SELECT
+      d.amount AS amount,
+      d.status AS status,
+      d.entry_type AS entryType
+    FROM invoice_deposits d
+    WHERE d.budget_source_id = ${sourceId}`,
+  );
+
+  const railBAmount = sumTaggedDepositContributions(railBRows, new Set(['claimed']));
+
+  return railAAmount + railBAmount;
 }
 
 /**
  * Compute the unclaimed (paid but not claimed) amount for a budget source.
+ * Story #1891: Rail A (line-derived via ExcludingTagged) + Rail B (tagged deposits).
  * Sums paid contributions from invoice budget lines linked to this source,
- * including deposits split proportionally by amount.
- * Returns 0 if no paid invoices exist.
+ * plus direct contributions from deposits tagged to this source.
+ * Returns 0 if no paid invoices/deposits exist.
  */
 function computeUnclaimedAmount(db: DbType, sourceId: string): number {
-  const rows = db.all<DepositAwareRow>(
+  // Rail A: invoice budget lines (excluding tagged deposits)
+  const railARows = db.all<DepositAwareRow & { deposit_budget_source_id: string | null }>(
     sql`SELECT
       ibl.id              AS ibl_id,
       ibl.itemized_amount AS itemized_amount,
@@ -176,7 +200,8 @@ function computeUnclaimedAmount(db: DbType, sourceId: string): number {
       d.id                AS deposit_id,
       d.amount            AS deposit_amount,
       d.status            AS deposit_status,
-      d.entry_type        AS deposit_entry_type
+      d.entry_type        AS deposit_entry_type,
+      d.budget_source_id  AS deposit_budget_source_id
     FROM invoice_budget_lines ibl
     INNER JOIN invoices i ON i.id = ibl.invoice_id
     LEFT JOIN invoice_deposits d ON d.invoice_id = i.id
@@ -193,7 +218,25 @@ function computeUnclaimedAmount(db: DbType, sourceId: string): number {
     )`,
   );
 
-  return computeStatusContribution(rows, 'paid');
+  const railAAmount = computeStatusContributionExcludingTagged(railARows, 'paid');
+
+  // Rail B: deposits tagged to this source
+  const railBRows = db.all<{
+    amount: number;
+    status: string;
+    entryType: string;
+  }>(
+    sql`SELECT
+      d.amount AS amount,
+      d.status AS status,
+      d.entry_type AS entryType
+    FROM invoice_deposits d
+    WHERE d.budget_source_id = ${sourceId}`,
+  );
+
+  const railBAmount = sumTaggedDepositContributions(railBRows, new Set(['paid']));
+
+  return railAAmount + railBAmount;
 }
 
 /**
@@ -214,25 +257,36 @@ function countBudgetLineReferences(db: DbType, sourceId: string): number {
 
 /**
  * Compute the discretionary invoice amount for a given status.
+ * Story #1891: Rail A (unallocated remainder + unallocated lines, excluding tagged deposits) + Rail B (tagged to discretionary source).
  * Includes:
  * 1. Unallocated remainder: invoice.amount - SUM(itemized_amount) for invoices with this status,
- *    split proportionally by deposits
+ *    split proportionally by deposits (excluding tagged)
  * 2. Lines with no budget_source: amount allocated to budget lines where source is NULL,
- *    split proportionally by deposits
+ *    split proportionally by deposits (excluding tagged)
+ * 3. Deposits tagged to the discretionary source
  */
 function computeDiscretionaryInvoiceAmount(db: DbType, status: string): number {
-  // 1. Unallocated remainder with deposit-aware split
-  // Fetch all invoices with unallocated remainder, along with their deposits
-  const remainderRows = db.all<{
-    invoice_id: string;
-    invoice_amount: number;
-    invoice_status: string;
-    total_itemized: number | null;
-    deposit_id: string | null;
-    deposit_amount: number | null;
-    deposit_status: string | null;
-    deposit_entry_type: string | null;
-  }>(
+  // Find the discretionary source ID
+  const discretionarySource = db
+    .select()
+    .from(budgetSources)
+    .where(eq(budgetSources.isDiscretionary, true))
+    .get();
+  const discretionarySourceId = discretionarySource?.id;
+
+  // 1. Unallocated remainder with deposit-aware split (excluding tagged)
+  const remainderRows = db.all<
+    {
+      invoice_id: string;
+      invoice_amount: number;
+      invoice_status: string;
+      total_itemized: number | null;
+      deposit_id: string | null;
+      deposit_amount: number | null;
+      deposit_status: string | null;
+      deposit_entry_type: string | null;
+    } & { deposit_budget_source_id: string | null }
+  >(
     sql`SELECT
       i.id              AS invoice_id,
       i.amount          AS invoice_amount,
@@ -241,7 +295,8 @@ function computeDiscretionaryInvoiceAmount(db: DbType, status: string): number {
       d.id              AS deposit_id,
       d.amount          AS deposit_amount,
       d.status          AS deposit_status,
-      d.entry_type      AS deposit_entry_type
+      d.entry_type      AS deposit_entry_type,
+      d.budget_source_id AS deposit_budget_source_id
     FROM invoices i
     LEFT JOIN invoice_budget_lines ibl ON ibl.invoice_id = i.id
     LEFT JOIN invoice_deposits d ON d.invoice_id = i.id
@@ -253,10 +308,8 @@ function computeDiscretionaryInvoiceAmount(db: DbType, status: string): number {
     HAVING (i.amount - COALESCE(SUM(ibl.itemized_amount), 0)) > 0`,
   );
 
-  // Build remainder amounts map and split by deposits
   let remainderTotal = 0;
   if (remainderRows.length > 0) {
-    // First pass: collect remainder amounts
     const remainderAmountByInvoice = new Map<string, number>();
     for (const row of remainderRows) {
       if (!remainderAmountByInvoice.has(row.invoice_id)) {
@@ -265,20 +318,16 @@ function computeDiscretionaryInvoiceAmount(db: DbType, status: string): number {
       }
     }
 
-    // Split invoices by deposits
-    const splitsByInvoiceId = splitByDeposits(remainderRows);
+    const splitsByInvoiceId = splitByDepositsExcludingTagged(remainderRows);
 
-    // Compute proportional split for remainder
     for (const [invoiceId, split] of splitsByInvoiceId) {
       const remainderAmount = remainderAmountByInvoice.get(invoiceId)!;
 
-      // Residual contribution under parent invoice status
       const residualAmount = remainderAmount * split.residualFraction;
       if (split.invoiceStatus === status) {
         remainderTotal += residualAmount;
       }
 
-      // Per-deposit contributions
       for (const df of split.depositFractions) {
         if (df.depositStatus === status) {
           const depositContribution = remainderAmount * df.fraction;
@@ -288,8 +337,8 @@ function computeDiscretionaryInvoiceAmount(db: DbType, status: string): number {
     }
   }
 
-  // 2. Lines with no budget_source with deposit-aware split
-  const noSourceRows = db.all<DepositAwareRow>(
+  // 2. Lines with no budget_source with deposit-aware split (excluding tagged)
+  const noSourceRows = db.all<DepositAwareRow & { deposit_budget_source_id: string | null }>(
     sql`SELECT
       ibl.id              AS ibl_id,
       ibl.itemized_amount AS itemized_amount,
@@ -299,7 +348,8 @@ function computeDiscretionaryInvoiceAmount(db: DbType, status: string): number {
       d.id                AS deposit_id,
       d.amount            AS deposit_amount,
       d.status            AS deposit_status,
-      d.entry_type        AS deposit_entry_type
+      d.entry_type        AS deposit_entry_type,
+      d.budget_source_id  AS deposit_budget_source_id
     FROM invoice_budget_lines ibl
     INNER JOIN invoices i ON i.id = ibl.invoice_id
     LEFT JOIN invoice_deposits d ON d.invoice_id = i.id
@@ -316,9 +366,31 @@ function computeDiscretionaryInvoiceAmount(db: DbType, status: string): number {
     )`,
   );
 
-  const noSourceTotal = computeStatusContribution(noSourceRows, status);
+  const noSourceTotal = computeStatusContributionExcludingTagged(noSourceRows, status);
+
+  // 3. Rail B: Deposits tagged to discretionary source (if it exists)
+  let railBAmount = 0;
+  if (discretionarySourceId) {
+    const railBRows = db.all<{
+      amount: number;
+      status: string;
+      entryType: string;
+    }>(
+      sql`SELECT
+        d.amount AS amount,
+        d.status AS status,
+        d.entry_type AS entryType
+      FROM invoice_deposits d
+      WHERE d.budget_source_id = ${discretionarySourceId}`,
+    );
+
+    railBAmount = sumTaggedDepositContributions(
+      railBRows,
+      new Set([status === 'claimed' ? 'claimed' : 'paid']),
+    );
+  }
 
-  return remainderTotal + noSourceTotal;
+  return remainderTotal + noSourceTotal + railBAmount;
 }
 
 /**
diff --git a/server/src/services/invoiceDepositService.test.ts b/server/src/services/invoiceDepositService.test.ts
index cebc6ce20..2f4f5ea43 100644
--- a/server/src/services/invoiceDepositService.test.ts
+++ b/server/src/services/invoiceDepositService.test.ts
@@ -1516,4 +1516,161 @@ describe('invoiceDepositService', () => {
       }).toThrow('claimedDate must be a valid ISO date (YYYY-MM-DD)');
     });
   });
+
+  // ─── budgetSourceId (Story #1891) ───────────────────────────────────────────
+
+  describe('budgetSourceId (Story #1891)', () => {
+    function createTestBudgetSource(name = 'Test Source'): string {
+      const id = `src-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+      const ts = new Date(Date.now() + tsOffset++).toISOString();
+      db.insert(schema.budgetSources)
+        .values({
+          id,
+          name,
+          sourceType: 'bank_loan',
+          totalAmount: 50000,
+          isDiscretionary: false,
+          status: 'active',
+          createdAt: ts,
+          updatedAt: ts,
+        })
+        .run();
+      return id;
+    }
+
+    it('createDeposit with no budgetSourceId defaults to null', () => {
+      const { userId, invoiceId } = setup();
+
+      const deposit = createDeposit(db, invoiceId, { amount: 300, dueDate: '2026-02-01' }, userId);
+
+      expect(deposit.budgetSourceId).toBeNull();
+    });
+
+    it('createDeposit persists a provided budgetSourceId', () => {
+      const { userId, invoiceId } = setup();
+      const sourceId = createTestBudgetSource();
+
+      const deposit = createDeposit(
+        db,
+        invoiceId,
+        { amount: 300, dueDate: '2026-02-01', budgetSourceId: sourceId },
+        userId,
+      );
+
+      expect(deposit.budgetSourceId).toBe(sourceId);
+
+      const row = sqlite
+        .prepare('SELECT budget_source_id FROM invoice_deposits WHERE id = ?')
+        .get(deposit.id) as { budget_source_id: string | null };
+      expect(row.budget_source_id).toBe(sourceId);
+    });
+
+    it('createDeposit with budgetSourceId explicitly null persists null (not undefined-coerced-to-something-else)', () => {
+      const { userId, invoiceId } = setup();
+
+      const deposit = createDeposit(
+        db,
+        invoiceId,
+        { amount: 300, dueDate: '2026-02-01', budgetSourceId: null },
+        userId,
+      );
+
+      expect(deposit.budgetSourceId).toBeNull();
+    });
+
+    it('updateDeposit sets budgetSourceId on a deposit that previously had none', () => {
+      const { userId, invoiceId } = setup();
+      const sourceId = createTestBudgetSource();
+      const deposit = createDeposit(db, invoiceId, { amount: 300, dueDate: '2026-02-01' }, userId);
+      expect(deposit.budgetSourceId).toBeNull();
+
+      const updated = updateDeposit(db, invoiceId, deposit.id, { budgetSourceId: sourceId });
+
+      expect(updated.budgetSourceId).toBe(sourceId);
+    });
+
+    it('updateDeposit clears budgetSourceId back to null', () => {
+      const { userId, invoiceId } = setup();
+      const sourceId = createTestBudgetSource();
+      const deposit = createDeposit(
+        db,
+        invoiceId,
+        { amount: 300, dueDate: '2026-02-01', budgetSourceId: sourceId },
+        userId,
+      );
+      expect(deposit.budgetSourceId).toBe(sourceId);
+
+      const updated = updateDeposit(db, invoiceId, deposit.id, { budgetSourceId: null });
+
+      expect(updated.budgetSourceId).toBeNull();
+    });
+
+    it('updateDeposit re-tags a deposit from one source to another', () => {
+      const { userId, invoiceId } = setup();
+      const sourceA = createTestBudgetSource('Source A');
+      const sourceB = createTestBudgetSource('Source B');
+      const deposit = createDeposit(
+        db,
+        invoiceId,
+        { amount: 300, dueDate: '2026-02-01', budgetSourceId: sourceA },
+        userId,
+      );
+
+      const updated = updateDeposit(db, invoiceId, deposit.id, { budgetSourceId: sourceB });
+
+      expect(updated.budgetSourceId).toBe(sourceB);
+    });
+
+    it('updateDeposit omitting budgetSourceId entirely leaves the existing tag untouched', () => {
+      const { userId, invoiceId } = setup();
+      const sourceId = createTestBudgetSource();
+      const deposit = createDeposit(
+        db,
+        invoiceId,
+        { amount: 300, dueDate: '2026-02-01', budgetSourceId: sourceId },
+        userId,
+      );
+
+      // Update something unrelated (description) without mentioning budgetSourceId at all.
+      const updated = updateDeposit(db, invoiceId, deposit.id, { description: 'renamed' });
+
+      expect(updated.budgetSourceId).toBe(sourceId);
+      expect(updated.description).toBe('renamed');
+    });
+
+    it('budgetSourceId can be set/edited regardless of the deposit’s current status (no edit-mode gating)', () => {
+      const { userId, invoiceId } = setup();
+      const sourceId = createTestBudgetSource();
+      const deposit = createDeposit(
+        db,
+        invoiceId,
+        { amount: 300, dueDate: '2026-02-01', status: 'claimed' },
+        userId,
+      );
+      expect(deposit.status).toBe('claimed');
+
+      // Tagging a budget source is independent of the status state machine — must not throw.
+      const updated = updateDeposit(db, invoiceId, deposit.id, { budgetSourceId: sourceId });
+
+      expect(updated.budgetSourceId).toBe(sourceId);
+      expect(updated.status).toBe('claimed'); // status unaffected
+    });
+
+    it('budgetSourceId is not validated for existence (FK-reliant, per workItemBudgetService convention) — an unknown id is stored as-is at the service layer', () => {
+      // The service layer does not perform an existence check (relies on the SQLite FK
+      // constraint to reject truly invalid references at the DB layer). This test pins that
+      // documented behavior: a syntactically well-formed but non-existent id raises the
+      // underlying FK error, not a service-level NotFoundError/ValidationError.
+      const { userId, invoiceId } = setup();
+
+      expect(() => {
+        createDeposit(
+          db,
+          invoiceId,
+          { amount: 300, dueDate: '2026-02-01', budgetSourceId: 'does-not-exist' },
+          userId,
+        );
+      }).toThrow(/FOREIGN KEY constraint failed/i);
+    });
+  });
 });
diff --git a/server/src/services/invoiceDepositService.ts b/server/src/services/invoiceDepositService.ts
index 8af61006d..f7c1dedad 100644
--- a/server/src/services/invoiceDepositService.ts
+++ b/server/src/services/invoiceDepositService.ts
@@ -85,6 +85,7 @@ function toInvoiceDeposit(db: DbType, row: typeof invoiceDeposits.$inferSelect):
     description: row.description,
     status: row.status as InvoiceDepositStatus,
     entryType: row.entryType as InvoiceDepositEntryType,
+    budgetSourceId: row.budgetSourceId,
     createdBy: toUserSummary(createdByUser),
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
@@ -286,6 +287,7 @@ export function createDeposit(
         description: data.description ?? null,
         status: targetStatus,
         entryType,
+        budgetSourceId: data.budgetSourceId ?? null,
         createdBy: userId,
         createdAt: now,
         updatedAt: now,
@@ -357,6 +359,11 @@ export function updateDeposit(
     updates.description = data.description ?? null;
   }
 
+  // Update budgetSourceId if provided
+  if (data.budgetSourceId !== undefined) {
+    updates.budgetSourceId = data.budgetSourceId ?? null;
+  }
+
   // Handle status transition if provided
   if (data.status !== undefined) {
     const newStatus = data.status;
diff --git a/server/src/services/invoiceService.test.ts b/server/src/services/invoiceService.test.ts
index 27b8cf0bc..81a6de773 100644
--- a/server/src/services/invoiceService.test.ts
+++ b/server/src/services/invoiceService.test.ts
@@ -825,8 +825,7 @@ describe('Invoice Service', () => {
       invoiceService.updateInvoice(db, vendorAId, invoiceId, { vendorId: vendorBId });
 
       const row = sqlite.prepare('SELECT * FROM invoice_deposits WHERE id = ?').get(depositId) as
-        | { invoice_id: string }
-        | undefined;
+        { invoice_id: string } | undefined;
       expect(row).toBeDefined();
       expect(row!.invoice_id).toBe(invoiceId);
     });
@@ -1812,8 +1811,7 @@ describe('Invoice Service', () => {
 
       // Deposit must still exist and be linked to the same invoice
       const row = sqlite.prepare('SELECT * FROM invoice_deposits WHERE id = ?').get(depositId) as
-        | { invoice_id: string }
-        | undefined;
+        { invoice_id: string } | undefined;
 
       expect(row).toBeDefined();
       expect(row!.invoice_id).toBe(invoiceId);
diff --git a/server/src/services/invoiceService.ts b/server/src/services/invoiceService.ts
index b805e2994..242f8f39b 100644
--- a/server/src/services/invoiceService.ts
+++ b/server/src/services/invoiceService.ts
@@ -99,6 +99,7 @@ export function toInvoice(
       description: depositRow.description,
       status: depositRow.status,
       entryType: depositRow.entryType,
+      budgetSourceId: depositRow.budgetSourceId,
       createdBy: toUserSummary(depositCreatedByUser),
       createdAt: depositRow.createdAt,
       updatedAt: depositRow.updatedAt,
diff --git a/server/src/services/shared/depositAggregateUtils.test.ts b/server/src/services/shared/depositAggregateUtils.test.ts
index 140c00ad4..93a69b935 100644
--- a/server/src/services/shared/depositAggregateUtils.test.ts
+++ b/server/src/services/shared/depositAggregateUtils.test.ts
@@ -7,6 +7,11 @@ import {
   splitByDeposits,
   computeFinalPaymentAmount,
   computeFinalPaymentAmounts,
+  splitByDepositsExcludingTagged,
+  computeLineContributionsExcludingTagged,
+  computeStatusContributionExcludingTagged,
+  sumTaggedDepositContributions,
+  sumTaggedDepositContributionsByInvoice,
   type DepositAwareRow,
   type InvoiceDepositRow,
 } from './depositAggregateUtils.js';
@@ -1272,3 +1277,342 @@ describe('computeFinalPaymentAmounts', () => {
     expect(result.get('inv-1')).toBe(10000);
   });
 });
+
+// ═════════════════════════════════════════════════════════════════════════
+// Story #1891: Rail A/Rail B additive functions
+// ═════════════════════════════════════════════════════════════════════════
+//
+// Design invariant under test: these five functions are PURELY ADDITIVE. The six
+// legacy functions above (splitByDeposits, computeStatusContribution,
+// computeStatusContributionByInvoice, aggregateInvoiceStatusBreakdown,
+// computeFinalPaymentAmount(s)) must remain byte-identical for their existing
+// consumers (budgetOverviewService, budgetBreakdownService, invoiceService,
+// budgetServiceFactory — none of which have a reporting-source concept). The
+// tests above already exercise the legacy functions completely unmodified,
+// which is the primary regression proof (if this PR touched their logic, those
+// tests would fail). The tests below add an EXPLICIT, direct comparison: running
+// the same untagged fixture through both the legacy function and its
+// ExcludingTagged sibling must produce identical output, proving the new
+// "exclude tagged deposits" branch is a true no-op when nothing is tagged.
+
+/**
+ * Build a row shaped for splitByDepositsExcludingTagged / computeStatusContributionExcludingTagged
+ * (adds deposit_budget_source_id on top of the legacy makeSplitRow shape).
+ */
+function makeTaggableSplitRow(
+  invoiceId: string,
+  invoiceAmount: number,
+  invoiceStatus: string,
+  deposit?: {
+    id: string;
+    amount: number;
+    status: string;
+    entryType?: string;
+    budgetSourceId?: string | null;
+  },
+) {
+  return {
+    invoice_id: invoiceId,
+    invoice_amount: invoiceAmount,
+    invoice_status: invoiceStatus,
+    deposit_id: deposit?.id ?? null,
+    deposit_amount: deposit?.amount ?? null,
+    deposit_status: deposit?.status ?? null,
+    deposit_entry_type: deposit ? (deposit.entryType ?? 'deposit') : null,
+    deposit_budget_source_id: deposit ? (deposit.budgetSourceId ?? null) : null,
+  };
+}
+
+/** Same as makeTaggableSplitRow but also carries ibl_id/itemized_amount for the line-level fns. */
+function makeTaggableRow(
+  iblId: string,
+  itemizedAmount: number,
+  invoiceId: string,
+  invoiceAmount: number,
+  invoiceStatus: string,
+  deposit?: {
+    id: string;
+    amount: number;
+    status: string;
+    entryType?: string;
+    budgetSourceId?: string | null;
+  },
+) {
+  return {
+    ibl_id: iblId,
+    itemized_amount: itemizedAmount,
+    ...makeTaggableSplitRow(invoiceId, invoiceAmount, invoiceStatus, deposit),
+  };
+}
+
+describe('splitByDepositsExcludingTagged', () => {
+  it('empty input returns empty Map', () => {
+    expect(splitByDepositsExcludingTagged([]).size).toBe(0);
+  });
+
+  it('regression: untagged fixtures produce byte-identical output to splitByDeposits', () => {
+    const legacyRows = [
+      makeSplitRow('inv-1', 1000, 'pending', { id: 'd-1', amount: 300, status: 'paid' }),
+      makeSplitRow('inv-2', 500, 'claimed'),
+      makeSplitRow('inv-3', 1000, 'pending', {
+        id: 'r-1',
+        amount: 200,
+        status: 'claimed',
+        entryType: 'refund',
+      }),
+    ];
+    const taggedRows = legacyRows.map((r) => ({ ...r, deposit_budget_source_id: null }));
+
+    const legacyResult = splitByDeposits(legacyRows);
+    const newResult = splitByDepositsExcludingTagged(taggedRows);
+
+    expect(newResult).toEqual(legacyResult);
+  });
+
+  it('a tagged deposit is omitted from depositFractions but still reduces the residual', () => {
+    const rows = [
+      makeTaggableSplitRow('inv-1', 1000, 'pending', {
+        id: 'd-1',
+        amount: 300,
+        status: 'paid',
+        budgetSourceId: 'src-A',
+      }),
+    ];
+    const result = splitByDepositsExcludingTagged(rows);
+    const split = result.get('inv-1')!;
+    // A tagged deposit contributes 100% to its source via Rail B (sumTaggedDepositContributions),
+    // so it must still be subtracted from Rail A's residual to avoid double-counting:
+    // residual = (1000 - 300) / 1000 = 0.7 (identical to legacy splitByDeposits residual math).
+    // It is still omitted from depositFractions (Rail A) since Rail B accounts for it separately.
+    expect(split.residualFraction).toBeCloseTo(0.7);
+    expect(split.depositFractions).toHaveLength(0);
+  });
+
+  it('mixed: one untagged deposit included, one tagged deposit omitted from depositFractions, on the same invoice', () => {
+    const rows = [
+      makeTaggableSplitRow('inv-1', 1000, 'pending', {
+        id: 'd-untagged',
+        amount: 300,
+        status: 'paid',
+      }),
+      makeTaggableSplitRow('inv-1', 1000, 'pending', {
+        id: 'd-tagged',
+        amount: 200,
+        status: 'claimed',
+        budgetSourceId: 'src-A',
+      }),
+    ];
+    const result = splitByDepositsExcludingTagged(rows);
+    const split = result.get('inv-1')!;
+    // Both deposits (tagged and untagged) count toward the residual denominator, matching
+    // legacy splitByDeposits: residual = (1000 - 300 - 200) / 1000 = 0.5.
+    // Only the untagged deposit is emitted in depositFractions (Rail A); the tagged one is
+    // handled separately via Rail B (sumTaggedDepositContributions).
+    expect(split.residualFraction).toBeCloseTo(0.5);
+    expect(split.depositFractions).toHaveLength(1);
+    expect(split.depositFractions[0]!.depositStatus).toBe('paid');
+    expect(split.depositFractions[0]!.fraction).toBeCloseTo(0.3);
+  });
+
+  it('a tagged deposit is still deduplicated by depositId (dedup happens before the tag filter)', () => {
+    const rows = [
+      makeTaggableSplitRow('inv-1', 1000, 'pending', {
+        id: 'd-1',
+        amount: 300,
+        status: 'paid',
+      }),
+      // Same deposit id appears again, this time WITHOUT the tag (simulates a LEFT JOIN
+      // row-expansion artifact) — dedup must not double count either way.
+      makeTaggableSplitRow('inv-1', 1000, 'pending', {
+        id: 'd-1',
+        amount: 300,
+        status: 'paid',
+      }),
+    ];
+    const result = splitByDepositsExcludingTagged(rows);
+    const split = result.get('inv-1')!;
+    expect(split.depositFractions).toHaveLength(1);
+  });
+});
+
+describe('computeLineContributionsExcludingTagged', () => {
+  it('empty rows → empty map', () => {
+    expect(computeLineContributionsExcludingTagged([], new Set(['claimed'])).size).toBe(0);
+  });
+
+  it('regression: untagged fixture, grouped-by-invoice sum matches computeStatusContributionByInvoice', () => {
+    const legacyRows = [
+      makeRow('ibl-A', 300, 'inv-1', 1000, 'paid', { id: 'd-1', amount: 500, status: 'claimed' }),
+      makeRow('ibl-B', 200, 'inv-1', 1000, 'paid', { id: 'd-1', amount: 500, status: 'claimed' }),
+      makeRow('ibl-C', 400, 'inv-2', 400, 'pending'),
+    ];
+    const taggedRows = legacyRows.map((r) => ({ ...r, deposit_budget_source_id: null }));
+    const targetStatuses = new Set(['claimed']);
+
+    const legacyByInvoice = computeStatusContributionByInvoice(legacyRows, targetStatuses);
+    const newByIbl = computeLineContributionsExcludingTagged(taggedRows, targetStatuses);
+
+    const newByInvoice = new Map<string, number>();
+    for (const [, { invoiceId, contribution }] of newByIbl) {
+      newByInvoice.set(invoiceId, (newByInvoice.get(invoiceId) ?? 0) + contribution);
+    }
+
+    expect(newByInvoice.get('inv-1')).toBeCloseTo(legacyByInvoice.get('inv-1')!);
+    expect(newByInvoice.get('inv-2')).toBeCloseTo(legacyByInvoice.get('inv-2')!);
+  });
+
+  it('returns per-ibl entries (not collapsed per invoice) so callers can build budgetLines[]', () => {
+    const rows = [
+      makeTaggableRow('ibl-A', 300, 'inv-1', 1000, 'paid'),
+      makeTaggableRow('ibl-B', 700, 'inv-1', 1000, 'paid'),
+    ];
+    const result = computeLineContributionsExcludingTagged(rows, new Set(['paid']));
+    expect(result.size).toBe(2);
+    expect(result.get('ibl-A')).toEqual({ invoiceId: 'inv-1', contribution: 300 });
+    expect(result.get('ibl-B')).toEqual({ invoiceId: 'inv-1', contribution: 700 });
+  });
+
+  it('a tagged deposit is excluded: its ibl contribution reflects only the untagged residual/deposits', () => {
+    // invoice=1000, ibl=1000, deposit 400 claimed TAGGED to src-A (excluded) → residual=1 (full 1000)
+    // parent status = pending, target={claimed} → residual doesn't count either.
+    // So contribution should be 0, NOT 400 (which is what it would be if the tag were ignored).
+    const rows = [
+      makeTaggableRow('ibl-1', 1000, 'inv-1', 1000, 'pending', {
+        id: 'd-1',
+        amount: 400,
+        status: 'claimed',
+        budgetSourceId: 'src-A',
+      }),
+    ];
+    const result = computeLineContributionsExcludingTagged(rows, new Set(['claimed']));
+    expect(result.get('ibl-1')!.contribution).toBe(0);
+  });
+});
+
+describe('computeStatusContributionExcludingTagged', () => {
+  it('returns 0 for empty rows array', () => {
+    expect(computeStatusContributionExcludingTagged([], 'claimed')).toBe(0);
+  });
+
+  it('regression: untagged fixture is byte-identical to computeStatusContribution', () => {
+    const legacyRows = [
+      makeRow('ibl-1', 1000, 'inv-1', 1000, 'paid', { id: 'd-1', amount: 300, status: 'paid' }),
+      makeRow('ibl-2', 500, 'inv-2', 500, 'claimed'),
+    ];
+    const taggedRows = legacyRows.map((r) => ({ ...r, deposit_budget_source_id: null }));
+
+    expect(computeStatusContributionExcludingTagged(taggedRows, 'paid')).toBeCloseTo(
+      computeStatusContribution(legacyRows, 'paid'),
+    );
+    expect(computeStatusContributionExcludingTagged(taggedRows, 'claimed')).toBeCloseTo(
+      computeStatusContribution(legacyRows, 'claimed'),
+    );
+  });
+
+  it('a tagged deposit is excluded from the target-status sum entirely', () => {
+    // invoice=1000, ibl=1000, deposit 400 paid TAGGED to src-A → excluded.
+    // Parent status pending (not 'paid') → 0 total, not 400.
+    const rows = [
+      makeTaggableRow('ibl-1', 1000, 'inv-1', 1000, 'pending', {
+        id: 'd-1',
+        amount: 400,
+        status: 'paid',
+        budgetSourceId: 'src-A',
+      }),
+    ];
+    expect(computeStatusContributionExcludingTagged(rows, 'paid')).toBe(0);
+  });
+
+  it('an untagged deposit alongside a tagged one on the same invoice: only the untagged one contributes', () => {
+    const rows = [
+      makeTaggableRow('ibl-1', 1000, 'inv-1', 1000, 'pending', {
+        id: 'd-untagged',
+        amount: 300,
+        status: 'paid',
+      }),
+      makeTaggableRow('ibl-1', 1000, 'inv-1', 1000, 'pending', {
+        id: 'd-tagged',
+        amount: 700,
+        status: 'paid',
+        budgetSourceId: 'src-A',
+      }),
+    ];
+    expect(computeStatusContributionExcludingTagged(rows, 'paid')).toBeCloseTo(300);
+  });
+});
+
+describe('sumTaggedDepositContributions', () => {
+  it('returns 0 for empty rows array', () => {
+    expect(sumTaggedDepositContributions([], new Set(['claimed']))).toBe(0);
+  });
+
+  it('sums deposit-type amounts whose status is in targetStatuses', () => {
+    const rows = [
+      { amount: 100, status: 'claimed', entryType: 'deposit' },
+      { amount: 200, status: 'paid', entryType: 'deposit' },
+      { amount: 50, status: 'claimed', entryType: 'deposit' },
+    ];
+    expect(sumTaggedDepositContributions(rows, new Set(['claimed']))).toBe(150);
+  });
+
+  it('excludes rows whose status is not in targetStatuses', () => {
+    const rows = [{ amount: 100, status: 'pending', entryType: 'deposit' }];
+    expect(sumTaggedDepositContributions(rows, new Set(['claimed', 'paid']))).toBe(0);
+  });
+
+  it('a refund entry contributes negatively (signed)', () => {
+    const rows = [
+      { amount: 500, status: 'claimed', entryType: 'deposit' },
+      { amount: 200, status: 'claimed', entryType: 'refund' },
+    ];
+    expect(sumTaggedDepositContributions(rows, new Set(['claimed']))).toBe(300);
+  });
+
+  it('a refund alone can drive the sum negative', () => {
+    const rows = [{ amount: 150, status: 'paid', entryType: 'refund' }];
+    expect(sumTaggedDepositContributions(rows, new Set(['paid']))).toBe(-150);
+  });
+
+  it('supports a multi-status target set (e.g. claim report = {pending, paid})', () => {
+    const rows = [
+      { amount: 100, status: 'pending', entryType: 'deposit' },
+      { amount: 200, status: 'paid', entryType: 'deposit' },
+      { amount: 300, status: 'claimed', entryType: 'deposit' },
+    ];
+    expect(sumTaggedDepositContributions(rows, new Set(['pending', 'paid']))).toBe(300);
+  });
+});
+
+describe('sumTaggedDepositContributionsByInvoice', () => {
+  it('returns an empty map for empty rows', () => {
+    expect(sumTaggedDepositContributionsByInvoice([], new Set(['claimed'])).size).toBe(0);
+  });
+
+  it('accumulates signed contributions per invoiceId independently', () => {
+    const rows = [
+      { invoiceId: 'inv-1', amount: 100, status: 'claimed', entryType: 'deposit' },
+      { invoiceId: 'inv-1', amount: 30, status: 'claimed', entryType: 'refund' },
+      { invoiceId: 'inv-2', amount: 500, status: 'claimed', entryType: 'deposit' },
+    ];
+    const result = sumTaggedDepositContributionsByInvoice(rows, new Set(['claimed']));
+    expect(result.get('inv-1')).toBe(70);
+    expect(result.get('inv-2')).toBe(500);
+    expect(result.size).toBe(2);
+  });
+
+  it('rows whose status is outside targetStatuses do not create a map entry', () => {
+    const rows = [{ invoiceId: 'inv-1', amount: 100, status: 'pending', entryType: 'deposit' }];
+    const result = sumTaggedDepositContributionsByInvoice(rows, new Set(['claimed']));
+    expect(result.has('inv-1')).toBe(false);
+  });
+
+  it('multiple deposits for the same invoice accumulate rather than overwrite', () => {
+    const rows = [
+      { invoiceId: 'inv-1', amount: 100, status: 'paid', entryType: 'deposit' },
+      { invoiceId: 'inv-1', amount: 200, status: 'paid', entryType: 'deposit' },
+      { invoiceId: 'inv-1', amount: 50, status: 'paid', entryType: 'deposit' },
+    ];
+    const result = sumTaggedDepositContributionsByInvoice(rows, new Set(['paid']));
+    expect(result.get('inv-1')).toBe(350);
+  });
+});
diff --git a/server/src/services/shared/depositAggregateUtils.ts b/server/src/services/shared/depositAggregateUtils.ts
index 53b26441b..82bff97c2 100644
--- a/server/src/services/shared/depositAggregateUtils.ts
+++ b/server/src/services/shared/depositAggregateUtils.ts
@@ -467,3 +467,269 @@ export function aggregateInvoiceStatusBreakdown(
 
   return result;
 }
+
+/**
+ * Variant of splitByDeposits that excludes deposits tagged to a budget source.
+ *
+ * Story #1891: Deposits with non-null budget_source_id are NOT included in the
+ * split computation (Rail A). They are handled separately by sumTaggedDepositContributions (Rail B).
+ *
+ * @param rows Rows from (invoices LEFT JOIN invoice_deposits), keyed by invoice_id
+ * @returns Map<invoiceId, split> (same structure as splitByDeposits, but missing tagged deposits)
+ */
+export function splitByDepositsExcludingTagged(
+  rows: Array<{
+    invoice_id: string;
+    invoice_amount: number;
+    invoice_status: string;
+    deposit_id: string | null;
+    deposit_amount: number | null;
+    deposit_status: string | null;
+    deposit_entry_type: string | null;
+    deposit_budget_source_id: string | null;
+  }>,
+): Map<string, InvoiceDepositSplit> {
+  const invoiceMap = new Map<string, { invoiceAmount: number; invoiceStatus: string }>();
+  const depositsByInvoice = new Map<
+    string,
+    Array<{
+      depositId: string;
+      depositAmount: number;
+      depositStatus: string;
+      entryType: string;
+      isTagged: boolean;
+    }>
+  >();
+
+  // Group rows by invoice and deduplicate deposits by depositId.
+  // Include ALL deposits (tagged or not), but mark tagged ones.
+  // Tagging affects which deposits are emitted in depositFractions (Rail A),
+  // but not the residual fraction denominator.
+  for (const row of rows) {
+    if (!invoiceMap.has(row.invoice_id)) {
+      invoiceMap.set(row.invoice_id, {
+        invoiceAmount: row.invoice_amount,
+        invoiceStatus: row.invoice_status,
+      });
+    }
+    if (row.deposit_id !== null && row.deposit_amount !== null && row.deposit_status !== null) {
+      const deps = depositsByInvoice.get(row.invoice_id) ?? [];
+      if (!deps.some((d) => d.depositId === row.deposit_id)) {
+        deps.push({
+          depositId: row.deposit_id,
+          depositAmount: row.deposit_amount,
+          depositStatus: row.deposit_status,
+          entryType: row.deposit_entry_type ?? 'deposit',
+          isTagged: row.deposit_budget_source_id !== null,
+        });
+        depositsByInvoice.set(row.invoice_id, deps);
+      }
+    }
+  }
+
+  // Compute splits for each invoice (same residual logic as splitByDeposits)
+  const result = new Map<string, InvoiceDepositSplit>();
+  for (const [invoiceId, inv] of invoiceMap) {
+    const deposits = depositsByInvoice.get(invoiceId) ?? [];
+    const safeInvoiceAmount = inv.invoiceAmount > 0 ? inv.invoiceAmount : 1;
+
+    if (deposits.length === 0) {
+      result.set(invoiceId, {
+        invoiceStatus: inv.invoiceStatus,
+        invoiceAmount: inv.invoiceAmount,
+        residualFraction: 1,
+        depositFractions: [],
+      });
+    } else {
+      // Residual computation includes ALL deposits (tagged or not), excluding refund-type.
+      // This matches legacy splitByDeposits logic regardless of tagging.
+      const totalDepositTypeAmount = deposits
+        .filter((d) => d.entryType !== 'refund')
+        .reduce((s, d) => s + d.depositAmount, 0);
+      const residualFraction =
+        Math.max(0, safeInvoiceAmount - totalDepositTypeAmount) / safeInvoiceAmount;
+
+      // Only emit untagged deposits in depositFractions (Rail A).
+      // Tagged deposits are handled separately by Rail B (sumTaggedDepositContributions).
+      const depositFractions = deposits
+        .filter((d) => !d.isTagged)
+        .map((d) => ({
+          depositStatus: d.depositStatus,
+          fraction:
+            d.entryType === 'refund'
+              ? -(d.depositAmount / safeInvoiceAmount)
+              : d.depositAmount / safeInvoiceAmount,
+        }));
+
+      result.set(invoiceId, {
+        invoiceStatus: inv.invoiceStatus,
+        invoiceAmount: inv.invoiceAmount,
+        residualFraction,
+        depositFractions,
+      });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Variant of computeStatusContributionByInvoice using splitByDepositsExcludingTagged.
+ *
+ * Returns per-ibl_id contributions, each paired with its invoiceId. Used by
+ * sourceReportService to build budgetLines[] with excludable line portions.
+ */
+export function computeLineContributionsExcludingTagged(
+  rows: Array<{
+    ibl_id: string;
+    itemized_amount: number;
+    invoice_id: string;
+    invoice_amount: number;
+    invoice_status: string;
+    deposit_id: string | null;
+    deposit_amount: number | null;
+    deposit_status: string | null;
+    deposit_entry_type: string | null;
+    deposit_budget_source_id: string | null;
+  }>,
+  targetStatuses: Set<string>,
+): Map<string, { invoiceId: string; contribution: number }> {
+  const result = new Map<string, { invoiceId: string; contribution: number }>();
+  if (rows.length === 0) return result;
+
+  const iblMap = new Map<string, { itemizedAmount: number; invoiceId: string }>();
+  for (const row of rows) {
+    if (!iblMap.has(row.ibl_id)) {
+      iblMap.set(row.ibl_id, { itemizedAmount: row.itemized_amount, invoiceId: row.invoice_id });
+    }
+  }
+
+  const splitsByInvoiceId = splitByDepositsExcludingTagged(rows);
+
+  for (const [iblId, ibl] of iblMap) {
+    const split = splitsByInvoiceId.get(ibl.invoiceId)!;
+    let contribution = 0;
+
+    if (targetStatuses.has(split.invoiceStatus)) {
+      contribution += ibl.itemizedAmount * split.residualFraction;
+    }
+    for (const df of split.depositFractions) {
+      if (targetStatuses.has(df.depositStatus)) {
+        contribution += ibl.itemizedAmount * df.fraction;
+      }
+    }
+    result.set(iblId, { invoiceId: ibl.invoiceId, contribution });
+  }
+
+  return result;
+}
+
+/**
+ * Variant of computeStatusContribution using splitByDepositsExcludingTagged.
+ *
+ * Computes the sum of contributions that match a specific status, excluding
+ * tagged deposits (those with non-null budget_source_id).
+ */
+export function computeStatusContributionExcludingTagged(
+  rows: Array<{
+    ibl_id: string;
+    itemized_amount: number;
+    invoice_id: string;
+    invoice_amount: number;
+    invoice_status: string;
+    deposit_id: string | null;
+    deposit_amount: number | null;
+    deposit_status: string | null;
+    deposit_entry_type: string | null;
+    deposit_budget_source_id: string | null;
+  }>,
+  targetStatus: string,
+): number {
+  if (rows.length === 0) {
+    return 0;
+  }
+
+  const iblMap = new Map<
+    string,
+    {
+      itemizedAmount: number;
+      invoiceId: string;
+    }
+  >();
+
+  for (const row of rows) {
+    if (!iblMap.has(row.ibl_id)) {
+      iblMap.set(row.ibl_id, {
+        itemizedAmount: row.itemized_amount,
+        invoiceId: row.invoice_id,
+      });
+    }
+  }
+
+  const splitsByInvoiceId = splitByDepositsExcludingTagged(rows);
+
+  let total = 0;
+
+  for (const [_iblId, ibl] of iblMap) {
+    const split = splitsByInvoiceId.get(ibl.invoiceId)!;
+
+    const residualAmount = ibl.itemizedAmount * split.residualFraction;
+    if (split.invoiceStatus === targetStatus) {
+      total += residualAmount;
+    }
+
+    for (const df of split.depositFractions) {
+      if (df.depositStatus === targetStatus) {
+        const depositContribution = ibl.itemizedAmount * df.fraction;
+        total += depositContribution;
+      }
+    }
+  }
+
+  return total;
+}
+
+/**
+ * Rail B: Sum of deposits tagged to the reported source, signed by entryType.
+ *
+ * Story #1891: A deposit with budget_source_id set contributes directly to that source
+ * if its status is in targetStatuses. Signed: entryType === 'refund' ? -amount : amount.
+ *
+ * @param rows Tagged deposits from the reported source (budget_source_id = sourceId)
+ * @param targetStatuses Set of statuses to include (e.g. Set(['claimed', 'paid']))
+ * @returns Signed sum, or 0 if rows is empty
+ */
+export function sumTaggedDepositContributions(
+  rows: Array<{ amount: number; status: string; entryType: string }>,
+  targetStatuses: Set<string>,
+): number {
+  let total = 0;
+  for (const row of rows) {
+    if (targetStatuses.has(row.status)) {
+      const signed = row.entryType === 'refund' ? -row.amount : row.amount;
+      total += signed;
+    }
+  }
+  return total;
+}
+
+/**
+ * Rail B per-invoice variant: Map of invoiceId to signed sum of tagged deposits.
+ *
+ * Same logic as sumTaggedDepositContributions but per invoice.
+ * Used by sourceReportService to populate the deposits[] for each invoice.
+ */
+export function sumTaggedDepositContributionsByInvoice(
+  rows: Array<{ invoiceId: string; amount: number; status: string; entryType: string }>,
+  targetStatuses: Set<string>,
+): Map<string, number> {
+  const result = new Map<string, number>();
+  for (const row of rows) {
+    if (targetStatuses.has(row.status)) {
+      const signed = row.entryType === 'refund' ? -row.amount : row.amount;
+      const current = result.get(row.invoiceId) ?? 0;
+      result.set(row.invoiceId, current + signed);
+    }
+  }
+  return result;
+}
diff --git a/server/src/services/sourceReportService.test.ts b/server/src/services/sourceReportService.test.ts
index 420b68735..14bf9d960 100644
--- a/server/src/services/sourceReportService.test.ts
+++ b/server/src/services/sourceReportService.test.ts
@@ -325,6 +325,109 @@ describe('sourceReportService', () => {
       expect(result.invoices[0]!.allocatedAmount).toBeCloseTo(500);
     });
 
+    it('Story #1891 regression: invoice with lines only for source B + a deposit tagged to source A → isSplit true in both A and B reports', async () => {
+      const sourceA = insertSource({ name: 'Source A' });
+      const sourceB = insertSource({ name: 'Source B' });
+      const vendorId = insertVendor();
+      const budgetB = insertWorkItemBudget(sourceB);
+      const invId = insertInvoice(vendorId, { status: 'paid', amount: 1000 });
+      insertInvoiceBudgetLine(invId, budgetB, 1000);
+      insertDeposit(invId, {
+        amount: 300,
+        status: 'paid',
+        entryType: 'deposit',
+        budgetSourceId: sourceA,
+      });
+
+      // Invoice appears in Source A's report purely via Rail B (the tagged deposit) —
+      // it has no budget lines pointing at source A at all.
+      const resultA = await getSourceReport(db, 'claim', sourceA, PAPERLESS_DISABLED);
+      expect(resultA.invoices).toHaveLength(1);
+      expect(resultA.invoices[0]!.isSplit).toBe(true);
+      expect(resultA.invoices[0]!.allocatedAmount).toBeCloseTo(300);
+
+      const resultB = await getSourceReport(db, 'claim', sourceB, PAPERLESS_DISABLED);
+      expect(resultB.invoices).toHaveLength(1);
+      expect(resultB.invoices[0]!.isSplit).toBe(true);
+      expect(resultB.invoices[0]!.allocatedAmount).toBeCloseTo(700);
+    });
+
+    it('Story #1891 regression: invoice with NO budget lines and two deposits tagged to two different sources → isSplit true in both reports', async () => {
+      const sourceA = insertSource({ name: 'Source A' });
+      const sourceB = insertSource({ name: 'Source B' });
+      const vendorId = insertVendor();
+      const invId = insertInvoice(vendorId, { status: 'paid', amount: 1000 });
+      insertDeposit(invId, {
+        amount: 400,
+        status: 'paid',
+        entryType: 'deposit',
+        budgetSourceId: sourceA,
+      });
+      insertDeposit(invId, {
+        amount: 600,
+        status: 'paid',
+        entryType: 'deposit',
+        budgetSourceId: sourceB,
+      });
+
+      const resultA = await getSourceReport(db, 'claim', sourceA, PAPERLESS_DISABLED);
+      expect(resultA.invoices).toHaveLength(1);
+      expect(resultA.invoices[0]!.isSplit).toBe(true);
+      expect(resultA.invoices[0]!.allocatedAmount).toBeCloseTo(400);
+
+      const resultB = await getSourceReport(db, 'claim', sourceB, PAPERLESS_DISABLED);
+      expect(resultB.invoices).toHaveLength(1);
+      expect(resultB.invoices[0]!.isSplit).toBe(true);
+      expect(resultB.invoices[0]!.allocatedAmount).toBeCloseTo(600);
+    });
+
+    it('Story #1891 regression: invoice with lines for one source + an UNTAGGED deposit → isSplit false', async () => {
+      const sourceA = insertSource({ name: 'Source A' });
+      const vendorId = insertVendor();
+      const budgetA = insertWorkItemBudget(sourceA);
+      const invId = insertInvoice(vendorId, { status: 'paid', amount: 1000 });
+      insertInvoiceBudgetLine(invId, budgetA, 1000);
+      insertDeposit(invId, { amount: 300, status: 'paid', entryType: 'deposit' }); // untagged (budgetSourceId null)
+
+      const result = await getSourceReport(db, 'claim', sourceA, PAPERLESS_DISABLED);
+      expect(result.invoices).toHaveLength(1);
+      expect(result.invoices[0]!.isSplit).toBe(false);
+    });
+
+    it('Story #1891 regression: invoice with lines for one source + a deposit tagged to that SAME source → isSplit false', async () => {
+      const sourceA = insertSource({ name: 'Source A' });
+      const vendorId = insertVendor();
+      const budgetA = insertWorkItemBudget(sourceA);
+      const invId = insertInvoice(vendorId, { status: 'paid', amount: 1000 });
+      insertInvoiceBudgetLine(invId, budgetA, 1000);
+      insertDeposit(invId, {
+        amount: 300,
+        status: 'paid',
+        entryType: 'deposit',
+        budgetSourceId: sourceA,
+      });
+
+      const result = await getSourceReport(db, 'claim', sourceA, PAPERLESS_DISABLED);
+      expect(result.invoices).toHaveLength(1);
+      expect(result.invoices[0]!.isSplit).toBe(false);
+    });
+
+    it('Story #1891 regression: invoice with no lines and a single tagged deposit → isSplit false', async () => {
+      const sourceA = insertSource({ name: 'Source A' });
+      const vendorId = insertVendor();
+      const invId = insertInvoice(vendorId, { status: 'paid', amount: 1000 });
+      insertDeposit(invId, {
+        amount: 500,
+        status: 'paid',
+        entryType: 'deposit',
+        budgetSourceId: sourceA,
+      });
+
+      const result = await getSourceReport(db, 'claim', sourceA, PAPERLESS_DISABLED);
+      expect(result.invoices).toHaveLength(1);
+      expect(result.invoices[0]!.isSplit).toBe(false);
+    });
+
     it('scenario 13: exactly-zero net contribution is dropped entirely (not in invoices, not in unallocated)', async () => {
       const sourceId = insertSource();
       const vendorId = insertVendor();
@@ -626,6 +729,338 @@ describe('sourceReportService', () => {
     });
   });
 
+  // ═══════════════════════════════════════════════════════════════════════
+  // Story #1891: Rail A (line-derived, excluding tagged deposits) + Rail B
+  // (deposit-direct) — budgetLines[]/deposits[] population, deposit-only
+  // invoices, cross-source deposit filtering.
+  // ═══════════════════════════════════════════════════════════════════════
+
+  describe('getSourceReport — Story #1891 Rail A + Rail B', () => {
+    it('a deposit-only invoice (zero budget lines for the source, one tagged deposit) appears with budgetLines:[] and is excluded from unallocatedInvoices', async () => {
+      const sourceId = insertSource();
+      const vendorId = insertVendor();
+      const invId = insertInvoice(vendorId, { status: 'pending', amount: 1000 });
+      // No invoice_budget_lines at all for this invoice.
+      insertDeposit(invId, {
+        amount: 300,
+        status: 'paid',
+        entryType: 'deposit',
+        budgetSourceId: sourceId,
+      });
+
+      const result = await getSourceReport(db, 'claim', sourceId, PAPERLESS_DISABLED);
+
+      expect(result.invoices).toHaveLength(1);
+      expect(result.invoices[0]!.invoiceId).toBe(invId);
+      expect(result.invoices[0]!.budgetLines).toEqual([]);
+      expect(result.invoices[0]!.allocatedAmount).toBeCloseTo(300);
+      // Must NOT also appear in unallocatedInvoices — the tagged deposit "claims" it.
+      expect(result.unallocatedInvoices).toHaveLength(0);
+    });
+
+    it('a deposit-only invoice whose tagged deposit status is outside the slice does not appear anywhere (0 net, dropped) — and IS counted in unallocatedInvoices if its own status matches', async () => {
+      const sourceId = insertSource();
+      const vendorId = insertVendor();
+      // Invoice status itself is 'claimed', which is in the proof-of-funds slice, so it
+      // still surfaces via unallocatedInvoices (no budget lines AND no tagged deposit for
+      // THIS report's slice contributes to it directly).
+      const invId = insertInvoice(vendorId, { status: 'pending', amount: 1000 });
+      insertDeposit(invId, {
+        amount: 300,
+        status: 'pending',
+        entryType: 'deposit',
+        budgetSourceId: sourceId,
+      });
+
+      // proof-of-funds slice = {claimed} only; the tagged deposit is 'pending' (outside slice).
+      const result = await getSourceReport(db, 'proof-of-funds', sourceId, PAPERLESS_DISABLED);
+
+      expect(result.invoices).toHaveLength(0);
+      // The invoice's own status (pending) is also outside {claimed}, so it does not
+      // surface via unallocatedInvoices either — fully absent from the report.
+      expect(result.unallocatedInvoices).toHaveLength(0);
+    });
+
+    it('budgetLines[] includes ALL ibl lines for the source, with description and linkedItem populated for a work item', async () => {
+      const sourceId = insertSource();
+      const vendorId = insertVendor();
+      const wiId = `wi-linked-${++counter}`;
+      const now = ts();
+      db.insert(schema.workItems)
+        .values({
+          id: wiId,
+          title: 'Foundation Work',
+          status: 'not_started',
+          createdAt: now,
+          updatedAt: now,
+        })
+        .run();
+      const budgetId = `wib-linked-${counter}`;
+      db.insert(schema.workItemBudgets)
+        .values({
+          id: budgetId,
+          workItemId: wiId,
+          budgetSourceId: sourceId,
+          plannedAmount: 0,
+          confidence: 'own_estimate',
+          createdAt: now,
+          updatedAt: now,
+        })
+        .run();
+      const invId = insertInvoice(vendorId, { status: 'paid', amount: 500 });
+      const iblId = insertInvoiceBudgetLine(invId, budgetId, 500);
+
+      const result = await getSourceReport(db, 'claim', sourceId, PAPERLESS_DISABLED);
+
+      expect(result.invoices).toHaveLength(1);
+      expect(result.invoices[0]!.budgetLines).toHaveLength(1);
+      const line = result.invoices[0]!.budgetLines[0]!;
+      expect(line.id).toBe(iblId);
+      expect(line.allocatedPortion).toBeCloseTo(500);
+      expect(line.linkedItem).toEqual({ type: 'work_item', id: wiId, name: 'Foundation Work' });
+    });
+
+    it('budgetLines[] linkedItem resolves a household item budget line', async () => {
+      const sourceId = insertSource();
+      const vendorId = insertVendor();
+      const hiId = `hi-linked-${++counter}`;
+      const now = ts();
+      db.insert(schema.householdItems)
+        .values({
+          id: hiId,
+          name: 'Kitchen Cabinet',
+          categoryId: 'hic-furniture',
+          createdAt: now,
+          updatedAt: now,
+        })
+        .run();
+      const budgetId = `hib-linked-${counter}`;
+      db.insert(schema.householdItemBudgets)
+        .values({
+          id: budgetId,
+          householdItemId: hiId,
+          budgetSourceId: sourceId,
+          plannedAmount: 0,
+          confidence: 'own_estimate',
+          createdAt: now,
+          updatedAt: now,
+        })
+        .run();
+      const invId = insertInvoice(vendorId, { status: 'paid', amount: 250 });
+      db.insert(schema.invoiceBudgetLines)
+        .values({
+          id: randomUUID(),
+          invoiceId: invId,
+          householdItemBudgetId: budgetId,
+          itemizedAmount: 250,
+          createdAt: ts(),
+          updatedAt: ts(),
+        })
+        .run();
+
+      const result = await getSourceReport(db, 'claim', sourceId, PAPERLESS_DISABLED);
+
+      expect(result.invoices[0]!.budgetLines[0]!.linkedItem).toEqual({
+        type: 'household_item',
+        id: hiId,
+        name: 'Kitchen Cabinet',
+      });
+    });
+
+    it('budgetLines[] includes lines even when their allocatedPortion is 0 for the current status slice', async () => {
+      const sourceId = insertSource();
+      const vendorId = insertVendor();
+      const budgetId = insertWorkItemBudget(sourceId);
+      // Invoice status = claimed, but report type = claim ({pending, paid}) — line contributes 0.
+      const invId = insertInvoice(vendorId, { status: 'claimed', amount: 500 });
+      insertInvoiceBudgetLine(invId, budgetId, 500);
+
+      const result = await getSourceReport(db, 'claim', sourceId, PAPERLESS_DISABLED);
+
+      // Net contribution is 0 → dropped from invoices entirely per the drop-on-zero rule,
+      // so budgetLines[] population itself isn't independently observable here; this test
+      // instead confirms the invoice does NOT appear (0 net rows are dropped, not partial).
+      expect(result.invoices).toHaveLength(0);
+    });
+
+    it('cross-source deposit filter: deposits[] includes untagged and this-source deposits, but excludes a deposit tagged to a DIFFERENT source', async () => {
+      const sourceA = insertSource({ name: 'Source A' });
+      const sourceB = insertSource({ name: 'Source B' });
+      const vendorId = insertVendor();
+      const budgetA = insertWorkItemBudget(sourceA);
+      const invId = insertInvoice(vendorId, { status: 'paid', amount: 1000 });
+      insertInvoiceBudgetLine(invId, budgetA, 1000);
+
+      const untaggedDep = insertDeposit(invId, {
+        amount: 100,
+        status: 'pending',
+        budgetSourceId: null,
+      });
+      const sameSourceDep = insertDeposit(invId, {
+        amount: 200,
+        status: 'pending',
+        budgetSourceId: sourceA,
+      });
+      const otherSourceDep = insertDeposit(invId, {
+        amount: 300,
+        status: 'pending',
+        budgetSourceId: sourceB,
+      });
+
+      const result = await getSourceReport(db, 'budget-overview', sourceA, PAPERLESS_DISABLED);
+
+      expect(result.invoices).toHaveLength(1);
+      const depositIds = result.invoices[0]!.deposits.map((d) => d.id).sort();
+      expect(depositIds).toEqual([sameSourceDep, untaggedDep].sort());
+      expect(depositIds).not.toContain(otherSourceDep);
+    });
+
+    it('deposits[] is informational: it is populated but its amounts are never summed into allocatedAmount beyond Rail A + Rail B', async () => {
+      const sourceId = insertSource();
+      const vendorId = insertVendor();
+      const budgetId = insertWorkItemBudget(sourceId);
+      const invId = insertInvoice(vendorId, { status: 'paid', amount: 1000 });
+      insertInvoiceBudgetLine(invId, budgetId, 1000);
+      // An UNTAGGED deposit still shows up in deposits[] (informational) even though it's
+      // status is outside this report's slice — deposits[] is unfiltered by status.
+      insertDeposit(invId, { amount: 50, status: 'claimed', budgetSourceId: null });
+
+      const result = await getSourceReport(db, 'claim', sourceId, PAPERLESS_DISABLED); // claim = {pending, paid}
+
+      expect(result.invoices[0]!.deposits).toHaveLength(1);
+      expect(result.invoices[0]!.deposits[0]!.status).toBe('claimed'); // present despite being out-of-slice
+    });
+
+    it('mixed two-source + tagged deposit reconciliation: source A gets its line share + its own tagged deposit; source B still shares the reduced invoice-level residual', async () => {
+      const sourceA = insertSource({ name: 'Source A' });
+      const sourceB = insertSource({ name: 'Source B' });
+      const vendorId = insertVendor();
+      const budgetA = insertWorkItemBudget(sourceA);
+      const budgetB = insertWorkItemBudget(sourceB);
+      const invId = insertInvoice(vendorId, { status: 'paid', amount: 1000 });
+      insertInvoiceBudgetLine(invId, budgetA, 600);
+      insertInvoiceBudgetLine(invId, budgetB, 400);
+      // A deposit tagged to source A only.
+      insertDeposit(invId, {
+        amount: 150,
+        status: 'paid',
+        entryType: 'deposit',
+        budgetSourceId: sourceA,
+      });
+
+      const resultA = await getSourceReport(db, 'claim', sourceA, PAPERLESS_DISABLED);
+      const resultB = await getSourceReport(db, 'claim', sourceB, PAPERLESS_DISABLED);
+
+      // The tagged deposit contributes 100% to source A via Rail B, so it must be
+      // subtracted from the invoice-level residual (Rail A) — same as legacy splitByDeposits —
+      // even though the deposit is only tagged to A: residual = (1000 - 150) / 1000 = 0.85.
+      // This residual fraction applies uniformly to every budget line on the invoice,
+      // regardless of which source that line belongs to.
+      //
+      // Source A: Rail A = 600 * 0.85 = 510, plus Rail B (its own tagged deposit) = 150.
+      // Total = 510 + 150 = 660.
+      expect(resultA.invoices[0]!.allocatedAmount).toBeCloseTo(660);
+      // Source B: Rail A = 400 * 0.85 = 340 (no tagged deposit of its own, so Rail B = 0).
+      expect(resultB.invoices[0]!.allocatedAmount).toBeCloseTo(340);
+      // Sanity check: Rail A (line pro-rata) + Rail B (tagged deposits) across ALL sources on
+      // this invoice reconstructs exactly to the invoice amount — 660 + 340 = 1000, not 1150.
+      expect(
+        resultA.invoices[0]!.allocatedAmount + resultB.invoices[0]!.allocatedAmount,
+      ).toBeCloseTo(1000);
+    });
+
+    it('deposits[] is ordered by dueDate asc, createdAt asc — identity order, not set-equality — when seeded out of insertion order', async () => {
+      const sourceId = insertSource();
+      const vendorId = insertVendor();
+      const budgetId = insertWorkItemBudget(sourceId);
+      const invId = insertInvoice(vendorId, { status: 'paid', amount: 1000 });
+      insertInvoiceBudgetLine(invId, budgetId, 1000);
+
+      // Seed deposits with dueDates in NON-insertion order — a naive "return rows as
+      // inserted / by rowid" implementation would yield [depLate, depEarly, depMid], which
+      // differs from the required dueDate-asc identity order [depEarly, depMid, depLate].
+      const depLate = insertDeposit(invId, { dueDate: '2026-03-01', amount: 100 });
+      const depEarly = insertDeposit(invId, { dueDate: '2026-01-01', amount: 100 });
+      const depMid = insertDeposit(invId, { dueDate: '2026-02-01', amount: 100 });
+
+      const result = await getSourceReport(db, 'claim', sourceId, PAPERLESS_DISABLED);
+
+      expect(result.invoices).toHaveLength(1);
+      // Identity order assertion (toEqual on the mapped id array, not toEqual(...).sort() /
+      // a Set comparison) — this fails if the ordering degrades back to insertion/rowid order.
+      expect(result.invoices[0]!.deposits.map((d) => d.id)).toEqual([depEarly, depMid, depLate]);
+    });
+
+    it('deposits[] breaks a dueDate tie using createdAt asc — identity order', async () => {
+      const sourceId = insertSource();
+      const vendorId = insertVendor();
+      const budgetId = insertWorkItemBudget(sourceId);
+      const invId = insertInvoice(vendorId, { status: 'paid', amount: 1000 });
+      insertInvoiceBudgetLine(invId, budgetId, 1000);
+
+      // All three share the same dueDate, so ordering can only be resolved by createdAt.
+      // insertDeposit's ts() helper hands out strictly increasing timestamps in call order,
+      // so createdAt order here matches insertion order: depFirst, depSecond, depThird.
+      const sameDueDate = '2026-05-01';
+      const depFirst = insertDeposit(invId, { dueDate: sameDueDate, amount: 100 });
+      const depSecond = insertDeposit(invId, { dueDate: sameDueDate, amount: 100 });
+      const depThird = insertDeposit(invId, { dueDate: sameDueDate, amount: 100 });
+
+      const result = await getSourceReport(db, 'claim', sourceId, PAPERLESS_DISABLED);
+
+      expect(result.invoices[0]!.deposits.map((d) => d.id)).toEqual([
+        depFirst,
+        depSecond,
+        depThird,
+      ]);
+    });
+
+    it('untagged pro-rata regression: with no tagged deposits at all, Rail A alone reproduces the pre-#1891 proportional-split result exactly', async () => {
+      const sourceId = insertSource();
+      const vendorId = insertVendor();
+      const budgetId = insertWorkItemBudget(sourceId);
+      const invId = insertInvoice(vendorId, { status: 'pending', amount: 1000 });
+      insertInvoiceBudgetLine(invId, budgetId, 1000);
+      // Untagged deposit: 300 paid.
+      insertDeposit(invId, {
+        amount: 300,
+        status: 'paid',
+        entryType: 'deposit',
+        budgetSourceId: null,
+      });
+
+      const result = await getSourceReport(db, 'claim', sourceId, PAPERLESS_DISABLED); // claim = {pending, paid}
+
+      // residual (pending, 700/1000) contributes to 'pending' (in slice) = 700;
+      // deposit (paid, 300/1000) contributes to 'paid' (in slice) = 300; total = 1000.
+      expect(result.invoices[0]!.allocatedAmount).toBeCloseTo(1000);
+    });
+
+    it('a tagged deposit does NOT get double-counted: Rail A residual and Rail B tagged sum to exactly the invoice amount', async () => {
+      const sourceId = insertSource();
+      const vendorId = insertVendor();
+      const budgetId = insertWorkItemBudget(sourceId);
+      const invId = insertInvoice(vendorId, { status: 'pending', amount: 1000 });
+      insertInvoiceBudgetLine(invId, budgetId, 1000);
+      // Deposit tagged to this source: 400 paid.
+      insertDeposit(invId, {
+        amount: 400,
+        status: 'paid',
+        entryType: 'deposit',
+        budgetSourceId: sourceId,
+      });
+
+      const result = await getSourceReport(db, 'claim', sourceId, PAPERLESS_DISABLED);
+
+      // A tagged deposit counts 100% toward its source via Rail B, so it must be subtracted
+      // from Rail A's residual to avoid double-counting: residual = (1000 - 400) / 1000 = 0.6.
+      // Rail A: invoice status 'pending' IS in the claim slice {pending, paid} →
+      // 1000 * 0.6 = 600. Rail B: deposit status 'paid' IS in the claim slice → +400.
+      // Combined = 600 + 400 = 1000 — exactly the invoice amount, not 1400.
+      expect(result.invoices[0]!.allocatedAmount).toBeCloseTo(1000);
+    });
+  });
+
   // ═══════════════════════════════════════════════════════════════════════
   // markInvoicesClaimed
   // ═══════════════════════════════════════════════════════════════════════
diff --git a/server/src/services/sourceReportService.ts b/server/src/services/sourceReportService.ts
index 46dcd907f..68aae9264 100644
--- a/server/src/services/sourceReportService.ts
+++ b/server/src/services/sourceReportService.ts
@@ -1,4 +1,4 @@
-import { eq, inArray, and, sql } from 'drizzle-orm';
+import { eq, inArray, and, sql, asc } from 'drizzle-orm';
 import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
 import type * as schemaTypes from '../db/schema.js';
 import { budgetSources, invoices, invoiceDeposits, documentLinks } from '../db/schema.js';
@@ -11,12 +11,18 @@ import type {
   MarkClaimedResponse,
   AttachmentType,
   SourceReportDocument,
+  SourceReportBudgetLine,
+  SourceReportDeposit,
+  SourceReportLinkedItem,
+  InvoiceDepositStatus,
+  InvoiceDepositEntryType,
 } from '@cornerstone/shared';
 import { NotFoundError, ValidationError, InvoicesNotClaimableError } from '../errors/AppError.js';
 import { toCents } from './shared/money.js';
 import {
-  computeStatusContributionByInvoice,
-  splitByDeposits,
+  computeLineContributionsExcludingTagged,
+  splitByDepositsExcludingTagged,
+  sumTaggedDepositContributionsByInvoice,
   type DepositAwareRow,
 } from './shared/depositAggregateUtils.js';
 import { onInvoiceStatusChanged, onDepositStatusChanged } from './diaryAutoEventService.js';
@@ -34,7 +40,8 @@ function today(): string {
 
 /**
  * Get a source report for a given budget source and report type.
- * The report includes all invoices whose budget lines reference this source,
+ * Story #1891: Implements Rail A (line-derived via ExcludingTagged) + Rail B (deposit-direct).
+ * The report includes all invoices whose budget lines or deposits reference this source,
  * filtered by the statuses specified for the report type.
  */
 export async function getSourceReport(
@@ -57,32 +64,35 @@ export async function getSourceReport(
   const targetStatuses = new Set<string>();
   switch (type) {
     case 'budget-overview':
-      // All 4 statuses including quotation
       targetStatuses.add('quotation');
       targetStatuses.add('pending');
       targetStatuses.add('paid');
       targetStatuses.add('claimed');
       break;
     case 'claim':
-      // Only pending and paid
       targetStatuses.add('pending');
       targetStatuses.add('paid');
       break;
     case 'proof-of-funds':
-      // Only claimed
       targetStatuses.add('claimed');
       break;
   }
 
-  // 3. Query rows (invoice + deposits) for this source
-  type SourceReportRow = DepositAwareRow & {
+  // Step a: Query rows (invoice + deposits) for Rail A (line-derived via ExcludingTagged)
+  type RailARow = DepositAwareRow & {
     invoice_number: string | null;
     invoice_date: string;
     vendor_id: string;
     vendor_name: string;
+    deposit_budget_source_id: string | null;
+    line_description: string | null;
+    work_item_id: string | null;
+    work_item_title: string | null;
+    household_item_id: string | null;
+    household_item_name: string | null;
   };
 
-  const rows = db.all<SourceReportRow>(
+  const railARows = db.all<RailARow>(
     sql`SELECT
       ibl.id              AS ibl_id,
       ibl.itemized_amount AS itemized_amount,
@@ -96,28 +106,67 @@ export async function getSourceReport(
       d.id                AS deposit_id,
       d.amount            AS deposit_amount,
       d.status            AS deposit_status,
-      d.entry_type        AS deposit_entry_type
+      d.entry_type        AS deposit_entry_type,
+      d.budget_source_id  AS deposit_budget_source_id,
+      COALESCE(wib.description, hib.description) AS line_description,
+      wib.work_item_id    AS work_item_id,
+      wi.title            AS work_item_title,
+      hib.household_item_id AS household_item_id,
+      hi.name             AS household_item_name
     FROM invoice_budget_lines ibl
     INNER JOIN invoices i ON i.id = ibl.invoice_id
     INNER JOIN vendors v ON v.id = i.vendor_id
     LEFT JOIN invoice_deposits d ON d.invoice_id = i.id
+    LEFT JOIN work_item_budgets wib ON wib.id = ibl.work_item_budget_id
+    LEFT JOIN work_items wi ON wi.id = wib.work_item_id
+    LEFT JOIN household_item_budgets hib ON hib.id = ibl.household_item_budget_id
+    LEFT JOIN household_items hi ON hi.id = hib.household_item_id
     WHERE (
       (ibl.work_item_budget_id IS NOT NULL AND EXISTS (
-        SELECT 1 FROM work_item_budgets wib
-        WHERE wib.id = ibl.work_item_budget_id AND wib.budget_source_id = ${sourceId}
+        SELECT 1 FROM work_item_budgets wib2
+        WHERE wib2.id = ibl.work_item_budget_id AND wib2.budget_source_id = ${sourceId}
       ))
       OR
       (ibl.household_item_budget_id IS NOT NULL AND EXISTS (
-        SELECT 1 FROM household_item_budgets hib
-        WHERE hib.id = ibl.household_item_budget_id AND hib.budget_source_id = ${sourceId}
+        SELECT 1 FROM household_item_budgets hib2
+        WHERE hib2.id = ibl.household_item_budget_id AND hib2.budget_source_id = ${sourceId}
       ))
     )`,
   );
 
-  // 4. Compute contributions per invoice, then round to 2dp
-  const rawContributions = computeStatusContributionByInvoice(rows, targetStatuses);
+  // Step b: Rail A contributions per invoice (excluding tagged deposits)
+  const railALineContributions = computeLineContributionsExcludingTagged(railARows, targetStatuses);
+
+  // Build ibl-level details map for budgetLines[] per invoice
+  const iblDetails = new Map<
+    string,
+    {
+      id: string;
+      description: string | null;
+      linkedItem: SourceReportLinkedItem | null;
+    }
+  >();
+  for (const row of railARows) {
+    if (!iblDetails.has(row.ibl_id)) {
+      let linkedItem: SourceReportLinkedItem | null = null;
+      if (row.work_item_id && row.work_item_title) {
+        linkedItem = { type: 'work_item', id: row.work_item_id, name: row.work_item_title };
+      } else if (row.household_item_id && row.household_item_name) {
+        linkedItem = {
+          type: 'household_item',
+          id: row.household_item_id,
+          name: row.household_item_name,
+        };
+      }
+      iblDetails.set(row.ibl_id, {
+        id: row.ibl_id,
+        description: row.line_description,
+        linkedItem,
+      });
+    }
+  }
 
-  // Build a map of invoice metadata for quick lookup
+  // Build invoice metadata from Rail A rows
   const invoiceMetadata = new Map<
     string,
     {
@@ -129,7 +178,7 @@ export async function getSourceReport(
       invoiceAmount: number;
     }
   >();
-  for (const row of rows) {
+  for (const row of railARows) {
     if (!invoiceMetadata.has(row.invoice_id)) {
       invoiceMetadata.set(row.invoice_id, {
         vendorId: row.vendor_id,
@@ -142,19 +191,88 @@ export async function getSourceReport(
     }
   }
 
-  // 5. Compute isSplit for all report invoices in one query
-  const reportInvoiceIds = Array.from(invoiceMetadata.keys());
+  // Step c: Rail B - deposits tagged to this source
+  type RailBRow = {
+    invoiceId: string;
+    amount: number;
+    status: string;
+    entryType: string;
+  };
+
+  const railBRows = db.all<RailBRow>(
+    sql`SELECT
+      d.invoice_id AS invoiceId,
+      d.amount AS amount,
+      d.status AS status,
+      d.entry_type AS entryType
+    FROM invoice_deposits d
+    WHERE d.budget_source_id = ${sourceId}`,
+  );
+
+  const railBContributions = sumTaggedDepositContributionsByInvoice(railBRows, targetStatuses);
+
+  // Step d: Merge Rail B-only invoices (deposits with no budget lines)
+  for (const invoiceId of railBContributions.keys()) {
+    if (!invoiceMetadata.has(invoiceId)) {
+      // Rail B-only invoice: fetch metadata
+      const inv = db.select().from(invoices).where(eq(invoices.id, invoiceId)).get();
+      if (inv) {
+        const vendorLookup = db.all<{ vendor_id: string; vendor_name: string }>(
+          sql`SELECT id AS vendor_id, name AS vendor_name FROM vendors WHERE id = ${inv.vendorId}`,
+        );
+        if (vendorLookup.length > 0) {
+          invoiceMetadata.set(invoiceId, {
+            vendorId: inv.vendorId,
+            vendorName: vendorLookup[0]!.vendor_name,
+            invoiceNumber: inv.invoiceNumber,
+            date: inv.date,
+            status: inv.status,
+            invoiceAmount: inv.amount,
+          });
+        }
+      }
+    }
+  }
+
+  // Step e: Combined contributions (Rail A + Rail B)
+  const combinedContributions = new Map<string, number>();
+  for (const [_iblId, lineContrib] of railALineContributions) {
+    const existing = combinedContributions.get(lineContrib.invoiceId) ?? 0;
+    combinedContributions.set(lineContrib.invoiceId, existing + lineContrib.contribution);
+  }
+  for (const [invoiceId, railBAmount] of railBContributions) {
+    const existing = combinedContributions.get(invoiceId) ?? 0;
+    combinedContributions.set(invoiceId, existing + railBAmount);
+  }
+
+  // Step f: Compute isSplit for all report invoices in one query
+  // isSplit = true if invoice's funding spans 2+ distinct budget sources across budget lines and tagged deposits
+  const reportInvoiceIds = Array.from(combinedContributions.keys());
+  const joinedInvoiceIds = sql.join(
+    reportInvoiceIds.map((id) => sql`${id}`),
+    sql`, `,
+  );
   const splitRows = db.all<{ invoice_id: string; source_count: number }>(
-    sql`SELECT ibl.invoice_id AS invoice_id,
-           COUNT(DISTINCT COALESCE(wib.budget_source_id, hib.budget_source_id)) AS source_count
-    FROM invoice_budget_lines ibl
-    LEFT JOIN work_item_budgets wib ON wib.id = ibl.work_item_budget_id
-    LEFT JOIN household_item_budgets hib ON hib.id = ibl.household_item_budget_id
-    WHERE ibl.invoice_id IN (${sql.join(
-      reportInvoiceIds.map((id) => sql`${id}`),
-      sql`, `,
-    )})
-    GROUP BY ibl.invoice_id`,
+    sql`SELECT split_data.invoice_id AS invoice_id,
+           COUNT(DISTINCT split_data.source_id) AS source_count
+    FROM (
+      SELECT ibl.invoice_id,
+             COALESCE(wib.budget_source_id, hib.budget_source_id) AS source_id
+      FROM invoice_budget_lines ibl
+      LEFT JOIN work_item_budgets wib ON wib.id = ibl.work_item_budget_id
+      LEFT JOIN household_item_budgets hib ON hib.id = ibl.household_item_budget_id
+      WHERE ibl.invoice_id IN (${joinedInvoiceIds})
+        AND COALESCE(wib.budget_source_id, hib.budget_source_id) IS NOT NULL
+
+      UNION
+
+      SELECT d.invoice_id,
+             d.budget_source_id AS source_id
+      FROM invoice_deposits d
+      WHERE d.invoice_id IN (${joinedInvoiceIds})
+        AND d.budget_source_id IS NOT NULL
+    ) AS split_data
+    GROUP BY split_data.invoice_id`,
   );
 
   const isSplitMap = new Map<string, boolean>();
@@ -162,48 +280,50 @@ export async function getSourceReport(
     isSplitMap.set(row.invoice_id, row.source_count > 1);
   }
 
-  // 6. Precompute deposit splits for all invoices
-  const splitsByInvoiceId = splitByDeposits(rows);
+  // Step g: Compute deposit splits excluding tagged (for stage-determination logic)
+  const splitsByInvoiceId = splitByDepositsExcludingTagged(railARows);
 
-  // 7. Batch fetch all document links for all report invoices (once, not per-invoice)
+  // Step h: Batch fetch document links
+  const allInvoiceIds = Array.from(invoiceMetadata.keys());
   const allDocumentLinks = db
     .select()
     .from(documentLinks)
     .where(
-      and(
-        eq(documentLinks.entityType, 'invoice'),
-        inArray(documentLinks.entityId, reportInvoiceIds),
-      ),
+      and(eq(documentLinks.entityType, 'invoice'), inArray(documentLinks.entityId, allInvoiceIds)),
     )
     .all();
 
-  // Build a map: invoiceId → filtered document links (by stage rules)
   const linksByInvoiceId = new Map<string, (typeof documentLinks.$inferSelect)[]>();
-  // Also collect all paperlessDocumentIds we'll need to fetch metadata for
   const allPaperlessDocIds = new Set<number>();
 
-  for (const invoiceId of reportInvoiceIds) {
-    const split = splitsByInvoiceId.get(invoiceId)!;
+  for (const invoiceId of allInvoiceIds) {
+    const split = splitsByInvoiceId.get(invoiceId);
 
-    // Determine which stages to include for this invoice
+    // Determine stages: if deposit-only (no split entry), include 'deposit' if any tagged deposit in slice
     const stages = new Set<AttachmentType>();
-    if (split.invoiceStatus === 'quotation' && targetStatuses.has('quotation')) {
-      stages.add('quotation');
-    }
-    if (
-      split.residualFraction > 0 &&
-      split.invoiceStatus !== 'quotation' &&
-      targetStatuses.has(split.invoiceStatus)
-    ) {
-      stages.add('invoice');
-    }
-    for (const df of split.depositFractions) {
-      if (targetStatuses.has(df.depositStatus)) {
+    if (split) {
+      if (split.invoiceStatus === 'quotation' && targetStatuses.has('quotation')) {
+        stages.add('quotation');
+      }
+      if (
+        split.residualFraction > 0 &&
+        split.invoiceStatus !== 'quotation' &&
+        targetStatuses.has(split.invoiceStatus)
+      ) {
+        stages.add('invoice');
+      }
+      for (const df of split.depositFractions) {
+        if (targetStatuses.has(df.depositStatus)) {
+          stages.add('deposit');
+        }
+      }
+    } else {
+      // Deposit-only: check if any tagged deposit in target statuses
+      if (railBContributions.has(invoiceId)) {
         stages.add('deposit');
       }
     }
 
-    // Filter links for this invoice by stage, include untagged always
     const invoiceLinks = allDocumentLinks
       .filter(
         (link) =>
@@ -218,7 +338,7 @@ export async function getSourceReport(
     linksByInvoiceId.set(invoiceId, invoiceLinks);
   }
 
-  // 8. Fetch metadata for ALL documents in one Paperless call (not per-invoice)
+  // Fetch Paperless metadata
   const paperlessDocMap = new Map<
     number,
     { archiveSerialNumber: number | null; title: string | null }
@@ -242,25 +362,64 @@ export async function getSourceReport(
         });
       }
     } catch (err) {
-      // Degrade gracefully — getDocuments throws, we just use nulls
       console.warn('[sourceReport] Paperless.getDocuments failed, degrading to null ASN/title', {
         error: err instanceof Error ? err.message : String(err),
       });
     }
   }
 
-  // 9. Build report invoices
+  // Step i: Build budget lines per invoice
+  const budgetLinesByInvoiceId = new Map<string, SourceReportBudgetLine[]>();
+  for (const [iblId, lineContrib] of railALineContributions) {
+    const invoiceId = lineContrib.invoiceId;
+    const details = iblDetails.get(iblId)!;
+    const lines = budgetLinesByInvoiceId.get(invoiceId) ?? [];
+    const portion = toCents(lineContrib.contribution) / 100;
+    lines.push({
+      id: details.id,
+      description: details.description,
+      allocatedPortion: portion,
+      linkedItem: details.linkedItem,
+    });
+    budgetLinesByInvoiceId.set(invoiceId, lines);
+  }
+
+  // Step j: Fetch deposits for each invoice (unfiltered by status, but filtered by source tag)
+  const depositsByInvoiceId = new Map<string, SourceReportDeposit[]>();
+  for (const invoiceId of allInvoiceIds) {
+    const deposits = db
+      .select()
+      .from(invoiceDeposits)
+      .where(eq(invoiceDeposits.invoiceId, invoiceId))
+      .orderBy(asc(invoiceDeposits.dueDate), asc(invoiceDeposits.createdAt))
+      .all();
+
+    const filtered: SourceReportDeposit[] = deposits
+      .filter((d) => d.budgetSourceId === null || d.budgetSourceId === sourceId)
+      .map((d) => ({
+        id: d.id,
+        amount: d.amount,
+        status: d.status as InvoiceDepositStatus,
+        entryType: d.entryType as InvoiceDepositEntryType,
+        dueDate: d.dueDate,
+        paidDate: d.paidDate,
+        claimedDate: d.claimedDate,
+        budgetSourceId: d.budgetSourceId,
+      }));
+
+    depositsByInvoiceId.set(invoiceId, filtered);
+  }
+
+  // Build report invoices
   const reportInvoices: SourceReportInvoice[] = [];
-  for (const [invoiceId, rawAmount] of rawContributions) {
+  for (const [invoiceId, rawAmount] of combinedContributions) {
     const metadata = invoiceMetadata.get(invoiceId)!;
     const roundedAmount = toCents(rawAmount) / 100;
 
-    // Drop exactly 0, otherwise include
     if (roundedAmount === 0) continue;
 
     const lineKind = roundedAmount > 0 ? 'invoice' : 'refund-adjustment';
 
-    // Map filtered document links to response documents
     const links = linksByInvoiceId.get(invoiceId) ?? [];
     const documents: SourceReportDocument[] = links.map((link) => {
       const paperlessEntry = paperlessDocMap.get(link.paperlessDocumentId);
@@ -282,12 +441,14 @@ export async function getSourceReport(
       invoiceAmount: metadata.invoiceAmount,
       allocatedAmount: roundedAmount,
       lineKind,
-      isSplit: isSplitMap.get(invoiceId) ?? false,
+      isSplit: isSplitMap.get(invoiceId) ?? false, // true iff invoice's funding spans 2+ distinct budget sources across budget lines and tagged deposits
       documents,
+      budgetLines: budgetLinesByInvoiceId.get(invoiceId) ?? [],
+      deposits: depositsByInvoiceId.get(invoiceId) ?? [],
     });
   }
 
-  // 10. Query unallocated invoices (no budget lines, but matching status)
+  // Step k: Query unallocated invoices (excluding those with tagged deposits)
   const unallocatedInvoices: SourceReportUnallocatedInvoice[] = [];
   const unallocRows = db.all<{
     invoice_id: string;
@@ -312,7 +473,8 @@ export async function getSourceReport(
       Array.from(targetStatuses).map((status) => sql`${status}`),
       sql`, `,
     )})
-    AND NOT EXISTS (SELECT 1 FROM invoice_budget_lines ibl WHERE ibl.invoice_id = i.id)`,
+    AND NOT EXISTS (SELECT 1 FROM invoice_budget_lines ibl WHERE ibl.invoice_id = i.id)
+    AND NOT EXISTS (SELECT 1 FROM invoice_deposits d WHERE d.invoice_id = i.id AND d.budget_source_id = ${sourceId})`,
   );
 
   for (const row of unallocRows) {
@@ -327,7 +489,7 @@ export async function getSourceReport(
     });
   }
 
-  // 11. Compute total amount from rounded lines
+  // Compute total from rounded lines
   const totalAmount =
     toCents(reportInvoices.reduce((sum, inv) => sum + inv.allocatedAmount, 0)) / 100;
 
diff --git a/shared/src/index.ts b/shared/src/index.ts
index 663a1a633..80e6f9e4c 100644
--- a/shared/src/index.ts
+++ b/shared/src/index.ts
@@ -424,6 +424,9 @@ export type {
 export type {
   SourceReportType,
   SourceReportDocument,
+  SourceReportLinkedItem,
+  SourceReportBudgetLine,
+  SourceReportDeposit,
   SourceReportInvoice,
   SourceReportUnallocatedInvoice,
   SourceReportSourceSummary,
diff --git a/shared/src/types/invoice.ts b/shared/src/types/invoice.ts
index e67291ff1..620466f6b 100644
--- a/shared/src/types/invoice.ts
+++ b/shared/src/types/invoice.ts
@@ -30,6 +30,7 @@ export type InvoiceDepositEntryType = 'deposit' | 'refund';
 
 /**
  * Invoice deposit entity - represents a staged partial payment within an invoice.
+ * Story #1891: budgetSourceId links deposit directly to a source (optional).
  */
 export interface InvoiceDeposit {
   id: string;
@@ -41,6 +42,7 @@ export interface InvoiceDeposit {
   description: string | null;
   status: InvoiceDepositStatus;
   entryType: InvoiceDepositEntryType;
+  budgetSourceId: string | null;
   createdBy: UserSummary | null;
   createdAt: string;
   updatedAt: string;
@@ -57,6 +59,7 @@ export interface CreateDepositRequest {
   entryType?: InvoiceDepositEntryType; // default 'deposit'; immutable after creation
   paidDate?: string | null;
   claimedDate?: string | null;
+  budgetSourceId?: string | null;
 }
 
 /**
@@ -69,6 +72,7 @@ export interface UpdateDepositRequest {
   status?: InvoiceDepositStatus;
   paidDate?: string | null;
   claimedDate?: string | null;
+  budgetSourceId?: string | null;
 }
 
 /**
diff --git a/shared/src/types/sourceReport.ts b/shared/src/types/sourceReport.ts
index 00cc91c77..9867d6daa 100644
--- a/shared/src/types/sourceReport.ts
+++ b/shared/src/types/sourceReport.ts
@@ -1,9 +1,36 @@
 import type { AttachmentType } from './document.js';
 import type { BudgetSourceType } from './budgetSource.js';
-import type { InvoiceStatus } from './invoice.js';
+import type { InvoiceStatus, InvoiceDepositStatus, InvoiceDepositEntryType } from './invoice.js';
 
 export type SourceReportType = 'budget-overview' | 'claim' | 'proof-of-funds';
 
+/** Linked item (work item or household item) associated with a budget line. */
+export interface SourceReportLinkedItem {
+  type: 'work_item' | 'household_item';
+  id: string;
+  name: string;
+}
+
+/** Budget line subtraction row: allocatedPortion is subtraction-only, never independently summed. */
+export interface SourceReportBudgetLine {
+  id: string;
+  description: string | null;
+  allocatedPortion: number;
+  linkedItem: SourceReportLinkedItem | null;
+}
+
+/** Informational deposit row: never summed, filtered server-side to untagged-or-this-source only. */
+export interface SourceReportDeposit {
+  id: string;
+  amount: number;
+  status: InvoiceDepositStatus;
+  entryType: InvoiceDepositEntryType;
+  dueDate: string;
+  paidDate: string | null;
+  claimedDate: string | null;
+  budgetSourceId: string | null;
+}
+
 /** A single Paperless-ngx document reference resolved for a report line. */
 export interface SourceReportDocument {
   documentId: number;
@@ -25,9 +52,13 @@ export interface SourceReportInvoice {
   /** Net contribution to this source for the report's status slice, rounded to 2dp. Negative for refund-adjustment lines. */
   allocatedAmount: number;
   lineKind: 'invoice' | 'refund-adjustment';
-  /** True iff this invoice's budget lines reference more than one distinct budget source. */
+  /** True iff the invoice's funding spans 2+ distinct budget sources across budget lines and tagged deposits. */
   isSplit: boolean;
   documents: SourceReportDocument[];
+  /** Budget line subtraction rows: all ibl lines per invoice (even portion 0). Deposit-only invoices: []. */
+  budgetLines: SourceReportBudgetLine[];
+  /** Deposit rows: all deposits for this invoice, filtered to untagged-or-this-source only. */
+  deposits: SourceReportDeposit[];
 }
 
 /** Informational row: matching-status invoice with zero budget lines (not itemized to any source). */
diff --git a/wiki b/wiki
index 0cd728d02..616bc90dd 160000
--- a/wiki
+++ b/wiki
@@ -1 +1 @@
-Subproject commit 0cd728d021117979b3567ad336ace4a05cf19730
+Subproject commit 616bc90dd787f3882c7509ddcfc4d0f53ce18663