diff --git a/docs/superpowers/plans/2026-10-23-badge-scanner-v2.md b/docs/superpowers/plans/2026-10-23-badge-scanner-v2.md
new file mode 100644
index 000000000..fd7387a28
--- /dev/null
+++ b/docs/superpowers/plans/2026-10-23-badge-scanner-v2.md
@@ -0,0 +1,154 @@
+# Badge Scanner v2 Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Fix the Vue badge scanner's camera + `null of 2` count, and extend it to show contestant identity (`LastName, F.`), claimed prize names, and per-event aggregate stats.
+
+**Architecture:** Two new/changed CAP function handlers on the existing `ScannerService` (`getContestant` extended, `getEventStats` added), consumed by the existing Vue island at `hugo-apps/src/scanner-vue/`. Camera fix is a one-line `nextTick` ordering change. CQL only; `@requires: 'MobileApp'` unchanged.
+
+**Tech Stack:** SAP CAP (Node.js, `@sap/cds` ≥10.1), CQL, Vue 3 (`<script setup>`), Fundamental Styles, Vitest. All tests — CAP (`cds.test`) and Vue island (happy-dom) — run from the **root** `vitest.config.ts` `unit` project: `npx vitest run --project unit <path>`. The `unit` project already includes `hugo-apps/src/**/*.{test,spec}.{js,ts}` with happy-dom (an existing `scanner-vue/__tests__/scanner-claim.test.ts` runs there). Do NOT add a vitest config under `hugo-apps/` — there is none and none is needed.
+
+**Spec:** `docs/superpowers/specs/2026-10-23-badge-scanner-v2-design.md`
+
+## Global Constraints
+
+- **CQL/CDS only — no raw SQL.** (Project rule; the `forUpdate()` cap in `claimPrizeForContestant` is untouched.)
+- **Event scoping = `TaskRecords.event_ID == event.ID`** (badge/app-space path), NOT the Devtoberfest date-window. Event resolved by `Events.legacyId == eventId`.
+- **Completion semantic:** has-ever-completed, DISTINCT by `(user_ID, taskLegacyId)`, counting `status in ('COMPLETED','SUPERSEDED')`. Identical for per-contestant and per-event aggregates.
+- **PII:** identity response carries `lastName` (full) + `firstInitial` (single uppercase char, derived server-side). **No email, no full first name, ever crosses the wire.**
+- **Statuses are `CLAIMED` / `EARNED` only** (probed on DEV). "Claimed" = `CLAIMED`.
+- **Auth:** `@requires: 'MobileApp'` on the service, unchanged. No new scope.
+- **Branch/PR:** `worktree-scanner-badge-v2` off `origin/DEV`; PR → **DEV**.
+
+## Review Focus
+
+- **Contestant with zero completions / zero prizes** — card must render `0`s and "None yet", never blank or `null` (the bug being fixed; owned by Task 1 tests).
+- **Unresolvable / absent `eventId` (0 or no matching Event)** — `getContestant` must still return the contestant; `getEventStats` returns a null-ish/empty shape and the Vue panel hides, no error (owned by Task 2 + Task 4 tests).
+- **`firstName` empty/null** — `firstInitial` must be `''`, not throw on `.charAt(0)` (owned by Task 1 tests).
+- **Event stats must not leak cross-event rows** — a CLAIMED/completion row on a *different* event must not count (owned by Task 2 tests).
+- **API returns `null` claimedCount** — Vue must render `0 of 2`, not `null of 2` (owned by Task 4 tests).
+
+---
+
+### Task 1: Extend `getContestant` — identity + claimed prize names
+
+**Files:**
+- Modify: `srv/scanner-service.cds:7-13` (return shape)
+- Modify: `srv/scanner-service.js:11-52` (`getContestant` handler)
+- Test: `test/unit/scanner-contestant-count.test.js` (extend)
+
+**Interfaces:**
+- Produces: `getContestant(accountNumber: String, eventId: Integer)` now returns
+  `{ lastName: String, firstInitial: String, tutorialsCompleted: Integer, groupsCompleted: Integer, missionsCompleted: Integer, claimedCount: Integer, claimedPrizeNames: array of String, prizeRecords: String }`.
+  `firstInitial` = first char of `firstName` uppercased, or `''` if empty.
+  `claimedPrizeNames` = names of CLAIMED prizes for (user, event) with a non-null `prize`; null-`prize` rows contribute a generic `'Prize'` entry so the list length tracks `claimedCount`.
+
+- [ ] **Step 1: Write failing tests** in `test/unit/scanner-contestant-count.test.js`:
+  - seed a user with `firstName:'Thomas', lastName:'Jung'`; assert `result.lastName === 'Jung'` and `result.firstInitial === 'T'`.
+  - seed a user with `firstName:''`; assert `firstInitial === ''` (no throw).
+  - seed 1 CLAIMED PrizeRecord for the event with `prize_ID` → a Prizes row `name:'Sticker Pack'`; assert `result.claimedPrizeNames` deep-equals `['Sticker Pack']`.
+  - assert existing `claimedCount` / `prizeRecords` assertions still hold.
+
+- [ ] **Step 2: Run to verify fail** — `npx vitest run --project unit test/unit/scanner-contestant-count.test.js`. Expected: FAIL (new keys undefined).
+
+- [ ] **Step 3: Implement.** In `.cds` add `lastName`, `firstInitial`, `claimedPrizeNames : array of String` to the return. In `.js`: select `firstName, lastName` off the user; `firstInitial = (user.firstName||'').trim().charAt(0).toUpperCase()`; when fetching CLAIMED PrizeRecords, expand `prize` (`.columns('status','prize_ID', {ref:['prize'],expand:['name']})` or a follow-up `SELECT Prizes` by collected ids) and build `claimedPrizeNames` (real name, else `'Prize'`). Keep the existing count/`prizeRecords` logic.
+
+- [ ] **Step 4: Run to verify pass** — `npx vitest run --project unit test/unit/scanner-contestant-count.test.js`. Expected: PASS.
+
+- [ ] **Step 5: Commit** — `git add srv/scanner-service.cds srv/scanner-service.js test/unit/scanner-contestant-count.test.js && git commit -m "feat(scanner): getContestant returns identity + claimed prize names (#badge-v2)"`
+
+---
+
+### Task 2: Add `getEventStats` function
+
+**Files:**
+- Modify: `srv/scanner-service.cds` (add function after line 25, before closing `}`)
+- Modify: `srv/scanner-service.js` (add `this.on('getEventStats', ...)` handler)
+- Test: `test/unit/scanner-event-stats.test.js` (create)
+
+**Interfaces:**
+- Consumes: nothing from Task 1.
+- Produces: `getEventStats(eventId: Integer)` returns
+  `{ eventName: String, prizesClaimed: Integer, prizesAvailable: Integer, earnedAwaitingHandover: Integer, participants: Integer, participantsClaimed: Integer, tutorialsCompleted: Integer, groupsCompleted: Integer, missionsCompleted: Integer }`.
+  Unresolvable `eventId` → all-zero/empty object with `eventName: null` (handler returns, does not reject).
+
+- [ ] **Step 1: Write failing tests** in `test/unit/scanner-event-stats.test.js` (`cds.test('serve')` like the sibling test). Seed: event `evt-main` (legacyId 10000015) + `evt-other`; 3 Prizes on evt-main (`prizesAvailable=3`); PrizeRecords — 2 CLAIMED + 1 EARNED on evt-main (across 2 users), 1 CLAIMED on evt-other; TaskRecords — user A: 2 TUTORIAL COMPLETED (distinct taskLegacyId) + 1 GROUP on evt-main; user B: 1 TUTORIAL on evt-main; 1 TUTORIAL on evt-other (must NOT count). Assert:
+  - `prizesClaimed===2`, `prizesAvailable===3`, `earnedAwaitingHandover===1`
+  - `participants===2`, `participantsClaimed===2`
+  - `tutorialsCompleted===3`, `groupsCompleted===1`, `missionsCompleted===0`
+  - cross-event: evt-other's rows absent from evt-main totals
+  - unresolvable eventId `999999` → `{ eventName:null, prizesClaimed:0, participants:0, ... }`, no throw.
+
+- [ ] **Step 2: Run to verify fail** — `npx vitest run --project unit test/unit/scanner-event-stats.test.js`. Expected: FAIL (`getEventStats` not found).
+
+- [ ] **Step 3: Implement.** Resolve event by `legacyId`; if none → return zero object. `prizesAvailable` = `SELECT.from(Prizes).where({event_ID})` count; `prizesClaimed`/`earnedAwaitingHandover` = counts of PrizeRecords where `{event_ID, status}`; `participantsClaimed` = distinct `user_ID` over CLAIMED. For participants + completion totals: `SELECT from TaskRecords where {event_ID, status:{in:['COMPLETED','SUPERSEDED']}}`, dedupe in JS by `(user_ID, taskLegacyId)` then count by `taskType` and distinct users (same loop pattern as `getContestant`). CQL only.
+
+- [ ] **Step 4: Run to verify pass** — same command. Expected: PASS.
+
+- [ ] **Step 5: Commit** — `git add srv/scanner-service.cds srv/scanner-service.js test/unit/scanner-event-stats.test.js && git commit -m "feat(scanner): add getEventStats event-aggregate function (#badge-v2)"`
+
+---
+
+### Task 3: Fix Vue camera (nextTick ordering)
+
+**Files:**
+- Modify: `hugo-apps/src/scanner-vue/ScannerApp.vue` (`onScan`, add `nextTick` import)
+- Test: `hugo-apps/src/scanner-vue/__tests__/scanner-camera-order.test.ts` (create)
+
+**Interfaces:**
+- Consumes: nothing. Produces: nothing for later tasks (behavioral fix).
+
+- [ ] **Step 1: Write failing test.** A light unit test (no full mount): import a small extracted `scanOrder` helper OR assert ordering via a mock. Simplest: extract the ordering into a testable function `beginScan(setState, nextTickFn, scanFn)` that calls `setState('scanning')`, `await nextTickFn()`, then `scanFn()`, and assert `scanFn` is called only after `nextTickFn` resolves (spy order). Place the helper in `ScannerApp.vue`'s script or a sibling `scan-order.ts` and import it.
+
+- [ ] **Step 2: Run to verify fail** — `npx vitest run --project unit hugo-apps/src/scanner-vue/__tests__/scanner-camera-order.test.ts`. Expected: FAIL.
+
+- [ ] **Step 3: Implement.** `import { ref, computed, nextTick } from 'vue'`; in `onScan`, after `state.value = 'scanning'` add `await nextTick()` before `const result = await scan()`. (If the ordering helper was extracted, wire `onScan` to it.)
+
+- [ ] **Step 4: Run to verify pass** — same command. Expected: PASS.
+
+- [ ] **Step 5: Commit** — `git add hugo-apps/src/scanner-vue/ && git commit -m "fix(scanner): await nextTick before camera scan so video ref is mounted (#badge-v2)"`
+
+---
+
+### Task 4: Vue UI — identity, claimed names, event stats, null-count guard
+
+**Files:**
+- Modify: `hugo-apps/src/scanner-vue/types.ts` (add fields + `EventStats`)
+- Modify: `hugo-apps/src/scanner-vue/useScannerApi.ts` (add `getEventStats`, numeric coercion)
+- Modify: `hugo-apps/src/scanner-vue/ScannerApp.vue` (render identity line, claimed-names list, event-stats section)
+- Test: `hugo-apps/src/scanner-vue/__tests__/scanner-coercion.test.ts` (create)
+
+**Interfaces:**
+- Consumes: `getContestant` and `getEventStats` shapes from Tasks 1 & 2.
+- Produces: `ContestantData` gains `lastName: string; firstInitial: string; claimedPrizeNames: string[]`. New `EventStats` interface mirroring Task 2's return.
+
+- [ ] **Step 1: Write failing test** in `scanner-coercion.test.ts`: a unit test over `useScannerApi`'s unwrap/coerce — given a stubbed `fetch` returning `{ value: { claimedCount: null, tutorialsCompleted: null } }`, assert `getContestant` resolves `claimedCount === 0` and `tutorialsCompleted === 0` (never null). (Stub global `fetch`.)
+
+- [ ] **Step 2: Run to verify fail** — `npx vitest run --project unit hugo-apps/src/scanner-vue/__tests__/scanner-coercion.test.ts`. Expected: FAIL.
+
+- [ ] **Step 3: Implement.**
+  - `types.ts`: add the three fields to `ContestantData`; add `EventStats`.
+  - `useScannerApi.ts`: add `getEventStats(eventId)` (fetch `/scanner/getEventStats(eventId=${eventId})`, `json.value ?? json`); in `getContestant` coerce numeric fields with `?? 0` and default `claimedPrizeNames` to `[]`.
+  - `ScannerApp.vue`: identity header → `{{ contestant.lastName }}, {{ contestant.firstInitial }}.`; render `claimedPrizeNames` as a list, empty → "None yet"; in `loadContestant`, after loading the contestant, `if (scanResult.payload.eventId) eventStats.value = await getEventStats(eventId)`; add an event-stats section (claimed vs available, earned-awaiting, participants/claimed, completion totals) shown only when `eventStats` is set.
+
+- [ ] **Step 4: Run to verify pass** — same command. Expected: PASS.
+
+- [ ] **Step 5: Commit** — `git add hugo-apps/src/scanner-vue/ && git commit -m "feat(scanner): identity line, claimed prize names, event stats panel, null-count guard (#badge-v2)"`
+
+---
+
+### Task 5: Verify full suite + lint
+
+**Files:** none (verification only).
+
+- [ ] **Step 1:** Run CAP unit scanner tests — `npx vitest run --project unit test/unit/scanner-*.test.js`. Expected: all PASS.
+- [ ] **Step 2:** Run Vue island tests — `npx vitest run --project unit hugo-apps/src/scanner-vue/`. Expected: all PASS.
+- [ ] **Step 3:** Typecheck the island — `cd hugo-apps && npx vue-tsc --noEmit` (or the project's configured check). Expected: no new errors in `scanner-vue/`.
+- [ ] **Step 4: Commit** any lint/type fixup if needed, else no-op.
+
+---
+
+## Notes for the executor
+
+- Deploy/verify-on-DEV is **out of plan scope** (separate step after merge, per spec Rollout). Do not deploy from the feature branch.
+- `cds bind --exec` is blocked inside this worktree by a harness guard — run any DB-bound command from the main checkout `D:\projects\tutorials-poc`, not here. Unit tests (`cds.test`) use in-memory SQLite and need no binding.
diff --git a/docs/superpowers/specs/2026-10-23-badge-scanner-v2-design.md b/docs/superpowers/specs/2026-10-23-badge-scanner-v2-design.md
new file mode 100644
index 000000000..f92942683
--- /dev/null
+++ b/docs/superpowers/specs/2026-10-23-badge-scanner-v2-design.md
@@ -0,0 +1,222 @@
+# Badge Scanner v2 — Design
+
+**Date:** 2026-10-23
+**Branch:** `worktree-scanner-badge-v2` (off `origin/DEV`) → PR targets **DEV**
+**Status:** Awaiting approval
+
+## DEV data ground-truth (probed 2026-10-23, read-only against DEV HANA)
+
+Settles the builder-check's data questions with real numbers, not assumptions:
+
+| Metric | DEV value |
+|---|---|
+| `PrizeRecords` total | 41,633 |
+| Distinct `status` values | `CLAIMED` (14,686), `EARNED` (26,947) — only these two |
+| CLAIMED rows with a populated `prize` (named) | **14,686 — i.e. ALL of them** |
+| CLAIMED rows with null `prize` | **0** |
+| `Prizes` catalog rows | 16 |
+
+**Implications (these override the earlier null-prize caveats below):**
+- **G4 is the common path, not an edge case.** Every CLAIMED record resolves to a
+  real prize name. The "generic row for null-prize handovers" becomes a cheap
+  defensive guard (the v2 `claimPrizeForContestant` null-`prize` flow has
+  evidently not written rows on DEV), not a primary code path. `claimedPrizeNames`
+  will populate for real.
+- **`EARNED` is a real, high-volume status** (26,947 rows). `getEventStats` must
+  count ONLY `CLAIMED` as "claimed." Additionally surface `EARNED` as
+  **"earned, awaiting handover"** per event — it's the operationally useful
+  "ready to collect" signal and nearly 2× the CLAIMED volume.
+- **"Claimed vs available" is meaningful**: a 16-row catalog, event-scoped
+  CLAIMED slice. Label honestly (handovers recorded vs catalog size); do not
+  imply the two are a strict fraction.
+
+## Builder-check resolutions (my calls, folded in)
+
+1. **Badge `eventId` is a legacyId**, resolved via `Events.legacyId == eventId`
+   (the existing handler already does this). **Fail-soft:** if `eventId` is
+   absent/`0`/unresolvable, the contestant card still renders; the event-stats
+   panel is simply hidden (no error). Builder implements the hidden-panel path.
+2. **Statuses are `CLAIMED` / `EARNED` only** (probed). `getEventStats` counts
+   CLAIMED for "claimed"; adds an `earnedAwaitingHandover` count. No other
+   statuses to worry about.
+3. **`claimedPrizeNames` resolves real names** (probed: 100% of CLAIMED have a
+   prize). Null-`prize` handling stays as a guard, not a main path.
+4. **Vue test = a light unit test** of (a) `nextTick`-before-`scan` ordering and
+   (b) null→`0 of 2` coercion — NOT a full component-mount harness (none exists
+   under `hugo-apps/` today; standing one up is out of scope for this change).
+
+## Intent & Why
+
+The Badge Scanner is the operator-facing tool used at an event prize table.
+An operator scans a contestant's badge QR to (1) confirm they are looking at
+the right person, (2) see that person's progress and which prizes they have
+already claimed, (3) record a capped prize handover, and (4) glance at how the
+event is going overall. Today the tool is not usable: the Vue version's camera
+never opens, and even via the manual path the contestant card shows
+`null of 2` prizes claimed with blank completion counts. It also does not show
+*which* prizes were claimed, nor any event-level picture.
+
+This redesign makes the tool do the operator's real job at the table.
+
+## Goals
+
+- **G1 — Camera works** in the Vue "Badge Scanner" (`/scanner-vue/`).
+- **G2 — Real prize count**: contestant card shows an accurate `N of 2`, never
+  `null`.
+- **G3 — Identity line** for eyeball verification against the physical badge:
+  `LastName, F.` (last name in full, first name as a single initial). **No
+  email, ever** — nothing more than last name + first initial crosses the wire.
+- **G4 — Claimed prize names**: list the names of prizes this contestant has
+  already claimed (claimed-only; not the full catalog).
+- **G5 — Event stats panel** under the contestant card, refreshed once per
+  scan (no polling, no toggle), scoped to the event tied to the scanned badge:
+  - **Prize totals** — total CLAIMED prize records across all contestants vs.
+    total prizes available for the event.
+  - **Participation** — number of distinct contestants with ≥1 completion for
+    the event, and how many of those have claimed ≥1 prize.
+  - **Completion totals** — sum of tutorials / groups / missions completed
+    across the event's participants.
+
+## Non-Goals
+
+- **Not** touching the UI5 scanner (`app/scanner/`, `/scanner-ui/`). It stays
+  as-is; the Vue `/scanner-vue/` "Badge Scanner" is the one being fixed. (The
+  user confirmed the Vue one is the target; the UI5 one is the older
+  `sap.ndc.BarcodeScanner` app.)
+- **No** always-on / live-refreshing event dashboard. Stats are a per-scan
+  snapshot. A standing dashboard is a separate idea if ever wanted.
+- **No** full prize catalog with per-prize claimed/unclaimed flags per
+  contestant — user chose "claimed prize names only."
+- **No** change to the capped-handover flow (max 2 CLAIMED per user+event) or
+  its atomicity guarantees.
+- **No** new auth scope — stays `@requires: 'MobileApp'`.
+
+## Anti-Goals (what makes this a failure even if it "works")
+
+- Leaking PII onto a shared operator device — specifically, surfacing email or
+  a full first name. If the identity line shows more than `LastName, F.`, that
+  is a failure.
+- A prize count that is ever `null`, `undefined`, or `NaN` on screen — the bug
+  we are fixing must not reappear in a new field.
+- Event stats that silently use the wrong event-scoping signal and so report
+  numbers that don't match reality (see Constraint C2).
+
+## Constraints
+
+- **C1 — CAP/CQL only.** No raw SQL. Use `cds.ql`/CQL. (`claimPrizeForContestant`
+  uses `forUpdate()` for the cap; that atomicity stays untouched.) Project rule.
+- **C2 — Event scoping = `TaskRecords.event_ID == event.ID`.** This scanner is
+  the badge / App-Space path, where `TaskRecords.event` carries the event
+  association. This is distinct from Devtoberfest gameboard scoring, which
+  scopes by date window `[startDate,endDate]` and deliberately ignores
+  `event_ID`. **Builder must not** swap in the date-window approach here. The
+  event is resolved by `Events.legacyId == eventId` (as the current handler
+  already does), then its UUID used for `event_ID` filters.
+- **C3 — Completion semantic matches today's.** "Has-ever-completed" DISTINCT by
+  `(user_ID, taskLegacyId)`, counting `COMPLETED` + `SUPERSEDED`, as the current
+  `getContestant` does. Event completion totals reuse the exact same semantic so
+  the per-contestant numbers and the aggregate are consistent.
+- **C4 — `@requires: 'MobileApp'`** unchanged; identity response carries only
+  `lastName` + a derived `firstInitial` (single char), computed server-side so
+  the full first name never leaves the server.
+- **C5 — Branch/deploy hygiene.** Work on `worktree-scanner-badge-v2` off
+  `origin/DEV`; PR → **DEV** (`main` is protected, no hotfix path). Never deploy
+  a feature branch.
+
+## The How (decided)
+
+### Service — `srv/scanner-service.cds` + `srv/scanner-service.js`
+
+**Extend `getContestant`** return shape with identity + claimed prize names:
+
+```cds
+function getContestant(accountNumber : String, eventId : Integer) returns {
+  lastName           : String;   // full last name (badge match)
+  firstInitial       : String;   // single char, derived server-side
+  tutorialsCompleted : Integer;
+  groupsCompleted    : Integer;
+  missionsCompleted  : Integer;
+  claimedCount       : Integer;
+  claimedPrizeNames  : array of String;   // names of CLAIMED prizes (this user+event)
+  prizeRecords       : String;            // kept: "N of 2 prizes claimed" (back-compat)
+};
+```
+
+Handler changes:
+- Select `firstName`, `lastName` off the user; return `lastName` and
+  `firstInitial = (firstName || '').trim().charAt(0).toUpperCase()`.
+- When resolving CLAIMED `PrizeRecords` for the (user, event), expand the
+  `prize` association (or follow-up SELECT on `Prizes`) to collect
+  `claimedPrizeNames` (drop nulls — new-flow handovers have a null `prize`;
+  show those as a count only, not a named line — builder's call on label).
+
+**New `getEventStats` function:**
+
+```cds
+function getEventStats(eventId : Integer) returns {
+  eventName         : String;
+  prizesClaimed     : Integer;   // count of CLAIMED PrizeRecords for the event
+  prizesAvailable   : Integer;   // count of Prizes rows for the event
+  earnedAwaitingHandover : Integer; // count of EARNED (not-yet-CLAIMED) for the event
+  participants      : Integer;   // distinct users with >=1 completion for the event
+  participantsClaimed : Integer; // distinct users with >=1 CLAIMED prize for the event
+  tutorialsCompleted : Integer;  // sum across event participants (DISTINCT semantic)
+  groupsCompleted    : Integer;
+  missionsCompleted  : Integer;
+};
+```
+
+Handler: resolve event by `legacyId`; `prizesAvailable` = `Prizes` count where
+`event_ID`; `prizesClaimed` = CLAIMED `PrizeRecords` where `event_ID`;
+`participantsClaimed` = distinct `user_ID` in those CLAIMED records;
+participants + completion totals from `TaskRecords` where `event_ID` and
+`status in (COMPLETED, SUPERSEDED)`, applying the C3 DISTINCT-by-
+`(user_ID, taskLegacyId)` semantic before counting/summing.
+
+### Vue — `hugo-apps/src/scanner-vue/`
+
+- **`useBarcodeScanner.ts` / `ScannerApp.vue` (G1):** `onScan()` sets
+  `state.value = 'scanning'` then `await nextTick()` **before** calling
+  `scan()`, so the `<video ref="videoRef">` in the `scanning` branch is mounted
+  when `scan()` reads `videoRef.value`. (Root cause: today it reads the ref in
+  the same tick, before Vue renders that branch, so it throws "Video element
+  not available" and tears the camera down.)
+- **`types.ts`:** add `lastName`, `firstInitial`, `claimedPrizeNames: string[]`
+  to `ContestantData`; add an `EventStats` interface.
+- **`useScannerApi.ts`:** add `getEventStats(eventId)`; keep the `json.value ??
+  json` unwrap (CAP function results wrap in `{value}`); ensure numeric fields
+  coerce with `?? 0` so a missing key renders `0`, never `null` (G2 defense in
+  depth).
+- **`ScannerApp.vue`:** identity header → `{{ lastName }}, {{ firstInitial }}.`;
+  render `claimedPrizeNames` as a small list (empty → "None yet"); add an
+  event-stats section below the card populated from `getEventStats`, fetched in
+  `loadContestant` alongside the contestant.
+
+### Tests (TDD)
+
+- Extend `test/unit/scanner-contestant-count.test.js`: asserts `claimedCount` is
+  a number, `lastName`/`firstInitial` correct, `claimedPrizeNames` resolves prize
+  names and omits nulls.
+- New `test/unit/scanner-event-stats.test.js`: seed users/taskrecords/prizes/
+  prizerecords for an event; assert each aggregate, including DISTINCT semantics
+  and event scoping (a record on a *different* event must not leak in).
+- Vue: a `scanner-vue` test covering `nextTick`-before-`scan` ordering and that
+  a `null` claimedCount from the API renders `0 of 2`, not `null of 2`.
+
+## Left to the builder
+
+- Exact Fundamental-Styles markup for the identity line, claimed-prize list, and
+  event-stats section (match existing `.scanner-card` styling).
+- Label wording for null-`prize` new-flow handovers in the claimed list
+  (count-only vs. a generic "Prize" label).
+- Whether `getEventStats` is a second fetch or folded into one round-trip — a
+  separate function is specified for testability; builder may combine if cheaper.
+- Precise CQL for the DISTINCT aggregates (set-based vs. in-memory dedupe) as
+  long as C2/C3 hold and no raw SQL is used.
+
+## Rollout
+
+- PR → **DEV**. Verify on the DEV approuter
+  (`https://tutorial-system-dev-tutorials-approuter.cfapps.eu10-005.hana.ondemand.com/scanner-vue/`)
+  with a real badge before claiming done (Tom's #1 rule). `/scanner-ui/` and
+  `/scanner-vue/` are both `MobileApp`-gated.
diff --git a/hugo-apps/src/scanner-vue/ScannerApp.vue b/hugo-apps/src/scanner-vue/ScannerApp.vue
index c096ed49a..b9fee392f 100644
--- a/hugo-apps/src/scanner-vue/ScannerApp.vue
+++ b/hugo-apps/src/scanner-vue/ScannerApp.vue
@@ -1,16 +1,18 @@
 <script setup lang="ts">
-import { ref, computed } from 'vue'
+import { ref, computed, nextTick } from 'vue'
 import { useBarcodeScanner } from './useBarcodeScanner'
 import { useScannerApi } from './useScannerApi'
-import type { ScanResult, ContestantData } from './types'
+import { beginScan } from './scan-order'
+import type { ScanResult, ContestantData, EventStats } from './types'
 
 const videoRef = ref<HTMLVideoElement | null>(null)
 const { scan, cancel, isSupported, isScanning, error: scanError } = useBarcodeScanner(videoRef)
-const { loading, getContestant, claimPrizeForContestant, reset: resetApi } = useScannerApi()
+const { loading, getContestant, getEventStats, claimPrizeForContestant, reset: resetApi } = useScannerApi()
 
 type AppState = 'idle' | 'scanning' | 'loaded' | 'claiming'
 const state = ref<AppState>('idle')
 const contestant = ref<ContestantData | null>(null)
+const eventStats = ref<EventStats | null>(null)
 const toast = ref<{ message: string; type: 'success' | 'error' } | null>(null)
 const manualInput = ref('')
 const errorMessage = ref<string | null>(null)
@@ -24,6 +26,7 @@ function showToast(message: string, type: 'success' | 'error' = 'success') {
 
 function resetState() {
   contestant.value = null
+  eventStats.value = null
   errorMessage.value = null
   state.value = 'idle'
   resetApi()
@@ -47,15 +50,21 @@ async function loadContestant(scanResult: ScanResult) {
   try {
     const data = await getContestant(scanResult.uid, scanResult.payload.eventId)
     contestant.value = {
+      ...data,
       uid: scanResult.uid,
       eventId: scanResult.payload.eventId,
       recordId: scanResult.payload.recordId,
       status: scanResult.payload.status,
-      tutorialsCompleted: data.tutorialsCompleted,
-      groupsCompleted: data.groupsCompleted,
-      missionsCompleted: data.missionsCompleted,
-      prizeRecords: data.prizeRecords,
-      claimedCount: data.claimedCount ?? 0
+    }
+    // Event stats panel is fail-soft: no/unresolvable event or a failed stats
+    // fetch leaves eventStats null and the panel simply hides.
+    eventStats.value = null
+    if (scanResult.payload.eventId) {
+      try {
+        eventStats.value = await getEventStats(scanResult.payload.eventId)
+      } catch {
+        eventStats.value = null
+      }
     }
   } catch (e) {
     errorMessage.value = `Could not load contestant: ${(e as Error).message}`
@@ -65,9 +74,10 @@ async function loadContestant(scanResult: ScanResult) {
 
 async function onScan() {
   errorMessage.value = null
-  state.value = 'scanning'
 
-  const result = await scan()
+  // Await nextTick after switching to the scanning state so the <video> ref is
+  // mounted before the camera scanner reads it (see scan-order.ts).
+  const result = await beginScan((s) => { state.value = s }, nextTick, scan)
   if (!result) {
     if (scanError.value) {
       errorMessage.value = scanError.value
@@ -204,9 +214,9 @@ async function onClaimPrize() {
         </div>
 
         <template v-if="contestant">
-          <!-- Identity -->
+          <!-- Identity — LastName, F. for eyeball match against the badge -->
           <div class="scanner-card__header">
-            <h3 class="scanner-card__uid">{{ contestant.uid }}</h3>
+            <h3 class="scanner-card__uid">{{ contestant.lastName }}, {{ contestant.firstInitial }}.</h3>
             <p class="scanner-card__meta">{{ contestant.recordId }} &middot; {{ contestant.status }}</p>
           </div>
 
@@ -216,6 +226,17 @@ async function onClaimPrize() {
             <span class="scanner-card__prizes-value">{{ contestant.claimedCount }} of 2</span>
           </div>
 
+          <!-- Claimed prize names -->
+          <ul class="fd-list scanner-card__prizelist" role="list">
+            <li v-if="contestant.claimedPrizeNames.length === 0" class="fd-list__item" role="listitem">
+              <span class="fd-list__title scanner-card__prizelist-empty">None yet</span>
+            </li>
+            <li v-for="(name, i) in contestant.claimedPrizeNames" :key="i" class="fd-list__item" role="listitem">
+              <i class="sap-icon--gift"></i>
+              <span class="fd-list__title">{{ name }}</span>
+            </li>
+          </ul>
+
           <!-- Stats -->
           <ul class="fd-list scanner-card__stats" role="list">
             <li class="fd-list__item" role="listitem">
@@ -234,6 +255,32 @@ async function onClaimPrize() {
         </template>
       </div>
 
+      <!-- Event stats panel (per scan; hidden when no event resolved) -->
+      <div v-if="eventStats && eventStats.eventName" class="scanner-card scanner-event">
+        <div class="scanner-card__header">
+          <h3 class="scanner-card__uid">{{ eventStats.eventName }}</h3>
+          <p class="scanner-card__meta">Event totals</p>
+        </div>
+        <ul class="fd-list scanner-card__stats" role="list">
+          <li class="fd-list__item" role="listitem">
+            <span class="fd-list__title">Prizes handed over</span>
+            <span class="fd-list__secondary">{{ eventStats.prizesClaimed }} / {{ eventStats.prizesAvailable }} in catalog</span>
+          </li>
+          <li class="fd-list__item" role="listitem">
+            <span class="fd-list__title">Earned, awaiting handover</span>
+            <span class="fd-list__secondary">{{ eventStats.earnedAwaitingHandover }}</span>
+          </li>
+          <li class="fd-list__item" role="listitem">
+            <span class="fd-list__title">Participants (claimed)</span>
+            <span class="fd-list__secondary">{{ eventStats.participants }} ({{ eventStats.participantsClaimed }})</span>
+          </li>
+          <li class="fd-list__item" role="listitem">
+            <span class="fd-list__title">Completions (tut / grp / mis)</span>
+            <span class="fd-list__secondary">{{ eventStats.tutorialsCompleted }} / {{ eventStats.groupsCompleted }} / {{ eventStats.missionsCompleted }}</span>
+          </li>
+        </ul>
+      </div>
+
       <!-- Footer bar -->
       <div class="fd-bar fd-bar--footer scanner-footer">
         <div class="fd-bar__right">
@@ -494,4 +541,26 @@ async function onClaimPrize() {
   align-items: center;
   gap: 0.5rem;
 }
+
+/* Claimed prize names list */
+.scanner-card__prizelist {
+  margin: 0;
+  border-top: 1px solid var(--sapList_BorderColor, #e5e5e5);
+}
+.scanner-card__prizelist .fd-list__item {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 0.5rem 1rem;
+}
+.scanner-card__prizelist-empty {
+  color: var(--sapContent_LabelColor, #6a6d70);
+  font-style: italic;
+}
+
+/* Event stats panel */
+.scanner-event {
+  margin-top: 0.5rem;
+}
 </style>
+
diff --git a/hugo-apps/src/scanner-vue/__tests__/scanner-camera-order.test.ts b/hugo-apps/src/scanner-vue/__tests__/scanner-camera-order.test.ts
new file mode 100644
index 000000000..2cd4c3f58
--- /dev/null
+++ b/hugo-apps/src/scanner-vue/__tests__/scanner-camera-order.test.ts
@@ -0,0 +1,20 @@
+// #badge-v2 — the camera ordering helper must await nextTick (so the <video>
+// element in the v-if="scanning" branch is mounted) BEFORE calling scan().
+// Regression guard for the bug where scan() read a null videoRef and threw.
+
+import { describe, expect, it } from 'vitest'
+import { beginScan } from '../scan-order'
+
+describe('beginScan ordering (#badge-v2)', () => {
+  it('awaits nextTick before invoking scan', async () => {
+    const calls: string[] = []
+    const setState = (s: string) => { calls.push(`state:${s}`) }
+    const nextTickFn = () => { calls.push('nextTick'); return Promise.resolve() }
+    const scanFn = () => { calls.push('scan'); return Promise.resolve('RESULT') }
+
+    const result = await beginScan(setState, nextTickFn, scanFn)
+
+    expect(result).toBe('RESULT')
+    expect(calls).toEqual(['state:scanning', 'nextTick', 'scan'])
+  })
+})
diff --git a/hugo-apps/src/scanner-vue/__tests__/scanner-claim-request.test.ts b/hugo-apps/src/scanner-vue/__tests__/scanner-claim-request.test.ts
new file mode 100644
index 000000000..9f89e631a
--- /dev/null
+++ b/hugo-apps/src/scanner-vue/__tests__/scanner-claim-request.test.ts
@@ -0,0 +1,16 @@
+// #badge-v2 — claimPrizeForContestant is an OData `action`, so it must be a POST
+// with params in the body, NOT a function-style GET with params in the URL.
+// claimRequest() builds that request; this pins the method/URL/body contract.
+
+import { describe, expect, it } from 'vitest'
+import { claimRequest } from '../useScannerApi'
+
+describe('claimRequest action contract (#badge-v2)', () => {
+  it('builds a POST with params in the body, not the URL', () => {
+    const req = claimRequest('uuid-abc', 10000015)
+    expect(req.method).toBe('POST')
+    expect(req.url).toBe('/scanner/claimPrizeForContestant')
+    expect(req.url).not.toContain('accountNumber')
+    expect(req.body).toEqual({ accountNumber: 'uuid-abc', eventId: 10000015 })
+  })
+})
diff --git a/hugo-apps/src/scanner-vue/__tests__/scanner-claim.test.ts b/hugo-apps/src/scanner-vue/__tests__/scanner-claim.test.ts
index 5dc03ef2e..68cf2da44 100644
--- a/hugo-apps/src/scanner-vue/__tests__/scanner-claim.test.ts
+++ b/hugo-apps/src/scanner-vue/__tests__/scanner-claim.test.ts
@@ -54,7 +54,7 @@ describe('useScannerApi', () => {
   })
 
   describe('claimPrizeForContestant(uid, eventId)', () => {
-    it('builds URL with accountNumber and eventId', async () => {
+    it('POSTs to the action with params in the body (#badge-v2)', async () => {
       const fetchSpy = vi.fn(async () =>
         jsonResponse({ claimedCount: 1, message: 'Prize recorded!' })
       )
@@ -64,8 +64,10 @@ describe('useScannerApi', () => {
       await claimPrizeForContestant('test-uuid-456', 10000015)
 
       expect(fetchSpy).toHaveBeenCalledOnce()
-      const url: string = fetchSpy.mock.calls[0][0]
-      expect(url).toBe("/scanner/claimPrizeForContestant(accountNumber='test-uuid-456',eventId=10000015)")
+      const [url, init]: [string, RequestInit] = fetchSpy.mock.calls[0] as any
+      expect(url).toBe('/scanner/claimPrizeForContestant')
+      expect(init.method).toBe('POST')
+      expect(JSON.parse(init.body as string)).toEqual({ accountNumber: 'test-uuid-456', eventId: 10000015 })
     })
 
     it('returns claimedCount and message from the response', async () => {
diff --git a/hugo-apps/src/scanner-vue/__tests__/scanner-coercion.test.ts b/hugo-apps/src/scanner-vue/__tests__/scanner-coercion.test.ts
new file mode 100644
index 000000000..976e76b19
--- /dev/null
+++ b/hugo-apps/src/scanner-vue/__tests__/scanner-coercion.test.ts
@@ -0,0 +1,32 @@
+// #badge-v2 — the API layer must coerce missing/null numeric fields to 0 so the
+// card never renders "null of 2" (the bug) and defaults claimedPrizeNames to [].
+
+import { describe, expect, it } from 'vitest'
+import { normalizeContestant } from '../useScannerApi'
+
+describe('normalizeContestant coercion (#badge-v2)', () => {
+  it('coerces null claimedCount and completion counts to 0', () => {
+    const r = normalizeContestant({ claimedCount: null, tutorialsCompleted: null })
+    expect(r.claimedCount).toBe(0)
+    expect(r.tutorialsCompleted).toBe(0)
+    expect(r.groupsCompleted).toBe(0)
+    expect(r.missionsCompleted).toBe(0)
+  })
+
+  it('defaults claimedPrizeNames to an empty array when missing', () => {
+    const r = normalizeContestant({})
+    expect(r.claimedPrizeNames).toEqual([])
+  })
+
+  it('preserves real values', () => {
+    const r = normalizeContestant({
+      lastName: 'Jung', firstInitial: 'T', claimedCount: 2,
+      claimedPrizeNames: ['Sticker Pack'], tutorialsCompleted: 5,
+    })
+    expect(r.lastName).toBe('Jung')
+    expect(r.firstInitial).toBe('T')
+    expect(r.claimedCount).toBe(2)
+    expect(r.claimedPrizeNames).toEqual(['Sticker Pack'])
+    expect(r.tutorialsCompleted).toBe(5)
+  })
+})
diff --git a/hugo-apps/src/scanner-vue/scan-order.ts b/hugo-apps/src/scanner-vue/scan-order.ts
new file mode 100644
index 000000000..cef15f517
--- /dev/null
+++ b/hugo-apps/src/scanner-vue/scan-order.ts
@@ -0,0 +1,19 @@
+// #badge-v2 — camera scan ordering helper.
+//
+// The <video ref="videoRef"> lives only in the v-if="state==='scanning'"
+// branch, so it is not in the DOM until Vue has rendered that branch. The
+// camera scanner reads videoRef.value synchronously; calling it in the same
+// tick as the state change reads a null ref and throws "Video element not
+// available", tearing the camera down. Awaiting nextTick between the state
+// change and the scan lets Vue mount the <video> first.
+//
+// Extracted so the ordering is unit-testable without mounting the component.
+export async function beginScan(
+  setState: (s: 'scanning') => void,
+  nextTickFn: () => Promise<void>,
+  scanFn: () => Promise<string | null>,
+): Promise<string | null> {
+  setState('scanning')
+  await nextTickFn()
+  return scanFn()
+}
diff --git a/hugo-apps/src/scanner-vue/types.ts b/hugo-apps/src/scanner-vue/types.ts
index cc97928db..f9a687513 100644
--- a/hugo-apps/src/scanner-vue/types.ts
+++ b/hugo-apps/src/scanner-vue/types.ts
@@ -12,9 +12,24 @@ export interface ContestantData {
   eventId: number
   recordId: string
   status: string
+  lastName: string
+  firstInitial: string
   tutorialsCompleted: number
   groupsCompleted: number
   missionsCompleted: number
   prizeRecords: string
   claimedCount: number
+  claimedPrizeNames: string[]
+}
+
+export interface EventStats {
+  eventName: string | null
+  prizesClaimed: number
+  prizesAvailable: number
+  earnedAwaitingHandover: number
+  participants: number
+  participantsClaimed: number
+  tutorialsCompleted: number
+  groupsCompleted: number
+  missionsCompleted: number
 }
diff --git a/hugo-apps/src/scanner-vue/useScannerApi.ts b/hugo-apps/src/scanner-vue/useScannerApi.ts
index 2693c9e56..c5d6dbf75 100644
--- a/hugo-apps/src/scanner-vue/useScannerApi.ts
+++ b/hugo-apps/src/scanner-vue/useScannerApi.ts
@@ -1,5 +1,39 @@
 import { ref } from 'vue'
-import type { ContestantData } from './types'
+import type { ContestantData, EventStats } from './types'
+
+const toNum = (v: unknown): number => {
+  const n = Number(v)
+  return Number.isFinite(n) ? n : 0
+}
+
+// Coerce the raw getContestant payload so missing/null numerics render 0 (never
+// "null of 2") and claimedPrizeNames is always an array.
+export function normalizeContestant(raw: Partial<ContestantData> & Record<string, unknown>): ContestantData {
+  return {
+    uid: String(raw.uid ?? ''),
+    eventId: toNum(raw.eventId),
+    recordId: String(raw.recordId ?? ''),
+    status: String(raw.status ?? ''),
+    lastName: String(raw.lastName ?? ''),
+    firstInitial: String(raw.firstInitial ?? ''),
+    tutorialsCompleted: toNum(raw.tutorialsCompleted),
+    groupsCompleted: toNum(raw.groupsCompleted),
+    missionsCompleted: toNum(raw.missionsCompleted),
+    prizeRecords: String(raw.prizeRecords ?? ''),
+    claimedCount: toNum(raw.claimedCount),
+    claimedPrizeNames: Array.isArray(raw.claimedPrizeNames) ? raw.claimedPrizeNames.map(String) : [],
+  }
+}
+
+// claimPrizeForContestant is an OData v4 `action` → POST with params in the body.
+// (A function-style GET with params in the URL is not served by an action.)
+export function claimRequest(uid: string, eventId: number): { url: string; method: 'POST'; body: { accountNumber: string; eventId: number } } {
+  return {
+    url: '/scanner/claimPrizeForContestant',
+    method: 'POST',
+    body: { accountNumber: uid, eventId },
+  }
+}
 
 export function useScannerApi() {
   const loading = ref(false)
@@ -16,22 +50,35 @@ export function useScannerApi() {
         throw new Error(body.error?.message || `HTTP ${res.status}`)
       }
       const json = await res.json()
-      return json.value ?? json
+      return normalizeContestant(json.value ?? json)
     } finally {
       loading.value = false
     }
   }
 
+  async function getEventStats(eventId: number): Promise<EventStats> {
+    const res = await fetch(`/scanner/getEventStats(eventId=${eventId})`)
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}))
+      throw new Error(body.error?.message || `HTTP ${res.status}`)
+    }
+    const json = await res.json()
+    return json.value ?? json
+  }
+
   async function claimPrizeForContestant(uid: string, eventId: number): Promise<{ claimedCount: number; message: string }> {
     loading.value = true
     error.value = null
     try {
-      const res = await fetch(
-        `/scanner/claimPrizeForContestant(accountNumber='${encodeURIComponent(uid)}',eventId=${eventId})`
-      )
+      const { url, method, body } = claimRequest(uid, eventId)
+      const res = await fetch(url, {
+        method,
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      })
       if (!res.ok) {
-        const body = await res.json().catch(() => ({}))
-        throw new Error(body.error?.message || `HTTP ${res.status}`)
+        const errBody = await res.json().catch(() => ({}))
+        throw new Error(errBody.error?.message || `HTTP ${res.status}`)
       }
       const json = await res.json()
       return json.value ?? json
@@ -46,5 +93,5 @@ export function useScannerApi() {
     loading.value = false
   }
 
-  return { loading, error, contestant, getContestant, claimPrizeForContestant, reset }
+  return { loading, error, contestant, getContestant, getEventStats, claimPrizeForContestant, reset }
 }
diff --git a/srv/scanner-service.cds b/srv/scanner-service.cds
index 082599bc8..06923cea9 100644
--- a/srv/scanner-service.cds
+++ b/srv/scanner-service.cds
@@ -5,10 +5,13 @@ using { com.sap.developers.ims as ims } from '../db/schema';
 service ScannerService {
 
   function getContestant(accountNumber : String, eventId : Integer) returns {
+    lastName           : String;
+    firstInitial       : String;
     tutorialsCompleted : Integer;
     groupsCompleted    : Integer;
     missionsCompleted  : Integer;
     claimedCount       : Integer;
+    claimedPrizeNames  : array of String;
     prizeRecords       : String;
   };
 
@@ -23,4 +26,19 @@ service ScannerService {
   // Returns the resulting claimedCount and a message.
   action claimPrizeForContestant(accountNumber : String, eventId : Integer)
     returns { claimedCount : Integer; message : String };
+
+  // #badge-v2: per-event aggregate for the badge scanner's event-stats panel.
+  // Scoped on TaskRecords.event_ID (badge/app-space path). Unresolvable eventId
+  // returns a zeroed shape (eventName null), never rejects.
+  function getEventStats(eventId : Integer) returns {
+    eventName              : String;
+    prizesClaimed          : Integer;
+    prizesAvailable        : Integer;
+    earnedAwaitingHandover : Integer;
+    participants           : Integer;
+    participantsClaimed    : Integer;
+    tutorialsCompleted     : Integer;
+    groupsCompleted        : Integer;
+    missionsCompleted      : Integer;
+  };
 }
diff --git a/srv/scanner-service.js b/srv/scanner-service.js
index 58522bbe0..d3948d996 100644
--- a/srv/scanner-service.js
+++ b/srv/scanner-service.js
@@ -13,17 +13,31 @@ export default class ScannerService extends cds.ApplicationService {
       if (!accountNumber) return req.reject(400, 'accountNumber is required');
 
       // accountNumber now carries the user's UUID (string ID), not a numeric legacyId.
-      const user = await SELECT.one.from(Users).where({ ID: accountNumber });
+      const user = await SELECT.one.from(Users).columns('ID', 'firstName', 'lastName').where({ ID: accountNumber });
       if (!user) return req.reject(404, `User not found: ${accountNumber}`);
 
+      const lastName = user.lastName || '';
+      const firstInitial = (user.firstName || '').trim().charAt(0).toUpperCase();
+
+      // Resolve event by legacyId when provided; use its UUID for the event_ID filter.
+      let eventFilter = null;
+      if (eventId != null) {
+        const event = await SELECT.one.from(Events).where({ legacyId: eventId });
+        if (event) eventFilter = event.ID;
+      }
+
       // "Has-ever-completed" semantic (issue #600): a SUPERSEDED row is a prior
       // completion that was reset, so it still counts. DISTINCT by
       // (user_ID, taskLegacyId) so a user who reset + re-completed the same
-      // task is counted once, not twice.
-      const taskRecords = await SELECT.from(TaskRecords).where({
+      // task is counted once, not twice. Scoped to the scanned event (#badge-v2)
+      // so the card's counts match the event-stats panel; falls back to all
+      // events when the eventId is absent/unresolvable.
+      const taskFilter = {
         user_ID: user.ID,
         status: { in: ['COMPLETED', 'SUPERSEDED'] }
-      });
+      };
+      if (eventFilter) taskFilter.event_ID = eventFilter;
+      const taskRecords = await SELECT.from(TaskRecords).where(taskFilter);
 
       const seenByType = { TUTORIAL: new Set(), GROUP: new Set(), MISSION: new Set() };
       for (const r of taskRecords) {
@@ -34,22 +48,79 @@ export default class ScannerService extends cds.ApplicationService {
       const groupsCompleted = seenByType.GROUP.size;
       const missionsCompleted = seenByType.MISSION.size;
 
-      // Resolve event by legacyId when provided; use its UUID for the event_ID filter.
-      let eventFilter = null;
-      if (eventId != null) {
-        const event = await SELECT.one.from(Events).where({ legacyId: eventId });
-        if (event) eventFilter = event.ID;
-      }
-
       // Count CLAIMED PrizeRecords for this user, scoped to the event when resolvable.
       const prizeFilter = { user_ID: user.ID, status: 'CLAIMED' };
       if (eventFilter) prizeFilter.event_ID = eventFilter;
-      const prizeRecs = await SELECT.from(PrizeRecords).where(prizeFilter);
+      const prizeRecs = await SELECT.from(PrizeRecords).columns('ID', 'prize_ID').where(prizeFilter);
 
       const claimedCount = prizeRecs.length;
       const prizeRecords = `${claimedCount} of 2 prizes claimed`;
 
-      return { tutorialsCompleted, groupsCompleted, missionsCompleted, claimedCount, prizeRecords };
+      // Resolve names of the claimed prizes. Rows with a real prize association
+      // yield the prize name; null-prize rows (new-flow handovers) fall back to
+      // a generic label so the list length always tracks claimedCount.
+      const prizeIds = prizeRecs.map(r => r.prize_ID).filter(Boolean);
+      const nameById = {};
+      if (prizeIds.length) {
+        const prizes = await SELECT.from(Prizes).columns('ID', 'name').where({ ID: { in: prizeIds } });
+        for (const p of prizes) nameById[p.ID] = p.name;
+      }
+      const claimedPrizeNames = prizeRecs.map(r => (r.prize_ID && nameById[r.prize_ID]) || 'Prize');
+
+      return { lastName, firstInitial, tutorialsCompleted, groupsCompleted, missionsCompleted, claimedCount, claimedPrizeNames, prizeRecords };
+    });
+
+    // #badge-v2 — per-event aggregate for the scanner's event-stats panel.
+    // Event scoping = TaskRecords.event_ID (badge/app-space path), NOT the
+    // Devtoberfest date-window. Completion totals use the same has-ever-completed
+    // DISTINCT-by-(user_ID, taskLegacyId) semantic as getContestant. CQL only.
+    this.on('getEventStats', async (req) => {
+      const { eventId } = req.data;
+      const zero = {
+        eventName: null, prizesClaimed: 0, prizesAvailable: 0, earnedAwaitingHandover: 0,
+        participants: 0, participantsClaimed: 0,
+        tutorialsCompleted: 0, groupsCompleted: 0, missionsCompleted: 0,
+      };
+      if (eventId == null) return zero;
+
+      const event = await SELECT.one.from(Events).columns('ID', 'name').where({ legacyId: eventId });
+      if (!event) return zero;
+
+      const prizeRecs = await SELECT.from(PrizeRecords)
+        .columns('user_ID', 'status')
+        .where({ event_ID: event.ID });
+      let prizesClaimed = 0, earnedAwaitingHandover = 0;
+      const claimers = new Set();
+      for (const r of prizeRecs) {
+        if (r.status === 'CLAIMED') { prizesClaimed++; claimers.add(r.user_ID); }
+        else if (r.status === 'EARNED') { earnedAwaitingHandover++; }
+      }
+
+      const prizesAvailable = (await SELECT.from(Prizes).columns('ID').where({ event_ID: event.ID })).length;
+
+      // Completions scoped to the event; DISTINCT by (user_ID, taskLegacyId).
+      const taskRecords = await SELECT.from(TaskRecords)
+        .columns('user_ID', 'taskType', 'taskLegacyId')
+        .where({ event_ID: event.ID, status: { in: ['COMPLETED', 'SUPERSEDED'] } });
+      const seenByType = { TUTORIAL: new Set(), GROUP: new Set(), MISSION: new Set() };
+      const participantSet = new Set();
+      for (const r of taskRecords) {
+        participantSet.add(r.user_ID);
+        const set = seenByType[r.taskType];
+        if (set) set.add(`${r.user_ID}|${r.taskLegacyId}`);
+      }
+
+      return {
+        eventName: event.name,
+        prizesClaimed,
+        prizesAvailable,
+        earnedAwaitingHandover,
+        participants: participantSet.size,
+        participantsClaimed: claimers.size,
+        tutorialsCompleted: seenByType.TUTORIAL.size,
+        groupsCompleted: seenByType.GROUP.size,
+        missionsCompleted: seenByType.MISSION.size,
+      };
     });
 
     // Task 6 — atomic capped handover (max 2 CLAIMED per user+event).
diff --git a/test/unit/scanner-contestant-count.test.js b/test/unit/scanner-contestant-count.test.js
index e3ae77937..27a43c5da 100644
--- a/test/unit/scanner-contestant-count.test.js
+++ b/test/unit/scanner-contestant-count.test.js
@@ -84,3 +84,80 @@ describe('ScannerService.getContestant — UUID lookup + event-scoped count', ()
     ).rejects.toThrow(/User not found/);
   });
 });
+
+describe('ScannerService.getContestant — identity + claimed prize names (#badge-v2)', () => {
+  const USER_UUID    = 'uuid-id-1';
+  const BLANK_UUID   = 'uuid-id-blank';
+  const EVENT_LEGACY = 9911;
+
+  beforeEach(async () => {
+    const { Users, Events, Prizes, PrizeRecords, TaskRecords } = cds.entities('com.sap.developers.ims');
+    await DELETE.from(PrizeRecords);
+    await DELETE.from(TaskRecords);
+    await DELETE.from(Prizes);
+    await DELETE.from(Events);
+    await DELETE.from(Users);
+
+    await INSERT.into(Users).entries([
+      { ID: USER_UUID,  uuid: USER_UUID,  sapId: 'sap-i1', firstName: 'Thomas', lastName: 'Jung' },
+      { ID: BLANK_UUID, uuid: BLANK_UUID, sapId: 'sap-i2', firstName: '',       lastName: 'Solo' },
+    ]);
+
+    await INSERT.into(Events).entries([
+      { ID: 'evt-id-main',  legacyId: EVENT_LEGACY, name: 'Identity Event' },
+      { ID: 'evt-id-other', legacyId: 9912,         name: 'Other Event' },
+    ]);
+
+    await INSERT.into(Prizes).entries([
+      { ID: 'prize-sticker', name: 'Sticker Pack', event_ID: 'evt-id-main' },
+    ]);
+
+    // 1 CLAIMED prize with a real prize association → name must resolve.
+    await INSERT.into(PrizeRecords).entries([
+      { ID: 'pr-id-1', user_ID: USER_UUID, event_ID: 'evt-id-main', prize_ID: 'prize-sticker', status: 'CLAIMED', legacyId: 89001 },
+    ]);
+
+    // 2 TUTORIAL completions on the scanned event, 1 on a DIFFERENT event.
+    // Card counts must be event-scoped → the other-event row must NOT count.
+    await INSERT.into(TaskRecords).entries([
+      { ID: 'tr-id-1', user_ID: USER_UUID, taskType: 'TUTORIAL', taskLegacyId: 11, status: 'COMPLETED', event_ID: 'evt-id-main' },
+      { ID: 'tr-id-2', user_ID: USER_UUID, taskType: 'TUTORIAL', taskLegacyId: 12, status: 'COMPLETED', event_ID: 'evt-id-main' },
+      { ID: 'tr-id-x', user_ID: USER_UUID, taskType: 'TUTORIAL', taskLegacyId: 99, status: 'COMPLETED', event_ID: 'evt-id-other' },
+    ]);
+  });
+
+  it('returns lastName and a single first initial', async () => {
+    const scanner = await cds.connect.to('ScannerService');
+    const result = await scanner.tx({ user: new cds.User.Privileged() }, tx =>
+      tx.send({ event: 'getContestant', data: { accountNumber: USER_UUID, eventId: EVENT_LEGACY } })
+    );
+    expect(result.lastName).toBe('Jung');
+    expect(result.firstInitial).toBe('T');
+  });
+
+  it('returns an empty firstInitial when firstName is blank (no throw)', async () => {
+    const scanner = await cds.connect.to('ScannerService');
+    const result = await scanner.tx({ user: new cds.User.Privileged() }, tx =>
+      tx.send({ event: 'getContestant', data: { accountNumber: BLANK_UUID, eventId: EVENT_LEGACY } })
+    );
+    expect(result.lastName).toBe('Solo');
+    expect(result.firstInitial).toBe('');
+  });
+
+  it('resolves claimed prize names for the scoped event', async () => {
+    const scanner = await cds.connect.to('ScannerService');
+    const result = await scanner.tx({ user: new cds.User.Privileged() }, tx =>
+      tx.send({ event: 'getContestant', data: { accountNumber: USER_UUID, eventId: EVENT_LEGACY } })
+    );
+    expect(result.claimedPrizeNames).toEqual(['Sticker Pack']);
+  });
+
+  it('scopes completion counts to the scanned event (#badge-v2)', async () => {
+    // 2 TUTORIAL on this event + 1 on another event → card shows 2, not 3.
+    const scanner = await cds.connect.to('ScannerService');
+    const result = await scanner.tx({ user: new cds.User.Privileged() }, tx =>
+      tx.send({ event: 'getContestant', data: { accountNumber: USER_UUID, eventId: EVENT_LEGACY } })
+    );
+    expect(result.tutorialsCompleted).toBe(2);
+  });
+});
diff --git a/test/unit/scanner-event-stats.test.js b/test/unit/scanner-event-stats.test.js
new file mode 100644
index 000000000..88801d0b5
--- /dev/null
+++ b/test/unit/scanner-event-stats.test.js
@@ -0,0 +1,88 @@
+// #badge-v2 — ScannerService.getEventStats: per-event aggregate for the badge scanner.
+// Scopes on TaskRecords.event_ID (badge/app-space path), has-ever-completed DISTINCT
+// semantic, CLAIMED vs EARNED vs Prizes catalog. Cross-event rows must not leak.
+
+import { beforeEach, describe, expect, it } from 'vitest';
+import cds from '@sap/cds';
+
+cds.test('serve', '--project', '.', '--in-memory');
+
+describe('ScannerService.getEventStats (#badge-v2)', () => {
+  const EVENT_LEGACY = 9921;
+  const OTHER_LEGACY = 9922;
+  const USER_A = 'uuid-es-a';
+  const USER_B = 'uuid-es-b';
+
+  beforeEach(async () => {
+    const { Users, Events, Prizes, PrizeRecords, TaskRecords } = cds.entities('com.sap.developers.ims');
+    await DELETE.from(PrizeRecords);
+    await DELETE.from(TaskRecords);
+    await DELETE.from(Prizes);
+    await DELETE.from(Events);
+    await DELETE.from(Users);
+
+    await INSERT.into(Users).entries([
+      { ID: USER_A, uuid: USER_A, sapId: 'sap-a' },
+      { ID: USER_B, uuid: USER_B, sapId: 'sap-b' },
+    ]);
+    await INSERT.into(Events).entries([
+      { ID: 'evt-es-main',  legacyId: EVENT_LEGACY, name: 'Stats Event' },
+      { ID: 'evt-es-other', legacyId: OTHER_LEGACY, name: 'Other' },
+    ]);
+    // 3 prizes available on main event.
+    await INSERT.into(Prizes).entries([
+      { ID: 'pz1', name: 'P1', event_ID: 'evt-es-main' },
+      { ID: 'pz2', name: 'P2', event_ID: 'evt-es-main' },
+      { ID: 'pz3', name: 'P3', event_ID: 'evt-es-main' },
+    ]);
+    // main: 2 CLAIMED (A,B) + 1 EARNED (A); other: 1 CLAIMED (must not count).
+    await INSERT.into(PrizeRecords).entries([
+      { ID: 'prA-c', user_ID: USER_A, event_ID: 'evt-es-main',  prize_ID: 'pz1', status: 'CLAIMED', legacyId: 90001 },
+      { ID: 'prB-c', user_ID: USER_B, event_ID: 'evt-es-main',  prize_ID: 'pz2', status: 'CLAIMED', legacyId: 90002 },
+      { ID: 'prA-e', user_ID: USER_A, event_ID: 'evt-es-main',  prize_ID: 'pz3', status: 'EARNED',  legacyId: 90003 },
+      { ID: 'prB-o', user_ID: USER_B, event_ID: 'evt-es-other', prize_ID: null,  status: 'CLAIMED', legacyId: 90004 },
+    ]);
+    // Completions on main: A=2 distinct TUTORIAL + 1 GROUP; B=1 TUTORIAL.
+    // One TUTORIAL for A on OTHER event — must not count.
+    await INSERT.into(TaskRecords).entries([
+      { ID: 'trA1', user_ID: USER_A, taskType: 'TUTORIAL', taskLegacyId: 1, status: 'COMPLETED', event_ID: 'evt-es-main' },
+      { ID: 'trA2', user_ID: USER_A, taskType: 'TUTORIAL', taskLegacyId: 2, status: 'SUPERSEDED', event_ID: 'evt-es-main' },
+      { ID: 'trA3', user_ID: USER_A, taskType: 'GROUP',    taskLegacyId: 3, status: 'COMPLETED', event_ID: 'evt-es-main' },
+      { ID: 'trB1', user_ID: USER_B, taskType: 'TUTORIAL', taskLegacyId: 1, status: 'COMPLETED', event_ID: 'evt-es-main' },
+      { ID: 'trAx', user_ID: USER_A, taskType: 'TUTORIAL', taskLegacyId: 9, status: 'COMPLETED', event_ID: 'evt-es-other' },
+    ]);
+  });
+
+  const call = (eventId) =>
+    cds.connect.to('ScannerService').then(s =>
+      s.tx({ user: new cds.User.Privileged() }, tx => tx.send({ event: 'getEventStats', data: { eventId } }))
+    );
+
+  it('aggregates prizes, participation, and completions for the event', async () => {
+    const r = await call(EVENT_LEGACY);
+    expect(r.eventName).toBe('Stats Event');
+    expect(r.prizesClaimed).toBe(2);
+    expect(r.prizesAvailable).toBe(3);
+    expect(r.earnedAwaitingHandover).toBe(1);
+    expect(r.participants).toBe(2);
+    expect(r.participantsClaimed).toBe(2);
+    expect(r.tutorialsCompleted).toBe(3);
+    expect(r.groupsCompleted).toBe(1);
+    expect(r.missionsCompleted).toBe(0);
+  });
+
+  it('does not leak rows from a different event', async () => {
+    const r = await call(OTHER_LEGACY);
+    expect(r.prizesClaimed).toBe(1);
+    expect(r.prizesAvailable).toBe(0);
+    expect(r.tutorialsCompleted).toBe(1);
+  });
+
+  it('returns a zeroed shape for an unresolvable event (no throw)', async () => {
+    const r = await call(999999);
+    expect(r.eventName).toBeNull();
+    expect(r.prizesClaimed).toBe(0);
+    expect(r.participants).toBe(0);
+    expect(r.tutorialsCompleted).toBe(0);
+  });
+});