diff --git a/CONTEXT.md b/CONTEXT.md
index 10c07e3..be4eced 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -13,8 +13,7 @@ people (or two devices for the same person) can both resume the same session.
 
 The checkout session moves through a single state machine (`status` field):
 
-- **created** — session just made for a selected listing; inventory hold placed.
-- **active** — fan is viewing/resuming the session; inventory still held, price/inventory
+- **active** — session created with inventory held; fan is viewing/resuming; price/inventory
   can still change underneath it.
 - **pending_payment** — fan submitted payment; awaiting provider result. This is the window
   where a second device resuming the same session is the actual duplicate-order hazard the
@@ -22,8 +21,8 @@ The checkout session moves through a single state machine (`status` field):
 - **completed** — order placed successfully. Terminal.
 - **expired** — inventory hold lapsed before completion. Terminal unless the fan starts a
   fresh session (re-priced/re-held).
-- **failed** — payment or completion failed. Fan may retry (transitions back to **active**)
-  or the session expires.
+- **failed** — payment or completion failed. Fan may retry (claims again through
+  **pending_payment**) or the session expires.
 
 ## Price Reconfirmation
 
@@ -50,3 +49,8 @@ own `expiresAt` implies the hold is still good — the hold can lapse independen
 shorter TTL than the session, or inventory reclaimed for other reasons). A session can be
 unexpired but reference inventory that is no longer held; that combination surfaces to the
 fan as a distinct "listing no longer available" state, not the same as "session expired."
+Conversely, when the session clock itself lapses, checkout also releases the hold
+(request-time via `expireIfNeeded`, or in the background via `expireLapsedSessions` /
+`SessionExpirySweeper`) so inventory isn't stranded — `expiryReason` stays
+`session_lapsed` (why the session died), not `hold_released` (hold disappeared while the
+session was still live).
diff --git a/README.md b/README.md
index 9f5383d..5de3d27 100644
--- a/README.md
+++ b/README.md
@@ -1,72 +1,50 @@
 # Notes about the demo
 
-- Cross-surface resume in this demo is **web ↔ web** (copy the link into another
-  tab/browser) and **mobile → web** (native share/copy hands the fan a web
-  checkout URL). I did not build a seamless **web → mobile** handoff: a browser
-  cannot detect whether an iOS/Android simulator (or Expo) is running on the
-  reviewer’s machine, and custom-scheme deep links (`mobileweb://…`) only work
-  when that OS has registered the scheme. An earlier **Open in app** control on
-  web (navigate / `window.open` to `mobileweb://…`) proved too volatile — it
-  either navigated the checkout page away or failed silently depending on the
-  browser and whether Expo had claimed the scheme — so it was removed. Use
-  `xcrun simctl openurl` (below) for local deep-link demos instead.
-- I also wanted to pressure-test a quickly built React Native demo alongside
-  shared UI and a monorepo with multiple apps. This started from a GitHub
-  template I maintain, with a decent amount of cleanup so the shared packages
-  actually show code reuse between the React Native app and the web app.
-- The core sharing/resume design came together quickly; I spent extra time on
-  presentation so the demo feels attractive and demonstrates mobile ↔ web
-  parity, not just a working handoff.
-- **Why go past a “minimal UI” slice?** The prompt’s time box (~2–3 hours)
-  prefers a focused end-to-end continuity path over a broad checkout clone. I
-  still invested past that floor on purpose: a bare curl-and-JSON demo proves
-  the state machine, but a product-shaped shell (selection → checkout, shared
-  tokens/UI, Gametime-like visual hierarchy) is a better signal of how I attack
-  _complicated_ product + systems problems — domain boundaries, cross-surface
-  consistency, and reviewer-friendly UX — not only whether `resume` returns
-  `200`. Treat the polish as intentional flex, not scope creep that replaced the
-  continuity core.
-
-**Time trade-offs (kept the continuity slice honest, deferred production depth):**
-
-- In-memory session store and deterministic payment/inventory fakes — fine per
-  the prompt, zero reviewer setup, and the CAS race is still real in one
-  process. No Prisma session model, no real Stripe/inventory SDKs, no auth.
-- Surfaces discover changes by acting (resume / complete), not via push — with
-  one demo exception: **Sec 118 · Row 8 · 10s price demo** (`listing_3`) ages its _held_
-  price after 10 seconds so you can watch reconfirmation live. Catalog price
-  stays at the seed if you leave and browse again; a new session resets the
-  timer. Other failure modes (decline, sold-out) still need tests /
-  `forceOutcome` / `releaseListing`.
-- No automated create-on-web / complete-on-mobile E2E; unit tests cover the
-  state machine and conflict path, and the handoff is verified by hand.
-- Fixed 10-minute session TTL, two-tap price confirm then buy (not one-tap),
-  and share via opaque session id only — deliberate scope cuts, not unfinished
-  stubs.
-
-**Beyond the basic ask (to raise demo quality):**
-
-- Ticket landing with listing selection and a static stadium map so the flow
-  starts like a product, not a bare “create session” curl.
-- Shared design tokens + `@repo/ui` checkout/listings so web (Next SSR) and
-  native actually share components — not two parallel UIs with the same API.
-- Visual shell aligned to Gametime-style mocks (layout, hierarchy, share UX)
-  while keeping payment/promo chrome decorative and non-functional.
-- Domain write-up (`CONTEXT.md`), decision log (`docs/decisions.md`), and
-  structured instrumentation so the _why_ of the state machine is reviewable.
-
-**AI-assisted engineering trail:** session notes under [`docs/`](./docs/)
-(`session_<date>_<time>_<slug>.md`) record planning, trade-offs, and
-implementation passes with AI. They are meant to show how I use assisted
-engineering to move a product forward quickly and refine existing work — not
-as a substitute for the code or the domain docs above.
-
----
-
-# RN + Web Template
-
-One codebase that ships to iOS, Android, and web, backed by a fully
-type-safe API. Use this as a GitHub template for new projects.
+- **Resume directions in this demo:** **web ↔ web** (same link in another tab/browser)
+  and **mobile → web** (native share/copy hands the fan a web checkout URL). There is no
+  seamless **web → mobile** handoff from the browser — custom schemes (`mobileweb://…`)
+  only work when the OS has registered them. For local deep-link demos use
+  `xcrun simctl openurl` (below). Shared UI aims for **checkout parity** across surfaces;
+  that is not the same as a bidirectional handoff product.
+- Built from a personal RN + web monorepo template so shared packages (`@repo/ui`,
+  tokens, contracts) actually reuse between Next and Expo — not two parallel UIs on the
+  same API.
+- Continuity core (session machine, resume, CAS, price reconfirm) came first; the
+  product-shaped shell (selection → checkout, Gametime-like hierarchy) is deliberate
+  polish on top of that slice, not a substitute for it. Prompt time box was ~2–3 hours;
+  I invested past that floor on presentation and shared UI.
+- **AI-assisted trail:** session notes under [`docs/`](./docs/)
+  (`session_<date>_<time>_<slug>.md`) record planning and implementation passes. There
+  are many of them — skim for decisions if useful; prefer this README, [`CONTEXT.md`](./CONTEXT.md),
+  and [`docs/decisions.md`](./docs/decisions.md) as the review path. Notes are not a
+  substitute for the code.
+
+**Deferred on purpose (continuity slice stays honest):**
+
+- In-memory session store + deterministic payment/inventory fakes (prompt-allowed). No
+  Prisma session model, real Stripe/inventory SDKs, or auth.
+- Surfaces discover changes by acting (resume / complete), not via push — except the
+  live **Sec 118 · Row 8 · 10s price demo** (`listing_3`), which ages its _held_ price
+  after 10s so reconfirmation is visible. Catalog seed price is unchanged if you leave
+  and browse again; a new session resets the timer.
+- Decline / sold-out paths are covered in unit tests via `FakePaymentProvider.forceOutcome`
+  and `FakeInventoryProvider.releaseListing` (process-local helpers — **not** exposed over
+  HTTP). The 10s price bump is the only failure mode you can drive from the UI without
+  tests.
+- No automated create-on-web / complete-on-mobile E2E. Unit tests cover the state machine
+  and conflict path; handoff is verified by hand. Playwright/Maestro scaffolds from the
+  template are not continuity coverage.
+- Fixed 10-minute session TTL, two-tap price confirm then buy, share via opaque session
+  id only. Session TTL lapse (request-time or in-process `SessionExpirySweeper`) also
+  releases the inventory hold; the sweeper is single-process demo glue, not a
+  multi-replica job runner.
+
+**Beyond the basic ask:**
+
+- Ticket landing with listing selection and a static stadium map.
+- Shared design tokens + `@repo/ui` so Next SSR and native share components.
+- Visual shell aligned to Gametime-style mocks; payment/promo chrome is decorative.
+- Domain write-up (`CONTEXT.md`), decision log (`docs/decisions.md`), structured event log.
 
 ---
 
@@ -87,6 +65,7 @@ URL so resume does not depend on the app already being installed.
 | `CheckoutService` state machine       | `apps/api/src/domain/checkout-service.ts`             |
 | In-memory session store (CAS)         | `apps/api/src/domain/session-store.ts`                |
 | Stubbed inventory + payment           | `apps/api/src/domain/{inventory,payment}-provider.ts` |
+| Session TTL sweeper (releases holds)  | `apps/api/src/domain/session-expiry-sweeper.ts`       |
 | Structured event log                  | `apps/api/src/domain/events.ts`                       |
 | tRPC surface                          | `apps/api/src/routers/checkout.ts`                    |
 | Web checkout (SSR)                    | `apps/web/app/checkout/[id]/`                         |
@@ -102,7 +81,7 @@ how it's built and how to run it.
 
 ```bash
 pnpm install
-cp apps/api/.env.example apps/api/.env   # DATABASE_URL only matters for the users demo route
+cp apps/api/.env.example apps/api/.env   # optional; DATABASE_URL only matters for the users demo route
 
 pnpm dev              # all three via Turborepo (Expo keys won't work — no TTY)
 # Prefer two terminals when you need Expo interactivity (r / j / etc.):
@@ -130,9 +109,10 @@ superjson transformer wired up, so there is no `{"json": ...}` envelope.
 
 ## The state model
 
-`created → active → pending_payment → completed`, with `expired` and `failed`
-as the off-ramps. `failed` is retryable (it transitions back through
-`pending_payment`); `completed` and `expired` are terminal.
+`active → pending_payment → completed`, with `expired` and `failed` as the
+off-ramps. `failed` is retryable (retry claims through `pending_payment` again);
+`completed` and `expired` are terminal. There is no separate `created` status —
+create writes `active` with the inventory hold already placed.
 
 The server is the only writer. A surface never computes state locally — it
 posts an intent (`resume`, `confirmPrice`, `complete`) and renders whatever
@@ -157,6 +137,12 @@ session also carries an `expiryReason` (`session_lapsed` | `hold_released`) —
 without it the resume path couldn't tell the two apart, only the write path
 could. Both surfaces read it to pick the right message.
 
+When the session clock lapses — on the next resume/complete/confirm touch or via
+the in-process `SessionExpirySweeper` (~30s) — checkout also `releaseHold`s and
+marks `session_lapsed`. Explicit abandon (`checkout.release`) drops the hold and
+marks `hold_released`. The sweeper is single-process demo glue, not a
+multi-replica job runner; mid-charge (`pending_payment`) is skipped.
+
 **Price changes.** The session tracks `acknowledgedPrice` separately from the
 listing's live price. A mismatch blocks completion with `PRECONDITION_FAILED`
 until the fan explicitly confirms via `checkout.confirmPrice`. Silent repricing
@@ -175,10 +161,11 @@ non-actionable **processing** view (no Buy CTA) — both when this surface just
 pressed Buy and when resume finds an in-flight claim — while `CONFLICT` maps to
 **claimed elsewhere**. Same “don’t buy again” outcome; different trust copy.
 
-**Instrumentation.** Every continuity-relevant transition emits a structured
-event (`session_created`, `session_resumed`, `price_reconfirmed`,
-`session_expired`, `session_completed`, `session_failed`) carrying the surface,
-so a cross-surface handoff is reconstructable from the log.
+**Instrumentation.** Continuity-relevant transitions emit structured events
+(`session_created`, `session_resumed`, `price_reconfirmed`, `session_expired`,
+`session_released`, `session_completed`, `session_failed`) carrying the surface
+where relevant, so a cross-surface handoff is reconstructable from the in-process
+log. There is no metrics API or funnel export in this prototype.
 
 ### Error codes
 
@@ -196,12 +183,11 @@ _distinguishable_, and that `CONFLICT` means only one thing.
 
 ## What appears before hydration (web)
 
-`/checkout/:id` is a React Server Component. It fetches the session server-side
-and renders the listing, status, and price into the HTML document — so the fan
-opening a resumed link sees real state in the first paint, with no spinner and
-no loading flash, before any client JS runs. The client component takes over
-afterward for the interactive parts (confirm price, complete) starting from that
-same server-rendered session, so hydration is seamless rather than a re-fetch.
+`/checkout/:id` is a React Server Component. It resumes the session server-side
+and passes that payload into the client tree, so the first HTML paint already
+includes listing, status, and price — no client mount spinner and no hydration
+re-fetch. The client then owns confirm / complete interactions from that same
+session.
 
 ## Tradeoffs
 
@@ -210,162 +196,73 @@ same server-rendered session, so hydration is seamless rather than a re-fetch.
   process, one map. Against a real DB this becomes a conditional
   `UPDATE ... WHERE status = $expected`, which is the same idea with the same
   guarantee; the `SessionStore` interface is the seam for that swap.
-- **Deterministic fakes over random failures.** `FakePaymentProvider.forceOutcome`
-  and `FakeInventoryProvider.setPrice` let tests and a live demo drive any state
-  transition on command. Randomized stubs would make the interesting paths
-  unreproducible.
+- **Deterministic fakes over random failures.** `forceOutcome`, `setPrice`, and
+  `releaseListing` on the fake providers let unit tests drive any transition on
+  command. The live UI demo path is the timed hold bump on `listing_3`; the
+  other knobs are not HTTP-exposed.
 - **No auth.** Deliberate, per the domain model — the session ID is the
   capability. Real deployment would still want the ID unguessable (it is) and
-  rate-limited (it isn't).
+  rate-limited (it isn't). Auth was not stubbed behind an interface; the prompt
+  listed it alongside payment/inventory, and the capability-id model is the
+  explicit substitute for this slice.
 - **Resume is pull-based.** A surface learns about changes when it acts, not
   when they happen.
 
 ## With more time
 
+- Multi-replica session expiry (durable job / leader election) instead of the
+  in-process sweeper, plus an indexed `expiresAt` query.
 - Push instead of pull — SSE or a websocket so a price change or a completion on
-  the other device updates this one live, rather than being discovered on the
-  next action.
-- Prisma-backed session store with a real conditional update, plus a background
-  sweeper to expire sessions rather than expiring lazily on read.
-- Playwright E2E driving an actual cross-surface handoff — create on web,
-  complete on mobile — which is the one thing the unit tests can only simulate.
-- Real idempotency keys on the payment call, so a retry after a network timeout
-  can't double-charge even if the process dies mid-flight.
+  the other device updates this one live.
+- Prisma-backed session store with a real conditional update.
+- Playwright (or similar) E2E for create-on-web / complete-on-mobile.
+- Real idempotency keys on the payment call so a retry after a network timeout
+  can't double-charge if the process dies mid-flight.
+- Cleaner overall UI, I definitely spent a good amount of time spitting and polishing because I hold myself to a high standard, however I would probably have done more real Gametime matching for overall look and feel.
+- Made the stadium (I changed to use the actual map you use on your website) scale better with all screen sizes, responsively, and on the mobile app too
+- True web to mobile deep-linking
 
 ---
 
 ## Stack
 
-| Layer          | Choice                                                |
-| -------------- | ----------------------------------------------------- |
-| Monorepo       | pnpm workspaces + Turborepo                           |
-| Mobile + Web   | Expo Router (React Native Web) — one app, 3 targets   |
-| Styling        | NativeWind (Tailwind for RN + web)                    |
-| State (server) | TanStack Query via tRPC                               |
-| API            | Fastify + tRPC                                        |
-| Database       | Prisma + Postgres                                     |
-| Validation     | Zod schemas in `@repo/api-contracts`                  |
-| Lint/format    | ESLint (flat config) + Prettier + Husky + lint-staged |
-| Unit/component | Jest + React Native Testing Library                   |
-| E2E (web)      | Playwright                                            |
-| E2E (mobile)   | Maestro                                               |
-| CI             | GitHub Actions + Turborepo remote caching             |
-| Versioning     | Changesets (per-package changelogs, no npm publish)   |
-| Deploy         | EAS (mobile), Vercel/EAS Hosting (web)                |
-
-Suggested next adds (not wired yet): Clerk (or another auth provider),
-Zustand for client state, React Hook Form for forms.
+| Layer       | Choice                                                               |
+| ----------- | -------------------------------------------------------------------- |
+| Monorepo    | pnpm workspaces + Turborepo                                          |
+| Web         | Next.js App Router (`apps/web`) — SSR checkout                       |
+| Mobile      | Expo Router (`apps/mobile-web`) — iOS / Android                      |
+| Shared UI   | `@repo/ui` + `@repo/tokens` (NativeWind)                             |
+| API         | Fastify + tRPC (`apps/api`)                                          |
+| Validation  | Zod in `@repo/api-contracts`                                         |
+| Sessions    | In-memory store (Prisma/Postgres exists for a users demo route only) |
+| Lint/format | ESLint + Prettier + Husky + lint-staged                              |
+| Tests       | Jest + React Native Testing Library; SSR markup tests on web         |
 
 ## Structure
 
 ```
 apps/
-  mobile-web/     Expo Router app — iOS, Android, and web from one codebase
-  api/            Fastify + tRPC server, Prisma, router implementation
+  web/            Next.js — SSR checkout + selection landing
+  mobile-web/     Expo Router — native checkout + deep links
+  api/            Fastify + tRPC, checkout domain, optional Prisma users demo
 packages/
-  ui/             Shared components (NativeWind)
-  api-contracts/  Shared Zod schemas — the contract between client and server
-  utils/          Shared helpers (use when you have cross-app pure logic)
+  ui/             Shared checkout/listings components (NativeWind)
+  tokens/         Shared design tokens
+  api-contracts/  Shared Zod schemas (client ↔ server contract)
+  utils/          Shared pure helpers
   config/         Shared ESLint, Tailwind, and tsconfig presets
 ```
 
-Ownership to copy when you fork:
-
-- **Schemas** live in `packages/api-contracts` (imported by the API, and by
-  the client when you build forms).
-- **Router + Prisma** live in `apps/api`. The client type-imports
-  `AppRouter` from `api` — type-only, so Metro never bundles server code.
-- Add a procedure in `apps/api/src/router.ts` and a schema in
-  `packages/api-contracts` when the input/output shape is shared.
-
-## Getting started
-
-```bash
-pnpm install
-cp apps/api/.env.example apps/api/.env   # set DATABASE_URL
-pnpm --filter api prisma:generate
-pnpm --filter api prisma:migrate
-
-pnpm dev              # all three via Turborepo (Expo keys won't work — no TTY)
-pnpm dev:servers      # api :4000 · web :3001
-pnpm dev:mobile-web   # Expo with a real TTY (use alongside dev:servers)
-# Or: pnpm dev:api / pnpm dev:web
-```
+- **Schemas** live in `packages/api-contracts`.
+- **Router + domain** live in `apps/api`. Clients type-import `AppRouter` only —
+  Metro/Next never bundle server code.
+- **SSR** is already owned by `apps/web`; Expo’s web target is secondary.
 
 ## Common commands
 
 ```bash
 pnpm lint          # ESLint across every app/package
 pnpm typecheck     # tsc --noEmit across every app/package
-pnpm test          # Jest unit + component tests
-pnpm test:e2e:web  # Playwright, against the web build
-pnpm --filter mobile-web test:e2e:mobile   # Maestro, needs a simulator/device
+pnpm test          # Jest unit + component tests (continuity coverage lives here)
 pnpm format        # Prettier write
 ```
-
-## Versioning changes (Changesets)
-
-After any change worth noting, run:
-
-```bash
-pnpm changeset
-```
-
-It'll ask which package(s) changed and whether it's a patch/minor/major,
-then write a small file in `.changeset/`. Commit that alongside your PR.
-When it's merged to `main`, the Release workflow (`.github/workflows/release.yml`)
-opens/updates a "Version Packages" PR that bumps versions and writes
-CHANGELOGs; merging _that_ PR is what finalizes a release. Nothing gets
-published to npm — this is an app template, so changesets are just used
-to keep a clean changelog per package as things evolve.
-
-## Using this as a template
-
-1. Rename `mobileweb` / `com.yourorg.mobileweb` in `apps/mobile-web/app.json`.
-2. Set up EAS (`eas init`) for mobile builds/submits.
-3. Point `DATABASE_URL` at a real Postgres instance (Supabase, Neon, RDS, etc.).
-4. Wire up auth in `apps/api/src/context.ts` and add a `protectedProcedure`
-   in `apps/api/src/trpc.ts`.
-5. Add a `TURBO_TOKEN`/`TURBO_TEAM` secret in GitHub if you want Turborepo
-   remote caching in CI (optional but speeds PRs up a lot).
-
-## ✅ Before committing this to the template repo
-
-Go through this list before you mark the repo "Template repository" on GitHub:
-
-- [ ] Run `pnpm install` locally at least once and commit the resulting
-      `pnpm-lock.yaml` — an unlocked template will drift immediately.
-- [ ] Run `pnpm lint`, `pnpm typecheck`, and `pnpm test` and confirm all pass clean.
-- [ ] Delete this checklist section (and the "Using this as a template"
-      section above) once you've actually done those steps, or leave it —
-      your call, but don't ship it half-followed.
-- [ ] Replace every occurrence of `mobileweb` / `com.yourorg.mobileweb`
-      (in `app.json`) with your real app name and bundle ID.
-- [ ] Replace `yourorg` in `apps/mobile-web/e2e/maestro/flow.yaml`'s `appId` too.
-- [ ] Decide on a real Postgres provider and update `apps/api/.env.example`
-      accordingly (don't commit a real `.env` — it's gitignored, keep it that way).
-- [ ] Confirm `.gitignore` covers your provider's local artifacts (e.g. add
-      `.vercel/`, `.eas/` if those tools generate local config you don't want committed).
-- [ ] If you want Turborepo remote caching in CI, add `TURBO_TOKEN` and
-      `TURBO_TEAM` as GitHub Actions secrets — otherwise CI still works,
-      just without cross-run caching.
-- [ ] If you want the Release workflow to actually open PRs, confirm
-      Actions has "Read and write permissions" enabled under
-      **Settings → Actions → General → Workflow permissions**.
-- [ ] Add a LICENSE file appropriate for how this template will be reused.
-- [ ] Smoke-test all three targets once end-to-end: `pnpm dev:web` in a
-      browser, `pnpm dev:ios`/`dev:android` in a simulator, and
-      `pnpm dev:api` responding on `/health`.
-- [ ] Squash/clean the git history so the template's first commit is tidy —
-      nobody forking it needs your scaffolding commits.
-
-## Extending
-
-- **New shared component:** add it to `packages/ui/src`, export from
-  `packages/ui/src/index.ts`. It's usable from `apps/mobile-web` immediately.
-- **New API endpoint:** add a Zod schema to `packages/api-contracts/src/schemas`
-  when the shape is shared; add the procedure in `apps/api/src/router.ts`
-  and talk to Prisma via `ctx.users` (or a new store on `Context`).
-- **Need real SSR/SEO for web later:** the `ui`/`api-contracts`/`utils`
-  packages don't know or care what renders them — you can swap the web
-  target for a Next.js app without touching shared code.
diff --git a/apps/api/src/context.ts b/apps/api/src/context.ts
index 1c8f47b..814de35 100644
--- a/apps/api/src/context.ts
+++ b/apps/api/src/context.ts
@@ -1,5 +1,6 @@
 import { PrismaClient } from '@prisma/client';
 import type { CreateUserInput, User } from '@repo/api-contracts';
+import { DEMO_CATALOG } from '@repo/api-contracts';
 import type { CreateFastifyContextOptions } from '@trpc/server/adapters/fastify';
 
 import { CheckoutService } from './domain/checkout-service';
@@ -7,6 +8,7 @@ import { EventLog } from './domain/events';
 import type { InventoryProvider } from './domain/inventory-provider';
 import { FakeInventoryProvider } from './domain/inventory-provider';
 import { FakePaymentProvider } from './domain/payment-provider';
+import { SessionExpirySweeper } from './domain/session-expiry-sweeper';
 import { InMemorySessionStore } from './domain/session-store';
 
 const prisma = new PrismaClient();
@@ -37,16 +39,8 @@ const inventoryProvider = new FakeInventoryProvider();
 const paymentProvider = new FakePaymentProvider();
 const eventLog = new EventLog();
 
-// Demo catalog — presentation fixtures in @repo/ui key off these listing ids.
-const DEMO_LISTINGS: Array<{ listingId: string; priceCents: number }> = [
-  { listingId: 'listing_1', priceCents: 15400 },
-  { listingId: 'listing_2', priceCents: 12500 },
-  { listingId: 'listing_3', priceCents: 8900 },
-  { listingId: 'listing_4', priceCents: 21000 },
-  { listingId: 'listing_5', priceCents: 167600 },
-];
-
-for (const listing of DEMO_LISTINGS) {
+// Demo catalog — shared with UI presentation via @repo/api-contracts.
+for (const listing of DEMO_CATALOG) {
   inventoryProvider.seedListing(listing.listingId, listing.priceCents);
 }
 
@@ -57,6 +51,13 @@ const checkoutService = new CheckoutService(
   eventLog,
 );
 
+/** In-process TTL sweeper bound to the shared checkout service. */
+export function createSessionExpirySweeper(
+  options: ConstructorParameters<typeof SessionExpirySweeper>[1] = {},
+): SessionExpirySweeper {
+  return new SessionExpirySweeper(checkoutService, options);
+}
+
 // Wire up your auth provider (e.g. Clerk) here to populate userId.
 export function createContext({ req: _req }: CreateFastifyContextOptions): Context {
   return {
diff --git a/apps/api/src/domain/checkout-service.test.ts b/apps/api/src/domain/checkout-service.test.ts
index cb68b82..efaa35d 100644
--- a/apps/api/src/domain/checkout-service.test.ts
+++ b/apps/api/src/domain/checkout-service.test.ts
@@ -43,16 +43,34 @@ describe('CheckoutService', () => {
     expect(completed.status).toBe('completed');
   });
 
+  it('returns live hold price on resume so clients can map price_changed', async () => {
+    const { service, inventory } = setup();
+    const session = await service.createSession('listing_1');
+    inventory.setPrice('listing_1', 5000);
+
+    const resumed = await service.resumeSession(session.id, 'web');
+
+    expect(resumed.session.status).toBe('active');
+    expect(resumed.livePriceCents).toBe(5000);
+  });
+
   it('expires a session once its expiresAt has passed', async () => {
     jest.useFakeTimers().setSystemTime(new Date('2026-01-01T00:00:00.000Z'));
-    const { service } = setup();
-    const session = await service.createSession('listing_1');
+    try {
+      const { service, inventory } = setup();
+      const session = await service.createSession('listing_1');
 
-    jest.setSystemTime(new Date('2026-01-01T00:11:00.000Z'));
-    const resumed = await service.resumeSession(session.id, 'mobile');
+      jest.setSystemTime(new Date('2026-01-01T00:11:00.000Z'));
+      const resumed = await service.resumeSession(session.id, 'mobile');
 
-    expect(resumed.status).toBe('expired');
-    jest.useRealTimers();
+      expect(resumed.session.status).toBe('expired');
+      expect(resumed.session.expiryReason).toBe('session_lapsed');
+      // TTL lapse must free inventory — otherwise the listing stays held forever.
+      await expect(inventory.getHoldStatus('listing_1')).resolves.toMatchObject({ held: false });
+      await expect(service.createSession('listing_1')).resolves.toMatchObject({ status: 'active' });
+    } finally {
+      jest.useRealTimers();
+    }
   });
 
   it('marks a session expired on resume if inventory hold was released independently', async () => {
@@ -62,7 +80,7 @@ describe('CheckoutService', () => {
 
     const resumed = await service.resumeSession(session.id, 'web');
 
-    expect(resumed.status).toBe('expired');
+    expect(resumed.session.status).toBe('expired');
   });
 
   it('blocks completion when price changed and has not been reconfirmed', async () => {
@@ -145,10 +163,11 @@ describe('CheckoutService', () => {
       inventory.releaseListing('listing_2');
       const dropped = await service.resumeSession(held.id, 'web');
 
-      expect(lapsed.status).toBe('expired');
-      expect(lapsed.expiryReason).toBe('session_lapsed');
-      expect(dropped.status).toBe('expired');
-      expect(dropped.expiryReason).toBe('hold_released');
+      expect(lapsed.session.status).toBe('expired');
+      expect(lapsed.session.expiryReason).toBe('session_lapsed');
+      await expect(inventory.getHoldStatus('listing_1')).resolves.toMatchObject({ held: false });
+      expect(dropped.session.status).toBe('expired');
+      expect(dropped.session.expiryReason).toBe('hold_released');
     } finally {
       jest.useRealTimers();
     }
@@ -272,4 +291,89 @@ describe('CheckoutService', () => {
     });
     jest.useRealTimers();
   });
+
+  describe('expireLapsedSessions', () => {
+    it.each([
+      {
+        name: 'active session past TTL',
+        listingId: 'listing_1',
+        advanceMs: 11 * 60 * 1000,
+        mutate: null as null | 'pending_payment',
+        expectSwept: 1,
+        expectHeld: false,
+        expectStatus: 'expired' as const,
+        expectReason: 'session_lapsed' as const,
+      },
+      {
+        name: 'active session still within TTL',
+        listingId: 'listing_1',
+        advanceMs: 60 * 1000,
+        mutate: null as null | 'pending_payment',
+        expectSwept: 0,
+        expectHeld: true,
+        expectStatus: 'active' as const,
+        expectReason: undefined,
+      },
+      {
+        name: 'pending_payment past TTL',
+        listingId: 'listing_1',
+        advanceMs: 11 * 60 * 1000,
+        mutate: 'pending_payment' as const,
+        expectSwept: 0,
+        expectHeld: true,
+        expectStatus: 'pending_payment' as const,
+        expectReason: undefined,
+      },
+    ])(
+      'handles $name',
+      async ({
+        listingId,
+        advanceMs,
+        mutate,
+        expectSwept,
+        expectHeld,
+        expectStatus,
+        expectReason,
+      }) => {
+        jest.useFakeTimers().setSystemTime(new Date('2026-01-01T00:00:00.000Z'));
+        try {
+          const { service, store, inventory } = setup();
+          const session = await service.createSession(listingId);
+          if (mutate) {
+            store.casUpdate(session.id, 'active', (current) => ({
+              ...current,
+              status: mutate,
+            }));
+          }
+
+          jest.advanceTimersByTime(advanceMs);
+          await expect(service.expireLapsedSessions()).resolves.toBe(expectSwept);
+
+          const after = store.get(session.id);
+          expect(after?.status).toBe(expectStatus);
+          expect(after?.expiryReason).toBe(expectReason);
+          await expect(inventory.getHoldStatus(listingId)).resolves.toMatchObject({
+            held: expectHeld,
+          });
+        } finally {
+          jest.useRealTimers();
+        }
+      },
+    );
+
+    it('leaves completed sessions and their sold inventory alone', async () => {
+      jest.useFakeTimers().setSystemTime(new Date('2026-01-01T00:00:00.000Z'));
+      try {
+        const { service, inventory } = setup();
+        const session = await service.createSession('listing_1');
+        await service.completeSession(session.id, 'web');
+
+        jest.advanceTimersByTime(11 * 60 * 1000);
+        await expect(service.expireLapsedSessions()).resolves.toBe(0);
+        await expect(inventory.getHoldStatus('listing_1')).resolves.toMatchObject({ held: true });
+      } finally {
+        jest.useRealTimers();
+      }
+    });
+  });
 });
diff --git a/apps/api/src/domain/checkout-service.ts b/apps/api/src/domain/checkout-service.ts
index 23d0374..690d185 100644
--- a/apps/api/src/domain/checkout-service.ts
+++ b/apps/api/src/domain/checkout-service.ts
@@ -1,4 +1,9 @@
-import type { CheckoutSession, CheckoutSurface, SessionExpiryReason } from '@repo/api-contracts';
+import type {
+  CheckoutSession,
+  CheckoutSurface,
+  ResumeSessionResult,
+  SessionExpiryReason,
+} from '@repo/api-contracts';
 import { nanoid } from 'nanoid';
 
 import type { EventLog } from './events';
@@ -75,17 +80,22 @@ export class CheckoutService {
     return session;
   }
 
-  async resumeSession(id: string, surface: CheckoutSurface): Promise<CheckoutSession> {
+  async resumeSession(id: string, surface: CheckoutSurface): Promise<ResumeSessionResult> {
     // Session expiration and the inventory hold are two independent clocks: a
     // session can be unexpired but reference inventory that is no longer held,
     // so resume checks the hold live rather than trusting `expiresAt`.
     let session = await this.expireIfNeeded(this.mustGet(id));
+    let livePriceCents: number | null = null;
     if (!this.isTerminal(session)) {
       const holdStatus = await this.inventory.getHoldStatus(session.listingId);
-      if (!holdStatus.held) session = this.expireNow(session, 'hold_released');
+      if (!holdStatus.held) {
+        session = this.expireNow(session, 'hold_released');
+      } else {
+        livePriceCents = holdStatus.currentPrice;
+      }
     }
     this.events.emit({ name: 'session_resumed', sessionId: id, toSurface: surface });
-    return session;
+    return { session, livePriceCents };
   }
 
   async confirmPrice(id: string): Promise<CheckoutSession> {
@@ -97,11 +107,10 @@ export class CheckoutService {
     if (session.status === 'pending_payment') throw new ConflictError(id);
 
     const holdStatus = await this.inventory.getHoldStatus(session.listingId);
-    const updated = this.store.casUpdate(id, session.status, (session) => ({
-      ...session,
+    const updated = this.mustCasUpdate(id, session.status, (current) => ({
+      ...current,
       acknowledgedPrice: holdStatus.currentPrice,
     }));
-    if (!updated) throw new ConflictError(id);
     this.events.emit({ name: 'price_reconfirmed', sessionId: id });
     return updated;
   }
@@ -128,29 +137,28 @@ export class CheckoutService {
     // Claim the session before charging. Whichever surface wins this swap owns
     // the payment attempt; the loser gets a ConflictError instead of a
     // duplicate order.
-    const claimed = this.store.casUpdate(id, session.status, (session) => ({
-      ...session,
+    this.mustCasUpdate(id, session.status, (current) => ({
+      ...current,
       status: 'pending_payment',
     }));
-    if (!claimed) throw new ConflictError(id);
 
     const outcome = await this.payment.charge(id, holdStatus.currentPrice);
     if (outcome === 'succeeded') {
-      const completed = this.store.casUpdate(id, 'pending_payment', (session) => ({
-        ...session,
+      const completed = this.mustCasUpdate(id, 'pending_payment', (current) => ({
+        ...current,
         status: 'completed',
       }));
       this.events.emit({ name: 'session_completed', sessionId: id, surface });
-      return completed as CheckoutSession;
+      return completed;
     }
 
-    const failed = this.store.casUpdate(id, 'pending_payment', (session) => ({
-      ...session,
+    const failed = this.mustCasUpdate(id, 'pending_payment', (current) => ({
+      ...current,
       status: 'failed',
       failureReason: outcome,
     }));
     this.events.emit({ name: 'session_failed', sessionId: id, surface });
-    return failed as CheckoutSession;
+    return failed;
   }
 
   /**
@@ -173,25 +181,71 @@ export class CheckoutService {
     return expired;
   }
 
+  /**
+   * Background / on-demand sweep: expire sessions past `expiresAt` and free
+   * their holds. Same lapse path as request-time TTL. Skips mid-charge.
+   * @returns how many sessions this pass newly marked session_lapsed
+   */
+  async expireLapsedSessions(): Promise<number> {
+    let swept = 0;
+    for (const session of this.store.list()) {
+      if (!this.isEligibleForSessionClockLapse(session)) continue;
+      const expired = await this.lapseForSessionClock(session);
+      if (expired) swept += 1;
+    }
+    return swept;
+  }
+
   private mustGet(id: string): CheckoutSession {
     const session = this.store.get(id);
     if (!session) throw new SessionNotFoundError(id);
     return session;
   }
 
+  private mustCasUpdate(
+    id: string,
+    expectedStatus: CheckoutSession['status'],
+    updater: (session: CheckoutSession) => CheckoutSession,
+  ): CheckoutSession {
+    const updated = this.store.casUpdate(id, expectedStatus, updater);
+    if (!updated) throw new ConflictError(id);
+    return updated;
+  }
+
   private isTerminal(session: CheckoutSession): boolean {
     return session.status === 'completed' || session.status === 'expired';
   }
 
+  /** Active/failed past TTL — not terminal, not mid-charge. */
+  private isEligibleForSessionClockLapse(session: CheckoutSession): boolean {
+    if (this.isTerminal(session)) return false;
+    if (session.status === 'pending_payment') return false;
+    return new Date(session.expiresAt).getTime() < Date.now();
+  }
+
   private async expireIfNeeded(session: CheckoutSession): Promise<CheckoutSession> {
-    if (this.isTerminal(session)) return session;
-    if (new Date(session.expiresAt).getTime() >= Date.now()) return session;
-    return this.expireNow(session, 'session_lapsed');
+    if (!this.isEligibleForSessionClockLapse(session)) return session;
+    await this.lapseForSessionClock(session);
+    return this.mustGet(session.id);
+  }
+
+  /**
+   * Mark session_lapsed then free the hold. CAS first so a concurrent
+   * pending_payment claim cannot lose its inventory underneath it.
+   * @returns true when this call won the expire CAS
+   */
+  private async lapseForSessionClock(session: CheckoutSession): Promise<boolean> {
+    const expired = this.expireNow(session, 'session_lapsed');
+    if (expired.status !== 'expired' || expired.expiryReason !== 'session_lapsed') {
+      return false;
+    }
+    await this.inventory.releaseHold(session.listingId);
+    return true;
   }
 
   private expireNow(session: CheckoutSession, reason: SessionExpiryReason): CheckoutSession {
-    const expired = this.store.casUpdate(session.id, session.status, (session) => ({
-      ...session,
+    const expired = this.store.casUpdate(session.id, session.status, (current) => ({
+      ...current,
       status: 'expired',
       expiryReason: reason,
     }));
diff --git a/apps/api/src/domain/session-expiry-sweeper.test.ts b/apps/api/src/domain/session-expiry-sweeper.test.ts
new file mode 100644
index 0000000..141ede2
--- /dev/null
+++ b/apps/api/src/domain/session-expiry-sweeper.test.ts
@@ -0,0 +1,53 @@
+import { SessionExpirySweeper } from './session-expiry-sweeper';
+
+describe('SessionExpirySweeper', () => {
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('invokes expireLapsedSessions on each interval tick', async () => {
+    jest.useFakeTimers();
+    const expireLapsedSessions = jest.fn().mockResolvedValue(2);
+    const onSwept = jest.fn();
+    const sweeper = new SessionExpirySweeper(
+      { expireLapsedSessions },
+      { intervalMs: 1000, onSwept },
+    );
+
+    sweeper.start();
+    await jest.advanceTimersByTimeAsync(1000);
+    await jest.advanceTimersByTimeAsync(1000);
+    sweeper.stop();
+
+    expect(expireLapsedSessions).toHaveBeenCalledTimes(2);
+    expect(onSwept).toHaveBeenCalledWith(2);
+  });
+
+  it('reports errors without throwing out of tick', async () => {
+    const expireLapsedSessions = jest.fn().mockRejectedValue(new Error('store down'));
+    const onError = jest.fn();
+    const sweeper = new SessionExpirySweeper({ expireLapsedSessions }, { onError });
+
+    await expect(sweeper.tick()).resolves.toBe(0);
+    expect(onError).toHaveBeenCalledWith(expect.any(Error));
+  });
+
+  it('skips overlapping ticks while a sweep is in flight', async () => {
+    let resolveSweep!: (count: number) => void;
+    const expireLapsedSessions = jest.fn(
+      () =>
+        new Promise<number>((resolve) => {
+          resolveSweep = resolve;
+        }),
+    );
+    const sweeper = new SessionExpirySweeper({ expireLapsedSessions });
+
+    const first = sweeper.tick();
+    const second = sweeper.tick();
+    resolveSweep(1);
+
+    await expect(first).resolves.toBe(1);
+    await expect(second).resolves.toBe(0);
+    expect(expireLapsedSessions).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/apps/api/src/domain/session-expiry-sweeper.ts b/apps/api/src/domain/session-expiry-sweeper.ts
new file mode 100644
index 0000000..57fa0d0
--- /dev/null
+++ b/apps/api/src/domain/session-expiry-sweeper.ts
@@ -0,0 +1,62 @@
+/** Default poll interval for the in-process session TTL sweeper. */
+export const SESSION_EXPIRY_SWEEP_INTERVAL_MS = 30_000;
+
+export type SessionExpirySweepTarget = {
+  expireLapsedSessions: () => Promise<number>;
+};
+
+export type SessionExpirySweeperOptions = {
+  intervalMs?: number;
+  onError?: (error: unknown) => void;
+  onSwept?: (count: number) => void;
+};
+
+/**
+ * In-process timer that periodically asks checkout to expire lapsed sessions.
+ * Single-process demo glue — production would use a real job runner / cron.
+ */
+export class SessionExpirySweeper {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private tickInFlight = false;
+  private readonly intervalMs: number;
+  private readonly onError: ((error: unknown) => void) | undefined;
+  private readonly onSwept: ((count: number) => void) | undefined;
+
+  constructor(
+    private readonly checkout: SessionExpirySweepTarget,
+    options: SessionExpirySweeperOptions = {},
+  ) {
+    this.intervalMs = options.intervalMs ?? SESSION_EXPIRY_SWEEP_INTERVAL_MS;
+    this.onError = options.onError;
+    this.onSwept = options.onSwept;
+  }
+
+  start(): void {
+    if (this.timer !== null) return;
+    this.timer = setInterval(() => {
+      void this.tick();
+    }, this.intervalMs);
+  }
+
+  stop(): void {
+    if (this.timer === null) return;
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+
+  /** One sweep pass. Safe to call from tests without starting the timer. */
+  async tick(): Promise<number> {
+    if (this.tickInFlight) return 0;
+    this.tickInFlight = true;
+    try {
+      const swept = await this.checkout.expireLapsedSessions();
+      if (swept > 0) this.onSwept?.(swept);
+      return swept;
+    } catch (error) {
+      this.onError?.(error);
+      return 0;
+    } finally {
+      this.tickInFlight = false;
+    }
+  }
+}
diff --git a/apps/api/src/domain/session-store.ts b/apps/api/src/domain/session-store.ts
index 3a326de..de53435 100644
--- a/apps/api/src/domain/session-store.ts
+++ b/apps/api/src/domain/session-store.ts
@@ -3,6 +3,8 @@ import type { CheckoutSession } from '@repo/api-contracts';
 export interface SessionStore {
   create(session: CheckoutSession): void;
   get(id: string): CheckoutSession | undefined;
+  /** Full scan for the in-memory prototype; production would filter by expiresAt. */
+  list(): CheckoutSession[];
   casUpdate(
     id: string,
     expectedStatus: CheckoutSession['status'],
@@ -21,6 +23,10 @@ export class InMemorySessionStore implements SessionStore {
     return this.sessions.get(id);
   }
 
+  list(): CheckoutSession[] {
+    return [...this.sessions.values()];
+  }
+
   // Compare-and-swap: the status check and the write happen with no `await`
   // between them, so two same-tick callers cannot both win the swap. This is
   // what prevents duplicate order completion across surfaces.
diff --git a/apps/api/src/index.ts b/apps/api/src/index.ts
index cbbc050..972bf7c 100644
--- a/apps/api/src/index.ts
+++ b/apps/api/src/index.ts
@@ -2,7 +2,7 @@ import cors from '@fastify/cors';
 import { fastifyTRPCPlugin } from '@trpc/server/adapters/fastify';
 import Fastify from 'fastify';
 
-import { createContext } from './context';
+import { createContext, createSessionExpirySweeper } from './context';
 import { env } from './env';
 import { appRouter } from './router';
 
@@ -19,6 +19,27 @@ async function main() {
   server.get('/health', async () => ({ ok: true }));
 
   await server.listen({ port: env.PORT, host: '0.0.0.0' });
+
+  const sweeper = createSessionExpirySweeper({
+    onError: (error) => {
+      server.log.error(error, 'session expiry sweep failed');
+    },
+    onSwept: (count) => {
+      server.log.info({ swept: count }, 'expired lapsed checkout sessions');
+    },
+  });
+  sweeper.start();
+
+  const shutdown = async () => {
+    sweeper.stop();
+    await server.close();
+  };
+  process.once('SIGINT', () => {
+    void shutdown();
+  });
+  process.once('SIGTERM', () => {
+    void shutdown();
+  });
 }
 
 main().catch((err) => {
diff --git a/apps/api/src/router.test.ts b/apps/api/src/router.test.ts
index 8c7e20b..d5697f3 100644
--- a/apps/api/src/router.test.ts
+++ b/apps/api/src/router.test.ts
@@ -122,7 +122,8 @@ describe('appRouter.checkout', () => {
     expect(created.status).toBe('active');
 
     const resumed = await caller.checkout.resume({ sessionId: created.id });
-    expect(resumed.status).toBe('active');
+    expect(resumed.session.status).toBe('active');
+    expect(resumed.livePriceCents).toBe(4200);
 
     const completed = await caller.checkout.complete({ sessionId: created.id });
     expect(completed.status).toBe('completed');
diff --git a/apps/api/src/routers/checkout.ts b/apps/api/src/routers/checkout.ts
index de760e9..cc450e3 100644
--- a/apps/api/src/routers/checkout.ts
+++ b/apps/api/src/routers/checkout.ts
@@ -2,6 +2,7 @@ import {
   CHECKOUT_ERROR_CODE,
   checkoutSessionSchema,
   createSessionInput,
+  resumeSessionResultSchema,
   sessionIdInput,
 } from '@repo/api-contracts';
 import { TRPCError } from '@trpc/server';
@@ -55,59 +56,45 @@ function toTRPCError(error: unknown): TRPCError {
   return new TRPCError({ code: 'INTERNAL_SERVER_ERROR', cause: error });
 }
 
+function withDomainErrors<T>(run: () => Promise<T>): Promise<T> {
+  return run().catch((error: unknown) => {
+    throw toTRPCError(error);
+  });
+}
+
 export const checkoutRouter = router({
   create: publicProcedure
     .input(createSessionInput)
     .output(checkoutSessionSchema)
-    .mutation(async ({ ctx, input }) => {
-      try {
-        return await ctx.checkout.createSession(input.listingId);
-      } catch (error) {
-        throw toTRPCError(error);
-      }
-    }),
+    .mutation(({ ctx, input }) =>
+      withDomainErrors(() => ctx.checkout.createSession(input.listingId)),
+    ),
 
   resume: publicProcedure
     .input(sessionIdInput)
-    .output(checkoutSessionSchema)
-    .mutation(async ({ ctx, input }) => {
-      try {
-        return await ctx.checkout.resumeSession(input.sessionId, input.surface);
-      } catch (error) {
-        throw toTRPCError(error);
-      }
-    }),
+    .output(resumeSessionResultSchema)
+    .mutation(({ ctx, input }) =>
+      withDomainErrors(() => ctx.checkout.resumeSession(input.sessionId, input.surface)),
+    ),
 
   confirmPrice: publicProcedure
     .input(sessionIdInput)
     .output(checkoutSessionSchema)
-    .mutation(async ({ ctx, input }) => {
-      try {
-        return await ctx.checkout.confirmPrice(input.sessionId);
-      } catch (error) {
-        throw toTRPCError(error);
-      }
-    }),
+    .mutation(({ ctx, input }) =>
+      withDomainErrors(() => ctx.checkout.confirmPrice(input.sessionId)),
+    ),
 
   complete: publicProcedure
     .input(sessionIdInput)
     .output(checkoutSessionSchema)
-    .mutation(async ({ ctx, input }) => {
-      try {
-        return await ctx.checkout.completeSession(input.sessionId, input.surface);
-      } catch (error) {
-        throw toTRPCError(error);
-      }
-    }),
+    .mutation(({ ctx, input }) =>
+      withDomainErrors(() => ctx.checkout.completeSession(input.sessionId, input.surface)),
+    ),
 
   release: publicProcedure
     .input(sessionIdInput)
     .output(checkoutSessionSchema)
-    .mutation(async ({ ctx, input }) => {
-      try {
-        return await ctx.checkout.releaseSession(input.sessionId, input.surface);
-      } catch (error) {
-        throw toTRPCError(error);
-      }
-    }),
+    .mutation(({ ctx, input }) =>
+      withDomainErrors(() => ctx.checkout.releaseSession(input.sessionId, input.surface)),
+    ),
 });
diff --git a/apps/mobile-web/app/__tests__/checkout.test.tsx b/apps/mobile-web/app/__tests__/checkout.test.tsx
index 06d5e1c..494c01a 100644
--- a/apps/mobile-web/app/__tests__/checkout.test.tsx
+++ b/apps/mobile-web/app/__tests__/checkout.test.tsx
@@ -58,6 +58,16 @@ const release = trpc.checkout.release.mutate as jest.Mock;
 // A TRPCClientError carries its wire code on `error.data.code`; the screen
 // duck-types that shape rather than importing the class, so the fakes below
 // are exactly what it reads in production.
+
+function resumeResult(
+  session: CheckoutSession,
+  livePriceCents: number | null = session.status === 'active' || session.status === 'failed'
+    ? session.acknowledgedPrice
+    : null,
+) {
+  return { session, livePriceCents };
+}
+
 function trpcError(code: string, message = code) {
   return Object.assign(new Error(message), { data: { code } });
 }
@@ -80,7 +90,7 @@ beforeEach(() => {
 
 describe('CheckoutScreen', () => {
   it('shows processing (no Buy CTA) when resume returns pending_payment', async () => {
-    resume.mockResolvedValue({ ...activeSession, status: 'pending_payment' });
+    resume.mockResolvedValue(resumeResult({ ...activeSession, status: 'pending_payment' }));
 
     render(<CheckoutScreen />);
 
@@ -91,10 +101,13 @@ describe('CheckoutScreen', () => {
   it('shows a loading state, then the active checkout state once resumed', async () => {
     // Keep resume pending until after the first paint so we can assert loading —
     // mockResolvedValue settles inside RTL's act() and skips straight to ready.
-    let resolveResume!: (session: CheckoutSession) => void;
+    let resolveResume!: (result: {
+      session: CheckoutSession;
+      livePriceCents: number | null;
+    }) => void;
     resume.mockImplementation(
       () =>
-        new Promise<CheckoutSession>((resolve) => {
+        new Promise<{ session: CheckoutSession; livePriceCents: number | null }>((resolve) => {
           resolveResume = resolve;
         }),
     );
@@ -103,14 +116,14 @@ describe('CheckoutScreen', () => {
 
     expect(screen.getByText(/finding your checkout/i)).toBeTruthy();
 
-    resolveResume(activeSession);
+    resolveResume(resumeResult(activeSession));
 
     await waitFor(() => expect(screen.getByTestId('complete-button')).toBeTruthy());
     expect(screen.getByText(/\$84\.00/)).toBeTruthy();
   });
 
   it('resumes reporting the mobile surface so the event log records the handoff', async () => {
-    resume.mockResolvedValue(activeSession);
+    resume.mockResolvedValue(resumeResult(activeSession));
 
     render(<CheckoutScreen />);
 
@@ -119,7 +132,7 @@ describe('CheckoutScreen', () => {
   });
 
   it('shows an unavailable state for an expired session', async () => {
-    resume.mockResolvedValue({ ...activeSession, status: 'expired' });
+    resume.mockResolvedValue(resumeResult({ ...activeSession, status: 'expired' }));
 
     render(<CheckoutScreen />);
 
@@ -127,13 +140,13 @@ describe('CheckoutScreen', () => {
   });
 
   it('distinguishes an expired session from an unavailable listing', async () => {
-    resume.mockResolvedValue({ ...activeSession, status: 'expired' });
+    resume.mockResolvedValue(resumeResult({ ...activeSession, status: 'expired' }));
     const expiredView = render(<CheckoutScreen />);
     await waitFor(() => expect(screen.getByText('Checkout session expired')).toBeTruthy());
     expect(screen.queryByText('Listing no longer available')).toBeNull();
     expiredView.unmount();
 
-    resume.mockResolvedValue(activeSession);
+    resume.mockResolvedValue(resumeResult(activeSession));
     complete.mockRejectedValue(trpcError('UNPROCESSABLE_CONTENT'));
     render(<CheckoutScreen />);
     await waitFor(() => expect(screen.getByTestId('complete-button')).toBeTruthy());
@@ -146,11 +159,13 @@ describe('CheckoutScreen', () => {
   it('reads unavailability off a resumed session whose inventory hold was released', async () => {
     // The session's own clock is fine; the hold underneath it went away. Resume
     // reports that as `expired`, and only `expiryReason` says which clock ran out.
-    resume.mockResolvedValue({
-      ...activeSession,
-      status: 'expired',
-      expiryReason: 'hold_released',
-    });
+    resume.mockResolvedValue(
+      resumeResult({
+        ...activeSession,
+        status: 'expired',
+        expiryReason: 'hold_released',
+      }),
+    );
 
     render(<CheckoutScreen />);
 
@@ -159,7 +174,7 @@ describe('CheckoutScreen', () => {
   });
 
   it('shows a confirmation state for a completed session', async () => {
-    resume.mockResolvedValue({ ...activeSession, status: 'completed' });
+    resume.mockResolvedValue(resumeResult({ ...activeSession, status: 'completed' }));
 
     render(<CheckoutScreen />);
 
@@ -167,7 +182,7 @@ describe('CheckoutScreen', () => {
   });
 
   it('requires an explicit acknowledgement before completing at a changed price', async () => {
-    resume.mockResolvedValue(activeSession);
+    resume.mockResolvedValue(resumeResult(activeSession));
     complete.mockRejectedValueOnce(trpcError('PRECONDITION_FAILED'));
     confirmPrice.mockResolvedValue({ ...activeSession, acknowledgedPrice: 5500 });
 
@@ -202,7 +217,7 @@ describe('CheckoutScreen', () => {
   });
 
   it('tells the fan the order is being completed on another device on CONFLICT', async () => {
-    resume.mockResolvedValue(activeSession);
+    resume.mockResolvedValue(resumeResult(activeSession));
     complete.mockRejectedValue(trpcError('CONFLICT'));
 
     render(<CheckoutScreen />);
@@ -216,11 +231,13 @@ describe('CheckoutScreen', () => {
   });
 
   it('shows the failure reason and lets the fan retry a failed payment', async () => {
-    resume.mockResolvedValue({
-      ...activeSession,
-      status: 'failed',
-      failureReason: 'card_declined',
-    });
+    resume.mockResolvedValue(
+      resumeResult({
+        ...activeSession,
+        status: 'failed',
+        failureReason: 'card_declined',
+      }),
+    );
     complete.mockResolvedValue({ ...activeSession, status: 'completed' });
 
     render(<CheckoutScreen />);
@@ -252,7 +269,7 @@ describe('CheckoutScreen', () => {
   });
 
   it('shows Share tickets for an active session without exposing raw URLs', async () => {
-    resume.mockResolvedValue(activeSession);
+    resume.mockResolvedValue(resumeResult(activeSession));
 
     render(<CheckoutScreen />);
 
@@ -262,7 +279,7 @@ describe('CheckoutScreen', () => {
   });
 
   it('releases the ticket hold when the fan taps back', async () => {
-    resume.mockResolvedValue(activeSession);
+    resume.mockResolvedValue(resumeResult(activeSession));
 
     render(<CheckoutScreen />);
     await waitFor(() => expect(screen.getByTestId('checkout-back')).toBeTruthy());
@@ -277,7 +294,7 @@ describe('CheckoutScreen', () => {
   });
 
   it('still navigates back if release fails', async () => {
-    resume.mockResolvedValue(activeSession);
+    resume.mockResolvedValue(resumeResult(activeSession));
     release.mockRejectedValue(new Error('offline'));
 
     render(<CheckoutScreen />);
diff --git a/apps/mobile-web/app/checkout/[id].tsx b/apps/mobile-web/app/checkout/[id].tsx
index a125735..b319889 100644
--- a/apps/mobile-web/app/checkout/[id].tsx
+++ b/apps/mobile-web/app/checkout/[id].tsx
@@ -1,5 +1,5 @@
 import type { CheckoutSession } from '@repo/api-contracts';
-import { DEMO_PRICE_CHANGE, msUntilDemoPriceBump } from '@repo/api-contracts';
+import { msUntilDemoPriceBump } from '@repo/api-contracts';
 import { colors, spacePx } from '@repo/tokens';
 import type { CheckoutView } from '@repo/ui';
 import {
@@ -13,14 +13,16 @@ import {
   isShareableSession,
   mapCheckoutPresentation,
   PriceBreakdown,
-  priceUpdatedNotice,
+  sessionFromView,
   ShareTickets,
+  showsCheckoutActions,
   SuperDealBanner,
   ThemeProvider,
   TicketDeliveryRow,
   UrgencyBanner,
+  useCheckoutActions,
   viewFromErrorCode,
-  viewFromSession,
+  viewFromResume,
 } from '@repo/ui';
 import { trpcErrorCode } from '@repo/utils';
 import { useLocalSearchParams, useRouter } from 'expo-router';
@@ -38,10 +40,6 @@ const SURFACE = 'mobile' as const;
 // Normally we'd store this in a `env.local` file. For the demo, we hardcode it here.
 const WEB_ORIGIN = process.env.EXPO_PUBLIC_WEB_ORIGIN ?? 'http://localhost:3001';
 
-function sessionFromView(view: CheckoutView): CheckoutSession | null {
-  return 'session' in view && view.session ? view.session : null;
-}
-
 export default function CheckoutScreen() {
   const router = useRouter();
   const listingsUtils = listingsApi.useUtils();
@@ -50,7 +48,6 @@ export default function CheckoutScreen() {
   const sessionId = Array.isArray(rawId) ? rawId[0] : rawId;
 
   const [view, setView] = useState<CheckoutView>({ kind: 'loading' });
-  const [busy, setBusy] = useState(false);
   const [detailsExpanded, setDetailsExpanded] = useState(false);
 
   // A resume for one id must never land on top of a later one, and nothing
@@ -65,11 +62,28 @@ export default function CheckoutScreen() {
     };
   }, []);
 
-  const isCurrent = useCallback(
-    (token: number) => mountedRef.current && token === requestRef.current,
+  const shouldApply = useCallback(() => mountedRef.current, []);
+
+  const mutations = useMemo(
+    () => ({
+      complete: (input: { sessionId: string; surface: 'mobile' | 'web' }) =>
+        trpc.checkout.complete.mutate(input),
+      confirmPrice: (input: { sessionId: string; surface: 'mobile' | 'web' }) =>
+        trpc.checkout.confirmPrice.mutate(input),
+      resume: (input: { sessionId: string; surface: 'mobile' | 'web' }) =>
+        trpc.checkout.resume.mutate(input),
+    }),
     [],
   );
 
+  const { busy, completeOrder, confirmNewPrice, refreshFromResume } = useCheckoutActions({
+    surface: SURFACE,
+    mutations,
+    setView,
+    shouldApply,
+    onConfirmPriceSuccess: () => setDetailsExpanded(true),
+  });
+
   useEffect(() => {
     if (!sessionId) {
       setView({ kind: 'error', message: 'This link is missing a checkout id.' });
@@ -81,37 +95,17 @@ export default function CheckoutScreen() {
 
     trpc.checkout.resume
       .mutate({ sessionId, surface: SURFACE })
-      .then((session) => {
-        if (isCurrent(token)) setView(viewFromSession(session));
+      .then((result) => {
+        if (mountedRef.current && token === requestRef.current) {
+          setView(viewFromResume(result.session, result.livePriceCents));
+        }
       })
       .catch((error: unknown) => {
-        if (isCurrent(token)) setView(viewFromErrorCode(trpcErrorCode(error)));
-      });
-  }, [isCurrent, sessionId]);
-
-  // Demo listing: after the demo window on an active hold, show price-change recovery.
-  useEffect(() => {
-    if (view.kind !== 'ready') return;
-    const delayMs = msUntilDemoPriceBump(view.session);
-    if (delayMs === null) return;
-
-    const trackedSessionId = view.session.id;
-    const timer = setTimeout(() => {
-      setView((current) => {
-        if (current.kind !== 'ready' || current.session.id !== trackedSessionId) return current;
-        if (current.session.acknowledgedPrice === DEMO_PRICE_CHANGE.heldPriceAfterBumpCents) {
-          return current;
+        if (mountedRef.current && token === requestRef.current) {
+          setView(viewFromErrorCode(trpcErrorCode(error)));
         }
-        return {
-          kind: 'price_changed',
-          session: current.session,
-          newPriceCents: DEMO_PRICE_CHANGE.heldPriceAfterBumpCents,
-        };
       });
-    }, delayMs);
-
-    return () => clearTimeout(timer);
-  }, [view]);
+  }, [sessionId]);
 
   const shareSession = (() => {
     const session = sessionFromView(view);
@@ -123,54 +117,6 @@ export default function CheckoutScreen() {
     return buildCheckoutShareUrls(shareSession.id, WEB_ORIGIN);
   }, [shareSession]);
 
-  const completePurchase = useCallback(
-    async (session: CheckoutSession) => {
-      if (!sessionId || busy) return;
-      const token = requestRef.current;
-      setBusy(true);
-      // Claim UI immediately — never leave Buy enabled while pending_payment.
-      setView({ kind: 'processing', session: { ...session, status: 'pending_payment' } });
-      try {
-        const next = await trpc.checkout.complete.mutate({ sessionId, surface: SURFACE });
-        if (isCurrent(token)) setView(viewFromSession(next));
-      } catch (error) {
-        if (isCurrent(token)) setView(viewFromErrorCode(trpcErrorCode(error), session));
-      } finally {
-        if (mountedRef.current) setBusy(false);
-      }
-    },
-    [busy, isCurrent, sessionId],
-  );
-
-  const confirmNewPrice = useCallback(
-    async (session: CheckoutSession) => {
-      if (!sessionId || busy) return;
-      const token = requestRef.current;
-      setBusy(true);
-      try {
-        const next = await trpc.checkout.confirmPrice.mutate({ sessionId, surface: SURFACE });
-        // Acknowledging shows the fan the new number and hands the purchase
-        // decision back to them — it deliberately does not charge. Expand the
-        // breakdown so the strike-through previous price is visible without a tap.
-        if (isCurrent(token)) {
-          setDetailsExpanded(true);
-          setView(
-            viewFromSession(
-              next,
-              priceUpdatedNotice(next.acknowledgedPrice),
-              session.acknowledgedPrice,
-            ),
-          );
-        }
-      } catch (error) {
-        if (isCurrent(token)) setView(viewFromErrorCode(trpcErrorCode(error), session));
-      } finally {
-        if (mountedRef.current) setBusy(false);
-      }
-    },
-    [busy, isCurrent, sessionId],
-  );
-
   const onShare = useCallback(async (payload: { webUrl: string; mobileUrl: string }) => {
     // Message-only: iOS Copy pastes the URL; message+url showed "2 Links";
     // url-only left the clipboard empty on Copy.
@@ -191,14 +137,26 @@ export default function CheckoutScreen() {
     router.back();
   }, [listingsUtils.listings.list, router, sessionId]);
 
+  const onDemoPriceExpire = useCallback(() => {
+    if (!sessionId || view.kind !== 'ready') return;
+    void refreshFromResume(sessionId);
+  }, [refreshFromResume, sessionId, view.kind]);
+
+  const completePurchase = useCallback(
+    async (session: CheckoutSession) => {
+      if (!sessionId || busy) return;
+      await completeOrder(session);
+    },
+    [busy, completeOrder, sessionId],
+  );
+
   const session = sessionFromView(view);
   const previousUnitPriceCents = view.kind === 'ready' ? view.previousUnitPriceCents : undefined;
   const presentation = session
     ? mapCheckoutPresentation(session, { viewKind: view.kind, previousUnitPriceCents })
     : null;
   const showShell = view.kind !== 'loading' && presentation !== null;
-  const showStickyActions =
-    view.kind === 'ready' || view.kind === 'price_changed' || view.kind === 'failed';
+  const showStickyActions = showsCheckoutActions(view);
   const showDemoCountdown = view.kind === 'ready' && msUntilDemoPriceBump(view.session) !== null;
 
   return (
@@ -235,6 +193,7 @@ export default function CheckoutScreen() {
               <DemoPriceCountdown
                 listingId={view.session.listingId}
                 createdAt={view.session.createdAt}
+                onExpire={onDemoPriceExpire}
               />
             ) : null}
             <View
diff --git a/apps/web/app/checkout-leave-mode.tsx b/apps/web/app/checkout-leave-mode.tsx
new file mode 100644
index 0000000..d3c8491
--- /dev/null
+++ b/apps/web/app/checkout-leave-mode.tsx
@@ -0,0 +1,40 @@
+'use client';
+
+import type { ReactNode } from 'react';
+import { createContext, useCallback, useContext, useMemo, useState } from 'react';
+
+/**
+ * How the checkout header leave control should read.
+ * `done` only after a successful purchase — not for expired / abandoned exits.
+ */
+export type CheckoutLeaveMode = 'cancel' | 'done';
+
+type CheckoutLeaveModeContextValue = {
+  leaveMode: CheckoutLeaveMode;
+  setLeaveMode: (mode: CheckoutLeaveMode) => void;
+};
+
+const noopSetLeaveMode = (_mode: CheckoutLeaveMode) => {
+  // Outside the provider (e.g. isolated SSR tests) — header stays on Cancel.
+};
+
+const CheckoutLeaveModeContext = createContext<CheckoutLeaveModeContextValue>({
+  leaveMode: 'cancel',
+  setLeaveMode: noopSetLeaveMode,
+});
+
+export function CheckoutLeaveModeProvider({ children }: { children: ReactNode }) {
+  const [leaveMode, setLeaveModeState] = useState<CheckoutLeaveMode>('cancel');
+  const setLeaveMode = useCallback((mode: CheckoutLeaveMode) => {
+    setLeaveModeState(mode);
+  }, []);
+  const value = useMemo(() => ({ leaveMode, setLeaveMode }), [leaveMode, setLeaveMode]);
+
+  return (
+    <CheckoutLeaveModeContext.Provider value={value}>{children}</CheckoutLeaveModeContext.Provider>
+  );
+}
+
+export function useCheckoutLeaveMode(): CheckoutLeaveModeContextValue {
+  return useContext(CheckoutLeaveModeContext);
+}
diff --git a/apps/web/app/checkout/[id]/checkout-client.test.tsx b/apps/web/app/checkout/[id]/checkout-client.test.tsx
index df52e7c..1e59961 100644
--- a/apps/web/app/checkout/[id]/checkout-client.test.tsx
+++ b/apps/web/app/checkout/[id]/checkout-client.test.tsx
@@ -1,7 +1,9 @@
 import type { CheckoutSession } from '@repo/api-contracts';
 import { DEMO_PRICE_CHANGE } from '@repo/api-contracts';
 import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import type { ReactElement } from 'react';
 
+import { CheckoutLeaveModeProvider } from '../../checkout-leave-mode';
 import { CheckoutClient } from './checkout-client';
 
 jest.mock('../../../src/trpc-client', () => ({
@@ -9,6 +11,7 @@ jest.mock('../../../src/trpc-client', () => ({
     checkout: {
       complete: { mutate: jest.fn() },
       confirmPrice: { mutate: jest.fn() },
+      resume: { mutate: jest.fn() },
       release: { mutate: jest.fn() },
     },
   },
@@ -20,6 +23,7 @@ const { trpc } = require('../../../src/trpc-client') as {
     checkout: {
       complete: { mutate: jest.Mock };
       confirmPrice: { mutate: jest.Mock };
+      resume: { mutate: jest.Mock };
       release: { mutate: jest.Mock };
     };
   };
@@ -36,6 +40,10 @@ const baseSession: CheckoutSession = {
   failureReason: null,
 };
 
+function renderCheckout(ui: ReactElement) {
+  return render(<CheckoutLeaveModeProvider>{ui}</CheckoutLeaveModeProvider>);
+}
+
 /** Shaped like a TRPCClientError: the wire code hangs off `.data.code`. */
 function trpcError(code: string, message = 'nope'): Error & { data: { code: string } } {
   return Object.assign(new Error(message), { data: { code } });
@@ -44,6 +52,7 @@ function trpcError(code: string, message = 'nope'): Error & { data: { code: stri
 beforeEach(() => {
   trpc.checkout.complete.mutate.mockReset();
   trpc.checkout.confirmPrice.mutate.mockReset();
+  trpc.checkout.resume.mutate.mockReset();
   trpc.checkout.release.mutate.mockReset();
   trpc.checkout.release.mutate.mockResolvedValue({
     ...baseSession,
@@ -58,7 +67,9 @@ afterEach(() => {
 
 describe('CheckoutClient', () => {
   it('renders processing (no Buy CTA) when the session is already pending_payment', () => {
-    render(<CheckoutClient initialSession={{ ...baseSession, status: 'pending_payment' }} />);
+    renderCheckout(
+      <CheckoutClient initialSession={{ ...baseSession, status: 'pending_payment' }} />,
+    );
     expect(screen.getAllByText(/payment in progress/i).length).toBeGreaterThan(0);
     expect(screen.queryByRole('button', { name: /continue/i })).not.toBeInTheDocument();
   });
@@ -72,7 +83,7 @@ describe('CheckoutClient', () => {
         }),
     );
 
-    render(<CheckoutClient initialSession={baseSession} />);
+    renderCheckout(<CheckoutClient initialSession={baseSession} />);
     fireEvent.click(screen.getByRole('button', { name: /continue/i }));
 
     expect((await screen.findAllByText(/payment in progress/i)).length).toBeGreaterThan(0);
@@ -83,15 +94,15 @@ describe('CheckoutClient', () => {
   });
 
   it('renders the continue CTA for an active session', () => {
-    render(<CheckoutClient initialSession={baseSession} />);
+    renderCheckout(<CheckoutClient initialSession={baseSession} />);
     expect(screen.getByRole('button', { name: /continue/i })).toBeInTheDocument();
   });
 
   it('shows a price-change banner when the live price differs from the acknowledged price', () => {
-    render(
+    renderCheckout(
       <CheckoutClient
         initialSession={{ ...baseSession, acknowledgedPrice: 4200 }}
-        priceChangedTo={5000}
+        livePriceCents={5000}
       />,
     );
     expect(screen.getByText(/price changed/i)).toBeInTheDocument();
@@ -100,7 +111,7 @@ describe('CheckoutClient', () => {
 
   it('tells a lapsed session apart from a released hold', () => {
     // Same status, different cause — and different next steps for the fan.
-    const lapsed = render(
+    const lapsed = renderCheckout(
       <CheckoutClient
         initialSession={{ ...baseSession, status: 'expired', expiryReason: 'session_lapsed' }}
       />,
@@ -109,7 +120,7 @@ describe('CheckoutClient', () => {
     expect(screen.queryByText(/listing no longer available/i)).not.toBeInTheDocument();
     lapsed.unmount();
 
-    render(
+    renderCheckout(
       <CheckoutClient
         initialSession={{ ...baseSession, status: 'expired', expiryReason: 'hold_released' }}
       />,
@@ -119,18 +130,18 @@ describe('CheckoutClient', () => {
   });
 
   it('hides completion until an unacknowledged price change is confirmed', () => {
-    render(<CheckoutClient initialSession={baseSession} priceChangedTo={5000} />);
+    renderCheckout(<CheckoutClient initialSession={baseSession} livePriceCents={5000} />);
     expect(screen.queryByRole('button', { name: /continue/i })).not.toBeInTheDocument();
   });
 
   it('shows a confirmation for a completed session and offers no complete button', () => {
-    render(<CheckoutClient initialSession={{ ...baseSession, status: 'completed' }} />);
+    renderCheckout(<CheckoutClient initialSession={{ ...baseSession, status: 'completed' }} />);
     expect(screen.getByText(/you're all set/i)).toBeInTheDocument();
     expect(screen.queryByRole('button', { name: /continue/i })).not.toBeInTheDocument();
   });
 
   it('shows the failure reason and a retry button for a failed session', () => {
-    render(
+    renderCheckout(
       <CheckoutClient
         initialSession={{ ...baseSession, status: 'failed', failureReason: 'card_declined' }}
       />,
@@ -141,7 +152,7 @@ describe('CheckoutClient', () => {
 
   it('moves into the price-change state when complete rejects with PRECONDITION_FAILED', async () => {
     trpc.checkout.complete.mutate.mockRejectedValue(trpcError('PRECONDITION_FAILED'));
-    render(<CheckoutClient initialSession={baseSession} />);
+    renderCheckout(<CheckoutClient initialSession={baseSession} />);
 
     fireEvent.click(screen.getByRole('button', { name: /continue/i }));
 
@@ -155,7 +166,7 @@ describe('CheckoutClient', () => {
       ...baseSession,
       acknowledgedPrice: 5000,
     });
-    render(<CheckoutClient initialSession={baseSession} priceChangedTo={5000} />);
+    renderCheckout(<CheckoutClient initialSession={baseSession} livePriceCents={5000} />);
 
     fireEvent.click(screen.getByRole('button', { name: /confirm new price/i }));
 
@@ -169,7 +180,7 @@ describe('CheckoutClient', () => {
 
   it('explains a CONFLICT as another device already completing the order', async () => {
     trpc.checkout.complete.mutate.mockRejectedValue(trpcError('CONFLICT'));
-    render(<CheckoutClient initialSession={baseSession} />);
+    renderCheckout(<CheckoutClient initialSession={baseSession} />);
 
     fireEvent.click(screen.getByRole('button', { name: /continue/i }));
 
@@ -178,7 +189,7 @@ describe('CheckoutClient', () => {
 
   it('reports a lapsed session when complete rejects with TIMEOUT', async () => {
     trpc.checkout.complete.mutate.mockRejectedValue(trpcError('TIMEOUT'));
-    render(<CheckoutClient initialSession={baseSession} />);
+    renderCheckout(<CheckoutClient initialSession={baseSession} />);
 
     fireEvent.click(screen.getByRole('button', { name: /continue/i }));
 
@@ -187,7 +198,7 @@ describe('CheckoutClient', () => {
 
   it('reports a released hold when complete rejects with UNPROCESSABLE_CONTENT', async () => {
     trpc.checkout.complete.mutate.mockRejectedValue(trpcError('UNPROCESSABLE_CONTENT'));
-    render(<CheckoutClient initialSession={baseSession} />);
+    renderCheckout(<CheckoutClient initialSession={baseSession} />);
 
     fireEvent.click(screen.getByRole('button', { name: /continue/i }));
 
@@ -197,7 +208,7 @@ describe('CheckoutClient', () => {
   });
 
   it('exposes Share tickets for an active session without rendering raw URLs', () => {
-    render(<CheckoutClient initialSession={baseSession} />);
+    renderCheckout(<CheckoutClient initialSession={baseSession} />);
 
     expect(screen.getByRole('button', { name: /share tickets/i })).toBeInTheDocument();
     expect(screen.queryByText(/http:\/\/localhost:3001\/checkout\//)).not.toBeInTheDocument();
@@ -205,13 +216,13 @@ describe('CheckoutClient', () => {
   });
 
   it('does not offer Open in app — custom schemes from the browser are too volatile', () => {
-    render(<CheckoutClient initialSession={baseSession} />);
+    renderCheckout(<CheckoutClient initialSession={baseSession} />);
 
     expect(screen.queryByRole('button', { name: /open in app/i })).not.toBeInTheDocument();
   });
 
   it('hides share for a completed session', () => {
-    render(<CheckoutClient initialSession={{ ...baseSession, status: 'completed' }} />);
+    renderCheckout(<CheckoutClient initialSession={{ ...baseSession, status: 'completed' }} />);
 
     expect(screen.queryByRole('button', { name: /share tickets/i })).not.toBeInTheDocument();
   });
@@ -221,10 +232,10 @@ describe('CheckoutClient', () => {
 
     function renderWithHomeLink(session: CheckoutSession = baseSession) {
       return render(
-        <>
+        <CheckoutLeaveModeProvider>
           <a href="/">Gametime home</a>
           <CheckoutClient initialSession={session} />
-        </>,
+        </CheckoutLeaveModeProvider>,
       );
     }
 
@@ -348,17 +359,26 @@ describe('CheckoutClient', () => {
       expiresAt: '2026-01-01T00:10:00.000Z',
     };
 
-    render(<CheckoutClient initialSession={demoSession} />);
+    renderCheckout(<CheckoutClient initialSession={demoSession} />);
     expect(screen.getByRole('button', { name: /continue/i })).toBeInTheDocument();
     expect(screen.getByTestId('demo-price-countdown')).toHaveTextContent(
       `${DEMO_PRICE_CHANGE.afterMs / 1000}s`,
     );
 
+    trpc.checkout.resume.mutate.mockResolvedValue({
+      session: demoSession,
+      livePriceCents: DEMO_PRICE_CHANGE.heldPriceAfterBumpCents,
+    });
+
     await act(async () => {
       await jest.advanceTimersByTimeAsync(DEMO_PRICE_CHANGE.afterMs);
     });
 
-    expect(screen.getByText(/price changed/i)).toBeInTheDocument();
+    await waitFor(() => expect(screen.getByText(/price changed/i)).toBeInTheDocument());
+    expect(trpc.checkout.resume.mutate).toHaveBeenCalledWith({
+      sessionId: 'sess_demo',
+      surface: 'web',
+    });
     expect(screen.getByRole('button', { name: /confirm new price/i })).toBeInTheDocument();
     expect(screen.getByText(/\$109\.00/)).toBeInTheDocument();
     expect(screen.queryByTestId('demo-price-countdown')).not.toBeInTheDocument();
@@ -375,7 +395,7 @@ describe('CheckoutClient', () => {
       createdAt: '2026-01-01T00:00:00.000Z',
     });
 
-    render(
+    renderCheckout(
       <CheckoutClient
         initialSession={{
           ...baseSession,
@@ -386,7 +406,7 @@ describe('CheckoutClient', () => {
           // bounce back into price_changed after confirm.
           createdAt: '2026-01-01T00:00:00.000Z',
         }}
-        priceChangedTo={10900}
+        livePriceCents={10900}
       />,
     );
 
diff --git a/apps/web/app/checkout/[id]/checkout-client.tsx b/apps/web/app/checkout/[id]/checkout-client.tsx
index c0a4b44..03c4718 100644
--- a/apps/web/app/checkout/[id]/checkout-client.tsx
+++ b/apps/web/app/checkout/[id]/checkout-client.tsx
@@ -1,24 +1,29 @@
 'use client';
 
 import type { CheckoutSession } from '@repo/api-contracts';
-import { DEMO_PRICE_CHANGE, msUntilDemoPriceBump } from '@repo/api-contracts';
+import { msUntilDemoPriceBump } from '@repo/api-contracts';
 import type { CheckoutView } from '@repo/ui';
 import {
   buildCheckoutShareUrls,
   CHECKOUT_COPY,
   CheckoutCard,
+  CheckoutTerms,
+  ContactRow,
   DemoPriceCountdown,
+  GuaranteePanel,
+  isDecorativeSessionStatus,
   isShareableSession,
   mapCheckoutPresentation,
-  priceUpdatedNotice,
-  viewFromErrorCode,
-  viewFromSession,
+  sessionFromView,
+  showsCheckoutActions,
+  useCheckoutActions,
+  viewFromResume,
 } from '@repo/ui';
-import { trpcErrorCode } from '@repo/utils';
-import { useEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
 import { trpc } from '#web/trpc-client';
 
+import { useCheckoutLeaveMode } from '../../checkout-leave-mode';
 import { checkoutPageStyles as styles } from './checkout-page-styles';
 import { OrderSummary } from './order-summary';
 
@@ -29,33 +34,16 @@ export type CheckoutClientProps = {
    * a loading flash.
    */
   initialSession: CheckoutSession;
-  /** Live price, in cents, when the server already knows it diverged. */
-  priceChangedTo?: number;
+  /** Live hold price from SSR resume; drives price_changed when it diverges. */
+  livePriceCents?: number | null;
 };
 
-function initialView(session: CheckoutSession, priceChangedTo?: number): CheckoutView {
-  const base = viewFromSession(session);
-  if (base.kind !== 'ready') return base;
-  if (priceChangedTo !== undefined) {
-    return { kind: 'price_changed', session, newPriceCents: priceChangedTo };
-  }
-  return base;
-}
-
 function webOrigin(): string {
   // Prefer an explicit public origin so share links stay stable in local
   // multi-port setups (API :4000, web :3001) and in tests under jsdom.
   return process.env.NEXT_PUBLIC_WEB_ORIGIN ?? 'http://localhost:3001';
 }
 
-function showsTerms(view: CheckoutView): boolean {
-  return view.kind === 'ready' || view.kind === 'price_changed' || view.kind === 'failed';
-}
-
-function sessionFromView(view: CheckoutView): CheckoutSession | null {
-  return 'session' in view && view.session ? view.session : null;
-}
-
 function isLeavingCheckout(href: string, currentPathname: string): boolean {
   try {
     const url = new URL(href, window.location.origin);
@@ -66,15 +54,36 @@ function isLeavingCheckout(href: string, currentPathname: string): boolean {
   }
 }
 
-function isDecorativeStatus(status: CheckoutSession['status']): boolean {
-  return status === 'created' || status === 'active' || status === 'failed';
-}
+const SURFACE = 'web' as const;
 
-export function CheckoutClient({ initialSession, priceChangedTo }: CheckoutClientProps) {
-  const [view, setView] = useState<CheckoutView>(() => initialView(initialSession, priceChangedTo));
-  const [busy, setBusy] = useState(false);
+export function CheckoutClient({ initialSession, livePriceCents = null }: CheckoutClientProps) {
+  const [view, setView] = useState<CheckoutView>(() =>
+    viewFromResume(initialSession, livePriceCents),
+  );
   const [shareFeedback, setShareFeedback] = useState<string | null>(null);
   const allowUnloadRef = useRef(false);
+  const { setLeaveMode } = useCheckoutLeaveMode();
+
+  // Header leave control: "Cancel" while shopping, "Done" only after purchase.
+  useEffect(() => {
+    setLeaveMode(view.kind === 'completed' ? 'done' : 'cancel');
+    return () => setLeaveMode('cancel');
+  }, [setLeaveMode, view.kind]);
+
+  const mutations = useMemo(
+    () => ({
+      complete: trpc.checkout.complete.mutate,
+      confirmPrice: trpc.checkout.confirmPrice.mutate,
+      resume: trpc.checkout.resume.mutate,
+    }),
+    [],
+  );
+
+  const { busy, completeOrder, confirmNewPrice, refreshFromResume } = useCheckoutActions({
+    surface: SURFACE,
+    mutations,
+    setView,
+  });
 
   const shareSession =
     'session' in view && view.session && isShareableSession(view.session) ? view.session : null;
@@ -94,34 +103,13 @@ export function CheckoutClient({ initialSession, priceChangedTo }: CheckoutClien
     previousUnitPriceCents,
   });
   const showDecorative =
-    isDecorativeStatus(summarySession.status) && presentation.showDecorativeChrome;
+    isDecorativeSessionStatus(summarySession.status) && presentation.showDecorativeChrome;
   const showDemoCountdown = view.kind === 'ready' && msUntilDemoPriceBump(view.session) !== null;
 
-  // Demo listing: surface the price-change UI when the hold ages past the demo
-  // window so a reviewer can watch reconfirmation without calling setPrice by hand.
-  useEffect(() => {
+  const onDemoPriceExpire = useCallback(() => {
     if (view.kind !== 'ready') return;
-    const delayMs = msUntilDemoPriceBump(view.session);
-    if (delayMs === null) return;
-
-    const sessionId = view.session.id;
-    const timer = window.setTimeout(() => {
-      setView((current) => {
-        if (current.kind !== 'ready' || current.session.id !== sessionId) return current;
-        // Fan already confirmed the demo bump — don't bounce them back.
-        if (current.session.acknowledgedPrice === DEMO_PRICE_CHANGE.heldPriceAfterBumpCents) {
-          return current;
-        }
-        return {
-          kind: 'price_changed',
-          session: current.session,
-          newPriceCents: DEMO_PRICE_CHANGE.heldPriceAfterBumpCents,
-        };
-      });
-    }, delayMs);
-
-    return () => window.clearTimeout(timer);
-  }, [view]);
+    void refreshFromResume(view.session.id);
+  }, [refreshFromResume, view]);
 
   useEffect(() => {
     if (!holdSessionId) return;
@@ -131,7 +119,7 @@ export function CheckoutClient({ initialSession, priceChangedTo }: CheckoutClien
 
     async function releaseHold(): Promise<void> {
       try {
-        await trpc.checkout.release.mutate({ sessionId, surface: 'web' });
+        await trpc.checkout.release.mutate({ sessionId, surface: SURFACE });
       } catch {
         // Fan is leaving either way — don't block navigation on release errors.
       }
@@ -199,44 +187,6 @@ export function CheckoutClient({ initialSession, priceChangedTo }: CheckoutClien
     };
   }, [holdSessionId]);
 
-  async function completeOrder(session: CheckoutSession) {
-    if (busy) return;
-    setBusy(true);
-    // Claim UI immediately — never leave Buy enabled while the server holds
-    // pending_payment (even for the brief window before the response lands).
-    setView({ kind: 'processing', session: { ...session, status: 'pending_payment' } });
-    try {
-      const next = await trpc.checkout.complete.mutate({ sessionId: session.id, surface: 'web' });
-      setView(viewFromSession(next));
-    } catch (error) {
-      setView(viewFromErrorCode(trpcErrorCode(error), session));
-    } finally {
-      setBusy(false);
-    }
-  }
-
-  async function confirmNewPrice(session: CheckoutSession) {
-    if (busy) return;
-    setBusy(true);
-    try {
-      const next = await trpc.checkout.confirmPrice.mutate({
-        sessionId: session.id,
-        surface: 'web',
-      });
-      setView(
-        viewFromSession(
-          next,
-          priceUpdatedNotice(next.acknowledgedPrice),
-          session.acknowledgedPrice,
-        ),
-      );
-    } catch (error) {
-      setView(viewFromErrorCode(trpcErrorCode(error), session));
-    } finally {
-      setBusy(false);
-    }
-  }
-
   async function onShare(payload: { webUrl: string; mobileUrl: string }) {
     try {
       await navigator.clipboard.writeText(payload.webUrl);
@@ -249,31 +199,21 @@ export function CheckoutClient({ initialSession, priceChangedTo }: CheckoutClien
   return (
     <div style={styles.grid} className="checkout-grid">
       <section style={styles.card}>
-        <div style={styles.contactRow} data-testid="checkout-contact-row">
-          <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
-            <p style={styles.contactLabel}>{CHECKOUT_COPY.contactLabel}</p>
-            {showDemoCountdown ? (
-              <DemoPriceCountdown
-                listingId={view.session.listingId}
-                createdAt={view.session.createdAt}
-              />
-            ) : null}
+        <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+          <div style={{ flex: 1 }}>
+            <ContactRow />
           </div>
-          <p style={styles.contactEmail}>{CHECKOUT_COPY.contactEmail}</p>
+          {showDemoCountdown ? (
+            <DemoPriceCountdown
+              listingId={view.session.listingId}
+              createdAt={view.session.createdAt}
+              onExpire={onDemoPriceExpire}
+            />
+          ) : null}
         </div>
 
         <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
-          {showsTerms(view) ? (
-            <p
-              data-testid="checkout-terms"
-              style={{ margin: 0, color: 'var(--color-muted)', fontSize: 14 }}
-            >
-              {CHECKOUT_COPY.termsPrefix}
-              <span style={{ textDecoration: 'underline' }}>{CHECKOUT_COPY.termsOfUse}</span>
-              {CHECKOUT_COPY.termsAnd}
-              <span style={{ textDecoration: 'underline' }}>{CHECKOUT_COPY.privacyPolicy}</span>
-            </p>
-          ) : null}
+          {showsCheckoutActions(view) ? <CheckoutTerms /> : null}
 
           <CheckoutCard
             view={view}
@@ -291,21 +231,7 @@ export function CheckoutClient({ initialSession, priceChangedTo }: CheckoutClien
           ) : null}
         </div>
 
-        {showDecorative ? (
-          <div style={styles.guarantee} data-testid="guarantee-panel">
-            <div style={styles.guaranteeCopy}>
-              <p style={styles.guaranteeTitle}>{CHECKOUT_COPY.guaranteeTitle}</p>
-              {CHECKOUT_COPY.guaranteeItems.map((item) => (
-                <p key={item} style={styles.guaranteeItem}>
-                  ✓ {item}
-                </p>
-              ))}
-            </div>
-            <div style={styles.guaranteeShield} aria-hidden>
-              ✓
-            </div>
-          </div>
-        ) : null}
+        {showDecorative ? <GuaranteePanel /> : null}
       </section>
 
       <OrderSummary session={summarySession} presentation={presentation} />
diff --git a/apps/web/app/checkout/[id]/page.ssr.test.tsx b/apps/web/app/checkout/[id]/page.ssr.test.tsx
index 5335a04..ee82772 100644
--- a/apps/web/app/checkout/[id]/page.ssr.test.tsx
+++ b/apps/web/app/checkout/[id]/page.ssr.test.tsx
@@ -13,7 +13,14 @@ import { renderToStaticMarkup } from 'react-dom/server';
 import CheckoutPage from './page';
 
 jest.mock('../../../src/trpc-client', () => ({
-  trpc: { checkout: { complete: { mutate: jest.fn() }, confirmPrice: { mutate: jest.fn() } } },
+  trpc: {
+    checkout: {
+      complete: { mutate: jest.fn() },
+      confirmPrice: { mutate: jest.fn() },
+      resume: { mutate: jest.fn() },
+      release: { mutate: jest.fn() },
+    },
+  },
 }));
 
 const session: CheckoutSession = {
@@ -48,7 +55,9 @@ afterEach(() => {
 
 describe('checkout page server render', () => {
   it('puts the listing, status and price in the HTML before hydration', async () => {
-    const fetchMock = stubFetch(200, { result: { data: session } });
+    const fetchMock = stubFetch(200, {
+      result: { data: { session, livePriceCents: session.acknowledgedPrice } },
+    });
 
     const html = await renderPage('sess_ssr');
 
@@ -66,7 +75,12 @@ describe('checkout page server render', () => {
 
   it('renders fixture-driven Super Deal when the listing has one', async () => {
     stubFetch(200, {
-      result: { data: { ...session, listingId: 'listing_1', acknowledgedPrice: 15400 } },
+      result: {
+        data: {
+          session: { ...session, listingId: 'listing_1', acknowledgedPrice: 15400 },
+          livePriceCents: 15400,
+        },
+      },
     });
 
     const html = await renderPage('sess_ssr');
@@ -83,7 +97,12 @@ describe('checkout page server render', () => {
 
   it('renders an expired session in its terminal state without client JS', async () => {
     stubFetch(200, {
-      result: { data: { ...session, status: 'expired', expiryReason: 'session_lapsed' } },
+      result: {
+        data: {
+          session: { ...session, status: 'expired', expiryReason: 'session_lapsed' },
+          livePriceCents: null,
+        },
+      },
     });
 
     const html = await renderPage('sess_ssr');
@@ -94,7 +113,12 @@ describe('checkout page server render', () => {
 
   it('renders a released inventory hold distinctly from a lapsed session', async () => {
     stubFetch(200, {
-      result: { data: { ...session, status: 'expired', expiryReason: 'hold_released' } },
+      result: {
+        data: {
+          session: { ...session, status: 'expired', expiryReason: 'hold_released' },
+          livePriceCents: null,
+        },
+      },
     });
 
     const html = await renderPage('sess_ssr');
diff --git a/apps/web/app/checkout/[id]/page.tsx b/apps/web/app/checkout/[id]/page.tsx
index 11dd731..eb8818c 100644
--- a/apps/web/app/checkout/[id]/page.tsx
+++ b/apps/web/app/checkout/[id]/page.tsx
@@ -25,7 +25,7 @@ export default async function CheckoutPage({ params }: { params: { id: string }
 
   return (
     <main style={styles.main}>
-      <CheckoutClient initialSession={result.session} />
+      <CheckoutClient initialSession={result.session} livePriceCents={result.livePriceCents} />
     </main>
   );
 }
diff --git a/apps/web/app/layout.tsx b/apps/web/app/layout.tsx
index c9bdd42..2c7e5ce 100644
--- a/apps/web/app/layout.tsx
+++ b/apps/web/app/layout.tsx
@@ -4,6 +4,7 @@ import { cssVariables } from '@repo/tokens';
 import type { Metadata } from 'next';
 import type { ReactNode } from 'react';
 
+import { CheckoutLeaveModeProvider } from './checkout-leave-mode';
 import { SiteHeader } from './site-header';
 
 export const metadata: Metadata = {
@@ -25,8 +26,10 @@ export default function RootLayout({ children }: { children: ReactNode }) {
           fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
         }}
       >
-        <SiteHeader />
-        {children}
+        <CheckoutLeaveModeProvider>
+          <SiteHeader />
+          {children}
+        </CheckoutLeaveModeProvider>
       </body>
     </html>
   );
diff --git a/apps/web/app/site-header.test.tsx b/apps/web/app/site-header.test.tsx
index 7a209c1..99cbd1d 100644
--- a/apps/web/app/site-header.test.tsx
+++ b/apps/web/app/site-header.test.tsx
@@ -1,6 +1,10 @@
 import { CHECKOUT_COPY } from '@repo/ui';
 import { render, screen } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { useLayoutEffect } from 'react';
 
+import type { CheckoutLeaveMode } from './checkout-leave-mode';
+import { CheckoutLeaveModeProvider, useCheckoutLeaveMode } from './checkout-leave-mode';
 import { SiteHeader } from './site-header';
 
 const usePathname = jest.fn();
@@ -9,6 +13,18 @@ jest.mock('next/navigation', () => ({
   usePathname: () => usePathname(),
 }));
 
+function renderHeader(ui: ReactNode = <SiteHeader />) {
+  return render(<CheckoutLeaveModeProvider>{ui}</CheckoutLeaveModeProvider>);
+}
+
+function SetLeaveMode({ mode }: { mode: CheckoutLeaveMode }) {
+  const { setLeaveMode } = useCheckoutLeaveMode();
+  useLayoutEffect(() => {
+    setLeaveMode(mode);
+  }, [mode, setLeaveMode]);
+  return null;
+}
+
 describe('SiteHeader', () => {
   beforeEach(() => {
     usePathname.mockReset();
@@ -18,29 +34,44 @@ describe('SiteHeader', () => {
     {
       name: 'checkout session route',
       pathname: '/checkout/sess_abc',
-      expectCancel: true,
+      expectLeaveControl: true,
     },
     {
       name: 'selection landing',
       pathname: '/',
-      expectCancel: false,
+      expectLeaveControl: false,
     },
-  ])('cancel control on $name', ({ pathname, expectCancel }) => {
+  ])('leave control on $name', ({ pathname, expectLeaveControl }) => {
     usePathname.mockReturnValue(pathname);
 
-    render(<SiteHeader />);
+    renderHeader();
 
     expect(screen.getByLabelText('Gametime home')).toBeInTheDocument();
     expect(screen.getByText(CHECKOUT_COPY.pageTitle)).toBeInTheDocument();
 
-    const cancel = screen.queryByTestId('checkout-cancel');
-    if (expectCancel) {
-      expect(cancel).toBeInTheDocument();
-      expect(cancel).toHaveAttribute('href', '/');
-      expect(cancel).toHaveAccessibleName(CHECKOUT_COPY.cancelAriaLabel);
-      expect(cancel).toHaveTextContent(`‹${CHECKOUT_COPY.cancelLabel}`);
+    const leaveControl = screen.queryByTestId('checkout-cancel');
+    if (expectLeaveControl) {
+      expect(leaveControl).toBeInTheDocument();
+      expect(leaveControl).toHaveAttribute('href', '/');
+      expect(leaveControl).toHaveAccessibleName(CHECKOUT_COPY.cancelAriaLabel);
+      expect(leaveControl).toHaveTextContent(`‹${CHECKOUT_COPY.cancelLabel}`);
     } else {
-      expect(cancel).not.toBeInTheDocument();
+      expect(leaveControl).not.toBeInTheDocument();
     }
   });
+
+  it('labels the leave control Done after a successful purchase', () => {
+    usePathname.mockReturnValue('/checkout/sess_abc');
+
+    renderHeader(
+      <>
+        <SetLeaveMode mode="done" />
+        <SiteHeader />
+      </>,
+    );
+
+    const leaveControl = screen.getByTestId('checkout-cancel');
+    expect(leaveControl).toHaveAccessibleName(CHECKOUT_COPY.doneAriaLabel);
+    expect(leaveControl).toHaveTextContent(`‹${CHECKOUT_COPY.doneLabel}`);
+  });
 });
diff --git a/apps/web/app/site-header.tsx b/apps/web/app/site-header.tsx
index dd1f6e0..4357fb8 100644
--- a/apps/web/app/site-header.tsx
+++ b/apps/web/app/site-header.tsx
@@ -4,13 +4,19 @@ import { CHECKOUT_COPY } from '@repo/ui';
 import Link from 'next/link';
 import { usePathname } from 'next/navigation';
 
+import { useCheckoutLeaveMode } from './checkout-leave-mode';
+
 function isCheckoutPath(pathname: string): boolean {
   return pathname.startsWith('/checkout/');
 }
 
 export function SiteHeader() {
   const pathname = usePathname();
-  const showCancel = isCheckoutPath(pathname);
+  const { leaveMode } = useCheckoutLeaveMode();
+  const showLeaveControl = isCheckoutPath(pathname);
+  const isDone = leaveMode === 'done';
+  const leaveLabel = isDone ? CHECKOUT_COPY.doneLabel : CHECKOUT_COPY.cancelLabel;
+  const leaveAriaLabel = isDone ? CHECKOUT_COPY.doneAriaLabel : CHECKOUT_COPY.cancelAriaLabel;
 
   return (
     <header className="site-header">
@@ -46,14 +52,14 @@ export function SiteHeader() {
         </span>
       </Link>
 
-      {showCancel ? (
+      {showLeaveControl ? (
         <div className="site-header-cancel-layer">
           <div className="site-header-cancel-shell">
             <div className="site-header-cancel-grid">
               <div className="site-header-cancel-slot">
                 <Link
                   href="/"
-                  aria-label={CHECKOUT_COPY.cancelAriaLabel}
+                  aria-label={leaveAriaLabel}
                   data-testid="checkout-cancel"
                   className="site-header-cancel"
                 >
@@ -61,7 +67,7 @@ export function SiteHeader() {
                     ‹
                   </span>
                   <span className="site-header-cancel-text" aria-hidden>
-                    {CHECKOUT_COPY.cancelLabel}
+                    {leaveLabel}
                   </span>
                 </Link>
               </div>
diff --git a/apps/web/src/format.ts b/apps/web/src/format.ts
index d8b5130..051fca4 100644
--- a/apps/web/src/format.ts
+++ b/apps/web/src/format.ts
@@ -1,7 +1,6 @@
 import type { CheckoutSessionStatus } from '@repo/api-contracts';
 
 const STATUS_LABELS: Record<CheckoutSessionStatus, string> = {
-  created: 'Created',
   active: 'Active',
   pending_payment: 'Payment in progress',
   completed: 'Completed',
diff --git a/apps/web/src/resume-session.ts b/apps/web/src/resume-session.ts
index 7c1ec55..9cbb498 100644
--- a/apps/web/src/resume-session.ts
+++ b/apps/web/src/resume-session.ts
@@ -1,4 +1,4 @@
-import type { CheckoutSession } from '@repo/api-contracts';
+import type { ResumeSessionResult } from '@repo/api-contracts';
 
 const API_URL = process.env.NEXT_PUBLIC_API_URL ?? 'http://localhost:4000';
 
@@ -10,10 +10,10 @@ export type ResumeFailure = {
   detail: string;
 };
 
-export type ResumeResult = { ok: true; session: CheckoutSession } | ResumeFailure;
+export type ResumeResult = ({ ok: true } & ResumeSessionResult) | ResumeFailure;
 
 type TrpcResponseBody = {
-  result?: { data?: CheckoutSession };
+  result?: { data?: ResumeSessionResult };
   error?: { message?: string; data?: { code?: string } };
 };
 
@@ -66,8 +66,10 @@ export async function resumeSession(sessionId: string): Promise<ResumeResult> {
     return failure('UNREACHABLE');
   }
 
-  const session = body.result?.data;
-  if (response.ok && session) return { ok: true, session };
+  const data = body.result?.data;
+  if (response.ok && data?.session) {
+    return { ok: true, session: data.session, livePriceCents: data.livePriceCents ?? null };
+  }
 
   return failure(body.error?.data?.code ?? 'INTERNAL_SERVER_ERROR');
 }
diff --git a/docs/decisions.md b/docs/decisions.md
index 3b2b8f4..c98bb19 100644
--- a/docs/decisions.md
+++ b/docs/decisions.md
@@ -88,7 +88,9 @@ sessions, and time-to-complete after a price reconfirmation vs. without one.
 ## 5. Polling on resume instead of push updates
 
 **What we did:** Both `apps/web` and `apps/mobile-web` fetch session state once, on load /
-resume — no live updates while a fan sits on the checkout screen.
+resume — no live updates while a fan sits on the checkout screen, except the demo listing:
+when `DemoPriceCountdown` hits zero it re-calls `checkout.resume` so the live hold price
+comes from the server (single price authority) rather than a client-side hardcoded bump.
 
 **Why:** Simplest thing that satisfies "how do web and mobile know whether a session is
 still valid" — check at the moment that matters (resume, complete) rather than continuously.
@@ -259,9 +261,12 @@ fan-facing tap.
 
 ## 14. Share tickets uses session id as the capability (no auth on resume links)
 
-**What we did:** Checkout surfaces a **Share tickets** control that copies/shares a web URL
-(`{origin}/checkout/{sessionId}`) plus a mobile deep link (`mobileweb://checkout/{sessionId}`).
-Possession of the id is enough to resume — unchanged from the original continuity model.
+**What we did:** Checkout surfaces a **Share tickets** control that copies/shares the web
+URL only (`{origin}/checkout/{sessionId}`). A `mobileweb://checkout/{sessionId}` URL is
+still built for local deep-link demos (`simctl` / Expo), but it is not what Copy/Share
+puts on the pasteboard — resume from share must not depend on the app already being
+installed. Possession of the id is enough to resume — unchanged from the original
+continuity model.
 
 **Why:** Matches the locked design for this pass (cross-surface takeover without an
 "open the other app on this device" strip) and keeps share UX shared via optional
@@ -273,3 +278,21 @@ already use `nanoid`, but there's no short-lived signed token or recipient bindi
 
 **What we'd do instead:** Signed, expiring resume tokens (or magic-link auth) scoped to the
 session, with optional surface binding and revoke-on-complete.
+
+## 15. Session TTL lapse also releases the inventory hold (lazy + background sweep)
+
+**What we did:** `expireIfNeeded` and `expireLapsedSessions` share a lapse helper that
+marks the session `expired` with `expiryReason: 'session_lapsed'` (CAS first), then
+`releaseHold`s. Explicit abandon (`releaseSession`) still uses `hold_released`. An
+in-process `SessionExpirySweeper` polls every 30s from the API process so abandoned tabs
+do not wait for the next fan touch.
+
+**Why:** Leaving the hold up after the session clock died stranded inventory —
+soft-conflicting with "not holding stale inventory forever." Releasing on lapse keeps the
+clocks conceptually separate (session owns resumability; inventory owns reservation) while
+ensuring checkout won't sit on sold-out seats after the fan's window closed.
+
+**Honesty limit:** the sweeper is single-process demo glue (no leader election, no durable
+job queue). Multi-replica production would need a real cron/worker and an indexed
+`expiresAt` query instead of `SessionStore.list()`. Mid-charge (`pending_payment`) is
+skipped so a sweep cannot drop inventory under an in-flight payment.
diff --git a/docs/session_2026-07-29_1430_code-quality-review.md b/docs/session_2026-07-29_1430_code-quality-review.md
new file mode 100644
index 0000000..9d99556
--- /dev/null
+++ b/docs/session_2026-07-29_1430_code-quality-review.md
@@ -0,0 +1,29 @@
+# Session: Full-app code quality review
+
+**Date/time:** 2026-07-29 ~14:30 PT  
+**Slug:** `code-quality-review`
+
+## Summary
+
+Ran a thermo-nuclear code quality review of the entire Checkout Continuity app (not a PR diff). Verdict: **do not rubber-stamp on structure**. Domain/contracts/view-model layers are strong; the main debt is duplicated web↔mobile checkout orchestration and a client-side demo price-change path that duplicates inventory authority. Produced an interactive findings canvas beside chat.
+
+## Key findings (priority)
+
+1. **Blocker — dual orchestration:** `apps/web/.../checkout-client.tsx` and `apps/mobile-web/app/checkout/[id].tsx` both reimplement `sessionFromView`, demo price-bump timer, complete/confirmPrice busy+optimistic processing flow. Code judo: one shared mutation/orchestration module; platform chrome stays local.
+2. **Blocker — dual price authority:** Server `FakeInventoryProvider.heldPrice` is authoritative; both clients also hardcode `DEMO_PRICE_CHANGE` timers. Web has `priceChangedTo` but `page.tsx` never passes it after SSR resume. Code judo: resume returns live hold price; `viewFromSession` maps `price_changed`; delete client timers as source of truth.
+3. **Major — chrome fork:** Shared `@repo/ui` chrome (`GuaranteePanel`, `ContactRow`, `CheckoutTerms`) exists, but web reinvents guarantee/terms/contact with DOM + `OrderSummary`. `decisions.md` claims shared UI closed the duplication risk; presentation stack is still forked.
+4. **Major — policy re-encoding:** `isShareableSession`, web `isDecorativeStatus`, mobile `showStickyActions`, presentation `TERMINAL_KINDS`, plus dead `created` status in the schema (create always sets `active`).
+5. **Major — catalog split-brain:** `DEMO_LISTINGS` in API context vs `LISTING_FIXTURES` in UI — ids aligned by convention only.
+6. **Minor:** Unused `TicketProtectionCard`; unused-by-web `GuaranteePanel`; `as CheckoutSession` casts after nullable CAS.
+
+## Strengths called out
+
+- `CheckoutService` owns the machine; CAS + explicit `pending_payment` reject.
+- `CheckoutView` + mappers keep `CheckoutCard` free of domain status switches.
+- No files near 1k LOC; complexity is behavioral not sprawl.
+- POC shortcuts documented in `docs/decisions.md`.
+
+## Artifacts
+
+- Canvas: `canvases/code-quality-review.canvas.tsx` (workspace canvases dir)
+- No code changes in the app repo from this review.
diff --git a/docs/session_2026-07-29_1445_code-quality-fixes.md b/docs/session_2026-07-29_1445_code-quality-fixes.md
new file mode 100644
index 0000000..656af5d
--- /dev/null
+++ b/docs/session_2026-07-29_1445_code-quality-fixes.md
@@ -0,0 +1,40 @@
+# Session: Code quality fixes (full-app)
+
+**Date/time:** 2026-07-29 ~14:45 PT  
+**Slug:** `code-quality-fixes`
+
+## Summary
+
+Implemented all six findings from the thermo-nuclear code quality review. No commit/push yet — waiting on manual flow testing.
+
+## Decisions (best judgment)
+
+| Finding            | Choice                                                                                                                                                    |
+| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| F1 orchestration   | Shared `useCheckoutActions` + `checkout.policy.util` in `@repo/ui`; platform leave-guards / sticky chrome stay in apps                                    |
+| F2 price authority | `resume` returns `{ session, livePriceCents }`; `viewFromResume` maps divergence; countdown `onExpire` re-resumes (no client `DEMO_PRICE_CHANGE` setView) |
+| F3 chrome          | Wire `GuaranteePanel` / `ContactRow` / `CheckoutTerms` on web via RN-web; keep DOM `OrderSummary` for SSR first paint                                     |
+| F4 status          | Drop unused `created` status; centralize shareable / decorative / actions predicates                                                                      |
+| F5 catalog         | `DEMO_CATALOG` + `DEMO_EVENT` in `@repo/api-contracts`; API seeds + UI fixtures both derive from it                                                       |
+| F6 cleanup         | Delete unused `TicketProtectionCard`; `mustCasUpdate` replaces nullable CAS casts; router `withDomainErrors` helper                                       |
+
+## Key files
+
+- `packages/api-contracts/src/demo-catalog.ts`, `schemas/checkout.ts` (`resumeSessionResultSchema`)
+- `apps/api/src/domain/checkout-service.ts`, `routers/checkout.ts`, `context.ts`
+- `packages/ui/.../useCheckoutActions.ts`, `checkout.policy.util.ts`, `mapCheckoutView.util.ts` (`viewFromResume`)
+- `apps/web/.../checkout-client.tsx`, `resume-session.ts`, `page.tsx`
+- `apps/mobile-web/app/checkout/[id].tsx`
+
+## Verification
+
+All package/app Jest suites + typechecks passed (`api-contracts`, `ui`, `api`, `web`, `mobile-web`).
+
+## Manual test checklist (for you)
+
+1. Selection → create checkout on web; SSR shows price/status without flash
+2. Complete purchase on web
+3. Create on web → resume on mobile (share / deep link)
+4. Demo listing (`listing_3`): wait ~10s → price-change UI after resume refresh → confirm → buy
+5. Leave/back on web and mobile releases hold; listing selectable again
+6. Concurrent complete race still shows “Finishing on another device”
diff --git a/docs/session_2026-07-29_1515_post-purchase-done-label.md b/docs/session_2026-07-29_1515_post-purchase-done-label.md
new file mode 100644
index 0000000..199f57b
--- /dev/null
+++ b/docs/session_2026-07-29_1515_post-purchase-done-label.md
@@ -0,0 +1,25 @@
+# Session: Post-purchase header leave label
+
+**Date:** 2026-07-29 ~1515 PT
+
+## Summary
+
+After a successful purchase (“Order complete”), the web checkout header leave control
+said “Cancel”. It now says **Done** — and only when the session is actually completed,
+not for expired / abandoned exits.
+
+## Changes
+
+- Added `doneLabel` / `doneAriaLabel` to `CHECKOUT_COPY`.
+- Introduced `CheckoutLeaveModeProvider` so `CheckoutClient` can tell `SiteHeader` when
+  the leave affordance should read as Done vs Cancel (siblings under the root layout).
+- `CheckoutClient` sets leave mode to `done` when `view.kind === 'completed'`, otherwise
+  `cancel`, and resets on unmount.
+- Tests cover Cancel on active checkout and Done after purchase; SSR page tests still pass
+  with a default no-op context outside the provider.
+
+## Rationale
+
+“Cancel” implies abandoning an in-progress purchase. Once tickets are bought, the same
+control is just navigation home — “Done” matches that intent. Scoped strictly to
+`completed` per product ask.
diff --git a/docs/session_2026-07-29_1520_ttl-lapse-releases-hold.md b/docs/session_2026-07-29_1520_ttl-lapse-releases-hold.md
new file mode 100644
index 0000000..f825a92
--- /dev/null
+++ b/docs/session_2026-07-29_1520_ttl-lapse-releases-hold.md
@@ -0,0 +1,28 @@
+# Session: TTL lapse releases inventory hold
+
+**Date:** 2026-07-29 ~1520 PT
+
+## Summary
+
+Fixed a product gap: when a checkout session hit `session_lapsed` (TTL), the session was
+expired but the inventory hold was left in place. Explicit abandon via `releaseSession`
+did release. That soft-conflicted with “not holding stale inventory forever.”
+
+## Fix
+
+`expireIfNeeded` now calls `inventory.releaseHold` before marking the session expired with
+`expiryReason: 'session_lapsed'`. Reasons stay distinct for fan copy:
+
+- `session_lapsed` — session clock died (hold freed as cleanup on that touch)
+- `hold_released` — hold disappeared while the session clock was still good / explicit abandon
+
+## Honesty note
+
+Still no background sweeper. A hold frees on the next resume/confirm/complete after TTL,
+explicit `checkout.release`, or external inventory reclaim. Documented in README, ADR #15,
+and `CONTEXT.md`.
+
+## Tests
+
+Extended “expires a session once its expiresAt has passed” to assert the listing is free
+and creatable again after lapse.
diff --git a/docs/session_2026-07-29_1530_session-expiry-sweeper.md b/docs/session_2026-07-29_1530_session-expiry-sweeper.md
new file mode 100644
index 0000000..4914751
--- /dev/null
+++ b/docs/session_2026-07-29_1530_session-expiry-sweeper.md
@@ -0,0 +1,22 @@
+# Session: Background session-expiry sweeper
+
+**Date:** 2026-07-29 ~1530 PT
+
+## Summary
+
+Added an in-process background sweeper so session TTL lapse frees inventory without
+waiting for the next fan touch.
+
+## Design (approved)
+
+- Domain: `CheckoutService.expireLapsedSessions()` — shared lapse helper with request-time
+  `expireIfNeeded` (CAS to `session_lapsed`, then `releaseHold`). Skips `pending_payment`.
+- Store: `SessionStore.list()` for full scan (prototype).
+- Glue: `SessionExpirySweeper` (~30s), started from `apps/api/src/index.ts`, stopped on
+  SIGINT/SIGTERM.
+- Docs: ADR #15, README, CONTEXT, design spec under `docs/superpowers/specs/`.
+
+## Honesty
+
+Single-process demo glue — not multi-replica safe. Production needs a real job runner and
+an indexed `expiresAt` query.
diff --git a/docs/superpowers/specs/2026-07-29-session-expiry-sweeper-design.md b/docs/superpowers/specs/2026-07-29-session-expiry-sweeper-design.md
new file mode 100644
index 0000000..b89bd55
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-29-session-expiry-sweeper-design.md
@@ -0,0 +1,38 @@
+# Session expiry sweeper
+
+**Date:** 2026-07-29  
+**Status:** Approved
+
+## Goal
+
+Close the abandoned-tab inventory gap: sessions past `expiresAt` free their holds
+without waiting for the next resume/confirm/complete touch.
+
+## Design
+
+### Domain
+
+- `CheckoutService.expireLapsedSessions(): Promise<number>` scans the store for
+  non-terminal sessions past `expiresAt`, skips `pending_payment` (mid-charge),
+  and for each runs the same lapse path as request-time TTL: `releaseHold` +
+  expire as `session_lapsed`.
+- Shared private helper used by both `expireIfNeeded` and the sweep so lazy and
+  background paths cannot drift.
+- Returns the count of sessions newly expired this pass.
+
+### Store
+
+- `SessionStore.list(): CheckoutSession[]` — full scan for the in-memory prototype.
+  Production would query `expiresAt < now AND status IN ('active','failed')`.
+
+### Process glue
+
+- `SessionExpirySweeper` wraps the domain method with `start` / `stop` / `tick`,
+  interval default ~30s, skips overlapping ticks, reports errors via callback.
+- Started from `apps/api/src/index.ts` after listen; stopped on process signals.
+
+### Non-goals
+
+- Multi-replica leader election / distributed locks
+- Inventory-owned hold TTL independent of session clock
+- Persisted job queue
diff --git a/packages/api-contracts/src/demo-catalog.ts b/packages/api-contracts/src/demo-catalog.ts
new file mode 100644
index 0000000..966accb
--- /dev/null
+++ b/packages/api-contracts/src/demo-catalog.ts
@@ -0,0 +1,71 @@
+/**
+ * Single demo catalog shared by API inventory seeding and UI presentation
+ * fixtures. Prices are commerce truth; section/row/map fields are presentation.
+ */
+export const DEMO_EVENT = {
+  artist: 'Ed Sheeran',
+  venue: 'Lumen Field',
+  datetimeLabel: 'Sat 8/1 at 5:30 PM',
+  city: 'Seattle',
+} as const;
+
+export type DemoListing = {
+  listingId: string;
+  priceCents: number;
+  section: string;
+  row: string;
+  seatCount: number;
+  isSuperDeal: boolean;
+  bubble: { leftPct: number; topPct: number };
+  urgencyTicketsLeft?: number;
+};
+
+export const DEMO_CATALOG: readonly DemoListing[] = [
+  {
+    listingId: 'listing_1',
+    priceCents: 15400,
+    section: '309',
+    row: 'JJ',
+    seatCount: 2,
+    isSuperDeal: true,
+    bubble: { leftPct: 62, topPct: 28 },
+    urgencyTicketsLeft: 4,
+  },
+  {
+    listingId: 'listing_2',
+    priceCents: 12500,
+    section: '204',
+    row: '12',
+    seatCount: 2,
+    isSuperDeal: true,
+    bubble: { leftPct: 38, topPct: 42 },
+  },
+  {
+    listingId: 'listing_3',
+    priceCents: 8900,
+    // Visible after the row so reviewers can spot the timed demo ticket.
+    section: '118',
+    row: '8 · 10s price demo',
+    seatCount: 3,
+    isSuperDeal: false,
+    bubble: { leftPct: 55, topPct: 58 },
+  },
+  {
+    listingId: 'listing_4',
+    priceCents: 21000,
+    section: '332',
+    row: 'A',
+    seatCount: 2,
+    isSuperDeal: false,
+    bubble: { leftPct: 72, topPct: 48 },
+  },
+  {
+    listingId: 'listing_5',
+    priceCents: 167600,
+    section: 'Floor',
+    row: '1',
+    seatCount: 2,
+    isSuperDeal: false,
+    bubble: { leftPct: 28, topPct: 52 },
+  },
+] as const;
diff --git a/packages/api-contracts/src/index.ts b/packages/api-contracts/src/index.ts
index 17b5a6f..2f369f4 100644
--- a/packages/api-contracts/src/index.ts
+++ b/packages/api-contracts/src/index.ts
@@ -1,3 +1,4 @@
+export * from './demo-catalog';
 export * from './demo-price-change';
 export * from './schemas/checkout';
 export * from './schemas/listings';
diff --git a/packages/api-contracts/src/schemas/checkout.ts b/packages/api-contracts/src/schemas/checkout.ts
index 737a6f2..21d6b74 100644
--- a/packages/api-contracts/src/schemas/checkout.ts
+++ b/packages/api-contracts/src/schemas/checkout.ts
@@ -1,7 +1,6 @@
 import { z } from 'zod';
 
 export const checkoutSessionStatus = z.enum([
-  'created',
   'active',
   'pending_payment',
   'completed',
@@ -44,6 +43,16 @@ export const sessionIdInput = z.object({
 });
 export type SessionIdInput = z.infer<typeof sessionIdInput>;
 
+/**
+ * Resume returns the session plus the live hold price (when still held) so
+ * clients can map price_changed without a second client-side price clock.
+ */
+export const resumeSessionResultSchema = z.object({
+  session: checkoutSessionSchema,
+  livePriceCents: z.number().nonnegative().nullable(),
+});
+export type ResumeSessionResult = z.infer<typeof resumeSessionResultSchema>;
+
 // The tRPC wire codes this checkout flow actually throws, named after the
 // domain failure each one stands in for. Both clients switch on these to
 // decide which recovery UI to show, so the API and the clients share this set
diff --git a/packages/ui/src/features/checkout/DemoPriceCountdown.tsx b/packages/ui/src/features/checkout/DemoPriceCountdown.tsx
index 257be10..daa6ef6 100644
--- a/packages/ui/src/features/checkout/DemoPriceCountdown.tsx
+++ b/packages/ui/src/features/checkout/DemoPriceCountdown.tsx
@@ -1,6 +1,6 @@
 import { msUntilDemoPriceBump } from '@repo/api-contracts';
 import { colors } from '@repo/tokens';
-import { useEffect, useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { Text as RNText, View } from 'react-native';
 
 import { useTheme } from '../../theme';
@@ -10,6 +10,11 @@ type DemoPriceCountdownProps = {
   createdAt: string;
   /** When false, hide even if this is the demo listing. */
   visible?: boolean;
+  /**
+   * Fires once when the countdown reaches zero so the parent can re-resume
+   * and pick up the authoritative live hold price.
+   */
+  onExpire?: () => void;
   testID?: string;
 };
 
@@ -21,12 +26,20 @@ export function DemoPriceCountdown({
   listingId,
   createdAt,
   visible = true,
+  onExpire,
   testID = 'demo-price-countdown',
 }: DemoPriceCountdownProps) {
   const theme = useTheme();
   const [secondsLeft, setSecondsLeft] = useState<number | null>(() =>
     secondsUntilBump(listingId, createdAt),
   );
+  const expiredRef = useRef(false);
+  const onExpireRef = useRef(onExpire);
+  onExpireRef.current = onExpire;
+
+  useEffect(() => {
+    expiredRef.current = false;
+  }, [createdAt, listingId]);
 
   useEffect(() => {
     if (!visible) {
@@ -35,7 +48,12 @@ export function DemoPriceCountdown({
     }
 
     function tick() {
-      setSecondsLeft(secondsUntilBump(listingId, createdAt));
+      const remaining = secondsUntilBump(listingId, createdAt);
+      setSecondsLeft(remaining);
+      if (remaining !== null && remaining <= 0 && !expiredRef.current) {
+        expiredRef.current = true;
+        onExpireRef.current?.();
+      }
     }
 
     tick();
diff --git a/packages/ui/src/features/checkout/TicketProtectionCard.tsx b/packages/ui/src/features/checkout/TicketProtectionCard.tsx
deleted file mode 100644
index a63c44a..0000000
--- a/packages/ui/src/features/checkout/TicketProtectionCard.tsx
+++ /dev/null
@@ -1,78 +0,0 @@
-import { colors } from '@repo/tokens';
-import { Pressable, Text as RNText, View } from 'react-native';
-
-import { Text } from '../../atoms/Text';
-import { useTheme } from '../../theme';
-import { CHECKOUT_COPY } from './checkout.copy';
-
-type TicketProtectionCardProps = {
-  testID?: string;
-};
-
-/** Static decorative upsell — not a real purchase flow. */
-export function TicketProtectionCard({
-  testID = 'ticket-protection-card',
-}: TicketProtectionCardProps) {
-  const theme = useTheme();
-
-  return (
-    <View
-      testID={testID}
-      style={{
-        gap: theme.space[3],
-        paddingVertical: theme.space[4],
-      }}
-    >
-      <View
-        style={{
-          flexDirection: 'row',
-          alignItems: 'center',
-          justifyContent: 'space-between',
-          gap: theme.space[3],
-        }}
-      >
-        <View style={{ flex: 1, gap: theme.space[1] }}>
-          <RNText
-            style={{
-              fontSize: theme.fontSize.base,
-              fontWeight: theme.fontWeight.bold,
-              lineHeight: 22,
-              color: theme.text,
-            }}
-          >
-            {CHECKOUT_COPY.ticketProtectionTitle}
-          </RNText>
-          <Text variant="muted">{CHECKOUT_COPY.ticketProtectionPrice}</Text>
-        </View>
-        <Pressable
-          accessibilityRole="button"
-          accessibilityLabel={CHECKOUT_COPY.ticketProtectionAdd}
-          disabled
-          style={{
-            paddingHorizontal: theme.space[3],
-            paddingVertical: theme.space[2],
-            borderRadius: theme.radius.md,
-            borderWidth: 1,
-            borderColor: colors.border,
-            backgroundColor: colors.surface,
-          }}
-        >
-          <Text variant="eyebrow">{CHECKOUT_COPY.ticketProtectionAdd}</Text>
-        </Pressable>
-      </View>
-      <RNText
-        style={{
-          color: theme.muted,
-          fontSize: theme.fontSize.base,
-          lineHeight: 22,
-        }}
-      >
-        {CHECKOUT_COPY.ticketProtectionBody}
-        <RNText style={{ color: colors.link, textDecorationLine: 'underline' }}>
-          {CHECKOUT_COPY.ticketProtectionLearnMore}
-        </RNText>
-      </RNText>
-      <Text variant="muted">{CHECKOUT_COPY.ticketProtectionPoweredBy}</Text>
-    </View>
-  );
-}
diff --git a/packages/ui/src/features/checkout/checkout.copy.ts b/packages/ui/src/features/checkout/checkout.copy.ts
index f3a75f9..21c8abf 100644
--- a/packages/ui/src/features/checkout/checkout.copy.ts
+++ b/packages/ui/src/features/checkout/checkout.copy.ts
@@ -6,6 +6,10 @@ export const CHECKOUT_COPY = {
   cancelLabel: 'Cancel',
   /** Accessible name for the cancel control (icon-only on narrow screens). */
   cancelAriaLabel: 'Cancel purchase',
+  /** Visible leave word after a successful purchase (same header control). */
+  doneLabel: 'Done',
+  /** Accessible name for the post-purchase leave control. */
+  doneAriaLabel: 'Done',
   completePurchase: 'CONTINUE',
   completing: 'CONTINUING…',
   confirmNewPrice: 'CONFIRM NEW PRICE',
diff --git a/packages/ui/src/features/checkout/checkout.policy.util.test.ts b/packages/ui/src/features/checkout/checkout.policy.util.test.ts
new file mode 100644
index 0000000..90db19b
--- /dev/null
+++ b/packages/ui/src/features/checkout/checkout.policy.util.test.ts
@@ -0,0 +1,61 @@
+import {
+  isDecorativeSessionStatus,
+  isShareableSession,
+  sessionFromView,
+  showsCheckoutActions,
+  showsDecorativeChrome,
+} from './checkout.policy.util';
+import type { CheckoutView } from './checkout.view-model';
+
+const active = {
+  id: 'sess_1',
+  listingId: 'listing_1',
+  status: 'active' as const,
+  priceAtCreation: 4200,
+  acknowledgedPrice: 4200,
+  createdAt: '2026-01-01T00:00:00.000Z',
+  expiresAt: '2026-01-01T00:10:00.000Z',
+  failureReason: null,
+};
+
+describe('checkout.policy', () => {
+  it.each([
+    { status: 'active' as const, decorative: true },
+    { status: 'failed' as const, decorative: true },
+    { status: 'completed' as const, decorative: false },
+    { status: 'expired' as const, decorative: false },
+    { status: 'pending_payment' as const, decorative: false },
+  ])('isDecorativeSessionStatus($status) → $decorative', ({ status, decorative }) => {
+    expect(isDecorativeSessionStatus(status)).toBe(decorative);
+  });
+
+  it.each([
+    { kind: 'ready' as const, shows: true },
+    { kind: 'price_changed' as const, shows: true },
+    { kind: 'failed' as const, shows: true },
+    { kind: 'completed' as const, shows: false },
+    { kind: 'processing' as const, shows: false },
+  ])('showsCheckoutActions($kind) → $shows', ({ kind, shows }) => {
+    const view = { kind, session: active } as CheckoutView;
+    expect(showsCheckoutActions(view)).toBe(shows);
+  });
+
+  it.each([
+    { kind: 'ready' as const, shows: true },
+    { kind: 'completed' as const, shows: false },
+    { kind: undefined, shows: true },
+  ])('showsDecorativeChrome($kind) → $shows', ({ kind, shows }) => {
+    expect(showsDecorativeChrome(kind)).toBe(shows);
+  });
+
+  it('sessionFromView returns the session when present', () => {
+    expect(sessionFromView({ kind: 'ready', session: active, notice: null })).toBe(active);
+    expect(sessionFromView({ kind: 'loading' })).toBeNull();
+  });
+
+  it('isShareableSession matches active and failed only', () => {
+    expect(isShareableSession(active)).toBe(true);
+    expect(isShareableSession({ ...active, status: 'failed' })).toBe(true);
+    expect(isShareableSession({ ...active, status: 'completed' })).toBe(false);
+  });
+});
diff --git a/packages/ui/src/features/checkout/checkout.policy.util.ts b/packages/ui/src/features/checkout/checkout.policy.util.ts
new file mode 100644
index 0000000..a96e4b4
--- /dev/null
+++ b/packages/ui/src/features/checkout/checkout.policy.util.ts
@@ -0,0 +1,40 @@
+import type { CheckoutSession } from '@repo/api-contracts';
+
+import type { CheckoutView } from './checkout.view-model';
+
+/** Session still open for resume / share / retry — not terminal and not mid-charge. */
+export function isShareableSession(session: CheckoutSession): boolean {
+  return session.status === 'active' || session.status === 'failed';
+}
+
+/** Statuses that may still show decorative chrome when the view kind allows it. */
+export function isDecorativeSessionStatus(status: CheckoutSession['status']): boolean {
+  return status === 'active' || status === 'failed';
+}
+
+/**
+ * View kinds that keep Buy / confirm / retry (and related sticky chrome) visible.
+ * Mirrors terms visibility on web and sticky footer actions on mobile.
+ */
+export function showsCheckoutActions(view: CheckoutView): boolean {
+  return view.kind === 'ready' || view.kind === 'price_changed' || view.kind === 'failed';
+}
+
+/** View kinds where deal / promo / guarantee chrome should hide. */
+export const TERMINAL_VIEW_KINDS = new Set<CheckoutView['kind']>([
+  'completed',
+  'expired',
+  'unavailable',
+  'claimed_elsewhere',
+  'processing',
+  'not_found',
+  'error',
+]);
+
+export function showsDecorativeChrome(viewKind: CheckoutView['kind'] | undefined): boolean {
+  return viewKind === undefined || !TERMINAL_VIEW_KINDS.has(viewKind);
+}
+
+export function sessionFromView(view: CheckoutView): CheckoutSession | null {
+  return 'session' in view && view.session ? view.session : null;
+}
diff --git a/packages/ui/src/features/checkout/checkoutShare.util.test.ts b/packages/ui/src/features/checkout/checkoutShare.util.test.ts
index 25abbb6..790400d 100644
--- a/packages/ui/src/features/checkout/checkoutShare.util.test.ts
+++ b/packages/ui/src/features/checkout/checkoutShare.util.test.ts
@@ -6,7 +6,6 @@ import {
 
 describe('checkoutShare', () => {
   it.each([
-    { status: 'created' as const, shareable: true },
     { status: 'active' as const, shareable: true },
     { status: 'failed' as const, shareable: true },
     { status: 'completed' as const, shareable: false },
diff --git a/packages/ui/src/features/checkout/checkoutShare.util.ts b/packages/ui/src/features/checkout/checkoutShare.util.ts
index 55c7d7d..ef1ec12 100644
--- a/packages/ui/src/features/checkout/checkoutShare.util.ts
+++ b/packages/ui/src/features/checkout/checkoutShare.util.ts
@@ -1,12 +1,4 @@
-import type { CheckoutSession } from '@repo/api-contracts';
-
-/**
- * Share is only offered while the session is still resumable — not after
- * completion, expiry, or while another surface has claimed `pending_payment`.
- */
-export function isShareableSession(session: CheckoutSession): boolean {
-  return session.status === 'created' || session.status === 'active' || session.status === 'failed';
-}
+export { isShareableSession } from './checkout.policy.util';
 
 export function buildCheckoutShareUrls(
   sessionId: string,
diff --git a/packages/ui/src/features/checkout/index.ts b/packages/ui/src/features/checkout/index.ts
index 0b8310c..50e2ce4 100644
--- a/packages/ui/src/features/checkout/index.ts
+++ b/packages/ui/src/features/checkout/index.ts
@@ -1,18 +1,27 @@
 export { CHECKOUT_COPY } from './checkout.copy';
+export {
+  isDecorativeSessionStatus,
+  isShareableSession,
+  sessionFromView,
+  showsCheckoutActions,
+  showsDecorativeChrome,
+  TERMINAL_VIEW_KINDS,
+} from './checkout.policy.util';
 export type { CheckoutMapBubble, CheckoutPresentation, CheckoutView } from './checkout.view-model';
 export { CheckoutCard } from './CheckoutCard';
 export { CheckoutTerms, ContactRow, TicketDeliveryRow } from './CheckoutChrome';
-export {
-  buildCheckoutShareUrls,
-  buildNativeSharePayload,
-  isShareableSession,
-} from './checkoutShare.util';
+export { buildCheckoutShareUrls, buildNativeSharePayload } from './checkoutShare.util';
 export { CheckoutStadiumMap } from './CheckoutStadiumMap';
 export { DemoPriceCountdown } from './DemoPriceCountdown';
 export { EventSummary } from './EventSummary';
 export { GuaranteePanel } from './GuaranteePanel';
 export { mapCheckoutPresentation } from './mapCheckoutPresentation.util';
-export { priceUpdatedNotice, viewFromErrorCode, viewFromSession } from './mapCheckoutView.util';
+export {
+  priceUpdatedNotice,
+  viewFromErrorCode,
+  viewFromResume,
+  viewFromSession,
+} from './mapCheckoutView.util';
 export { PriceBreakdown } from './PriceBreakdown';
 export { ShareTickets } from './ShareTickets';
 export {
@@ -21,5 +30,5 @@ export {
   stadiumMapImageUrl,
 } from './stadiumMapImage.util';
 export { SuperDealBanner } from './SuperDealBanner';
-export { TicketProtectionCard } from './TicketProtectionCard';
 export { UrgencyBanner } from './UrgencyBanner';
+export { useCheckoutActions } from './useCheckoutActions';
diff --git a/packages/ui/src/features/checkout/mapCheckoutPresentation.util.ts b/packages/ui/src/features/checkout/mapCheckoutPresentation.util.ts
index 47122ee..f18afcd 100644
--- a/packages/ui/src/features/checkout/mapCheckoutPresentation.util.ts
+++ b/packages/ui/src/features/checkout/mapCheckoutPresentation.util.ts
@@ -3,18 +3,9 @@ import { formatCurrency } from '@repo/utils';
 
 import { DEMO_EVENT, LISTING_FIXTURES } from '../listings/listings.fixtures';
 import { CHECKOUT_COPY } from './checkout.copy';
+import { showsDecorativeChrome } from './checkout.policy.util';
 import type { CheckoutPresentation, CheckoutView } from './checkout.view-model';
 
-const TERMINAL_KINDS = new Set<CheckoutView['kind']>([
-  'completed',
-  'expired',
-  'unavailable',
-  'claimed_elsewhere',
-  'processing',
-  'not_found',
-  'error',
-]);
-
 export type MapCheckoutPresentationOptions = {
   viewKind?: CheckoutView['kind'];
   /** Set only after the fan confirms a price bump — enables Tickets strikethrough. */
@@ -31,7 +22,7 @@ export function mapCheckoutPresentation(
 ): CheckoutPresentation {
   const fixture = LISTING_FIXTURES[session.listingId];
   const viewKind = options?.viewKind;
-  const showDecorativeChrome = viewKind === undefined || !TERMINAL_KINDS.has(viewKind);
+  const showDecorativeChrome = showsDecorativeChrome(viewKind);
 
   const section = fixture?.section ?? null;
   const row = fixture?.row ?? null;
diff --git a/packages/ui/src/features/checkout/mapCheckoutView.util.test.ts b/packages/ui/src/features/checkout/mapCheckoutView.util.test.ts
index a8bf14d..deec90f 100644
--- a/packages/ui/src/features/checkout/mapCheckoutView.util.test.ts
+++ b/packages/ui/src/features/checkout/mapCheckoutView.util.test.ts
@@ -1,6 +1,11 @@
 import { CHECKOUT_ERROR_CODE } from '@repo/api-contracts';
 
-import { priceUpdatedNotice, viewFromErrorCode, viewFromSession } from './mapCheckoutView.util';
+import {
+  priceUpdatedNotice,
+  viewFromErrorCode,
+  viewFromResume,
+  viewFromSession,
+} from './mapCheckoutView.util';
 
 const active = {
   id: 'sess_1',
@@ -68,6 +73,36 @@ describe('viewFromErrorCode', () => {
   });
 });
 
+describe('viewFromResume', () => {
+  it.each([
+    {
+      name: 'matching live price stays ready',
+      livePriceCents: 4200,
+      kind: 'ready',
+    },
+    {
+      name: 'diverged live price becomes price_changed',
+      livePriceCents: 5000,
+      kind: 'price_changed',
+    },
+    {
+      name: 'null live price stays ready',
+      livePriceCents: null,
+      kind: 'ready',
+    },
+  ])('$name', ({ livePriceCents, kind }) => {
+    const view = viewFromResume(active, livePriceCents);
+    expect(view.kind).toBe(kind);
+    if (kind === 'price_changed' && view.kind === 'price_changed') {
+      expect(view.newPriceCents).toBe(5000);
+    }
+  });
+
+  it('does not override terminal session status with live price', () => {
+    expect(viewFromResume({ ...active, status: 'completed' }, 9999).kind).toBe('completed');
+  });
+});
+
 describe('priceUpdatedNotice', () => {
   it('formats the confirmed-price notice', () => {
     expect(priceUpdatedNotice(4200)).toBe('Price updated to $42.00.');
diff --git a/packages/ui/src/features/checkout/mapCheckoutView.util.ts b/packages/ui/src/features/checkout/mapCheckoutView.util.ts
index 0b97d47..6c703ca 100644
--- a/packages/ui/src/features/checkout/mapCheckoutView.util.ts
+++ b/packages/ui/src/features/checkout/mapCheckoutView.util.ts
@@ -27,6 +27,22 @@ export function viewFromSession(
   return { kind: 'ready', session, notice, previousUnitPriceCents };
 }
 
+/**
+ * Maps a resume payload. When the live hold price diverges from what the fan
+ * acknowledged, surface price_changed from the server clock — not a client timer.
+ */
+export function viewFromResume(
+  session: CheckoutSession,
+  livePriceCents: number | null,
+): CheckoutView {
+  const base = viewFromSession(session);
+  if (base.kind !== 'ready') return base;
+  if (livePriceCents !== null && livePriceCents !== session.acknowledgedPrice) {
+    return { kind: 'price_changed', session, newPriceCents: livePriceCents };
+  }
+  return base;
+}
+
 export function viewFromErrorCode(code: string | null, session?: CheckoutSession): CheckoutView {
   switch (code) {
     case CHECKOUT_ERROR_CODE.NOT_FOUND:
diff --git a/packages/ui/src/features/checkout/useCheckoutActions.ts b/packages/ui/src/features/checkout/useCheckoutActions.ts
new file mode 100644
index 0000000..b2529ab
--- /dev/null
+++ b/packages/ui/src/features/checkout/useCheckoutActions.ts
@@ -0,0 +1,106 @@
+import type { CheckoutSession, CheckoutSurface, ResumeSessionResult } from '@repo/api-contracts';
+import { trpcErrorCode } from '@repo/utils';
+import type { Dispatch, SetStateAction } from 'react';
+import { useCallback, useState } from 'react';
+
+import type { CheckoutView } from './checkout.view-model';
+import {
+  priceUpdatedNotice,
+  viewFromErrorCode,
+  viewFromResume,
+  viewFromSession,
+} from './mapCheckoutView.util';
+
+type CheckoutMutations = {
+  complete: (input: { sessionId: string; surface: CheckoutSurface }) => Promise<CheckoutSession>;
+  confirmPrice: (input: {
+    sessionId: string;
+    surface: CheckoutSurface;
+  }) => Promise<CheckoutSession>;
+  resume: (input: { sessionId: string; surface: CheckoutSurface }) => Promise<ResumeSessionResult>;
+};
+
+export type UseCheckoutActionsOptions = {
+  surface: CheckoutSurface;
+  mutations: CheckoutMutations;
+  setView: Dispatch<SetStateAction<CheckoutView>>;
+  /**
+   * When false, skip applying the response (unmounted or superseded request).
+   * Defaults to always apply.
+   */
+  shouldApply?: () => boolean;
+  /** Extra work after a successful price confirm (e.g. expand breakdown). */
+  onConfirmPriceSuccess?: () => void;
+};
+
+/**
+ * Shared complete / confirmPrice / resume-refresh orchestration for web + mobile.
+ * Platform chrome (leave guards, sticky footer, SSR) stays in each app.
+ */
+export function useCheckoutActions({
+  surface,
+  mutations,
+  setView,
+  shouldApply = () => true,
+  onConfirmPriceSuccess,
+}: UseCheckoutActionsOptions) {
+  const [busy, setBusy] = useState(false);
+
+  const completeOrder = useCallback(
+    async (session: CheckoutSession) => {
+      if (busy) return;
+      setBusy(true);
+      // Claim UI immediately — never leave Buy enabled while pending_payment.
+      setView({ kind: 'processing', session: { ...session, status: 'pending_payment' } });
+      try {
+        const next = await mutations.complete({ sessionId: session.id, surface });
+        if (shouldApply()) setView(viewFromSession(next));
+      } catch (error) {
+        if (shouldApply()) setView(viewFromErrorCode(trpcErrorCode(error), session));
+      } finally {
+        if (shouldApply()) setBusy(false);
+      }
+    },
+    [busy, mutations, setView, shouldApply, surface],
+  );
+
+  const confirmNewPrice = useCallback(
+    async (session: CheckoutSession) => {
+      if (busy) return;
+      setBusy(true);
+      try {
+        const next = await mutations.confirmPrice({ sessionId: session.id, surface });
+        if (shouldApply()) {
+          onConfirmPriceSuccess?.();
+          setView(
+            viewFromSession(
+              next,
+              priceUpdatedNotice(next.acknowledgedPrice),
+              session.acknowledgedPrice,
+            ),
+          );
+        }
+      } catch (error) {
+        if (shouldApply()) setView(viewFromErrorCode(trpcErrorCode(error), session));
+      } finally {
+        if (shouldApply()) setBusy(false);
+      }
+    },
+    [busy, mutations, onConfirmPriceSuccess, setView, shouldApply, surface],
+  );
+
+  /** Re-resume after the demo countdown expires so live hold price is authoritative. */
+  const refreshFromResume = useCallback(
+    async (sessionId: string) => {
+      try {
+        const result = await mutations.resume({ sessionId, surface });
+        if (shouldApply()) setView(viewFromResume(result.session, result.livePriceCents));
+      } catch (error) {
+        if (shouldApply()) setView(viewFromErrorCode(trpcErrorCode(error)));
+      }
+    },
+    [mutations, setView, shouldApply, surface],
+  );
+
+  return { busy, completeOrder, confirmNewPrice, refreshFromResume };
+}
diff --git a/packages/ui/src/features/listings/listings.fixtures.ts b/packages/ui/src/features/listings/listings.fixtures.ts
index c276534..f9a3db5 100644
--- a/packages/ui/src/features/listings/listings.fixtures.ts
+++ b/packages/ui/src/features/listings/listings.fixtures.ts
@@ -1,57 +1,29 @@
+import type { DemoListing } from '@repo/api-contracts';
+import { DEMO_CATALOG, DEMO_EVENT as SHARED_DEMO_EVENT } from '@repo/api-contracts';
+
 import type { EventFixture, ListingFixture } from './listings.view-model';
 
-export const DEMO_EVENT: EventFixture = {
-  artist: 'Ed Sheeran',
-  venue: 'Lumen Field',
-  datetimeLabel: 'Sat 8/1 at 5:30 PM',
-  city: 'Seattle',
-};
+export const DEMO_EVENT: EventFixture = { ...SHARED_DEMO_EVENT };
+
+function toListingFixture(listing: DemoListing): ListingFixture {
+  return {
+    listingId: listing.listingId,
+    section: listing.section,
+    row: listing.row,
+    seatCount: listing.seatCount,
+    isSuperDeal: listing.isSuperDeal,
+    bubble: listing.bubble,
+    ...(listing.urgencyTicketsLeft !== undefined
+      ? { urgencyTicketsLeft: listing.urgencyTicketsLeft }
+      : {}),
+  };
+}
 
 /**
  * Presentation-only catalog keyed by API listing ids. Prices and availability
  * come from `listings.list` — these fixtures never invent commerce state.
+ * Source of truth for ids + presentation fields: `@repo/api-contracts` DEMO_CATALOG.
  */
-export const LISTING_FIXTURES: Record<string, ListingFixture> = {
-  listing_1: {
-    listingId: 'listing_1',
-    section: '309',
-    row: 'JJ',
-    seatCount: 2,
-    isSuperDeal: true,
-    bubble: { leftPct: 62, topPct: 28 },
-    urgencyTicketsLeft: 4,
-  },
-  listing_2: {
-    listingId: 'listing_2',
-    section: '204',
-    row: '12',
-    seatCount: 2,
-    isSuperDeal: true,
-    bubble: { leftPct: 38, topPct: 42 },
-  },
-  listing_3: {
-    listingId: 'listing_3',
-    // Visible after the row so reviewers can spot the timed demo ticket.
-    section: '118',
-    row: '8 · 10s price demo',
-    seatCount: 3,
-    isSuperDeal: false,
-    bubble: { leftPct: 55, topPct: 58 },
-  },
-  listing_4: {
-    listingId: 'listing_4',
-    section: '332',
-    row: 'A',
-    seatCount: 2,
-    isSuperDeal: false,
-    bubble: { leftPct: 72, topPct: 48 },
-  },
-  listing_5: {
-    listingId: 'listing_5',
-    section: 'Floor',
-    row: '1',
-    seatCount: 2,
-    isSuperDeal: false,
-    bubble: { leftPct: 28, topPct: 52 },
-  },
-};
+export const LISTING_FIXTURES: Record<string, ListingFixture> = Object.fromEntries(
+  DEMO_CATALOG.map((listing) => [listing.listingId, toListingFixture(listing)]),
+);
diff --git a/packages/ui/src/server.ts b/packages/ui/src/server.ts
index c99583f..7f03710 100644
--- a/packages/ui/src/server.ts
+++ b/packages/ui/src/server.ts
@@ -4,6 +4,13 @@
  * Import from `@repo/ui/server` so the main barrel's client components are not pulled in.
  */
 export { CHECKOUT_COPY } from './features/checkout/checkout.copy';
+export {
+  isDecorativeSessionStatus,
+  isShareableSession,
+  sessionFromView,
+  showsCheckoutActions,
+  showsDecorativeChrome,
+} from './features/checkout/checkout.policy.util';
 export type {
   CheckoutMapBubble,
   CheckoutPresentation,
@@ -13,6 +20,7 @@ export { mapCheckoutPresentation } from './features/checkout/mapCheckoutPresenta
 export {
   priceUpdatedNotice,
   viewFromErrorCode,
+  viewFromResume,
   viewFromSession,
 } from './features/checkout/mapCheckoutView.util';
 export {