chore(submodules): bump openfut-core -> 2fb8352 (match economy + club manager, pushed)

fix(clippy): use slice::from_ref instead of clone in sbc challenge test
style(fifa17): cargo fmt match wire + host match integration
2026-08-20 18:21:27 +00:00 · 2026-08-20 18:17:30 +00:00 · 2026-08-20 17:59:03 +00:00 · 2026-08-20 17:38:32 +00:00 · 2026-08-20 17:30:17 +00:00 · 2026-08-20 16:44:40 +00:00
45 changed files with 4957 additions and 885 deletions
@@ -0,0 +1,25 @@
+# OpenFUT Docker stack configuration. Copy to .env and adjust.
+# All values have sensible defaults in docker-compose.yml; override as needed.
+
+# --- Container registry (Gitea) ---
+# Images resolve to ${REGISTRY}/${NAMESPACE}/<image>:${TAG}
+# e.g. git.aleshym.co/openfut/openfut-core:latest
+REGISTRY=git.aleshym.co
+NAMESPACE=openfut
+TAG=latest
+
+# --- Networking ---
+# Where the bridge (FIFA client entry point) is published. 0.0.0.0 = all
+# interfaces so LAN clients can connect. Set to a specific IP to restrict.
+BRIDGE_PUBLISH=0.0.0.0
+# Where core's REST API is published. 127.0.0.1 keeps it host-local (the bridge
+# still reaches it over the internal docker network). Set 0.0.0.0 to expose it.
+CORE_PUBLISH=127.0.0.1
+
+# --- Behaviour ---
+# Bridge returns placeholder JSON + captures unknown routes when true.
+PLACEHOLDER_MODE=true
+
+# --- Logging (RUST_LOG filters) ---
+CORE_LOG=openfut_core=info,tower_http=info
+BRIDGE_LOG=openfut_bridge=info,tower_http=info
@@ -0,0 +1,163 @@
+# AGENTS.md — OpenFUT
+
+**Read this first.** It is the entry point for AI-assisted work on OpenFUT. It supersedes the
+root `README.md` and `CLAUDE.md`, which are **stale** (they describe an earlier FIFA 23 plan).
+
+## Project
+
+OpenFUT is a preservation / private-server project that restores **offline, single-player FIFA
+Ultimate Team (FUT)** after EA retired the online servers. You must own the game legitimately; the
+project does not bypass ownership checks — it only re-serves the dead online services locally.
+
+**Current active target: FIFA 17 (PC).** A clean-room emulation of the full online + FUT stack
+was proven working end-to-end on **2026-08-01** (auth → Blaze login → device-trust → FUT hub).
+This lives in `fifa17-recon/`. The FIFA 17 work is explicitly the **Rosetta Stone for FIFA 23**
+(identical Blaze/LSX/UTAS wire format), so FIFA 23 remains the eventual second target.
+
+Three moving parts, kept strictly separate:
+- **The FIFA client** — the retail game (FIFA 17 now). Unmodified except live cert-verify patches.
+- **The emulation layer** — Python responders in `fifa17-recon/tools/` (LSX, Blaze, UTAS, roster)
+  that impersonate EA's online services on localhost. This is where all reverse engineering lives.
+- **OpenFUT Core** — a game-independent REST FUT economy backend (`openfut-core/`), feature-complete
+  and tested. Knows nothing about FIFA. Intended to eventually back the emulation layer's FUT data.
+
+> The emulation layer and Core are **not yet wired together.** The FIFA 17 UTAS server currently
+> serves its own hardcoded/JSON payloads, not Core's API. See `docs/PROJECT_STATE.md`.
+
+## Repository map
+
+Monorepo. `openfut-core`, `openfut-bridge`, `openfut-launcher`, `fifa-blaze` are **git submodules**
+(each with independent history — use `tea`/Gitea, not `gh`). `fifa17-recon/` is a plain directory.
+
+| Path | What it is | Status |
+|---|---|---|
+| `fifa17-recon/` | **The live path.** FIFA 17 offline FUT emulation: Python responders, cert patcher, runbook, RE write-ups. | Working |
+| `openfut-core/` | Rust (Axum + SQLite) FUT economy backend. Game-independent REST API. | Working, tested |
+| `openfut-bridge/` | Rust FIFA 23 in-process hook / proxy RE effort. | Blocked (see below) |
+| `fifa-blaze/` | Rust Blaze protocol emulator scaffold for FIFA 23 (capture stub). | Milestone 1 stub |
+| `openfut-launcher/` | Rust egui/eframe desktop launcher (targets FIFA 23 hook flow). | Legacy plan |
+| `docs/` | **Mirrors** of the vault (`OpenFUT-Vault`), which is canonical. Direction pivots + context. | — |
+| `tools/` | Host-side RE helpers (file-watch-diff, exporters, squad-injector) from the FLE-bridge idea. | Legacy plan |
+| `setup.sh` | FIFA 23 full-stack orchestrator (core+bridge). | Legacy plan |
+
+**Legacy vs live:** the project pivoted twice — (1) FIFA 23 Blaze backend → (2) FIFA 23 as a match
+renderer driven by an FLE Lua bridge (`docs/direction.md`) → (3) **FIFA 17 full online emulation,
+which succeeded and is now the primary path** (`fifa17-recon/`). Treat `openfut-bridge`,
+`openfut-launcher`, `fifa-blaze`, `tools/`, `setup.sh`, and `docs/direction.md` as historical unless
+a task explicitly targets the FIFA 23 port.
+
+## Architecture (live path)
+
+```
+FIFA 17 client (Wine/Proton, base 0x140000000)
+  │  autopatch.py NOPs two ProtoSSL cert-verify gates in /proc/PID/mem
+  ├─ LSX  127.0.0.1:4216   → lsx_responder_v2.py     (Origin login/profile/authcode)
+  ├─ TLS  127.0.0.1:42127  → blaze_responder_v3b.py  (Blaze redirector, via DNAT of 159.153.51.20)
+  ├─ Blaze 42130 / Nucleus 42131 → blaze_responder_v3b.py (Fire2/Heat2 binary + login)
+  ├─ easw.easports.com (→127.0.0.1) :8099 → utas_server.py (UTAS/RS4 FUT API + device-trust)
+  └─ roster :8081 → roster_server.py (FUT roster-update XML)
+
+OpenFUT Core (openfut-core, :8080)  ── clean REST FUT economy ──  NOT YET CONNECTED to the above
+```
+
+Host arming (`root_arm.sh` via `pkexec`, volatile across reboot): `ptrace_scope=0`,
+`route_localnet=1`, iptables DNAT `159.153.51.20→127.0.0.1:42127`, `/etc/hosts easw.easports.com`.
+
+## Development commands (verified)
+
+**FIFA 17 emulation** (from `fifa17-recon/tools/`):
+- Start everything (idempotent; re-run after reboot): `./openfut-fut.sh start`
+- Status / stop / restart: `./openfut-fut.sh status | stop | restart`
+- Then launch the game fresh (`~/Desktop/launch-fifa17.sh`) and pick Ultimate Team.
+- Logs: `/tmp/{lsx,blaze,roster,utas,autopatch}.log`
+- Full procedure + gate-ladder troubleshooting: `fifa17-recon/FUT-RUNBOOK.md`
+
+**OpenFUT Core** (from `openfut-core/`): `cargo run` (creates `openfut.db`) · `cargo test`
+(full in-memory integration suite; requires `data/`) · `cargo test <name>` for one ·
+`cargo clippy -- -D warnings` · `cargo fmt`. Env: `LISTEN_ADDR` (127.0.0.1:8080), `DATABASE_URL`
+(sqlite://openfut.db), `DATA_DIR` (data).
+
+**Other Rust crates** (`openfut-bridge`, `fifa-blaze`, `openfut-launcher`): standard
+`cargo run/build/test/clippy/fmt` from within each. `fifa-blaze` is a workspace (`--bin blaze-server`).
+
+**CI:** only `openfut-core` has it (`.gitea/workflows/ci.yml`): `fmt --check`, `clippy -D warnings`,
+`build --locked`, `test --locked` on push/PR to main. No CI on the other crates or the recon dir.
+
+There is **no install step, no Docker, no JS/TS frontend, no typecheck** in this repo. Do not invent them.
+
+## Coding conventions
+
+- **Rust (Core):** Axum 0.7 + SQLx 0.7 (SQLite, compile-time-checked queries). Strict layering —
+  `routes/` (handlers, extract state, call services) → `services/` (own **all** DB access + logic)
+  → `models/` (pure `Serde`/`FromRow` data). Errors via `AppError` (`src/error.rs`) with
+  `IntoResponse`. One file per domain across `routes/`, `services/`, `models/`. **Single-profile
+  design:** every service reads "the active profile" as the first DB row — intentional, don't
+  parameterize it. Content is data-driven: JSON under `data/` loaded at startup into Arc registries
+  in `AppState`. Add content by dropping JSON files, not code. Migrations are numbered SQL in
+  `migrations/`. Keep `clippy -D warnings` and `fmt` clean (CI enforces).
+- **Python (recon):** stdlib-only servers, no framework. Each responder is a standalone script with
+  the reverse-engineered contract documented in its module docstring (byte offsets, VAs, symbol
+  names). When changing a responder, preserve byte-exactness — the client is the oracle.
+- **Clean-room, always.** Every finding derives from binaries we own + live observation. **Never**
+  use, reference, or reproduce leaked EA source. If a task seems to need it, stop and say so.
+
+## AI-agent rules
+
+1. Read this file before exploring the repo.
+2. Read the vault file relevant to the task (`../OpenFUT-Vault/`), not the whole tree. Repo
+   `docs/` files are mirrors of the vault — consult them for the same content, but treat the
+   vault as canonical.
+3. Don't scan the whole repository unless the knowledge base is clearly stale — if you find it
+   stale, update the vault, then its repo `docs/` mirror.
+4. Search the specific directory (`fifa17-recon/`, `openfut-core/src/<layer>/`) before a repo-wide search.
+5. Update the vault when architecture materially changes (and sync the matching `docs/` mirror).
+6. Don't refactor or rewrite unrelated working code.
+7. Prefer small, testable changes; run the narrowest relevant test first (`cargo test <name>`).
+8. **Never invent EA/FIFA/Blaze protocol behavior.** Values you don't know are `TODO/CONFIRM`, not
+   confident guesses. The live client is the only oracle for whether a gate is satisfied.
+9. Clearly separate discovered behavior from hypotheses; record findings in
+   `../OpenFUT-Vault/02 Reverse Engineering/FIFA 17/Protocol Findings.md` under the right confidence
+   tier — never silently promote a hypothesis to a fact.
+10. Root `README.md` / `CLAUDE.md` and `openfut-bridge/CLAUDE.md` describe superseded FIFA 23 plans;
+    prefer vault + repository evidence over them when they conflict.
+
+## AI Session Bootstrap
+
+Future agents should start with:
+1. Read `AGENTS.md`.
+2. Read the vault README (`../OpenFUT-Vault/README.md`) to locate the canonical files.
+3. Identify the subsystem the task affects and read the corresponding vault file: Architecture,
+   Project State, Roadmap/Current Priorities, or Protocol Findings.
+4. Inspect only the relevant source directories.
+5. Check `../OpenFUT-Vault/02 Reverse Engineering/FIFA 17/Protocol Findings.md` before assuming
+   anything about FIFA/EA behavior.
+6. Check `../OpenFUT-Vault/06 Agent Memory/Project State.md` before assuming a feature exists.
+7. Implement the smallest coherent change.
+8. Run the narrowest relevant tests.
+9. Update the vault (and its repo `docs/` mirror) only if the change makes existing knowledge
+   inaccurate.
+
+Do not reread the entire repository during every session.
+
+## OpenFUT Knowledge Base
+
+**The OpenFUT Vault is the canonical project knowledge base.** Repo `docs/` files mirror it; the
+vault wins on any disagreement. Consult it before starting substantial work and update it after
+durable discoveries.
+
+Vault location: `../OpenFUT-Vault/` — start at `../OpenFUT-Vault/README.md`.
+
+Canonical files:
+- Dashboard: `00 Dashboard/OpenFUT.md`
+- Architecture: `01 Architecture/Architecture.md` (repo mirror `docs/ARCHITECTURE.md`)
+- RE findings: `02 Reverse Engineering/FIFA 17/Protocol Findings.md`
+  (repo mirror `docs/research/KNOWN_FINDINGS.md`)
+- Direction history: `04 Decisions/Direction History.md`
+- Project State: `06 Agent Memory/Project State.md` (repo mirror `docs/PROJECT_STATE.md`)
+- Current Priorities: `06 Agent Memory/Current Priorities.md`
+- Known Issues: `06 Agent Memory/Known Issues.md`
+- Important Discoveries: `06 Agent Memory/Important Discoveries.md`
+- Roadmap: `08 Roadmap/Roadmap.md` (repo mirror `docs/ROADMAP.md`)
+
+When editing knowledge that exists in both places, edit the vault first, then update the matching
+`docs/` mirror so they stay in sync.
@@ -2,6 +2,8 @@

 This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

+> ⚠️ **Stale (FIFA 23).** This file's status and targets predate the FIFA 17 pivot. Prefer [`docs/PROJECT_STATE.md`](./docs/PROJECT_STATE.md) (canonical). The working target is **FIFA 17**; the canonical server is `fifa17-recon/docker/fifa17-python` (`docker compose up -d`). `openfut-bridge` (FIFA 23) is superseded; `openfut-core` remains the shared backend.
+
 ## Repository Layout

 This is a monorepo containing three independent Rust crates as git submodules:
@@ -3210,6 +3210,7 @@ dependencies = [
 "serde",
 "serde_json",
 "sqlx",
+ "tempfile",
 "thiserror 1.0.69",
 "tokio",
 "tower 0.5.3",
@@ -1,5 +1,9 @@
 # OpenFUT

+> ⚠️ **Status — see [`docs/PROJECT_STATE.md`](./docs/PROJECT_STATE.md) (canonical).** The working, actively-developed target is **FIFA 17**, not FIFA 23. Everything below this banner describes the **superseded FIFA 23 `bridge` lineage** and is kept for historical context.
+>
+> **Run the server (canonical):** `cd fifa17-recon/docker/fifa17-python && docker compose up -d` — see [`fifa17-recon/FUT-RUNBOOK.md`](./fifa17-recon/FUT-RUNBOOK.md). `openfut-core` is the shared offline backend (still used by the FIFA 17 path); `openfut-bridge` is the retired FIFA 23 integration.
+
 **Offline Ultimate Team — like SPT, but for FIFA 23.**

 OpenFUT replaces EA's retired FUT servers with a fully offline, single-player backend. You own FIFA 23 legitimately. You just want to keep playing after EA shut down the servers.
@@ -0,0 +1,93 @@
+# ============================================================================
+# ⚠️ LEGACY (FIFA 23 lineage). This compose runs core + bridge for the
+# superseded FIFA 23 direction. It is NOT the canonical server bring-up.
+#
+# Canonical server (FIFA 17):
+#   cd fifa17-recon/docker/fifa17-python && docker compose up -d
+#   (runbook: fifa17-recon/FUT-RUNBOOK.md)
+#
+# `core` (openfut-core) IS still the shared, game-independent backend and is
+# used by the FIFA 17 UTAS host (OPENFUT_CORE_URL). `bridge` (openfut-bridge)
+# is the retired FIFA 23 integration, kept for reference.
+# Status source of truth: docs/PROJECT_STATE.md
+# ============================================================================
+# OpenFUT server stack — offline FUT backend (Core) + FIFA proxy (Bridge).
+#
+#   Bring up:    docker compose up -d
+#   Tear down:   docker compose down            (keeps data/captures volumes)
+#   Wipe state:  docker compose down -v         (also drops volumes)
+#   Rebuild:     docker compose build           (or ./scripts/registry.sh build)
+#   Logs:        docker compose logs -f
+#
+# Images are pulled from / pushed to the Gitea container registry. Override the
+# registry, namespace, or tag in .env (see .env.example). When REGISTRY is set,
+# `up` pulls prebuilt images; the build: blocks let you rebuild locally too.
+
+name: openfut
+
+services:
+  core:
+    image: ${REGISTRY:-git.aleshym.co}/${NAMESPACE:-openfut}/openfut-core:${TAG:-latest}
+    build:
+      context: ./openfut-core
+      dockerfile: Dockerfile
+    restart: unless-stopped
+    environment:
+      LISTEN_ADDR: 0.0.0.0:8080
+      DATABASE_URL: sqlite:///app/db/openfut.db
+      DATA_DIR: /app/data
+      RUST_LOG: ${CORE_LOG:-openfut_core=info,tower_http=info}
+    volumes:
+      - core-db:/app/db
+    # Bound to localhost by default — the bridge reaches core over the internal
+    # network, so core need not be world-exposed. Set CORE_PUBLISH=0.0.0.0 in
+    # .env if you want to hit the REST API directly from other hosts.
+    ports:
+      - "${CORE_PUBLISH:-127.0.0.1}:8080:8080"
+    networks:
+      - openfut
+    healthcheck:
+      test: ["CMD", "curl", "-fsS", "http://127.0.0.1:8080/health"]
+      interval: 15s
+      timeout: 4s
+      retries: 5
+      start_period: 10s
+
+  bridge:
+    image: ${REGISTRY:-git.aleshym.co}/${NAMESPACE:-openfut}/openfut-bridge:${TAG:-latest}
+    build:
+      context: ./openfut-bridge
+      dockerfile: Dockerfile
+    restart: unless-stopped
+    depends_on:
+      core:
+        condition: service_healthy
+    environment:
+      BRIDGE_LISTEN_ADDR: 0.0.0.0:8443
+      CORE_URL: http://core:8080
+      CAPTURES_DIR: /app/captures
+      PLACEHOLDER_MODE: ${PLACEHOLDER_MODE:-true}
+      TLS_ENABLED: "true"
+      RUST_LOG: ${BRIDGE_LOG:-openfut_bridge=info,tower_http=info}
+    volumes:
+      - bridge-captures:/app/captures
+    # The FIFA client connects here — publish on all interfaces by default so
+    # LAN clients (e.g. 10.10.0.0/24) can reach it.
+    ports:
+      - "${BRIDGE_PUBLISH:-0.0.0.0}:8443:8443"
+    networks:
+      - openfut
+    healthcheck:
+      test: ["CMD", "curl", "-fsSk", "https://127.0.0.1:8443/_bridge/health"]
+      interval: 15s
+      timeout: 4s
+      retries: 5
+      start_period: 8s
+
+networks:
+  openfut:
+    driver: bridge
+
+volumes:
+  core-db:
+  bridge-captures:
@@ -9,3 +9,25 @@ OPENFUT_ADVERTISE=203.0.113.10   # <- REPLACE with this host's LAN IP
 # Defaults to 0.0.0.0 (container-facing); the original all-on-localhost flow
 # uses the loopback default baked into the responders when unset.
 OPENFUT_BIND=0.0.0.0
+
+# OPENFUT_SERVERS — which Python responders Docker runs (space/comma separated).
+# Default (unset) = the server-side set: "blaze roster utas pow".
+#
+# This host is the SERVER (.120). Docker runs ONLY components that have NOT been
+# migrated to a Rust host. During migration the Rust hosts (redirector / roster
+# / utas) run OUTSIDE Docker; as each Python component is replaced, remove its
+# name here so the two never serve the same role at once.
+#   blaze   Blaze redirector + main + nucleus (bundled)   :42127 :42130 :42131
+#   roster  FUT roster-update XML                         :8081
+#   utas    FUT/UTAS RS4 API                              :8099
+#           (Rust utas-host still proxies its non-/club routes here for now)
+#   pow     POW / EASFC                                   :8094 (+ content :8080)
+#   lsx     Origin LSX bootstrap                          :4216
+#           CLIENT-SIDE: LSX runs on the game machine (.105) with autopatch, NOT
+#           on this server. Leave it OUT unless client and server share one box.
+#
+# Example — Rust already owns roster, so Docker should not also serve it:
+#   OPENFUT_SERVERS=blaze utas pow
+# When you drop a component, also stop advertising / DNAT'ing its port to this
+# container so the client is routed to the Rust host instead.
+#OPENFUT_SERVERS=blaze roster utas pow
@@ -36,10 +36,14 @@ services:
      FUT_PROFILE_ROOT: "/state/accounts"
      FUT_SETTINGS: "off"
      FUT_MODES: "1"
+      # Which Python responders this SERVER runs. Default excludes lsx (that is
+      # a client-side responder — see below). Drop a name once it is migrated to
+      # a Rust host (run outside Docker) so the two never overlap. See .env.example.
+      OPENFUT_SERVERS: "${OPENFUT_SERVERS:-blaze roster utas pow}"
    volumes:
      - "../state:/state"
    ports:
-      - "4216:4216"      # LSX (Origin bootstrap)
+      - "4216:4216"      # LSX — CLIENT-SIDE (.105); only used if lsx is enabled for all-on-one-box
      - "42127:42127"    # Blaze redirector (TLS)
      - "42130:42130"    # Blaze main
      - "42131:42131"    # Nucleus OAuth stub
@@ -57,10 +57,40 @@ declare -a SERVERS=(
  "pow|pow_server.py|-"
 )

+# ── Component selection ──────────────────────────────────────────────────────
+# OPENFUT_SERVERS picks which Python responders run (space- or comma-separated).
+# This container is the SERVER side (.120). It serves ONLY components that have
+# NOT been migrated to a Rust host — as each moves to Rust (which runs OUTSIDE
+# Docker during migration), drop its name so the two never serve the same role.
+#   blaze   Blaze redirector + main + nucleus (bundled)   :42127 :42130 :42131
+#   roster  FUT roster-update XML                         :8081
+#   utas    FUT/UTAS RS4 API                              :8099
+#           (the Rust utas-host currently reverse-proxies its non-/club routes
+#            back here, so keep this enabled until UTAS is fully migrated)
+#   pow     POW / EASFC                                   :8094 (+ content :8080)
+#   lsx     Origin LSX bootstrap                          :4216
+#           CLIENT-SIDE — LSX runs on the game machine (.105) with autopatch,
+#           NOT on the server. Excluded by default; enable ONLY for an
+#           all-on-one-box dev setup where client and server share a host.
+OPENFUT_SERVERS="${OPENFUT_SERVERS:-blaze roster utas pow}"
+want=" ${OPENFUT_SERVERS//,/ } "
+known=" lsx blaze roster utas pow "
+for w in $want; do
+  case "$known" in
+    *" $w "*) ;;
+    *) echo "[openfut] unknown component '$w' in OPENFUT_SERVERS (valid: lsx blaze roster utas pow)" >&2; exit 2 ;;
+  esac
+done
+echo "[openfut] servers=$OPENFUT_SERVERS"
+
 pids=()
 names=()
 for entry in "${SERVERS[@]}"; do
  IFS='|' read -r name script env <<<"$entry"
+  case "$want" in
+    *" $name "*) ;;
+    *) echo "[openfut] skipping $name (not in OPENFUT_SERVERS)"; continue ;;
+  esac
  envprefix=""; [ "$env" != "-" ] && envprefix="env $env"
  echo "[openfut] starting $name ($script)"
  # shellcheck disable=SC2086
@@ -69,6 +99,11 @@ for entry in "${SERVERS[@]}"; do
  names+=("$name")
 done

+if [ "${#pids[@]}" -eq 0 ]; then
+  echo "[openfut] OPENFUT_SERVERS selected no components; nothing to run" >&2
+  exit 2
+fi
+
 # Propagate SIGTERM/SIGINT to children so `docker stop` is clean.
 term() {
  echo "[openfut] shutting down…"
@@ -424,6 +424,25 @@ Chemistry/rating/nation/league-count constraints (`teamChemistry 0x307`, `starRa
 generically as `{eligibilityKey, eligibilityOperation, eligibilityValue}` triples, **not** as
 named scalar fields on the record. **FREEZE-RISK: elgReq must be a JSON array of objects.**

+> **2026-08-19 — `eligibilityKey`/`eligibilityOperation` are LOCALIZATION ORDINALS, not the
+> atom hex ids above.** Reversed from the pinned CardsDLL (`4706a881…`). The client's sole
+> confirmed consumer of these fields is the requirement-display string builder at
+> `~0x1800ef900`: it loads the eligibility int fields (`0x148(rcx)`) and formats them through
+> *indexed localization keys* — `ELIGIBILITY_STRING%d` (`0x1802186b8`), `LOC_SBC_ELG_KEY_%d`
+> (`0x180226710`), `ELIGIBILITY_OPERATION` (`0x1802186e8`) — appending to a string builder via
+> vtable `*0x10`/`*0x20`. There is **no comparison/branch**: the client does not validate on
+> these ints, it renders `LOC_SBC_ELG_KEY_<eligibilityKey>` (and an operation string) as
+> display text. Therefore `eligibilityKey` is a small ordinal that indexes the **packed FIFA17
+> locale**, NOT `0x307`/`0x22f`/etc. (those hex values are the atom ids of the *named* fields
+> the encoding replaces, not the ordinal values). CONSEQUENCE: correct projection needs the
+> ordinal→locale-string map, which lives only in the packed locale (absent from CardsDLL and
+> every `fifa17-recon/data` file; a game-dir locale probe on the live client found none) or a
+> real EA `elgReq` capture (unavailable on a private server). Emitting a *guessed* ordinal
+> renders the WRONG requirement text to the player, so `elgReq` stays `[]` until the ordinal
+> map is recovered. This is a display-only gap: SBC submission is fully validated server-side
+> (Core), and an invalid squad's generic comms modal originates from the server 400, not from
+> the empty `elgReq`.
+
 **awards / grantedAwards** — nested array of reward objects (atoms: `rewardType 0x28e`,
 `rewardValue 0x28f`, `rewardQuantity 0x28d`, `rewardMultiplier 0x28c`, `awardCount 0x40`,
 `awardSet 0x45`, `awardSetId 0x46`, `prizeSet 0x253`). **FREEZE-RISK: must be array.**
@@ -55,6 +55,34 @@ verify_exports() {
  done
 }

+# Refuse any DLL that is not a FIFA-17-profile build.
+#
+# openfut-hook builds TWO mutually exclusive injection paths from one crate: the
+# default (FIFA 23) path installs getaddrinfo/connect/ProtoSSL/origin hooks, while
+# `--features fifa17` installs ONLY the FIFA-17-safe logic (module map, FIFA 17
+# cert-verify, SBC dispatch, store tab bind). Deploying a default-feature build
+# into FIFA 17 hijacks the login transport and the client reports "Unable to
+# connect to the EA servers", with none of the FIFA 17 repairs present.
+#
+# That exact mistake happened on 2026-08-19 (artifact 1c71a17a, hand-built without
+# the feature): two failed launches, diagnosed only by comparing embedded strings.
+# `build` below passes the feature, but a hand-built DLL can reach `stage`/`deploy`
+# via OPENFUT_FIFA17_HOOK_DLL, so assert the profile on the bytes themselves.
+verify_fifa17_profile() {
+  local dll=$1 marker
+  # Markers that MUST be present: the FIFA 17 target module and its repairs.
+  for marker in 'CardsDLL_Win64_retail.dll' 'SBC_DISPATCH'; do
+    grep -qaF -- "$marker" "$dll" ||
+      die "$dll is not a --features fifa17 build (missing $marker); refusing to stage/deploy"
+  done
+  # Markers that MUST be absent: the FIFA-23-only transport hooking.
+  for marker in 'getaddrinfo IAT patched' 'connect: inline-hooked' 'origin_spy'; do
+    if grep -qaF -- "$marker" "$dll"; then
+      die "$dll contains FIFA-23-only hook '$marker'; build with --features fifa17"
+    fi
+  done
+}
+
 verify_inputs() {
  command -v sha256sum >/dev/null || die "sha256sum is required"
  command -v x86_64-w64-mingw32-objdump >/dev/null ||
@@ -62,6 +90,7 @@ verify_inputs() {
  need_file "$hook_dll"
  need_file "$system_version"
  verify_pe64 "$hook_dll"
+  verify_fifa17_profile "$hook_dll"
 }

 inspect() {
@@ -129,6 +158,7 @@ deploy() {
  need_file "$manifest"
  verify_pe64 "$staged"
  verify_exports "$staged"
+  verify_fifa17_profile "$staged"
  local recorded actual
  recorded="$(awk -F= '$1=="artifact_sha256"{print $2}' "$manifest")"
  actual="$(sha256 "$staged")"
@@ -158,7 +188,7 @@ launch() {
  local trace_enabled=0
  local request_trace_enabled=0
  local notifier_trace_enabled=0
-  local commit_enabled=0
+  local dispatch_enabled=0
  case "$mode" in
    baseline)
      [[ "${OPENFUT_FIFA17_LAUNCH:-}" == "I_ACCEPT_M1_BASELINE_LAUNCH" ]] ||
@@ -177,14 +207,11 @@ launch() {
      request_trace_enabled=1
      notifier_trace_enabled=1
      ;;
-    commit)
-      [[ "${OPENFUT_FIFA17_COMMIT:-}" == "I_ACCEPT_POST_PARSE_READY_BYTE" ]] ||
-        die "launch-commit requires OPENFUT_FIFA17_COMMIT=I_ACCEPT_POST_PARSE_READY_BYTE"
-      hook_enabled=1
-      trace_enabled=1
+    dispatch)
+      [[ "${OPENFUT_FIFA17_DISPATCH:-}" == "I_ACCEPT_GUARDED_NATIVE_DISPATCH" ]] ||
+        die "launch-dispatch requires OPENFUT_FIFA17_DISPATCH=I_ACCEPT_GUARDED_NATIVE_DISPATCH"
      request_trace_enabled=1
-      notifier_trace_enabled=1
-      commit_enabled=1
+      dispatch_enabled=1
      ;;
    *) die "unknown launch mode: $mode" ;;
  esac
@@ -207,7 +234,7 @@ launch() {
  done
  mkdir -p "${wine_prefix}/dosdevices"
  ln -sfn /mnt "${wine_prefix}/dosdevices/w:"
-  note "Launching $mode mode (SBC_HOOK=$hook_enabled; SBC_TRACE=$trace_enabled; SBC_REQUEST_TRACE=$request_trace_enabled; SBC_NOTIFIER_TRACE=$notifier_trace_enabled; SBC_COMMIT=$commit_enabled); log=/tmp/fifa17-hook-m1-launch.log"
+  note "Launching $mode mode (SBC_HOOK=$hook_enabled; SBC_TRACE=$trace_enabled; SBC_REQUEST_TRACE=$request_trace_enabled; SBC_NOTIFIER_TRACE=$notifier_trace_enabled; SBC_DISPATCH=$dispatch_enabled); log=/tmp/fifa17-hook-m1-launch.log"
  cd "$game_dir"
  env \
    GAMEID=fifa17 \
@@ -218,8 +245,8 @@ launch() {
    OPENFUT_SBC_TRACE="$trace_enabled" \
    OPENFUT_SBC_REQUEST_TRACE="$request_trace_enabled" \
    OPENFUT_SBC_NOTIFIER_TRACE="$notifier_trace_enabled" \
-    OPENFUT_SBC_DISPATCH=0 \
-    OPENFUT_SBC_COMMIT="$commit_enabled" \
+    OPENFUT_SBC_DISPATCH="$dispatch_enabled" \
+    OPENFUT_SBC_DISPATCH_TRACE=0 \
    OPENFUT_SBC_ARM_ONLY=0 \
    OPENFUT_SBC_POPULATE=0 \
    umu-run _fifa17.exe 2>&1 | tee /tmp/fifa17-hook-m1-launch.log
@@ -227,7 +254,7 @@ launch() {

 usage() {
  cat <<'EOF'
-Usage: fifa17-hook-m1.sh [inspect|build|stage|deploy|launch|launch-resolve|launch-trace|launch-commit]
+Usage: fifa17-hook-m1.sh [inspect|build|stage|deploy|launch|launch-resolve|launch-trace|launch-dispatch]

  inspect  Read-only PE/hash/export preflight (default).
  build    Cross-build the inert FIFA17 hook, then run inspect.
@@ -240,11 +267,11 @@ Usage: fifa17-hook-m1.sh [inspect|build|stage|deploy|launch|launch-resolve|launc
           Start M2 resolve-only mode (guarded reads/logging, no detours/writes); requires:
           OPENFUT_FIFA17_RESOLVE=I_ACCEPT_M2_RESOLVE_LAUNCH
  launch-trace
-           Start the single M3 passive factory/deserializer trace; requires:
+           Start the M3-M6 passive parser/request/notifier trace; requires:
           OPENFUT_FIFA17_TRACE=I_ACCEPT_M3_PASSIVE_TRACE
-  launch-commit
-           Trace and arm the SBC cache only after a validated native parse; requires:
-           OPENFUT_FIFA17_COMMIT=I_ACCEPT_POST_PARSE_READY_BYTE
+  launch-dispatch
+           Trace and repair only a fully validated native status-999 completion; requires:
+           OPENFUT_FIFA17_DISPATCH=I_ACCEPT_GUARDED_NATIVE_DISPATCH

 Optional path overrides:
  OPENFUT_FIFA17_HOOK_DLL, OPENFUT_FIFA17_GAME_DIR,
@@ -260,7 +287,7 @@ case "${1:-inspect}" in
  launch) launch baseline ;;
  launch-resolve) launch resolve ;;
  launch-trace) launch trace ;;
-  launch-commit) launch commit ;;
+  launch-dispatch) launch dispatch ;;
  -h|--help|help) usage ;;
  *) usage >&2; die "unknown command: $1" ;;
 esac
@@ -379,7 +379,10 @@ mod tests {

    #[test]
    fn honest_zero_club_items_present() {
-        let g = global(&club_stats_body(&[player(90, false, None)], ContextField::Nation));
+        let g = global(&club_stats_body(
+            &[player(90, false, None)],
+            ContextField::Nation,
+        ));
        for atom in [
            "stadia",
            "balls",
@@ -411,7 +414,10 @@ mod tests {
            .filter(|r| r["contextId"] == 3 && r["contextValue"] == 13)
            .collect();
        assert_eq!(league_rows.len(), 6);
-        let gold = league_rows.iter().find(|r| r["type"] == "playersGold").unwrap();
+        let gold = league_rows
+            .iter()
+            .find(|r| r["type"] == "playersGold")
+            .unwrap();
        assert_eq!(gold["typeValue"], 1);

        // league screen -> team (teamid) buckets: players/kits/badgeDBid (3 rows).
@@ -2,52 +2,13 @@
 //!
 //! These translate FIFA 17 wire semantics into the generic amounts the host
 //! feeds to Core economy authority. They own NO state — Core owns balances and
-//! inventory; these are the FIFA-specific numbers/derivations. Values are the
-//! current OpenFUT economy (match rewards are the Python oracle's
-//! `MATCH_COINS`/`MATCH_PARTICIPATION` at production defaults); pack prices come
-//! from the Store catalogue.
+//! inventory; these are the FIFA-specific numbers/derivations. Pack prices come
+//! from the Store catalogue; the transfer-market fee is the FUT-era 5%.
+//!
+//! Match result mapping + reward-body shaping live in [`crate::fut::match_wire`].

 use crate::fut::store_catalog::pack_by_id;

-/// Normalized match outcome for reward purposes.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum MatchResult {
-    Win,
-    Draw,
-    Loss,
-}
-
-/// Participation award added to every match reward (oracle `MATCH_PARTICIPATION`
-/// default = 0).
-pub const MATCH_PARTICIPATION: i64 = 0;
-
-/// Per-result match coins (oracle `MATCH_COINS`: won 400 / draw 200 / loss 100).
-pub fn match_result_coins(result: MatchResult) -> i64 {
-    match result {
-        MatchResult::Win => 400,
-        MatchResult::Draw => 200,
-        MatchResult::Loss => 100,
-    }
-}
-
-/// Total match reward = per-result coins + participation.
-pub fn match_reward_total(result: MatchResult) -> i64 {
-    match_result_coins(result) + MATCH_PARTICIPATION
-}
-
-/// Derive the outcome from the match `endReason` enum (the oracle's primary
-/// signal, `_END_REASON`). Unknown/absent reasons default to `Draw`, matching
-/// the oracle's conservative default. Score-based derivation is a fallback the
-/// oracle also supports; the enum is authoritative when present.
-pub fn result_from_end_reason(end_reason: Option<&str>) -> MatchResult {
-    match end_reason.unwrap_or("").to_ascii_uppercase().as_str() {
-        "WIN" | "DNF_WIN" => MatchResult::Win,
-        "LOSS" | "QUIT" | "DNF" | "DNF_LOSS" => MatchResult::Loss,
-        // "DRAW", "DNF_DRAW", "NO_CONTEST", unknown -> draw.
-        _ => MatchResult::Draw,
-    }
-}
-
 /// The Store buy-now price for a pack id (`None` for unknown/owned-only packs,
 /// which are never purchasable).
 pub fn pack_price(pack_id: u64) -> Option<u64> {
@@ -100,24 +61,6 @@ pub fn seller_proceeds(gross: i64) -> i64 {
 mod tests {
    use super::*;

-    #[test]
-    fn match_rewards_match_oracle() {
-        assert_eq!(match_reward_total(MatchResult::Win), 400);
-        assert_eq!(match_reward_total(MatchResult::Draw), 200);
-        assert_eq!(match_reward_total(MatchResult::Loss), 100);
-    }
-
-    #[test]
-    fn end_reason_maps_to_outcome() {
-        assert_eq!(result_from_end_reason(Some("WIN")), MatchResult::Win);
-        assert_eq!(result_from_end_reason(Some("dnf_win")), MatchResult::Win);
-        assert_eq!(result_from_end_reason(Some("LOSS")), MatchResult::Loss);
-        assert_eq!(result_from_end_reason(Some("QUIT")), MatchResult::Loss);
-        assert_eq!(result_from_end_reason(Some("DRAW")), MatchResult::Draw);
-        assert_eq!(result_from_end_reason(None), MatchResult::Draw);
-        assert_eq!(result_from_end_reason(Some("weird")), MatchResult::Draw);
-    }
-
    #[test]
    fn pack_price_rejects_unknown_and_owned_only() {
        assert!(pack_price(1).is_some());
@@ -0,0 +1,251 @@
+//! FIFA 17 `/match` + `/match/end` wire ↔ Core match-economy mapping.
+//!
+//! This module owns the FIFA 17-specific match protocol: the `endReason` enum
+//! (wire atom 260), the `PUT …/match/end` payload shape, and the reward-response
+//! body. It is pure — no state, no Core calls. The host wires it to OpenFUT
+//! Core's authoritative `complete_match` transaction:
+//!
+//! 1. [`parse_match_end`] turns the client payload into a [`MatchEnd`].
+//! 2. [`MatchResult::core_token`] gives Core the canonical, game-independent
+//!    result string — Core never sees a FIFA `endReason`.
+//! 3. Core applies the economy exactly once and returns the authoritative coin
+//!    numbers, which the host renders back through [`reward_response`].
+//!
+//! Keeping every FIFA 17 constant here (never in Core) is the layering contract:
+//! a second title's adapter maps its own wire onto the same canonical tokens.
+
+use serde_json::{json, Value};
+
+/// Participation award added to every match reward. FIFA 17 economy parameter
+/// (oracle `MATCH_PARTICIPATION`, production default `0`). Core owns the coin
+/// balance; this is only the wire body's cosmetic `participationAward` field.
+pub const MATCH_PARTICIPATION: i64 = 0;
+
+/// Canonical match result. The FIFA 17 `endReason` enum (atom 260) is the
+/// AUTHORITATIVE source [STATIC_REVERSED]; this is the normalized shape the host
+/// forwards to Core.
+///
+/// * `Win` / `Draw` / `Loss` — a decided match.
+/// * `Dnf` — the reporting player abandoned/quit (`DNF`/`QUIT`). Economically a
+///   loss (LIVE_PROVEN: `endReason=DNF` → loss reward), tracked in its own Core
+///   statistics bucket.
+/// * `NoContest` — a voided match; zero economic effect.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MatchResult {
+    Win,
+    Draw,
+    Loss,
+    Dnf,
+    NoContest,
+}
+
+impl MatchResult {
+    /// The canonical Core result token — the ONLY match datum the adapter hands
+    /// Core. Matches `openfut_core::models::match_result::MatchResultKind`'s serde
+    /// representation exactly (`win`/`draw`/`loss`/`dnf`/`no_contest`).
+    pub fn core_token(self) -> &'static str {
+        match self {
+            MatchResult::Win => "win",
+            MatchResult::Draw => "draw",
+            MatchResult::Loss => "loss",
+            MatchResult::Dnf => "dnf",
+            MatchResult::NoContest => "no_contest",
+        }
+    }
+}
+
+/// Map the FIFA 17 `endReason` enum onto a canonical [`MatchResult`].
+///
+/// The enum is authoritative when present [STATIC_REVERSED]. `DNF`/`QUIT` are the
+/// reporting player's abandon (→ `Dnf`, loss economics, LIVE_PROVEN); the
+/// `DNF_WIN`/`DNF_DRAW`/`DNF_LOSS` variants carry a decided outcome (the opponent
+/// abandoned) and map to that outcome. `NO_CONTEST` voids the match. An
+/// absent/unknown reason is a conservative `Draw`, matching the oracle default.
+pub fn result_from_end_reason(end_reason: Option<&str>) -> MatchResult {
+    match end_reason.unwrap_or("").to_ascii_uppercase().as_str() {
+        "WIN" => MatchResult::Win,
+        "DRAW" => MatchResult::Draw,
+        "LOSS" => MatchResult::Loss,
+        "DNF" | "QUIT" => MatchResult::Dnf,
+        "DNF_WIN" => MatchResult::Win,
+        "DNF_DRAW" => MatchResult::Draw,
+        "DNF_LOSS" => MatchResult::Loss,
+        "NO_CONTEST" => MatchResult::NoContest,
+        _ => MatchResult::Draw,
+    }
+}
+
+/// A parsed `PUT …/match/end` payload: the fields the host needs to drive Core.
+/// Unknown fields are ignored.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MatchEnd {
+    /// The raw `endReason` string, if the client sent one.
+    pub end_reason: Option<String>,
+    /// Canonical result derived from `end_reason`.
+    pub result: MatchResult,
+    /// `matchReportId` from the payload (observed `0` on the live path).
+    pub match_report_id: i64,
+    /// Goals scored by the reporting player — `myMatchStats[0]` (goals is the
+    /// first of the 15 ints). Absent on `DNF`/`QUIT` (stats omitted) → `0`.
+    pub goals_for: i64,
+    /// Opponent goals — `opponentMatchStats[0]`. Absent on `DNF`/`QUIT` → `0`.
+    pub goals_against: i64,
+}
+
+/// Parse the FIFA 17 match-end body. Returns `None` for a body that is not a
+/// JSON object (malformed). A well-formed object with a missing/unknown
+/// `endReason` still parses — the result defaults to `Draw`.
+pub fn parse_match_end(body: &[u8]) -> Option<MatchEnd> {
+    let v: Value = serde_json::from_slice(body).ok()?;
+    if !v.is_object() {
+        return None;
+    }
+    let end_reason = v
+        .get("endReason")
+        .and_then(Value::as_str)
+        .map(str::to_string);
+    let result = result_from_end_reason(end_reason.as_deref());
+    let match_report_id = v.get("matchReportId").and_then(Value::as_i64).unwrap_or(0);
+    Some(MatchEnd {
+        end_reason,
+        result,
+        match_report_id,
+        goals_for: first_stat(&v, "myMatchStats"),
+        goals_against: first_stat(&v, "opponentMatchStats"),
+    })
+}
+
+/// `myMatchStats`/`opponentMatchStats` are 15 ints with goals first
+/// [STATIC_REVERSED]; the arrays are OMITTED on DNF/QUIT, so a missing array is
+/// `0` goals, not an error.
+fn first_stat(v: &Value, key: &str) -> i64 {
+    v.get(key)
+        .and_then(Value::as_array)
+        .and_then(|a| a.first())
+        .and_then(Value::as_i64)
+        .unwrap_or(0)
+}
+
+/// Build the FIFA 17 match-reward response body (the `destroy_match_body` shape,
+/// [STATIC_REVERSED]).
+///
+/// `all_coins` is Core's AUTHORITATIVE post-credit balance; `match_coins` is the
+/// amount Core granted for THIS match (mirrored into `gameModeAward.coins`, where
+/// the client reads it). Emits ONLY the reversed fields — it NEVER emits
+/// `bidTokens` or `qualifiedChampionEventId`, which are client freeze traps.
+pub fn reward_response(all_coins: i64, match_coins: i64) -> Value {
+    json!({
+        "allCoins": all_coins,
+        "matchCoins": match_coins,
+        "seasonCoins": 0,
+        "tournamentCoins": 0,
+        "boostConis": 0, // EA's misspelling (atom 96), preserved on the wire.
+        "participationAward": MATCH_PARTICIPATION,
+        "teamOfTournamentWinner": false,
+        "gameModeAward": { "coins": match_coins },
+    })
+}
+
+/// Build the FIFA 17 `POST …/match` create ack. Zero economic effect: it only
+/// hands the client a match id + start time. `id` doubles as the per-match
+/// identity the host later keys Core's exactly-once completion on.
+pub fn create_response(id: i64, start_epoch: i64) -> Value {
+    json!({
+        "startDateTime": start_epoch,
+        "reportIdEnabled": false,
+        "id": id,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_end_reason_maps_to_canonical_result() {
+        assert_eq!(result_from_end_reason(Some("WIN")), MatchResult::Win);
+        assert_eq!(result_from_end_reason(Some("DRAW")), MatchResult::Draw);
+        assert_eq!(result_from_end_reason(Some("LOSS")), MatchResult::Loss);
+        assert_eq!(result_from_end_reason(Some("DNF")), MatchResult::Dnf);
+        assert_eq!(result_from_end_reason(Some("QUIT")), MatchResult::Dnf);
+        assert_eq!(
+            result_from_end_reason(Some("NO_CONTEST")),
+            MatchResult::NoContest
+        );
+        assert_eq!(result_from_end_reason(Some("DNF_WIN")), MatchResult::Win);
+        assert_eq!(result_from_end_reason(Some("DNF_DRAW")), MatchResult::Draw);
+        assert_eq!(result_from_end_reason(Some("DNF_LOSS")), MatchResult::Loss);
+        // Case-insensitive.
+        assert_eq!(result_from_end_reason(Some("dnf_win")), MatchResult::Win);
+        // Unknown / absent → conservative draw.
+        assert_eq!(result_from_end_reason(Some("weird")), MatchResult::Draw);
+        assert_eq!(result_from_end_reason(None), MatchResult::Draw);
+    }
+
+    #[test]
+    fn core_tokens_match_core_serde() {
+        assert_eq!(MatchResult::Win.core_token(), "win");
+        assert_eq!(MatchResult::Draw.core_token(), "draw");
+        assert_eq!(MatchResult::Loss.core_token(), "loss");
+        assert_eq!(MatchResult::Dnf.core_token(), "dnf");
+        assert_eq!(MatchResult::NoContest.core_token(), "no_contest");
+    }
+
+    #[test]
+    fn parse_match_end_reads_reason_and_goals() {
+        let body = br#"{"matchReportId":7,"endReason":"WIN","myMatchStats":[3,1,2,0,0,0,0,0,0,0,0,0,0,0,0],"opponentMatchStats":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}"#;
+        let end = parse_match_end(body).expect("parses");
+        assert_eq!(end.result, MatchResult::Win);
+        assert_eq!(end.match_report_id, 7);
+        assert_eq!(end.goals_for, 3);
+        assert_eq!(end.goals_against, 1);
+    }
+
+    #[test]
+    fn parse_match_end_dnf_omits_stats_as_zero() {
+        // The live DNF payload: stats arrays omitted entirely.
+        let body = br#"{"matchReportId":0,"endReason":"DNF","items":[],"matchData":"","matchStatusFlags":0}"#;
+        let end = parse_match_end(body).expect("parses");
+        assert_eq!(end.result, MatchResult::Dnf);
+        assert_eq!(end.goals_for, 0);
+        assert_eq!(end.goals_against, 0);
+    }
+
+    #[test]
+    fn parse_match_end_unknown_reason_defaults_draw() {
+        let end = parse_match_end(br#"{"endReason":"BANANA"}"#).expect("parses");
+        assert_eq!(end.result, MatchResult::Draw);
+        assert_eq!(end.end_reason.as_deref(), Some("BANANA"));
+    }
+
+    #[test]
+    fn parse_match_end_rejects_malformed() {
+        assert!(parse_match_end(b"not json").is_none());
+        assert!(parse_match_end(b"[]").is_none());
+        assert!(parse_match_end(b"42").is_none());
+    }
+
+    #[test]
+    fn reward_response_has_only_reversed_fields() {
+        let body = reward_response(29_876_876, 100);
+        assert_eq!(body["allCoins"], 29_876_876);
+        assert_eq!(body["matchCoins"], 100);
+        assert_eq!(body["gameModeAward"]["coins"], 100);
+        assert_eq!(body["seasonCoins"], 0);
+        assert_eq!(body["tournamentCoins"], 0);
+        assert_eq!(body["boostConis"], 0);
+        assert_eq!(body["participationAward"], 0);
+        assert_eq!(body["teamOfTournamentWinner"], false);
+        // The freeze traps must never appear.
+        assert!(body.get("bidTokens").is_none());
+        assert!(body.get("qualifiedChampionEventId").is_none());
+    }
+
+    #[test]
+    fn create_response_shape() {
+        let body = create_response(100_004_838, 1_700_000_000);
+        assert_eq!(body["id"], 100_004_838);
+        assert_eq!(body["reportIdEnabled"], false);
+        assert_eq!(body["startDateTime"], 1_700_000_000);
+    }
+}
@@ -12,9 +12,11 @@ pub mod economy;
 pub mod economy_policy;
 pub mod entities;
 pub mod item;
+pub mod match_wire;
 pub mod non_economy;
 pub mod owned_query;
 pub mod pack_content;
+pub mod sbc;
 pub mod squad;
 pub mod squad_ext;
 pub mod squad_projection;
@@ -67,12 +67,19 @@ pub fn feature_off_body() -> Value {
 pub fn item_def(resource_id: i64) -> Value {
    let asset = resource_id & 0xff_ffff;
    // (name, rating, position, nation, leagueId, teamid, [6 attrs])
-    let (name, rating, pos, nation, league, team, attrs): (&str, i64, &str, i64, i64, i64, [i64; 6]) =
-        if asset == 20801 {
-            ("Ronaldo", 94, "ST", 38, 53, 243, [90, 93, 82, 91, 33, 80])
-        } else {
-            ("Player", 75, "CM", 0, 0, 0, [70, 70, 70, 70, 70, 70])
-        };
+    let (name, rating, pos, nation, league, team, attrs): (
+        &str,
+        i64,
+        &str,
+        i64,
+        i64,
+        i64,
+        [i64; 6],
+    ) = if asset == 20801 {
+        ("Ronaldo", 94, "ST", 38, 53, 243, [90, 93, 82, 91, 33, 80])
+    } else {
+        ("Player", 75, "CM", 0, 0, 0, [70, 70, 70, 70, 70, 70])
+    };
    let attribute_list: Vec<Value> = attrs
        .iter()
        .enumerate()
@@ -365,7 +372,11 @@ pub fn user_mass_info_body(
 pub fn format_utc_datetime(epoch_secs: i64) -> String {
    let days = epoch_secs.div_euclid(86_400);
    let secs_of_day = epoch_secs.rem_euclid(86_400);
-    let (hour, min, sec) = (secs_of_day / 3600, (secs_of_day % 3600) / 60, secs_of_day % 60);
+    let (hour, min, sec) = (
+        secs_of_day / 3600,
+        (secs_of_day % 3600) / 60,
+        secs_of_day % 60,
+    );
    // civil_from_days: days is a count of days since 1970-01-01.
    let z = days + 719_468;
    let era = if z >= 0 { z } else { z - 146_096 } / 146_097;
@@ -628,8 +639,14 @@ mod tests {
        });
        let body = user_mass_info_body(squad, 29_859_876, 0, 33_068_179, "Real FUT", "RF", "2016");
        // Flat top-level envelope.
-        assert_eq!(body["pileSizeClientData"]["entries"][0], json!({"key": 2, "value": 100}));
-        assert_eq!(body["pileSizeClientData"]["entries"][1], json!({"key": 4, "value": 50}));
+        assert_eq!(
+            body["pileSizeClientData"]["entries"][0],
+            json!({"key": 2, "value": 100})
+        );
+        assert_eq!(
+            body["pileSizeClientData"]["entries"][1],
+            json!({"key": 4, "value": 50})
+        );
        assert_eq!(body["settings"], json!({"configs": []}));
        assert_eq!(body["userData"], json!({}));
        // userInfo economy + club identity.
@@ -7,20 +7,16 @@
 //! (only card ids that resolve in BOTH the FIFA catalogue and Core content),
 //! mints the drawn cards into Core, and shapes them onto the wire.
 //!
-//! ## Parity note — Python `open_pack` / `_pack_body`
-//! (`fifa17-recon/tools/fut_store.py:689`, `utas_server.py:3474`)
-//! 1. `open_pack(price, count, gold, tiers, special_chance)` deducts coins then
-//!    draws `count` items (mostly players); the reveal body wraps them verbatim.
-//! 2. Non-tiered draws split the pool at rating 75 by `gold` (`p[1] >= 75 == gold`)
-//!    and fall back to the whole pool when that tier is empty (`... or PACK_POOL`).
-//! 3. Each drawn player becomes a special with probability `special_chance`
-//!    (`random.random() < special_chance`).
-//! 4. `FUT_PACK_MIX` swaps ~`count // 4` players for consumables/staff extras;
-//!    we deliberately OMIT that mix (Core candidates are player defs — players-only).
-//! 5. Prices/counts/odds are the OpenFUT **PLACEHOLDER** economy (the audit found
-//!    them invented); only the wire *shape* is EA-observed/oracle-verified.
-//! 6. This port reproduces the count + gold-tier split + `special_chance` gate as
-//!    that same PLACEHOLDER policy, drawing with replacement from the pool.
+//! ## Policy (real FUT 17 composition, DESIGNED odds)
+//!
+//! A pack draws [`PackDef::count`] cards split across rating tiers by the pack's
+//! `n_bronze`/`n_silver`/`n_gold` composition (the same numbers the tile shows in
+//! `packContentInfo`), drawing with replacement from the candidate pool. Each pick
+//! is biased toward a special version with probability `special_chance` (a DESIGNED
+//! placeholder — FUT 17 pack odds are unrecoverable). An empty tier falls back to
+//! the whole pool so a draw is always possible even when the pool lacks that tier.
+//! `FUT_PACK_MIX` (consumable/staff extras) is deliberately OMITTED — Core
+//! candidates are player defs.

 use rand::Rng;

@@ -77,50 +73,83 @@ pub struct GeneratedCard {
    pub attributes: [u8; 6],
 }

-/// Draw `pack.count` cards from `pool` with the injected RNG. Pure and
-/// deterministic under a seeded RNG. Returns an empty `Vec` (fail-closed) when
-/// the pool is empty or the pack awards no cards.
+/// Draw a pack's cards from `pool` with the injected RNG. Pure and deterministic
+/// under a seeded RNG. Returns an empty `Vec` (fail-closed) when the pool is empty
+/// or the pack awards no cards.
 ///
-/// Policy (PLACEHOLDER — see the module parity note): draw with replacement from
-/// the pack's tier (`gold`), biasing each draw toward a special card with
-/// probability `special_chance`. An empty tier or partition falls back to the
-/// next-wider set so a draw is always possible when the pool is non-empty.
+/// Draws the pack's per-tier composition (`n_gold` gold-tier, `n_silver` silver,
+/// `n_bronze` bronze), biasing each pick toward a special with `special_chance`.
+/// An empty tier falls back to the whole pool (so a draw is always possible).
 pub fn generate_pack_contents(
    pack: &PackDef,
    rng: &mut impl Rng,
    pool: &[GeneratedCandidate],
 ) -> Vec<GeneratedCard> {
-    if pool.is_empty() || pack.count == 0 {
+    if pool.is_empty() || pack.count() == 0 {
        return Vec::new();
    }
-    // Tier split: a gold pack draws gold-tier candidates, a non-gold pack draws
-    // non-gold; an empty tier falls back to the whole pool (oracle `... or POOL`).
-    let tier: Vec<&GeneratedCandidate> = pool.iter().filter(|c| c.gold == pack.gold).collect();
-    let tier: Vec<&GeneratedCandidate> = if tier.is_empty() {
-        pool.iter().collect()
-    } else {
-        tier
-    };
-    // Partition the tier by special so `special_chance` can bias a draw; either
-    // partition falls back to the whole tier when empty.
-    let special: Vec<&GeneratedCandidate> = tier.iter().copied().filter(|c| c.special).collect();
-    let normal: Vec<&GeneratedCandidate> = tier.iter().copied().filter(|c| !c.special).collect();
-    let chance = pack.special_chance.clamp(0.0, 1.0);
+    let all: Vec<&GeneratedCandidate> = pool.iter().collect();
+    let gold: Vec<&GeneratedCandidate> = pool.iter().filter(|c| c.rating >= 75).collect();
+    let silver: Vec<&GeneratedCandidate> = pool
+        .iter()
+        .filter(|c| (65..75).contains(&c.rating))
+        .collect();
+    let bronze: Vec<&GeneratedCandidate> = pool.iter().filter(|c| c.rating < 65).collect();

-    let mut out = Vec::with_capacity(pack.count as usize);
-    for _ in 0..pack.count {
+    let mut out = Vec::with_capacity(pack.count() as usize);
+    draw_tier(&mut out, &gold, &all, pack.n_gold, pack.special_chance, rng);
+    draw_tier(
+        &mut out,
+        &silver,
+        &all,
+        pack.n_silver,
+        pack.special_chance,
+        rng,
+    );
+    draw_tier(
+        &mut out,
+        &bronze,
+        &all,
+        pack.n_bronze,
+        pack.special_chance,
+        rng,
+    );
+    out
+}
+
+/// Draw `n` cards from `tier` — or the whole-pool `fallback` when `tier` is empty —
+/// biasing each pick toward a special version with probability `chance`. Either the
+/// special or normal partition falls back to the tier when empty.
+fn draw_tier(
+    out: &mut Vec<GeneratedCard>,
+    tier: &[&GeneratedCandidate],
+    fallback: &[&GeneratedCandidate],
+    n: u64,
+    chance: f64,
+    rng: &mut impl Rng,
+) {
+    if n == 0 {
+        return;
+    }
+    let src: &[&GeneratedCandidate] = if tier.is_empty() { fallback } else { tier };
+    if src.is_empty() {
+        return;
+    }
+    let special: Vec<&GeneratedCandidate> = src.iter().copied().filter(|c| c.special).collect();
+    let normal: Vec<&GeneratedCandidate> = src.iter().copied().filter(|c| !c.special).collect();
+    let chance = chance.clamp(0.0, 1.0);
+    for _ in 0..n {
        let want_special = chance > 0.0 && rng.gen_bool(chance);
        let sub: &[&GeneratedCandidate] = if want_special && !special.is_empty() {
            &special
        } else if !want_special && !normal.is_empty() {
            &normal
        } else {
-            &tier
+            src
        };
        let pick = sub[rng.gen_range(0..sub.len())];
        out.push(pick.to_card());
    }
-    out
 }

 #[cfg(test)]
@@ -156,13 +185,22 @@ mod tests {
        ]
    }

-    fn pack(id: u64, count: u64, gold: bool, special_chance: f64) -> PackDef {
+    fn pack(id: u64, n_bronze: u64, n_silver: u64, n_gold: u64, special_chance: f64) -> PackDef {
        PackDef {
            id,
            name: "Test Pack",
            price: 1000,
-            count,
-            gold,
+            n_bronze,
+            n_silver,
+            n_gold,
+            rares: 0,
+            category: if n_gold > 0 {
+                "gold"
+            } else if n_silver > 0 {
+                "silver"
+            } else {
+                "bronze"
+            },
            special_chance,
            owned_only: false,
        }
@@ -171,7 +209,7 @@ mod tests {
    #[test]
    fn same_seed_same_output() {
        let pool = pool();
-        let p = pack(5, 7, true, 0.3);
+        let p = pack(5, 0, 0, 7, 0.3);
        let mut a = StdRng::seed_from_u64(42);
        let mut b = StdRng::seed_from_u64(42);
        assert_eq!(
@@ -183,7 +221,7 @@ mod tests {
    #[test]
    fn different_seeds_can_diverge() {
        let pool = pool();
-        let p = pack(5, 7, true, 0.3);
+        let p = pack(5, 0, 0, 7, 0.3);
        let a = generate_pack_contents(&p, &mut StdRng::seed_from_u64(1), &pool);
        let b = generate_pack_contents(&p, &mut StdRng::seed_from_u64(999), &pool);
        // Not a hard guarantee, but with this pool/count the two seeds differ.
@@ -196,7 +234,7 @@ mod tests {
        let ids: std::collections::HashSet<&str> =
            pool.iter().map(|c| c.card_id.as_str()).collect();
        for &n in &[1u64, 5, 7, 11] {
-            let p = pack(6, n, true, 0.08);
+            let p = pack(6, 0, 0, n, 0.08);
            let cards = generate_pack_contents(&p, &mut StdRng::seed_from_u64(n), &pool);
            assert_eq!(cards.len() as u64, n);
            for c in &cards {
@@ -212,7 +250,7 @@ mod tests {
    #[test]
    fn gold_pack_draws_only_gold_tier() {
        let pool = pool();
-        let p = pack(5, 20, true, 0.03);
+        let p = pack(5, 0, 0, 20, 0.03);
        let cards = generate_pack_contents(&p, &mut StdRng::seed_from_u64(7), &pool);
        assert!(
            cards.iter().all(|c| c.rating >= 75),
@@ -223,7 +261,7 @@ mod tests {
    #[test]
    fn bronze_pack_draws_only_bronze_tier() {
        let pool = pool();
-        let p = pack(1, 20, false, 0.005);
+        let p = pack(1, 20, 0, 0, 0.005);
        let cards = generate_pack_contents(&p, &mut StdRng::seed_from_u64(7), &pool);
        assert!(
            cards.iter().all(|c| c.rating < 75),
@@ -239,7 +277,7 @@ mod tests {
            .filter(|c| c.special)
            .map(|c| c.card_id.as_str())
            .collect();
-        let p = pack(7, 11, true, 1.0);
+        let p = pack(7, 0, 0, 11, 1.0);
        let cards = generate_pack_contents(&p, &mut StdRng::seed_from_u64(3), &pool);
        assert!(cards
            .iter()
@@ -248,7 +286,7 @@ mod tests {

    #[test]
    fn empty_pool_fails_closed() {
-        let p = pack(5, 7, true, 0.03);
+        let p = pack(5, 0, 0, 7, 0.03);
        assert!(generate_pack_contents(&p, &mut StdRng::seed_from_u64(1), &[]).is_empty());
    }
 }
@@ -0,0 +1,388 @@
+//! FIFA 17 Squad Building Challenge wire shapes.
+//!
+//! Numeric category/set/challenge ids and container types mirror the reversed FIFA 17
+//! `/sbs/*` family. Core ids remain opaque strings and are mapped here, never in Core.
+
+use serde_json::{json, Value};
+
+pub const CATEGORY_ID: i64 = 1;
+pub const CATEGORY_NAME: &str = "Foundations";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ChallengeIdentity {
+    pub core_id: &'static str,
+    pub set_id: i64,
+    pub challenge_id: i64,
+    pub priority: i64,
+}
+
+pub const CHALLENGES: [ChallengeIdentity; 2] = [
+    ChallengeIdentity {
+        core_id: "sbc_bronze_upgrade",
+        set_id: 1,
+        challenge_id: 101,
+        priority: 1,
+    },
+    ChallengeIdentity {
+        core_id: "sbc_hybrid_nations",
+        set_id: 2,
+        challenge_id: 201,
+        priority: 2,
+    },
+];
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ChallengeView {
+    pub identity: ChallengeIdentity,
+    pub name: String,
+    pub description: String,
+    pub repeatable: bool,
+    pub times_completed: i64,
+}
+
+pub fn identity_for_core(core_id: &str) -> Option<ChallengeIdentity> {
+    CHALLENGES
+        .iter()
+        .copied()
+        .find(|entry| entry.core_id == core_id)
+}
+
+pub fn identity_for_challenge(challenge_id: i64) -> Option<ChallengeIdentity> {
+    CHALLENGES
+        .iter()
+        .copied()
+        .find(|entry| entry.challenge_id == challenge_id)
+}
+
+/// `GET sbs/sets`: object root; categories, sets and awards are always arrays.
+pub fn sets_body(challenges: &[ChallengeView]) -> Value {
+    let sets: Vec<Value> = challenges
+        .iter()
+        .map(|challenge| {
+            json!({
+                "setId": challenge.identity.set_id,
+                "categoryId": CATEGORY_ID,
+                "name": challenge.name,
+                "description": challenge.description,
+                "priority": challenge.identity.priority,
+                "challengesCount": 1,
+                "challengesCompletedCount": i64::from(!challenge.repeatable && challenge.times_completed > 0),
+                "awards": [],
+                "hidden": false,
+                "endTime": 4_102_444_800_i64
+            })
+        })
+        .collect();
+    json!({
+        "categories": [{
+            "categoryId": CATEGORY_ID,
+            "name": CATEGORY_NAME,
+            "priority": 1,
+            "sets": sets
+        }]
+    })
+}
+
+/// `GET sbs/setId/{id}/challenges`: object root with a challenge array.
+pub fn challenges_body(set_id: i64, challenges: &[ChallengeView]) -> Value {
+    let records: Vec<Value> = challenges
+        .iter()
+        .filter(|challenge| challenge.identity.set_id == set_id)
+        .map(|challenge| {
+            // A repeatable challenge is always available to enter again. The FIFA 17
+            // client gates challenge re-entry on `timesCompleted` (not on `repeatable`):
+            // a nonzero count renders the tile COMPLETED and refuses re-entry. So a
+            // repeatable challenge never reports itself as terminally completed here.
+            // Core keeps the true completion record (economy authority); this is
+            // presentation only. Live-proven on the retail client 2026-08-18.
+            let times_completed = if challenge.repeatable {
+                0
+            } else {
+                challenge.times_completed
+            };
+            json!({
+                "challengeId": challenge.identity.challenge_id,
+                "setId": challenge.identity.set_id,
+                "categoryId": CATEGORY_ID,
+                "index": 0,
+                "type": "OPEN_CHALLENGE",
+                "name": challenge.name,
+                "description": challenge.description,
+                "challengeImageId": "",
+                "formation": "f442",
+                "endTime": 0,
+                "repeatable": challenge.repeatable,
+                "trophyId": 0,
+                "status": "OPEN",
+                "timesCompleted": times_completed,
+                "awards": [],
+                // `elgReq` stays empty deliberately. Reversed from the pinned CardsDLL
+                // (2026-08-19, see ENDPOINT_MAP.md "Shared record shapes"): the client
+                // consumes `eligibilityKey`/`eligibilityOperation` only as ordinals that
+                // index the packed locale (`LOC_SBC_ELG_KEY_%d`) to render requirement
+                // text — it does NOT validate on them. The ordinal->string map is not
+                // recoverable from any asset we have, so any value we emit would show the
+                // WRONG requirement to the player. Submission is validated server-side by
+                // Core regardless; leaving this empty is display-only, never a correctness
+                // gap. Populate ONLY once the locale ordinal map is captured.
+                "elgReq": []
+            })
+        })
+        .collect();
+    json!({ "challenges": records })
+}
+
+/// Empty-body POST starts a challenge. `squad` is object-root on this response class.
+pub fn start_body(challenge_id: i64) -> Value {
+    json!({
+        "challengeId": challenge_id,
+        "squad": {},
+        "playerRequirements": []
+    })
+}
+
+/// GET challenge squad. The reversed response requires array containers.
+pub fn squad_body(challenge_id: i64, wire_item_ids: &[i64]) -> Value {
+    let squad: Vec<Value> = wire_item_ids
+        .iter()
+        .enumerate()
+        .map(|(index, id)| {
+            json!({
+                "index": index,
+                "itemData": { "id": id },
+                "kitNumber": 0
+            })
+        })
+        .collect();
+    json!({
+        "id": challenge_id,
+        "squad": squad,
+        "playerRequirements": []
+    })
+}
+
+pub fn save_body(challenge_id: i64) -> Value {
+    json!({ "id": challenge_id })
+}
+
+pub fn submit_body(challenge_id: i64, set_id: i64, credits: i64, unopened_packs: i64) -> Value {
+    json!({
+        "challengeId": challenge_id,
+        "setId": set_id,
+        "credits": credits,
+        "preOrderPacks": 0,
+        "recoveredPacks": unopened_packs,
+        "grantedChallengeAwards": [],
+        "grantedSetAwards": []
+    })
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum SbcWireError {
+    Json(String),
+    MissingSquad,
+}
+
+impl std::fmt::Display for SbcWireError {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Json(error) => write!(formatter, "invalid SBC squad JSON: {error}"),
+            Self::MissingSquad => {
+                formatter.write_str("SBC squad body contains no supported squad container")
+            }
+        }
+    }
+}
+
+impl std::error::Error for SbcWireError {}
+
+/// Extract FIFA wire item ids from a saved/submitted challenge squad.
+///
+/// The exact retail challenge-squad body is now captured (2026-08-18 Gate C,
+/// `PUT /ut/game/fifa17/sbs/challenge/101/squad`): a fixed 23-entry `players`
+/// array of `{index, itemData:{id, dream}}` (empty slots carry `id == 0`),
+/// alongside sibling `chemistry`, `rating`, `formation`, and a `manager` array
+/// of `{id, dream}`. Only `players[].itemData.id` selects the consumed cards;
+/// the manager, chemistry, rating, formation, dream, and index fields are
+/// presentation/validation hints and are never consumed. The `squad` array
+/// container remains accepted for the alternate proven shape. Within either,
+/// only non-zero `itemData.id` values are interpreted.
+pub fn parse_wire_item_ids(body: &[u8]) -> Result<Vec<i64>, SbcWireError> {
+    let root: Value =
+        serde_json::from_slice(body).map_err(|error| SbcWireError::Json(error.to_string()))?;
+    let entries = root
+        .get("players")
+        .and_then(Value::as_array)
+        .or_else(|| root.get("squad").and_then(Value::as_array))
+        .ok_or(SbcWireError::MissingSquad)?;
+
+    let mut ids = Vec::new();
+    for entry in entries {
+        if let Some(id) = entry
+            .get("itemData")
+            .and_then(|item| item.get("id"))
+            .and_then(Value::as_i64)
+            .filter(|id| *id != 0)
+        {
+            ids.push(id);
+        }
+    }
+    Ok(ids)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn challenge() -> ChallengeView {
+        ChallengeView {
+            identity: CHALLENGES[0],
+            name: "Bronze Upgrade".into(),
+            description: "Submit players".into(),
+            repeatable: true,
+            times_completed: 2,
+        }
+    }
+
+    #[test]
+    fn response_containers_match_reversed_fifa17_shapes() {
+        let sets = sets_body(&[challenge()]);
+        assert!(sets.is_object());
+        assert!(sets["categories"].is_array());
+        assert!(sets["categories"][0]["sets"].is_array());
+        assert!(sets["categories"][0]["sets"][0]["awards"].is_array());
+
+        let challenges = challenges_body(1, &[challenge()]);
+        assert!(challenges.is_object());
+        assert!(challenges["challenges"].is_array());
+        assert!(challenges["challenges"][0]["awards"].is_array());
+        assert!(challenges["challenges"][0]["elgReq"].is_array());
+
+        assert!(start_body(101)["squad"].is_object());
+        assert!(start_body(101)["playerRequirements"].is_array());
+        assert!(squad_body(101, &[100_000_001])["squad"].is_array());
+        let submit = submit_body(101, 1, 1234, 1);
+        assert!(submit["grantedChallengeAwards"].is_array());
+        assert!(submit["grantedSetAwards"].is_array());
+    }
+
+    #[test]
+    fn repeatable_completed_challenge_stays_enterable() {
+        // The FIFA 17 client refuses challenge re-entry when timesCompleted > 0, so
+        // a repeatable challenge must always project as not-yet-completed while a
+        // non-repeatable one keeps its true count. Core holds the real record.
+        let repeatable = ChallengeView {
+            identity: CHALLENGES[0],
+            name: "Bronze Upgrade".into(),
+            description: "Submit players".into(),
+            repeatable: true,
+            times_completed: 3,
+        };
+        let once = ChallengeView {
+            identity: CHALLENGES[1],
+            name: "Hybrid Nations".into(),
+            description: "Submit a hybrid squad".into(),
+            repeatable: false,
+            times_completed: 1,
+        };
+
+        let repeatable_view =
+            challenges_body(CHALLENGES[0].set_id, std::slice::from_ref(&repeatable));
+        assert_eq!(repeatable_view["challenges"][0]["timesCompleted"], 0);
+        assert_eq!(repeatable_view["challenges"][0]["status"], "OPEN");
+        let once_view = challenges_body(CHALLENGES[1].set_id, std::slice::from_ref(&once));
+        assert_eq!(once_view["challenges"][0]["timesCompleted"], 1);
+
+        let sets = sets_body(&[repeatable, once]);
+        let sets_arr = sets["categories"][0]["sets"].as_array().unwrap();
+        let repeatable_set = sets_arr
+            .iter()
+            .find(|set| set["setId"] == CHALLENGES[0].set_id)
+            .unwrap();
+        let once_set = sets_arr
+            .iter()
+            .find(|set| set["setId"] == CHALLENGES[1].set_id)
+            .unwrap();
+        assert_eq!(
+            repeatable_set["challengesCompletedCount"], 0,
+            "a repeatable set never reports itself terminally completed"
+        );
+        assert_eq!(
+            once_set["challengesCompletedCount"], 1,
+            "a one-shot set counts its single completion"
+        );
+    }
+
+    #[test]
+    fn parser_accepts_only_known_squad_containers_and_item_ids() {
+        let normal = br#"{"players":[{"index":0,"itemData":{"id":100000001}},{"index":1,"itemData":{"id":0}}]}"#;
+        assert_eq!(parse_wire_item_ids(normal).unwrap(), [100_000_001]);
+        let sbc = br#"{"squad":[{"itemData":{"id":100000002}}]}"#;
+        assert_eq!(parse_wire_item_ids(sbc).unwrap(), [100_000_002]);
+        assert_eq!(
+            parse_wire_item_ids(br#"{"challengeId":101}"#),
+            Err(SbcWireError::MissingSquad)
+        );
+        assert!(matches!(
+            parse_wire_item_ids(br#"{"squad":"not-an-array"}"#),
+            Err(SbcWireError::MissingSquad)
+        ));
+        assert!(matches!(
+            parse_wire_item_ids(br#"{"squad":["#),
+            Err(SbcWireError::Json(_))
+        ));
+    }
+
+    #[test]
+    fn parser_matches_captured_retail_challenge_squad_body() {
+        // Verbatim shape from the 2026-08-18 Gate C retail capture of
+        // PUT /ut/game/fifa17/sbs/challenge/101/squad (11 filled + 12 empty
+        // slots, plus manager/chemistry/rating/formation siblings). Only the 11
+        // non-zero player itemData.id values are consumed, in wire order; the
+        // manager and all presentation fields are ignored.
+        let retail = br#"{"chemistry":21,"rating":86,"formation":"f433",
+            "manager":[{"id":100000427,"dream":false}],
+            "players":[
+              {"index":0,"itemData":{"id":100004227,"dream":false}},
+              {"index":1,"itemData":{"id":100004233,"dream":false}},
+              {"index":2,"itemData":{"id":100001317,"dream":false}},
+              {"index":3,"itemData":{"id":100001531,"dream":false}},
+              {"index":4,"itemData":{"id":100000966,"dream":false}},
+              {"index":5,"itemData":{"id":100001947,"dream":false}},
+              {"index":6,"itemData":{"id":100000169,"dream":false}},
+              {"index":7,"itemData":{"id":100002017,"dream":false}},
+              {"index":8,"itemData":{"id":100002765,"dream":false}},
+              {"index":9,"itemData":{"id":100000147,"dream":false}},
+              {"index":10,"itemData":{"id":100000311,"dream":false}},
+              {"index":11,"itemData":{"id":0,"dream":false}},
+              {"index":12,"itemData":{"id":0,"dream":false}},
+              {"index":13,"itemData":{"id":0,"dream":false}},
+              {"index":14,"itemData":{"id":0,"dream":false}},
+              {"index":15,"itemData":{"id":0,"dream":false}},
+              {"index":16,"itemData":{"id":0,"dream":false}},
+              {"index":17,"itemData":{"id":0,"dream":false}},
+              {"index":18,"itemData":{"id":0,"dream":false}},
+              {"index":19,"itemData":{"id":0,"dream":false}},
+              {"index":20,"itemData":{"id":0,"dream":false}},
+              {"index":21,"itemData":{"id":0,"dream":false}},
+              {"index":22,"itemData":{"id":0,"dream":false}}
+            ]}"#;
+        assert_eq!(
+            parse_wire_item_ids(retail).unwrap(),
+            [
+                100_004_227,
+                100_004_233,
+                100_001_317,
+                100_001_531,
+                100_000_966,
+                100_001_947,
+                100_000_169,
+                100_002_017,
+                100_002_765,
+                100_000_147,
+                100_000_311
+            ],
+            "exactly the 11 non-zero players in wire order; manager and empty slots ignored"
+        );
+    }
+}
@@ -141,6 +141,13 @@ pub struct ProposedSquad {
    /// never used to derive slot layout.
    pub formation: Option<String>,
    pub slots: Vec<ProposedSlot>,
+    /// The owned instance assigned as the squad's **manager**, reverse-resolved
+    /// from the wire `manager` ref to a Core `owned_card_id` (so the assignment
+    /// is ownership-backed, never a dangling wire id). `None` when the save
+    /// carries no manager. A manager wire id the resolver cannot map is reported
+    /// in `unresolved_wire_ids` — a save is refused rather than assigning a
+    /// manager the club does not own.
+    pub manager_owned_card_id: Option<String>,
    /// Occupied wire item ids the resolver could not map. A caller MUST refuse the
    /// replacement if this is non-empty — a save must never silently drop an
    /// owned player it failed to identify.
@@ -180,12 +187,14 @@ pub fn parse_squad_put(body: &[u8]) -> Result<Fifa17SquadPut, SquadError> {

 /// Resolve a parsed save into a **canonical** [`ProposedSquad`]: drop empty
 /// (`id == 0`) slots, reverse-map each occupied slot's wire id to a Core
-/// `owned_card_id`, flag the captain, and derive the bench split from the fixed
-/// 23-slot array. FIFA-only state (`custom`, manager, kicktakers, kit numbers,
-/// squadType) and client-reported evaluation are NOT canonical — they are built
-/// separately into [`crate::fut::squad_ext::Fifa17SquadExtensionV1`]. The
-/// formation token is carried verbatim (never mapped). Unresolvable occupied ids
-/// are reported, never guessed or dropped.
+/// `owned_card_id`, flag the captain, derive the bench split from the fixed
+/// 23-slot array, and reverse-resolve the manager ref to an owned instance
+/// (the manager assignment is ownership-backed canonical state, migration 0023).
+/// The remaining FIFA-only state (`custom`, kicktakers, kit numbers, squadType)
+/// and client-reported evaluation are NOT canonical — they are built separately
+/// into [`crate::fut::squad_ext::Fifa17SquadExtensionV1`]. The formation token is
+/// carried verbatim (never mapped). Unresolvable occupied ids are reported,
+/// never guessed or dropped.
 pub fn to_proposed(put: &Fifa17SquadPut, resolver: &dyn SquadWireResolver) -> ProposedSquad {
    let captain = put.captain.unwrap_or(0);
    let mut slots = Vec::new();
@@ -205,11 +214,22 @@ pub fn to_proposed(put: &Fifa17SquadPut, resolver: &dyn SquadWireResolver) -> Pr
            None => unresolved.push(p.item_data.id),
        }
    }
+    // Manager: the first non-zero manager ref, reverse-resolved to an owned
+    // instance. An unresolvable manager is an unresolved wire id (refused), not a
+    // silently dropped assignment — you cannot manage with a card you don't own.
+    let mut manager_owned_card_id = None;
+    if let Some(wire) = put.manager.iter().map(|m| m.id).find(|&id| id != 0) {
+        match resolver.owned_id_for_wire(wire) {
+            Some(owned) => manager_owned_card_id = Some(owned),
+            None => unresolved.push(wire),
+        }
+    }
    ProposedSquad {
        squad_id: put.id,
        name: put.squad_name.clone(),
        formation: put.formation.clone(),
        slots,
+        manager_owned_card_id,
        unresolved_wire_ids: unresolved,
    }
 }
@@ -237,9 +257,11 @@ mod tests {
    }
    fn full_resolver() -> MapResolver {
        // indices 0..=10 (11 starters); the rest of the 23 slots are id==0 (empty).
+        // 100000427 is the fixture's manager ref — the host resolves it like any
+        // other owned instance, so the manager assignment is ownership-backed.
        let ids = [
            100000003, 100000010, 100000005, 100000008, 100000007, 100000006, 100000004, 100000009,
-            100000001, 100000002, 100000025,
+            100000001, 100000002, 100000025, 100000427,
        ];
        MapResolver(ids.iter().map(|&w| (w, format!("oc-{w}"))).collect())
    }
@@ -283,6 +305,8 @@ mod tests {
        assert_eq!(caps[0].owned_card_id, "oc-100000001");
        assert_eq!(caps[0].index, 8);
        assert_eq!(caps[0].kit_number, 8);
+        // The manager ref is reverse-resolved to an owned instance (canonical).
+        assert_eq!(sq.manager_owned_card_id.as_deref(), Some("oc-100000427"));
    }

    #[test]
@@ -12,7 +12,7 @@
 //! | `custom` | opaque 33-int string; meaning UNKNOWN, round-tripped verbatim |
 //! | `squad_type` | an observed FIFA wire token; no matching generic Core concept |
 //! | `kit_numbers` | keyed by **`owned_card_id`** — evidence: kit follows the player |
-//! | `manager` | a FIFA manager item ref; not a squad player, semantics opaque |
+//! | ~~manager~~ | MOVED to ownership-backed canonical Core state (migration 0023 `squad_managers`); resolved to an `owned_card_id`, no longer opaque here |
 //! | `kicktakers` | role→item refs; relationship to captain UNKNOWN, kept opaque |
 //! | `client_reported` | chemistry/rating/starRating — client shadow, NOT authority |
 //!
@@ -30,7 +30,7 @@ use std::collections::BTreeMap;

 use serde::{Deserialize, Serialize};

-use crate::fut::squad::{ClientReportedSquadEval, Fifa17SquadPut, ProposedSquad, SquadEntityRef};
+use crate::fut::squad::{ClientReportedSquadEval, Fifa17SquadPut, ProposedSquad};

 /// Opaque scope key Core files this extension under (`game_entity_ext.namespace`).
 pub const EXT_NAMESPACE: &str = "fifa17.squad";
@@ -49,15 +49,6 @@ pub struct WireItemRef {
    pub dream: bool,
 }

-impl From<&SquadEntityRef> for WireItemRef {
-    fn from(r: &SquadEntityRef) -> Self {
-        WireItemRef {
-            id: r.id,
-            dream: r.dream,
-        }
-    }
-}
-
 /// A kicktaker slot preserved verbatim. `index` is the role slot (0..=4 observed);
 /// `item` is the referenced FIFA wire item. The role→player meaning and any
 /// relationship to the captain are UNKNOWN, so this is stored opaquely and never
@@ -83,9 +74,9 @@ pub struct Fifa17SquadExtensionV1 {
    /// proves the kit number follows the player across swaps and formation change.
    #[serde(default)]
    pub kit_numbers: BTreeMap<String, i64>,
-    /// Manager item ref(s), opaque. Not a squad player; not shaped as an item.
-    #[serde(default)]
-    pub manager: Vec<WireItemRef>,
+    // NOTE: the squad manager is NO LONGER carried here. It is ownership-backed
+    // canonical Core state (migration 0023 `squad_managers`), resolved to an
+    // `owned_card_id` on the ProposedSquad — never a dangling opaque wire ref.
    /// Kicktaker role refs, opaque (see [`KicktakerRef`]).
    #[serde(default)]
    pub kicktakers: Vec<KicktakerRef>,
@@ -132,7 +123,6 @@ impl Fifa17SquadExtensionV1 {
            custom: put.custom.clone(),
            squad_type: put.squad_type.clone(),
            kit_numbers,
-            manager: put.manager.iter().map(WireItemRef::from).collect(),
            kicktakers: put
                .kicktakers
                .iter()
@@ -256,6 +246,9 @@ mod tests {
        let ids = [
            100000003, 100000010, 100000005, 100000008, 100000007, 100000006, 100000004, 100000009,
            100000001, 100000002, 100000025,
+            // The f442 fixture's manager ref — the host resolves it like any other
+            // owned instance, so the ownership-backed manager assignment is present.
+            100000427,
        ];
        MapResolver(ids.iter().map(|&w| (w, format!("oc-{w}"))).collect())
    }
@@ -308,22 +301,32 @@ mod tests {
    }

    #[test]
-    fn manager_and_kicktakers_preserved_opaquely() {
-        let ext = built().extension;
+    fn manager_is_canonical_and_kicktakers_stay_opaque() {
+        let build = built();
+        // Manager is now ownership-backed canonical state: the wire ref resolved
+        // to a Core owned_card_id on the ProposedSquad, not an opaque ext blob.
        assert_eq!(
-            ext.manager,
-            vec![WireItemRef {
-                id: 100000427,
-                dream: false
-            }]
+            build.canonical.manager_owned_card_id.as_deref(),
+            Some("oc-100000427")
        );
+        // Kicktakers remain opaque in the extension.
+        let ext = build.extension;
        assert_eq!(ext.kicktakers.len(), 5);
-        // All five reference the same wire id in this capture; carried verbatim,
-        // NEVER normalized to the captain even though they coincide here.
        assert!(ext.kicktakers.iter().all(|k| k.item.id == 100000001));
        assert_eq!(ext.kicktakers[0].index, 0);
    }

+    #[test]
+    fn build_refuses_an_unowned_manager() {
+        // Manager wire id present but NOT resolvable → refused, never assigned a
+        // manager the club does not own.
+        let put = parse_squad_put(PUT_F442.as_bytes()).unwrap();
+        let mut ids = full_resolver().0;
+        ids.remove(&100000427);
+        let err = build_squad_write(&put, &MapResolver(ids)).unwrap_err();
+        assert_eq!(err, SquadBuildError::UnresolvedWireIds(vec![100000427]));
+    }
+
    #[test]
    fn unknown_schema_version_is_rejected_not_coerced() {
        let payload = built().extension.to_payload();
@@ -77,6 +77,11 @@ pub struct SquadProjectionInput<'a> {
    /// Every owned item a slot references, keyed by `owned_card_id`. Assembled by
    /// the host in one batch — the projector only reads from it.
    pub owned: &'a HashMap<String, CoreOwnedItem>,
+    /// The owned instance assigned as this squad's **manager** (Core's
+    /// ownership-backed `squad_managers` assignment, migration 0023), or `None`.
+    /// Projected as the FIFA `manager` wire ref resolved from ownership — never a
+    /// dangling wire id, and never fabricated when absent.
+    pub manager: Option<CoreOwnedItem>,
 }

 /// Result of a projection, with the extension-freshness verdict surfaced.
@@ -171,6 +176,17 @@ pub fn project_squad<I: ItemIdentityResolver + ?Sized>(
        }
    }

+    // Manager: the ownership-backed assignment, resolved to its FIFA wire ref.
+    // Emitted as the STATIC_REVERSED `[{id, dream}]` shape (the same shape the
+    // client sends on save). An owned manager with no resolvable FIFA identity
+    // is omitted (non-fatal, like /club dropping an unrenderable card) rather
+    // than emitted with a fabricated id. NOTE: a richer manager itemData
+    // (contract/leagueId/nation) is INFERRED-only from the offline-season
+    // diagnosis and deliberately NOT invented here pending wire reversal.
+    let manager = match input.manager.as_ref().and_then(|m| ident.resolve(m)) {
+        Some(id) => json!([{ "id": id.item_id, "dream": false }]),
+        None => json!([]),
+    };
    let squad = json!({
        "id": input.fifa_squad_id,
        "squadName": input.name,
@@ -180,7 +196,7 @@ pub fn project_squad<I: ItemIdentityResolver + ?Sized>(
        "starRating": ext.client_reported.star_rating,
        "rating": ext.client_reported.rating,
        "captain": captain_wire,
-        "manager": ext.manager,
+        "manager": manager,
        "custom": ext.custom,
        "players": players,
        "kicktakers": ext.kicktakers,
@@ -262,6 +278,7 @@ mod tests {
            }],
            ext,
            owned,
+            manager: None,
        }
    }

@@ -272,7 +289,6 @@ mod tests {
            custom: Some("[1,2,3]".into()),
            squad_type: Some("REGULAR_SQUAD".into()),
            kit_numbers: kit,
-            manager: vec![],
            kicktakers: vec![],
            client_reported: Default::default(),
        }
@@ -403,6 +419,7 @@ mod tests {
            ],
            ext: SquadExtInput::Fresh(ext),
            owned: owned_ref,
+            manager: None,
        };
        let SquadProjection::Projected(v) = project_squad(&input, &ident, &ent()).unwrap() else {
            panic!();
@@ -423,4 +440,65 @@ mod tests {
            "kit stays with the instance"
        );
    }
+
+    #[test]
+    fn manager_projected_from_ownership_as_wire_ref() {
+        let mut owned = HashMap::new();
+        owned.insert("oc1".to_string(), owned_item("oc1", "card_x"));
+        let ident = TableIdentity(HashMap::from([
+            (
+                "oc1".to_string(),
+                Fifa17Identity {
+                    item_id: 100000042,
+                    asset_id: 20801,
+                    resource_id: 20801,
+                    rareflag: 1,
+                },
+            ),
+            (
+                "oc-mgr".to_string(),
+                Fifa17Identity {
+                    item_id: 100000427,
+                    asset_id: 5001,
+                    resource_id: 5001,
+                    rareflag: 1,
+                },
+            ),
+        ]));
+        let mut input = one_slot_input(&owned, SquadExtInput::Fresh(fresh_ext()));
+        input.manager = Some(owned_item("oc-mgr", "fifa17_mgr"));
+        let SquadProjection::Projected(v) = project_squad(&input, &ident, &ent()).unwrap() else {
+            panic!("expected Projected");
+        };
+        assert_eq!(
+            v["manager"],
+            json!([{ "id": 100000427, "dream": false }]),
+            "manager is the ownership-backed wire ref, resolved from the owned item"
+        );
+    }
+
+    #[test]
+    fn absent_manager_projects_empty_array_never_fabricated() {
+        let mut owned = HashMap::new();
+        owned.insert("oc1".to_string(), owned_item("oc1", "card_x"));
+        let ident = TableIdentity(HashMap::from([(
+            "oc1".to_string(),
+            Fifa17Identity {
+                item_id: 100000042,
+                asset_id: 20801,
+                resource_id: 20801,
+                rareflag: 1,
+            },
+        )]));
+        // one_slot_input leaves manager: None.
+        let input = one_slot_input(&owned, SquadExtInput::Fresh(fresh_ext()));
+        let SquadProjection::Projected(v) = project_squad(&input, &ident, &ent()).unwrap() else {
+            panic!("expected Projected");
+        };
+        assert_eq!(
+            v["manager"],
+            json!([]),
+            "no manager assignment => empty array, nothing fabricated"
+        );
+    }
 }
@@ -1,92 +1,217 @@
 //! FIFA 17 Store pack catalogue + `/store/purchasegroup` wire shaping.
 //!
-//! A faithful Rust port of the Python oracle's `PACK_CATALOG` + `_pack_body` +
-//! `store_catalog` assembly (`fifa17-recon/tools/{fut_store,utas_server}.py`) at the
-//! **production flag defaults** (`FUT_STORE_DISPLAYGROUP=1` on, `FUT_STORE_GROUPID=0`
-//! off, `FUT_PRICE_PROBE=0` off). Parity is pinned by differential fixtures generated
-//! from the Python oracle (`tests/fixtures/purchasegroup_*.json`).
+//! Rust is the authoritative store owner: [`build_purchasegroup`] is served live
+//! by the host via `EconomyRoute::PurchaseGroup` over Core economy authority (Core
+//! owns coins + unopened packs), so there is no Python dependency and no
+//! dual-write/split-brain.
 //!
-//! ## Scope / split-brain safety
+//! ## Relationship to the Python oracle
 //!
-//! This is **pure wire shaping** — no economy state, no IO. [`build_purchasegroup`]
-//! is a function of `(owned unopened pack ids, empty-My-Packs StoreMode)`. It is
-//! deliberately **not yet wired** into the live host: serving purchasegroup from Rust
-//! requires an authoritative Rust owner of `unopenedPackIds`, and today Python is the
-//! single writer of coins + unopened packs (BUY, quick-sell, rewards). Wiring this
-//! before that economy authority exists would create a dual-write/split-brain. See
-//! the R3 economy-authority prerequisite in the vault (`Rust UTAS Migration`).
+//! The wire *shape* was RE'd from the client and cross-checked against the Python
+//! oracle's `_pack_body`/`store_catalog`
+//! (`fifa17-recon/tools/{fut_store,utas_server}.py`). Rust now diverges from the
+//! oracle where the RE proved the oracle wrong: it does NOT emit `extPrice`, whose
+//! parser side-effect creates an `"mtx"` currency row and switches on the broken
+//! `or %1s` FIFA-Points tile line (plan-2026-08-05-store-subsystem.md §3.4). The
+//! Python oracle stays the rollback baseline and is never modified; the
+//! `tests/fixtures/purchasegroup_*.json` goldens pin Rust's authoritative output.
 //!
 //! ## Economy-parameter provenance
 //!
-//! Prices, counts and odds are the current OpenFUT **PLACEHOLDER** economy, NOT
-//! EA-authentic (the overnight audit established the store economy is invented). The
-//! wire *shape* is EA-observed/oracle-verified; the *numbers* are placeholders.
+//! Pack prices and tier composition are the real always-available FUT 17
+//! regular-store packs (community-documented on fifauteam). Pack ODDS
+//! (`special_chance`) are DESIGNED placeholders, NOT EA-authentic — EA never
+//! published FUT 17 pack probabilities. The wire *shape* is EA-observed/RE-verified.

 use serde_json::{json, Value};

 use crate::fut::store_session::{StoreMode, SENTINEL_PACK_ID};

-/// A FIFA 17 Store pack definition. Wire shape is oracle-verified; the economy
-/// numbers (`price`/`count`/`special_chance`) are OpenFUT PLACEHOLDER, not EA-authentic.
+/// A FIFA 17 Store pack definition. The wire *shape* is RE-verified; the price and
+/// per-tier composition are the real always-available FUT 17 regular-store packs,
+/// with DESIGNED (not EA-authentic) `special_chance` odds.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct PackDef {
    pub id: u64,
    pub name: &'static str,
    pub price: u64,
-    pub count: u64,
-    pub gold: bool,
+    /// Cards awarded per rating-tier band: bronze `< 65`, silver `65..=74`, gold
+    /// `>= 75`. These are ALSO the wire `packContentInfo` per-tier quantities, so a
+    /// pack's displayed composition matches what its generator draws.
+    pub n_bronze: u64,
+    pub n_silver: u64,
+    pub n_gold: u64,
+    /// `rareQuantity` shown on the tile (wire display only).
+    pub rares: u64,
+    /// StoreFront category token (`displayGroup.value`): one of the six hard-coded
+    /// client tokens — here `"bronze"`, `"silver"` or `"gold"`.
+    pub category: &'static str,
+    /// Per-draw probability the awarded card is a special version (DESIGNED
+    /// placeholder; FUT 17 odds are unrecoverable).
    pub special_chance: f64,
    /// Reward-only pack (no purchase path): excluded from the normal catalogue,
    /// rendered only when owned (in `unopenedPackIds`).
    pub owned_only: bool,
 }

-/// The current supported FIFA 17 pack catalogue (`fut_store.py:820`). Only observed/
-/// currently-supported ids. The 65534 sentinel is deliberately ABSENT — it is a
-/// compatibility shim, never a catalogue pack (never purchasable/openable).
+impl PackDef {
+    /// Total cards awarded / wire `itemQuantity` — the sum of the per-tier counts.
+    pub fn count(&self) -> u64 {
+        self.n_bronze + self.n_silver + self.n_gold
+    }
+}
+
+/// The always-available FIFA 17 FUT regular-store packs (real fifauteam-documented
+/// prices + tier composition), plus the OpenFUT reward pack. Two packs per client
+/// category (bronze/silver/gold), which the client renders as separate buyable tiles
+/// on drill-in. The 65534 sentinel is deliberately ABSENT — a compatibility shim,
+/// never purchasable/openable.
 pub const PACK_CATALOG: &[PackDef] = &[
+    // ── Bronze category ──
    PackDef {
        id: 1,
        name: "Bronze Pack",
        price: 400,
-        count: 5,
-        gold: false,
-        special_chance: 0.005,
+        n_bronze: 10,
+        n_silver: 2,
+        n_gold: 0,
+        rares: 1,
+        category: "bronze",
+        special_chance: 0.01,
        owned_only: false,
    },
+    PackDef {
+        id: 2,
+        name: "Premium Bronze Pack",
+        price: 750,
+        n_bronze: 10,
+        n_silver: 2,
+        n_gold: 0,
+        rares: 3,
+        category: "bronze",
+        special_chance: 0.02,
+        owned_only: false,
+    },
+    // ── Silver category ──
+    PackDef {
+        id: 3,
+        name: "Silver Pack",
+        price: 2500,
+        n_bronze: 1,
+        n_silver: 11,
+        n_gold: 0,
+        rares: 1,
+        category: "silver",
+        special_chance: 0.015,
+        owned_only: false,
+    },
+    PackDef {
+        id: 4,
+        name: "Premium Silver Pack",
+        price: 3750,
+        n_bronze: 1,
+        n_silver: 11,
+        n_gold: 0,
+        rares: 3,
+        category: "silver",
+        special_chance: 0.03,
+        owned_only: false,
+    },
+    // ── Gold category ──
    PackDef {
        id: 5,
        name: "Gold Pack",
        price: 5000,
-        count: 7,
-        gold: true,
-        special_chance: 0.03,
+        n_bronze: 0,
+        n_silver: 2,
+        n_gold: 10,
+        rares: 1,
+        category: "gold",
+        special_chance: 0.04,
        owned_only: false,
    },
    PackDef {
        id: 6,
-        name: "Premium Gold",
-        price: 15000,
-        count: 11,
-        gold: true,
-        special_chance: 0.08,
-        owned_only: false,
-    },
-    PackDef {
-        id: 7,
-        name: "Special Players Pack",
-        price: 25000,
-        count: 11,
-        gold: true,
-        special_chance: 1.0,
+        name: "Premium Gold Pack",
+        price: 7500,
+        n_bronze: 0,
+        n_silver: 2,
+        n_gold: 10,
+        rares: 3,
+        category: "gold",
+        special_chance: 0.06,
        owned_only: false,
    },
+    // ── Reward (owned-only; opened from My Packs, never coin-purchasable) ──
    PackDef {
        id: 70,
-        name: "Reward Special Players Pack",
+        name: "Reward Gold Pack",
        price: 0,
-        count: 11,
-        gold: true,
+        n_bronze: 0,
+        n_silver: 0,
+        n_gold: 11,
+        rares: 11,
+        category: "gold",
+        special_chance: 1.0,
+        owned_only: true,
+    },
+    PackDef {
+        id: 71,
+        name: "Bronze Pack",
+        price: 0,
+        n_bronze: 10,
+        n_silver: 2,
+        n_gold: 0,
+        rares: 1,
+        category: "bronze",
+        special_chance: 0.01,
+        owned_only: true,
+    },
+    PackDef {
+        id: 72,
+        name: "Silver Pack",
+        price: 0,
+        n_bronze: 1,
+        n_silver: 11,
+        n_gold: 0,
+        rares: 1,
+        category: "silver",
+        special_chance: 0.02,
+        owned_only: true,
+    },
+    PackDef {
+        id: 73,
+        name: "Gold Pack",
+        price: 0,
+        n_bronze: 0,
+        n_silver: 2,
+        n_gold: 10,
+        rares: 1,
+        category: "gold",
+        special_chance: 0.05,
+        owned_only: true,
+    },
+    PackDef {
+        id: 74,
+        name: "Rare Gold Pack",
+        price: 0,
+        n_bronze: 0,
+        n_silver: 2,
+        n_gold: 10,
+        rares: 3,
+        category: "gold",
+        special_chance: 0.10,
+        owned_only: true,
+    },
+    PackDef {
+        id: 75,
+        name: "Icon Pack",
+        price: 0,
+        n_bronze: 0,
+        n_silver: 0,
+        n_gold: 12,
+        rares: 12,
+        category: "gold",
        special_chance: 1.0,
        owned_only: true,
    },
@@ -97,27 +222,88 @@ pub fn pack_by_id(id: u64) -> Option<&'static PackDef> {
    PACK_CATALOG.iter().find(|p| p.id == id)
 }

-/// The FIFA17 StoreFront category token for a NORMAL pack tile (`utas_server.py:3579`):
-/// one of the six hard-coded tokens the client resolves.
-fn category(p: &PackDef) -> &'static str {
-    if p.special_chance >= 1.0 {
-        "special"
-    } else if p.gold {
-        "gold"
-    } else {
-        "bronze"
+/// Resolve a Core entitlement's opaque `definition_id` to the FIFA 17 numeric
+/// owned-only pack it renders and opens as. Accepts a numeric id (imported
+/// entitlements, e.g. `"70"`) or one of the symbolic reward-pack names Core's
+/// reward services grant (SBC, draft, season, check-in, FUT Champions). Only
+/// owned-only packs qualify, so an unknown or non-reward entitlement resolves to
+/// `None` and is simply not shown as an openable pack rather than faked.
+pub fn owned_pack_id_for_definition(definition_id: &str) -> Option<u64> {
+    if let Ok(numeric) = definition_id.parse::<u64>() {
+        return pack_by_id(numeric)
+            .filter(|pack| pack.owned_only)
+            .map(|pack| pack.id);
    }
+    let id = match definition_id {
+        "bronze_pack" => 71,
+        "silver_pack" => 72,
+        "gold_pack" => 73,
+        "rare_gold_pack" => 74,
+        "icon_pack" => 75,
+        _ => return None,
+    };
+    Some(id)
+}
+
+/// The FIFA 17 StoreFront category token for a pack tile (`displayGroup.value`):
+/// one of the six hard-coded tokens the client resolves. Each catalogue pack
+/// carries its own token; owned/reward packs take `mypacks` instead (see
+/// [`pack_body`]).
+fn category(p: &PackDef) -> &'static str {
+    p.category
 }

 /// One `purchase[]` entry — the faithful `_pack_body` port (`utas_server.py:3474`) at
 /// production flag defaults. `owned` packs (My Packs / reward / sentinel) drop the
 /// purchase fields and take the `mypacks` display group.
 pub fn pack_body(p: &PackDef, idx: u64, owned: bool) -> Value {
-    let mtx = std::cmp::max(1, p.price / 100);
+    let pack_type = match p.category {
+        "gold" => "GOLD",
+        "silver" => "SILVER",
+        _ => "BRONZE",
+    };
+    // Group background texture: FIFA 17's all-groups landing (shown on first store
+    // entry) renders one tile per group whose art is the client-bundled
+    // `packs_backgrounds_%d.dds` selected by this field. LIVE-PROBED 2026-08-18:
+    // index 0 is blank; 1/2/3 render real pack art — so assign non-zero per
+    // category and that landing shows native art instead of blank shields. The
+    // persistent tabbed store draws its pack art from the packs themselves and
+    // does not depend on this.
+    let group_bg: u64 = if owned {
+        3
+    } else {
+        match p.category {
+            "gold" => 3,
+            "silver" => 2,
+            _ => 1,
+        }
+    };
+    // My Packs cover art. LIVE-MAPPED on the retail client 2026-08-18 across all
+    // three store tabs and two reward tiles:
+    //   * `assetId` only gates whether art renders AT ALL. A reward pack's own id
+    //     (70-75) is not a known client asset, so its tile renders BLANK; any valid
+    //     catalogue asset (1-6) makes art appear.
+    //   * WHICH art is drawn comes from `packType` + `packContentInfo.rareQuantity`,
+    //     not from `assetId`: BRONZE+1rare -> bronze card, BRONZE+3 -> silver,
+    //     SILVER+1 -> gold, SILVER+3 -> silver trio, GOLD+1 -> blue special,
+    //     GOLD+3 -> red inform. (Remapping assetId 5->3 and 3->2 left both frames
+    //     unchanged and only rotated the featured player, which proves this.)
+    // So a reward tile automatically shows the same art as the equivalent
+    // purchasable pack; we only need a valid asset, and we use the tier's own store
+    // pack for clarity. `id` stays the pack's own id (the open packId / SERVER_ID).
+    let art_asset: u64 = if owned {
+        match p.category {
+            "gold" => 5,
+            "silver" => 3,
+            _ => 1,
+        }
+    } else {
+        p.id
+    };
    let mut body = json!({
-        "assetId": p.id,
+        "assetId": art_asset,
        "id": p.id,
-        "packType": if p.gold { "GOLD" } else { "BRONZE" },
+        "packType": pack_type,
        "description": p.name,
        "state": "active",
        "saleType": "promo",
@@ -127,26 +313,37 @@ pub fn pack_body(p: &PackDef, idx: u64, owned: bool) -> Value {
        "purchaseCount": 0,
        "isPremium": false,
        "sortPriority": idx,
+        "displayGroupAssetId": group_bg,
+        // The tile renders `finalFunds` as its coin price; the HUD balance reads
+        // `funds` from the /credits currencies array. We keep the pair equal.
+        //
+        // NO `extPrice`. Its parser has a SIDE EFFECT: `finalPrice`/`originalPrice`
+        // both CREATE an `"mtx"` currency row, which the tile adapter reads as "has
+        // a real-money price" and switches on the broken `or %1s` label — the
+        // Origin/Dime commerce catalogue that would fill it no longer exists
+        // offline, so every string stays at its constructor default. Omitting the
+        // key is the documented fix (plan-2026-08-05-store-subsystem.md §3.4 /
+        // experiment #4): it strictly reduces executed client code and leaves every
+        // tile buyable. LIVE-observed `or %1s` on the Store tiles, 2026-08-18.
        "currencies": [{ "name": "coins", "funds": p.price, "finalFunds": p.price }],
-        "extPrice": {
-            "finalPrice": { "amount": mtx, "currency": "mtx" },
-            "originalPrice": { "amount": mtx, "currency": "mtx" },
-        },
        "packContentInfo": {
-            "bronzeQuantity": if p.gold { 0 } else { p.count },
-            "silverQuantity": 0,
-            "goldQuantity": if p.gold { p.count } else { 0 },
-            "rareQuantity": if p.gold { p.count } else { 0 },
-            "itemQuantity": p.count,
+            "bronzeQuantity": p.n_bronze,
+            "silverQuantity": p.n_silver,
+            "goldQuantity": p.n_gold,
+            "rareQuantity": p.rares,
+            "itemQuantity": p.count(),
        },
        "unopened": owned,
    });
    let obj = body.as_object_mut().expect("pack body is a JSON object");
    if owned {
-        // Reward/My-Packs tiles have no purchase path; leaving zero-value coin/mtx
-        // objects makes the client render the price label as literal "undefined".
-        obj.remove("currencies");
-        obj.remove("extPrice");
+        // Reward/My-Packs tiles KEEP the coins currency at the pack price (0 for
+        // reward packs). My Packs opens through the store purchase flow, so a tile
+        // with no currency row is not actionable — clicking navigates instead of
+        // opening. With a free coin row the client sends POST /purchased and the
+        // server (owned-only) opens it for free. No extPrice (that is the `or %1s`
+        // mtx bug), so the free coin row formats as "0", not an unavailable label.
+        // LIVE-PROVEN 2026-08-18: a reward Silver Pack opened and revealed cards.
        obj.insert(
            "displayGroup".into(),
            json!({ "value": "mypacks", "priority": idx }),
@@ -165,8 +362,11 @@ pub fn sentinel_body(idx: u64) -> Value {
        id: SENTINEL_PACK_ID,
        name: "",
        price: 0,
-        count: 0,
-        gold: true,
+        n_bronze: 0,
+        n_silver: 0,
+        n_gold: 0,
+        rares: 0,
+        category: "gold",
        special_chance: 0.0,
        owned_only: true,
    };
@@ -176,13 +376,19 @@ pub fn sentinel_body(idx: u64) -> Value {
        .expect("sentinel body is a JSON object");
    obj.insert("state".into(), json!("active"));
    obj.insert("unopened".into(), json!(false));
+    // The sentinel must stay non-openable (it is only a resolve-without-crash shim
+    // for an empty My Packs), so it keeps no purchase path.
+    obj.remove("currencies");
+    // Keep the sentinel's own id as its asset: it must render as an inert blank
+    // placeholder, never borrow a real pack's cover.
+    obj.insert("assetId".into(), json!(SENTINEL_PACK_ID));
    body
 }

-/// Build the full `/store/purchasegroup` body from the authoritative unopened-pack ids
-/// and the frozen empty-My-Packs mode. Pure — mirrors `store_catalog` (`3627`):
-/// normal packs (1,5,6,7) first, then any owned packs, then the empty-My-Packs shim
-/// (sentinel for [`StoreMode::Sentinel`], nothing for [`StoreMode::CleanV1`]).
+/// Build the full `/store/purchasegroup` body from the authoritative unopened-pack
+/// ids and the frozen empty-My-Packs mode. Pure: the six regular packs (ids 1–6)
+/// first, then any owned packs, then the empty-My-Packs shim (sentinel for
+/// [`StoreMode::Sentinel`], nothing for [`StoreMode::CleanV1`]).
 pub fn build_purchasegroup(unopened_ids: &[u64], mode: StoreMode) -> Value {
    let mut packs: Vec<Value> = PACK_CATALOG
        .iter()
@@ -203,10 +409,11 @@ pub fn build_purchasegroup(unopened_ids: &[u64], mode: StoreMode) -> Value {

 #[cfg(test)]
 mod tests {
-    //! Differential parity against the Python oracle. The fixtures under
-    //! `tests/fixtures/purchasegroup_*.json` are generated by calling the oracle's
-    //! `_pack_body`/`store_catalog` at production flag defaults; Rust must match
-    //! them semantically (object key order is irrelevant to `serde_json::Value` eq).
+    //! Golden tests pinning the authoritative Rust `/store/purchasegroup` body. The
+    //! fixtures under `tests/fixtures/purchasegroup_*.json` are Rust's own output
+    //! (object key order is irrelevant to `serde_json::Value` eq). They track the
+    //! RE-driven divergence from the Python oracle — notably no `extPrice` (see the
+    //! module header).
    use super::*;

    fn parse(s: &str) -> Value {
@@ -214,7 +421,7 @@ mod tests {
    }

    #[test]
-    fn purchasegroup_zero_sentinel_matches_oracle() {
+    fn purchasegroup_zero_sentinel_matches_golden() {
        let got = build_purchasegroup(&[], StoreMode::Sentinel);
        let want = parse(include_str!(
            "../../tests/fixtures/purchasegroup_zero_sentinel.json"
@@ -223,7 +430,7 @@ mod tests {
    }

    #[test]
-    fn purchasegroup_zero_clean_matches_oracle() {
+    fn purchasegroup_zero_clean_matches_golden() {
        let got = build_purchasegroup(&[], StoreMode::CleanV1);
        let want = parse(include_str!(
            "../../tests/fixtures/purchasegroup_zero_clean.json"
@@ -232,7 +439,7 @@ mod tests {
    }

    #[test]
-    fn purchasegroup_pack70_matches_oracle() {
+    fn purchasegroup_pack70_matches_golden() {
        // Owned pack present -> no sentinel regardless of mode.
        let got = build_purchasegroup(&[70], StoreMode::Sentinel);
        let want = parse(include_str!(
@@ -247,6 +454,68 @@ mod tests {
        assert!(PACK_CATALOG.iter().all(|p| p.id != SENTINEL_PACK_ID));
    }

+    #[test]
+    fn reward_pack_definitions_resolve_to_openable_owned_packs() {
+        // Core reward services grant symbolic pack names; each must resolve to an
+        // owned-only catalogue pack so it renders as an openable My Packs tile.
+        for (def, want) in [
+            ("bronze_pack", 71),
+            ("silver_pack", 72),
+            ("gold_pack", 73),
+            ("rare_gold_pack", 74),
+            ("icon_pack", 75),
+        ] {
+            let id = owned_pack_id_for_definition(def).expect("reward def resolves");
+            assert_eq!(id, want);
+            assert!(
+                pack_by_id(id).unwrap().owned_only,
+                "a reward pack must be owned-only"
+            );
+        }
+        // Imported numeric owned-pack ids resolve to themselves.
+        assert_eq!(owned_pack_id_for_definition("70"), Some(70));
+        // Purchasable (non-owned) numeric ids and unknown names never resolve.
+        assert_eq!(owned_pack_id_for_definition("5"), None);
+        assert_eq!(owned_pack_id_for_definition("mystery_pack"), None);
+    }
+
+    #[test]
+    fn reward_tiles_carry_a_renderable_cover_asset() {
+        // A reward pack's own id is not a client art asset, so its My Packs tile
+        // renders blank. Each reward tile must therefore carry a valid catalogue
+        // assetId (its tier's store pack) while `id` stays the open packId.
+        for (reward_id, want_asset) in [(71, 1), (72, 3), (73, 5), (74, 5), (75, 5)] {
+            let pack = pack_by_id(reward_id).expect("reward pack in catalogue");
+            let tile = pack_body(pack, 1, true);
+            assert_eq!(tile["id"], reward_id, "open packId stays the pack's own id");
+            assert_eq!(
+                tile["assetId"], want_asset,
+                "reward tile borrows its tier's store-pack cover asset"
+            );
+            assert!(
+                pack_by_id(tile["assetId"].as_u64().unwrap()).is_some_and(|p| !p.owned_only),
+                "the cover asset must be a real purchasable catalogue pack"
+            );
+        }
+        // The sentinel must NOT borrow a real cover — it stays an inert placeholder.
+        assert_eq!(sentinel_body(1)["assetId"], SENTINEL_PACK_ID);
+    }
+
+    #[test]
+    fn symbolic_reward_pack_renders_as_openable_my_packs_tile() {
+        // A granted silver reward pack (resolved to id 72) must appear as an owned
+        // My Packs tile, not the non-openable sentinel shim.
+        let got = build_purchasegroup(&[72], StoreMode::Sentinel);
+        let packs = got["purchase"].as_array().unwrap();
+        let reward = packs
+            .iter()
+            .find(|p| p["id"] == 72)
+            .expect("reward pack tile present");
+        assert_eq!(reward["displayGroup"]["value"], "mypacks");
+        assert!(reward["unopened"].as_bool().unwrap());
+        assert!(packs.iter().all(|p| p["id"] != SENTINEL_PACK_ID));
+    }
+
    #[test]
    fn clean_v1_empty_emits_no_mypacks_group() {
        let got = build_purchasegroup(&[], StoreMode::CleanV1);
@@ -256,13 +525,13 @@ mod tests {
            .iter()
            .map(|e| e["id"].as_u64().unwrap())
            .collect();
-        assert_eq!(ids, vec![1, 5, 6, 7]);
+        assert_eq!(ids, vec![1, 2, 3, 4, 5, 6]);
    }

    #[test]
    fn category_tokens_are_canonical() {
        assert_eq!(category(pack_by_id(1).unwrap()), "bronze");
+        assert_eq!(category(pack_by_id(3).unwrap()), "silver");
        assert_eq!(category(pack_by_id(5).unwrap()), "gold");
-        assert_eq!(category(pack_by_id(7).unwrap()), "special");
    }
 }
@@ -2,197 +2,235 @@
  "purchase": [
    {
      "assetId": 1,
+      "id": 1,
+      "packType": "BRONZE",
+      "description": "Bronze Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 1,
+      "displayGroupAssetId": 1,
      "currencies": [
        {
-          "finalFunds": 400,
+          "name": "coins",
          "funds": 400,
-          "name": "coins"
+          "finalFunds": 400
        }
      ],
-      "description": "Bronze Pack",
+      "packContentInfo": {
+        "bronzeQuantity": 10,
+        "silverQuantity": 2,
+        "goldQuantity": 0,
+        "rareQuantity": 1,
+        "itemQuantity": 12
+      },
+      "unopened": false,
      "displayGroup": {
        "value": "bronze"
-      },
-      "extPrice": {
-        "finalPrice": {
-          "amount": 4,
-          "currency": "mtx"
-        },
-        "originalPrice": {
-          "amount": 4,
-          "currency": "mtx"
-        }
-      },
-      "id": 1,
-      "isPremium": false,
-      "limitType": "NONE",
-      "packContentInfo": {
-        "bronzeQuantity": 5,
-        "goldQuantity": 0,
-        "itemQuantity": 5,
-        "rareQuantity": 0,
-        "silverQuantity": 0
-      },
+      }
+    },
+    {
+      "assetId": 2,
+      "id": 2,
      "packType": "BRONZE",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 1,
+      "description": "Premium Bronze Pack",
      "state": "active",
-      "unopened": false
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 2,
+      "displayGroupAssetId": 1,
+      "currencies": [
+        {
+          "name": "coins",
+          "funds": 750,
+          "finalFunds": 750
+        }
+      ],
+      "packContentInfo": {
+        "bronzeQuantity": 10,
+        "silverQuantity": 2,
+        "goldQuantity": 0,
+        "rareQuantity": 3,
+        "itemQuantity": 12
+      },
+      "unopened": false,
+      "displayGroup": {
+        "value": "bronze"
+      }
+    },
+    {
+      "assetId": 3,
+      "id": 3,
+      "packType": "SILVER",
+      "description": "Silver Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 3,
+      "displayGroupAssetId": 2,
+      "currencies": [
+        {
+          "name": "coins",
+          "funds": 2500,
+          "finalFunds": 2500
+        }
+      ],
+      "packContentInfo": {
+        "bronzeQuantity": 1,
+        "silverQuantity": 11,
+        "goldQuantity": 0,
+        "rareQuantity": 1,
+        "itemQuantity": 12
+      },
+      "unopened": false,
+      "displayGroup": {
+        "value": "silver"
+      }
+    },
+    {
+      "assetId": 4,
+      "id": 4,
+      "packType": "SILVER",
+      "description": "Premium Silver Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 4,
+      "displayGroupAssetId": 2,
+      "currencies": [
+        {
+          "name": "coins",
+          "funds": 3750,
+          "finalFunds": 3750
+        }
+      ],
+      "packContentInfo": {
+        "bronzeQuantity": 1,
+        "silverQuantity": 11,
+        "goldQuantity": 0,
+        "rareQuantity": 3,
+        "itemQuantity": 12
+      },
+      "unopened": false,
+      "displayGroup": {
+        "value": "silver"
+      }
    },
    {
      "assetId": 5,
+      "id": 5,
+      "packType": "GOLD",
+      "description": "Gold Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 5,
+      "displayGroupAssetId": 3,
      "currencies": [
        {
-          "finalFunds": 5000,
+          "name": "coins",
          "funds": 5000,
-          "name": "coins"
+          "finalFunds": 5000
        }
      ],
-      "description": "Gold Pack",
-      "displayGroup": {
-        "value": "gold"
-      },
-      "extPrice": {
-        "finalPrice": {
-          "amount": 50,
-          "currency": "mtx"
-        },
-        "originalPrice": {
-          "amount": 50,
-          "currency": "mtx"
-        }
-      },
-      "id": 5,
-      "isPremium": false,
-      "limitType": "NONE",
      "packContentInfo": {
        "bronzeQuantity": 0,
-        "goldQuantity": 7,
-        "itemQuantity": 7,
-        "rareQuantity": 7,
-        "silverQuantity": 0
+        "silverQuantity": 2,
+        "goldQuantity": 10,
+        "rareQuantity": 1,
+        "itemQuantity": 12
      },
-      "packType": "GOLD",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 2,
-      "state": "active",
-      "unopened": false
+      "unopened": false,
+      "displayGroup": {
+        "value": "gold"
+      }
    },
    {
      "assetId": 6,
+      "id": 6,
+      "packType": "GOLD",
+      "description": "Premium Gold Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 6,
+      "displayGroupAssetId": 3,
      "currencies": [
        {
-          "finalFunds": 15000,
-          "funds": 15000,
-          "name": "coins"
+          "name": "coins",
+          "funds": 7500,
+          "finalFunds": 7500
        }
      ],
-      "description": "Premium Gold",
+      "packContentInfo": {
+        "bronzeQuantity": 0,
+        "silverQuantity": 2,
+        "goldQuantity": 10,
+        "rareQuantity": 3,
+        "itemQuantity": 12
+      },
+      "unopened": false,
      "displayGroup": {
        "value": "gold"
-      },
-      "extPrice": {
-        "finalPrice": {
-          "amount": 150,
-          "currency": "mtx"
-        },
-        "originalPrice": {
-          "amount": 150,
-          "currency": "mtx"
-        }
-      },
-      "id": 6,
-      "isPremium": false,
-      "limitType": "NONE",
-      "packContentInfo": {
-        "bronzeQuantity": 0,
-        "goldQuantity": 11,
-        "itemQuantity": 11,
-        "rareQuantity": 11,
-        "silverQuantity": 0
-      },
-      "packType": "GOLD",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 3,
-      "state": "active",
-      "unopened": false
+      }
    },
    {
-      "assetId": 7,
+      "assetId": 5,
+      "id": 70,
+      "packType": "GOLD",
+      "description": "Reward Gold Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 1,
+      "displayGroupAssetId": 3,
      "currencies": [
        {
-          "finalFunds": 25000,
-          "funds": 25000,
-          "name": "coins"
+          "name": "coins",
+          "funds": 0,
+          "finalFunds": 0
        }
      ],
-      "description": "Special Players Pack",
-      "displayGroup": {
-        "value": "special"
-      },
-      "extPrice": {
-        "finalPrice": {
-          "amount": 250,
-          "currency": "mtx"
-        },
-        "originalPrice": {
-          "amount": 250,
-          "currency": "mtx"
-        }
-      },
-      "id": 7,
-      "isPremium": false,
-      "limitType": "NONE",
      "packContentInfo": {
        "bronzeQuantity": 0,
+        "silverQuantity": 0,
        "goldQuantity": 11,
-        "itemQuantity": 11,
        "rareQuantity": 11,
-        "silverQuantity": 0
+        "itemQuantity": 11
      },
-      "packType": "GOLD",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 4,
-      "state": "active",
-      "unopened": false
-    },
-    {
-      "assetId": 70,
-      "description": "Reward Special Players Pack",
+      "unopened": true,
      "displayGroup": {
-        "priority": 1,
-        "value": "mypacks"
-      },
-      "id": 70,
-      "isPremium": false,
-      "limitType": "NONE",
-      "packContentInfo": {
-        "bronzeQuantity": 0,
-        "goldQuantity": 11,
-        "itemQuantity": 11,
-        "rareQuantity": 11,
-        "silverQuantity": 0
-      },
-      "packType": "GOLD",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 1,
-      "state": "active",
-      "unopened": true
+        "value": "mypacks",
+        "priority": 1
+      }
    }
  ],
  "timestamp": 1596326400
@@ -2,171 +2,201 @@
  "purchase": [
    {
      "assetId": 1,
+      "id": 1,
+      "packType": "BRONZE",
+      "description": "Bronze Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 1,
+      "displayGroupAssetId": 1,
      "currencies": [
        {
-          "finalFunds": 400,
+          "name": "coins",
          "funds": 400,
-          "name": "coins"
+          "finalFunds": 400
        }
      ],
-      "description": "Bronze Pack",
+      "packContentInfo": {
+        "bronzeQuantity": 10,
+        "silverQuantity": 2,
+        "goldQuantity": 0,
+        "rareQuantity": 1,
+        "itemQuantity": 12
+      },
+      "unopened": false,
      "displayGroup": {
        "value": "bronze"
-      },
-      "extPrice": {
-        "finalPrice": {
-          "amount": 4,
-          "currency": "mtx"
-        },
-        "originalPrice": {
-          "amount": 4,
-          "currency": "mtx"
-        }
-      },
-      "id": 1,
-      "isPremium": false,
-      "limitType": "NONE",
-      "packContentInfo": {
-        "bronzeQuantity": 5,
-        "goldQuantity": 0,
-        "itemQuantity": 5,
-        "rareQuantity": 0,
-        "silverQuantity": 0
-      },
+      }
+    },
+    {
+      "assetId": 2,
+      "id": 2,
      "packType": "BRONZE",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 1,
+      "description": "Premium Bronze Pack",
      "state": "active",
-      "unopened": false
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 2,
+      "displayGroupAssetId": 1,
+      "currencies": [
+        {
+          "name": "coins",
+          "funds": 750,
+          "finalFunds": 750
+        }
+      ],
+      "packContentInfo": {
+        "bronzeQuantity": 10,
+        "silverQuantity": 2,
+        "goldQuantity": 0,
+        "rareQuantity": 3,
+        "itemQuantity": 12
+      },
+      "unopened": false,
+      "displayGroup": {
+        "value": "bronze"
+      }
+    },
+    {
+      "assetId": 3,
+      "id": 3,
+      "packType": "SILVER",
+      "description": "Silver Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 3,
+      "displayGroupAssetId": 2,
+      "currencies": [
+        {
+          "name": "coins",
+          "funds": 2500,
+          "finalFunds": 2500
+        }
+      ],
+      "packContentInfo": {
+        "bronzeQuantity": 1,
+        "silverQuantity": 11,
+        "goldQuantity": 0,
+        "rareQuantity": 1,
+        "itemQuantity": 12
+      },
+      "unopened": false,
+      "displayGroup": {
+        "value": "silver"
+      }
+    },
+    {
+      "assetId": 4,
+      "id": 4,
+      "packType": "SILVER",
+      "description": "Premium Silver Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 4,
+      "displayGroupAssetId": 2,
+      "currencies": [
+        {
+          "name": "coins",
+          "funds": 3750,
+          "finalFunds": 3750
+        }
+      ],
+      "packContentInfo": {
+        "bronzeQuantity": 1,
+        "silverQuantity": 11,
+        "goldQuantity": 0,
+        "rareQuantity": 3,
+        "itemQuantity": 12
+      },
+      "unopened": false,
+      "displayGroup": {
+        "value": "silver"
+      }
    },
    {
      "assetId": 5,
+      "id": 5,
+      "packType": "GOLD",
+      "description": "Gold Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 5,
+      "displayGroupAssetId": 3,
      "currencies": [
        {
-          "finalFunds": 5000,
+          "name": "coins",
          "funds": 5000,
-          "name": "coins"
+          "finalFunds": 5000
        }
      ],
-      "description": "Gold Pack",
-      "displayGroup": {
-        "value": "gold"
-      },
-      "extPrice": {
-        "finalPrice": {
-          "amount": 50,
-          "currency": "mtx"
-        },
-        "originalPrice": {
-          "amount": 50,
-          "currency": "mtx"
-        }
-      },
-      "id": 5,
-      "isPremium": false,
-      "limitType": "NONE",
      "packContentInfo": {
        "bronzeQuantity": 0,
-        "goldQuantity": 7,
-        "itemQuantity": 7,
-        "rareQuantity": 7,
-        "silverQuantity": 0
+        "silverQuantity": 2,
+        "goldQuantity": 10,
+        "rareQuantity": 1,
+        "itemQuantity": 12
      },
-      "packType": "GOLD",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 2,
-      "state": "active",
-      "unopened": false
+      "unopened": false,
+      "displayGroup": {
+        "value": "gold"
+      }
    },
    {
      "assetId": 6,
+      "id": 6,
+      "packType": "GOLD",
+      "description": "Premium Gold Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 6,
+      "displayGroupAssetId": 3,
      "currencies": [
        {
-          "finalFunds": 15000,
-          "funds": 15000,
-          "name": "coins"
+          "name": "coins",
+          "funds": 7500,
+          "finalFunds": 7500
        }
      ],
-      "description": "Premium Gold",
+      "packContentInfo": {
+        "bronzeQuantity": 0,
+        "silverQuantity": 2,
+        "goldQuantity": 10,
+        "rareQuantity": 3,
+        "itemQuantity": 12
+      },
+      "unopened": false,
      "displayGroup": {
        "value": "gold"
-      },
-      "extPrice": {
-        "finalPrice": {
-          "amount": 150,
-          "currency": "mtx"
-        },
-        "originalPrice": {
-          "amount": 150,
-          "currency": "mtx"
-        }
-      },
-      "id": 6,
-      "isPremium": false,
-      "limitType": "NONE",
-      "packContentInfo": {
-        "bronzeQuantity": 0,
-        "goldQuantity": 11,
-        "itemQuantity": 11,
-        "rareQuantity": 11,
-        "silverQuantity": 0
-      },
-      "packType": "GOLD",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 3,
-      "state": "active",
-      "unopened": false
-    },
-    {
-      "assetId": 7,
-      "currencies": [
-        {
-          "finalFunds": 25000,
-          "funds": 25000,
-          "name": "coins"
-        }
-      ],
-      "description": "Special Players Pack",
-      "displayGroup": {
-        "value": "special"
-      },
-      "extPrice": {
-        "finalPrice": {
-          "amount": 250,
-          "currency": "mtx"
-        },
-        "originalPrice": {
-          "amount": 250,
-          "currency": "mtx"
-        }
-      },
-      "id": 7,
-      "isPremium": false,
-      "limitType": "NONE",
-      "packContentInfo": {
-        "bronzeQuantity": 0,
-        "goldQuantity": 11,
-        "itemQuantity": 11,
-        "rareQuantity": 11,
-        "silverQuantity": 0
-      },
-      "packType": "GOLD",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 4,
-      "state": "active",
-      "unopened": false
+      }
    }
  ],
  "timestamp": 1596326400
@@ -2,197 +2,228 @@
  "purchase": [
    {
      "assetId": 1,
+      "id": 1,
+      "packType": "BRONZE",
+      "description": "Bronze Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 1,
+      "displayGroupAssetId": 1,
      "currencies": [
        {
-          "finalFunds": 400,
+          "name": "coins",
          "funds": 400,
-          "name": "coins"
+          "finalFunds": 400
        }
      ],
-      "description": "Bronze Pack",
+      "packContentInfo": {
+        "bronzeQuantity": 10,
+        "silverQuantity": 2,
+        "goldQuantity": 0,
+        "rareQuantity": 1,
+        "itemQuantity": 12
+      },
+      "unopened": false,
      "displayGroup": {
        "value": "bronze"
-      },
-      "extPrice": {
-        "finalPrice": {
-          "amount": 4,
-          "currency": "mtx"
-        },
-        "originalPrice": {
-          "amount": 4,
-          "currency": "mtx"
-        }
-      },
-      "id": 1,
-      "isPremium": false,
-      "limitType": "NONE",
-      "packContentInfo": {
-        "bronzeQuantity": 5,
-        "goldQuantity": 0,
-        "itemQuantity": 5,
-        "rareQuantity": 0,
-        "silverQuantity": 0
-      },
+      }
+    },
+    {
+      "assetId": 2,
+      "id": 2,
      "packType": "BRONZE",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 1,
+      "description": "Premium Bronze Pack",
      "state": "active",
-      "unopened": false
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 2,
+      "displayGroupAssetId": 1,
+      "currencies": [
+        {
+          "name": "coins",
+          "funds": 750,
+          "finalFunds": 750
+        }
+      ],
+      "packContentInfo": {
+        "bronzeQuantity": 10,
+        "silverQuantity": 2,
+        "goldQuantity": 0,
+        "rareQuantity": 3,
+        "itemQuantity": 12
+      },
+      "unopened": false,
+      "displayGroup": {
+        "value": "bronze"
+      }
+    },
+    {
+      "assetId": 3,
+      "id": 3,
+      "packType": "SILVER",
+      "description": "Silver Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 3,
+      "displayGroupAssetId": 2,
+      "currencies": [
+        {
+          "name": "coins",
+          "funds": 2500,
+          "finalFunds": 2500
+        }
+      ],
+      "packContentInfo": {
+        "bronzeQuantity": 1,
+        "silverQuantity": 11,
+        "goldQuantity": 0,
+        "rareQuantity": 1,
+        "itemQuantity": 12
+      },
+      "unopened": false,
+      "displayGroup": {
+        "value": "silver"
+      }
+    },
+    {
+      "assetId": 4,
+      "id": 4,
+      "packType": "SILVER",
+      "description": "Premium Silver Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 4,
+      "displayGroupAssetId": 2,
+      "currencies": [
+        {
+          "name": "coins",
+          "funds": 3750,
+          "finalFunds": 3750
+        }
+      ],
+      "packContentInfo": {
+        "bronzeQuantity": 1,
+        "silverQuantity": 11,
+        "goldQuantity": 0,
+        "rareQuantity": 3,
+        "itemQuantity": 12
+      },
+      "unopened": false,
+      "displayGroup": {
+        "value": "silver"
+      }
    },
    {
      "assetId": 5,
+      "id": 5,
+      "packType": "GOLD",
+      "description": "Gold Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 5,
+      "displayGroupAssetId": 3,
      "currencies": [
        {
-          "finalFunds": 5000,
+          "name": "coins",
          "funds": 5000,
-          "name": "coins"
+          "finalFunds": 5000
        }
      ],
-      "description": "Gold Pack",
-      "displayGroup": {
-        "value": "gold"
-      },
-      "extPrice": {
-        "finalPrice": {
-          "amount": 50,
-          "currency": "mtx"
-        },
-        "originalPrice": {
-          "amount": 50,
-          "currency": "mtx"
-        }
-      },
-      "id": 5,
-      "isPremium": false,
-      "limitType": "NONE",
      "packContentInfo": {
        "bronzeQuantity": 0,
-        "goldQuantity": 7,
-        "itemQuantity": 7,
-        "rareQuantity": 7,
-        "silverQuantity": 0
+        "silverQuantity": 2,
+        "goldQuantity": 10,
+        "rareQuantity": 1,
+        "itemQuantity": 12
      },
-      "packType": "GOLD",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 2,
-      "state": "active",
-      "unopened": false
+      "unopened": false,
+      "displayGroup": {
+        "value": "gold"
+      }
    },
    {
      "assetId": 6,
+      "id": 6,
+      "packType": "GOLD",
+      "description": "Premium Gold Pack",
+      "state": "active",
+      "saleType": "promo",
+      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 6,
+      "displayGroupAssetId": 3,
      "currencies": [
        {
-          "finalFunds": 15000,
-          "funds": 15000,
-          "name": "coins"
+          "name": "coins",
+          "funds": 7500,
+          "finalFunds": 7500
        }
      ],
-      "description": "Premium Gold",
+      "packContentInfo": {
+        "bronzeQuantity": 0,
+        "silverQuantity": 2,
+        "goldQuantity": 10,
+        "rareQuantity": 3,
+        "itemQuantity": 12
+      },
+      "unopened": false,
      "displayGroup": {
        "value": "gold"
-      },
-      "extPrice": {
-        "finalPrice": {
-          "amount": 150,
-          "currency": "mtx"
-        },
-        "originalPrice": {
-          "amount": 150,
-          "currency": "mtx"
-        }
-      },
-      "id": 6,
-      "isPremium": false,
-      "limitType": "NONE",
-      "packContentInfo": {
-        "bronzeQuantity": 0,
-        "goldQuantity": 11,
-        "itemQuantity": 11,
-        "rareQuantity": 11,
-        "silverQuantity": 0
-      },
-      "packType": "GOLD",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 3,
-      "state": "active",
-      "unopened": false
-    },
-    {
-      "assetId": 7,
-      "currencies": [
-        {
-          "finalFunds": 25000,
-          "funds": 25000,
-          "name": "coins"
-        }
-      ],
-      "description": "Special Players Pack",
-      "displayGroup": {
-        "value": "special"
-      },
-      "extPrice": {
-        "finalPrice": {
-          "amount": 250,
-          "currency": "mtx"
-        },
-        "originalPrice": {
-          "amount": 250,
-          "currency": "mtx"
-        }
-      },
-      "id": 7,
-      "isPremium": false,
-      "limitType": "NONE",
-      "packContentInfo": {
-        "bronzeQuantity": 0,
-        "goldQuantity": 11,
-        "itemQuantity": 11,
-        "rareQuantity": 11,
-        "silverQuantity": 0
-      },
-      "packType": "GOLD",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 4,
-      "state": "active",
-      "unopened": false
+      }
    },
    {
      "assetId": 65534,
-      "description": "",
-      "displayGroup": {
-        "priority": 1,
-        "value": "mypacks"
-      },
      "id": 65534,
-      "isPremium": false,
+      "packType": "GOLD",
+      "description": "",
+      "state": "active",
+      "saleType": "promo",
      "limitType": "NONE",
+      "quantity": 0,
+      "purchaseLimit": 0,
+      "purchaseCount": 0,
+      "isPremium": false,
+      "sortPriority": 1,
+      "displayGroupAssetId": 3,
      "packContentInfo": {
        "bronzeQuantity": 0,
+        "silverQuantity": 0,
        "goldQuantity": 0,
-        "itemQuantity": 0,
        "rareQuantity": 0,
-        "silverQuantity": 0
+        "itemQuantity": 0
      },
-      "packType": "GOLD",
-      "purchaseCount": 0,
-      "purchaseLimit": 0,
-      "quantity": 0,
-      "saleType": "promo",
-      "sortPriority": 1,
-      "state": "active",
-      "unopened": false
+      "unopened": false,
+      "displayGroup": {
+        "value": "mypacks",
+        "priority": 1
+      }
    }
  ],
  "timestamp": 1596326400
@@ -11,8 +11,9 @@
 //! ```
 //!
 //! Fidelity is asserted by ownership class:
-//!   CANONICAL  player instance per index, formation, captain, bench split
-//!   EXTENSION  custom, kicktakers, manager, kit numbers (by player), squadType
+//!   CANONICAL  player instance per index, formation, captain, bench split, and
+//!              the ownership-backed manager assignment (migration 0023)
+//!   EXTENSION  custom, kicktakers, kit numbers (by player), squadType
 //!   SHADOW     chemistry/rating/starRating (client-reported, round-tripped as-is)
 //!   DERIVED    correct FIFA 17 item identity (wire id + resourceId)
 //!
@@ -146,6 +147,9 @@ fn project_put(
        slots,
        ext: SquadExtInput::Fresh(extension),
        owned,
+        // This stand-in supplies no owned manager; the manager is projected from
+        // the ownership-backed assignment, exercised in persisted_read below.
+        manager: None,
    };
    match project_squad(&input, ident, &NoEntities).unwrap() {
        SquadProjection::Projected(v) => v,
@@ -194,9 +198,11 @@ fn baseline_projects_the_known_squad_round_trip() {
        projected["captain"], 100000001,
        "captain is the player's WIRE id"
    );
-    // EXTENSION: custom byte-identical, manager + squadType preserved.
+    // EXTENSION: custom byte-identical, squadType preserved. The manager is now
+    // an ownership-backed assignment (not projected from the PUT/ext); with none
+    // supplied to this stand-in it projects empty.
    assert_eq!(projected["custom"], put_v["custom"]);
-    assert_eq!(projected["manager"], put_v["manager"]);
+    assert!(projected["manager"].as_array().unwrap().is_empty());
    assert_eq!(projected["squadType"], "REGULAR_SQUAD");
    // SHADOW: client-reported values carried as-is (baseline chemistry 52).
    assert_eq!(projected["chemistry"], 52);
@@ -268,13 +274,11 @@ fn persisted_read_round_trips_via_reconstructed_canonical_and_extension() {
    // evidence, then project and require the read back — the strongest fidelity
    // check across all four ownership classes.
    use openfut_adapter_fifa17::fut::squad::ClientReportedSquadEval;
-    use openfut_adapter_fifa17::fut::squad_ext::{
-        Fifa17SquadExtensionV1, KicktakerRef, WireItemRef,
-    };
+    use openfut_adapter_fifa17::fut::squad_ext::{Fifa17SquadExtensionV1, KicktakerRef};
    use std::collections::BTreeMap;

    let oracle: Value = serde_json::from_str(READ_ORACLE).unwrap();
-    let (owned, ident) = oracle_tables();
+    let (owned, mut ident) = oracle_tables();
    let captain = oracle["captain"].as_i64().unwrap();

    let mut slots = Vec::new();
@@ -294,14 +298,35 @@ fn persisted_read_round_trips_via_reconstructed_canonical_and_extension() {
            is_on_bench: index >= 11,
        });
    }
-    let manager: Vec<WireItemRef> = serde_json::from_value(oracle["manager"].clone()).unwrap();
+    // The manager is now ownership-backed: register its owned instance + identity
+    // and pass it as the assignment, not as an opaque extension field.
+    let mgr_wire = oracle["manager"][0]["id"].as_i64().unwrap();
+    let mgr_oc = format!("oc-{mgr_wire}");
+    ident.0.insert(
+        mgr_oc.clone(),
+        Fifa17Identity {
+            item_id: mgr_wire as u32,
+            asset_id: 5001,
+            resource_id: 5001,
+            rareflag: 1,
+        },
+    );
+    let manager_item = CoreOwnedItem {
+        owned_card_id: mgr_oc,
+        card_id: "def-manager".to_string(),
+        rating: 0,
+        position: String::new(),
+        nation: String::new(),
+        league: String::new(),
+        club: String::new(),
+        attributes: [0; 6],
+    };
    let kicktakers: Vec<KicktakerRef> =
        serde_json::from_value(oracle["kicktakers"].clone()).unwrap();
    let ext = Fifa17SquadExtensionV1 {
        custom: oracle["custom"].as_str().map(str::to_string),
        squad_type: oracle["squadType"].as_str().map(str::to_string),
        kit_numbers,
-        manager,
        kicktakers,
        client_reported: ClientReportedSquadEval {
            chemistry: oracle["chemistry"].as_i64(),
@@ -316,6 +341,7 @@ fn persisted_read_round_trips_via_reconstructed_canonical_and_extension() {
        slots,
        ext: SquadExtInput::Fresh(ext),
        owned: &owned,
+        manager: Some(manager_item),
    };
    let SquadProjection::Projected(projected) = project_squad(&input, &ident, &NoEntities).unwrap()
    else {
@@ -208,7 +208,15 @@ pub fn plan_apply(
            .and_then(|s| s.get(0))
            .context("report says a squad is present but profile has no squads[0]")?;
        let body = serde_json::to_vec(raw_squad).context("re-serialize source squad")?;
-        let put = parse_squad_put(&body).map_err(|e| anyhow::anyhow!("parse source squad: {e}"))?;
+        let mut put =
+            parse_squad_put(&body).map_err(|e| anyhow::anyhow!("parse source squad: {e}"))?;
+        // A HISTORICAL profile may reference a manager whose owned instance is
+        // not imported (unsupported/deferred, or a dangling id with no owned
+        // item at all). Drop such a manager ref here rather than failing the
+        // whole import — the manager assignment is only imported when its owned
+        // instance is. (A LIVE squad PUT still refuses an unresolved manager,
+        // because the client is actively assigning one it must own.)
+        put.manager.retain(|m| wire_to_owned.contains_key(&m.id));
        let build = build_squad_write(&put, &MapResolver(&wire_to_owned))
            .map_err(|e| anyhow::anyhow!("build squad write: {e}"))?;
        let formation = build
@@ -3,6 +3,18 @@
 //! collide with the live oracle). `core_url` defaults to Bridge's convention.

 use std::env;
+const SBC_FAULT_ACK: &str = "staging-only-sbc-receipt-loss";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum SbcPostCommitFault {
+    #[default]
+    Off,
+    Drop,
+    Malformed,
+    Delay {
+        millis: u64,
+    },
+}

 #[derive(Debug, Clone)]
 pub struct HostConfig {
@@ -44,6 +56,9 @@ pub struct HostConfig {
    /// `OPENFUT_ACCOUNT_PATH`, then existing `FUT_ACCOUNT_PATH`, then the
    /// identity store's parent directory + `active_account.json`.
    pub account_path: String,
+    /// Disabled by default. Non-off values require three explicit staging guards;
+    /// see [`parse_sbc_post_commit_fault`].
+    pub sbc_post_commit_fault: SbcPostCommitFault,
 }

 #[derive(Debug)]
@@ -76,9 +91,68 @@ fn required_i64_nonzero(key: &str) -> Result<i64, ConfigError> {
    Ok(val)
 }

+fn parse_sbc_post_commit_fault(
+    raw: Option<&str>,
+    environment: Option<&str>,
+    ack: Option<&str>,
+    listen_addr: &str,
+) -> Result<SbcPostCommitFault, ConfigError> {
+    let mode = match raw.filter(|value| !value.is_empty()).unwrap_or("off") {
+        "off" => return Ok(SbcPostCommitFault::Off),
+        "drop" => SbcPostCommitFault::Drop,
+        "malformed" => SbcPostCommitFault::Malformed,
+        value if value.starts_with("delay:") => {
+            let millis = value["delay:".len()..].parse::<u64>().map_err(|_| {
+                ConfigError(
+                    "OPENFUT_FIFA17_SBC_POST_COMMIT_FAULT delay must be delay:<milliseconds>"
+                        .into(),
+                )
+            })?;
+            if !(1..=30_000).contains(&millis) {
+                return Err(ConfigError(
+                    "OPENFUT_FIFA17_SBC_POST_COMMIT_FAULT delay must be 1..=30000 ms".into(),
+                ));
+            }
+            SbcPostCommitFault::Delay { millis }
+        }
+        value => {
+            return Err(ConfigError(format!(
+                "OPENFUT_FIFA17_SBC_POST_COMMIT_FAULT must be off, drop, malformed, or delay:<milliseconds>; got {value:?}"
+            )));
+        }
+    };
+    if environment != Some("staging") {
+        return Err(ConfigError(
+            "SBC post-commit faults require OPENFUT_ENVIRONMENT=staging".into(),
+        ));
+    }
+    if ack != Some(SBC_FAULT_ACK) {
+        return Err(ConfigError(format!(
+            "SBC post-commit faults require OPENFUT_FIFA17_SBC_POST_COMMIT_FAULT_ACK={SBC_FAULT_ACK}"
+        )));
+    }
+    if listen_addr.rsplit_once(':').map(|(_, port)| port) == Some("8099") {
+        return Err(ConfigError(
+            "SBC post-commit faults refuse the production UTAS port 8099".into(),
+        ));
+    }
+    Ok(mode)
+}
+
 impl HostConfig {
    pub fn from_env() -> Result<Self, ConfigError> {
        let identity_store_path = required("OPENFUT_IDENTITY_STORE")?;
+        let listen_addr = required("OPENFUT_UTAS_HOST_ADDR")?;
+        let sbc_post_commit_fault = parse_sbc_post_commit_fault(
+            env::var("OPENFUT_FIFA17_SBC_POST_COMMIT_FAULT")
+                .ok()
+                .as_deref(),
+            env::var("OPENFUT_ENVIRONMENT").ok().as_deref(),
+            env::var("OPENFUT_FIFA17_SBC_POST_COMMIT_FAULT_ACK")
+                .ok()
+                .as_deref(),
+            &listen_addr,
+        )?;
        let clientdata_path = env::var("OPENFUT_CLIENTDATA_DB")
            .ok()
            .filter(|v| !v.is_empty())
@@ -89,7 +163,7 @@ impl HostConfig {
            .or_else(|| env::var("FUT_ACCOUNT_PATH").ok().filter(|v| !v.is_empty()))
            .unwrap_or_else(|| default_account_path(&identity_store_path));
        Ok(HostConfig {
-            listen_addr: required("OPENFUT_UTAS_HOST_ADDR")?,
+            listen_addr,
            python_upstream: required("OPENFUT_UTAS_PYTHON_URL")?,
            core_url: env::var("OPENFUT_CORE_URL")
                .unwrap_or_else(|_| "http://127.0.0.1:8080".into()),
@@ -102,6 +176,7 @@ impl HostConfig {
            identity_store_path,
            clientdata_path,
            account_path,
+            sbc_post_commit_fault,
        })
    }
 }
@@ -125,3 +200,57 @@ fn default_account_path(identity_store_path: &str) -> String {
        .to_string_lossy()
        .into_owned()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sbc_post_commit_faults_require_all_staging_guards() {
+        assert_eq!(
+            parse_sbc_post_commit_fault(None, None, None, "0.0.0.0:8099").unwrap(),
+            SbcPostCommitFault::Off
+        );
+        assert!(parse_sbc_post_commit_fault(
+            Some("drop"),
+            None,
+            Some(SBC_FAULT_ACK),
+            "127.0.0.1:18199"
+        )
+        .is_err());
+        assert!(parse_sbc_post_commit_fault(
+            Some("drop"),
+            Some("staging"),
+            None,
+            "127.0.0.1:18199"
+        )
+        .is_err());
+        assert!(parse_sbc_post_commit_fault(
+            Some("drop"),
+            Some("staging"),
+            Some(SBC_FAULT_ACK),
+            "0.0.0.0:8099"
+        )
+        .is_err());
+        assert_eq!(
+            parse_sbc_post_commit_fault(
+                Some("drop"),
+                Some("staging"),
+                Some(SBC_FAULT_ACK),
+                "0.0.0.0:18199"
+            )
+            .unwrap(),
+            SbcPostCommitFault::Drop
+        );
+        assert_eq!(
+            parse_sbc_post_commit_fault(
+                Some("delay:25"),
+                Some("staging"),
+                Some(SBC_FAULT_ACK),
+                "0.0.0.0:18199"
+            )
+            .unwrap(),
+            SbcPostCommitFault::Delay { millis: 25 }
+        );
+    }
+}
@@ -31,7 +31,9 @@ use openfut_adapter_fifa17::fut::pack_content::{
    generate_pack_contents, GeneratedCandidate, GeneratedCard,
 };
 use openfut_adapter_fifa17::fut::squad::SquadWireResolver;
-use openfut_adapter_fifa17::fut::store_catalog::{pack_by_id, PackDef};
+use openfut_adapter_fifa17::fut::store_catalog::{
+    owned_pack_id_for_definition, pack_by_id, PackDef,
+};

 use crate::{
    error_response, json_response, json_status, CoreAccess, CoreEconomy, CoreError,
@@ -244,7 +246,11 @@ fn pack_open_body(pid: u64, pack: &PackDef) -> WireResponse {
        "firstPartyStoreId": 0,
        "groupName": "fifa17",
        "productId": pid.to_string(),
-        "purchasePackType": if pack.gold { "GOLD" } else { "BRONZE" },
+        "purchasePackType": match pack.category {
+            "gold" => "GOLD",
+            "silver" => "SILVER",
+            _ => "BRONZE",
+        },
    }))
 }

@@ -269,11 +275,12 @@ pub fn handle_pack_open(body: &[u8], deps: &StoreDeps<'_>, rng: &mut impl Rng) -
            Ok(e) => e,
            Err(_) => return error_response(503, "core_unavailable"),
        };
-        // The unopened pack instance is an entitlement whose definition id is the
-        // pack id. Absent → already consumed / never granted: honest empty reveal.
+        // The unopened pack instance is an entitlement whose definition id resolves
+        // to this owned-only pack id (a numeric id or a symbolic reward-pack name).
+        // Absent → already consumed / never granted: honest empty reveal.
        let ent = match ents
            .into_iter()
-            .find(|e| e.definition_id.parse::<u64>().ok() == Some(pid))
+            .find(|e| owned_pack_id_for_definition(&e.definition_id) == Some(pid))
        {
            Some(e) => e,
            None => return json_response(&json!({ "itemData": [] })),
@@ -457,7 +464,10 @@ mod tests {
    use std::collections::HashMap;
    use std::sync::atomic::{AtomicI64, AtomicU32, Ordering};

-    use crate::{EconomyEntitlement, EconomyPurchase, EconomySale, EconomySaleReceipt};
+    use crate::{
+        CoreMatchCompletion, CoreMatchReceipt, EconomyEntitlement, EconomyPurchase, EconomySale,
+        EconomySaleReceipt,
+    };

    // ── Recording economy double ────────────────────────────────────────────

@@ -592,6 +602,13 @@ mod tests {
            // Sale settlement is not exercised by the Store/quick-sell paths.
            Err(CoreError::Status(501))
        }
+        fn complete_match(
+            &self,
+            _m: &CoreMatchCompletion<'_>,
+        ) -> Result<CoreMatchReceipt, CoreError> {
+            // Match completion is not exercised by the Store/quick-sell paths.
+            Err(CoreError::Status(501))
+        }
    }

    // ── Identity / entity / lookup doubles ──────────────────────────────────
@@ -695,7 +712,7 @@ mod tests {
    // ── Store BUY ──────────────────────────────────────────────────────────

    #[test]
-    fn buy_pack1_debits_mints_and_reveals_five_cards() {
+    fn buy_pack1_debits_mints_and_reveals_twelve_cards() {
        let econ = RecEcon::new(10_000);
        let pool = pool();
        let assets = FakeAssets::for_pool(&pool);
@@ -705,23 +722,23 @@ mod tests {
        assert_eq!(resp.status, 200);
        let b: Value = serde_json::from_slice(&resp.body).unwrap();
        let cpr = &b["createPackResponse"];
-        assert_eq!(cpr["numberItems"], 5); // pack 1 count
-        assert_eq!(cpr["itemList"].as_array().unwrap().len(), 5);
+        assert_eq!(cpr["numberItems"], 12); // pack 1 count (10 bronze + 2 silver)
+        assert_eq!(cpr["itemList"].as_array().unwrap().len(), 12);
        assert_eq!(cpr["purchasedPackId"], 1);
        assert_eq!(cpr["duplicateItemIdList"], json!([]));
-        // Exactly one atomic debit of the pack price (400) minting 5 items.
+        // Exactly one atomic debit of the pack price (400) minting 12 items.
        assert_eq!(econ.coins(), 10_000 - 400);
        let purchased = econ.purchased.lock();
        assert_eq!(purchased.len(), 1);
        assert_eq!(purchased[0].0, 400);
-        assert_eq!(purchased[0].1.len(), 5);
+        assert_eq!(purchased[0].1.len(), 12);
        for g in &purchased[0].1 {
            assert!(pool.iter().any(|c| c.card_id == g.card_id));
        }
    }

    #[test]
-    fn buy_pack5_debits_gold_price_and_mints_seven() {
+    fn buy_pack5_debits_gold_price_and_mints_twelve() {
        let econ = RecEcon::new(10_000);
        let pool = pool();
        let assets = FakeAssets::for_pool(&pool);
@@ -729,7 +746,7 @@ mod tests {
        let deps = store_deps(&econ, &assets, &ent, &pool);
        let resp = handle_store_buy(&body(json!({ "packId": 5 })), &deps, &mut rng(2));
        let b: Value = serde_json::from_slice(&resp.body).unwrap();
-        assert_eq!(b["createPackResponse"]["numberItems"], 7); // pack 5 count
+        assert_eq!(b["createPackResponse"]["numberItems"], 12); // pack 5 count (10 gold + 2 silver)
        assert_eq!(econ.coins(), 10_000 - 5000);
    }

@@ -860,7 +877,7 @@ mod tests {
        assert_eq!(b["firstPartyStoreId"], 0);
        assert_eq!(b["purchasePackType"], "GOLD"); // pack 5 is gold
        assert_eq!(econ.coins(), 10_000 - 5000);
-        assert_eq!(econ.purchased.lock()[0].1.len(), 7);
+        assert_eq!(econ.purchased.lock()[0].1.len(), 12);
    }

    #[test]
@@ -886,6 +903,31 @@ mod tests {
        assert_eq!(redeemed[0].1.len(), 11); // pack 70 count
    }

+    #[test]
+    fn open_symbolic_silver_reward_redeems_entitlement_without_debit() {
+        // A Core reward grant ("silver_pack") resolves to owned-only pack 72 and
+        // opens for free by consuming its entitlement — the SBC reward-pack fix.
+        let econ = RecEcon::with_entitlements(4600, &["silver_pack"]);
+        let pool = pool();
+        let assets = FakeAssets::for_pool(&pool);
+        let ent = Fifa17Entities::default();
+        let deps = store_deps(&econ, &assets, &ent, &pool);
+        let resp = handle_pack_open(&body(json!({ "packId": 72 })), &deps, &mut rng(12));
+        assert_eq!(resp.status, 200);
+        let b: Value = serde_json::from_slice(&resp.body).unwrap();
+        assert_eq!(b["packId"], 72);
+        assert_eq!(b["purchasePackType"], "SILVER");
+        assert_eq!(econ.coins(), 4600, "a reward pack opens for free");
+        assert!(
+            econ.entitlements.lock().is_empty(),
+            "the reward entitlement is consumed once"
+        );
+        let redeemed = econ.redeemed.lock();
+        assert_eq!(redeemed.len(), 1);
+        assert_eq!(redeemed[0].0, "e0");
+        assert_eq!(redeemed[0].1.len(), 12); // 1 bronze + 11 silver
+    }
+
    #[test]
    fn open_owned_70_twice_is_consume_once() {
        let econ = RecEcon::with_entitlements(4600, &["70"]);
@@ -36,7 +36,7 @@ use crate::economy_store::OwnedItemLookup;
 use crate::market_store::{now_secs, Listing, MarketError, MarketStore};
 use crate::pile_store::PileStore;
 use crate::sold_experiment::{CountMode, SoldExperiment};
-use crate::{CoreEconomy, CoreError, WireResponse};
+use crate::{CoreEconomy, CoreError, ResponseTransport, WireResponse};

 /// FIFA trade-id numbering base (mirrors the oracle's `_TRADE_ID_BASE`).
 const TRADE_ID_BASE: i64 = 900_000_000;
@@ -47,6 +47,7 @@ fn json_body(status: u16, body: &Value) -> WireResponse {
        status,
        headers: vec![("Content-Type".to_string(), "application/json".to_string())],
        body: bytes,
+        transport: ResponseTransport::Normal,
    }
 }

@@ -804,7 +805,8 @@ pub async fn handle_move_items(
 mod tests {
    use super::*;
    use crate::{
-        EconomyEntitlement, EconomyGrantItem, EconomyPurchase, EconomySale, EconomySaleReceipt,
+        CoreMatchCompletion, CoreMatchReceipt, EconomyEntitlement, EconomyGrantItem,
+        EconomyPurchase, EconomySale, EconomySaleReceipt,
    };
    use std::collections::HashMap;
    use std::sync::atomic::{AtomicI64, AtomicU64, AtomicUsize, Ordering};
@@ -958,6 +960,13 @@ mod tests {
                squad_slots_freed: 0,
            })
        }
+        fn complete_match(
+            &self,
+            _m: &CoreMatchCompletion<'_>,
+        ) -> Result<CoreMatchReceipt, CoreError> {
+            // Match completion is not exercised through the market double.
+            Err(CoreError::Status(501))
+        }
    }

    // ---- SquadWireResolver double -----------------------------------------
@@ -697,6 +697,18 @@ impl MarketStore {
        .map_err(db)?
        .rows_affected())
    }
+
+    pub async fn has_active_for_core_item(&self, core_item_id: &str) -> Result<bool, MarketError> {
+        sqlx::query_scalar(
+            "SELECT EXISTS( \
+                SELECT 1 FROM listings WHERE core_item_id = ? AND state = 'active' \
+             )",
+        )
+        .bind(core_item_id)
+        .fetch_one(&self.pool)
+        .await
+        .map_err(db)
+    }
 }

 #[cfg(test)]
@@ -159,6 +159,16 @@ impl PileStore {
            .map(|r| r.get::<String, _>("core_item_id"))
            .collect())
    }
+    /// Remove stale presentation metadata after Core has consumed an item.
+    /// Projection paths still intersect Core ownership, so failure is safe.
+    pub async fn remove(&self, core_item_id: &str) -> Result<(), PileError> {
+        sqlx::query("DELETE FROM item_pile WHERE core_item_id = ?")
+            .bind(core_item_id)
+            .execute(&self.pool)
+            .await
+            .map_err(db)?;
+        Ok(())
+    }
 }

 #[cfg(test)]
@@ -311,7 +311,7 @@ fn case_a_two_buys(h: &Harness) -> String {
            refs, 1,
            "exactly one BUY refused 461 (statuses {statuses:?})"
        );
-        // The winner minted 5 cards; the loser minted nothing.
+        // The winner minted 12 cards (real Bronze Pack); the loser minted nothing.
        for r in &rs {
            if r.status == 200 {
                assert_eq!(
@@ -319,7 +319,7 @@ fn case_a_two_buys(h: &Harness) -> String {
                        .as_array()
                        .unwrap()
                        .len(),
-                    5
+                    12
                );
            }
        }
@@ -436,8 +436,10 @@ fn case_d_two_market_buyers(h: &Harness) -> String {
                "POST",
                "/ut/game/fifa17/auctionhouse",
                &[],
-                format!(r#"{{"itemData":{{"id":{item_id}}},"buyNowPrice":1000,"startingBid":500}}"#)
-                    .as_bytes(),
+                format!(
+                    r#"{{"itemData":{{"id":{item_id}}},"buyNowPrice":1000,"startingBid":500}}"#
+                )
+                .as_bytes(),
                None,
            )
            .expect("list routed");
@@ -484,20 +486,39 @@ fn case_d_two_market_buyers(h: &Harness) -> String {
    )
 }

-/// E: match REWARD + Store BUY concurrently → final balance is one legal
-/// serialization (no lost update). Reward (+400) and buy (−400) commute, so the
-/// final balance must equal the start exactly.
+/// E: match REWARD + Store BUY concurrently → one legal serialization (no lost
+/// update). The two commute, so the final balance must equal exactly one serial
+/// outcome: the match's reported post-credit balance (`allCoins`), or that minus
+/// the buy's debit — never a torn value from a clobbered write. Amount-agnostic,
+/// so it holds even when a WIN also triggers an XP level-up bonus.
 fn case_e_reward_and_buy(h: &Harness) -> String {
+    // Measure the store BUY's deterministic debit once.
+    set_balance(&h.client, 50_000);
+    let pre_probe = h.client.balance().unwrap();
+    let probe = fire(
+        &h.server,
+        vec![(
+            "PUT",
+            "/ut/game/fifa17/store/transaction".into(),
+            b"{\"packId\":1}".to_vec(),
+        )],
+    );
+    assert_eq!(probe[0].status, 200, "probe buy ok");
+    let buy_debit = pre_probe - h.client.balance().unwrap();
+    assert!(buy_debit > 0, "store buy must debit a positive price");
+
    let start = 8_000i64;
-    for _ in 0..ITERS {
+    for i in 0..ITERS {
        set_balance(&h.client, start);
+        // A DISTINCT match per iteration (unique matchReportId) so the
+        // exactly-once reward applies every time.
        let rs = fire(
            &h.server,
            vec![
                (
                    "POST",
                    "/ut/delete/game/fifa17/match".into(),
-                    b"{\"endReason\":\"WIN\"}".to_vec(),
+                    format!("{{\"matchReportId\":{i},\"endReason\":\"WIN\"}}").into_bytes(),
                ),
                (
                    "PUT",
@@ -507,13 +528,15 @@ fn case_e_reward_and_buy(h: &Harness) -> String {
            ],
        );
        assert!(rs.iter().all(|r| r.status == 200), "both ops succeed");
-        assert_eq!(
-            h.client.balance().unwrap(),
-            start,
-            "reward(+400) and buy(-400) both applied: no lost update"
+        let all = bj(&rs[0])["allCoins"].as_i64().expect("allCoins");
+        let after = h.client.balance().unwrap();
+        // Both writers serialized: `after` is one of the two legal orderings.
+        assert!(
+            after == all || after == all - buy_debit,
+            "no lost update: after={after}, match allCoins={all}, buy_debit={buy_debit}"
        );
    }
-    format!("E reward+buy: {ITERS} iters, final==start ({start}) every time (no lost update)")
+    format!("E reward+buy: {ITERS} iters, no lost update (buy_debit={buy_debit})")
 }

 /// F: MOVE + QUICK-SELL of the same item → one coherent final state (item sold
@@ -26,15 +26,15 @@
 //! | userMassInfo economy   | PARITY             | `userInfo.currencies[coins].funds == credits coins`; both    |
 //! |                        |                    | carry `unopenedPacks.recoveredPacks==1`. Coins consistent    |
 //! |                        |                    | across the credits & massinfo surfaces on each side.         |
-//! | purchasegroup pack70   | PARITY             | owned pack present -> id set {1,5,6,7,70}, NO 65534 sentinel. |
-//! | purchasegroup sentinel | PARITY             | empty My Packs + unverified session -> {1,5,6,7,65534},      |
-//! |                        |                    | sentinel `state:"active"`.                                   |
-//! | purchasegroup clean-v1 | PARITY             | empty My Packs + verified capability session -> {1,5,6,7},   |
+//! | purchasegroup pack70   | DIFFERENT-BY-DESIGN| STORE DIVERGED: Rust serves the real 6-pack catalogue        |
+//! |                        |                    | {1,2,3,4,5,6,70}; oracle (rollback) keeps {1,5,6,7,70}.      |
+//! | purchasegroup sentinel | DIFFERENT-BY-DESIGN| empty My Packs + unverified -> rust {1..6,65534} vs oracle   |
+//! |                        |                    | {1,5,6,7,65534}; sentinel `state:"active"` on both.          |
+//! | purchasegroup clean-v1 | DIFFERENT-BY-DESIGN| empty + verified capability -> rust {1..6}, oracle {1,5,6,7};|
 //! |                        |                    | sentinel stripped. Rust drives the REAL `SessionStore` state |
-//! |                        |                    | machine (register_capability+open_session+freeze) exactly as |
-//! |                        |                    | the oracle's launcher/auth handshake does.                   |
-//! | Store BUY (pack 1)     | PARITY             | 200; `createPackResponse{itemList(5),numberItems:5,          |
-//! |                        |                    | purchasedPackId,duplicateItemIdList}`; coin delta -400.      |
+//! |                        |                    | machine (register_capability+open_session+freeze).          |
+//! | Store BUY (pack 1)     | DIFFERENT-BY-DESIGN| 200; rust real Bronze Pack -> itemList(12),numberItems:12;   |
+//! |                        |                    | oracle placeholder -> 5; both debit 400 + purchasedPackId 1. |
 //! | POST /purchased open70 | PARITY             | 200; envelope `{packId:70,firstPartyStoreId,productId:"70",  |
 //! |                        |                    | purchasePackType:"GOLD"}`; coin delta 0; entitlement -1.     |
 //! | GET /purchased reveal  | PARITY             | Durable single-profile purchased pile on BOTH (Rust reveal   |
@@ -95,6 +95,7 @@
 //! killed on guard drop. Never touches the production Core DB/ports or `.105`.

 use openfut_adapter_fifa17::fut::catalog::Fifa17CardCatalog;
+use openfut_adapter_fifa17::fut::club_response::ItemIdentityResolver;
 use openfut_adapter_fifa17::fut::entities::Fifa17Entities;
 use openfut_adapter_fifa17::fut::non_economy::PERSONA_DISPLAY_NAME;
 use openfut_adapter_fifa17::fut::store_session::{SessionStore, StoreMode, SENTINEL_PACK_ID};
@@ -310,8 +311,12 @@ fn core_post(http: &reqwest::blocking::Client, base: &str, path: &str, body: Val

 /// Build a real `Server` with economy authority wired against the seeded Core.
 /// Returns the server, a direct Core client for balance/entitlement assertions,
-/// and a valid wire `resourceId` (20000) that reverse-maps to a real Core card.
-fn build_econ_server(base: &str, dir: &std::path::Path) -> (Server, HttpCoreClient, i64) {
+/// the resolver used to obtain stable wire instance ids, and a valid wire
+/// `resourceId` (20000) that reverse-maps to a real Core card.
+fn build_econ_server(
+    base: &str,
+    dir: &std::path::Path,
+) -> (Server, HttpCoreClient, Arc<Fifa17IdentityResolver>, i64) {
    let probe = HttpCoreClient::new(base, "fifa17");
    let owned = probe.all_owned().expect("core collection");
    assert!(!owned.is_empty(), "seed must grant a starter collection");
@@ -374,7 +379,7 @@ fn build_econ_server(base: &str, dir: &std::path::Path) -> (Server, HttpCoreClie
        PERSONA_ID,
    )
    .with_economy(services);
-    (server, probe, 20000)
+    (server, probe, resolver, 20000)
 }

 // ─────────────────────────── differential comparison ────────────────────────
@@ -409,13 +414,31 @@ fn pack_ids(pg: &Value) -> Vec<u64> {
    v
 }

+/// Preserve every object key, array position, and JSON scalar kind while discarding
+/// wire-insignificant values such as translated labels and live completion counts.
+fn json_shape(value: &Value) -> Value {
+    match value {
+        Value::Null => json!("null"),
+        Value::Bool(_) => json!("bool"),
+        Value::Number(_) => json!("number"),
+        Value::String(_) => json!("string"),
+        Value::Array(values) => Value::Array(values.iter().map(json_shape).collect()),
+        Value::Object(values) => Value::Object(
+            values
+                .iter()
+                .map(|(key, value)| (key.clone(), json_shape(value)))
+                .collect(),
+        ),
+    }
+}
+
 /// Every op runs on a plain OS thread with NO ambient Tokio runtime (the blocking
 /// Core client + `reqwest::blocking` require this), exactly like the
 /// thread-per-connection server — the bridge takes its direct `block_on` path.
 fn run_differential(core_base: &str, oracle: &Oracle, dir: &std::path::Path) {
    wait_ready(core_base);
    let http = reqwest::blocking::Client::new();
-    let (server, client, _sample_resource) = build_econ_server(core_base, dir);
+    let (server, client, _resolver, _sample_resource) = build_econ_server(core_base, dir);

    // ── Fixture alignment: both sides own exactly one pack-70 entitlement. ──
    // Oracle: fresh profile already owns pack 70. Core: grant the "70" entitlement
@@ -527,29 +550,43 @@ fn run_differential(core_base: &str, oracle: &Oracle, dir: &std::path::Path) {
        None,
    )
    .1;
+    // STORE DIVERGED: Rust is the authoritative store owner and serves the real
+    // 6-pack regular catalogue (ids 1..6 + owned 70). The Python oracle (rollback
+    // baseline, never modified) still serves the old placeholder set {1,5,6,7,70},
+    // so this is Rust-authoritative, NOT oracle parity.
    assert_eq!(
        pack_ids(&opg),
        vec![1, 5, 6, 7, 70],
-        "oracle owned pack70 id set"
+        "oracle (rollback) placeholder id set"
    );
    assert_eq!(
        pack_ids(&rpg),
-        vec![1, 5, 6, 7, 70],
-        "rust owned pack70 id set"
+        vec![1, 2, 3, 4, 5, 6, 70],
+        "rust authoritative real-catalogue id set"
    );
    for b in [&opg, &rpg] {
        assert!(
            !pack_ids(b).contains(&SENTINEL_PACK_ID),
            "no 65534 sentinel while a pack is owned"
        );
-        // packType parity per id (BRONZE for 1, GOLD for the rest).
-        for p in b["purchase"].as_array().unwrap() {
-            let id = p["id"].as_u64().unwrap();
-            let want = if id == 1 { "BRONZE" } else { "GOLD" };
-            assert_eq!(p["packType"], want, "packType parity for pack {id}");
-        }
    }
-    matrix.push(("purchasegroup pack70", "PARITY"));
+    // packType by side: oracle BRONZE for 1 else GOLD; rust by real category
+    // (1,2 bronze / 3,4 silver / 5,6,70 gold).
+    for p in opg["purchase"].as_array().unwrap() {
+        let id = p["id"].as_u64().unwrap();
+        let want = if id == 1 { "BRONZE" } else { "GOLD" };
+        assert_eq!(p["packType"], want, "oracle packType for pack {id}");
+    }
+    for p in rpg["purchase"].as_array().unwrap() {
+        let id = p["id"].as_u64().unwrap();
+        let want = match id {
+            1 | 2 => "BRONZE",
+            3 | 4 => "SILVER",
+            _ => "GOLD",
+        };
+        assert_eq!(p["packType"], want, "rust packType for pack {id}");
+    }
+    matrix.push(("purchasegroup pack70", "DIFFERENT-BY-DESIGN"));

    // ── OP 4: Store BUY (pack 1 Bronze, price 400, 5 cards) ────────────────
    let o_bal0 = oracle.coins();
@@ -577,11 +614,22 @@ fn run_differential(core_base: &str, oracle: &Oracle, dir: &std::path::Path) {
        .as_array()
        .expect("rust itemList")
        .clone();
-    assert_eq!(o_items.len(), 5, "oracle pack1 -> 5 cards");
-    assert_eq!(r_items.len(), 5, "rust pack1 -> 5 cards");
+    // STORE DIVERGED: rust serves the real Bronze Pack (10+2 = 12 cards); the
+    // oracle placeholder awards 5. Both debit the same 400-coin price.
+    assert_eq!(o_items.len(), 5, "oracle (rollback) pack1 -> 5 cards");
+    assert_eq!(r_items.len(), 12, "rust pack1 real Bronze Pack -> 12 cards");
+    assert_eq!(
+        o_buy["createPackResponse"]["numberItems"].as_i64().unwrap(),
+        5,
+        "oracle numberItems==5"
+    );
+    assert_eq!(
+        r_buy["createPackResponse"]["numberItems"].as_i64().unwrap(),
+        12,
+        "rust numberItems==12"
+    );
    for b in [&o_buy, &r_buy] {
        let cpr = &b["createPackResponse"];
-        assert_eq!(cpr["numberItems"].as_i64().unwrap(), 5, "numberItems==5");
        assert_eq!(
            cpr["purchasedPackId"].as_i64().unwrap(),
            1,
@@ -596,9 +644,9 @@ fn run_differential(core_base: &str, oracle: &Oracle, dir: &std::path::Path) {
    assert_eq!(
        client.balance().unwrap() - r_bal0,
        -400,
-        "rust BUY debits 400"
+        "rust BUY debits 400 (price parity)"
    );
-    matrix.push(("Store BUY (pack1)", "PARITY"));
+    matrix.push(("Store BUY (pack1)", "DIFFERENT-BY-DESIGN"));
    // Minted wire ids for the item ops that follow (both sides put them in the
    // pending purchased pile).
    let o_wire: Vec<i64> = o_items.iter().map(|i| i["id"].as_i64().unwrap()).collect();
@@ -1153,8 +1201,8 @@ fn run_differential(core_base: &str, oracle: &Oracle, dir: &std::path::Path) {
    );
    assert_eq!(
        pack_ids(&r_pg_s),
-        vec![1, 5, 6, 7, SENTINEL_PACK_ID],
-        "rust empty (unknown SID) -> sentinel"
+        vec![1, 2, 3, 4, 5, 6, SENTINEL_PACK_ID],
+        "rust empty (unknown SID) -> real catalogue + sentinel"
    );
    for b in [&o_pg_s, &r_pg_s] {
        let s = b["purchase"]
@@ -1165,7 +1213,7 @@ fn run_differential(core_base: &str, oracle: &Oracle, dir: &std::path::Path) {
            .unwrap();
        assert_eq!(s["state"], "active", "sentinel state active");
    }
-    matrix.push(("purchasegroup sentinel", "PARITY"));
+    matrix.push(("purchasegroup sentinel", "DIFFERENT-BY-DESIGN"));

    // ── OP 3c: purchasegroup — clean-v1 (empty + verified capability session) ─
    // Oracle: register the launcher capability, open a session (auth), present the
@@ -1217,11 +1265,11 @@ fn run_differential(core_base: &str, oracle: &Oracle, dir: &std::path::Path) {
    let r_pg_c: Value = serde_json::from_slice(&r_pg_c_resp.body).unwrap();
    assert_eq!(
        pack_ids(&r_pg_c),
-        vec![1, 5, 6, 7],
-        "rust clean-v1 strips the sentinel"
+        vec![1, 2, 3, 4, 5, 6],
+        "rust clean-v1 real catalogue, sentinel stripped"
    );
    assert!(!pack_ids(&r_pg_c).contains(&SENTINEL_PACK_ID));
-    matrix.push(("purchasegroup clean-v1", "PARITY"));
+    matrix.push(("purchasegroup clean-v1", "DIFFERENT-BY-DESIGN"));

    // ── Emit the matrix for the run log. ────────────────────────────────────
    eprintln!("\n===== economy_differential PARITY / DIFFERENT-BY-DESIGN matrix =====");
@@ -1240,6 +1288,202 @@ fn run_differential(core_base: &str, oracle: &Oracle, dir: &std::path::Path) {
    assert_eq!(matrix.len(), 16, "all economy ops classified");
 }

+/// Compare the complete reversed `/sbs/*` response family against the Python oracle.
+/// Listing labels and counters deliberately come from Core, so parity is defined as the
+/// exact key/container/scalar-kind graph. Submission is the one semantic deviation:
+/// Python acknowledges any body without consuming cards; Rust rejects an empty squad.
+fn run_sbc_differential(core_base: &str, oracle: &Oracle, dir: &std::path::Path) {
+    wait_ready(core_base);
+    let (server, client, resolver, _sample_resource) = build_econ_server(core_base, dir);
+    let cases = [
+        ("GET", "/ut/game/fifa17/sbs/sets", None),
+        ("GET", "/ut/game/fifa17/sbs/setId/1/challenges", None),
+        ("GET", "/ut/game/fifa17/sbs/setId/2/challenges", None),
+        ("GET", "/ut/game/fifa17/sbs/setId/999/challenges", None),
+        ("POST", "/ut/game/fifa17/sbs/sets/tag", Some(json!({}))),
+        ("PUT", "/ut/game/fifa17/sbs/sets/tag", Some(json!({}))),
+        ("POST", "/ut/game/fifa17/sbs/challenge/101", None),
+        ("GET", "/ut/game/fifa17/sbs/challenge/101/squad", None),
+        (
+            "PUT",
+            "/ut/game/fifa17/sbs/challenge/101/squad",
+            Some(json!({ "squad": [] })),
+        ),
+    ];
+
+    for (method, path, body) in cases {
+        let oracle_result = oracle.req(method, path, body.clone(), None);
+        let bytes = body
+            .as_ref()
+            .map(|value| serde_json::to_vec(value).unwrap())
+            .unwrap_or_default();
+        let rust_result = rust(&server, method, path, &bytes, None);
+        assert_eq!(
+            rust_result.0, oracle_result.0,
+            "{method} {path} status parity"
+        );
+        assert_eq!(
+            json_shape(&rust_result.1),
+            json_shape(&oracle_result.1),
+            "{method} {path} wire shape parity\nRust: {}\nOracle: {}",
+            rust_result.1,
+            oracle_result.1
+        );
+        match (method, path) {
+            ("GET", "/ut/game/fifa17/sbs/sets") => {
+                assert_eq!(rust_result.1["categories"][0]["categoryId"], 1);
+                assert_eq!(oracle_result.1["categories"][0]["categoryId"], 1);
+                let rust_set_ids: Vec<i64> = rust_result.1["categories"][0]["sets"]
+                    .as_array()
+                    .unwrap()
+                    .iter()
+                    .map(|set| set["setId"].as_i64().unwrap())
+                    .collect();
+                let oracle_set_ids: Vec<i64> = oracle_result.1["categories"][0]["sets"]
+                    .as_array()
+                    .unwrap()
+                    .iter()
+                    .map(|set| set["setId"].as_i64().unwrap())
+                    .collect();
+                assert_eq!(rust_set_ids, [1, 2]);
+                assert_eq!(oracle_set_ids, [1, 2]);
+            }
+            ("GET", "/ut/game/fifa17/sbs/setId/1/challenges") => {
+                for body in [&rust_result.1, &oracle_result.1] {
+                    assert_eq!(body["challenges"][0]["challengeId"], 101);
+                    assert_eq!(body["challenges"][0]["setId"], 1);
+                    assert_eq!(body["challenges"][0]["categoryId"], 1);
+                }
+            }
+            ("GET", "/ut/game/fifa17/sbs/setId/2/challenges") => {
+                for body in [&rust_result.1, &oracle_result.1] {
+                    assert_eq!(body["challenges"][0]["challengeId"], 201);
+                    assert_eq!(body["challenges"][0]["setId"], 2);
+                    assert_eq!(body["challenges"][0]["categoryId"], 1);
+                }
+            }
+            ("GET", "/ut/game/fifa17/sbs/setId/999/challenges") => {
+                assert_eq!(rust_result.1["challenges"], json!([]));
+                assert_eq!(oracle_result.1["challenges"], json!([]));
+            }
+            ("POST", "/ut/game/fifa17/sbs/challenge/101") => {
+                assert_eq!(rust_result.1["challengeId"], 101);
+                assert_eq!(oracle_result.1["challengeId"], 101);
+            }
+            (method, "/ut/game/fifa17/sbs/challenge/101/squad") => {
+                assert!(method == "GET" || method == "PUT");
+                assert_eq!(rust_result.1["id"], 101);
+                assert_eq!(oracle_result.1["id"], 101);
+            }
+            _ => {}
+        }
+    }
+
+    let submit = json!({ "squad": [] });
+    let oracle_submit = oracle.req(
+        "PUT",
+        "/ut/game/fifa17/sbs/challenge/101",
+        Some(submit.clone()),
+        None,
+    );
+    let rust_submit = rust(
+        &server,
+        "PUT",
+        "/ut/game/fifa17/sbs/challenge/101",
+        &serde_json::to_vec(&submit).unwrap(),
+        None,
+    );
+    assert_eq!(oracle_submit.0, 200, "oracle preserves its no-op submit");
+    assert_eq!(
+        json_shape(&oracle_submit.1),
+        json_shape(&json!({
+            "challengeId": 0,
+            "setId": 0,
+            "credits": 0,
+            "preOrderPacks": 0,
+            "recoveredPacks": 0,
+            "grantedChallengeAwards": [],
+            "grantedSetAwards": []
+        })),
+        "oracle submit response remains freeze-safe"
+    );
+    assert_eq!(
+        rust_submit.0, 400,
+        "Rust must validate instead of copying the oracle's no-op acceptance"
+    );
+
+    let owned = client.all_owned().expect("SBC differential inventory");
+    let mut selected = Vec::new();
+    for nation in ["Argentina", "Brazil"] {
+        selected.push(
+            owned
+                .iter()
+                .find(|item| item.rating >= 70 && item.nation == nation)
+                .unwrap_or_else(|| panic!("missing {nation} SBC fixture")),
+        );
+    }
+    for item in &owned {
+        if selected.len() == 11 {
+            break;
+        }
+        if item.rating >= 70
+            && !selected
+                .iter()
+                .any(|existing| existing.owned_card_id == item.owned_card_id)
+        {
+            selected.push(item);
+        }
+    }
+    assert_eq!(selected.len(), 11);
+    let successful = json!({
+        "squad": selected
+            .iter()
+            .enumerate()
+            .map(|(index, item)| json!({
+                "index": index,
+                "itemData": {
+                    "id": i64::from(
+                        resolver.resolve(item).expect("SBC wire identity").item_id
+                    )
+                }
+            }))
+            .collect::<Vec<_>>()
+    });
+    let before_balance = client.balance().unwrap();
+    let before_packs = client.entitlements().unwrap().len();
+    let oracle_success = oracle.req(
+        "POST",
+        "/ut/game/fifa17/sbs/challenge/201",
+        Some(successful.clone()),
+        None,
+    );
+    let rust_success = rust(
+        &server,
+        "POST",
+        "/ut/game/fifa17/sbs/challenge/201",
+        &serde_json::to_vec(&successful).unwrap(),
+        None,
+    );
+    assert_eq!(oracle_success.0, 200);
+    assert_eq!(rust_success.0, 200);
+    assert_eq!(
+        json_shape(&rust_success.1),
+        json_shape(&oracle_success.1),
+        "successful Rust submit preserves the oracle response class"
+    );
+    assert_eq!(rust_success.1["challengeId"], 201);
+    assert_eq!(rust_success.1["setId"], 2);
+    assert!(
+        client.balance().unwrap() > before_balance,
+        "Core applies challenge and achievement coin rewards"
+    );
+    assert_eq!(
+        client.entitlements().unwrap().len(),
+        before_packs + 1,
+        "Core grants one Hybrid Nations pack"
+    );
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn economy_differential_python_oracle() {
    let dir = std::env::temp_dir().join(format!(
@@ -1281,3 +1525,35 @@ async fn economy_differential_python_oracle() {
    std::fs::remove_dir_all(&dir).ok();
    outcome.expect("differential thread panicked");
 }
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn sbc_differential_python_oracle() {
+    let dir = std::env::temp_dir().join(format!(
+        "openfut-sbc-diff-{}-{}",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+    ));
+    std::fs::create_dir_all(&dir).unwrap();
+    let db_url = format!("sqlite://{}/sbc.db", dir.display());
+    let (core_handle, core_base) = start_core_seeded(&db_url, true).await;
+
+    let core_base_run = core_base.clone();
+    let dir_run = dir.clone();
+    let outcome = tokio::task::spawn_blocking(move || {
+        std::thread::spawn(move || {
+            let mut oracle = Oracle::spawn(&dir_run);
+            oracle.wait_ready();
+            run_sbc_differential(&core_base_run, &oracle, &dir_run);
+        })
+        .join()
+    })
+    .await
+    .expect("join spawn_blocking");
+
+    core_handle.abort();
+    std::fs::remove_dir_all(&dir).ok();
+    outcome.expect("SBC differential thread panicked");
+}
@@ -30,9 +30,9 @@ use openfut_utas_host::async_bridge::AsyncBridge;
 use openfut_utas_host::market_store::MarketStore;
 use openfut_utas_host::pile_store::PileStore;
 use openfut_utas_host::{
-    build_content_pool, CoreAccess, CoreEconomy, CoreError, EconomyEntitlement, EconomyGrantItem,
-    EconomyPurchase, EconomySale, EconomySaleReceipt, EconomyServices, Fifa17IdentityResolver,
-    HttpCoreClient, PassClient, Server, WireResponse,
+    build_content_pool, CoreAccess, CoreEconomy, CoreError, CoreMatchCompletion, CoreMatchReceipt,
+    EconomyEntitlement, EconomyGrantItem, EconomyPurchase, EconomySale, EconomySaleReceipt,
+    EconomyServices, Fifa17IdentityResolver, HttpCoreClient, PassClient, Server, WireResponse,
 };
 use parking_lot::Mutex;
 use serde_json::Value;
@@ -140,6 +140,12 @@ impl CoreEconomy for FaultEconomy {
        }
        self.inner.settle_sale(sale)
    }
+    fn complete_match(&self, m: &CoreMatchCompletion<'_>) -> Result<CoreMatchReceipt, CoreError> {
+        if self.trip("complete_match") {
+            return Err(Self::injected());
+        }
+        self.inner.complete_match(m)
+    }
 }

 /// An `ExternalIdentityStore` that forwards to a real `JsonIdentityStore` but can
@@ -12,7 +12,7 @@
 //! touches the production Core DB, production ports/containers, or `.105`.

 use openfut_adapter_fifa17::fut::catalog::Fifa17CardCatalog;
-use openfut_adapter_fifa17::fut::entities::Fifa17Entities;
+use openfut_adapter_fifa17::fut::entities::{Fifa17Entities, ReverseEntityResolver};
 use openfut_adapter_fifa17::fut::store_session::StoreMode;
 use openfut_identity::JsonIdentityStore;
 use openfut_utas_host::async_bridge::AsyncBridge;
@@ -140,8 +140,8 @@ fn pack_ids(pg: &Value) -> Vec<u64> {
 }

 /// Seed via the real Core HTTP API, then exercise the host handlers + transport.
-/// Returns nothing; panics on any mismatch.
-fn seed_and_exercise(base: &str) {
+/// Returns the final Core balance so the restart phase can assert persistence.
+fn seed_and_exercise(base: &str) -> i64 {
    wait_ready(base);
    let http = reqwest::blocking::Client::new();

@@ -155,12 +155,33 @@ fn seed_and_exercise(base: &str) {
    let credits: Value = serde_json::from_slice(&handle_credits(&client).body).unwrap();
    assert_eq!(credits["currencies"][0]["funds"], 5000, "seeded balance");

-    // Match-reward WRITER: win credits +400 via Core grant_reward, end to end.
-    let m = handle_match_end(&client, br#"{"endReason":"WIN"}"#);
+    // Match-reward WRITER: a WIN applies its reward through Core's authoritative,
+    // exactly-once complete_match transaction, end to end. The reward is at least
+    // the match coins; Core may also grant XP-driven level-up and first-win
+    // achievement coins, so assert the flat match coins + a relative delta.
+    let before_match = client.balance().unwrap();
+    let m = handle_match_end(&client, 1, br#"{"endReason":"WIN"}"#);
    assert_eq!(m.status, 200);
    let mb: Value = serde_json::from_slice(&m.body).unwrap();
-    assert_eq!(mb["allCoins"], 5400, "match reward credited in Core");
-    assert_eq!(client.balance().unwrap(), 5400);
+    assert_eq!(mb["matchCoins"], 400, "flat match coins");
+    let after_match = client.balance().unwrap();
+    assert!(
+        after_match >= before_match + 400,
+        "match credited at least +400"
+    );
+    assert_eq!(
+        mb["allCoins"].as_i64().unwrap(),
+        after_match,
+        "response echoes the authoritative Core balance"
+    );
+    // Idempotent replay: the SAME match-end body does NOT double-credit.
+    let replay = handle_match_end(&client, 1, br#"{"endReason":"WIN"}"#);
+    assert_eq!(replay.status, 200);
+    assert_eq!(
+        client.balance().unwrap(),
+        after_match,
+        "replay must not re-credit"
+    );

    // Buy a numeric entitlement "70" through the Core economy API (debit 600).
    post(
@@ -169,11 +190,16 @@ fn seed_and_exercise(base: &str) {
        "/economy/purchase-entitlement",
        json!({ "cost": 600, "definition_id": "70" }),
    );
-    assert_eq!(client.balance().unwrap(), 4800, "debit applied atomically");
+    let after_buy = after_match - 600;
+    assert_eq!(
+        client.balance().unwrap(),
+        after_buy,
+        "debit applied atomically"
+    );

    // credits reflects the debit through the same Core state.
    let credits2: Value = serde_json::from_slice(&handle_credits(&client).body).unwrap();
-    assert_eq!(credits2["currencies"][0]["funds"], 4800);
+    assert_eq!(credits2["currencies"][0]["funds"], after_buy);

    // purchasegroup full-gen shows the owned pack 70 and NO sentinel.
    let pg: Value =
@@ -194,25 +220,27 @@ fn seed_and_exercise(base: &str) {
        client.balance().unwrap(),
        client.entitlements().unwrap().len(),
    );
-    assert_eq!(mass["userInfo"]["currencies"][0]["funds"], 4800);
+    assert_eq!(mass["userInfo"]["currencies"][0]["funds"], after_buy);
    // Invariant: credits coins == userMassInfo coins == Core balance.
    assert_eq!(
        credits2["currencies"][0]["funds"],
        mass["userInfo"]["currencies"][0]["funds"]
    );
+
+    after_buy
 }

 /// After a Core restart from the same DB file, all economy state persists.
-fn verify_after_restart(base: &str) {
+fn verify_after_restart(base: &str, expected_balance: i64) {
    wait_ready(base);
    let client = HttpCoreClient::new(base, "fifa17");
    assert_eq!(
        client.balance().unwrap(),
-        4800,
+        expected_balance,
        "coins persisted across restart"
    );
    let credits: Value = serde_json::from_slice(&handle_credits(&client).body).unwrap();
-    assert_eq!(credits["currencies"][0]["funds"], 4800);
+    assert_eq!(credits["currencies"][0]["funds"], expected_balance);
    let pg: Value =
        serde_json::from_slice(&handle_purchasegroup(&client, StoreMode::Sentinel).body).unwrap();
    assert!(
@@ -239,12 +267,12 @@ async fn economy_end_to_end_and_restart_persistence() {
    let b1 = base1.clone();
    let r = tokio::task::spawn_blocking(move || seed_and_exercise(&b1)).await;
    h1.abort();
-    r.expect("exercise phase");
+    let expected_balance = r.expect("exercise phase");

    // --- Core instance #2: same on-disk DB, prove persistence ---
    let (h2, base2) = start_core(&db_url).await;
    let b2 = base2.clone();
-    let r2 = tokio::task::spawn_blocking(move || verify_after_restart(&b2)).await;
+    let r2 = tokio::task::spawn_blocking(move || verify_after_restart(&b2, expected_balance)).await;
    h2.abort();
    r2.expect("restart phase");

@@ -373,8 +401,8 @@ fn economy_sequence(base: &str, dir: &std::path::Path) -> SeqResult {
        .as_array()
        .expect("itemList")
        .clone();
-    assert_eq!(items.len(), 5, "pack 1 awards 5 cards");
-    assert_eq!(bv["createPackResponse"]["numberItems"], 5);
+    assert_eq!(items.len(), 12, "pack 1 (real Bronze Pack) awards 12 cards");
+    assert_eq!(bv["createPackResponse"]["numberItems"], 12);
    assert!(
        items[0]["id"].as_i64().unwrap() >= 100_000_000,
        "minted wire id above the FIFA floor"
@@ -422,7 +450,8 @@ fn economy_sequence(base: &str, dir: &std::path::Path) -> SeqResult {
        "totalCredits == absolute Core balance"
    );

-    // 4) Match END reward through dispatch (WIN = +400).
+    // 4) Match END reward through dispatch. The WIN credits at least the flat
+    //    match coins (Core may also add XP level-up / first-win achievement coins).
    let before_match = client.balance().unwrap();
    let mm = server
        .try_handle_economy(
@@ -434,10 +463,11 @@ fn economy_sequence(base: &str, dir: &std::path::Path) -> SeqResult {
        )
        .expect("match routed");
    assert_eq!(mm.status, 200);
-    assert_eq!(
-        client.balance().unwrap(),
-        before_match + 400,
-        "WIN credited +400 via Core"
+    let mmb: Value = serde_json::from_slice(&mm.body).unwrap();
+    assert_eq!(mmb["matchCoins"], 400, "flat match coins");
+    assert!(
+        client.balance().unwrap() >= before_match + 400,
+        "WIN credited at least +400 via Core"
    );

    // 5) MARKET buy-now (async handlers via the bridge): list -> query -> buy ->
@@ -769,6 +799,7 @@ fn from_config(base: &str, dir: &std::path::Path) -> openfut_utas_host::config::
            .join("active_account.json")
            .to_string_lossy()
            .into_owned(),
+        sbc_post_commit_fault: openfut_utas_host::config::SbcPostCommitFault::Off,
    }
 }

@@ -908,6 +939,212 @@ async fn from_config_constructs_and_serves_economy() {
    std::fs::remove_dir_all(&dir).ok();
 }

+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn sbc_survives_complete_core_and_host_restart() {
+    let dir = std::env::temp_dir().join(format!(
+        "openfut-sbc-restart-{}-{}",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+    ));
+    std::fs::create_dir_all(&dir).unwrap();
+    let db_url = format!("sqlite://{}/sbc.db", dir.display());
+
+    let (h1, base1) = start_core_seeded(&db_url, true).await;
+    let first_base = base1.clone();
+    let first_dir = dir.clone();
+    let (mut cfg, selected_core_ids, selected_wire_ids) = tokio::task::spawn_blocking(move || {
+        let cfg = from_config(&first_base, &first_dir);
+        let server = Server::from_config(&cfg).expect("first complete host");
+        let club = server.handle("GET", "/ut/game/fifa17/club?count=200", &[], b"");
+        assert_eq!(club.status, 200);
+        let club: Value = serde_json::from_slice(&club.body).unwrap();
+        let items = club["itemData"].as_array().expect("club itemData");
+        let entities =
+            Fifa17Entities::from_tables_dir(std::path::Path::new(&cfg.tables_dir)).unwrap();
+        let argentina = i64::from(entities.nation_id("Argentina").unwrap());
+        let brazil = i64::from(entities.nation_id("Brazil").unwrap());
+        let mut selected = Vec::new();
+        for nation in [argentina, brazil] {
+            selected.push(
+                items
+                    .iter()
+                    .find(|item| {
+                        item["rating"].as_i64().unwrap_or_default() >= 70
+                            && item["nation"].as_i64() == Some(nation)
+                    })
+                    .expect("required hybrid nation")
+                    .clone(),
+            );
+        }
+        for item in items {
+            if selected.len() == 11 {
+                break;
+            }
+            if item["rating"].as_i64().unwrap_or_default() >= 70
+                && !selected.iter().any(|existing| existing["id"] == item["id"])
+            {
+                selected.push(item.clone());
+            }
+        }
+        assert_eq!(selected.len(), 11, "deterministic Hybrid Nations squad");
+        let selected_wire_ids: Vec<i64> = selected
+            .iter()
+            .map(|item| item["id"].as_i64().expect("wire id"))
+            .collect();
+        let catalog = Fifa17CardCatalog::from_file(std::path::Path::new(&cfg.catalog_path))
+            .expect("catalog reload");
+        let store = JsonIdentityStore::open(&cfg.identity_store_path).expect("identity reload");
+        let resolver = Fifa17IdentityResolver::new(catalog, Arc::new(store));
+        let selected_core_ids: Vec<String> = selected_wire_ids
+            .iter()
+            .map(|wire| {
+                resolver
+                    .owned_id_for_wire(*wire)
+                    .expect("wire mapping persisted")
+            })
+            .collect();
+        let squad = json!({
+            "squad": selected_wire_ids
+                .iter()
+                .enumerate()
+                .map(|(index, id)| json!({
+                    "index": index,
+                    "itemData": { "id": id },
+                    "kitNumber": 0
+                }))
+                .collect::<Vec<_>>()
+        });
+        let squad_bytes = serde_json::to_vec(&squad).unwrap();
+        assert_eq!(
+            server
+                .handle(
+                    "PUT",
+                    "/ut/game/fifa17/sbs/challenge/201/squad",
+                    &[],
+                    &squad_bytes,
+                )
+                .status,
+            200
+        );
+        let submitted = server.handle("PUT", "/ut/game/fifa17/sbs/challenge/201", &[], br#"{}"#);
+        assert_eq!(submitted.status, 200);
+        let submitted: Value = serde_json::from_slice(&submitted.body).unwrap();
+        assert_eq!(submitted["challengeId"], 201);
+        assert_eq!(submitted["credits"], 102_750);
+        assert_eq!(submitted["recoveredPacks"], 1);
+        (cfg, selected_core_ids, selected_wire_ids)
+    })
+    .await
+    .expect("initial complete-host phase");
+
+    h1.abort();
+    let _ = h1.await;
+    let (h2, base2) = start_core_seeded(&db_url, false).await;
+    cfg.core_url = base2.clone();
+    let selected_core_ids_check = selected_core_ids.clone();
+    let selected_wire_ids_check = selected_wire_ids.clone();
+    tokio::task::spawn_blocking(move || {
+        let server = Server::from_config(&cfg).expect("restarted complete host");
+        let client = HttpCoreClient::new(&base2, "fifa17");
+        assert_eq!(client.balance().unwrap(), 102_750);
+        assert_eq!(client.entitlements().unwrap().len(), 1);
+        assert_eq!(
+            client
+                .sbc_completion_counts()
+                .unwrap()
+                .get("sbc_hybrid_nations")
+                .copied(),
+            Some(1)
+        );
+        let owned = client.all_owned().unwrap();
+        assert!(selected_core_ids_check
+            .iter()
+            .all(|id| { owned.iter().all(|item| item.owned_card_id != *id) }));
+
+        let club = server.handle("GET", "/ut/game/fifa17/club?count=200", &[], b"");
+        let club: Value = serde_json::from_slice(&club.body).unwrap();
+        assert!(selected_wire_ids_check.iter().all(|id| {
+            club["itemData"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .all(|item| item["id"].as_i64() != Some(*id))
+        }));
+        let saved = server.handle("GET", "/ut/game/fifa17/sbs/challenge/201/squad", &[], b"");
+        let saved: Value = serde_json::from_slice(&saved.body).unwrap();
+        assert!(saved["squad"].as_array().unwrap().is_empty());
+        let purchased = server.handle("GET", "/ut/v2/game/fifa17/purchased/items", &[], b"");
+        let purchased: Value = serde_json::from_slice(&purchased.body).unwrap();
+        assert!(purchased["itemData"].as_array().unwrap().is_empty());
+        for path in ["/ut/game/fifa17/tradePile", "/ut/game/fifa17/watchList"] {
+            let pile = server.handle("GET", path, &[], b"");
+            let pile: Value = serde_json::from_slice(&pile.body).unwrap();
+            assert!(pile["auctionInfo"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .all(|auction| {
+                    selected_wire_ids_check
+                        .iter()
+                        .all(|id| auction["itemData"]["id"].as_i64() != Some(*id))
+                }));
+        }
+        let active = server.handle("GET", "/ut/game/fifa17/squad/active", &[], b"");
+        let active: Value = serde_json::from_slice(&active.body).unwrap();
+        assert!(selected_wire_ids_check.iter().all(|id| {
+            active["players"].as_array().is_none_or(|players| {
+                players
+                    .iter()
+                    .all(|slot| slot["itemData"]["id"].as_i64() != Some(*id))
+            })
+        }));
+
+        let replay_body = json!({
+            "squad": selected_wire_ids_check
+                .iter()
+                .map(|id| json!({ "itemData": { "id": id } }))
+                .collect::<Vec<_>>()
+        });
+        assert_eq!(
+            server
+                .handle(
+                    "PUT",
+                    "/ut/game/fifa17/sbs/challenge/201",
+                    &[],
+                    &serde_json::to_vec(&replay_body).unwrap(),
+                )
+                .status,
+            404,
+            "host rejects consumed wire ids before a duplicate effect"
+        );
+        assert!(matches!(
+            client.submit_sbc("sbc_hybrid_nations", &selected_core_ids_check),
+            Err(openfut_utas_host::CoreError::Status(409))
+        ));
+        assert_eq!(client.balance().unwrap(), 102_750);
+        assert_eq!(client.entitlements().unwrap().len(), 1);
+
+        let catalog = Fifa17CardCatalog::from_file(std::path::Path::new(&cfg.catalog_path))
+            .expect("restart catalog");
+        let store = JsonIdentityStore::open(&cfg.identity_store_path).expect("restart identity");
+        let resolver = Fifa17IdentityResolver::new(catalog, Arc::new(store));
+        for (wire, core_id) in selected_wire_ids_check.iter().zip(&selected_core_ids_check) {
+            assert_eq!(
+                resolver.owned_id_for_wire(*wire).as_deref(),
+                Some(core_id.as_str())
+            );
+        }
+    })
+    .await
+    .expect("restart verification");
+    h2.abort();
+    let _ = h2.await;
+    std::fs::remove_dir_all(&dir).ok();
+}
+
 // ─────────────── Post-barrier authority proofs (NEVER BOTH / no fallback / ────
 //                 stale reader), through the REAL handle_with_ip dispatch ──────

@@ -1040,6 +1277,35 @@ fn pure_economy_routes() -> Vec<(&'static str, String, Vec<u8>)> {
            "/ut/game/fifa17/tradePile/counts".into(),
            b"".to_vec(),
        ),
+        // ── FIFA 17 SBC family. Reads, tag acknowledgement, durable squad
+        //    saves, challenge start, and submission are all Rust-owned. ──
+        ("GET", "/ut/game/fifa17/sbs/sets".into(), b"".to_vec()),
+        (
+            "GET",
+            "/ut/game/fifa17/sbs/setId/1/challenges".into(),
+            b"".to_vec(),
+        ),
+        (
+            "GET",
+            "/ut/game/fifa17/sbs/challenge/101/squad".into(),
+            b"".to_vec(),
+        ),
+        ("PUT", "/ut/game/fifa17/sbs/sets/tag".into(), b"{}".to_vec()),
+        (
+            "PUT",
+            "/ut/game/fifa17/sbs/challenge/101/squad".into(),
+            br#"{"squad":[]}"#.to_vec(),
+        ),
+        (
+            "POST",
+            "/ut/game/fifa17/sbs/challenge/101".into(),
+            b"".to_vec(),
+        ),
+        (
+            "PUT",
+            "/ut/game/fifa17/sbs/challenge/101".into(),
+            br#"{"squad":[]}"#.to_vec(),
+        ),
    ]
 }

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""Authoritative Core state snapshot for FIFA17 FUT loop verification.
+
+Queries openfut-core's authoritative read API directly (NOT the FIFA UI, NOT the
+host projection, NOT Python) and emits a machine-readable JSON snapshot with the
+integrity fields needed to detect, across any economy operation or a full stack
+restart:
+
+  * coin drift            (balance vs club.coins cross-check + absolute value)
+  * duplicate ownership   (repeated owned_card_id)
+  * missing ownership     (squad references an owned_card_id not in the collection)
+  * resurrection          (owned-set hash changes when it must not)
+  * entitlement dup/count (unopened pack entitlements)
+  * stale squad mappings  (squad player ids absent from ownership)
+
+This is verification/oracle tooling, not production behavior. It reads only.
+
+Usage:
+  core-snapshot.py [--core URL] [--game fifa17] [--squad-ns fifa17.squad]
+                   [--out FILE] [--label NAME]
+Env fallbacks: OPENFUT_CORE_URL, OPENFUT_GAME, OPENFUT_SQUAD_NS.
+Exit code 0 always for a successful read; integrity problems are reported IN the
+snapshot (`integrity.ok` / `integrity.problems`) so callers can diff/assert.
+"""
+import argparse
+import hashlib
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+from datetime import datetime, timezone
+
+
+def fetch(core, game, path):
+    req = urllib.request.Request(core + path, headers={"X-OpenFUT-Game": game})
+    try:
+        with urllib.request.urlopen(req, timeout=15) as f:
+            return f.status, f.read()
+    except urllib.error.HTTPError as e:
+        return e.code, e.read()
+    except Exception as e:  # noqa: BLE001 - surface transport errors in the snapshot
+        return None, str(e).encode()
+
+
+def fetch_json(core, game, path):
+    st, body = fetch(core, game, path)
+    if st != 200:
+        raise SystemExit(f"Core read {path} failed: status={st} body={body[:200]!r}")
+    return json.loads(body)
+
+
+def sha(items):
+    h = hashlib.sha256()
+    for it in items:
+        h.update(str(it).encode())
+        h.update(b"\x00")
+    return h.hexdigest()
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--core", default=os.environ.get("OPENFUT_CORE_URL", "http://127.0.0.1:18101"))
+    ap.add_argument("--game", default=os.environ.get("OPENFUT_GAME", "fifa17"))
+    ap.add_argument("--squad-ns", default=os.environ.get("OPENFUT_SQUAD_NS", "fifa17.squad"))
+    ap.add_argument("--out")
+    ap.add_argument("--label", default="")
+    args = ap.parse_args()
+
+    balance = fetch_json(args.core, args.game, "/economy/balance")
+    entitlements = fetch_json(args.core, args.game, "/economy/entitlements")
+    profile = fetch_json(args.core, args.game, "/profile")
+    club = fetch_json(args.core, args.game, "/club")
+    collection = fetch_json(args.core, args.game, "/collection")["collection"]
+    squad = fetch_json(args.core, args.game, f"/squad/ext?namespace={args.squad_ns}")
+
+    coins_balance = balance.get("balance")
+    coins_club = club.get("coins")
+
+    owned_ids = sorted(x["owned_card_id"] for x in collection)
+    card_ids = sorted(x["card"]["id"] for x in collection)
+    dup_owned = sorted({i for i in owned_ids if owned_ids.count(i) > 1}) if len(owned_ids) != len(set(owned_ids)) else []
+    loans = [x["owned_card_id"] for x in collection if x.get("is_loan")]
+
+    # Squad player ownership references (from the opaque extension payload).
+    squad_player_ids = []
+    ext = squad.get("extension") or {}
+    payload_raw = ext.get("payload")
+    kit_numbers = {}
+    if payload_raw:
+        try:
+            payload = json.loads(payload_raw)
+            kit_numbers = payload.get("kit_numbers", {}) or {}
+            squad_player_ids = sorted(kit_numbers.keys())
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+    owned_set = set(owned_ids)
+    squad_missing = sorted(pid for pid in squad_player_ids if pid not in owned_set)
+
+    problems = []
+    if coins_balance != coins_club:
+        problems.append(f"coin cross-check mismatch: balance={coins_balance} club={coins_club}")
+    if dup_owned:
+        problems.append(f"duplicate owned_card_id: {dup_owned[:10]} (+{max(0,len(dup_owned)-10)} more)")
+    if squad_missing:
+        problems.append(f"squad references non-owned ids: {squad_missing}")
+
+    snap = {
+        "label": args.label,
+        "captured_at": datetime.now(timezone.utc).isoformat(),
+        "core": args.core,
+        "game": args.game,
+        "coins": {"balance": coins_balance, "club": coins_club},
+        "profile": {"username": profile.get("username"), "level": profile.get("level"), "xp": profile.get("xp")},
+        "entitlements": {"count": len(entitlements), "ids": entitlements},
+        "collection": {
+            "owned": len(collection),
+            "distinct_owned_card_id": len(set(owned_ids)),
+            "distinct_card_id": len(set(card_ids)),
+            "loans": len(loans),
+            "duplicate_owned_card_id": dup_owned,
+            "owned_set_sha256": sha(owned_ids),
+            "card_multiset_sha256": sha(card_ids),
+        },
+        "squad": {
+            "namespace": args.squad_ns,
+            "verdict": squad.get("verdict"),
+            "player_count": len(squad_player_ids),
+            "player_ids": squad_player_ids,
+            "missing_from_ownership": squad_missing,
+            "ext_schema_version": ext.get("schema_version"),
+        },
+        "integrity": {"ok": not problems, "problems": problems},
+    }
+
+    text = json.dumps(snap, indent=2, sort_keys=True)
+    if args.out:
+        with open(args.out, "w") as f:
+            f.write(text + "\n")
+    print(text)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
@@ -278,7 +278,7 @@ def cmd_parse(args):
    os.makedirs(out_dir, exist_ok=True)
    out_path = os.path.join(out_dir, "transactions.jsonl")

-    total, skipped = 0, 0
+    total, skipped, filtered = 0, 0, 0
    with open(out_path, "w") as out:
        for conn_id in sorted(conns):
            c = conns[conn_id]
@@ -298,6 +298,9 @@ def cmd_parse(args):
                m = re.match(r"(\S+)\s+(\S+)\s+(HTTP/\d\.\d)", rl)
                method, target, ver = (m.group(1), m.group(2), m.group(3)) if m else ("?", rl, "?")
                path, _, query = target.partition("?")
+                if args.path_prefix and not path.startswith(args.path_prefix):
+                    filtered += 1
+                    continue
                st = re.match(r"HTTP/\d\.\d\s+(\d+)", sl)
                req_t, req_unix = time_at(c["marks"]["c2s"], rend - 1)
                res_t, res_unix = time_at(c["marks"]["s2c"], max(send - 1, 0))
@@ -342,9 +345,14 @@ def cmd_parse(args):
                total += 1

    os.chmod(out_path, 0o644)
+    detail = []
+    if skipped:
+        detail.append("%d unpaired messages reported above" % skipped)
+    if filtered:
+        detail.append("%d transactions excluded by path prefix" % filtered)
    print("wrote %s (%d transactions across %d connections%s)"
          % (out_path, total, len(conns),
-             "; %d unpaired messages reported above" % skipped if skipped else ""))
+             "; " + "; ".join(detail) if detail else ""))
    return 0


@@ -587,6 +595,8 @@ def main():
    # fixture for the whole response.
    p.add_argument("--max-body", type=int, default=0,
                   help="bytes; 0 = keep every body in full")
+    p.add_argument("--path-prefix", default="",
+                   help="emit only transactions whose request path starts with this prefix")
    p.set_defaults(fn=cmd_parse)

    s = sub.add_parser("snapshot")
@@ -123,8 +123,8 @@ def main():

    body = json.dumps({"squad": [1, 2, 3], "note": "x" * 300}).encode()
    reqs = [
-        b"GET /ut/game/fifa17/userMassInfo HTTP/1.1\r\nHost: t\r\n\r\n",
-        b"POST /ut/game/fifa17/purchased/items HTTP/1.1\r\nHost: t\r\n"
+        b"GET /ut/game/fifa17/sbs/sets HTTP/1.1\r\nHost: t\r\n\r\n",
+        b"POST /ut/game/fifa17/sbs/challenge/101/squad HTTP/1.1\r\nHost: t\r\n"
        b"Content-Type: application/json\r\nContent-Length: %d\r\n\r\n" % len(body) + body,
        b"GET /chunked?deviceId=DEADBEEFCAFE&keep=yes HTTP/1.1\r\nHost: t\r\n\r\n",
        b"GET /ut/game/fifa17/hub HTTP/1.1\r\nHost: t\r\nConnection: close\r\n\r\n",
@@ -180,8 +180,8 @@ def main():
    if len(txs) == 4:
        check("methods and paths in order",
              [(t["request"]["method"], t["request"]["path"]) for t in txs] ==
-              [("GET", "/ut/game/fifa17/userMassInfo"),
-               ("POST", "/ut/game/fifa17/purchased/items"),
+              [("GET", "/ut/game/fifa17/sbs/sets"),
+               ("POST", "/ut/game/fifa17/sbs/challenge/101/squad"),
               ("GET", "/chunked"),
               ("GET", "/ut/game/fifa17/hub")])
        check("request body preserved byte-for-byte",
@@ -210,6 +210,20 @@ def main():
              qtx is not None and "keep=yes" in qtx["request"]["query"],
              qtx["request"]["query"] if qtx else "")

+    print("== path-scoped fixture ==")
+    r = subprocess.run(
+        [sys.executable, TOOL, "parse", "--session", SESSION,
+         "--path-prefix", "/ut/game/fifa17/sbs/"],
+        capture_output=True, text=True)
+    print("     " + r.stdout.strip().replace("\n", "\n     "))
+    filtered = [json.loads(l) for l in
+                open(os.path.join(SESSION, "sanitized", "transactions.jsonl"))]
+    check("SBC prefix emits only the two SBC transactions", len(filtered) == 2,
+          "got %d" % len(filtered))
+    check("SBC save body remains byte-exact after scoped parse",
+          len(filtered) == 2 and
+          base64.b64decode(filtered[1]["request"]["body_b64"]) == body)
+
    srv.shutdown()
    print()
    print("all checks passed" if not fails else "%d FAILED: %s" % (len(fails), fails))
@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""Attribute captured UTAS requests to labelled UI actions, and diff them.
+
+    utas-filter-diff.py --session <dir> [--baseline NO_FILTER]
+
+The My Squad filter investigation needs to answer "which wire field changed
+when I changed exactly one thing in the UI". That is a diff between labelled
+groups of requests, so this tool needs both halves:
+
+  raw/utas.ofcap    what the client sent
+  labels.txt        MARKER <label> <HH:MM:SS> UTC lines, written when the human
+                    said a search was done
+
+Requests are attributed to the label whose marker most recently PRECEDES them.
+Anything before the first marker is 'boot'.
+
+Why a separate tool: the observer must stay a dumb, byte-faithful tee. Anything
+that interprets traffic belongs outside it, so a mistake here can never affect
+what was recorded.
+"""
+import argparse
+import base64
+import collections
+import hashlib
+import json
+import os
+import re
+import sys
+from urllib.parse import parse_qsl
+
+
+def load(session):
+    """Rebuild per-connection streams, keeping the wall time of each chunk."""
+    path = os.path.join(session, "raw", "utas.ofcap")
+    conns = collections.defaultdict(
+        lambda: {"c2s": bytearray(), "s2c": bytearray(), "marks": []}
+    )
+    with open(path) as f:
+        for line in f:
+            r = json.loads(line)
+            if "b64" not in r:
+                continue
+            c = conns[r["conn"]]
+            data = base64.b64decode(r["b64"])
+            if r["dir"] == "c2s":
+                c["marks"].append((len(c["c2s"]), r["unix"]))
+            c[r["dir"]].extend(data)
+    return conns
+
+
+def labels(session):
+    out = []
+    p = os.path.join(session, "labels.txt")
+    if not os.path.exists(p):
+        return out
+    import datetime
+    for line in open(p):
+        m = re.match(r"MARKER\s+(\S+)\s+(\d\d):(\d\d):(\d\d)\s+UTC", line.strip())
+        if m:
+            name, h, mi, s = m.group(1), *map(int, m.groups()[1:])
+            out.append((name, h * 3600 + mi * 60 + s))
+    return out
+
+
+def split_requests(buf):
+    """(offset, method, target, headers, body) per request in a stream."""
+    out, i = [], 0
+    while True:
+        sep = buf.find(b"\r\n\r\n", i)
+        if sep < 0:
+            break
+        head = bytes(buf[i:sep]).decode("latin1")
+        line0 = head.split("\r\n")[0]
+        m = re.match(r"(\S+)\s+(\S+)\s+HTTP/", line0)
+        if not m:
+            break
+        hdrs = [h.split(":", 1) for h in head.split("\r\n")[1:] if ":" in h]
+        hdrs = [(k.strip(), v.strip()) for k, v in hdrs]
+        cl = next((int(v) for k, v in hdrs if k.lower() == "content-length" and v.isdigit()), 0)
+        start = sep + 4
+        body = bytes(buf[start:start + cl])
+        out.append((i, m.group(1), m.group(2), hdrs, body))
+        i = start + cl
+    return out
+
+
+def split_responses(buf):
+    out, i = [], 0
+    while True:
+        sep = buf.find(b"\r\n\r\n", i)
+        if sep < 0:
+            break
+        head = bytes(buf[i:sep]).decode("latin1")
+        st = re.match(r"HTTP/\d\.\d\s+(\d+)", head)
+        cl = re.search(r"(?im)^content-length:\s*(\d+)\s*$", head)
+        te = re.search(r"(?im)^transfer-encoding:.*chunked", head)
+        start = sep + 4
+        if te:
+            j, body = start, bytearray()
+            while True:
+                nl = buf.find(b"\r\n", j)
+                if nl < 0:
+                    return out
+                try:
+                    n = int(bytes(buf[j:nl]).split(b";")[0], 16)
+                except ValueError:
+                    return out
+                j = nl + 2
+                if n == 0:
+                    j = buf.find(b"\r\n", j)
+                    j = j + 2 if j >= 0 else len(buf)
+                    break
+                body.extend(buf[j:j + n])
+                j += n + 2
+            out.append((int(st.group(1)) if st else None, bytes(body)))
+            i = j
+        elif cl:
+            n = int(cl.group(1))
+            out.append((int(st.group(1)) if st else None, bytes(buf[start:start + n])))
+            i = start + n
+        else:
+            out.append((int(st.group(1)) if st else None, b""))
+            i = start
+    return out
+
+
+def time_at(marks, off):
+    t = marks[0][1] if marks else 0
+    for pos, unix in marks:
+        if pos > off:
+            break
+        t = unix
+    return t
+
+
+def item_ids(body):
+    """Item ids in a response, if it looks like an item list."""
+    try:
+        d = json.loads(body)
+    except Exception:
+        return None
+    ids = []
+
+    def walk(o):
+        if isinstance(o, dict):
+            if "id" in o and isinstance(o["id"], int):
+                ids.append(o["id"])
+            for v in o.values():
+                walk(v)
+        elif isinstance(o, list):
+            for v in o:
+                walk(v)
+
+    walk(d)
+    return ids
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--session", required=True)
+    ap.add_argument("--baseline", default="NO_FILTER")
+    a = ap.parse_args()
+
+    import datetime
+    conns = load(a.session)
+    marks = labels(a.session)
+
+    rows = []
+    for cid in sorted(conns):
+        c = conns[cid]
+        reqs = split_requests(c["c2s"])
+        resps = split_responses(c["s2c"])
+        for i, (off, method, target, hdrs, body) in enumerate(reqs):
+            unix = time_at(c["marks"], off)
+            secs = datetime.datetime.utcfromtimestamp(unix)
+            secs = secs.hour * 3600 + secs.minute * 60 + secs.second
+            label = "boot"
+            for name, at in marks:
+                if at <= secs:
+                    label = name
+            status, rbody = resps[i] if i < len(resps) else (None, b"")
+            path, _, query = target.partition("?")
+            ids = item_ids(rbody)
+            rows.append({
+                "label": label,
+                "time": datetime.datetime.utcfromtimestamp(unix).strftime("%H:%M:%S"),
+                "conn": cid, "method": method, "path": path,
+                "query": dict(parse_qsl(query, keep_blank_values=True)) if query else {},
+                "query_raw": query,
+                "req_body": body.decode("latin1") if len(body) < 2000 else "<%dB>" % len(body),
+                "status": status,
+                "resp_len": len(rbody),
+                "resp_sha": hashlib.sha256(rbody).hexdigest()[:12],
+                "item_count": len(ids) if ids is not None else None,
+                "item_ids": ids[:40] if ids else None,
+            })
+
+    print("=== requests by label ===")
+    for r in rows:
+        if r["label"] == "boot":
+            continue
+        print("%-18s %s conn%-3d %-5s %-46s %s %5dB sha=%s items=%s"
+              % (r["label"], r["time"], r["conn"], r["method"], r["path"][:46],
+                 r["status"], r["resp_len"], r["resp_sha"],
+                 r["item_count"] if r["item_count"] is not None else "-"))
+        if r["query"]:
+            print("%-18s   query: %s" % ("", r["query"]))
+        if r["req_body"].strip():
+            print("%-18s   body : %s" % ("", r["req_body"][:200]))
+
+    # Field-level diff against the baseline label.
+    base = [r for r in rows if r["label"] == a.baseline]
+    if not base:
+        print("\n(no %s rows yet; skipping diff)" % a.baseline)
+        return 0
+    print("\n=== query-field diff vs %s ===" % a.baseline)
+    bq = base[-1]["query"]
+    bpath = base[-1]["path"]
+    seen = set()
+    for r in rows:
+        if r["label"] in ("boot", a.baseline) or r["label"] in seen:
+            continue
+        seen.add(r["label"])
+        added = {k: v for k, v in r["query"].items() if bq.get(k) != v}
+        removed = {k: v for k, v in bq.items() if k not in r["query"]}
+        note = "" if r["path"] == bpath else "  PATH DIFFERS: %s" % r["path"]
+        print("  %-18s +%s  -%s%s" % (r["label"], added or "{}", removed or "{}", note))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
@@ -1,5 +1,12 @@
 #!/usr/bin/env bash
-# OpenFUT Setup Script
+# OpenFUT Setup Script  —  ⚠️ LEGACY (FIFA 23 core+bridge lineage)
+#
+# SUPERSEDED. The working target is FIFA 17. This script builds/starts the old
+# FIFA 23 core+bridge stack and redirects EA domains for FIFA 23. Do NOT use it
+# for the current server. Canonical server bring-up (FIFA 17):
+#   cd fifa17-recon/docker/fifa17-python && docker compose up -d
+# Status: docs/PROJECT_STATE.md · Runbook: fifa17-recon/FUT-RUNBOOK.md
+#
 # Builds, configures, and starts the OpenFUT offline FUT emulator for FIFA 23.
 # Run as a regular user; the script will sudo only for hosts/cert/iptables steps.

@@ -407,6 +414,11 @@ EOF
 }

 # ── Dispatch ───────────────────────────────────────────────────────────────────
+# --- Legacy guard: this is the superseded FIFA 23 flow (see header banner). ---
+echo "[LEGACY] setup.sh drives the superseded FIFA 23 core+bridge stack." >&2
+echo "[LEGACY] Canonical FIFA 17 server: cd fifa17-recon/docker/fifa17-python && docker compose up -d" >&2
+echo "[LEGACY] Status: docs/PROJECT_STATE.md · Runbook: fifa17-recon/FUT-RUNBOOK.md" >&2
+
 case "${1:-help}" in
    quickstart)   cmd_quickstart ;;
    build)        cmd_build ;;
Author	SHA1	Message	Date
funman300	d8d704d441	chore(submodules): bump openfut-core -> 2fb8352 (match economy + club manager, pushed)	2026-08-20 18:21:27 +00:00
funman300	07d4a92309	fix(clippy): use slice::from_ref instead of clone in sbc challenge test	2026-08-20 18:17:30 +00:00
funman300	afa5f620bd	style(fifa17): cargo fmt match wire + host match integration	2026-08-20 17:59:03 +00:00
funman300	56bd9ddc85	test(fifa17): update squad_projection integration test to ownership-backed manager The manager moved from an opaque extension field to an ownership-backed canonical assignment: SquadProjectionInput.manager (owned item) replaces Fifa17SquadExtensionV1.manager. - project_put stand-in passes manager: None; baseline asserts the manager projects empty when none is owned. - persisted_read registers the manager's owned instance + identity and passes it as the assignment, asserting the resolved [{id,dream}] ref round-trips to the read oracle's manager.	2026-08-20 17:38:32 +00:00
funman300	9ddd80993c	feat(fifa17): route match completion to Core exactly-once economy Adapter: new fut/match_wire.rs owns the FIFA17 match wire — endReason enum -> canonical result token (win/draw/loss/dnf/no_contest), match-end payload parse (goals from myMatchStats[0], omitted on DNF/QUIT), and the reward-response projection (only reversed fields; never bidTokens/ qualifiedChampionEventId). Match logic removed from economy_policy.rs (kept pack/fee); registered match_wire in fut/mod.rs. Host: handle_match_end now applies the match to Core's authoritative complete_match (POST /matches/complete) fail-closed — any Core error is a 503, never a Python fallback — and renders Core's authoritative coins. Per-match identity from matchReportId or a body fingerprint keys Core's durable idempotency. New CoreEconomy::complete_match transport + CoreMatchCompletion/CoreMatchReceipt. Tests: adapter endReason/parse/projection; host shaping, fail-closed, malformed, identity dedupe; integration replay + rebased balance chains (match now also grants XP/level-up/achievement coins).	2026-08-20 17:30:17 +00:00
funman300	25f4ad12bc	feat(host): wire ownership-backed squad manager through Core Thread the manager assignment between the FIFA squad path and Core: - CoreAccess gains get_squad_manager/set_squad_manager (GET/PUT /club/manager); HttpCoreClient implements both. - project_active_squad fetches the assigned manager owned item and passes it to the projector (non-fatal on error/absence). - handle_put_squad authorizes the resolved manager against the active club (like a slot) and persists it via set_squad_manager after the atomic squad replace; fails loudly, never silently drops it.	2026-08-20 16:44:40 +00:00
funman300	d37a9d5b5e	feat(fifa17): ownership-backed squad manager, not opaque round-trip Move the squad manager from an opaque, unvalidated wire ref in the squad extension to a resolved, ownership-backed assignment (Core migration 0023 squad_managers). - squad::to_proposed reverse-resolves the manager wire ref to a Core owned_card_id on ProposedSquad; an unresolvable manager is reported as an unresolved wire id (a live save is refused rather than assigning a manager the club does not own). - squad_ext: drop the opaque manager field from Fifa17SquadExtensionV1 (clean cutover) and the now-unused SquadEntityRef->WireItemRef From. - squad_projection: project the manager as the STATIC_REVERSED [{id,dream}] wire ref resolved from the owned assignment; absent -> [] (never faked). Richer manager itemData (contract/league/nation) is INFERRED-only and left out pending wire reversal. - import(apply): drop a historical dangling manager ref rather than failing the whole import (live PUTs still refuse an unresolved manager).	2026-08-20 16:43:39 +00:00
funman300	e5d356e8be	chore(submodules): bump core/launcher/bridge pointers to pushed commits openfut-core -> a034e74 (cargo fmt pass, pushed) openfut-launcher -> 8d5bb62 (fifa17 season diag commits, pushed) openfut-bridge -> c58e732 (consolidate backup HEAD, on origin/main) All targets verified present on their remotes. fifa-blaze unchanged.	2026-08-20 16:10:22 +00:00
funman300	0b189b36c5	chore(tools): add utas-filter-diff.py diagnostic Read-only UTAS capture diff helper. Retained pre-existing WIP verified.	2026-08-20 16:06:29 +00:00
funman300	11c17f3039	style(adapter-fifa17): apply cargo fmt to fut store/pack/non_economy/club_stats Pure rustfmt reflow; git diff -w confirms logic byte-identical (PACK_CATALOG values, pack tiers, item_def stubs unchanged). Builds clean. Retained WIP.	2026-08-20 16:06:29 +00:00
funman300	871d02406f	chore(deploy): add root core+bridge compose stack + .env.example Localhost-default (127.0.0.1) compose for the Rust core+bridge; env-driven CORE_PUBLISH. No secrets/staging-prod defaults. Retained WIP verified.	2026-08-20 16:06:29 +00:00
funman300	6811caeab1	feat(fifa17-docker): OPENFUT_SERVERS component selection for staged Py->Rust migration entrypoint.sh validates/selects among lsx blaze roster utas pow and skips unselected responders (errors if none). docker-compose threads the env through; .env.example documents it. Retained pre-existing WIP verified.	2026-08-20 16:06:28 +00:00
funman300	d71234b03d	docs: add AGENTS.md canonical entry point; mark FIFA23 README/CLAUDE/setup stale AGENTS.md is the new canonical AI-agent entry point (FIFA17 active target, repo map, FIFA23->FIFA17 pivot history). README/CLAUDE/setup.sh get stale banners pointing to it. Retained pre-existing WIP brought forward.	2026-08-20 16:06:28 +00:00
funman300	8e1fb640b6	tools: authoritative Core-state snapshot for FUT loop verification Reads openfut-core's authoritative API directly (balance, entitlements, profile, club, collection, squad/ext) with the fifa17 game header and emits a machine-readable JSON snapshot plus integrity checks: coin cross-check, duplicate owned_card_id, squad-references-non-owned, owned-set + card-multiset hashes for drift/resurrection detection across operations and restarts. Read-only oracle tooling; used to verify Phases 1-9 of the Core-backed FUT loop audit.	2026-08-19 19:20:28 +00:00
funman300	0019806a3b	tools(fifa17): refuse to stage/deploy a non-fifa17-profile hook DLL openfut-hook builds two mutually exclusive injection paths from one crate. The default (FIFA 23) path installs getaddrinfo/connect/ProtoSSL/origin_spy transport hooks; `--features fifa17` installs only the FIFA-17-safe logic (module map, FIFA 17 cert-verify, SBC dispatch, store tab bind). Deploying a default-feature build into FIFA 17 hijacks the login transport: the client reports "Unable to connect to the EA servers at this time" and none of the FIFA 17 repairs are present in the binary at all. That happened today: artifact 1c71a17a was built by hand without the feature and deployed, costing two failed launches. It was diagnosed only by comparing embedded strings between the deployed DLL and the last known-good one (the deployed DLL had 0 occurrences of CardsDLL_Win64_retail.dll and SBC_DISPATCH, and 6 of cert-verify plus 1 of "connect: inline-hooked" -- the inverse of a fifa17 build). `build` already passes --features fifa17, but OPENFUT_FIFA17_HOOK_DLL lets a hand-built DLL reach stage/deploy, so verify_fifa17_profile asserts the profile on the bytes: CardsDLL_Win64_retail.dll and SBC_DISPATCH must be present, and the FIFA-23-only markers must be absent. Wired into verify_inputs (stage/inspect) and into deploy's staged-artifact checks. Verified: the gate rejects 1c71a17a, accepts 3641d581 (last known good) and f0ef528f (the corrected fifa17 build now deployed).	2026-08-19 18:31:27 +00:00
funman300	c7c057a31a	superproject: bump launcher submodule to consolidated main Records the store-entry category-clamp hook (launcher 9aecc65) as the launcher tip on main. Only the launcher gitlink is bumped; core stays 271c363 and bridge stays 0f581eb (both as already recorded), and the in-tree formatting/doc churn is left untouched.	2026-08-19 15:35:34 +00:00
funman300	89dc1b1d85	sbc: document reversed elgReq ordinal finding; elgReq stays empty Reversed from the pinned CardsDLL (4706a881): eligibilityKey and eligibilityOperation are localization ordinals (LOC_SBC_ELG_KEY_%d), not the atom hex ids. The client's only consumer is the requirement- display string builder at ~0x1800ef900 (formats via indexed locale keys, no comparison/gate). The ordinal->string map lives only in the packed locale (absent from all assets we hold), so any emitted value would render the WRONG requirement text. Submission stays fully validated server-side by Core; the empty elgReq is display-only. Correct ENDPOINT_MAP.md's implied atom-id==ordinal assumption and pin the exact remaining blocker at the emit site.	2026-08-19 15:00:18 +00:00
funman300	13a22c4507	Bump launcher: plain-language launch status	2026-08-19 04:28:13 +00:00
funman300	1db9acdf6d	Bump launcher: persist hook DLL override in the prefix registry Removes the manual Steam launch-options step; the launcher now writes version=native,builtin into the Wine prefix so any launch path loads the hook.	2026-08-19 03:01:47 +00:00
funman300	911c7a34fd	Bump launcher: promote FIFA17 SBC dispatch (no env arming) Picks up openfut-launcher 94feaec, which makes the guarded native SBC dispatch repair a build-armed promoted feature instead of an OPENFUT_SBC_DISPATCH env gate. Any launch path (Steam, the launcher Launch button, bare umu-run) now gets the repair, so the SBC screen no longer depends on a harness script exporting a variable. Every runtime guard is unchanged; rollback is a version.dll file swap.	2026-08-19 02:45:58 +00:00
funman300	fcc314afb1	fifa17 store: render cover art on My Packs reward tiles A reward pack advertised its own id (70-75) as assetId, which is not a client art asset, so its My Packs tile rendered blank. Reward tiles now carry their tier store pack as the cover asset (bronze->1, silver->3, gold->5) while `id` stays the pack own id (the open packId / SERVER_ID); the sentinel keeps its own id so it stays an inert placeholder. LIVE-MAPPED on the retail client 2026-08-18 across all three store tabs and two reward tiles, which corrected an earlier wrong assumption: * assetId only gates whether art renders AT ALL (unknown id -> blank tile). * WHICH art is drawn comes from packType + packContentInfo.rareQuantity, NOT assetId: BRONZE+1rare -> bronze card, BRONZE+3 -> silver, SILVER+1 -> gold, SILVER+3 -> silver trio, GOLD+1 -> blue special, GOLD+3 -> red inform. Remapping assetId 5->3 and 3->2 left both frames unchanged and only rotated the featured player, which proves art is content-driven. So a reward tile now shows the same cover as the equivalent purchasable pack (a gold reward shows the blue-special art the 5000-coin Gold Pack shows - EA art advertises an aspirational card rather than the tier colour). Regression test reward_tiles_carry_a_renderable_cover_asset added; pack70 golden regenerated.	2026-08-19 02:08:37 +00:00
funman300	b323244ac9	fifa17 store: make My Packs reward tiles openable (free coins row) Reward/My-Packs tiles were emitted with no currencies row (dropped to avoid an "undefined" payment label). But FIFA 17 opens My Packs through the store PURCHASE flow (My Packs is a client-side filter over the store catalogue; the open-vs-buy fork is client-side and no response selects it), so a tile with no purchase path is not actionable — clicking it navigates instead of opening, sending no request. Fix: keep the coins currency at the pack price (0 for reward packs; no extPrice, so no `or %1s` mtx bug). The client then treats the tile as free and clicking sends POST /purchased, which the server opens for free (owned-only redeem, no debit). The empty-My-Packs sentinel keeps no currency row so it stays non-openable. pack70 golden regenerated. LIVE-PROVEN 2026-08-18: a reward Silver Pack opened and revealed cards on the retail client (host log: POST /purchased/items 200 -> GET /purchased/items).	2026-08-19 01:50:51 +00:00
funman300	1d6a6fffcc	fifa17 store: make reward packs (SBC/draft/season/...) openable SBC completion and the other Core reward services grant packs with symbolic definition_ids ("silver_pack", "gold_pack", ...). The FIFA 17 pack system keys entirely on numeric catalogue ids, and entitlement_pack_ids / handle_pack_open resolved definition_ids with definition_id.parse::<u64>(), so every symbolic reward pack was silently dropped from the openable My Packs list. The unopened count (recoveredPacks, = entitlement count) still counted them, so the client showed "you have N packs" but had no tile to open -> "no pack available". Fix (adapter-layer, Core stays game-neutral): add owned-only reward pack catalogue entries 71-75 (bronze/silver/gold/rare_gold/icon) and a resolver owned_pack_id_for_definition() that maps both numeric owned ids and the symbolic reward names to their numeric owned-only pack. entitlement_pack_ids and the pack-open entitlement selection now use it, so reward packs render as openable My Packs tiles and redeem their entitlement for free (consume-once, no debit). Server-verified on staging: 3 Core reward entitlements now render 3 openable mypacks tiles matching recoveredPacks=3. Tests: adapter resolver + rendering, host symbolic-reward open flow; full adapter + host suites green.	2026-08-19 01:27:22 +00:00
funman300	f56aa613da	fifa17 SBC: keep repeatable challenges re-enterable after completion The FIFA 17 client gates challenge re-entry on timesCompleted, not on the repeatable flag: a nonzero count renders the tile COMPLETED and refuses re-entry even when repeatable=true. So a repeatable challenge now always projects timesCompleted=0 (challenges_body) and its set as challengesCompletedCount=0 (sets_body); a non-repeatable challenge keeps its true count and stays locked once completed. Core keeps the authoritative completion record — economy is unaffected; this is presentation only. Live-proven on the retail client 2026-08-18: a completed repeatable Bronze Upgrade now re-opens for a fresh submit instead of blocking. Regression test repeatable_completed_challenge_stays_enterable added; adapter + full host suite (incl. differential and the concurrency race) green.	2026-08-19 01:18:36 +00:00
funman300	8c17f896b4	fifa17 store: native category art via displayGroupAssetId The all-groups landing (shown on first store entry) renders one tile per group whose background is the client-bundled packs_backgrounds_%d.dds, selected by displayGroupAssetId. Live-probed on the retail client 2026-08-18: index 0 is blank; indices 1/2/3 render real pack art. Assign non-zero per category (bronze=1, silver=2, gold/mypacks=3) so that landing shows native pack art instead of blank shields. The persistent tabbed store (MY PACKS/BRONZE/SILVER/ GOLD PACKS) draws pack art from the packs themselves and is unaffected. LIVE-CONFIRMED end-to-end: native tabbed store renders the real 6-pack catalogue with correct prices (Gold 5000 / Premium Gold 7500), counts (12 items, 10 gold, 1/3 rares), pack art, and no "or %1s" line.	2026-08-19 00:02:13 +00:00
funman300	c68c10cf04	fifa17 store: real 6-pack economy + full-DB pool; drop extPrice - store_catalog: replace the invented catalogue with the real always-available FUT17 regular packs (Bronze/Prem Bronze/Silver/Prem Silver/Gold/Prem Gold) at real prices + tier composition; PackDef now carries per-tier quantities. - pack_body: drop extPrice (its mtx side-effect switched on the broken "or %1s" FIFA-Points tile line; plan-2026-08-05-store-subsystem.md section 3.4). - pack_content: tier-aware generator draws each pack bronze/silver/gold composition with special_chance bias + empty-tier fallback. - host: CoreAccess::all_definitions (GET /cards); build_content_pool draws the FULL card universe via non-minting catalog lookup, owned-inventory fallback. - economy_differential: store ops reclassified DIFFERENT-BY-DESIGN (Rust is the authoritative store; Python oracle stays the untouched rollback baseline). - fixtures/tests updated to the real catalogue. Odds are DESIGNED placeholders (FUT17 pack probabilities were never published); club items remain excluded (cardtype-9 mapping unknown). Full regression green; real prices + tier-correct draws verified server-side on staging.	2026-08-18 23:26:55 +00:00
funman300	7116046195	Lock FIFA17 SBC challenge-squad parser to captured retail wire body Retail Gate C captured PUT /sbs/challenge/101/squad: 23-slot players[] of {index,itemData:{id,dream}} plus manager/chemistry/rating/formation siblings. parse_wire_item_ids already handles it (players[].itemData.id, non-zero only); update the stale "captures unavailable" note and add a verbatim regression test.	2026-08-18 21:29:47 +00:00
funman300	dcac2c546b	Bump launcher: FIFA17 SBC dispatch notifier lifecycle correction	2026-08-18 20:59:07 +00:00
funman300	5c8e2dc0bd	Bump launcher: FIFA17 SBC dispatch response-class live vtable fix	2026-08-18 20:53:05 +00:00
funman300	bd03aec82a	Gate FIFA17 SBC dispatch acceptance	2026-08-18 20:20:38 +00:00
funman300	e8d1c1ddac	test(fifa17): harden SBC retail acceptance	2026-08-18 19:01:33 +00:00
funman300	f9740f640d	feat(fifa17): route SBCs through atomic Rust Core	2026-08-18 18:26:35 +00:00