backend phase 5: service catalog & nurse pricing variants

Two-tier service model the marketplace is priced and searched on. Admin catalog skeleton (categories + EAV option groups/values, addable as data not migrations; NULL category = cross-category) and the nurse pricing layer (nurse_service_variants — the atomic bookable unit: category + one value per required dimension at the nurse's own IRR price and price unit). - New `catalog` schema via one additive migration; Price BIGINT (no floats), on the wire as a string of digits; total = price + unit + session_count. - Duplicate-listing guard: deterministic option_set_hash + filtered UNIQUE(nurse_id, service_category_id, option_set_hash) WHERE deleted_at IS NULL + friendly 409 pre-check. One value per dimension; required groups (incl. cross-category) enforced; deactivate, never delete. - Public catalog browse cached behind a CatalogCache generation token, invalidated on any admin write. IVariantSnapshotSerializer shipped for b8. - Contract (catalog.md) + handoff + report published; swagger refreshed. 122 tests green; zero new build warnings. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-07-02 22:21:53 +03:30
parent 4b4243c451
commit f77a23cb25
84 changed files with 8229 additions and 4 deletions
@@ -0,0 +1,142 @@
+# Contract — Service catalog & nurse pricing variants (backend phase b5)
+
+> The admin catalog skeleton (categories → option groups → option values) and the nurse pricing layer
+> (variants — the atomic bookable unit). Assumes
+> [`../conventions/api-conventions.md`](../conventions/api-conventions.md) +
+> [`../conventions/money-and-types.md`](../conventions/money-and-types.md). Machine schema:
+> [`../openapi/swagger.v1.json`](../openapi/README.md) (refreshed for b5).
+
+**Status:** live as of backend-phase-b5 · **Frontend consumer:** frontend-phase-f4-b5
+
+> **Routing note.** Routes are **action-style** (`[controller]/[action]`, snake_cased) to match the
+> codebase convention and the dynamic-permission key scheme — e.g. create-a-category is
+> `POST api/v1/admin_catalog/create_category`, not `POST api/v1/admin/catalog/categories`. Mutations use
+> **POST**; ids for edit/toggle come from the **route**, never the body. All responses use the standard
+> `{ succeeded, statusCode, data }` envelope; `data` shapes are below. JSON bodies/fields are **camelCase**.
+
+## Enums used
+- `price_unit`: `per_hour` | `per_session` | `per_half_day` | `per_day` | `per_24h` — the unit a variant's
+  `price` is quoted in. `per_24h` (شبانه‌روزی / live-in) and `per_day` are first-class. Stable string codes;
+  the client maps them to i18n labels, never derives a label from the code.
+
+## Key semantics (read first)
+- **The bookable unit is the VARIANT, not the nurse.** A nurse with no active variant is not bookable.
+  Search (b7) and booking (b8) operate on a variant.
+- **`price` is IRR Rials, integer, on the wire as a string of digits** (e.g. `"8000000"`). No floats, no
+  Toman. The engagement **total is `price` + `price_unit` + `session_count`** — never derive a total from
+  `price` alone.
+- **A NULL-category option group is cross-category** — it applies to *every* category. The applicable
+  groups for a category = its own groups **plus** every cross-category group.
+- **All required dimensions must be answered** on variant create (including required cross-category ones);
+  **one value per dimension**; a value must belong to its group and be active.
+- **Duplicate identical listings are rejected** — same nurse + same category + identical answered
+  option-set → **409**.
+- **`display_name` auto-generates** from the category + chosen value labels but is nurse-editable.
+- **Deactivate, never delete.** Categories/groups/values/variants soft-deactivate; a deactivated variant is
+  unbookable and drops out of the public view.
+- **Every catalog row carries `nameFa` (primary) + `nameEn`.** The client picks by locale.
+
+## Public catalog browse — `CatalogController` (no auth)
+
+### `GET api/v1/catalog/categories?page=&page_size=`
+- Active categories ordered by `sortOrder`, **paginated** (default `page_size` 50, max 100). Cached. `data`:
+  `PagedResult<ServiceCategoryDto>`.
+
+### `GET api/v1/catalog/option_groups?category_id={id}`
+- A category's **applicable** option groups — its own active groups **plus** every cross-category (NULL)
+  active group — each with its active values, ordered by `sortOrder`. Cached. **Empty list is valid**
+  (no dimensions defined yet). `data`: `OptionGroupDto[]`.
+
+## Admin catalog curation — `AdminCatalogController` (admin / dynamic-permission)
+Every write **invalidates the catalog cache**. Both labels required (`nameFa`/`nameEn`). No hard delete.
+
+| Route | Body | Result |
+| --- | --- | --- |
+| `POST admin_catalog/create_category` | `{ nameFa, nameEn, descriptionFa?, descriptionEn?, iconKey?, sortOrder }` | `ServiceCategoryDto` |
+| `POST admin_catalog/update_category/{id}` | `{ nameFa, nameEn, descriptionFa?, descriptionEn?, iconKey?, sortOrder }` | `ServiceCategoryDto` |
+| `POST admin_catalog/set_category_active/{id}` | `{ isActive }` | `true` |
+| `POST admin_catalog/create_option_group` | `{ serviceCategoryId?, nameFa, nameEn, isRequired, sortOrder }` | `OptionGroupDto` |
+| `POST admin_catalog/update_option_group/{id}` | `{ serviceCategoryId?, nameFa, nameEn, isRequired, sortOrder }` | `OptionGroupDto` |
+| `POST admin_catalog/create_option_value` | `{ optionGroupId, nameFa, nameEn, sortOrder }` | `OptionValueDto` |
+| `POST admin_catalog/update_option_value/{id}` | `{ nameFa, nameEn, sortOrder, isActive }` | `OptionValueDto` |
+
+- **`serviceCategoryId = null` on a group = cross-category** (applies to every category).
+- `update_option_value` intentionally does **not** re-parent a value to another group (it would change the
+  meaning of variants that already answered with it).
+- **Failure cases:** `400` empty labels / unknown parent (`serviceCategoryId`/`optionGroupId`); `401`
+  unauthenticated; `403` non-admin; `404` unknown id on update/toggle.
+
+## Nurse variants — `NurseVariantsController` (authenticated; nurse-owner-scoped in handler)
+
+### `POST api/v1/nurse_variants/create`
+- **Body:** `{ serviceCategoryId, options: [{ optionGroupId, optionValueId }], price, priceUnit, sessionCount?, displayName? }`
+  — `price` is a string of digits; `options` answers the dimensions (one value per group). Omit
+  `displayName` to auto-generate it.
+- **`data`:** `VariantDto` (`isActive: true`, `displayName` auto-generated from labels unless overridden).
+- **Failure cases:** `400` invalid price (non-digits/≤0)/`priceUnit`/`sessionCount`; a **missing required
+  dimension** (names it); a value not belonging to its group; the same group answered twice; an unknown/
+  inapplicable group or value; missing/inactive category. `401` unauthenticated; `403` caller is not a
+  nurse (or has no nurse profile). **`409`** a duplicate identical listing (same category + option-set) —
+  never a `500`.
+- **Tenancy/side effects:** the nurse is derived from the caller, never the body. (Deferred: this is the
+  trigger point for the b7 `nurse_search_index` fan-out.)
+
+### `POST api/v1/nurse_variants/update/{id}`
+- **Body:** `{ price, priceUnit, sessionCount?, displayName? }` — edits price/unit/session/display only. The
+  **option-set is immutable** here (change dimensions = create-new + deactivate-old). A blank `displayName`
+  leaves the current one unchanged. `data`: `VariantDto`. `404` if not owned/absent (existence not leaked).
+
+### `POST api/v1/nurse_variants/set_active/{id}`
+- **Body:** `{ isActive }`. Deactivate/reactivate — **never hard-delete**. `data`: `true`. `404` if not owned.
+
+### `GET api/v1/nurse_variants/list?page=&page_size=`
+- The nurse's own offerings — **active and inactive**, active-first, paginated. `data`:
+  `PagedResult<VariantDto>`.
+
+### `GET api/v1/nurse_variants/get/{id}`
+- **Auth:** none required (owner/admin get the full view; any other caller gets the **public** projection).
+- The owning nurse and an admin see the variant in any state; anyone else sees it only when **active**.
+  `data`: `VariantDto`. `404` when absent, or inactive to a non-owner.
+
+## Shared shapes
+- `ServiceCategoryDto`: `id` (long), `nameFa`, `nameEn`, `descriptionFa` (string?), `descriptionEn`
+  (string?), `iconKey` (string?), `sortOrder` (int), `isActive` (bool).
+- `OptionValueDto`: `id`, `nameFa`, `nameEn`, `sortOrder`, `isActive`.
+- `OptionGroupDto`: `id`, `serviceCategoryId` (long?, **null = cross-category**), `nameFa`, `nameEn`,
+  `isRequired` (bool), `sortOrder`, `isActive`, `values` (`OptionValueDto[]`).
+- `VariantOptionDto`: `optionGroupId`, `groupNameFa`, `groupNameEn`, `optionValueId`, `valueNameFa`,
+  `valueNameEn`.
+- `VariantDto`: `id`, `serviceCategoryId`, `categoryNameFa`, `categoryNameEn`, `price` (**string of IRR
+  digits**), `priceUnit` (enum), `sessionCount` (int?), `displayName`, `isActive` (bool), `options`
+  (`VariantOptionDto[]`).
+- `PagedResult<T>`: `items` (`T[]`), `total` (int), `page` (int), `pageSize` (int).
+
+## Seed (available on a fresh DB)
+Five categories, ordered by `sortOrder`, `nameFa` + `nameEn`: Elderly Care (id 1, مراقبت از سالمند),
+Post-Surgery Recovery (2, مراقبت پس از جراحی), Infant Care (3, مراقبت از نوزاد), Chronic Illness
+Management (4, مدیریت بیماری مزمن), Companionship (5, همراهی و مراقبت روزمره). **Option groups/values are
+not seeded** — an admin authors them per category (EAV; no migration needed).
+
+## Example — build a variant
+```
+# 1) admin defines a dimension for Elderly Care
+POST /api/v1/admin_catalog/create_option_group
+  { "serviceCategoryId": 1, "nameFa": "نوع شیفت", "nameEn": "Shift type", "isRequired": true, "sortOrder": 1 }
+  -> data.id = 11
+POST /api/v1/admin_catalog/create_option_value
+  { "optionGroupId": 11, "nameFa": "شبانه‌روزی", "nameEn": "Live-in", "sortOrder": 1 }  -> data.id = 101
+
+# 2) nurse builds a priced variant
+POST /api/v1/nurse_variants/create
+  { "serviceCategoryId": 1, "options": [{ "optionGroupId": 11, "optionValueId": 101 }],
+    "price": "8000000", "priceUnit": "per_24h" }
+  -> 200 { id, isActive: true, price: "8000000", displayName: "مراقبت از سالمند · شبانه‌روزی", options: [...] }
+
+# 3) repeating the exact same create -> 409 (duplicate identical listing)
+# 4) omitting the required shift-type value -> 400 (missing required dimension)
+```
+
+## Changelog
+- b5 — initial contract: public catalog browse (categories + applicable option groups), admin catalog CRUD
+  + set-active, nurse variant create/update/set-active/list/get; `price_unit` enum; IRR-string money;
+  `409` duplicate listing / `400` missing required dimension.
@@ -12,6 +12,31 @@ One block per completed backend phase. Newest at the top. Backend lane writes he
 - **Notes for frontend:** <anything load-bearing>
 -->

+## backend-phase-5 — Service catalog & nurse pricing variants — 2026-07-02
+- **Shipped:** five tables via one additive migration (`ServiceCatalogAndNurseVariants`) — new **`catalog`**
+  schema `ServiceCategories` / `ServiceOptionGroups` (nullable `service_category_id` = cross-category) /
+  `ServiceOptionValues` / `NurseServiceVariants` (`Price` **BIGINT IRR**, `PriceUnit`, `SessionCount?`,
+  `DisplayName`, `OptionSetHash`) / `NurseServiceVariantOptions` (`UNIQUE(variant_id, option_group_id)`);
+  seed of **5 categories** (`nameFa`+`nameEn`) via `HasData`. 16 CQRS slices across 3 controllers
+  (`catalog` public browse, `admin_catalog` CRUD + set-active, `nurse_variants` create/update/set-active/
+  list/get). Duplicate-listing guard = `OptionSetHash` + filtered `UNIQUE(nurse_id, service_category_id,
+  option_set_hash) WHERE deleted_at IS NULL` + 409 pre-check. Public catalog reads cached behind a
+  `CatalogCache` generation token (invalidate on any admin write). Ships **`IVariantSnapshotSerializer`**
+  (pure, for b8). **No new seam.**
+- **Contracts:** dev/contracts/domains/catalog.md + openapi snapshot refreshed (yes — 14 new
+  catalog/admin_catalog/nurse_variants paths; 71 total).
+- **Mocked:** none — this phase mocks nothing and adds **no** `reports/mocks-registry.md` row.
+- **Gate:** build clean (0 new code warnings) / tests green (122 pass: +10 handler/serializer unit,
+  +11 `Baya.Test.Api` integration). Migration verified to apply on a real SQL Server; swagger exposes all
+  b5 paths. Adversarial 4-dimension review: 0 confirmed findings.
+- **Handoff:** backend/handoff/after-backend-phase-5.md
+- **Notes for frontend:** the **variant is the bookable unit** (not the nurse). `price` is a **string of IRR
+  digits**; the total is `price` + `priceUnit` + `sessionCount`, never price alone. A **NULL-category option
+  group is cross-category** (render it under every category; required ones must be answered). Duplicate
+  identical listing → **409**; missing required dimension → **400**. `displayName` auto-generates (editable).
+  Deactivate, never delete. Routes are action-style POST (`admin_catalog/create_category`,
+  `nurse_variants/create`, …); groups/values are admin-authored (only categories are seeded).
+
 ## backend-phase-4 — Geography, addresses & nurse service areas — 2026-07-02
 - **Shipped:** five tables via one migration (`GeographyAddressesServiceAreas`) — new **`geo`** schema
  `Provinces` 1:N `Cities` 1:N `Districts` (+ `NurseServiceAreas`) and `usr.CustomerAddresses`; seed
@@ -0,0 +1,82 @@
+# After backend-phase-5 — the service catalog & nurse pricing variants are live
+
+The two-tier service model the whole marketplace is priced and searched on now exists. Admins curate a
+catalog skeleton (categories → configurable option groups → option values) that ships as **data, not
+migrations**, and each nurse turns that skeleton into **variants** — the atomic bookable unit: a category +
+one chosen value per dimension, at the nurse's own price and price unit. Contract:
+[`dev/contracts/domains/catalog.md`](../../../contracts/domains/catalog.md); machine schema:
+`dev/contracts/openapi/swagger.v1.json` (refreshed for b5).
+
+## What the frontend (f4-b5) can now build
+- **Category grid / browse** — `GET api/v1/catalog/categories` (active, ordered, **paginated**, cached).
+  Five categories are seeded (Elderly, Post-Surgery, Infant, Chronic, Companionship) with `nameFa`+`nameEn`.
+- **The nurse service-builder** — for a chosen category, `GET api/v1/catalog/option_groups?category_id=`
+  returns the **applicable** dimensions (the category's own groups **plus** every cross-category group),
+  each with `isRequired` and its active values. The nurse then `POST api/v1/nurse_variants/create`
+  `{ serviceCategoryId, options: [{ optionGroupId, optionValueId }], price, priceUnit, sessionCount?, displayName? }`.
+  Manage with `update/{id}`, `set_active/{id}`, `list`, `get/{id}`. Requires a nurse profile first
+  (b3 `nurse_profiles/upsert`).
+- **Admin catalog console** — `admin_catalog/create_category|update_category/{id}|set_category_active/{id}`,
+  `create_option_group|update_option_group/{id}`, `create_option_value|update_option_value/{id}` (admin
+  token / dynamic-permission).
+- **Public variant view** — `GET api/v1/nurse_variants/get/{id}` returns the public (active-only) projection
+  for anyone, backing a nurse-profile offerings list.
+
+## Rules baked into the API (don't fight them client-side)
+- **The bookable unit is the variant, not the nurse.** Price/book against a specific variant.
+- **`price` is a string of IRR-Rial digits** (e.g. `"8000000"`) — integer money, no floats, no Toman. The
+  **total is `price` + `priceUnit` + `sessionCount`**; never compute it from `price` alone. Parse with a
+  BigInt-safe helper, format for display, map `priceUnit` to an i18n label (never off the code).
+- **A NULL-category option group is cross-category** — it applies to every category. Render the cross-
+  category groups in the builder for *every* category; the required ones must be answered.
+- **All required dimensions must be answered**, **one value per dimension**, a value must belong to its
+  group. A missing required dimension → **400** (names it); a duplicate identical listing → **409**; surface
+  both cleanly.
+- **`displayName` auto-generates** (category + chosen value labels) — show it, let the nurse override it.
+- **Deactivate, never delete.** A deactivated variant stays in the nurse's own `list` (flagged
+  `isActive:false`) but is unbookable and 404s on the public `get`.
+- **Every catalog row has `nameFa` (primary) + `nameEn`** — pick by locale, never label off a code.
+- **Tenancy** — variants are strictly owner-scoped; another nurse's id on write → **404** (existence not
+  leaked). Catalog skeleton writes are **admin-only**.
+- **Refresh after `select_role`** still applies (nurse scoping reads the role claim in the token).
+- **Routes are action-style** (`admin_catalog/create_category`, `nurse_variants/create`, …), POST for
+  mutations, camelCase bodies — see the contract for the full list.
+
+## What b7 (search & matching) must read from the variant
+The variant is a clean, projection-friendly source. b7 owns the denormalized `nurse_search_index` and the
+`INurseSearch` seam (**not built here**). Its fan-out reads, per active variant: `service_category_id`,
+`price`, `price_unit`, `is_active`, `nurse_id` — joined to the nurse's `nurse_service_areas` (b4) to emit one
+index row per covered city/district, and to `nurse_profiles` for `is_verified`/accepting/gender/rating. The
+**single write trigger points** to maintain that index are `CreateVariantCommand`, `SetVariantActiveCommand`
+(and later option/price edits) — hook the index maintenance there.
+
+## What b8 (booking) consumes
+`IVariantSnapshotSerializer` (`Application/Contracts/Common`, single real impl in `Application/Common`) is
+ready: `string Serialize(VariantSnapshot)` emits the canonical `variant_snapshot_json` (category id + labels,
+each `(group label, value label)`, `price` as a digit string, `price_unit`, `session_count`, `display_name`,
+`variant_id`). b8 owns the `booking_requests.variant_snapshot_json` **column** and calls the serializer at
+booking time so later variant edits/deactivation never mutate past bookings. The snapshot column is **not**
+added here.
+
+## Schema / migration
+Migration **`20260702132758_ServiceCatalogAndNurseVariants`** (applies on startup), new **`catalog`** schema:
+`ServiceCategories`, `ServiceOptionGroups` (nullable `ServiceCategoryId` = cross-category),
+`ServiceOptionValues`, `NurseServiceVariants` (`Price` **BIGINT**, `PriceUnit` code, `SessionCount?`,
+`DisplayName`, `OptionSetHash`), `NurseServiceVariantOptions`. Constraints: `UNIQUE(VariantId, OptionGroupId)`
+(one value per dimension); filtered `UNIQUE(NurseId, ServiceCategoryId, OptionSetHash) WHERE DeletedAt IS
+NULL` (duplicate-listing backstop); soft-delete query filters. Seed: five categories (`nameFa`+`nameEn`),
+ids 1–5. Option groups/values are admin-authored data (not seeded).
+
+## Deferred to later phases (do not build against these yet)
+- **`nurse_search_index`, `INurseSearch`, the search query & index fan-out** → **b7** (variant writes are the
+  clean trigger point; the variant shape is projection-ready).
+- **`variant_snapshot_json` persistence** → **b8** (the serializer is shipped and unit-tested here).
+- **`nurse_availability_slots` / `nurse_availability_exceptions`** → **deferred** (soft scheduling guidance,
+  not on the money/safety path) — not built.
+- **Holiday/surge pricing, a Companionship *tier* pricing model, tiered per-category commission** →
+  **deferred**. Companionship ships only as a seeded category (data), not a special pricing path.
+
+## What's mocked
+**Nothing.** Catalog and variant data are fully owned by Balinyaar's DB — this phase introduces **no**
+cross-cutting seam and adds **no** row to `reports/mocks-registry.md`. It reuses `ICacheService` (b0) for the
+public catalog reads with invalidate-on-mutation.
@@ -0,0 +1,103 @@
+# Backend Phase 5 — Service catalog & nurse pricing variants — report
+
+**Status:** complete · build clean (0 new code warnings) · `dotnet test Baya.sln` green (122 pass:
+21 over b4's 101 — 10 new handler/serializer unit tests, +11 API integration & adversarially reviewed).
+**Nothing is mocked** in this phase.
+
+## What was built
+The two-tier service model the whole marketplace is priced/searched on — one additive migration
+(`20260702132758_ServiceCatalogAndNurseVariants`, new **`catalog`** schema), five tables, 14 endpoints across
+3 controllers, plus the b8 snapshot serializer.
+
+- **Entities** (`Domain/Entities/Catalog/`): `ServiceCategory`, `ServiceOptionGroup` (nullable
+  `ServiceCategoryId` = cross-category), `ServiceOptionValue`, `NurseServiceVariant` (`Price` **BIGINT IRR**,
+  `PriceUnit`, `SessionCount?`, `DisplayName`, `OptionSetHash`), `NurseServiceVariantOption`, and the closed
+  `PriceUnits` set (`per_hour`/`per_session`/`per_half_day`/`per_day`/`per_24h`).
+- **EF configs + seed** (`Persistence/Configuration/CatalogConfig/`): soft-delete query filters;
+  `UNIQUE(variant_id, option_group_id)`; filtered `UNIQUE(nurse_id, service_category_id, option_set_hash)
+  WHERE deleted_at IS NULL`; `(is_active, sort_order)` / `(service_category_id, sort_order)` /
+  `(option_group_id, sort_order)` / `(nurse_id, is_active)` / `(service_category_id)` indexes. **Five seed
+  categories** (`nameFa`+`nameEn`, ids 1–5) via `HasData`.
+- **Admin catalog CQRS** (`Features/Catalog/`): `CreateServiceCategory`/`UpdateServiceCategory`/
+  `SetServiceCategoryActive`, `CreateServiceOptionGroup`/`UpdateServiceOptionGroup`,
+  `CreateServiceOptionValue`/`UpdateServiceOptionValue`, and the public cached `GetCatalogCategories`
+  (paginated) / `GetCategoryOptionGroups` (applicable = own + cross-category). Every mutation invalidates the
+  `CatalogCache` generation token.
+- **Nurse variant CQRS** (`Features/Variants/`): `CreateVariant` (required-group enforcement incl.
+  cross-category, one-value-per-dimension, value-in-group, duplicate-listing pre-check + auto display-name),
+  `UpdateVariant` (price/unit/session/display; option-set immutable), `SetVariantActive` (deactivate, never
+  delete), `ListMyVariants` (active + inactive), `GetVariant` (owner/admin full · public active-only).
+- **`OptionSetHash`** helper (deterministic, order-independent SHA-256) + **`IVariantSnapshotSerializer`**
+  (pure, singleton; canonical `variant_snapshot_json` for b8).
+- **Controllers** (`Controllers/V1/`): `AdminCatalogController` (dynamic-permission), `CatalogController`
+  (public), `NurseVariantsController` (`[Authorize]`; `get/{id}` is `[AllowAnonymous]`).
+
+## What is now testable — and exactly how (the phase §7 steps)
+Run the API (`dotnet run --project src/API/Baya.Web.Api/...`) against a reachable SQL Server; use Swagger/curl.
+1. **Catalog seeded** — `GET /api/v1/catalog/categories` → `200`, five categories, `nameFa`+`nameEn`, ordered
+   by `sortOrder`, active only.
+2. **Admin builds a dimension** — as admin, `POST /api/v1/admin_catalog/create_option_group`
+   `{ serviceCategoryId: 1, nameFa: "نوع شیفت", nameEn: "Shift type", isRequired: true, sortOrder: 1 }` → `200`;
+   `POST /api/v1/admin_catalog/create_option_value` twice → `200`;
+   `GET /api/v1/catalog/option_groups?category_id=1` → the required group **plus any cross-category groups**,
+   each with its values.
+3. **Nurse builds a valid variant** — `POST /api/v1/nurse_variants/create`
+   `{ serviceCategoryId: 1, options: [{ optionGroupId, optionValueId }], price: "8000000", priceUnit: "per_24h" }`
+   → `200`, `isActive: true`, auto `displayName` = category + value labels.
+4. **Duplicate identical listing** — repeat the exact create → clean **`409`** (not a `500`).
+5. **Missing required dimension** — create with `options: []` → **`400`** naming the missing group.
+6. **One value per dimension** — two values for the same group in one create → rejected (handler + the
+   `UNIQUE(variant_id, option_group_id)` backstop).
+7. **List active + inactive** — `GET /api/v1/nurse_variants/list`; then
+   `POST /api/v1/nurse_variants/set_active/{id}` `{ isActive: false }` → the deactivated variant still appears,
+   flagged `isActive: false` and unbookable; the row is **never** hard-deleted.
+8. **Tenancy** — a *different* nurse `POST /api/v1/nurse_variants/update/{id}` on the first nurse's variant →
+   **`404`** (existence not leaked).
+9. **Snapshot serializer** — unit-tested: the JSON carries the category labels, each option label, `price`
+   (as a digit string), `priceUnit`, and `sessionCount`.
+
+Automated coverage: `Baya.Test.Foundation/Catalog/` (CreateVariant valid/missing-required/duplicate/
+one-value-per-dimension/value-not-in-group/inactive-category/non-nurse/override; admin category cache
+invalidation + parent checks + cross-category null group; serializer) and `Baya.Test.Api/`
+(`CatalogPublicApiTests`, `NurseVariantsApiTests` — full lifecycle incl. 409/400/tenancy-404/public-get/401).
+
+## Adversarial review
+A 4-dimension review (tenancy/authorization, EAV/cross-category/required-group, money integrity, EF-translation/
+caching/soft-delete) with independent per-finding verification ran over the diff (159 tool-uses, ~382k tokens):
+**0 confirmed findings**. Spot-checked by hand: cross-nurse `get/{id}` returns the public (never full) view;
+the duplicate hash includes cross-category selections; missing a required cross-category group → 400.
+
+## Contracts produced / consumed
+- **Produced:** [`dev/contracts/domains/catalog.md`](../../contracts/domains/catalog.md) (routes, shapes,
+  `price_unit` enum, IRR-string money, `409`/`400` failure cases, examples). `swagger.v1.json` **refreshed**
+  (71 paths total; +14 catalog/variant paths) — verified the API boots and applies the migration on a real
+  SQL Server.
+- **Consumed:** `nurse_profiles` (b3), `ICacheService`/CQRS/`OperationResult`/`BaseController` (b0),
+  admin dynamic-permission policy (b1/b2). No geography coupling (b7 joins the two later).
+
+## Mocks
+**None.** This phase introduces no cross-cutting seam and adds **no** row to
+[`mocks-registry.md`](mocks-registry.md) — stated here so the next agent doesn't go looking.
+`IVariantSnapshotSerializer` is an internal application contract with a single real implementation (not a
+mock seam). `ICacheService` is reused (already 🟡 from b0), not redefined.
+
+## Follow-ups for later phases
+- **b7 (search & matching)** — owns `nurse_search_index`, `INurseSearch`, the search query, and index
+  fan-out. Reads per active variant: `service_category_id`, `price`, `price_unit`, `is_active`, `nurse_id`,
+  fanned across the nurse's `nurse_service_areas` (b4). The maintenance trigger points are
+  `CreateVariantCommand` / `SetVariantActiveCommand` (and future option/price edits).
+- **b8 (booking)** — owns `booking_requests.variant_snapshot_json`; calls `IVariantSnapshotSerializer` at
+  booking time. The serializer is shipped and unit-tested here.
+- **Deferred (not built):** `nurse_availability_slots`/`_exceptions` (soft guidance); holiday/surge pricing;
+  a Companionship *tier* pricing model (ships only as a seeded category); tiered per-category commission.
+
+## Notable decisions (recorded in product/eng docs, not invented)
+- Routes are **action-style POST** with camelCase bodies (matching b3/b4), not the PUT/PATCH the phase table
+  sketched — documented in the contract's routing note.
+- `update_option_value` does **not** re-parent a value to another group (would silently change the meaning of
+  variants that already answered with it).
+- `price` crosses the wire as a **string of digits** (`money-and-types.md`); the DTO/command use `string`.
+- The `OptionSetHash` + filtered-unique duplicate-listing strategy is noted as a reusable pattern in
+  `server/CONVENTIONS.md` §6.
+No new *business* rules were discovered — the product docs (`business/03`, `data-model/03`) already matched;
+left unchanged.
@@ -81,15 +81,15 @@ projects/assemblies, Clean-Architecture layers, and cross-layer dependencies.
 ```
 src/
 ├── Core/
-│   ├── Baya.Domain          Entities (User, Role, UserSession, RoleNames…, Identity/ (NurseProfile, CustomerProfile, Patient, NurseBankAccount, CustomerAddress), Geography/ (Province, City, District, NurseServiceArea), + Configuration/Audit/Analytics/Holidays/Notifications/SupportAlerts), BaseEntity, IEntity, ITimeModification, IAuditableEntity, IAuditable (audit-row marker)
-│   └── Baya.Application     Features/ (Commands & Queries; Identity area = auth + profiles/patients/nurse-bank-accounts; Geography/ServiceAreas/Addresses areas = geo hierarchy + nurse service areas + customer addresses; + Configuration/Audit/Analytics/Holidays/Notifications/SupportAlerts areas), Contracts/ (incl. Contracts/Common cross-cutting seams incl. IBankAccountOwnershipVerifier + IGeocoder + the platform-signal facade contracts + Contracts/Persistence per-domain repositories on IUnitOfWork), Models/, pipeline behaviors (Common/ — validators auto-registered from this assembly)
+│   ├── Baya.Domain          Entities (User, Role, UserSession, RoleNames…, Identity/ (NurseProfile, CustomerProfile, Patient, NurseBankAccount, CustomerAddress), Geography/ (Province, City, District, NurseServiceArea), Catalog/ (ServiceCategory, ServiceOptionGroup, ServiceOptionValue, NurseServiceVariant, NurseServiceVariantOption, PriceUnits), + Configuration/Audit/Analytics/Holidays/Notifications/SupportAlerts), BaseEntity, IEntity, ITimeModification, IAuditableEntity, IAuditable (audit-row marker)
+│   └── Baya.Application     Features/ (Commands & Queries; Identity area = auth + profiles/patients/nurse-bank-accounts; Geography/ServiceAreas/Addresses areas = geo hierarchy + nurse service areas + customer addresses; Catalog/Variants areas = admin catalog skeleton + nurse pricing variants; + Configuration/Audit/Analytics/Holidays/Notifications/SupportAlerts areas), Contracts/ (incl. Contracts/Common cross-cutting seams incl. IBankAccountOwnershipVerifier + IGeocoder + IVariantSnapshotSerializer + the platform-signal facade contracts + Contracts/Persistence per-domain repositories on IUnitOfWork), Models/, pipeline behaviors (Common/ — validators auto-registered from this assembly)
 ├── Infrastructure/
 │   ├── Baya.Infrastructure.Persistence     ApplicationDbContext (+ encrypted-PII value converters & phone-hash sync), ValueConversion/, Repositories/, Configuration/ (per-area EF config), Migrations/, Interceptors/ (AuditFieldInterceptor — audit-fields + audit-log rows), Services/ (DB-backed platform-signal facades + notification-retention hosted service)
 │   ├── Baya.Infrastructure.Identity        Jwt/, Identity/ (Managers, Stores, PermissionManager, Seed, CurrentUser/)
 │   ├── Baya.Infrastructure.CrossCutting    Serilog wiring + Seams/ (mock impls of the cross-cutting seams incl. LoggingSmsSender + MockBankAccountOwnershipVerifier) + AddCrossCuttingSeams
 │   └── Baya.Infrastructure.Monitoring      HealthChecks, OpenTelemetry, prometheus-net
 ├── API/
-│   ├── Baya.Web.Api         Program.cs, Controllers/V1/ (Ping + Auth/Me phone-OTP surface + admin PlatformConfig/Holidays/Audit/SupportAlerts + current-user Notifications + public Geo + admin AdminGeo + nurse NurseServiceAreas + customer CustomerAddresses), appsettings*.json
+│   ├── Baya.Web.Api         Program.cs, Controllers/V1/ (Ping + Auth/Me phone-OTP surface + admin PlatformConfig/Holidays/Audit/SupportAlerts + current-user Notifications + public Geo + admin AdminGeo + nurse NurseServiceAreas + customer CustomerAddresses + public Catalog + admin AdminCatalog + nurse NurseVariants), appsettings*.json
 │   ├── Baya.WebFramework    BaseController (incl. 401/403 OperationResult mapping), Filters/, Middlewares/, Swagger/, Routing/, ServiceConfiguration/ (rate limiting)
 │   └── Plugins/Baya.Web.Plugins.Grpc   gRPC services + .proto models (User only)
 ├── Shared/Baya.SharedKernel   Extensions + validation base
@@ -168,6 +168,32 @@ via `HasData` (b1 path): 31 provinces + their capital cities (covers the white-s
 - **Reference reads are cached** through `ICacheService` behind a generation-token key scheme (`GeoCache`);
  any admin geo write bumps the token, invalidating the whole geo cache namespace at once.

+**Service catalog & nurse pricing variants (backend-phase-5).** A new **`catalog` schema** holds the two-tier
+service model. The **admin skeleton** — `ServiceCategories` → `ServiceOptionGroups` → `ServiceOptionValues` —
+is intentionally **EAV/data, not code**: an admin adds a category or a pricing dimension as rows, never a
+migration (the only closed code enum in the area is `PriceUnits`). A `ServiceOptionGroups.ServiceCategoryId =
+NULL` marks a **cross-category** dimension that applies to every category. The **nurse layer** —
+`NurseServiceVariants` (the atomic **bookable unit**: FK `nurse_profiles` + category + `Price` **BIGINT IRR**
+ `PriceUnit` code + `SessionCount?` + auto-generated-but-editable `DisplayName`) + `NurseServiceVariantOptions`
+(one row per answered dimension, `UNIQUE(variant_id, option_group_id)`) — turns the skeleton into priced
+offerings. Features under `Baya.Application/Features/{Catalog|Variants}/`; configs +
+seed in `Persistence/Configuration/CatalogConfig/`; per-domain repos (`ICatalogRepository`,
+`INurseServiceVariantRepository`) on `IUnitOfWork`. Load-bearing rules:
+- **The bookable unit is the variant, not the nurse.** b7 (search) and b8 (booking) operate on a variant;
+  keep it a clean projectable source. `price` is IRR `BIGINT` (no floats) and crosses the wire as a digit
+  string; the engagement total is `price` + `price_unit` + `session_count`, never `price` alone.
+- **Duplicate-listing guard** = a deterministic `OptionSetHash` (see `CONVENTIONS.md`) + a filtered
+  `UNIQUE(nurse_id, service_category_id, option_set_hash) WHERE deleted_at IS NULL` backstop, plus a friendly
+  pre-check (409) — a multi-row option-set can't be a plain composite unique.
+- **Applicable groups = the category's own groups + every cross-category (NULL) group** everywhere (public
+  browse, required-group validation, duplicate guard). All required groups must be answered; one value per
+  dimension; deactivate, never hard-delete (soft-delete query filters).
+- **Public catalog reads are cached** through `ICacheService` behind a `CatalogCache` generation-token scheme;
+  any admin catalog write bumps the token.
+- **`IVariantSnapshotSerializer`** (Application contract, single real impl in `Application/Common`) emits the
+  canonical `variant_snapshot_json` and is **consumed by b8** (which owns the `booking_requests` column);
+  this phase ships and unit-tests it but persists nothing. `nurse_search_index` is **b7's** (not built here).
+
 **Keeping the Project map current.** When a change touches the architecture — adds, removes, or
 renames a project/assembly, a Clean-Architecture layer, or a major folder, or changes a cross-layer
 dependency — you **must** update this Project map (and the dependency rule above, if affected) in the
@@ -300,6 +300,18 @@ Wire `ICurrentUser` (HTTP context accessor wrapped in an interface, registered S

 Every monetary value is **IRR Rials stored as `long` / `BIGINT`**. There is **no float/decimal path** on money — not in entities, DTOs, the API, or arithmetic. Toman is display-only and converts to/from Rials **only** inside a provider adapter at its boundary, never in domain or shared code. If a money value object is introduced later it must be integer-only. The three booking amounts always satisfy `gross = commission + payout`.

+### Deterministic set-hash for multi-row uniqueness
+
+When "no two rows may share the same *set* of child rows" must be enforced (e.g. a nurse can't list two
+identical variants — same category + identical answered option-set), a plain composite unique index can't
+express it because the set spans multiple rows. Reduce the set to a single comparable column with
+**`Baya.Application.Common.OptionSetHash.Compute(pairs)`** (backend-phase-5): it sorts the `(long, long)`
+pairs and SHA-256s them to a stable 64-char hex hash that is **order-independent** (identical sets always
+collide). Persist it (`NVARCHAR(64)`) and back it with a **filtered unique index** (e.g.
+`UNIQUE(nurse_id, service_category_id, option_set_hash) WHERE deleted_at IS NULL`) as the race-safe backstop,
+with a handler pre-check for the friendly `409`. Reuse this helper for any future "same set of ids" guard;
+do **not** reuse `IFieldEncryptor.Hash` (that is for PII-column equality lookups).
+
 ---

 ## 7. Validation
@@ -0,0 +1,61 @@
+using System.ComponentModel.DataAnnotations;
+using Asp.Versioning;
+using Baya.Application.Features.Catalog.Commands.CreateServiceCategory;
+using Baya.Application.Features.Catalog.Commands.CreateServiceOptionGroup;
+using Baya.Application.Features.Catalog.Commands.CreateServiceOptionValue;
+using Baya.Application.Features.Catalog.Commands.SetServiceCategoryActive;
+using Baya.Application.Features.Catalog.Commands.UpdateServiceCategory;
+using Baya.Application.Features.Catalog.Commands.UpdateServiceOptionGroup;
+using Baya.Application.Features.Catalog.Commands.UpdateServiceOptionValue;
+using Baya.Application.Models.Catalog;
+using Baya.Infrastructure.Identity.Identity.PermissionManager;
+using Baya.WebFramework.Attributes;
+using Baya.WebFramework.BaseController;
+using Mediator;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Baya.Web.Api.Controllers.V1;
+
+[ApiVersion("1")]
+[ApiController]
+[Route("api/v{version:apiVersion}/[controller]")]
+[Authorize(ConstantPolicies.DynamicPermission)]
+[Display(Description = "Admin: curate the catalog skeleton (categories + option groups/values; no delete)")]
+public sealed class AdminCatalogController(ISender sender) : BaseController
+{
+    [HttpPost("[action]")]
+    [ProducesOkApiResponseType<ServiceCategoryDto>]
+    public async Task<IActionResult> CreateCategory(CreateServiceCategoryCommand command, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(command, cancellationToken));
+
+    [HttpPost("[action]/{id}")]
+    [ProducesOkApiResponseType<ServiceCategoryDto>]
+    public async Task<IActionResult> UpdateCategory(long id, UpdateServiceCategoryCommand command, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(command with { Id = id }, cancellationToken));
+
+    [HttpPost("[action]/{id}")]
+    [ProducesOkApiResponseType]
+    public async Task<IActionResult> SetCategoryActive(long id, SetServiceCategoryActiveCommand command, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(command with { Id = id }, cancellationToken));
+
+    [HttpPost("[action]")]
+    [ProducesOkApiResponseType<OptionGroupDto>]
+    public async Task<IActionResult> CreateOptionGroup(CreateServiceOptionGroupCommand command, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(command, cancellationToken));
+
+    [HttpPost("[action]/{id}")]
+    [ProducesOkApiResponseType<OptionGroupDto>]
+    public async Task<IActionResult> UpdateOptionGroup(long id, UpdateServiceOptionGroupCommand command, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(command with { Id = id }, cancellationToken));
+
+    [HttpPost("[action]")]
+    [ProducesOkApiResponseType<OptionValueDto>]
+    public async Task<IActionResult> CreateOptionValue(CreateServiceOptionValueCommand command, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(command, cancellationToken));
+
+    [HttpPost("[action]/{id}")]
+    [ProducesOkApiResponseType<OptionValueDto>]
+    public async Task<IActionResult> UpdateOptionValue(long id, UpdateServiceOptionValueCommand command, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(command with { Id = id }, cancellationToken));
+}
@@ -0,0 +1,29 @@
+using System.ComponentModel.DataAnnotations;
+using Asp.Versioning;
+using Baya.Application.Features.Catalog.Queries.GetCatalogCategories;
+using Baya.Application.Features.Catalog.Queries.GetCategoryOptionGroups;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Baya.WebFramework.Attributes;
+using Baya.WebFramework.BaseController;
+using Mediator;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Baya.Web.Api.Controllers.V1;
+
+[ApiVersion("1")]
+[ApiController]
+[Route("api/v{version:apiVersion}/[controller]")]
+[Display(Description = "Public catalog browse: active categories and a category's applicable option groups")]
+public sealed class CatalogController(ISender sender) : BaseController
+{
+    [HttpGet("[action]")]
+    [ProducesOkApiResponseType<PagedResult<ServiceCategoryDto>>]
+    public async Task<IActionResult> Categories([FromQuery] GetCatalogCategoriesQuery query, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(query, cancellationToken));
+
+    [HttpGet("[action]")]
+    [ProducesOkApiResponseType<IReadOnlyList<OptionGroupDto>>]
+    public async Task<IActionResult> OptionGroups([FromQuery(Name = "category_id")] long categoryId, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(new GetCategoryOptionGroupsQuery(categoryId), cancellationToken));
+}
@@ -0,0 +1,51 @@
+using System.ComponentModel.DataAnnotations;
+using Asp.Versioning;
+using Baya.Application.Features.Variants.Commands.CreateVariant;
+using Baya.Application.Features.Variants.Commands.SetVariantActive;
+using Baya.Application.Features.Variants.Commands.UpdateVariant;
+using Baya.Application.Features.Variants.Queries.GetVariant;
+using Baya.Application.Features.Variants.Queries.ListMyVariants;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Baya.WebFramework.Attributes;
+using Baya.WebFramework.BaseController;
+using Mediator;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Baya.Web.Api.Controllers.V1;
+
+[ApiVersion("1")]
+[ApiController]
+[Route("api/v{version:apiVersion}/[controller]")]
+[Authorize]
+[Display(Description = "The signed-in nurse's priced service variants (the bookable unit)")]
+public sealed class NurseVariantsController(ISender sender) : BaseController
+{
+    [HttpPost("[action]")]
+    [ProducesOkApiResponseType<VariantDto>]
+    public async Task<IActionResult> Create(CreateVariantCommand command, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(command, cancellationToken));
+
+    [HttpPost("[action]/{id}")]
+    [ProducesOkApiResponseType<VariantDto>]
+    public async Task<IActionResult> Update(long id, UpdateVariantCommand command, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(command with { Id = id }, cancellationToken));
+
+    [HttpPost("[action]/{id}")]
+    [ProducesOkApiResponseType]
+    public async Task<IActionResult> SetActive(long id, SetVariantActiveCommand command, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(command with { Id = id }, cancellationToken));
+
+    [HttpGet("[action]")]
+    [ProducesOkApiResponseType<PagedResult<VariantDto>>]
+    public async Task<IActionResult> List([FromQuery] ListMyVariantsQuery query, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(query, cancellationToken));
+
+    // Owner/admin get the full view; any other caller (public nurse-profile view) gets active-only.
+    [AllowAnonymous]
+    [HttpGet("[action]/{id}")]
+    [ProducesOkApiResponseType<VariantDto>]
+    public async Task<IActionResult> Get(long id, CancellationToken cancellationToken)
+        => OperationResult(await sender.Send(new GetVariantQuery(id), cancellationToken));
+}
@@ -0,0 +1,26 @@
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Baya.Application.Common;
+
+/// <summary>
+/// Deterministic hash of a variant's answered option-set — the key behind the duplicate-listing filtered
+/// unique index (<c>UNIQUE(nurse_id, service_category_id, option_set_hash)</c>). Because the option-set is
+/// multi-row, a plain composite unique index can't express "same set of choices"; hashing the sorted
+/// <c>(group_id, value_id)</c> pairs reduces it to one comparable column. Sorting makes the hash order-
+/// independent; the same set of choices always yields the same 64-char hex hash. An empty option-set
+/// (a category with no answered groups) hashes to a stable value, so two such variants still collide.
+/// </summary>
+public static class OptionSetHash
+{
+    public static string Compute(IEnumerable<(long GroupId, long ValueId)> pairs)
+    {
+        var canonical = string.Join(
+            "|",
+            pairs.OrderBy(p => p.GroupId).ThenBy(p => p.ValueId)
+                 .Select(p => $"{p.GroupId}:{p.ValueId}"));
+
+        var hash = SHA256.HashData(Encoding.UTF8.GetBytes(canonical));
+        return Convert.ToHexString(hash).ToLowerInvariant();
+    }
+}
@@ -0,0 +1,56 @@
+using System.Globalization;
+using System.Text.Encodings.Web;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.Unicode;
+using Baya.Application.Contracts.Common;
+using Baya.Application.Models.Catalog;
+
+namespace Baya.Application.Common;
+
+/// <summary>
+/// Canonical implementation of <see cref="IVariantSnapshotSerializer"/>. Emits a stable, camelCase JSON
+/// object carrying the category id + labels, each resolved <c>(group label, value label)</c>, the price
+/// (as a string of digits), price unit, session count, display name, and the variant id. Property order is
+/// fixed (declaration order) so the output is deterministic for a given input.
+/// </summary>
+public sealed class VariantSnapshotSerializer : IVariantSnapshotSerializer
+{
+    private static readonly JsonSerializerOptions Options = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        DefaultIgnoreCondition = JsonIgnoreCondition.Never,
+        // Persian labels must land in the snapshot as readable text, not \uXXXX escapes; the encoder still
+        // escapes the HTML-sensitive ASCII characters so the stored JSON stays safe to embed.
+        Encoder = JavaScriptEncoder.Create(UnicodeRanges.All),
+        WriteIndented = false
+    };
+
+    public string Serialize(VariantSnapshot snapshot)
+    {
+        // Money crosses the snapshot as a string of IRR-Rial digits (integer money, no floats). Invariant
+        // culture so the digits are always ASCII regardless of the ambient locale.
+        var payload = new
+        {
+            variantId = snapshot.VariantId,
+            serviceCategoryId = snapshot.ServiceCategoryId,
+            categoryNameFa = snapshot.CategoryNameFa,
+            categoryNameEn = snapshot.CategoryNameEn,
+            price = snapshot.Price.ToString(CultureInfo.InvariantCulture),
+            priceUnit = snapshot.PriceUnit,
+            sessionCount = snapshot.SessionCount,
+            displayName = snapshot.DisplayName,
+            options = snapshot.Options.Select(o => new
+            {
+                o.OptionGroupId,
+                o.GroupNameFa,
+                o.GroupNameEn,
+                o.OptionValueId,
+                o.ValueNameFa,
+                o.ValueNameEn
+            })
+        };
+
+        return JsonSerializer.Serialize(payload, Options);
+    }
+}
@@ -0,0 +1,16 @@
+using Baya.Application.Models.Catalog;
+
+namespace Baya.Application.Contracts.Common;
+
+/// <summary>
+/// Emits the canonical <c>variant_snapshot_json</c> that Booking (backend-phase-8) freezes onto a
+/// <c>booking_requests</c> row so later variant edits/deactivation never mutate past bookings, disputes, or
+/// invoices. A pure function — no I/O, no state. This phase ships and unit-tests it; b8 persists its output.
+/// Not an external-service seam: it has a single real implementation.
+/// </summary>
+public interface IVariantSnapshotSerializer
+{
+    /// <summary>Serialize a variant + its resolved options as they are at serialize time. Price is emitted
+    /// as a string of IRR-Rial digits (integer money, no floats).</summary>
+    string Serialize(VariantSnapshot snapshot);
+}
@@ -0,0 +1,43 @@
+#nullable enable
+using Baya.Application.Models.Catalog;
+using Baya.Domain.Entities.Catalog;
+
+namespace Baya.Application.Contracts.Persistence;
+
+/// <summary>
+/// The admin catalog skeleton (categories → option groups → option values) plus the public browse reads.
+/// Reads are projected + no-tracking (callers cache them); admin getters are tracked (include inactive,
+/// exclude soft-deleted) for edit/toggle. The applicable-groups read returns a category's own groups
+/// <b>plus</b> every cross-category (NULL-category) group — the load-bearing EAV rule.
+/// </summary>
+public interface ICatalogRepository
+{
+    /// <summary>All active categories, ordered by sort order — cached by the caller.</summary>
+    Task<IReadOnlyList<ServiceCategoryDto>> ListActiveCategoriesAsync(CancellationToken cancellationToken);
+
+    /// <summary>The category's own active groups plus every cross-category (NULL) active group, each with
+    /// its active values, ordered by sort order. Empty is valid (no dimensions defined yet).</summary>
+    Task<IReadOnlyList<OptionGroupDto>> GetApplicableGroupsAsync(long categoryId, CancellationToken cancellationToken);
+
+    /// <summary>Active-only category projection for variant creation — null if missing or deactivated.</summary>
+    Task<ServiceCategoryDto?> GetActiveCategoryAsync(long id, CancellationToken cancellationToken);
+
+    /// <summary>A single group projected with its active values — the honest response for a group mutation
+    /// (a freshly created group returns an empty value list). Null if the group is absent/soft-deleted.</summary>
+    Task<OptionGroupDto?> GetGroupDtoAsync(long id, CancellationToken cancellationToken);
+
+    // Admin: tracked lookups (include inactive, exclude soft-deleted) for edit/toggle.
+    Task<ServiceCategory?> GetCategoryAsync(long id, CancellationToken cancellationToken);
+    Task<ServiceOptionGroup?> GetGroupAsync(long id, CancellationToken cancellationToken);
+    Task<ServiceOptionValue?> GetValueAsync(long id, CancellationToken cancellationToken);
+
+    /// <summary>Whether a non-soft-deleted category exists (any active state) — parent check for a group.</summary>
+    Task<bool> CategoryExistsAsync(long id, CancellationToken cancellationToken);
+
+    /// <summary>Whether a non-soft-deleted group exists — parent check for a value.</summary>
+    Task<bool> GroupExistsAsync(long id, CancellationToken cancellationToken);
+
+    Task AddCategoryAsync(ServiceCategory category, CancellationToken cancellationToken);
+    Task AddGroupAsync(ServiceOptionGroup group, CancellationToken cancellationToken);
+    Task AddValueAsync(ServiceOptionValue value, CancellationToken cancellationToken);
+}
@@ -0,0 +1,36 @@
+#nullable enable
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Baya.Domain.Entities.Catalog;
+
+namespace Baya.Application.Contracts.Persistence;
+
+/// <summary>
+/// A nurse's priced offerings — the atomic bookable unit. Writes go through the owning-nurse tenancy check;
+/// reads project to <see cref="VariantDto"/> with resolved category/option labels. The duplicate-listing
+/// guard is a pre-check here plus the filtered unique index backstop in the EF configuration.
+/// </summary>
+public interface INurseServiceVariantRepository
+{
+    Task AddAsync(NurseServiceVariant variant, CancellationToken cancellationToken);
+
+    /// <summary>Tracked, tenancy-scoped getter for owner scalar edits/toggle. Null if not owned/absent —
+    /// existence of another nurse's variant is never leaked.</summary>
+    Task<NurseServiceVariant?> GetOwnedAsync(long id, long nurseId, CancellationToken cancellationToken);
+
+    /// <summary>Duplicate-listing pre-check: a non-deleted variant with this exact option-set already exists
+    /// for the nurse+category. <paramref name="excludeVariantId"/> skips the variant being edited.</summary>
+    Task<bool> DuplicateHashExistsAsync(long nurseId, long serviceCategoryId, string optionSetHash, long? excludeVariantId, CancellationToken cancellationToken);
+
+    /// <summary>The nurse's own offerings (active + inactive), paginated, active-first, resolved labels.</summary>
+    Task<PagedResult<VariantDto>> ListMineAsync(long nurseId, int page, int pageSize, CancellationToken cancellationToken);
+
+    /// <summary>Full projection for the owning nurse — any status. Null if not owned/absent.</summary>
+    Task<VariantDto?> GetOwnedProjectedAsync(long id, long nurseId, CancellationToken cancellationToken);
+
+    /// <summary>Full projection for admin — any status. Null if absent.</summary>
+    Task<VariantDto?> GetProjectedAsync(long id, CancellationToken cancellationToken);
+
+    /// <summary>Public-safe projection: an <b>active</b> variant only. Null when missing/inactive.</summary>
+    Task<VariantDto?> GetPublicProjectedAsync(long id, CancellationToken cancellationToken);
+}
@@ -12,6 +12,8 @@ public interface IUnitOfWork
    public IGeoRepository GeoRepository { get; }
    public INurseServiceAreaRepository NurseServiceAreaRepository { get; }
    public ICustomerAddressRepository CustomerAddressRepository { get; }
+    public ICatalogRepository CatalogRepository { get; }
+    public INurseServiceVariantRepository NurseServiceVariantRepository { get; }
    Task CommitAsync();
    ValueTask RollBackAsync();
 }
@@ -0,0 +1,31 @@
+#nullable enable
+using Baya.Application.Contracts.Common;
+
+namespace Baya.Application.Features.Catalog;
+
+/// <summary>
+/// Cache-key scheme for the read-heavy public catalog lookups (categories + a category's option groups).
+/// Every data key is namespaced by a generation token; any admin catalog mutation bumps the token, which
+/// orphans all prior catalog entries in one move (they lapse by TTL). Mirrors the geo generation-token
+/// scheme so cascade invalidation stays trivial and correct — deactivating a category or editing a group
+/// instantly refreshes the whole namespace without enumerating child keys.
+/// </summary>
+internal static class CatalogCache
+{
+    private const string VersionKey = "catalog:version";
+
+    // Catalog reference data changes rarely; a modest TTL bounds staleness even if a bump is ever missed.
+    public static readonly TimeSpan Ttl = TimeSpan.FromHours(1);
+
+    public static ValueTask<string> VersionAsync(ICacheService cache, CancellationToken cancellationToken)
+        => cache.GetOrCreateAsync(VersionKey, _ => ValueTask.FromResult(NewToken()), null, cancellationToken);
+
+    public static ValueTask InvalidateAsync(ICacheService cache, CancellationToken cancellationToken)
+        => cache.SetAsync(VersionKey, NewToken(), null, cancellationToken);
+
+    public static string CategoriesKey(string version) => $"catalog:{version}:categories";
+
+    public static string OptionGroupsKey(string version, long categoryId) => $"catalog:{version}:groups:{categoryId}";
+
+    private static string NewToken() => Guid.NewGuid().ToString("N");
+}
@@ -0,0 +1,35 @@
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Baya.Domain.Entities.Catalog;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.CreateServiceCategory;
+
+internal sealed class CreateServiceCategoryCommandHandler(IUnitOfWork unitOfWork, ICacheService cache)
+    : IRequestHandler<CreateServiceCategoryCommand, OperationResult<ServiceCategoryDto>>
+{
+    public async ValueTask<OperationResult<ServiceCategoryDto>> Handle(CreateServiceCategoryCommand request, CancellationToken cancellationToken)
+    {
+        var category = new ServiceCategory
+        {
+            NameFa = request.NameFa,
+            NameEn = request.NameEn,
+            DescriptionFa = request.DescriptionFa,
+            DescriptionEn = request.DescriptionEn,
+            IconKey = request.IconKey,
+            SortOrder = request.SortOrder,
+            IsActive = true
+        };
+
+        await unitOfWork.CatalogRepository.AddCategoryAsync(category, cancellationToken);
+        await unitOfWork.CommitAsync();
+
+        await CatalogCache.InvalidateAsync(cache, cancellationToken);
+
+        return OperationResult<ServiceCategoryDto>.SuccessResult(new ServiceCategoryDto(
+            category.Id, category.NameFa, category.NameEn, category.DescriptionFa, category.DescriptionEn,
+            category.IconKey, category.SortOrder, category.IsActive));
+    }
+}
@@ -0,0 +1,15 @@
+using FluentValidation;
+
+namespace Baya.Application.Features.Catalog.Commands.CreateServiceCategory;
+
+public sealed class CreateServiceCategoryCommandValidator : AbstractValidator<CreateServiceCategoryCommand>
+{
+    public CreateServiceCategoryCommandValidator()
+    {
+        RuleFor(x => x.NameFa).NotEmpty().MaximumLength(150);
+        RuleFor(x => x.NameEn).NotEmpty().MaximumLength(150);
+        RuleFor(x => x.DescriptionFa).MaximumLength(1000);
+        RuleFor(x => x.DescriptionEn).MaximumLength(1000);
+        RuleFor(x => x.IconKey).MaximumLength(100);
+    }
+}
@@ -0,0 +1,15 @@
+#nullable enable
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.CreateServiceCategory;
+
+/// <summary>Admin: add a top-level care category (data, not code). Both labels required. Invalidates cache.</summary>
+public record CreateServiceCategoryCommand(
+    string NameFa,
+    string NameEn,
+    string? DescriptionFa,
+    string? DescriptionEn,
+    string? IconKey,
+    int SortOrder) : IRequest<OperationResult<ServiceCategoryDto>>;
@@ -0,0 +1,37 @@
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Baya.Domain.Entities.Catalog;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.CreateServiceOptionGroup;
+
+internal sealed class CreateServiceOptionGroupCommandHandler(IUnitOfWork unitOfWork, ICacheService cache)
+    : IRequestHandler<CreateServiceOptionGroupCommand, OperationResult<OptionGroupDto>>
+{
+    public async ValueTask<OperationResult<OptionGroupDto>> Handle(CreateServiceOptionGroupCommand request, CancellationToken cancellationToken)
+    {
+        if (request.ServiceCategoryId is { } categoryId
+            && !await unitOfWork.CatalogRepository.CategoryExistsAsync(categoryId, cancellationToken))
+            return OperationResult<OptionGroupDto>.FailureResult(nameof(request.ServiceCategoryId), "Category not found.");
+
+        var group = new ServiceOptionGroup
+        {
+            ServiceCategoryId = request.ServiceCategoryId,
+            NameFa = request.NameFa,
+            NameEn = request.NameEn,
+            IsRequired = request.IsRequired,
+            SortOrder = request.SortOrder,
+            IsActive = true
+        };
+
+        await unitOfWork.CatalogRepository.AddGroupAsync(group, cancellationToken);
+        await unitOfWork.CommitAsync();
+
+        await CatalogCache.InvalidateAsync(cache, cancellationToken);
+
+        var dto = await unitOfWork.CatalogRepository.GetGroupDtoAsync(group.Id, cancellationToken);
+        return OperationResult<OptionGroupDto>.SuccessResult(dto!);
+    }
+}
@@ -0,0 +1,14 @@
+using FluentValidation;
+
+namespace Baya.Application.Features.Catalog.Commands.CreateServiceOptionGroup;
+
+public sealed class CreateServiceOptionGroupCommandValidator : AbstractValidator<CreateServiceOptionGroupCommand>
+{
+    public CreateServiceOptionGroupCommandValidator()
+    {
+        RuleFor(x => x.NameFa).NotEmpty().MaximumLength(150);
+        RuleFor(x => x.NameEn).NotEmpty().MaximumLength(150);
+        // Null is the deliberate cross-category case; only a supplied id must be positive.
+        RuleFor(x => x.ServiceCategoryId).GreaterThan(0).When(x => x.ServiceCategoryId.HasValue);
+    }
+}
@@ -0,0 +1,17 @@
+#nullable enable
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.CreateServiceOptionGroup;
+
+/// <summary>
+/// Admin: add a pricing dimension. <see cref="ServiceCategoryId"/> == <c>null</c> makes it
+/// <b>cross-category</b> (applies to every category). Invalidates the catalog cache.
+/// </summary>
+public record CreateServiceOptionGroupCommand(
+    long? ServiceCategoryId,
+    string NameFa,
+    string NameEn,
+    bool IsRequired,
+    int SortOrder) : IRequest<OperationResult<OptionGroupDto>>;
@@ -0,0 +1,35 @@
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Baya.Domain.Entities.Catalog;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.CreateServiceOptionValue;
+
+internal sealed class CreateServiceOptionValueCommandHandler(IUnitOfWork unitOfWork, ICacheService cache)
+    : IRequestHandler<CreateServiceOptionValueCommand, OperationResult<OptionValueDto>>
+{
+    public async ValueTask<OperationResult<OptionValueDto>> Handle(CreateServiceOptionValueCommand request, CancellationToken cancellationToken)
+    {
+        if (!await unitOfWork.CatalogRepository.GroupExistsAsync(request.OptionGroupId, cancellationToken))
+            return OperationResult<OptionValueDto>.FailureResult(nameof(request.OptionGroupId), "Option group not found.");
+
+        var value = new ServiceOptionValue
+        {
+            OptionGroupId = request.OptionGroupId,
+            NameFa = request.NameFa,
+            NameEn = request.NameEn,
+            SortOrder = request.SortOrder,
+            IsActive = true
+        };
+
+        await unitOfWork.CatalogRepository.AddValueAsync(value, cancellationToken);
+        await unitOfWork.CommitAsync();
+
+        await CatalogCache.InvalidateAsync(cache, cancellationToken);
+
+        return OperationResult<OptionValueDto>.SuccessResult(new OptionValueDto(
+            value.Id, value.NameFa, value.NameEn, value.SortOrder, value.IsActive));
+    }
+}
@@ -0,0 +1,13 @@
+using FluentValidation;
+
+namespace Baya.Application.Features.Catalog.Commands.CreateServiceOptionValue;
+
+public sealed class CreateServiceOptionValueCommandValidator : AbstractValidator<CreateServiceOptionValueCommand>
+{
+    public CreateServiceOptionValueCommandValidator()
+    {
+        RuleFor(x => x.OptionGroupId).GreaterThan(0);
+        RuleFor(x => x.NameFa).NotEmpty().MaximumLength(150);
+        RuleFor(x => x.NameEn).NotEmpty().MaximumLength(150);
+    }
+}
@@ -0,0 +1,12 @@
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.CreateServiceOptionValue;
+
+/// <summary>Admin: add a concrete choice to an option group. Both labels required. Invalidates cache.</summary>
+public record CreateServiceOptionValueCommand(
+    long OptionGroupId,
+    string NameFa,
+    string NameEn,
+    int SortOrder) : IRequest<OperationResult<OptionValueDto>>;
@@ -0,0 +1,24 @@
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.SetServiceCategoryActive;
+
+internal sealed class SetServiceCategoryActiveCommandHandler(IUnitOfWork unitOfWork, ICacheService cache)
+    : IRequestHandler<SetServiceCategoryActiveCommand, OperationResult<bool>>
+{
+    public async ValueTask<OperationResult<bool>> Handle(SetServiceCategoryActiveCommand request, CancellationToken cancellationToken)
+    {
+        var category = await unitOfWork.CatalogRepository.GetCategoryAsync(request.Id, cancellationToken);
+        if (category is null)
+            return OperationResult<bool>.NotFoundResult("Category not found.");
+
+        category.IsActive = request.IsActive;
+
+        await unitOfWork.CommitAsync();
+        await CatalogCache.InvalidateAsync(cache, cancellationToken);
+
+        return OperationResult<bool>.SuccessResult(true);
+    }
+}
@@ -0,0 +1,11 @@
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.SetServiceCategoryActive;
+
+/// <summary>
+/// Admin: toggle a category's active flag. <b>Soft state only — never hard-delete.</b> Deactivating hides
+/// the category from public browse and from new variant creation; existing variants in it are left intact
+/// (their bookings/history survive via the booking snapshot). <see cref="Id"/> comes from the route.
+/// </summary>
+public record SetServiceCategoryActiveCommand(long Id, bool IsActive) : IRequest<OperationResult<bool>>;
@@ -0,0 +1,32 @@
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.UpdateServiceCategory;
+
+internal sealed class UpdateServiceCategoryCommandHandler(IUnitOfWork unitOfWork, ICacheService cache)
+    : IRequestHandler<UpdateServiceCategoryCommand, OperationResult<ServiceCategoryDto>>
+{
+    public async ValueTask<OperationResult<ServiceCategoryDto>> Handle(UpdateServiceCategoryCommand request, CancellationToken cancellationToken)
+    {
+        var category = await unitOfWork.CatalogRepository.GetCategoryAsync(request.Id, cancellationToken);
+        if (category is null)
+            return OperationResult<ServiceCategoryDto>.NotFoundResult("Category not found.");
+
+        category.NameFa = request.NameFa;
+        category.NameEn = request.NameEn;
+        category.DescriptionFa = request.DescriptionFa;
+        category.DescriptionEn = request.DescriptionEn;
+        category.IconKey = request.IconKey;
+        category.SortOrder = request.SortOrder;
+
+        await unitOfWork.CommitAsync();
+        await CatalogCache.InvalidateAsync(cache, cancellationToken);
+
+        return OperationResult<ServiceCategoryDto>.SuccessResult(new ServiceCategoryDto(
+            category.Id, category.NameFa, category.NameEn, category.DescriptionFa, category.DescriptionEn,
+            category.IconKey, category.SortOrder, category.IsActive));
+    }
+}
@@ -0,0 +1,16 @@
+using FluentValidation;
+
+namespace Baya.Application.Features.Catalog.Commands.UpdateServiceCategory;
+
+public sealed class UpdateServiceCategoryCommandValidator : AbstractValidator<UpdateServiceCategoryCommand>
+{
+    // Id is supplied by the route (set after model binding), so it is not validated here.
+    public UpdateServiceCategoryCommandValidator()
+    {
+        RuleFor(x => x.NameFa).NotEmpty().MaximumLength(150);
+        RuleFor(x => x.NameEn).NotEmpty().MaximumLength(150);
+        RuleFor(x => x.DescriptionFa).MaximumLength(1000);
+        RuleFor(x => x.DescriptionEn).MaximumLength(1000);
+        RuleFor(x => x.IconKey).MaximumLength(100);
+    }
+}
@@ -0,0 +1,16 @@
+#nullable enable
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.UpdateServiceCategory;
+
+/// <summary>Admin: edit a category's labels/description/icon/order. <see cref="Id"/> comes from the route.</summary>
+public record UpdateServiceCategoryCommand(
+    long Id,
+    string NameFa,
+    string NameEn,
+    string? DescriptionFa,
+    string? DescriptionEn,
+    string? IconKey,
+    int SortOrder) : IRequest<OperationResult<ServiceCategoryDto>>;
@@ -0,0 +1,34 @@
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.UpdateServiceOptionGroup;
+
+internal sealed class UpdateServiceOptionGroupCommandHandler(IUnitOfWork unitOfWork, ICacheService cache)
+    : IRequestHandler<UpdateServiceOptionGroupCommand, OperationResult<OptionGroupDto>>
+{
+    public async ValueTask<OperationResult<OptionGroupDto>> Handle(UpdateServiceOptionGroupCommand request, CancellationToken cancellationToken)
+    {
+        var group = await unitOfWork.CatalogRepository.GetGroupAsync(request.Id, cancellationToken);
+        if (group is null)
+            return OperationResult<OptionGroupDto>.NotFoundResult("Option group not found.");
+
+        if (request.ServiceCategoryId is { } categoryId
+            && !await unitOfWork.CatalogRepository.CategoryExistsAsync(categoryId, cancellationToken))
+            return OperationResult<OptionGroupDto>.FailureResult(nameof(request.ServiceCategoryId), "Category not found.");
+
+        group.ServiceCategoryId = request.ServiceCategoryId;
+        group.NameFa = request.NameFa;
+        group.NameEn = request.NameEn;
+        group.IsRequired = request.IsRequired;
+        group.SortOrder = request.SortOrder;
+
+        await unitOfWork.CommitAsync();
+        await CatalogCache.InvalidateAsync(cache, cancellationToken);
+
+        var dto = await unitOfWork.CatalogRepository.GetGroupDtoAsync(group.Id, cancellationToken);
+        return OperationResult<OptionGroupDto>.SuccessResult(dto!);
+    }
+}
@@ -0,0 +1,14 @@
+using FluentValidation;
+
+namespace Baya.Application.Features.Catalog.Commands.UpdateServiceOptionGroup;
+
+public sealed class UpdateServiceOptionGroupCommandValidator : AbstractValidator<UpdateServiceOptionGroupCommand>
+{
+    // Id is supplied by the route (set after model binding), so it is not validated here.
+    public UpdateServiceOptionGroupCommandValidator()
+    {
+        RuleFor(x => x.NameFa).NotEmpty().MaximumLength(150);
+        RuleFor(x => x.NameEn).NotEmpty().MaximumLength(150);
+        RuleFor(x => x.ServiceCategoryId).GreaterThan(0).When(x => x.ServiceCategoryId.HasValue);
+    }
+}
@@ -0,0 +1,16 @@
+#nullable enable
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.UpdateServiceOptionGroup;
+
+/// <summary>Admin: edit a dimension's category scope (null = cross-category), labels, required flag, order.
+/// <see cref="Id"/> comes from the route.</summary>
+public record UpdateServiceOptionGroupCommand(
+    long Id,
+    long? ServiceCategoryId,
+    string NameFa,
+    string NameEn,
+    bool IsRequired,
+    int SortOrder) : IRequest<OperationResult<OptionGroupDto>>;
@@ -0,0 +1,29 @@
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.UpdateServiceOptionValue;
+
+internal sealed class UpdateServiceOptionValueCommandHandler(IUnitOfWork unitOfWork, ICacheService cache)
+    : IRequestHandler<UpdateServiceOptionValueCommand, OperationResult<OptionValueDto>>
+{
+    public async ValueTask<OperationResult<OptionValueDto>> Handle(UpdateServiceOptionValueCommand request, CancellationToken cancellationToken)
+    {
+        var value = await unitOfWork.CatalogRepository.GetValueAsync(request.Id, cancellationToken);
+        if (value is null)
+            return OperationResult<OptionValueDto>.NotFoundResult("Option value not found.");
+
+        value.NameFa = request.NameFa;
+        value.NameEn = request.NameEn;
+        value.SortOrder = request.SortOrder;
+        value.IsActive = request.IsActive;
+
+        await unitOfWork.CommitAsync();
+        await CatalogCache.InvalidateAsync(cache, cancellationToken);
+
+        return OperationResult<OptionValueDto>.SuccessResult(new OptionValueDto(
+            value.Id, value.NameFa, value.NameEn, value.SortOrder, value.IsActive));
+    }
+}
@@ -0,0 +1,13 @@
+using FluentValidation;
+
+namespace Baya.Application.Features.Catalog.Commands.UpdateServiceOptionValue;
+
+public sealed class UpdateServiceOptionValueCommandValidator : AbstractValidator<UpdateServiceOptionValueCommand>
+{
+    // Id is supplied by the route (set after model binding), so it is not validated here.
+    public UpdateServiceOptionValueCommandValidator()
+    {
+        RuleFor(x => x.NameFa).NotEmpty().MaximumLength(150);
+        RuleFor(x => x.NameEn).NotEmpty().MaximumLength(150);
+    }
+}
@@ -0,0 +1,17 @@
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Commands.UpdateServiceOptionValue;
+
+/// <summary>
+/// Admin: edit a value's labels/order and activate/deactivate it. Re-parenting to a different group is
+/// deliberately not allowed — it would silently change the meaning of variants that already answered with
+/// this value. <see cref="Id"/> comes from the route.
+/// </summary>
+public record UpdateServiceOptionValueCommand(
+    long Id,
+    string NameFa,
+    string NameEn,
+    int SortOrder,
+    bool IsActive) : IRequest<OperationResult<OptionValueDto>>;
@@ -0,0 +1,32 @@
+using Baya.Application.Common;
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Queries.GetCatalogCategories;
+
+internal sealed class GetCatalogCategoriesQueryHandler(IUnitOfWork unitOfWork, ICacheService cache)
+    : IRequestHandler<GetCatalogCategoriesQuery, OperationResult<PagedResult<ServiceCategoryDto>>>
+{
+    public async ValueTask<OperationResult<PagedResult<ServiceCategoryDto>>> Handle(GetCatalogCategoriesQuery request, CancellationToken cancellationToken)
+    {
+        var (page, pageSize) = Pagination.Normalize(request.Page, request.PageSize);
+
+        var version = await CatalogCache.VersionAsync(cache, cancellationToken);
+
+        // The active-category set is small, near-static reference data — cache the whole ordered list once
+        // per generation token and page it in memory, so a mutation's cache bump refreshes every page.
+        var all = await cache.GetOrCreateAsync(
+            CatalogCache.CategoriesKey(version),
+            async ct => await unitOfWork.CatalogRepository.ListActiveCategoriesAsync(ct),
+            CatalogCache.Ttl,
+            cancellationToken);
+
+        var items = all.Skip((page - 1) * pageSize).Take(pageSize).ToList();
+
+        return OperationResult<PagedResult<ServiceCategoryDto>>.SuccessResult(
+            new PagedResult<ServiceCategoryDto>(items, all.Count, page, pageSize));
+    }
+}
@@ -0,0 +1,9 @@
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Queries.GetCatalogCategories;
+
+/// <summary>Public: active categories ordered by sort order, paginated. Cached reference data.</summary>
+public record GetCatalogCategoriesQuery(int Page = 1, int PageSize = 50)
+    : IRequest<OperationResult<PagedResult<ServiceCategoryDto>>>;
@@ -0,0 +1,24 @@
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Queries.GetCategoryOptionGroups;
+
+internal sealed class GetCategoryOptionGroupsQueryHandler(IUnitOfWork unitOfWork, ICacheService cache)
+    : IRequestHandler<GetCategoryOptionGroupsQuery, OperationResult<IReadOnlyList<OptionGroupDto>>>
+{
+    public async ValueTask<OperationResult<IReadOnlyList<OptionGroupDto>>> Handle(GetCategoryOptionGroupsQuery request, CancellationToken cancellationToken)
+    {
+        var version = await CatalogCache.VersionAsync(cache, cancellationToken);
+
+        var groups = await cache.GetOrCreateAsync(
+            CatalogCache.OptionGroupsKey(version, request.CategoryId),
+            async ct => await unitOfWork.CatalogRepository.GetApplicableGroupsAsync(request.CategoryId, ct),
+            CatalogCache.Ttl,
+            cancellationToken);
+
+        return OperationResult<IReadOnlyList<OptionGroupDto>>.SuccessResult(groups);
+    }
+}
@@ -0,0 +1,13 @@
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Catalog.Queries.GetCategoryOptionGroups;
+
+/// <summary>
+/// Public: a category's <b>applicable</b> option groups — its own groups plus every cross-category (NULL)
+/// group — each with its active values and <c>is_required</c>, ordered by sort order. The skeleton the
+/// nurse builder fills in and the customer browses. Cached reference data.
+/// </summary>
+public record GetCategoryOptionGroupsQuery(long CategoryId)
+    : IRequest<OperationResult<IReadOnlyList<OptionGroupDto>>>;
@@ -0,0 +1,132 @@
+#nullable enable
+using System.Globalization;
+using Baya.Application.Common;
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Baya.Domain.Entities.Catalog;
+using Baya.Domain.Entities.User;
+using Mediator;
+
+namespace Baya.Application.Features.Variants.Commands.CreateVariant;
+
+internal sealed class CreateVariantCommandHandler(ICurrentUser currentUser, IUnitOfWork unitOfWork)
+    : IRequestHandler<CreateVariantCommand, OperationResult<VariantDto>>
+{
+    public async ValueTask<OperationResult<VariantDto>> Handle(CreateVariantCommand request, CancellationToken cancellationToken)
+    {
+        if (currentUser.UserId is not { } userId)
+            return OperationResult<VariantDto>.UnauthorizedResult("Not authenticated.");
+
+        if (currentUser.Roles?.Contains(RoleNames.Nurse) != true)
+            return OperationResult<VariantDto>.ForbiddenResult("Only a nurse can create a variant.");
+
+        var nurseId = await unitOfWork.NurseProfileRepository.GetProfileIdByUserIdAsync(userId, cancellationToken);
+        if (nurseId is not { } nid)
+            return OperationResult<VariantDto>.FailureResult("No nurse profile exists yet. Create your profile first.");
+
+        // Catalog must be seeded and the category active — a variant can't rest on a missing/inactive category.
+        var category = await unitOfWork.CatalogRepository.GetActiveCategoryAsync(request.ServiceCategoryId, cancellationToken);
+        if (category is null)
+            return OperationResult<VariantDto>.FailureResult(nameof(request.ServiceCategoryId), "Category not found or inactive.");
+
+        // Applicable = the category's own active groups PLUS every cross-category (NULL) active group.
+        var applicableGroups = await unitOfWork.CatalogRepository.GetApplicableGroupsAsync(request.ServiceCategoryId, cancellationToken);
+        var groupById = applicableGroups.ToDictionary(g => g.Id);
+
+        // Every submitted (group, value) must apply to this category and the value must belong to its group.
+        foreach (var selection in request.Options)
+        {
+            if (!groupById.TryGetValue(selection.OptionGroupId, out var group))
+                return OperationResult<VariantDto>.FailureResult(
+                    nameof(request.Options), $"Option group {selection.OptionGroupId} does not apply to this category.");
+
+            if (group.Values.All(v => v.Id != selection.OptionValueId))
+                return OperationResult<VariantDto>.FailureResult(
+                    nameof(request.Options), $"Option value {selection.OptionValueId} is not a valid choice for '{group.NameFa}'.");
+        }
+
+        // One value per dimension: no group answered twice.
+        var answeredGroupIds = request.Options.Select(o => o.OptionGroupId).ToList();
+        if (answeredGroupIds.Count != answeredGroupIds.Distinct().Count())
+            return OperationResult<VariantDto>.FailureResult(nameof(request.Options), "A dimension was answered more than once.");
+
+        // Every required dimension (incl. cross-category ones) must be answered.
+        var answered = answeredGroupIds.ToHashSet();
+        var missingRequired = applicableGroups.Where(g => g.IsRequired && !answered.Contains(g.Id)).ToList();
+        if (missingRequired.Count > 0)
+            return OperationResult<VariantDto>.FailureResult(
+                nameof(request.Options),
+                $"Required dimension(s) not answered: {string.Join(", ", missingRequired.Select(g => g.NameFa))}.");
+
+        var resolvedOptions = ResolveOptions(request.Options, groupById);
+        var optionSetHash = OptionSetHash.Compute(request.Options.Select(o => (o.OptionGroupId, o.OptionValueId)));
+
+        // Duplicate-listing guard: friendly pre-check ahead of the filtered unique-index DB backstop.
+        if (await unitOfWork.NurseServiceVariantRepository.DuplicateHashExistsAsync(nid, category.Id, optionSetHash, null, cancellationToken))
+            return OperationResult<VariantDto>.ConflictResult("You already offer this exact configuration in this category.");
+
+        var price = long.Parse(request.Price, NumberStyles.None, CultureInfo.InvariantCulture);
+        var displayName = string.IsNullOrWhiteSpace(request.DisplayName)
+            ? BuildDisplayName(category.NameFa, resolvedOptions)
+            : request.DisplayName.Trim();
+
+        var variant = new NurseServiceVariant
+        {
+            NurseId = nid,
+            ServiceCategoryId = category.Id,
+            Price = price,
+            PriceUnit = request.PriceUnit,
+            SessionCount = request.SessionCount,
+            DisplayName = displayName,
+            OptionSetHash = optionSetHash,
+            IsActive = true,
+            Options = request.Options
+                .Select(o => new NurseServiceVariantOption
+                {
+                    OptionGroupId = o.OptionGroupId,
+                    OptionValueId = o.OptionValueId
+                })
+                .ToList()
+        };
+
+        // DEFERRED (b7): this is the write that later fans a variant out into nurse_search_index. Keep it the
+        // single trigger point — do not build the index here.
+        await unitOfWork.NurseServiceVariantRepository.AddAsync(variant, cancellationToken);
+        await unitOfWork.CommitAsync();
+
+        return OperationResult<VariantDto>.SuccessResult(new VariantDto(
+            variant.Id,
+            category.Id,
+            category.NameFa,
+            category.NameEn,
+            variant.Price.ToString(CultureInfo.InvariantCulture),
+            variant.PriceUnit,
+            variant.SessionCount,
+            variant.DisplayName,
+            variant.IsActive,
+            resolvedOptions));
+    }
+
+    private static IReadOnlyList<VariantOptionDto> ResolveOptions(
+        IReadOnlyList<VariantOptionSelection> selections,
+        IReadOnlyDictionary<long, OptionGroupDto> groupById)
+        => selections
+            .Select(s =>
+            {
+                var group = groupById[s.OptionGroupId];
+                var value = group.Values.First(v => v.Id == s.OptionValueId);
+                return (group, value);
+            })
+            .OrderBy(x => x.group.SortOrder)
+            .ThenBy(x => x.group.Id)
+            .Select(x => new VariantOptionDto(
+                x.group.Id, x.group.NameFa, x.group.NameEn, x.value.Id, x.value.NameFa, x.value.NameEn))
+            .ToList();
+
+    private static string BuildDisplayName(string categoryNameFa, IReadOnlyList<VariantOptionDto> options)
+        => options.Count == 0
+            ? categoryNameFa
+            : $"{categoryNameFa} · {string.Join(" · ", options.Select(o => o.ValueNameFa))}";
+}
@@ -0,0 +1,39 @@
+using System.Globalization;
+using Baya.Domain.Entities.Catalog;
+using FluentValidation;
+
+namespace Baya.Application.Features.Variants.Commands.CreateVariant;
+
+public sealed class CreateVariantCommandValidator : AbstractValidator<CreateVariantCommand>
+{
+    public CreateVariantCommandValidator()
+    {
+        RuleFor(x => x.ServiceCategoryId).GreaterThan(0);
+
+        // Money is a string of IRR-Rial digits — positive integer, no sign/decimal/whitespace, no overflow.
+        RuleFor(x => x.Price)
+            .NotEmpty()
+            .Must(BePositiveIrrAmount)
+            .WithMessage("Price must be a positive integer number of IRR Rials (digits only).");
+
+        RuleFor(x => x.PriceUnit)
+            .Must(PriceUnits.IsValid)
+            .WithMessage("price_unit must be one of: per_hour, per_session, per_half_day, per_day, per_24h.");
+
+        RuleFor(x => x.SessionCount).GreaterThan(0).When(x => x.SessionCount.HasValue);
+
+        RuleFor(x => x.DisplayName).MaximumLength(300);
+
+        // The required-group / one-value-per-dimension / value-belongs-to-group rules need the catalog, so
+        // they live in the handler (clean OperationResult). Here we only enforce the shape.
+        RuleFor(x => x.Options).NotNull();
+        RuleForEach(x => x.Options).ChildRules(o =>
+        {
+            o.RuleFor(s => s.OptionGroupId).GreaterThan(0);
+            o.RuleFor(s => s.OptionValueId).GreaterThan(0);
+        });
+    }
+
+    private static bool BePositiveIrrAmount(string value)
+        => long.TryParse(value, NumberStyles.None, CultureInfo.InvariantCulture, out var amount) && amount > 0;
+}
@@ -0,0 +1,20 @@
+#nullable enable
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Variants.Commands.CreateVariant;
+
+/// <summary>
+/// The signed-in nurse builds a priced offering: a category, one chosen value per answered dimension, a
+/// price (IRR-Rial digit string) + price unit + optional session count, and an optional display-name
+/// override (auto-generated from the option labels when omitted). The nurse is derived from the caller,
+/// never the body. A duplicate identical listing returns 409; a missing required dimension returns 400.
+/// </summary>
+public record CreateVariantCommand(
+    long ServiceCategoryId,
+    IReadOnlyList<VariantOptionSelection> Options,
+    string Price,
+    string PriceUnit,
+    int? SessionCount,
+    string? DisplayName) : IRequest<OperationResult<VariantDto>>;
@@ -0,0 +1,36 @@
+#nullable enable
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Common;
+using Baya.Domain.Entities.User;
+using Mediator;
+
+namespace Baya.Application.Features.Variants.Commands.SetVariantActive;
+
+internal sealed class SetVariantActiveCommandHandler(ICurrentUser currentUser, IUnitOfWork unitOfWork)
+    : IRequestHandler<SetVariantActiveCommand, OperationResult<bool>>
+{
+    public async ValueTask<OperationResult<bool>> Handle(SetVariantActiveCommand request, CancellationToken cancellationToken)
+    {
+        if (currentUser.UserId is not { } userId)
+            return OperationResult<bool>.UnauthorizedResult("Not authenticated.");
+
+        if (currentUser.Roles?.Contains(RoleNames.Nurse) != true)
+            return OperationResult<bool>.ForbiddenResult("Only a nurse can manage variants.");
+
+        var nurseId = await unitOfWork.NurseProfileRepository.GetProfileIdByUserIdAsync(userId, cancellationToken);
+        if (nurseId is not { } nid)
+            return OperationResult<bool>.NotFoundResult("Variant not found.");
+
+        var variant = await unitOfWork.NurseServiceVariantRepository.GetOwnedAsync(request.Id, nid, cancellationToken);
+        if (variant is null)
+            return OperationResult<bool>.NotFoundResult("Variant not found.");
+
+        variant.IsActive = request.IsActive;
+
+        // DEFERRED (b7): toggling active is the trigger point for the search-index add/remove.
+        await unitOfWork.CommitAsync();
+
+        return OperationResult<bool>.SuccessResult(true);
+    }
+}
@@ -0,0 +1,11 @@
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Variants.Commands.SetVariantActive;
+
+/// <summary>
+/// The owning nurse activates/deactivates a variant. <b>Deactivate, never hard-delete.</b> A deactivated
+/// variant cannot be booked and (via b7) drops out of the search index; its past bookings/snapshots are
+/// untouched. <see cref="Id"/> comes from the route.
+/// </summary>
+public record SetVariantActiveCommand(long Id, bool IsActive) : IRequest<OperationResult<bool>>;
@@ -0,0 +1,46 @@
+#nullable enable
+using System.Globalization;
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Baya.Domain.Entities.User;
+using Mediator;
+
+namespace Baya.Application.Features.Variants.Commands.UpdateVariant;
+
+internal sealed class UpdateVariantCommandHandler(ICurrentUser currentUser, IUnitOfWork unitOfWork)
+    : IRequestHandler<UpdateVariantCommand, OperationResult<VariantDto>>
+{
+    public async ValueTask<OperationResult<VariantDto>> Handle(UpdateVariantCommand request, CancellationToken cancellationToken)
+    {
+        if (currentUser.UserId is not { } userId)
+            return OperationResult<VariantDto>.UnauthorizedResult("Not authenticated.");
+
+        if (currentUser.Roles?.Contains(RoleNames.Nurse) != true)
+            return OperationResult<VariantDto>.ForbiddenResult("Only a nurse can edit a variant.");
+
+        var nurseId = await unitOfWork.NurseProfileRepository.GetProfileIdByUserIdAsync(userId, cancellationToken);
+        if (nurseId is not { } nid)
+            return OperationResult<VariantDto>.NotFoundResult("Variant not found.");
+
+        // Tenancy: a non-owned/absent id resolves to null → not-found (existence is not leaked).
+        var variant = await unitOfWork.NurseServiceVariantRepository.GetOwnedAsync(request.Id, nid, cancellationToken);
+        if (variant is null)
+            return OperationResult<VariantDto>.NotFoundResult("Variant not found.");
+
+        variant.Price = long.Parse(request.Price, NumberStyles.None, CultureInfo.InvariantCulture);
+        variant.PriceUnit = request.PriceUnit;
+        variant.SessionCount = request.SessionCount;
+        if (!string.IsNullOrWhiteSpace(request.DisplayName))
+            variant.DisplayName = request.DisplayName.Trim();
+
+        await unitOfWork.CommitAsync();
+
+        // Re-project with resolved labels for the response (the option-set is unchanged).
+        var dto = await unitOfWork.NurseServiceVariantRepository.GetOwnedProjectedAsync(request.Id, nid, cancellationToken);
+        return dto is null
+            ? OperationResult<VariantDto>.NotFoundResult("Variant not found.")
+            : OperationResult<VariantDto>.SuccessResult(dto);
+    }
+}
@@ -0,0 +1,28 @@
+using System.Globalization;
+using Baya.Domain.Entities.Catalog;
+using FluentValidation;
+
+namespace Baya.Application.Features.Variants.Commands.UpdateVariant;
+
+public sealed class UpdateVariantCommandValidator : AbstractValidator<UpdateVariantCommand>
+{
+    // Id is supplied by the route (set after model binding), so it is not validated here.
+    public UpdateVariantCommandValidator()
+    {
+        RuleFor(x => x.Price)
+            .NotEmpty()
+            .Must(BePositiveIrrAmount)
+            .WithMessage("Price must be a positive integer number of IRR Rials (digits only).");
+
+        RuleFor(x => x.PriceUnit)
+            .Must(PriceUnits.IsValid)
+            .WithMessage("price_unit must be one of: per_hour, per_session, per_half_day, per_day, per_24h.");
+
+        RuleFor(x => x.SessionCount).GreaterThan(0).When(x => x.SessionCount.HasValue);
+
+        RuleFor(x => x.DisplayName).MaximumLength(300);
+    }
+
+    private static bool BePositiveIrrAmount(string value)
+        => long.TryParse(value, NumberStyles.None, CultureInfo.InvariantCulture, out var amount) && amount > 0;
+}
@@ -0,0 +1,19 @@
+#nullable enable
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Variants.Commands.UpdateVariant;
+
+/// <summary>
+/// The owning nurse edits a variant's price, price unit, session count, and display name. The <b>option-set
+/// is immutable</b> here — changing dimensions is modelled as create-new + deactivate-old so historical
+/// meaning stays stable, which also means an edit can never collide with the duplicate-listing guard.
+/// A blank <see cref="DisplayName"/> leaves the current one unchanged. <see cref="Id"/> comes from the route.
+/// </summary>
+public record UpdateVariantCommand(
+    long Id,
+    string Price,
+    string PriceUnit,
+    int? SessionCount,
+    string? DisplayName) : IRequest<OperationResult<VariantDto>>;
@@ -0,0 +1,43 @@
+#nullable enable
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Baya.Domain.Entities.User;
+using Mediator;
+
+namespace Baya.Application.Features.Variants.Queries.GetVariant;
+
+internal sealed class GetVariantQueryHandler(ICurrentUser currentUser, IUnitOfWork unitOfWork)
+    : IRequestHandler<GetVariantQuery, OperationResult<VariantDto>>
+{
+    public async ValueTask<OperationResult<VariantDto>> Handle(GetVariantQuery request, CancellationToken cancellationToken)
+    {
+        var roles = currentUser.Roles;
+
+        // Admin: the full view of any variant, any state.
+        if (roles?.Contains(RoleNames.Admin) == true)
+            return Resolve(await unitOfWork.NurseServiceVariantRepository.GetProjectedAsync(request.Id, cancellationToken));
+
+        // Owning nurse: the full view of their own variant, any state.
+        if (currentUser.UserId is { } userId && roles?.Contains(RoleNames.Nurse) == true)
+        {
+            var nurseId = await unitOfWork.NurseProfileRepository.GetProfileIdByUserIdAsync(userId, cancellationToken);
+            if (nurseId is { } nid)
+            {
+                var owned = await unitOfWork.NurseServiceVariantRepository.GetOwnedProjectedAsync(request.Id, nid, cancellationToken);
+                if (owned is not null)
+                    return OperationResult<VariantDto>.SuccessResult(owned);
+            }
+            // Not their variant → fall through to the public (active-only) projection.
+        }
+
+        // Everyone else (incl. anonymous): the public-safe projection — active variants only.
+        return Resolve(await unitOfWork.NurseServiceVariantRepository.GetPublicProjectedAsync(request.Id, cancellationToken));
+    }
+
+    private static OperationResult<VariantDto> Resolve(VariantDto? dto)
+        => dto is null
+            ? OperationResult<VariantDto>.NotFoundResult("Variant not found.")
+            : OperationResult<VariantDto>.SuccessResult(dto);
+}
@@ -0,0 +1,12 @@
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Variants.Queries.GetVariant;
+
+/// <summary>
+/// A single variant with its full resolved option-set. The owning nurse and an admin see it in any state;
+/// any other caller (the public nurse-profile view) sees only an <b>active</b> variant. Absent/inaccessible
+/// resolves to not-found.
+/// </summary>
+public record GetVariantQuery(long Id) : IRequest<OperationResult<VariantDto>>;
@@ -0,0 +1,33 @@
+#nullable enable
+using Baya.Application.Common;
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Baya.Domain.Entities.User;
+using Mediator;
+
+namespace Baya.Application.Features.Variants.Queries.ListMyVariants;
+
+internal sealed class ListMyVariantsQueryHandler(ICurrentUser currentUser, IUnitOfWork unitOfWork)
+    : IRequestHandler<ListMyVariantsQuery, OperationResult<PagedResult<VariantDto>>>
+{
+    public async ValueTask<OperationResult<PagedResult<VariantDto>>> Handle(ListMyVariantsQuery request, CancellationToken cancellationToken)
+    {
+        if (currentUser.UserId is not { } userId)
+            return OperationResult<PagedResult<VariantDto>>.UnauthorizedResult("Not authenticated.");
+
+        if (currentUser.Roles?.Contains(RoleNames.Nurse) != true)
+            return OperationResult<PagedResult<VariantDto>>.ForbiddenResult("Only a nurse can view their variants.");
+
+        var (page, pageSize) = Pagination.Normalize(request.Page, request.PageSize);
+
+        var nurseId = await unitOfWork.NurseProfileRepository.GetProfileIdByUserIdAsync(userId, cancellationToken);
+        if (nurseId is not { } nid)
+            return OperationResult<PagedResult<VariantDto>>.SuccessResult(
+                new PagedResult<VariantDto>([], 0, page, pageSize));
+
+        var result = await unitOfWork.NurseServiceVariantRepository.ListMineAsync(nid, page, pageSize, cancellationToken);
+        return OperationResult<PagedResult<VariantDto>>.SuccessResult(result);
+    }
+}
@@ -0,0 +1,9 @@
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Mediator;
+
+namespace Baya.Application.Features.Variants.Queries.ListMyVariants;
+
+/// <summary>The signed-in nurse's own offerings — active and inactive — paginated, active-first.</summary>
+public record ListMyVariantsQuery(int Page = 1, int PageSize = 50)
+    : IRequest<OperationResult<PagedResult<VariantDto>>>;
@@ -0,0 +1,17 @@
+#nullable enable
+namespace Baya.Application.Models.Catalog;
+
+/// <summary>
+/// A pricing dimension applicable to a category, with its active values. <c>ServiceCategoryId == null</c>
+/// marks a cross-category group (applies to every category). This is the skeleton the nurse builder fills
+/// in and the customer browses.
+/// </summary>
+public record OptionGroupDto(
+    long Id,
+    long? ServiceCategoryId,
+    string NameFa,
+    string NameEn,
+    bool IsRequired,
+    int SortOrder,
+    bool IsActive,
+    IReadOnlyList<OptionValueDto> Values);
@@ -0,0 +1,9 @@
+namespace Baya.Application.Models.Catalog;
+
+/// <summary>A concrete choice within an option group (e.g. شبانه‌روزی / live-in).</summary>
+public record OptionValueDto(
+    long Id,
+    string NameFa,
+    string NameEn,
+    int SortOrder,
+    bool IsActive);
@@ -0,0 +1,13 @@
+#nullable enable
+namespace Baya.Application.Models.Catalog;
+
+/// <summary>An admin catalog category. <c>NameFa</c> is primary; the client picks the label by locale.</summary>
+public record ServiceCategoryDto(
+    long Id,
+    string NameFa,
+    string NameEn,
+    string? DescriptionFa,
+    string? DescriptionEn,
+    string? IconKey,
+    int SortOrder,
+    bool IsActive);
@@ -0,0 +1,18 @@
+namespace Baya.Application.Models.Catalog;
+
+/// <summary>
+/// A nurse's priced offering with its resolved option-set. <c>Price</c> crosses the wire as a <b>string of
+/// IRR-Rial digits</b> (integer money, no floats). The engagement total is <c>Price</c> + <c>PriceUnit</c>
+/// + <c>SessionCount</c> — a downstream consumer derives it, never from price alone.
+/// </summary>
+public record VariantDto(
+    long Id,
+    long ServiceCategoryId,
+    string CategoryNameFa,
+    string CategoryNameEn,
+    string Price,
+    string PriceUnit,
+    int? SessionCount,
+    string DisplayName,
+    bool IsActive,
+    IReadOnlyList<VariantOptionDto> Options);
@@ -0,0 +1,10 @@
+namespace Baya.Application.Models.Catalog;
+
+/// <summary>One answered dimension of a variant, with both the group and value labels resolved.</summary>
+public record VariantOptionDto(
+    long OptionGroupId,
+    string GroupNameFa,
+    string GroupNameEn,
+    long OptionValueId,
+    string ValueNameFa,
+    string ValueNameEn);
@@ -0,0 +1,5 @@
+namespace Baya.Application.Models.Catalog;
+
+/// <summary>One dimension answered when building a variant: the chosen value for a group. The nurse sends
+/// one of these per group they answer; the handler validates them against the category's applicable groups.</summary>
+public record VariantOptionSelection(long OptionGroupId, long OptionValueId);
@@ -0,0 +1,17 @@
+namespace Baya.Application.Models.Catalog;
+
+/// <summary>
+/// The immutable input the variant-snapshot serializer freezes onto a booking (b8) — a variant + its
+/// resolved options exactly as they are at serialize time. <c>Price</c> is the raw IRR-Rial integer;
+/// the serializer emits it as a string of digits per the money convention.
+/// </summary>
+public record VariantSnapshot(
+    long VariantId,
+    long ServiceCategoryId,
+    string CategoryNameFa,
+    string CategoryNameEn,
+    long Price,
+    string PriceUnit,
+    int? SessionCount,
+    string DisplayName,
+    IReadOnlyList<VariantOptionDto> Options);
@@ -1,4 +1,5 @@
 using Baya.Application.Common;
+using Baya.Application.Contracts.Common;
 using FluentValidation;
 using Mediator;
 using Microsoft.Extensions.DependencyInjection;
@@ -21,6 +22,9 @@ public static class ServiceCollectionExtension

        services.AddScoped(typeof(IPipelineBehavior<,>), typeof(ValidateCommandBehavior<,>));

+        // Pure, stateless serializer that b8 consumes to freeze a variant onto a booking.
+        services.AddSingleton<IVariantSnapshotSerializer, VariantSnapshotSerializer>();
+
        RegisterCommandValidators(services);

        return services;
@@ -0,0 +1,50 @@
+using Baya.Domain.Common;
+using Baya.Domain.Entities.Identity;
+
+namespace Baya.Domain.Entities.Catalog;
+
+/// <summary>
+/// The <b>atomic bookable unit</b> of the marketplace: a nurse offering a category with a chosen option
+/// combination at their own price and price unit. Search (b7), booking (b8), and every money calculation
+/// operate on a <i>variant</i> — never on "a nurse". A nurse with no active variant is not bookable.
+/// <para>
+/// <see cref="Price"/> is <b>IRR Rials as an integer</b> — no float, ever. The engagement total is
+/// <see cref="Price"/> combined with <see cref="PriceUnit"/> and <see cref="SessionCount"/>; a downstream
+/// consumer (booking) derives it from all three, never from price alone.
+/// </para>
+/// <para>
+/// <see cref="OptionSetHash"/> is a deterministic hash of the sorted answered
+/// <c>(option_group_id, option_value_id)</c> pairs. It backs the filtered
+/// <c>UNIQUE(nurse_id, service_category_id, option_set_hash) WHERE deleted_at IS NULL</c> that makes the
+/// duplicate-listing guard race-safe (a multi-row option-set can't be a plain composite unique index).
+/// </para>
+/// </summary>
+public class NurseServiceVariant : BaseEntity<long>
+{
+    public long NurseId { get; set; }
+    public NurseProfile Nurse { get; set; }
+
+    public long ServiceCategoryId { get; set; }
+    public ServiceCategory ServiceCategory { get; set; }
+
+    /// <summary>IRR Rials, integer — never a float/decimal-with-fraction. There is no Toman in the DB.</summary>
+    public long Price { get; set; }
+
+    /// <summary>Closed code set — see <see cref="PriceUnits"/>. The only code enum in the catalog area.</summary>
+    public string PriceUnit { get; set; }
+
+    /// <summary>Number of sessions/units the engagement spans; relevant for <c>per_session</c> and packages.</summary>
+    public int? SessionCount { get; set; }
+
+    /// <summary>Auto-generated from the option labels at create time, but nurse-editable.</summary>
+    public string DisplayName { get; set; }
+
+    /// <summary>Deterministic hash of the sorted answered option-set — the duplicate-listing DB backstop key.</summary>
+    public string OptionSetHash { get; set; }
+
+    public bool IsActive { get; set; }
+
+    public DateTimeOffset? DeletedAt { get; set; }
+
+    public ICollection<NurseServiceVariantOption> Options { get; set; }
+}
@@ -0,0 +1,20 @@
+using Baya.Domain.Common;
+
+namespace Baya.Domain.Entities.Catalog;
+
+/// <summary>
+/// One answered dimension of a variant: the option value it chose for a given group. One row per
+/// dimension makes the variant's meaning explicit and queryable. <c>UNIQUE(variant_id, option_group_id)</c>
+/// enforces <b>one value per dimension per variant</b> — a variant can never answer the same group twice.
+/// </summary>
+public class NurseServiceVariantOption : BaseEntity<long>
+{
+    public long VariantId { get; set; }
+    public NurseServiceVariant Variant { get; set; }
+
+    public long OptionGroupId { get; set; }
+    public ServiceOptionGroup OptionGroup { get; set; }
+
+    public long OptionValueId { get; set; }
+    public ServiceOptionValue OptionValue { get; set; }
+}
@@ -0,0 +1,21 @@
+namespace Baya.Domain.Entities.Catalog;
+
+/// <summary>
+/// The five price units a nurse can price a variant in — the <b>only</b> closed code enum in the catalog
+/// area (categories, groups, and values are data, never code constants). <c>per_24h</c> (شبانه‌روزی /
+/// live-in) and <c>per_day</c> are first-class, not edge cases — Iranian home-nursing sells exactly these
+/// shapes. Crosses the wire as the stable string code.
+/// </summary>
+public static class PriceUnits
+{
+    public const string PerHour = "per_hour";
+    public const string PerSession = "per_session";
+    public const string PerHalfDay = "per_half_day";
+    public const string PerDay = "per_day";
+    public const string Per24H = "per_24h";
+
+    public static readonly IReadOnlySet<string> All =
+        new HashSet<string> { PerHour, PerSession, PerHalfDay, PerDay, Per24H };
+
+    public static bool IsValid(string value) => value is not null && All.Contains(value);
+}
@@ -0,0 +1,30 @@
+using Baya.Domain.Common;
+
+namespace Baya.Domain.Entities.Catalog;
+
+/// <summary>
+/// An admin-managed top-level care type (Elderly, Post-Surgery, Infant, Chronic, Companionship) — the
+/// primary search dimension and the first thing a nurse picks when building a variant. Categories are
+/// <b>data, not code</b>: an admin adds one as a row, never a migration. Deactivate (never delete) so the
+/// bookings/variants already resting on a category survive — their history lives in the booking snapshot.
+/// Every row carries the <c>NameFa</c> (primary) + <c>NameEn</c> pair; the client picks by locale.
+/// </summary>
+public class ServiceCategory : BaseEntity<long>
+{
+    public string NameFa { get; set; }
+    public string NameEn { get; set; }
+
+    public string DescriptionFa { get; set; }
+    public string DescriptionEn { get; set; }
+
+    /// <summary>UI glyph key the client maps to an icon; not a business value.</summary>
+    public string IconKey { get; set; }
+
+    public int SortOrder { get; set; }
+    public bool IsActive { get; set; }
+
+    public DateTimeOffset? DeletedAt { get; set; }
+
+    public ICollection<ServiceOptionGroup> OptionGroups { get; set; }
+    public ICollection<NurseServiceVariant> Variants { get; set; }
+}
@@ -0,0 +1,33 @@
+using Baya.Domain.Common;
+
+namespace Baya.Domain.Entities.Catalog;
+
+/// <summary>
+/// An admin-managed configurable <b>pricing dimension</b> (e.g. نوع شیفت / shift type, تعداد بیمار /
+/// patient count). This is the EAV skeleton that lets a new dimension ship as rows, not a schema change.
+/// <para>
+/// <see cref="ServiceCategoryId"/> == <c>null</c> is a <b>meaningful "cross-category"</b> group: the
+/// dimension applies to <i>every</i> category (e.g. shift type applies everywhere), not missing data.
+/// The applicable set for a category is therefore its own groups <b>plus</b> every NULL-category group —
+/// the required-group check and the duplicate guard must both honour that.
+/// </para>
+/// </summary>
+public class ServiceOptionGroup : BaseEntity<long>
+{
+    /// <summary>NULL = cross-category (applies to every category). A real coverage choice, not unset.</summary>
+    public long? ServiceCategoryId { get; set; }
+    public ServiceCategory ServiceCategory { get; set; }
+
+    public string NameFa { get; set; }
+    public string NameEn { get; set; }
+
+    /// <summary>Whether a variant in an applicable category must answer this dimension exactly once.</summary>
+    public bool IsRequired { get; set; }
+
+    public int SortOrder { get; set; }
+    public bool IsActive { get; set; }
+
+    public DateTimeOffset? DeletedAt { get; set; }
+
+    public ICollection<ServiceOptionValue> Values { get; set; }
+}
@@ -0,0 +1,22 @@
+using Baya.Domain.Common;
+
+namespace Baya.Domain.Entities.Catalog;
+
+/// <summary>
+/// A concrete choice inside a <see cref="ServiceOptionGroup"/> (e.g. شبانه‌روزی / live-in, ۲ نفر / two
+/// patients). A variant answers a dimension by referencing exactly one value from that dimension's group.
+/// Carries the <c>NameFa</c> (primary) + <c>NameEn</c> pair like every catalog row.
+/// </summary>
+public class ServiceOptionValue : BaseEntity<long>
+{
+    public long OptionGroupId { get; set; }
+    public ServiceOptionGroup OptionGroup { get; set; }
+
+    public string NameFa { get; set; }
+    public string NameEn { get; set; }
+
+    public int SortOrder { get; set; }
+    public bool IsActive { get; set; }
+
+    public DateTimeOffset? DeletedAt { get; set; }
+}
@@ -0,0 +1,36 @@
+namespace Baya.Infrastructure.Persistence.Configuration.CatalogConfig;
+
+/// <summary>
+/// The five MVP service categories, seeded via <c>HasData</c> so they land with the migration on a fresh
+/// DB (the b1 seeding path) — a nurse can build a variant immediately. Ids are fixed and deterministic
+/// (1…5, sort_order = id) so re-running is idempotent and the model snapshot stays stable. Option
+/// groups/values are <b>not</b> seeded: those are admin-authored data per category (EAV is load-bearing).
+/// </summary>
+internal static class CatalogSeed
+{
+    // (id, name_fa, name_en). Companionship ships only as a seeded category (data), not a pricing path.
+    private static readonly (long Id, string NameFa, string NameEn)[] CategoryRows =
+    [
+        (1, "مراقبت از سالمند", "Elderly Care"),
+        (2, "مراقبت پس از جراحی", "Post-Surgery Recovery"),
+        (3, "مراقبت از نوزاد", "Infant Care"),
+        (4, "مدیریت بیماری مزمن", "Chronic Illness Management"),
+        (5, "همراهی و مراقبت روزمره", "Companionship"),
+    ];
+
+    public static object[] Categories()
+    {
+        var ts = SeedConstants.Timestamp;
+        return CategoryRows
+            .Select(c => (object)new
+            {
+                c.Id,
+                c.NameFa,
+                c.NameEn,
+                SortOrder = (int)c.Id,
+                IsActive = true,
+                CreatedAt = ts
+            })
+            .ToArray();
+    }
+}
@@ -0,0 +1,45 @@
+using Baya.Domain.Entities.Catalog;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Baya.Infrastructure.Persistence.Configuration.CatalogConfig;
+
+internal sealed class NurseServiceVariantConfig : IEntityTypeConfiguration<NurseServiceVariant>
+{
+    public void Configure(EntityTypeBuilder<NurseServiceVariant> builder)
+    {
+        builder.ToTable("NurseServiceVariants", "catalog");
+
+        // Price is IRR Rials as BIGINT (long → bigint). There is no float/decimal money path, ever.
+        builder.Property(v => v.PriceUnit).HasMaxLength(20).IsRequired();
+        builder.Property(v => v.DisplayName).HasMaxLength(300).IsRequired();
+        builder.Property(v => v.OptionSetHash).HasMaxLength(64).IsRequired();
+        builder.Property(v => v.IsActive).HasDefaultValue(true);
+
+        // The nurse's offerings list + the b7 index projection read on (nurse_id, is_active).
+        builder.HasIndex(v => new { v.NurseId, v.IsActive });
+        // Leading column is nurse_id on the unique index, so a standalone category index is still useful
+        // for "all variants in a category" (b7 category browse).
+        builder.HasIndex(v => v.ServiceCategoryId);
+
+        // Duplicate-listing DB backstop: a multi-row option-set can't be a plain composite unique, so it is
+        // reduced to a deterministic option_set_hash and made race-safe here. Filtered to exclude
+        // soft-deleted rows so a deactivated+deleted listing can be re-created.
+        builder.HasIndex(v => new { v.NurseId, v.ServiceCategoryId, v.OptionSetHash })
+            .IsUnique()
+            .HasFilter("[DeletedAt] IS NULL")
+            .HasDatabaseName("UX_NurseServiceVariants_Nurse_Category_OptionSet");
+
+        builder.HasOne(v => v.Nurse)
+            .WithMany()
+            .HasForeignKey(v => v.NurseId)
+            .IsRequired();
+
+        builder.HasOne(v => v.ServiceCategory)
+            .WithMany(c => c.Variants)
+            .HasForeignKey(v => v.ServiceCategoryId)
+            .IsRequired();
+
+        builder.HasQueryFilter(v => v.DeletedAt == null);
+    }
+}
@@ -0,0 +1,35 @@
+using Baya.Domain.Entities.Catalog;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Baya.Infrastructure.Persistence.Configuration.CatalogConfig;
+
+internal sealed class NurseServiceVariantOptionConfig : IEntityTypeConfiguration<NurseServiceVariantOption>
+{
+    public void Configure(EntityTypeBuilder<NurseServiceVariantOption> builder)
+    {
+        builder.ToTable("NurseServiceVariantOptions", "catalog");
+
+        // One value per dimension per variant. The unique index is the authoritative backstop; the handler
+        // validates the same rule for a clean message. Its leading column is variant_id, so it also serves
+        // "load a variant's full option set" — no separate variant_id index needed.
+        builder.HasIndex(o => new { o.VariantId, o.OptionGroupId })
+            .IsUnique()
+            .HasDatabaseName("UX_NurseServiceVariantOptions_Variant_Group");
+
+        builder.HasOne(o => o.Variant)
+            .WithMany(v => v.Options)
+            .HasForeignKey(o => o.VariantId)
+            .IsRequired();
+
+        builder.HasOne(o => o.OptionGroup)
+            .WithMany()
+            .HasForeignKey(o => o.OptionGroupId)
+            .IsRequired();
+
+        builder.HasOne(o => o.OptionValue)
+            .WithMany()
+            .HasForeignKey(o => o.OptionValueId)
+            .IsRequired();
+    }
+}
@@ -0,0 +1,28 @@
+using Baya.Domain.Entities.Catalog;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Baya.Infrastructure.Persistence.Configuration.CatalogConfig;
+
+internal sealed class ServiceCategoryConfig : IEntityTypeConfiguration<ServiceCategory>
+{
+    public void Configure(EntityTypeBuilder<ServiceCategory> builder)
+    {
+        builder.ToTable("ServiceCategories", "catalog");
+
+        builder.Property(c => c.NameFa).HasMaxLength(150).IsRequired();
+        builder.Property(c => c.NameEn).HasMaxLength(150).IsRequired();
+        builder.Property(c => c.DescriptionFa).HasMaxLength(1000);
+        builder.Property(c => c.DescriptionEn).HasMaxLength(1000);
+        builder.Property(c => c.IconKey).HasMaxLength(100);
+        builder.Property(c => c.SortOrder).HasDefaultValue(0);
+        builder.Property(c => c.IsActive).HasDefaultValue(true);
+
+        // Public ordered browse: active categories in sort order.
+        builder.HasIndex(c => new { c.IsActive, c.SortOrder });
+
+        builder.HasQueryFilter(c => c.DeletedAt == null);
+
+        builder.HasData(CatalogSeed.Categories());
+    }
+}
@@ -0,0 +1,30 @@
+using Baya.Domain.Entities.Catalog;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Baya.Infrastructure.Persistence.Configuration.CatalogConfig;
+
+internal sealed class ServiceOptionGroupConfig : IEntityTypeConfiguration<ServiceOptionGroup>
+{
+    public void Configure(EntityTypeBuilder<ServiceOptionGroup> builder)
+    {
+        builder.ToTable("ServiceOptionGroups", "catalog");
+
+        builder.Property(g => g.NameFa).HasMaxLength(150).IsRequired();
+        builder.Property(g => g.NameEn).HasMaxLength(150).IsRequired();
+        builder.Property(g => g.IsRequired).HasDefaultValue(false);
+        builder.Property(g => g.SortOrder).HasDefaultValue(0);
+        builder.Property(g => g.IsActive).HasDefaultValue(true);
+
+        // (service_category_id, sort_order) for the applicable-groups read. The nullable FK is deliberate —
+        // a NULL category is the cross-category case and must not be broken by a required relationship.
+        builder.HasIndex(g => new { g.ServiceCategoryId, g.SortOrder });
+
+        builder.HasOne(g => g.ServiceCategory)
+            .WithMany(c => c.OptionGroups)
+            .HasForeignKey(g => g.ServiceCategoryId)
+            .IsRequired(false);
+
+        builder.HasQueryFilter(g => g.DeletedAt == null);
+    }
+}
@@ -0,0 +1,27 @@
+using Baya.Domain.Entities.Catalog;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Baya.Infrastructure.Persistence.Configuration.CatalogConfig;
+
+internal sealed class ServiceOptionValueConfig : IEntityTypeConfiguration<ServiceOptionValue>
+{
+    public void Configure(EntityTypeBuilder<ServiceOptionValue> builder)
+    {
+        builder.ToTable("ServiceOptionValues", "catalog");
+
+        builder.Property(v => v.NameFa).HasMaxLength(150).IsRequired();
+        builder.Property(v => v.NameEn).HasMaxLength(150).IsRequired();
+        builder.Property(v => v.SortOrder).HasDefaultValue(0);
+        builder.Property(v => v.IsActive).HasDefaultValue(true);
+
+        builder.HasIndex(v => new { v.OptionGroupId, v.SortOrder });
+
+        builder.HasOne(v => v.OptionGroup)
+            .WithMany(g => g.Values)
+            .HasForeignKey(v => v.OptionGroupId)
+            .IsRequired();
+
+        builder.HasQueryFilter(v => v.DeletedAt == null);
+    }
+}
@@ -0,0 +1,280 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
+
+namespace Baya.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class ServiceCatalogAndNurseVariants : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.EnsureSchema(
+                name: "catalog");
+
+            migrationBuilder.CreateTable(
+                name: "ServiceCategories",
+                schema: "catalog",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    NameFa = table.Column<string>(type: "nvarchar(150)", maxLength: 150, nullable: false),
+                    NameEn = table.Column<string>(type: "nvarchar(150)", maxLength: 150, nullable: false),
+                    DescriptionFa = table.Column<string>(type: "nvarchar(1000)", maxLength: 1000, nullable: true),
+                    DescriptionEn = table.Column<string>(type: "nvarchar(1000)", maxLength: 1000, nullable: true),
+                    IconKey = table.Column<string>(type: "nvarchar(100)", maxLength: 100, nullable: true),
+                    SortOrder = table.Column<int>(type: "int", nullable: false, defaultValue: 0),
+                    IsActive = table.Column<bool>(type: "bit", nullable: false, defaultValue: true),
+                    DeletedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: true),
+                    CreatedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
+                    ModifiedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: true),
+                    CreatedById = table.Column<int>(type: "int", nullable: true),
+                    ModifiedById = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ServiceCategories", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "NurseServiceVariants",
+                schema: "catalog",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    NurseId = table.Column<long>(type: "bigint", nullable: false),
+                    ServiceCategoryId = table.Column<long>(type: "bigint", nullable: false),
+                    Price = table.Column<long>(type: "bigint", nullable: false),
+                    PriceUnit = table.Column<string>(type: "nvarchar(20)", maxLength: 20, nullable: false),
+                    SessionCount = table.Column<int>(type: "int", nullable: true),
+                    DisplayName = table.Column<string>(type: "nvarchar(300)", maxLength: 300, nullable: false),
+                    OptionSetHash = table.Column<string>(type: "nvarchar(64)", maxLength: 64, nullable: false),
+                    IsActive = table.Column<bool>(type: "bit", nullable: false, defaultValue: true),
+                    DeletedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: true),
+                    CreatedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
+                    ModifiedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: true),
+                    CreatedById = table.Column<int>(type: "int", nullable: true),
+                    ModifiedById = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_NurseServiceVariants", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_NurseServiceVariants_NurseProfiles_NurseId",
+                        column: x => x.NurseId,
+                        principalSchema: "usr",
+                        principalTable: "NurseProfiles",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_NurseServiceVariants_ServiceCategories_ServiceCategoryId",
+                        column: x => x.ServiceCategoryId,
+                        principalSchema: "catalog",
+                        principalTable: "ServiceCategories",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "ServiceOptionGroups",
+                schema: "catalog",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    ServiceCategoryId = table.Column<long>(type: "bigint", nullable: true),
+                    NameFa = table.Column<string>(type: "nvarchar(150)", maxLength: 150, nullable: false),
+                    NameEn = table.Column<string>(type: "nvarchar(150)", maxLength: 150, nullable: false),
+                    IsRequired = table.Column<bool>(type: "bit", nullable: false, defaultValue: false),
+                    SortOrder = table.Column<int>(type: "int", nullable: false, defaultValue: 0),
+                    IsActive = table.Column<bool>(type: "bit", nullable: false, defaultValue: true),
+                    DeletedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: true),
+                    CreatedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
+                    ModifiedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: true),
+                    CreatedById = table.Column<int>(type: "int", nullable: true),
+                    ModifiedById = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ServiceOptionGroups", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ServiceOptionGroups_ServiceCategories_ServiceCategoryId",
+                        column: x => x.ServiceCategoryId,
+                        principalSchema: "catalog",
+                        principalTable: "ServiceCategories",
+                        principalColumn: "Id");
+                });
+
+            migrationBuilder.CreateTable(
+                name: "ServiceOptionValues",
+                schema: "catalog",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    OptionGroupId = table.Column<long>(type: "bigint", nullable: false),
+                    NameFa = table.Column<string>(type: "nvarchar(150)", maxLength: 150, nullable: false),
+                    NameEn = table.Column<string>(type: "nvarchar(150)", maxLength: 150, nullable: false),
+                    SortOrder = table.Column<int>(type: "int", nullable: false, defaultValue: 0),
+                    IsActive = table.Column<bool>(type: "bit", nullable: false, defaultValue: true),
+                    DeletedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: true),
+                    CreatedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
+                    ModifiedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: true),
+                    CreatedById = table.Column<int>(type: "int", nullable: true),
+                    ModifiedById = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ServiceOptionValues", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ServiceOptionValues_ServiceOptionGroups_OptionGroupId",
+                        column: x => x.OptionGroupId,
+                        principalSchema: "catalog",
+                        principalTable: "ServiceOptionGroups",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "NurseServiceVariantOptions",
+                schema: "catalog",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    VariantId = table.Column<long>(type: "bigint", nullable: false),
+                    OptionGroupId = table.Column<long>(type: "bigint", nullable: false),
+                    OptionValueId = table.Column<long>(type: "bigint", nullable: false),
+                    CreatedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
+                    ModifiedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: true),
+                    CreatedById = table.Column<int>(type: "int", nullable: true),
+                    ModifiedById = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_NurseServiceVariantOptions", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_NurseServiceVariantOptions_NurseServiceVariants_VariantId",
+                        column: x => x.VariantId,
+                        principalSchema: "catalog",
+                        principalTable: "NurseServiceVariants",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_NurseServiceVariantOptions_ServiceOptionGroups_OptionGroupId",
+                        column: x => x.OptionGroupId,
+                        principalSchema: "catalog",
+                        principalTable: "ServiceOptionGroups",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_NurseServiceVariantOptions_ServiceOptionValues_OptionValueId",
+                        column: x => x.OptionValueId,
+                        principalSchema: "catalog",
+                        principalTable: "ServiceOptionValues",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.InsertData(
+                schema: "catalog",
+                table: "ServiceCategories",
+                columns: new[] { "Id", "CreatedAt", "CreatedById", "DeletedAt", "DescriptionEn", "DescriptionFa", "IconKey", "IsActive", "ModifiedAt", "ModifiedById", "NameEn", "NameFa", "SortOrder" },
+                values: new object[,]
+                {
+                    { 1L, new DateTimeOffset(new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)), null, null, null, null, null, true, null, null, "Elderly Care", "مراقبت از سالمند", 1 },
+                    { 2L, new DateTimeOffset(new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)), null, null, null, null, null, true, null, null, "Post-Surgery Recovery", "مراقبت پس از جراحی", 2 },
+                    { 3L, new DateTimeOffset(new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)), null, null, null, null, null, true, null, null, "Infant Care", "مراقبت از نوزاد", 3 },
+                    { 4L, new DateTimeOffset(new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)), null, null, null, null, null, true, null, null, "Chronic Illness Management", "مدیریت بیماری مزمن", 4 },
+                    { 5L, new DateTimeOffset(new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)), null, null, null, null, null, true, null, null, "Companionship", "همراهی و مراقبت روزمره", 5 }
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_NurseServiceVariantOptions_OptionGroupId",
+                schema: "catalog",
+                table: "NurseServiceVariantOptions",
+                column: "OptionGroupId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_NurseServiceVariantOptions_OptionValueId",
+                schema: "catalog",
+                table: "NurseServiceVariantOptions",
+                column: "OptionValueId");
+
+            migrationBuilder.CreateIndex(
+                name: "UX_NurseServiceVariantOptions_Variant_Group",
+                schema: "catalog",
+                table: "NurseServiceVariantOptions",
+                columns: new[] { "VariantId", "OptionGroupId" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_NurseServiceVariants_NurseId_IsActive",
+                schema: "catalog",
+                table: "NurseServiceVariants",
+                columns: new[] { "NurseId", "IsActive" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_NurseServiceVariants_ServiceCategoryId",
+                schema: "catalog",
+                table: "NurseServiceVariants",
+                column: "ServiceCategoryId");
+
+            migrationBuilder.CreateIndex(
+                name: "UX_NurseServiceVariants_Nurse_Category_OptionSet",
+                schema: "catalog",
+                table: "NurseServiceVariants",
+                columns: new[] { "NurseId", "ServiceCategoryId", "OptionSetHash" },
+                unique: true,
+                filter: "[DeletedAt] IS NULL");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ServiceCategories_IsActive_SortOrder",
+                schema: "catalog",
+                table: "ServiceCategories",
+                columns: new[] { "IsActive", "SortOrder" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ServiceOptionGroups_ServiceCategoryId_SortOrder",
+                schema: "catalog",
+                table: "ServiceOptionGroups",
+                columns: new[] { "ServiceCategoryId", "SortOrder" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ServiceOptionValues_OptionGroupId_SortOrder",
+                schema: "catalog",
+                table: "ServiceOptionValues",
+                columns: new[] { "OptionGroupId", "SortOrder" });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "NurseServiceVariantOptions",
+                schema: "catalog");
+
+            migrationBuilder.DropTable(
+                name: "NurseServiceVariants",
+                schema: "catalog");
+
+            migrationBuilder.DropTable(
+                name: "ServiceOptionValues",
+                schema: "catalog");
+
+            migrationBuilder.DropTable(
+                name: "ServiceOptionGroups",
+                schema: "catalog");
+
+            migrationBuilder.DropTable(
+                name: "ServiceCategories",
+                schema: "catalog");
+        }
+    }
+}
@@ -98,6 +98,337 @@ namespace Baya.Infrastructure.Persistence.Migrations
                    b.ToTable("AuditLogs", "ops");
                });

+            modelBuilder.Entity("Baya.Domain.Entities.Catalog.NurseServiceVariant", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("CreatedById")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset?>("DeletedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(300)
+                        .HasColumnType("nvarchar(300)");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<DateTimeOffset?>("ModifiedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("ModifiedById")
+                        .HasColumnType("int");
+
+                    b.Property<long>("NurseId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("OptionSetHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<long>("Price")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("PriceUnit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<long>("ServiceCategoryId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int?>("SessionCount")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ServiceCategoryId");
+
+                    b.HasIndex("NurseId", "IsActive");
+
+                    b.HasIndex("NurseId", "ServiceCategoryId", "OptionSetHash")
+                        .IsUnique()
+                        .HasDatabaseName("UX_NurseServiceVariants_Nurse_Category_OptionSet")
+                        .HasFilter("[DeletedAt] IS NULL");
+
+                    b.ToTable("NurseServiceVariants", "catalog");
+                });
+
+            modelBuilder.Entity("Baya.Domain.Entities.Catalog.NurseServiceVariantOption", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("CreatedById")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset?>("ModifiedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("ModifiedById")
+                        .HasColumnType("int");
+
+                    b.Property<long>("OptionGroupId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("OptionValueId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("VariantId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OptionGroupId");
+
+                    b.HasIndex("OptionValueId");
+
+                    b.HasIndex("VariantId", "OptionGroupId")
+                        .IsUnique()
+                        .HasDatabaseName("UX_NurseServiceVariantOptions_Variant_Group");
+
+                    b.ToTable("NurseServiceVariantOptions", "catalog");
+                });
+
+            modelBuilder.Entity("Baya.Domain.Entities.Catalog.ServiceCategory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("CreatedById")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset?>("DeletedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("DescriptionEn")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("DescriptionFa")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("IconKey")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<DateTimeOffset?>("ModifiedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("ModifiedById")
+                        .HasColumnType("int");
+
+                    b.Property<string>("NameEn")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.Property<string>("NameFa")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsActive", "SortOrder");
+
+                    b.ToTable("ServiceCategories", "catalog");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1L,
+                            CreatedAt = new DateTimeOffset(new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            IsActive = true,
+                            NameEn = "Elderly Care",
+                            NameFa = "مراقبت از سالمند",
+                            SortOrder = 1
+                        },
+                        new
+                        {
+                            Id = 2L,
+                            CreatedAt = new DateTimeOffset(new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            IsActive = true,
+                            NameEn = "Post-Surgery Recovery",
+                            NameFa = "مراقبت پس از جراحی",
+                            SortOrder = 2
+                        },
+                        new
+                        {
+                            Id = 3L,
+                            CreatedAt = new DateTimeOffset(new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            IsActive = true,
+                            NameEn = "Infant Care",
+                            NameFa = "مراقبت از نوزاد",
+                            SortOrder = 3
+                        },
+                        new
+                        {
+                            Id = 4L,
+                            CreatedAt = new DateTimeOffset(new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            IsActive = true,
+                            NameEn = "Chronic Illness Management",
+                            NameFa = "مدیریت بیماری مزمن",
+                            SortOrder = 4
+                        },
+                        new
+                        {
+                            Id = 5L,
+                            CreatedAt = new DateTimeOffset(new DateTime(2026, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            IsActive = true,
+                            NameEn = "Companionship",
+                            NameFa = "همراهی و مراقبت روزمره",
+                            SortOrder = 5
+                        });
+                });
+
+            modelBuilder.Entity("Baya.Domain.Entities.Catalog.ServiceOptionGroup", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("CreatedById")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset?>("DeletedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<bool>("IsRequired")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(false);
+
+                    b.Property<DateTimeOffset?>("ModifiedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("ModifiedById")
+                        .HasColumnType("int");
+
+                    b.Property<string>("NameEn")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.Property<string>("NameFa")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.Property<long?>("ServiceCategoryId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ServiceCategoryId", "SortOrder");
+
+                    b.ToTable("ServiceOptionGroups", "catalog");
+                });
+
+            modelBuilder.Entity("Baya.Domain.Entities.Catalog.ServiceOptionValue", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("CreatedById")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset?>("DeletedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<bool>("IsActive")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(true);
+
+                    b.Property<DateTimeOffset?>("ModifiedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("ModifiedById")
+                        .HasColumnType("int");
+
+                    b.Property<string>("NameEn")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.Property<string>("NameFa")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.Property<long>("OptionGroupId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OptionGroupId", "SortOrder");
+
+                    b.ToTable("ServiceOptionValues", "catalog");
+                });
+
            modelBuilder.Entity("Baya.Domain.Entities.Configuration.PlatformConfig", b =>
                {
                    b.Property<long>("Id")
@@ -2243,6 +2574,72 @@ namespace Baya.Infrastructure.Persistence.Migrations
                        .HasForeignKey("ActorUserId");
                });

+            modelBuilder.Entity("Baya.Domain.Entities.Catalog.NurseServiceVariant", b =>
+                {
+                    b.HasOne("Baya.Domain.Entities.Identity.NurseProfile", "Nurse")
+                        .WithMany()
+                        .HasForeignKey("NurseId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Baya.Domain.Entities.Catalog.ServiceCategory", "ServiceCategory")
+                        .WithMany("Variants")
+                        .HasForeignKey("ServiceCategoryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Nurse");
+
+                    b.Navigation("ServiceCategory");
+                });
+
+            modelBuilder.Entity("Baya.Domain.Entities.Catalog.NurseServiceVariantOption", b =>
+                {
+                    b.HasOne("Baya.Domain.Entities.Catalog.ServiceOptionGroup", "OptionGroup")
+                        .WithMany()
+                        .HasForeignKey("OptionGroupId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Baya.Domain.Entities.Catalog.ServiceOptionValue", "OptionValue")
+                        .WithMany()
+                        .HasForeignKey("OptionValueId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Baya.Domain.Entities.Catalog.NurseServiceVariant", "Variant")
+                        .WithMany("Options")
+                        .HasForeignKey("VariantId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("OptionGroup");
+
+                    b.Navigation("OptionValue");
+
+                    b.Navigation("Variant");
+                });
+
+            modelBuilder.Entity("Baya.Domain.Entities.Catalog.ServiceOptionGroup", b =>
+                {
+                    b.HasOne("Baya.Domain.Entities.Catalog.ServiceCategory", "ServiceCategory")
+                        .WithMany("OptionGroups")
+                        .HasForeignKey("ServiceCategoryId");
+
+                    b.Navigation("ServiceCategory");
+                });
+
+            modelBuilder.Entity("Baya.Domain.Entities.Catalog.ServiceOptionValue", b =>
+                {
+                    b.HasOne("Baya.Domain.Entities.Catalog.ServiceOptionGroup", "OptionGroup")
+                        .WithMany("Values")
+                        .HasForeignKey("OptionGroupId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("OptionGroup");
+                });
+
            modelBuilder.Entity("Baya.Domain.Entities.Geography.City", b =>
                {
                    b.HasOne("Baya.Domain.Entities.Geography.Province", "Province")
@@ -2466,6 +2863,23 @@ namespace Baya.Infrastructure.Persistence.Migrations
                    b.Navigation("User");
                });

+            modelBuilder.Entity("Baya.Domain.Entities.Catalog.NurseServiceVariant", b =>
+                {
+                    b.Navigation("Options");
+                });
+
+            modelBuilder.Entity("Baya.Domain.Entities.Catalog.ServiceCategory", b =>
+                {
+                    b.Navigation("OptionGroups");
+
+                    b.Navigation("Variants");
+                });
+
+            modelBuilder.Entity("Baya.Domain.Entities.Catalog.ServiceOptionGroup", b =>
+                {
+                    b.Navigation("Values");
+                });
+
            modelBuilder.Entity("Baya.Domain.Entities.Geography.City", b =>
                {
                    b.Navigation("Districts");
@@ -0,0 +1,99 @@
+#nullable enable
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Domain.Entities.Catalog;
+using Microsoft.EntityFrameworkCore;
+
+namespace Baya.Infrastructure.Persistence.Repositories;
+
+internal sealed class CatalogRepository : ICatalogRepository
+{
+    private readonly ApplicationDbContext _db;
+
+    public CatalogRepository(ApplicationDbContext db) => _db = db;
+
+    public async Task<IReadOnlyList<ServiceCategoryDto>> ListActiveCategoriesAsync(CancellationToken cancellationToken)
+        => await _db.Set<ServiceCategory>()
+            .AsNoTracking()
+            .Where(c => c.IsActive)
+            .OrderBy(c => c.SortOrder)
+            .ThenBy(c => c.Id)
+            .Select(c => new ServiceCategoryDto(
+                c.Id, c.NameFa, c.NameEn, c.DescriptionFa, c.DescriptionEn, c.IconKey, c.SortOrder, c.IsActive))
+            .ToListAsync(cancellationToken);
+
+    public async Task<IReadOnlyList<OptionGroupDto>> GetApplicableGroupsAsync(long categoryId, CancellationToken cancellationToken)
+        => await _db.Set<ServiceOptionGroup>()
+            .AsNoTracking()
+            // The category's own active groups PLUS every cross-category (NULL) active group.
+            .Where(g => g.IsActive && (g.ServiceCategoryId == categoryId || g.ServiceCategoryId == null))
+            .OrderBy(g => g.SortOrder)
+            .ThenBy(g => g.Id)
+            .Select(g => new OptionGroupDto(
+                g.Id,
+                g.ServiceCategoryId,
+                g.NameFa,
+                g.NameEn,
+                g.IsRequired,
+                g.SortOrder,
+                g.IsActive,
+                g.Values
+                    .Where(v => v.IsActive)
+                    .OrderBy(v => v.SortOrder)
+                    .ThenBy(v => v.Id)
+                    .Select(v => new OptionValueDto(v.Id, v.NameFa, v.NameEn, v.SortOrder, v.IsActive))
+                    .ToList()))
+            .ToListAsync(cancellationToken);
+
+    public Task<ServiceCategoryDto?> GetActiveCategoryAsync(long id, CancellationToken cancellationToken)
+        => _db.Set<ServiceCategory>()
+            .AsNoTracking()
+            .Where(c => c.Id == id && c.IsActive)
+            .Select(c => new ServiceCategoryDto(
+                c.Id, c.NameFa, c.NameEn, c.DescriptionFa, c.DescriptionEn, c.IconKey, c.SortOrder, c.IsActive))
+            .FirstOrDefaultAsync(cancellationToken);
+
+    public Task<OptionGroupDto?> GetGroupDtoAsync(long id, CancellationToken cancellationToken)
+        => _db.Set<ServiceOptionGroup>()
+            .AsNoTracking()
+            .Where(g => g.Id == id)
+            .Select(g => new OptionGroupDto(
+                g.Id,
+                g.ServiceCategoryId,
+                g.NameFa,
+                g.NameEn,
+                g.IsRequired,
+                g.SortOrder,
+                g.IsActive,
+                g.Values
+                    .Where(v => v.IsActive)
+                    .OrderBy(v => v.SortOrder)
+                    .ThenBy(v => v.Id)
+                    .Select(v => new OptionValueDto(v.Id, v.NameFa, v.NameEn, v.SortOrder, v.IsActive))
+                    .ToList()))
+            .FirstOrDefaultAsync(cancellationToken);
+
+    public Task<ServiceCategory?> GetCategoryAsync(long id, CancellationToken cancellationToken)
+        => _db.Set<ServiceCategory>().FirstOrDefaultAsync(c => c.Id == id, cancellationToken);
+
+    public Task<ServiceOptionGroup?> GetGroupAsync(long id, CancellationToken cancellationToken)
+        => _db.Set<ServiceOptionGroup>().FirstOrDefaultAsync(g => g.Id == id, cancellationToken);
+
+    public Task<ServiceOptionValue?> GetValueAsync(long id, CancellationToken cancellationToken)
+        => _db.Set<ServiceOptionValue>().FirstOrDefaultAsync(v => v.Id == id, cancellationToken);
+
+    public Task<bool> CategoryExistsAsync(long id, CancellationToken cancellationToken)
+        => _db.Set<ServiceCategory>().AsNoTracking().AnyAsync(c => c.Id == id, cancellationToken);
+
+    public Task<bool> GroupExistsAsync(long id, CancellationToken cancellationToken)
+        => _db.Set<ServiceOptionGroup>().AsNoTracking().AnyAsync(g => g.Id == id, cancellationToken);
+
+    public async Task AddCategoryAsync(ServiceCategory category, CancellationToken cancellationToken)
+        => await _db.Set<ServiceCategory>().AddAsync(category, cancellationToken);
+
+    public async Task AddGroupAsync(ServiceOptionGroup group, CancellationToken cancellationToken)
+        => await _db.Set<ServiceOptionGroup>().AddAsync(group, cancellationToken);
+
+    public async Task AddValueAsync(ServiceOptionValue value, CancellationToken cancellationToken)
+        => await _db.Set<ServiceOptionValue>().AddAsync(value, cancellationToken);
+}
@@ -16,6 +16,8 @@ public class UnitOfWork : IUnitOfWork
    public IGeoRepository GeoRepository { get; }
    public INurseServiceAreaRepository NurseServiceAreaRepository { get; }
    public ICustomerAddressRepository CustomerAddressRepository { get; }
+    public ICatalogRepository CatalogRepository { get; }
+    public INurseServiceVariantRepository NurseServiceVariantRepository { get; }

    public UnitOfWork(ApplicationDbContext db)
    {
@@ -30,6 +32,8 @@ public class UnitOfWork : IUnitOfWork
        GeoRepository = new GeoRepository(_db);
        NurseServiceAreaRepository = new NurseServiceAreaRepository(_db);
        CustomerAddressRepository = new CustomerAddressRepository(_db);
+        CatalogRepository = new CatalogRepository(_db);
+        NurseServiceVariantRepository = new NurseServiceVariantRepository(_db);
    }

    public Task CommitAsync()
@@ -0,0 +1,125 @@
+#nullable enable
+using System.Globalization;
+using System.Linq.Expressions;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Models.Catalog;
+using Baya.Application.Models.Common;
+using Baya.Domain.Entities.Catalog;
+using Baya.Infrastructure.Persistence.Repositories.Common;
+using Microsoft.EntityFrameworkCore;
+
+namespace Baya.Infrastructure.Persistence.Repositories;
+
+internal sealed class NurseServiceVariantRepository : BaseAsyncRepository<NurseServiceVariant>, INurseServiceVariantRepository
+{
+    public NurseServiceVariantRepository(ApplicationDbContext dbContext) : base(dbContext)
+    {
+    }
+
+    public Task AddAsync(NurseServiceVariant variant, CancellationToken cancellationToken)
+        => base.AddAsync(variant);
+
+    public Task<NurseServiceVariant?> GetOwnedAsync(long id, long nurseId, CancellationToken cancellationToken)
+        => Table.FirstOrDefaultAsync(v => v.Id == id && v.NurseId == nurseId, cancellationToken);
+
+    public Task<bool> DuplicateHashExistsAsync(long nurseId, long serviceCategoryId, string optionSetHash, long? excludeVariantId, CancellationToken cancellationToken)
+        => TableNoTracking.AnyAsync(
+            v => v.NurseId == nurseId
+                 && v.ServiceCategoryId == serviceCategoryId
+                 && v.OptionSetHash == optionSetHash
+                 && (excludeVariantId == null || v.Id != excludeVariantId),
+            cancellationToken);
+
+    public async Task<PagedResult<VariantDto>> ListMineAsync(long nurseId, int page, int pageSize, CancellationToken cancellationToken)
+    {
+        var query = TableNoTracking.Where(v => v.NurseId == nurseId);
+
+        var total = await query.CountAsync(cancellationToken);
+        var rows = await query
+            // Active offerings first, then newest — the deactivated ones stay visibly distinct at the tail.
+            .OrderByDescending(v => v.IsActive)
+            .ThenByDescending(v => v.Id)
+            .Skip((page - 1) * pageSize)
+            .Take(pageSize)
+            .Select(Projection)
+            .ToListAsync(cancellationToken);
+
+        return new PagedResult<VariantDto>(rows.Select(Map).ToList(), total, page, pageSize);
+    }
+
+    public async Task<VariantDto?> GetOwnedProjectedAsync(long id, long nurseId, CancellationToken cancellationToken)
+    {
+        var row = await TableNoTracking
+            .Where(v => v.Id == id && v.NurseId == nurseId)
+            .Select(Projection)
+            .FirstOrDefaultAsync(cancellationToken);
+        return row is null ? null : Map(row);
+    }
+
+    public async Task<VariantDto?> GetProjectedAsync(long id, CancellationToken cancellationToken)
+    {
+        var row = await TableNoTracking
+            .Where(v => v.Id == id)
+            .Select(Projection)
+            .FirstOrDefaultAsync(cancellationToken);
+        return row is null ? null : Map(row);
+    }
+
+    public async Task<VariantDto?> GetPublicProjectedAsync(long id, CancellationToken cancellationToken)
+    {
+        var row = await TableNoTracking
+            .Where(v => v.Id == id && v.IsActive)
+            .Select(Projection)
+            .FirstOrDefaultAsync(cancellationToken);
+        return row is null ? null : Map(row);
+    }
+
+    // Shared DB projection: keeps Price as the raw long (translatable) and resolves category/option labels.
+    // Price is formatted to a digit string in memory (see Map) so no long.ToString() SQL translation is
+    // required, and the option-set is a single-level collection projection (SQLite-safe).
+    private static readonly Expression<Func<NurseServiceVariant, VariantRow>> Projection = v => new VariantRow(
+        v.Id,
+        v.ServiceCategoryId,
+        v.ServiceCategory.NameFa,
+        v.ServiceCategory.NameEn,
+        v.Price,
+        v.PriceUnit,
+        v.SessionCount,
+        v.DisplayName,
+        v.IsActive,
+        v.Options
+            .OrderBy(o => o.OptionGroup.SortOrder)
+            .ThenBy(o => o.OptionGroupId)
+            .Select(o => new VariantOptionDto(
+                o.OptionGroupId,
+                o.OptionGroup.NameFa,
+                o.OptionGroup.NameEn,
+                o.OptionValueId,
+                o.OptionValue.NameFa,
+                o.OptionValue.NameEn))
+            .ToList());
+
+    private static VariantDto Map(VariantRow r) => new(
+        r.Id,
+        r.ServiceCategoryId,
+        r.CategoryNameFa,
+        r.CategoryNameEn,
+        r.Price.ToString(CultureInfo.InvariantCulture),
+        r.PriceUnit,
+        r.SessionCount,
+        r.DisplayName,
+        r.IsActive,
+        r.Options);
+
+    private sealed record VariantRow(
+        long Id,
+        long ServiceCategoryId,
+        string CategoryNameFa,
+        string CategoryNameEn,
+        long Price,
+        string PriceUnit,
+        int? SessionCount,
+        string DisplayName,
+        bool IsActive,
+        List<VariantOptionDto> Options);
+}
@@ -0,0 +1,72 @@
+using System.Net;
+using System.Net.Http.Json;
+
+namespace Baya.Test.Api;
+
+public class CatalogPublicApiTests(BayaApiFactory factory) : IClassFixture<BayaApiFactory>
+{
+    private const long ElderlyCategoryId = 1;
+
+    [Fact]
+    public async Task Categories_Seeded_ReturnsFiveWithBothLabels()
+    {
+        var client = factory.CreateClient();
+
+        var response = await client.GetAsync("/api/v1/catalog/categories");
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var data = await AuthTestClient.ReadDataAsync(response);
+        Assert.Equal(5, data.GetProperty("total").GetInt32());
+
+        var first = data.GetProperty("items").EnumerateArray().First();
+        Assert.False(string.IsNullOrWhiteSpace(first.GetProperty("nameFa").GetString()));
+        Assert.False(string.IsNullOrWhiteSpace(first.GetProperty("nameEn").GetString()));
+        // Ordered by sort_order → Elderly Care (seed id/sort 1) leads.
+        Assert.Equal("Elderly Care", first.GetProperty("nameEn").GetString());
+    }
+
+    [Fact]
+    public async Task AdminBuildsDimension_PublicListsGroupWithValuesPlusCrossCategory()
+    {
+        var client = factory.CreateClient();
+        await AdminTestClient.AuthenticateAsync(factory, client, "09131000001");
+
+        // A category-scoped required dimension.
+        var group = await client.PostAsJsonAsync("/api/v1/admin_catalog/create_option_group",
+            new { serviceCategoryId = ElderlyCategoryId, nameFa = "نوع شیفت", nameEn = "Shift type", isRequired = true, sortOrder = 1 });
+        Assert.Equal(HttpStatusCode.OK, group.StatusCode);
+        var groupId = (await AuthTestClient.ReadDataAsync(group)).GetProperty("id").GetInt64();
+
+        // A cross-category (null category) dimension applies to every category.
+        var crossGroup = await client.PostAsJsonAsync("/api/v1/admin_catalog/create_option_group",
+            new { serviceCategoryId = (long?)null, nameFa = "تعداد بیمار", nameEn = "Patient count", isRequired = false, sortOrder = 2 });
+        Assert.Equal(HttpStatusCode.OK, crossGroup.StatusCode);
+        var crossGroupId = (await AuthTestClient.ReadDataAsync(crossGroup)).GetProperty("id").GetInt64();
+
+        var v1 = await client.PostAsJsonAsync("/api/v1/admin_catalog/create_option_value",
+            new { optionGroupId = groupId, nameFa = "شبانه‌روزی", nameEn = "Live-in", sortOrder = 1 });
+        var v2 = await client.PostAsJsonAsync("/api/v1/admin_catalog/create_option_value",
+            new { optionGroupId = groupId, nameFa = "روزانه", nameEn = "Daytime", sortOrder = 2 });
+        Assert.Equal(HttpStatusCode.OK, v1.StatusCode);
+        Assert.Equal(HttpStatusCode.OK, v2.StatusCode);
+
+        var groups = await client.GetAsync($"/api/v1/catalog/option_groups?category_id={ElderlyCategoryId}");
+        var arr = (await AuthTestClient.ReadDataAsync(groups)).EnumerateArray().ToList();
+
+        var shift = arr.Single(g => g.GetProperty("id").GetInt64() == groupId);
+        Assert.True(shift.GetProperty("isRequired").GetBoolean());
+        Assert.Equal(2, shift.GetProperty("values").GetArrayLength());
+
+        // The cross-category group shows up under this category too.
+        Assert.Contains(arr, g => g.GetProperty("id").GetInt64() == crossGroupId);
+    }
+
+    [Fact]
+    public async Task CreateCategory_Unauthenticated_Returns401()
+    {
+        var client = factory.CreateClient();
+        var response = await client.PostAsJsonAsync("/api/v1/admin_catalog/create_category",
+            new { nameFa = "x", nameEn = "x", sortOrder = 1 });
+        Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
+    }
+}
@@ -0,0 +1,115 @@
+using System.Net;
+using System.Net.Http.Json;
+
+namespace Baya.Test.Api;
+
+public class NurseVariantsApiTests(BayaApiFactory factory) : IClassFixture<BayaApiFactory>
+{
+    private const long ElderlyCategoryId = 1;
+
+    private static async Task SetUpNurseAsync(BayaApiFactory factory, HttpClient client, string phone)
+    {
+        await ProfileTestClient.AuthenticateAsync(factory, client, phone, "nurse");
+        await client.PostAsJsonAsync("/api/v1/nurse_profiles/upsert",
+            new { bio = "b", yearsOfExperience = 5, educationLevel = "", educationField = "", specializationsJson = "[]" });
+    }
+
+    [Fact]
+    public async Task Variant_FullLifecycle_BuildDuplicateMissingRequiredListDeactivateTenancy()
+    {
+        // --- Admin builds the required dimension for the Elderly category ---
+        var admin = factory.CreateClient();
+        await AdminTestClient.AuthenticateAsync(factory, admin, "09132000001");
+
+        var groupResp = await admin.PostAsJsonAsync("/api/v1/admin_catalog/create_option_group",
+            new { serviceCategoryId = ElderlyCategoryId, nameFa = "نوع شیفت", nameEn = "Shift type", isRequired = true, sortOrder = 1 });
+        var groupId = (await AuthTestClient.ReadDataAsync(groupResp)).GetProperty("id").GetInt64();
+
+        var valResp = await admin.PostAsJsonAsync("/api/v1/admin_catalog/create_option_value",
+            new { optionGroupId = groupId, nameFa = "شبانه‌روزی", nameEn = "Live-in", sortOrder = 1 });
+        var liveInId = (await AuthTestClient.ReadDataAsync(valResp)).GetProperty("id").GetInt64();
+
+        // --- Nurse builds a valid variant ---
+        var nurse = factory.CreateClient();
+        await SetUpNurseAsync(factory, nurse, "09132000002");
+
+        object CreatePayload(long valueId) => new
+        {
+            serviceCategoryId = ElderlyCategoryId,
+            options = new[] { new { optionGroupId = groupId, optionValueId = valueId } },
+            price = "8000000",
+            priceUnit = "per_24h"
+        };
+
+        var create = await nurse.PostAsJsonAsync("/api/v1/nurse_variants/create", CreatePayload(liveInId));
+        Assert.Equal(HttpStatusCode.OK, create.StatusCode);
+        var created = await AuthTestClient.ReadDataAsync(create);
+        var variantId = created.GetProperty("id").GetInt64();
+        Assert.True(created.GetProperty("isActive").GetBoolean());
+        Assert.Equal("8000000", created.GetProperty("price").GetString());
+        // The DbContext normalises the Persian ZWNJ (نیم‌فاصله) to a space platform-wide, so assert on a
+        // ZWNJ-agnostic substring of the auto-generated display name (category + chosen value label).
+        var displayName = created.GetProperty("displayName").GetString();
+        Assert.Contains("مراقبت از سالمند", displayName);
+        Assert.Contains("شبانه", displayName);
+
+        // --- Public (anonymous) sees the active variant ---
+        var anon = factory.CreateClient();
+        var publicGet = await anon.GetAsync($"/api/v1/nurse_variants/get/{variantId}");
+        Assert.Equal(HttpStatusCode.OK, publicGet.StatusCode);
+        Assert.Equal("8000000", (await AuthTestClient.ReadDataAsync(publicGet)).GetProperty("price").GetString());
+
+        // --- Duplicate identical listing → 409 (clean, not a 500) ---
+        var duplicate = await nurse.PostAsJsonAsync("/api/v1/nurse_variants/create", CreatePayload(liveInId));
+        Assert.Equal(HttpStatusCode.Conflict, duplicate.StatusCode);
+
+        // --- Missing the required dimension → 400 ---
+        var missing = await nurse.PostAsJsonAsync("/api/v1/nurse_variants/create",
+            new { serviceCategoryId = ElderlyCategoryId, options = Array.Empty<object>(), price = "5000000", priceUnit = "per_day" });
+        Assert.Equal(HttpStatusCode.BadRequest, missing.StatusCode);
+
+        // --- List shows the one active variant ---
+        var listActive = await AuthTestClient.ReadDataAsync(await nurse.GetAsync("/api/v1/nurse_variants/list"));
+        Assert.Equal(1, listActive.GetProperty("total").GetInt32());
+
+        // --- Deactivate (never delete); it stays in the list, flagged inactive ---
+        var deactivate = await nurse.PostAsJsonAsync($"/api/v1/nurse_variants/set_active/{variantId}", new { isActive = false });
+        Assert.Equal(HttpStatusCode.OK, deactivate.StatusCode);
+
+        var listAfter = await AuthTestClient.ReadDataAsync(await nurse.GetAsync("/api/v1/nurse_variants/list"));
+        Assert.Equal(1, listAfter.GetProperty("total").GetInt32());
+        var row = listAfter.GetProperty("items").EnumerateArray().Single(v => v.GetProperty("id").GetInt64() == variantId);
+        Assert.False(row.GetProperty("isActive").GetBoolean());
+
+        // --- A deactivated variant drops out of the public view (404) ---
+        var publicGetAfter = await anon.GetAsync($"/api/v1/nurse_variants/get/{variantId}");
+        Assert.Equal(HttpStatusCode.NotFound, publicGetAfter.StatusCode);
+
+        // --- Tenancy: a different nurse cannot edit it → 404 (existence not leaked) ---
+        var otherNurse = factory.CreateClient();
+        await SetUpNurseAsync(factory, otherNurse, "09132000003");
+        var tenancy = await otherNurse.PostAsJsonAsync($"/api/v1/nurse_variants/update/{variantId}",
+            new { price = "9000000", priceUnit = "per_day" });
+        Assert.Equal(HttpStatusCode.NotFound, tenancy.StatusCode);
+    }
+
+    [Fact]
+    public async Task Create_Unauthenticated_Returns401()
+    {
+        var client = factory.CreateClient();
+        var response = await client.PostAsJsonAsync("/api/v1/nurse_variants/create",
+            new { serviceCategoryId = ElderlyCategoryId, options = Array.Empty<object>(), price = "8000000", priceUnit = "per_24h" });
+        Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task Create_InvalidPrice_Returns400()
+    {
+        var client = factory.CreateClient();
+        await SetUpNurseAsync(factory, client, "09132000004");
+
+        var response = await client.PostAsJsonAsync("/api/v1/nurse_variants/create",
+            new { serviceCategoryId = ElderlyCategoryId, options = Array.Empty<object>(), price = "-5", priceUnit = "per_24h" });
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+    }
+}
@@ -0,0 +1,82 @@
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Features.Catalog.Commands.CreateServiceCategory;
+using Baya.Application.Features.Catalog.Commands.CreateServiceOptionGroup;
+using Baya.Application.Features.Catalog.Commands.CreateServiceOptionValue;
+using Baya.Application.Models.Catalog;
+using Baya.Domain.Entities.Catalog;
+using NSubstitute;
+
+namespace Baya.Test.Foundation.Catalog;
+
+public class CatalogAdminHandlerTests
+{
+    private readonly IUnitOfWork _unitOfWork = Substitute.For<IUnitOfWork>();
+    private readonly ICatalogRepository _catalog = Substitute.For<ICatalogRepository>();
+    private readonly ICacheService _cache = Substitute.For<ICacheService>();
+
+    public CatalogAdminHandlerTests()
+    {
+        _unitOfWork.CatalogRepository.Returns(_catalog);
+    }
+
+    [Fact]
+    public async Task CreateCategory_Succeeds_AndInvalidatesCache()
+    {
+        var handler = new CreateServiceCategoryCommandHandler(_unitOfWork, _cache);
+
+        var result = await handler.Handle(
+            new CreateServiceCategoryCommand("مراقبت از سالمند", "Elderly Care", null, null, null, 1), CancellationToken.None);
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal("Elderly Care", result.Result.NameEn);
+        Assert.True(result.Result.IsActive);
+        await _catalog.Received(1).AddCategoryAsync(Arg.Any<ServiceCategory>(), Arg.Any<CancellationToken>());
+        await _unitOfWork.Received(1).CommitAsync();
+        // Invalidation bumps the generation-token key so every cached catalog page refreshes.
+        await _cache.Received().SetAsync("catalog:version", Arg.Any<string>(), Arg.Any<TimeSpan?>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task CreateOptionGroup_UnknownCategory_Fails()
+    {
+        _catalog.CategoryExistsAsync(99L, Arg.Any<CancellationToken>()).Returns(false);
+        var handler = new CreateServiceOptionGroupCommandHandler(_unitOfWork, _cache);
+
+        var result = await handler.Handle(
+            new CreateServiceOptionGroupCommand(99L, "نوع شیفت", "Shift type", true, 1), CancellationToken.None);
+
+        Assert.False(result.IsSuccess);
+        await _catalog.DidNotReceive().AddGroupAsync(Arg.Any<ServiceOptionGroup>(), Arg.Any<CancellationToken>());
+        await _unitOfWork.DidNotReceive().CommitAsync();
+    }
+
+    [Fact]
+    public async Task CreateOptionGroup_CrossCategoryNull_Succeeds()
+    {
+        _catalog.GetGroupDtoAsync(Arg.Any<long>(), Arg.Any<CancellationToken>())
+            .Returns(new OptionGroupDto(5, null, "نوع شیفت", "Shift type", true, 1, true, []));
+        var handler = new CreateServiceOptionGroupCommandHandler(_unitOfWork, _cache);
+
+        var result = await handler.Handle(
+            new CreateServiceOptionGroupCommand(null, "نوع شیفت", "Shift type", true, 1), CancellationToken.None);
+
+        Assert.True(result.IsSuccess);
+        Assert.Null(result.Result.ServiceCategoryId);
+        await _catalog.Received(1).AddGroupAsync(
+            Arg.Is<ServiceOptionGroup>(g => g.ServiceCategoryId == null && g.IsRequired), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task CreateOptionValue_UnknownGroup_Fails()
+    {
+        _catalog.GroupExistsAsync(77L, Arg.Any<CancellationToken>()).Returns(false);
+        var handler = new CreateServiceOptionValueCommandHandler(_unitOfWork, _cache);
+
+        var result = await handler.Handle(
+            new CreateServiceOptionValueCommand(77L, "شبانه‌روزی", "Live-in", 1), CancellationToken.None);
+
+        Assert.False(result.IsSuccess);
+        await _catalog.DidNotReceive().AddValueAsync(Arg.Any<ServiceOptionValue>(), Arg.Any<CancellationToken>());
+    }
+}
@@ -0,0 +1,149 @@
+using Baya.Application.Contracts.Common;
+using Baya.Application.Contracts.Persistence;
+using Baya.Application.Features.Variants.Commands.CreateVariant;
+using Baya.Application.Models.Catalog;
+using Baya.Domain.Entities.Catalog;
+using Baya.Domain.Entities.User;
+using NSubstitute;
+using NSubstitute.ReturnsExtensions;
+
+namespace Baya.Test.Foundation.Catalog;
+
+public class CreateVariantHandlerTests
+{
+    private readonly ICurrentUser _currentUser = Substitute.For<ICurrentUser>();
+    private readonly IUnitOfWork _unitOfWork = Substitute.For<IUnitOfWork>();
+    private readonly INurseProfileRepository _nurses = Substitute.For<INurseProfileRepository>();
+    private readonly ICatalogRepository _catalog = Substitute.For<ICatalogRepository>();
+    private readonly INurseServiceVariantRepository _variants = Substitute.For<INurseServiceVariantRepository>();
+
+    private const long CategoryId = 1;
+    private const long ShiftGroupId = 10;
+    private const long LiveInValueId = 100;
+    private const long DaytimeValueId = 101;
+
+    public CreateVariantHandlerTests()
+    {
+        _currentUser.UserId.Returns(7);
+        _currentUser.Roles.Returns([RoleNames.Nurse]);
+        _unitOfWork.NurseProfileRepository.Returns(_nurses);
+        _unitOfWork.CatalogRepository.Returns(_catalog);
+        _unitOfWork.NurseServiceVariantRepository.Returns(_variants);
+
+        _nurses.GetProfileIdByUserIdAsync(7, Arg.Any<CancellationToken>()).Returns(42L);
+
+        _catalog.GetActiveCategoryAsync(CategoryId, Arg.Any<CancellationToken>())
+            .Returns(new ServiceCategoryDto(CategoryId, "مراقبت از سالمند", "Elderly Care", null, null, null, 1, true));
+
+        _catalog.GetApplicableGroupsAsync(CategoryId, Arg.Any<CancellationToken>())
+            .Returns(new List<OptionGroupDto>
+            {
+                new(ShiftGroupId, CategoryId, "نوع شیفت", "Shift type", IsRequired: true, SortOrder: 1, IsActive: true,
+                    Values:
+                    [
+                        new OptionValueDto(LiveInValueId, "شبانه‌روزی", "Live-in", 1, true),
+                        new OptionValueDto(DaytimeValueId, "روزانه", "Daytime", 2, true)
+                    ])
+            });
+
+        _variants.DuplicateHashExistsAsync(Arg.Any<long>(), Arg.Any<long>(), Arg.Any<string>(), Arg.Any<long?>(), Arg.Any<CancellationToken>())
+            .Returns(false);
+    }
+
+    private CreateVariantCommandHandler Handler() => new(_currentUser, _unitOfWork);
+
+    private static CreateVariantCommand Command(IReadOnlyList<VariantOptionSelection> options, string? displayName = null)
+        => new(CategoryId, options, "8000000", "per_24h", null, displayName);
+
+    [Fact]
+    public async Task Create_ValidVariant_SucceedsWithGeneratedDisplayName()
+    {
+        var result = await Handler().Handle(Command([new(ShiftGroupId, LiveInValueId)]), CancellationToken.None);
+
+        Assert.True(result.IsSuccess);
+        Assert.True(result.Result.IsActive);
+        Assert.Equal("8000000", result.Result.Price);
+        Assert.Contains("مراقبت از سالمند", result.Result.DisplayName);
+        Assert.Contains("شبانه‌روزی", result.Result.DisplayName);
+        Assert.Single(result.Result.Options);
+        await _variants.Received(1).AddAsync(
+            Arg.Is<NurseServiceVariant>(v =>
+                v.NurseId == 42L && v.ServiceCategoryId == CategoryId && v.PriceUnit == "per_24h"
+                && v.Price == 8000000 && !string.IsNullOrEmpty(v.OptionSetHash) && v.Options.Count == 1),
+            Arg.Any<CancellationToken>());
+        await _unitOfWork.Received(1).CommitAsync();
+    }
+
+    [Fact]
+    public async Task Create_MissingRequiredGroup_FailsValidationNotConflict()
+    {
+        var result = await Handler().Handle(Command([]), CancellationToken.None);
+
+        Assert.False(result.IsSuccess);
+        Assert.False(result.IsConflict);
+        Assert.False(result.IsNotFound);
+        await _variants.DidNotReceive().AddAsync(Arg.Any<NurseServiceVariant>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Create_DuplicateOptionSet_ReturnsConflict()
+    {
+        _variants.DuplicateHashExistsAsync(42L, CategoryId, Arg.Any<string>(), null, Arg.Any<CancellationToken>()).Returns(true);
+
+        var result = await Handler().Handle(Command([new(ShiftGroupId, LiveInValueId)]), CancellationToken.None);
+
+        Assert.True(result.IsConflict);
+        await _variants.DidNotReceive().AddAsync(Arg.Any<NurseServiceVariant>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Create_SameGroupTwice_FailsOneValuePerDimension()
+    {
+        var result = await Handler().Handle(
+            Command([new(ShiftGroupId, LiveInValueId), new(ShiftGroupId, DaytimeValueId)]), CancellationToken.None);
+
+        Assert.False(result.IsSuccess);
+        await _variants.DidNotReceive().AddAsync(Arg.Any<NurseServiceVariant>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Create_ValueNotBelongingToGroup_Fails()
+    {
+        var result = await Handler().Handle(Command([new(ShiftGroupId, 999L)]), CancellationToken.None);
+
+        Assert.False(result.IsSuccess);
+        await _variants.DidNotReceive().AddAsync(Arg.Any<NurseServiceVariant>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Create_InactiveOrMissingCategory_Fails()
+    {
+        _catalog.GetActiveCategoryAsync(CategoryId, Arg.Any<CancellationToken>()).ReturnsNull();
+
+        var result = await Handler().Handle(Command([new(ShiftGroupId, LiveInValueId)]), CancellationToken.None);
+
+        Assert.False(result.IsSuccess);
+        await _variants.DidNotReceive().AddAsync(Arg.Any<NurseServiceVariant>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Create_NonNurse_IsForbidden()
+    {
+        _currentUser.Roles.Returns([RoleNames.Customer]);
+
+        var result = await Handler().Handle(Command([new(ShiftGroupId, LiveInValueId)]), CancellationToken.None);
+
+        Assert.True(result.IsForbidden);
+        await _variants.DidNotReceive().AddAsync(Arg.Any<NurseServiceVariant>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Create_NurseOverridesDisplayName_UsesOverride()
+    {
+        var result = await Handler().Handle(
+            Command([new(ShiftGroupId, LiveInValueId)], displayName: "My live-in package"), CancellationToken.None);
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal("My live-in package", result.Result.DisplayName);
+    }
+}
@@ -0,0 +1,39 @@
+using Baya.Application.Common;
+using Baya.Application.Models.Catalog;
+
+namespace Baya.Test.Foundation.Catalog;
+
+public class VariantSnapshotSerializerTests
+{
+    [Fact]
+    public void Serialize_CarriesCategoryAndOptionLabels_PriceAsString_UnitAndSession()
+    {
+        var serializer = new VariantSnapshotSerializer();
+
+        var snapshot = new VariantSnapshot(
+            VariantId: 12,
+            ServiceCategoryId: 1,
+            CategoryNameFa: "مراقبت از سالمند",
+            CategoryNameEn: "Elderly Care",
+            Price: 8000000,
+            PriceUnit: "per_24h",
+            SessionCount: 3,
+            DisplayName: "مراقبت از سالمند · شبانه‌روزی",
+            Options: [new VariantOptionDto(10, "نوع شیفت", "Shift type", 100, "شبانه‌روزی", "Live-in")]);
+
+        var json = serializer.Serialize(snapshot);
+
+        // Money is a string of IRR-Rial digits (no floats, no numeric literal).
+        Assert.Contains("\"price\":\"8000000\"", json);
+        Assert.Contains("\"priceUnit\":\"per_24h\"", json);
+        Assert.Contains("\"sessionCount\":3", json);
+        Assert.Contains("\"variantId\":12", json);
+        // Category labels (both) — Persian lands as readable text, not \uXXXX.
+        Assert.Contains("مراقبت از سالمند", json);
+        Assert.Contains("Elderly Care", json);
+        // Each option label (group + value).
+        Assert.Contains("نوع شیفت", json);
+        Assert.Contains("شبانه‌روزی", json);
+        Assert.Contains("Live-in", json);
+    }
+}