Add files using upload-large-folder tool

tasks/taskrabbit/solution/site/README.md

@@ -0,0 +1,3 @@
+# Private oracle implementation
+
+The implementation is a deterministic projection of the current material clone and is copied only into the privileged oracle solution.

tasks/taskrabbit/solution/site/implementation/backend/runtime.json

@@ -0,0 +1,118 @@
+{
+  "database": {
+    "data_dir": "data",
+    "engine": "sqlite",
+    "filename": "taskrabbit.sqlite3",
+    "legacy_unbound_migration": false,
+    "migration_hook": "backend.db:apply_migrations",
+    "seed_hook": "backend.db:seed",
+    "volume_identity": "websitebench-taskrabbit-data"
+  },
+  "deployment": {
+    "profiles": {
+      "cloudflare-review": {
+        "mail_adapter": "redis-resend",
+        "payment_adapter": "stripe-test",
+        "persistence": "ephemeral-reset"
+      },
+      "docker-volume": {
+        "mail_adapter": "effects-gateway",
+        "payment_adapter": "local-sandbox",
+        "persistence": "persistent-volume"
+      },
+      "offline-harbor": {
+        "mail_adapter": "local-outbox",
+        "payment_adapter": "local-sandbox",
+        "persistence": "persistent"
+      }
+    }
+  },
+  "mail": {
+    "enabled": true,
+    "purposes": {
+      "password-reset": {
+        "body": "Your password reset code is ${code}.",
+        "expiry": "This code expires in ${minutes} minutes.",
+        "footer": "Ignore this message if you did not contact Taskrabbit Clone.",
+        "lead": "A password reset was requested for Taskrabbit Clone.",
+        "required_variables": [
+          "code",
+          "minutes"
+        ],
+        "secret_variables": [
+          "code"
+        ],
+        "subject": "Reset your Taskrabbit Clone password",
+        "template_id": "taskrabbit.password-reset.v1"
+      },
+      "registration": {
+        "body": "Your verification code is ${code}.",
+        "expiry": "This code expires in ${minutes} minutes.",
+        "footer": "This code is only for Taskrabbit Clone.",
+        "lead": "Finish creating your Taskrabbit Clone account.",
+        "required_variables": [
+          "code",
+          "minutes"
+        ],
+        "secret_variables": [
+          "code"
+        ],
+        "subject": "Verify your Taskrabbit Clone account",
+        "template_id": "taskrabbit.registration.v1"
+      }
+    },
+    "sender": {
+      "address_env": "RESEND_FROM_EMAIL",
+      "display_name": "Taskrabbit Clone"
+    }
+  },
+  "payments": {
+    "currency": "USD",
+    "default_adapter": "local-sandbox",
+    "enabled": true,
+    "local_sandbox": {
+      "scenarios": [
+        {
+          "display_label": "Simulated approval",
+          "id": "sandbox-approved",
+          "outcome": "approved"
+        },
+        {
+          "display_label": "Simulated decline",
+          "id": "sandbox-declined",
+          "outcome": "declined"
+        },
+        {
+          "display_label": "Simulated retry",
+          "id": "sandbox-retry",
+          "outcome": "retryable"
+        }
+      ]
+    },
+    "stripe_test": {
+      "max_line_items": 1,
+      "payment_method_types": [
+        "card",
+        "link"
+      ],
+      "integration_identifier_prefix": "websitebench_taskrabbit_",
+      "public_origin": "https://taskrabbit.website-bench.com",
+      "return_path": "/book/stripe-return",
+      "secret_key_env": "STRIPE_TEST_SECRET_KEY",
+      "webhook_path": "/api/stripe/webhook",
+      "webhook_secret_env": "STRIPE_TEST_WEBHOOK_SECRET"
+    }
+  },
+  "schema_version": "websitebench.site-backend-runtime.v1",
+  "session": {
+    "host_only": true,
+    "http_only": true,
+    "same_site": "Lax",
+    "secure": true
+  },
+  "site": {
+    "id": "taskrabbit",
+    "label": "Taskrabbit Clone",
+    "public_origin": "https://taskrabbit.website-bench.com"
+  }
+}

tasks/taskrabbit/solution/site/implementation/clone/backend/__init__.py

@@ -0,0 +1,13 @@
+"""Persistent backend package for the TaskRabbit offline clone (R3 stage).
+
+The backend owns every business fact the frontend renders: the help-moving
+category, the fictional fixture address, the 1-bedroom apartment option, the
+simulated Tasker roster with availability and hourly rates, the server-owned
+slot version, wizard drafts (draft booking with version), and confirmed
+booking-request rows.  Storage is a site-local SQLite database in WAL mode
+that lives outside clone/ (WEBSITEBENCH_DATA_DIR, default materials/taskrabbit/
+data).  Nothing here contacts taskrabbit.com; no real payment, chat, SMS, or
+fulfillment ever occurs.
+"""
+
+from __future__ import annotations

tasks/taskrabbit/solution/site/implementation/clone/backend/booking_payments.py

@@ -0,0 +1,314 @@
+"""TaskRabbit booking-payment overlay on the shared WebsiteBench ledger.
+
+A separate, offline-sandbox Payment step for the booking wizard. It authorizes,
+declines, or asks to retry a *test* payment through the shared ledger's
+``create_intent -> attempt -> consume_approval`` contract. There is **no real
+charge** and **no card-number entry**: the client only selects an outcome. Each
+authorization is bound by a fingerprint to exactly one booking draft (task,
+Tasker, slot, amount). ``confirm_booking`` later spends that authorization, so a
+booking can never be created without a matching authorized test payment.
+
+The ledger's own scenario labels ("Simulated approval" / ...) are banned from
+visible copy, so this module maps every sandbox outcome to a safe user-facing
+label before the payment form ever sees it.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sqlite3
+from collections.abc import Mapping
+from typing import Any
+
+from websitebench.site_backend import (
+    PaymentConflict,
+    PaymentError,
+    PaymentRejected,
+    SiteBackend,
+)
+
+SITE_ID = "taskrabbit"
+CURRENCY = "USD"
+# TaskRabbit authorizes against a standard minimum estimate rather than the full
+# open-ended hourly job; two hours is the funnel's frozen estimate.
+ESTIMATED_HOURS = 2
+PAYMENT_ADAPTER_ENV = "PAYMENT_ADAPTER"
+
+# runtime.json ships display labels ("Simulated approval" / "Simulated decline"
+# / "Simulated retry"); those words are banned from visible copy, so remap every
+# sandbox outcome to a safe, self-describing label for the payment form.
+_SAFE_LABELS = {
+    "approved": "Approve test payment",
+    "declined": "Decline test payment",
+    "retryable": "Ask to retry test payment",
+}
+_SAFE_HINTS = {
+    "approved": "Authorize the estimated total and continue to confirm the booking.",
+    "declined": "Preview how the booking flow handles a declined authorization.",
+    "retryable": "Preview how the booking flow handles a retryable authorization.",
+}
+
+
+class BookingPaymentError(RuntimeError):
+    """The booking payment is absent, stale, foreign, or otherwise invalid."""
+
+
+def _require_transaction(connection: sqlite3.Connection) -> None:
+    if not isinstance(connection, sqlite3.Connection) or not connection.in_transaction:
+        raise BookingPaymentError("booking payment requires an active transaction")
+
+
+def estimated_amount_minor(hourly_rate: int | str) -> int:
+    """Authorized amount, in minor units, for a Tasker's hourly rate."""
+    return int(hourly_rate) * ESTIMATED_HOURS * 100
+
+
+def format_total(amount_minor: int | str, currency: str = CURRENCY) -> str:
+    return f"${int(amount_minor) / 100:.2f} {currency}"
+
+
+def flow_idempotency_key(fingerprint_value: str) -> str:
+    """Stable opaque submit token for exactly one server-priced draft."""
+    return f"taskrabbit-book-flow:{fingerprint_value[:40]}"
+
+
+def payment_adapter(backend: SiteBackend) -> str:
+    """Resolve the deployment-selected test adapter, failing closed."""
+    adapter = str(
+        os.environ.get(
+            PAYMENT_ADAPTER_ENV,
+            backend.config.payments["default_adapter"],
+        )
+    ).strip()
+    if adapter not in {"local-sandbox", "stripe-test"}:
+        raise BookingPaymentError("the configured test payment adapter is invalid")
+    if adapter == "stripe-test" and backend.config.payments["stripe_test"] is None:
+        raise BookingPaymentError("Stripe test Checkout is not configured")
+    return adapter
+
+
+def payment_scenarios(backend: SiteBackend) -> tuple[dict[str, str], ...]:
+    """Sandbox outcomes for the payment form, with safe user-facing labels."""
+    if payment_adapter(backend) != "local-sandbox":
+        return ()
+    scenarios: list[dict[str, str]] = []
+    for item in backend.config.payments["local_sandbox"]["scenarios"]:
+        outcome = str(item["outcome"])
+        scenarios.append(
+            {
+                "id": str(item["id"]),
+                "outcome": outcome,
+                "label": _SAFE_LABELS.get(outcome, "Test payment"),
+                "hint": _SAFE_HINTS.get(outcome, ""),
+            }
+        )
+    return tuple(scenarios)
+
+
+def scenario_ids(backend: SiteBackend) -> set[str]:
+    return {scenario["id"] for scenario in payment_scenarios(backend)}
+
+
+def approved_scenario_id(backend: SiteBackend) -> str:
+    for scenario in payment_scenarios(backend):
+        if scenario["outcome"] == "approved":
+            return scenario["id"]
+    raise BookingPaymentError("no approving sandbox scenario is configured")
+
+
+def fingerprint(
+    *,
+    request_id: str,
+    account_id: str,
+    category_id: str,
+    tasker_id: str,
+    slot_id: str,
+    amount_minor: int,
+) -> str:
+    """Bind an authorization to exactly one booking draft.
+
+    Deliberately excludes the mutable draft version: the authorization is tied to
+    the concrete task/Tasker/slot/amount the client saw and paid for, not to an
+    internal counter that other wizard writes bump.
+    """
+    payload = {
+        "site_id": SITE_ID,
+        "request_id": request_id,
+        "account_id": account_id,
+        "category_id": category_id,
+        "tasker_id": tasker_id,
+        "slot_id": slot_id,
+        "amount_minor": int(amount_minor),
+        "currency": CURRENCY,
+        "effect": "test-only-booking-authorization",
+    }
+    canonical = json.dumps(payload, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+def create_or_reuse_flow(
+    connection: sqlite3.Connection,
+    backend: SiteBackend,
+    *,
+    account_id: str,
+    amount_minor: int,
+    fingerprint_value: str,
+) -> str:
+    """Open — or idempotently reuse — a payment flow for this fingerprint."""
+    _require_transaction(connection)
+    try:
+        flow = backend.payments.create_intent(
+            owner=account_id,
+            amount_minor=int(amount_minor),
+            currency=CURRENCY,
+            fingerprint=fingerprint_value,
+            idempotency_key=flow_idempotency_key(fingerprint_value),
+            adapter=payment_adapter(backend),
+            connection=connection,
+        )
+    except (PaymentConflict, PaymentError, PaymentRejected) as exc:
+        raise BookingPaymentError("booking payment flow was rejected") from exc
+    return str(flow["flow_id"])
+
+
+def create_or_reuse_stripe_flow(
+    connection: sqlite3.Connection,
+    backend: SiteBackend,
+    *,
+    account_id: str,
+    amount_minor: int,
+    fingerprint_value: str,
+) -> dict[str, Any]:
+    """Open the immutable server-priced flow used by Stripe test Checkout."""
+    _require_transaction(connection)
+    if payment_adapter(backend) != "stripe-test":
+        raise BookingPaymentError("Stripe test Checkout is not enabled")
+    try:
+        return backend.payments.create_intent(
+            owner=account_id,
+            amount_minor=int(amount_minor),
+            currency=CURRENCY,
+            fingerprint=fingerprint_value,
+            idempotency_key=flow_idempotency_key(fingerprint_value),
+            adapter="stripe-test",
+            connection=connection,
+        )
+    except (PaymentConflict, PaymentError, PaymentRejected) as exc:
+        raise BookingPaymentError("Stripe test payment flow was rejected") from exc
+
+
+def approve_verified_stripe(
+    connection: sqlite3.Connection,
+    backend: SiteBackend,
+    *,
+    flow_id: str,
+    account_id: str,
+    amount_minor: int,
+    fingerprint_value: str,
+    provider_session_id: str,
+    provider_snapshot: Mapping[str, Any],
+) -> str:
+    """Approve only a provider-verified, immutable Stripe test Session."""
+    _require_transaction(connection)
+    if payment_adapter(backend) != "stripe-test":
+        raise BookingPaymentError("Stripe test Checkout is not enabled")
+    try:
+        attempt = backend.payments.attempt_verified_stripe(
+            flow_id=flow_id,
+            owner=account_id,
+            amount_minor=int(amount_minor),
+            currency=CURRENCY,
+            fingerprint=fingerprint_value,
+            provider_session_id=provider_session_id,
+            idempotency_key=f"taskrabbit-stripe:{flow_id}:{provider_session_id}",
+            provider_verifier=lambda _session_id: provider_snapshot,
+            connection=connection,
+        )
+    except (PaymentConflict, PaymentError, PaymentRejected) as exc:
+        raise BookingPaymentError("Stripe test Session was rejected") from exc
+    return str(attempt["status"]).casefold()
+
+
+def attempt_local_payment(
+    connection: sqlite3.Connection,
+    backend: SiteBackend,
+    *,
+    flow_id: str,
+    account_id: str,
+    amount_minor: int,
+    fingerprint_value: str,
+    scenario_id: str,
+) -> str:
+    """Run one sandbox attempt; return the lowercased outcome.
+
+    Outcome is one of ``approved`` / ``declined`` / ``retryable``. The ledger
+    persists an APPROVED flow status that ``confirm_booking`` later consumes.
+    """
+    _require_transaction(connection)
+    if scenario_id not in scenario_ids(backend):
+        raise BookingPaymentError("unknown payment scenario")
+    try:
+        attempt = backend.payments.attempt(
+            flow_id=flow_id,
+            owner=account_id,
+            amount_minor=int(amount_minor),
+            currency=CURRENCY,
+            fingerprint=fingerprint_value,
+            scenario_id=scenario_id,
+            idempotency_key=f"taskrabbit-book-attempt:{flow_id}:{scenario_id}",
+            connection=connection,
+        )
+    except (PaymentConflict, PaymentError, PaymentRejected) as exc:
+        raise BookingPaymentError("local sandbox payment was rejected") from exc
+    return str(attempt["status"]).casefold()
+
+
+def consume_authorization(
+    connection: sqlite3.Connection,
+    backend: SiteBackend,
+    *,
+    flow_id: str,
+    account_id: str,
+    amount_minor: int,
+    fingerprint_value: str,
+) -> dict[str, Any]:
+    """Spend a previously-approved authorization inside the caller's txn.
+
+    Must be the first write of ``confirm_booking``'s transaction: a fact mismatch
+    forces the ledger to COMMIT + reopen the transaction, which would otherwise
+    discard sibling writes made before it.
+    """
+    _require_transaction(connection)
+    try:
+        return backend.payments.consume_approval(
+            connection,
+            flow_id=flow_id,
+            owner=account_id,
+            amount_minor=int(amount_minor),
+            currency=CURRENCY,
+            fingerprint=fingerprint_value,
+        )
+    except (PaymentConflict, PaymentError, PaymentRejected) as exc:
+        raise BookingPaymentError("booking payment authorization was rejected") from exc
+
+
+__all__ = [
+    "CURRENCY",
+    "ESTIMATED_HOURS",
+    "BookingPaymentError",
+    "approved_scenario_id",
+    "attempt_local_payment",
+    "approve_verified_stripe",
+    "consume_authorization",
+    "create_or_reuse_flow",
+    "create_or_reuse_stripe_flow",
+    "estimated_amount_minor",
+    "fingerprint",
+    "flow_idempotency_key",
+    "format_total",
+    "payment_adapter",
+    "payment_scenarios",
+    "scenario_ids",
+]

tasks/taskrabbit/solution/site/implementation/clone/backend/db.py

@@ -0,0 +1,1722 @@
+"""SQLite persistence layer for the TaskRabbit offline clone (R3 backend).
+
+Design contract (batch standard):
+  * sqlite3 in WAL mode, one site-local database file;
+  * the data directory comes from WEBSITEBENCH_DATA_DIR and defaults to
+    materials/taskrabbit/data -- it must NEVER live inside clone/;
+  * schema_migrations table plus ordered, append-only migrations;
+  * the server owns every business fact: booking categories, clients,
+    client address books (any syntactically valid US address is accepted),
+    the simulated Tasker roster with hourly rates, versioned availability
+    slots derived from the frozen clock by date arithmetic, wizard drafts,
+    and confirmed booking-request rows;
+  * sessions are persisted server-side (sessions table) so login state
+    survives a process restart;
+  * admin reset restores the seeded state deterministically.
+
+Generic source-site rules only: nothing in this module branches on a
+benchmark constant.  The seeded category, address, Tasker roster, and
+slots are ordinary rows; any other valid input books identically.
+Everything here is local simulation only -- no real Tasker, payment,
+chat, SMS, or fulfillment is ever involved and nothing contacts
+taskrabbit.com.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import sqlite3
+from collections.abc import Callable
+from contextlib import contextmanager
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Iterator
+
+from .task_catalog import CATEGORY_LABELS as TASK_CATALOG_CATEGORY_LABELS
+from .service_booking_catalog import (
+    CATEGORY_LABELS as SERVICE_BOOKING_CATEGORY_LABELS,
+)
+
+CLONE_DIR = Path(__file__).resolve().parents[1]
+SITE_DIR = CLONE_DIR.parent
+DEFAULT_DATA_DIR = SITE_DIR / "data"
+DB_FILENAME = "taskrabbit.sqlite3"
+SITE_ID = "taskrabbit"
+
+DATA_DIR_ENV = "WEBSITEBENCH_TASKRABBIT_DATA_DIR"
+SHARED_DATA_DIR_ENV = "WEBSITEBENCH_DATA_DIR"
+ADMIN_TOKEN_ENV = "WEBSITEBENCH_ADMIN_TOKEN"
+
+# ---- frozen clock and date arithmetic ---------------------------------------
+
+FROZEN_CLOCK = "2026-07-25T12:00:00-04:00"
+
+
+def frozen_now() -> datetime:
+    """The clone's frozen wall clock (never the host machine's real time)."""
+    return datetime.fromisoformat(FROZEN_CLOCK)
+
+
+def next_weekday(now: datetime, weekday: int) -> datetime:
+    """Next occurrence of *weekday* strictly after *now* (0=Mon .. 6=Sun)."""
+    days_ahead = (weekday - now.weekday()) % 7
+    if days_ahead == 0:
+        days_ahead = 7
+    return now + timedelta(days=days_ahead)
+
+
+def next_saturday(now: datetime | None = None) -> datetime:
+    return next_weekday(now or frozen_now(), 5)
+
+
+# 'Next Saturday' is computed by date arithmetic, never hardcoded.
+BOOKING_DATE = next_saturday().strftime("%Y-%m-%d")
+
+# ---- seed data (ordinary rows; not business rules) ---------------------------
+
+_CORE_CATEGORIES: tuple[tuple[str, str], ...] = (
+    ("help-moving", "Help Moving"),
+    ("furniture-assembly", "Furniture Assembly"),
+    ("patio-furniture-assembly", "Patio Furniture Assembly"),
+    ("desk-assembly", "Desk Assembly"),
+    ("dresser-assembly", "Dresser Assembly"),
+    ("bed-assembly", "Bed Assembly"),
+    ("bookshelf-assembly", "Bookshelf Assembly"),
+    ("couch-assembly", "Couch Assembly"),
+    ("chair-assembly", "Chair Assembly"),
+    ("wardrobe-assembly", "Wardrobe Assembly"),
+    ("table-assembly", "Table Assembly"),
+    ("disassemble-furniture", "Disassemble furniture"),
+)
+SEED_CATEGORIES: tuple[tuple[str, str], ...] = _CORE_CATEGORIES + tuple(
+    (category_id, label)
+    for category_id, label in TASK_CATALOG_CATEGORY_LABELS.items()
+    if category_id not in {item[0] for item in _CORE_CATEGORIES}
+) + tuple(SERVICE_BOOKING_CATEGORY_LABELS.items())
+CATEGORY_ID = SEED_CATEGORIES[0][0]
+CATEGORY_LABEL = SEED_CATEGORIES[0][1]
+KNOWN_CATEGORY_IDS = frozenset(category_id for category_id, _ in SEED_CATEGORIES)
+
+SEED_SIZES: tuple[tuple[str, str, str], ...] = (
+    ("studio", "size-v1", "Studio apartment"),
+    ("1-bedroom", "size-v1", "1-bedroom apartment"),
+    ("2-bedroom", "size-v1", "2-bedroom apartment"),
+    ("3-bedroom", "size-v1", "3-bedroom apartment"),
+    ("task-small", "task-size-v1", "Small task — about 1 hour"),
+    ("task-medium", "task-size-v1", "Medium task — about 2 hours"),
+    ("task-large", "task-size-v1", "Large task — 3 hours or more"),
+)
+APARTMENT_SIZE = "1-bedroom"
+APARTMENT_SIZE_VERSION = "size-v1"
+APARTMENT_LABEL = "1-bedroom apartment"
+TASK_TEMPLATE_ID = "help-moving-v1"
+
+
+def task_template_id_for_category(category_id: str) -> str:
+    """Resolve the server-owned task template for a known category."""
+    if category_id not in KNOWN_CATEGORY_IDS:
+        raise ValueError("unknown task category")
+    service_match = re.fullmatch(r"service-[1-9]\d*-([1-9]\d*)", category_id)
+    if service_match:
+        return f"source-task-template-{service_match.group(1)}-v1"
+    return f"{category_id}-v1"
+
+SESSION_ACCOUNT = "requester-morgan-001"
+FOREIGN_ACCOUNT = "requester-robin-002"
+TASKER_ACCOUNT = "tasker-taylor-001"
+SEED_CLIENTS: tuple[tuple[str, str, str], ...] = (
+    (SESSION_ACCOUNT, "Morgan Lee", "requester"),
+    (FOREIGN_ACCOUNT, "Robin Lee", "requester"),
+    (TASKER_ACCOUNT, "Taylor Tasker", "tasker"),
+)
+
+FIXTURE_ADDRESS_ID = "address-morgan-home"
+FIXTURE_ADDRESS = "482 Cedar Row, Apt 3, Brooklyn NY 11215"
+FOREIGN_ADDRESS_ID = "address-robin-home"
+FOREIGN_ADDRESS = "910 Birch Lane, Apt 5, Bronx NY 10457"
+SEED_ADDRESSES: tuple[dict[str, Any], ...] = (
+    {
+        "id": FIXTURE_ADDRESS_ID,
+        "owner": SESSION_ACCOUNT,
+        "street": "482 Cedar Row",
+        "unit": "Apt 3",
+        "city": "Brooklyn",
+        "state": "NY",
+        "zip": "11215",
+        "is_default": 1,
+    },
+    {
+        "id": FOREIGN_ADDRESS_ID,
+        "owner": FOREIGN_ACCOUNT,
+        "street": "910 Birch Lane",
+        "unit": "Apt 5",
+        "city": "Bronx",
+        "state": "NY",
+        "zip": "10457",
+        "is_default": 1,
+    },
+)
+
+DEFAULT_TASKER_ID = "tasker-sim-morgan"
+SEED_TASKERS: tuple[dict[str, Any], ...] = (
+    {
+        "id": "tasker-sim-alex",
+        "provider_version": "provider-alex-v1",
+        "name": "Alex R. (Simulated)",
+        "rate": 52,
+        "rating": "4.9",
+        "reviews": 128,
+        "blurb": "Fixture profile: two-person moves, walk-ups, careful wrapping.",
+        "profile_variant": "rich",
+        "availability_state": "available",
+    },
+    {
+        "id": "tasker-sim-morgan",
+        "provider_version": "provider-morgan-v1",
+        "name": "Morgan K. (Simulated)",
+        "rate": 47,
+        "rating": "",
+        "reviews": 0,
+        "blurb": "",
+        "profile_variant": "sparse",
+        "availability_state": "available",
+    },
+    {
+        "id": "tasker-sim-riley",
+        "provider_version": "provider-riley-v1",
+        "name": "Riley S. (Simulated)",
+        "rate": 61,
+        "rating": "",
+        "reviews": 0,
+        "blurb": "",
+        "profile_variant": "unavailable",
+        "availability_state": "no-compatible-slot",
+    },
+)
+
+# Two availability slots on the arithmetically derived next Saturday.
+WINDOW_START = "09:00"
+WINDOW_END = "13:00"
+BOOKING_WINDOW = f"{WINDOW_START}-{WINDOW_END}"
+SLOT_ID = f"slot-{BOOKING_DATE}-0900"
+SLOT_VERSION = f"slot-v7-{BOOKING_DATE}-0900"
+ALT_WINDOW_START = "14:00"
+ALT_WINDOW_END = "18:00"
+ALT_WINDOW = f"{ALT_WINDOW_START}-{ALT_WINDOW_END}"
+ALT_SLOT_ID = f"slot-{BOOKING_DATE}-1400"
+ALT_SLOT_VERSION = f"slot-v3-{BOOKING_DATE}-1400"
+SEED_SLOTS: tuple[dict[str, str], ...] = (
+    {
+        "id": SLOT_ID,
+        "version": SLOT_VERSION,
+        "date": BOOKING_DATE,
+        "window_start": WINDOW_START,
+        "window_end": WINDOW_END,
+    },
+    {
+        "id": ALT_SLOT_ID,
+        "version": ALT_SLOT_VERSION,
+        "date": BOOKING_DATE,
+        "window_start": ALT_WINDOW_START,
+        "window_end": ALT_WINDOW_END,
+    },
+)
+
+SEED_DRAFT_REF = "request-000001"
+REQUEST_ID = SEED_DRAFT_REF
+BOOKING_ID = "booking-000001"
+FOREIGN_BOOKING_ID = "trbk-foreign-9999"
+FOREIGN_REQUEST_ID = "request-foreign-9999"
+
+BOOKING_STATUS_OPEN = "open"
+CONFIRM_MERGE_KEY_FIELDS = (
+    "idempotency_token",
+    "owner_id",
+    "session_id",
+    "request_id",
+    "request_version",
+    "category_id",
+    "task_template_id",
+    "apartment_size_id",
+    "apartment_size_version",
+    "address_id",
+    "service_date",
+    "window_start",
+    "window_end",
+    "provider_id",
+    "provider_version",
+    "quote_id",
+    "quote_version",
+    "quote_owner_id",
+    "slot_id",
+    "slot_version",
+    "payment_flow_id",
+)
+
+# ---- ordered migrations -----------------------------------------------------
+
+MIGRATIONS: tuple[tuple[int, str, tuple[str, ...]], ...] = (
+    (
+        1,
+        "0001-core-domain-schema",
+        (
+            """
+            CREATE TABLE categories (
+                id TEXT PRIMARY KEY,
+                label TEXT NOT NULL
+            )
+            """,
+            """
+            CREATE TABLE apartment_sizes (
+                id TEXT PRIMARY KEY,
+                label TEXT NOT NULL
+            )
+            """,
+            """
+            CREATE TABLE clients (
+                id TEXT PRIMARY KEY,
+                display_name TEXT NOT NULL
+            )
+            """,
+            """
+            CREATE TABLE addresses (
+                id TEXT PRIMARY KEY,
+                owner TEXT NOT NULL REFERENCES clients(id),
+                street TEXT NOT NULL,
+                unit TEXT NOT NULL DEFAULT '',
+                city TEXT NOT NULL,
+                state TEXT NOT NULL,
+                zip TEXT NOT NULL,
+                is_default INTEGER NOT NULL DEFAULT 0,
+                fictional INTEGER NOT NULL DEFAULT 1
+            )
+            """,
+            """
+            CREATE TABLE taskers (
+                id TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                rate INTEGER NOT NULL,
+                rating TEXT NOT NULL,
+                reviews INTEGER NOT NULL,
+                blurb TEXT NOT NULL,
+                simulated INTEGER NOT NULL DEFAULT 1
+            )
+            """,
+            """
+            CREATE TABLE slots (
+                id TEXT PRIMARY KEY,
+                version TEXT NOT NULL UNIQUE,
+                date TEXT NOT NULL,
+                window_start TEXT NOT NULL,
+                window_end TEXT NOT NULL
+            )
+            """,
+            """
+            CREATE TABLE tasker_availability (
+                tasker_id TEXT NOT NULL REFERENCES taskers(id),
+                slot_id TEXT NOT NULL REFERENCES slots(id),
+                PRIMARY KEY (tasker_id, slot_id)
+            )
+            """,
+            """
+            CREATE TABLE wizard_drafts (
+                owner TEXT PRIMARY KEY REFERENCES clients(id),
+                booking_ref TEXT NOT NULL UNIQUE,
+                category TEXT,
+                apartment_size TEXT,
+                address_id TEXT,
+                slot_id TEXT,
+                tasker_id TEXT,
+                draft_version INTEGER NOT NULL DEFAULT 1,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            )
+            """,
+            """
+            CREATE TABLE bookings (
+                id TEXT PRIMARY KEY,
+                owner TEXT NOT NULL REFERENCES clients(id),
+                category TEXT NOT NULL,
+                apartment_size TEXT NOT NULL,
+                tasker_id TEXT NOT NULL REFERENCES taskers(id),
+                slot_id TEXT NOT NULL,
+                slot_version TEXT NOT NULL,
+                date TEXT NOT NULL,
+                window TEXT NOT NULL,
+                address TEXT NOT NULL,
+                status TEXT NOT NULL DEFAULT 'open',
+                created_at TEXT NOT NULL
+            )
+            """,
+            """
+            CREATE TABLE sequences (
+                name TEXT PRIMARY KEY,
+                value INTEGER NOT NULL
+            )
+            """,
+        ),
+    ),
+    (
+        2,
+        "0002-persistent-sessions-and-open-booking-guard",
+        (
+            """
+            CREATE TABLE sessions (
+                token TEXT PRIMARY KEY,
+                account TEXT NOT NULL REFERENCES clients(id),
+                created_at TEXT NOT NULL
+            )
+            """,
+            """
+            CREATE UNIQUE INDEX idx_bookings_one_open_per_client_tasker
+            ON bookings(owner, tasker_id) WHERE status = 'open'
+            """,
+        ),
+    ),
+    (
+        3,
+        "0003-explicit-provider-profile-and-availability-variants",
+        (
+            """
+            ALTER TABLE taskers
+            ADD COLUMN provider_version TEXT NOT NULL DEFAULT 'provider-v1'
+            """,
+            """
+            ALTER TABLE taskers
+            ADD COLUMN profile_variant TEXT NOT NULL DEFAULT 'rich'
+            """,
+            """
+            ALTER TABLE taskers
+            ADD COLUMN availability_state TEXT NOT NULL DEFAULT 'available'
+            """,
+        ),
+    ),
+    (
+        4,
+        "0004-request-identity-replaces-owner-provider-merge",
+        (
+            """
+            DROP INDEX IF EXISTS idx_bookings_one_open_per_client_tasker
+            """,
+        ),
+    ),
+    (
+        5,
+        "0005-post-confirm-booking-and-versioned-apartment-size",
+        (
+            """
+            ALTER TABLE apartment_sizes
+            ADD COLUMN version TEXT NOT NULL DEFAULT 'size-v1'
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN request_id TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN request_version TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN task_template_id TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN apartment_size_version TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN address_id TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN provider_version TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN quote_id TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN quote_version TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN quote_owner_id TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN session_id TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN idempotency_token TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN receipt_id TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN merge_key_json TEXT
+            """,
+            """
+            CREATE UNIQUE INDEX idx_bookings_request_identity
+            ON bookings(request_id) WHERE request_id IS NOT NULL
+            """,
+            """
+            CREATE UNIQUE INDEX idx_bookings_idempotency_token
+            ON bookings(idempotency_token) WHERE idempotency_token IS NOT NULL
+            """,
+        ),
+    ),
+    (
+        6,
+        "0006-server-price-snapshot-and-opaque-auth-only",
+        (
+            """
+            ALTER TABLE bookings ADD COLUMN hourly_rate INTEGER
+            """,
+            """
+            DROP TABLE IF EXISTS sessions
+            """,
+        ),
+    ),
+    (
+        7,
+        "0007-role-authority-and-booking-command-journal",
+        (
+            """
+            ALTER TABLE clients
+            ADD COLUMN role TEXT NOT NULL DEFAULT 'requester'
+            """,
+            """
+            CREATE TABLE booking_workflow_commands (
+                command_id TEXT PRIMARY KEY,
+                owner_id TEXT NOT NULL REFERENCES clients(id),
+                resolved_role TEXT NOT NULL,
+                idempotency_key TEXT NOT NULL,
+                payload_digest TEXT NOT NULL,
+                operation_kind TEXT NOT NULL,
+                entity_id TEXT NOT NULL,
+                expected_version TEXT NOT NULL,
+                status TEXT NOT NULL,
+                outcome_booking_id TEXT NOT NULL REFERENCES bookings(id),
+                canonical_outcome_json TEXT NOT NULL,
+                outcome_digest TEXT NOT NULL,
+                committed_at TEXT NOT NULL,
+                UNIQUE(owner_id, idempotency_key)
+            )
+            """,
+            """
+            CREATE TABLE booking_workflow_version_journal (
+                entity_id TEXT NOT NULL,
+                version INTEGER NOT NULL,
+                command_id TEXT NOT NULL
+                    REFERENCES booking_workflow_commands(command_id),
+                prior_version INTEGER NOT NULL,
+                booking_id TEXT NOT NULL REFERENCES bookings(id),
+                outcome_digest TEXT NOT NULL,
+                committed_at TEXT NOT NULL,
+                PRIMARY KEY(entity_id, version)
+            )
+            """,
+            """
+            ALTER TABLE bookings
+            ADD COLUMN command_id TEXT
+            """,
+            """
+            ALTER TABLE bookings
+            ADD COLUMN committed_version INTEGER
+            """,
+            """
+            CREATE UNIQUE INDEX idx_bookings_command_id
+            ON bookings(command_id) WHERE command_id IS NOT NULL
+            """,
+        ),
+    ),
+    (
+        8,
+        "0008-offline-sandbox-booking-payment",
+        (
+            # One authorized offline-sandbox payment binds to one draft; the
+            # shared ledger (websitebench_payment_flows/attempts) lives in this
+            # same database, created by SiteBackend before these migrations run.
+            """
+            ALTER TABLE wizard_drafts ADD COLUMN payment_flow_id TEXT
+            """,
+            """
+            ALTER TABLE wizard_drafts ADD COLUMN payment_amount_minor INTEGER
+            """,
+            """
+            ALTER TABLE wizard_drafts ADD COLUMN payment_currency TEXT
+            """,
+            """
+            ALTER TABLE wizard_drafts ADD COLUMN payment_fingerprint TEXT
+            """,
+            """
+            ALTER TABLE wizard_drafts ADD COLUMN payment_status TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN payment_flow_id TEXT
+            """,
+            """
+            ALTER TABLE bookings ADD COLUMN amount_minor INTEGER
+            """,
+        ),
+    ),
+)
+MIGRATION_HEAD = MIGRATIONS[-1][1]
+
+DRAFT_FIELDS = (
+    "category",
+    "apartment_size",
+    "address_id",
+    "slot_id",
+    "tasker_id",
+)
+
+# ---- environment / connection helpers ---------------------------------------
+
+
+def admin_token() -> str | None:
+    token = os.environ.get(ADMIN_TOKEN_ENV, "").strip()
+    return token or None
+
+
+def resolve_data_dir(value: str | os.PathLike[str] | None = None) -> Path:
+    raw = (
+        value
+        or os.environ.get(DATA_DIR_ENV)
+        or os.environ.get(SHARED_DATA_DIR_ENV)
+        or DEFAULT_DATA_DIR
+    )
+    path = Path(raw).resolve()
+    clone = CLONE_DIR.resolve()
+    if path == clone or clone in path.parents:
+        raise ValueError(
+            "the persistent data directory must never live inside clone/"
+        )
+    return path
+
+
+def connect(db_file: str | os.PathLike[str]) -> sqlite3.Connection:
+    conn = sqlite3.connect(str(db_file), timeout=30)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA busy_timeout=10000")
+    conn.execute("PRAGMA foreign_keys=ON")
+    return conn
+
+
+@contextmanager
+def session(
+    db_file: str | os.PathLike[str],
+    *,
+    immediate: bool = False,
+) -> Iterator[sqlite3.Connection]:
+    conn = connect(db_file)
+    try:
+        if immediate:
+            conn.execute("BEGIN IMMEDIATE")
+        yield conn
+        conn.commit()
+    except BaseException:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+# ---- migrations -------------------------------------------------------------
+
+
+def _ensure_migrations_table(conn: sqlite3.Connection) -> None:
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS schema_migrations (
+            version INTEGER PRIMARY KEY,
+            name TEXT NOT NULL UNIQUE,
+            applied_at TEXT NOT NULL
+        )
+        """
+    )
+
+
+def applied_versions(conn: sqlite3.Connection) -> list[int]:
+    _ensure_migrations_table(conn)
+    rows = conn.execute(
+        "SELECT version FROM schema_migrations ORDER BY version"
+    ).fetchall()
+    return [row["version"] for row in rows]
+
+
+def migration_head(conn: sqlite3.Connection) -> str | None:
+    _ensure_migrations_table(conn)
+    row = conn.execute(
+        "SELECT name FROM schema_migrations ORDER BY version DESC LIMIT 1"
+    ).fetchone()
+    return row["name"] if row else None
+
+
+def apply_migrations(
+    conn: sqlite3.Connection, *, upto: int | None = None
+) -> str | None:
+    """Apply every pending migration in order (optionally capped at *upto*)."""
+    _ensure_migrations_table(conn)
+    applied = set(applied_versions(conn))
+    for version, name, statements in MIGRATIONS:
+        if version in applied:
+            continue
+        if upto is not None and version > upto:
+            break
+        for statement in statements:
+            conn.execute(statement)
+        if version == 7:
+            _backfill_booking_command_history(conn)
+        conn.execute(
+            "INSERT INTO schema_migrations (version, name, applied_at)"
+            " VALUES (?, ?, ?)",
+            (version, name, FROZEN_CLOCK),
+        )
+    applied_head = max(applied_versions(conn), default=0)
+    conn.execute(f"PRAGMA user_version = {applied_head}")
+    return migration_head(conn)
+
+
+def _canonical_json(value: Any) -> str:
+    return json.dumps(
+        value,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    )
+
+
+def _digest_json(value: Any) -> str:
+    return hashlib.sha256(_canonical_json(value).encode("utf-8")).hexdigest()
+
+
+def _backfill_booking_command_history(conn: sqlite3.Connection) -> None:
+    """Give pre-0007 committed bookings explicit immutable command history."""
+    table = conn.execute(
+        "SELECT 1 FROM sqlite_master WHERE type='table' "
+        "AND name='booking_workflow_commands'"
+    ).fetchone()
+    if table is None:
+        return
+    rows = conn.execute(
+        "SELECT * FROM bookings ORDER BY id"
+    ).fetchall()
+    for row in rows:
+        booking = dict(row)
+        entity_id = str(booking.get("request_id") or booking["id"])
+        idempotency_key = str(
+            booking.get("idempotency_token")
+            or f"migrated-{booking['id']}"
+        )
+        try:
+            payload = json.loads(str(booking.get("merge_key_json") or "{}"))
+        except json.JSONDecodeError:
+            payload = {"legacy_merge_key": str(booking.get("merge_key_json"))}
+        payload_digest = _digest_json(payload)
+        outcome = {
+            "booking_id": str(booking["id"]),
+            "receipt_id": str(
+                booking.get("receipt_id") or f"receipt-{booking['id']}"
+            ),
+            "result": "committed",
+        }
+        outcome_json = _canonical_json(outcome)
+        outcome_digest = hashlib.sha256(outcome_json.encode("utf-8")).hexdigest()
+        command_id = f"command-migrated-{booking['id']}"
+        conn.execute(
+            "INSERT OR IGNORE INTO booking_workflow_commands"
+            " (command_id, owner_id, resolved_role, idempotency_key,"
+            "  payload_digest, operation_kind, entity_id, expected_version,"
+            "  status, outcome_booking_id, canonical_outcome_json,"
+            "  outcome_digest, committed_at)"
+            " VALUES (?, ?, 'requester', ?, ?, 'legacy-confirm', ?, ?,"
+            "  'committed', ?, ?, ?, ?)",
+            (
+                command_id,
+                str(booking["owner"]),
+                idempotency_key,
+                payload_digest,
+                entity_id,
+                str(booking.get("request_version") or "legacy"),
+                str(booking["id"]),
+                outcome_json,
+                outcome_digest,
+                str(booking.get("created_at") or FROZEN_CLOCK),
+            ),
+        )
+        conn.execute(
+            "INSERT OR IGNORE INTO booking_workflow_version_journal"
+            " (entity_id, version, command_id, prior_version,"
+            "  booking_id, outcome_digest, committed_at)"
+            " VALUES (?, 1, ?, 0, ?, ?, ?)",
+            (
+                entity_id,
+                command_id,
+                str(booking["id"]),
+                outcome_digest,
+                str(booking.get("created_at") or FROZEN_CLOCK),
+            ),
+        )
+        conn.execute(
+            "UPDATE bookings SET command_id = ?, committed_version = 1 "
+            "WHERE id = ? AND command_id IS NULL",
+            (command_id, str(booking["id"])),
+        )
+
+
+# ---- seed / reset -----------------------------------------------------------
+
+
+def seed(conn: sqlite3.Connection) -> dict[str, int]:
+    """Idempotently insert the deterministic seed rows (fixed IDs)."""
+    before = conn.total_changes
+    for category_id, label in SEED_CATEGORIES:
+        conn.execute(
+            "INSERT OR IGNORE INTO categories (id, label) VALUES (?, ?)",
+            (category_id, label),
+        )
+    for size_id, version, label in SEED_SIZES:
+        conn.execute(
+            "INSERT OR IGNORE INTO apartment_sizes (id, label, version)"
+            " VALUES (?, ?, ?)",
+            (size_id, label, version),
+        )
+    for client_id, display_name, role in SEED_CLIENTS:
+        conn.execute(
+            "INSERT OR IGNORE INTO clients (id, display_name, role)"
+            " VALUES (?, ?, ?)",
+            (client_id, display_name, role),
+        )
+    for address in SEED_ADDRESSES:
+        conn.execute(
+            "INSERT OR IGNORE INTO addresses"
+            " (id, owner, street, unit, city, state, zip, is_default,"
+            "  fictional)"
+            " VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1)",
+            (
+                address["id"],
+                address["owner"],
+                address["street"],
+                address["unit"],
+                address["city"],
+                address["state"],
+                address["zip"],
+                address["is_default"],
+            ),
+        )
+    for tasker in SEED_TASKERS:
+        conn.execute(
+            "INSERT OR IGNORE INTO taskers"
+            " (id, name, rate, rating, reviews, blurb, simulated,"
+            "  provider_version, profile_variant, availability_state)"
+            " VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?, ?)",
+            (
+                tasker["id"],
+                tasker["name"],
+                tasker["rate"],
+                tasker["rating"],
+                tasker["reviews"],
+                tasker["blurb"],
+                tasker["provider_version"],
+                tasker["profile_variant"],
+                tasker["availability_state"],
+            ),
+        )
+    for slot in SEED_SLOTS:
+        conn.execute(
+            "INSERT OR IGNORE INTO slots"
+            " (id, version, date, window_start, window_end)"
+            " VALUES (?, ?, ?, ?, ?)",
+            (
+                slot["id"],
+                slot["version"],
+                slot["date"],
+                slot["window_start"],
+                slot["window_end"],
+            ),
+        )
+    for tasker in SEED_TASKERS:
+        if tasker["availability_state"] != "available":
+            continue
+        for slot in SEED_SLOTS:
+            conn.execute(
+                "INSERT OR IGNORE INTO tasker_availability"
+                " (tasker_id, slot_id) VALUES (?, ?)",
+                (tasker["id"], slot["id"]),
+            )
+    # The seed client's wizard draft is an ordinary seed row capturing a
+    # completed wizard journey (category, size, address, slot) so the
+    # review/confirm surface is reachable immediately after a reset.
+    conn.execute(
+        "INSERT OR IGNORE INTO wizard_drafts"
+        " (owner, booking_ref, category, apartment_size, address_id,"
+        "  slot_id, draft_version, created_at, updated_at)"
+        " VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)",
+        (
+            SESSION_ACCOUNT,
+            SEED_DRAFT_REF,
+            CATEGORY_ID,
+            APARTMENT_SIZE,
+            FIXTURE_ADDRESS_ID,
+            SLOT_ID,
+            FROZEN_CLOCK,
+            FROZEN_CLOCK,
+        ),
+    )
+    # A foreign-owned booking row so cross-account isolation is a real,
+    # database-backed refusal instead of a hard-coded page.
+    conn.execute(
+        "INSERT OR IGNORE INTO bookings"
+        " (id, owner, category, apartment_size, tasker_id, slot_id,"
+        "  slot_version, date, window, address, status, created_at,"
+        "  hourly_rate)"
+        " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        (
+            FOREIGN_BOOKING_ID,
+            FOREIGN_ACCOUNT,
+            CATEGORY_ID,
+            APARTMENT_SIZE,
+            "tasker-sim-alex",
+            SLOT_ID,
+            SLOT_VERSION,
+            BOOKING_DATE,
+            BOOKING_WINDOW,
+            FOREIGN_ADDRESS,
+            BOOKING_STATUS_OPEN,
+            FROZEN_CLOCK,
+            52,
+        ),
+    )
+    conn.execute(
+        "UPDATE bookings SET request_id = ?, request_version = ?,"
+        " task_template_id = ?, apartment_size_version = ?, address_id = ?,"
+        " provider_version = ?, quote_id = ?, quote_version = ?,"
+        " quote_owner_id = ?, session_id = ?, idempotency_token = ?,"
+        " receipt_id = ?, merge_key_json = ? WHERE id = ?",
+        (
+            FOREIGN_REQUEST_ID,
+            "request-v1",
+            TASK_TEMPLATE_ID,
+            APARTMENT_SIZE_VERSION,
+            FOREIGN_ADDRESS_ID,
+            "provider-alex-v1",
+            f"quote-tasker-sim-alex-{FOREIGN_REQUEST_ID}",
+            "quote-v1",
+            FOREIGN_ACCOUNT,
+            "session-robin-seed",
+            f"idem-{FOREIGN_REQUEST_ID}-request-v1",
+            f"receipt-{FOREIGN_BOOKING_ID}",
+            "{}",
+            FOREIGN_BOOKING_ID,
+        ),
+    )
+    _backfill_booking_command_history(conn)
+    for name in ("booking_ref", "booking", "address", "command"):
+        conn.execute(
+            "INSERT OR IGNORE INTO sequences (name, value) VALUES (?, 0)",
+            (name,),
+        )
+    return {"rows_inserted": conn.total_changes - before}
+
+
+def reset_state(conn: sqlite3.Connection) -> dict[str, int]:
+    """Admin reset: wipe all mutable state, then restore the exact seed."""
+    table_names = {
+        str(row["name"])
+        for row in conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='table'"
+        ).fetchall()
+    }
+    auth_tables = {
+        name for name in table_names if name.startswith("local_auth_")
+    }
+    if "websitebench_payment_events" in table_names:
+        # Payment events are immutable in ordinary application transactions.
+        # The token-protected benchmark reset is the sole lifecycle boundary
+        # allowed to rebuild the deterministic local fixture from zero.
+        conn.execute("DROP TRIGGER IF EXISTS websitebench_payment_events_no_delete")
+    counts = {
+        "payment_events_deleted": (
+            conn.execute("DELETE FROM websitebench_payment_events").rowcount
+            if "websitebench_payment_events" in table_names
+            else 0
+        ),
+        "payment_attempts_deleted": (
+            conn.execute("DELETE FROM websitebench_payment_attempts").rowcount
+            if "websitebench_payment_attempts" in table_names
+            else 0
+        ),
+        "payment_flows_deleted": (
+            conn.execute("DELETE FROM websitebench_payment_flows").rowcount
+            if "websitebench_payment_flows" in table_names
+            else 0
+        ),
+        "booking_version_journal_deleted": conn.execute(
+            "DELETE FROM booking_workflow_version_journal"
+        ).rowcount,
+        "booking_commands_deleted": conn.execute(
+            "DELETE FROM booking_workflow_commands"
+        ).rowcount,
+        "bookings_deleted": conn.execute("DELETE FROM bookings").rowcount,
+        "wizard_drafts_deleted": conn.execute(
+            "DELETE FROM wizard_drafts"
+        ).rowcount,
+        "auth_sessions_deleted": (
+            conn.execute("DELETE FROM local_auth_sessions").rowcount
+            if "local_auth_sessions" in auth_tables
+            else 0
+        ),
+        "auth_registration_flows_deleted": (
+            conn.execute("DELETE FROM local_auth_registration_flows").rowcount
+            if "local_auth_registration_flows" in auth_tables
+            else 0
+        ),
+        "auth_password_reset_flows_deleted": (
+            conn.execute("DELETE FROM local_auth_password_reset_flows").rowcount
+            if "local_auth_password_reset_flows" in auth_tables
+            else 0
+        ),
+        "auth_mail_deleted": (
+            conn.execute("DELETE FROM local_auth_mail_outbox").rowcount
+            if "local_auth_mail_outbox" in auth_tables
+            else 0
+        ),
+        "auth_rate_limits_deleted": (
+            conn.execute("DELETE FROM local_auth_mail_rate_limits").rowcount
+            if "local_auth_mail_rate_limits" in auth_tables
+            else 0
+        ),
+        "auth_nonseed_accounts_deleted": (
+            conn.execute(
+                "DELETE FROM local_auth_accounts "
+                "WHERE subject_id NOT IN (?, ?, ?)",
+                (SESSION_ACCOUNT, FOREIGN_ACCOUNT, TASKER_ACCOUNT),
+            ).rowcount
+            if "local_auth_accounts" in auth_tables
+            else 0
+        ),
+        "addresses_deleted": conn.execute("DELETE FROM addresses").rowcount,
+        "tasker_availability_deleted": conn.execute(
+            "DELETE FROM tasker_availability"
+        ).rowcount,
+        "taskers_deleted": conn.execute("DELETE FROM taskers").rowcount,
+        "slots_deleted": conn.execute("DELETE FROM slots").rowcount,
+    }
+    if "websitebench_payment_events" in table_names:
+        conn.execute(
+            "CREATE TRIGGER websitebench_payment_events_no_delete "
+            "BEFORE DELETE ON websitebench_payment_events BEGIN "
+            "SELECT RAISE(ABORT, 'payment events are immutable'); END"
+        )
+    counts["registered_clients_deleted"] = conn.execute(
+        "DELETE FROM clients WHERE id NOT IN (?, ?, ?)",
+        (SESSION_ACCOUNT, FOREIGN_ACCOUNT, TASKER_ACCOUNT),
+    ).rowcount
+    conn.execute("DELETE FROM sequences")
+    seeded = seed(conn)
+    counts["seed_rows_inserted"] = seeded["rows_inserted"]
+    return counts
+
+
+def init_db(data_dir: str | os.PathLike[str] | None = None) -> Path:
+    """Resolve the data dir, migrate to head, seed, and return the db file."""
+    directory = resolve_data_dir(data_dir)
+    directory.mkdir(parents=True, exist_ok=True)
+    db_file = directory / DB_FILENAME
+    if db_file.is_file() and db_file.stat().st_size > 0:
+        uri = f"{db_file.resolve().as_uri()}?mode=ro"
+        with sqlite3.connect(uri, uri=True) as inspection:
+            legacy = inspection.execute(
+                "SELECT 1 FROM sqlite_master WHERE type='table' "
+                "AND name='clawbench_site_binding'"
+            ).fetchone()
+            if legacy is not None:
+                raise RuntimeError(
+                    "Taskrabbit database uses the legacy binding namespace"
+                )
+            canonical = inspection.execute(
+                "SELECT 1 FROM sqlite_master WHERE type='table' "
+                "AND name='websitebench_site_binding'"
+            ).fetchone()
+            if canonical is None:
+                raise RuntimeError(
+                    "Taskrabbit database is unbound; copy-only migration is required"
+                )
+            bindings = inspection.execute(
+                "SELECT singleton,site_id FROM websitebench_site_binding"
+            ).fetchall()
+            if (
+                len(bindings) != 1
+                or int(bindings[0][0]) != 1
+                or str(bindings[0][1]) != SITE_ID
+            ):
+                raise RuntimeError("Taskrabbit database has a foreign site binding")
+    with session(db_file) as conn:
+        conn.execute(
+            "CREATE TABLE IF NOT EXISTS websitebench_site_binding("
+            "singleton INTEGER PRIMARY KEY CHECK(singleton=1),"
+            "site_id TEXT NOT NULL UNIQUE,bound_at TEXT NOT NULL)"
+        )
+        bindings = conn.execute(
+            "SELECT singleton,site_id FROM websitebench_site_binding"
+        ).fetchall()
+        if not bindings:
+            conn.execute(
+                "INSERT INTO websitebench_site_binding"
+                "(singleton,site_id,bound_at) VALUES (1,?,?)",
+                (SITE_ID, FROZEN_CLOCK),
+            )
+        elif (
+            len(bindings) != 1
+            or int(bindings[0]["singleton"]) != 1
+            or str(bindings[0]["site_id"]) != SITE_ID
+        ):
+            raise RuntimeError("Taskrabbit database has a foreign site binding")
+        apply_migrations(conn)
+        seed(conn)
+    return db_file
+
+
+# ---- sequences ----------------------------------------------------------------
+
+
+def next_sequence(conn: sqlite3.Connection, name: str) -> int:
+    conn.execute(
+        "INSERT OR IGNORE INTO sequences (name, value) VALUES (?, 0)", (name,)
+    )
+    conn.execute(
+        "UPDATE sequences SET value = value + 1 WHERE name = ?", (name,)
+    )
+    row = conn.execute(
+        "SELECT value FROM sequences WHERE name = ?", (name,)
+    ).fetchone()
+    return int(row["value"])
+
+
+# ---- catalog reads ------------------------------------------------------------
+
+
+def get_category(conn: sqlite3.Connection, category_id: str) -> dict[str, Any] | None:
+    row = conn.execute(
+        "SELECT * FROM categories WHERE id = ?", (category_id,)
+    ).fetchone()
+    return dict(row) if row else None
+
+
+def get_size(conn: sqlite3.Connection, size_id: str) -> dict[str, Any] | None:
+    row = conn.execute(
+        "SELECT * FROM apartment_sizes WHERE id = ?", (size_id,)
+    ).fetchone()
+    return dict(row) if row else None
+
+
+def get_client(conn: sqlite3.Connection, client_id: str) -> dict[str, Any] | None:
+    row = conn.execute(
+        "SELECT * FROM clients WHERE id = ?", (client_id,)
+    ).fetchone()
+    return dict(row) if row else None
+
+
+def list_taskers(conn: sqlite3.Connection) -> list[dict[str, Any]]:
+    rows = conn.execute(
+        "SELECT * FROM taskers WHERE simulated = 1 ORDER BY id"
+    ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def get_tasker(conn: sqlite3.Connection, tasker_id: str) -> dict[str, Any] | None:
+    row = conn.execute(
+        "SELECT * FROM taskers WHERE id = ?", (tasker_id,)
+    ).fetchone()
+    return dict(row) if row else None
+
+
+# ---- availability slots (versioned, frozen-clock derived) ----------------------
+
+
+def slot_start(slot: dict[str, Any]) -> datetime:
+    """Slot start as an aware datetime in the frozen clock's timezone."""
+    tz = frozen_now().tzinfo or timezone(timedelta(hours=-4))
+    return datetime.fromisoformat(
+        f"{slot['date']}T{slot['window_start']}:00"
+    ).replace(tzinfo=tz)
+
+
+def slot_is_past(slot: dict[str, Any]) -> bool:
+    return slot_start(slot) <= frozen_now()
+
+
+def list_slots(conn: sqlite3.Connection) -> list[dict[str, Any]]:
+    rows = conn.execute(
+        "SELECT * FROM slots ORDER BY date, window_start"
+    ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def list_open_slots(conn: sqlite3.Connection) -> list[dict[str, Any]]:
+    return [slot for slot in list_slots(conn) if not slot_is_past(slot)]
+
+
+def get_slot(conn: sqlite3.Connection, slot_id: str) -> dict[str, Any] | None:
+    row = conn.execute("SELECT * FROM slots WHERE id = ?", (slot_id,)).fetchone()
+    return dict(row) if row else None
+
+
+def find_slot(
+    conn: sqlite3.Connection, date: str, window: str
+) -> dict[str, Any] | None:
+    start, _, end = window.partition("-")
+    row = conn.execute(
+        "SELECT * FROM slots WHERE date = ? AND window_start = ?"
+        " AND window_end = ?",
+        (date, start, end),
+    ).fetchone()
+    return dict(row) if row else None
+
+
+def tasker_available(
+    conn: sqlite3.Connection, tasker_id: str, slot_id: str
+) -> bool:
+    row = conn.execute(
+        "SELECT 1 FROM tasker_availability WHERE tasker_id = ? AND slot_id = ?",
+        (tasker_id, slot_id),
+    ).fetchone()
+    return row is not None
+
+
+# ---- addresses (generic US-address validation) ---------------------------------
+
+_STREET_RE = re.compile(r"^\d+[A-Za-z]?\s+[A-Za-z0-9][A-Za-z0-9 .'-]*$")
+_CITY_RE = re.compile(r"^[A-Za-z][A-Za-z .'-]*$")
+_ZIP_RE = re.compile(r"^\d{5}(?:-\d{4})?$")
+US_STATES = {
+    "AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "DC", "FL", "GA", "HI",
+    "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD", "MA", "MI", "MN",
+    "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND", "OH",
+    "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "WA",
+    "WV", "WI", "WY",
+}
+
+_ADDRESS_TAIL_RE = re.compile(
+    r"^([A-Za-z][A-Za-z .'-]*?)\s+([A-Za-z]{2})\s+(\d{5}(?:-\d{4})?)$"
+)
+
+
+def validate_us_address(
+    street: str, unit: str, city: str, state: str, zip_code: str
+) -> list[str]:
+    """Generic syntactic validation for any US address (no allow-list)."""
+    errors: list[str] = []
+    if not _STREET_RE.match(street.strip()):
+        errors.append(
+            "Street must look like a US street line, e.g. '482 Cedar Row'."
+        )
+    if unit and not re.match(r"^[A-Za-z0-9 #.-]+$", unit.strip()):
+        errors.append("Unit may only contain letters, digits, #, ., or -.")
+    if not _CITY_RE.match(city.strip()):
+        errors.append("City must be a plausible US city name.")
+    if state.strip().upper() not in US_STATES:
+        errors.append("State must be a valid two-letter US state code.")
+    if not _ZIP_RE.match(zip_code.strip()):
+        errors.append("ZIP must be a 5-digit US ZIP code (ZIP+4 allowed).")
+    return errors
+
+
+def parse_address_line(line: str) -> dict[str, str] | None:
+    """Parse 'street[, unit], City ST 12345' into address parts, or None."""
+    parts = [part.strip() for part in line.split(",") if part.strip()]
+    if len(parts) < 2 or len(parts) > 3:
+        return None
+    tail = _ADDRESS_TAIL_RE.match(parts[-1])
+    if tail is None:
+        return None
+    return {
+        "street": parts[0],
+        "unit": parts[1] if len(parts) == 3 else "",
+        "city": tail.group(1),
+        "state": tail.group(2).upper(),
+        "zip": tail.group(3),
+    }
+
+
+def address_label(address: dict[str, Any]) -> str:
+    parts = [str(address["street"])]
+    if address.get("unit"):
+        parts.append(str(address["unit"]))
+    parts.append(f"{address['city']} {address['state']} {address['zip']}")
+    return ", ".join(parts)
+
+
+def list_addresses(conn: sqlite3.Connection, owner: str) -> list[dict[str, Any]]:
+    rows = conn.execute(
+        "SELECT * FROM addresses WHERE owner = ?"
+        " ORDER BY is_default DESC, id",
+        (owner,),
+    ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def default_display_address(conn: sqlite3.Connection) -> dict[str, Any] | None:
+    """First default address row (anonymous display sample only)."""
+    row = conn.execute(
+        "SELECT * FROM addresses WHERE is_default = 1 ORDER BY id LIMIT 1"
+    ).fetchone()
+    return dict(row) if row else None
+
+
+def get_owned_address(
+    conn: sqlite3.Connection, owner: str, address_id: str
+) -> dict[str, Any] | None:
+    row = conn.execute(
+        "SELECT * FROM addresses WHERE id = ? AND owner = ?",
+        (address_id, owner),
+    ).fetchone()
+    return dict(row) if row else None
+
+
+def create_address(
+    conn: sqlite3.Connection,
+    owner: str,
+    *,
+    street: str,
+    unit: str,
+    city: str,
+    state: str,
+    zip_code: str,
+) -> dict[str, Any]:
+    """Insert a validated address; identical re-entry reuses the same row."""
+    existing = conn.execute(
+        "SELECT * FROM addresses WHERE owner = ? AND street = ? AND unit = ?"
+        " AND city = ? AND state = ? AND zip = ?",
+        (owner, street, unit, city, state.upper(), zip_code),
+    ).fetchone()
+    if existing is not None:
+        return dict(existing)
+    address_id = f"addr-{next_sequence(conn, 'address'):06d}"
+    conn.execute(
+        "INSERT INTO addresses"
+        " (id, owner, street, unit, city, state, zip, is_default, fictional)"
+        " VALUES (?, ?, ?, ?, ?, ?, ?, 0, 1)",
+        (address_id, owner, street, unit, city, state.upper(), zip_code),
+    )
+    row = conn.execute(
+        "SELECT * FROM addresses WHERE id = ?", (address_id,)
+    ).fetchone()
+    return dict(row)
+
+
+# ---- wizard drafts --------------------------------------------------------------
+
+
+def get_draft(conn: sqlite3.Connection, owner: str) -> dict[str, Any] | None:
+    row = conn.execute(
+        "SELECT * FROM wizard_drafts WHERE owner = ?", (owner,)
+    ).fetchone()
+    return dict(row) if row else None
+
+
+def ensure_draft(conn: sqlite3.Connection, owner: str) -> dict[str, Any]:
+    draft = get_draft(conn, owner)
+    if draft is not None:
+        return draft
+    booking_ref = f"trbk-{next_sequence(conn, 'booking_ref'):06d}"
+    conn.execute(
+        "INSERT INTO wizard_drafts"
+        " (owner, booking_ref, draft_version, created_at, updated_at)"
+        " VALUES (?, ?, 1, ?, ?)",
+        (owner, booking_ref, FROZEN_CLOCK, FROZEN_CLOCK),
+    )
+    draft = get_draft(conn, owner)
+    assert draft is not None
+    return draft
+
+
+def update_draft(
+    conn: sqlite3.Connection, owner: str, **fields: str
+) -> dict[str, Any]:
+    """Upsert the owner's draft booking; every write bumps draft_version."""
+    unknown = set(fields) - set(DRAFT_FIELDS)
+    if unknown:
+        raise ValueError(f"unknown draft fields: {sorted(unknown)}")
+    ensure_draft(conn, owner)
+    assignments = ", ".join(f"{name} = ?" for name in fields)
+    conn.execute(
+        f"UPDATE wizard_drafts SET {assignments},"
+        " draft_version = draft_version + 1, updated_at = ?"
+        " WHERE owner = ?",
+        [*fields.values(), FROZEN_CLOCK, owner],
+    )
+    draft = get_draft(conn, owner)
+    assert draft is not None
+    return draft
+
+
+def delete_draft(conn: sqlite3.Connection, owner: str) -> None:
+    conn.execute("DELETE FROM wizard_drafts WHERE owner = ?", (owner,))
+
+
+def set_draft_payment(
+    conn: sqlite3.Connection,
+    owner: str,
+    *,
+    flow_id: str,
+    amount_minor: int,
+    currency: str,
+    fingerprint: str,
+    status: str,
+) -> None:
+    """Record the offline-sandbox payment facts on the owner's draft.
+
+    Payment is orthogonal to booking identity, so this deliberately does not bump
+    ``draft_version`` — the request/quote version stays fixed from Tasker
+    selection through confirm, and the authorization is bound to that draft.
+    """
+    conn.execute(
+        "UPDATE wizard_drafts SET payment_flow_id = ?, payment_amount_minor = ?,"
+        " payment_currency = ?, payment_fingerprint = ?, payment_status = ?,"
+        " updated_at = ? WHERE owner = ?",
+        (flow_id, int(amount_minor), currency, fingerprint, status, FROZEN_CLOCK, owner),
+    )
+
+
+def clear_draft_payment(conn: sqlite3.Connection, owner: str) -> None:
+    """Void any stored authorization; forces a fresh payment for the draft."""
+    conn.execute(
+        "UPDATE wizard_drafts SET payment_flow_id = NULL,"
+        " payment_amount_minor = NULL, payment_currency = NULL,"
+        " payment_fingerprint = NULL, payment_status = NULL, updated_at = ?"
+        " WHERE owner = ?",
+        (FROZEN_CLOCK, owner),
+    )
+
+
+# ---- booking requests ------------------------------------------------------------
+
+
+def get_booking(conn: sqlite3.Connection, booking_id: str) -> dict[str, Any] | None:
+    row = conn.execute(
+        "SELECT * FROM bookings WHERE id = ?", (booking_id,)
+    ).fetchone()
+    return dict(row) if row else None
+
+
+def get_booking_by_request(
+    conn: sqlite3.Connection, request_id: str
+) -> dict[str, Any] | None:
+    row = conn.execute(
+        "SELECT * FROM bookings WHERE request_id = ?", (request_id,)
+    ).fetchone()
+    return dict(row) if row else None
+
+
+def list_bookings(
+    conn: sqlite3.Connection, owner: str | None = None
+) -> list[dict[str, Any]]:
+    if owner is None:
+        rows = conn.execute("SELECT * FROM bookings ORDER BY id").fetchall()
+    else:
+        rows = conn.execute(
+            "SELECT * FROM bookings WHERE owner = ? ORDER BY id", (owner,)
+        ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def open_booking_for(
+    conn: sqlite3.Connection, owner: str, tasker_id: str
+) -> dict[str, Any] | None:
+    row = conn.execute(
+        "SELECT * FROM bookings WHERE owner = ? AND tasker_id = ?"
+        " AND status = ?",
+        (owner, tasker_id, BOOKING_STATUS_OPEN),
+    ).fetchone()
+    return dict(row) if row else None
+
+
+class BookingConflict(Exception):
+    """Raised when the submitted slot version is stale (HTTP 409)."""
+
+
+class BookingInvalid(Exception):
+    """Raised when the booking draft is incomplete/invalid (HTTP 422)."""
+
+
+class BookingUnauthorized(Exception):
+    """Raised when a resolved account role cannot confirm bookings."""
+
+
+def get_booking_command(
+    conn: sqlite3.Connection,
+    owner: str,
+    idempotency_key: str,
+) -> dict[str, Any] | None:
+    row = conn.execute(
+        "SELECT * FROM booking_workflow_commands "
+        "WHERE owner_id = ? AND idempotency_key = ?",
+        (owner, idempotency_key),
+    ).fetchone()
+    return dict(row) if row else None
+
+
+def booking_command_history(
+    conn: sqlite3.Connection,
+    entity_id: str,
+) -> list[dict[str, Any]]:
+    rows = conn.execute(
+        "SELECT * FROM booking_workflow_version_journal "
+        "WHERE entity_id = ? ORDER BY version",
+        (entity_id,),
+    ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def confirm_booking(
+    conn: sqlite3.Connection,
+    *,
+    owner: str,
+    request_id: str,
+    submitted_merge_key: dict[str, str],
+    payment_consumer: Callable[..., Any] | None = None,
+) -> tuple[dict[str, Any], bool]:
+    """Persist one booking row from the owner's completed request/draft.
+
+    The pre-confirm path is a request identity. A distinct booking ID is minted
+    only after the complete server-owned twenty-one-field merge key validates
+    (the final field binds the booking to one authorized offline-sandbox
+    payment). Byte-equivalent retries reuse that booking; any changed field
+    conflicts.
+
+    ``payment_consumer`` — when supplied — spends the draft's authorization as
+    the transaction's first write; it receives ``(conn, flow_id=, account_id=,
+    amount_minor=, fingerprint_value=)`` and must raise ``BookingInvalid`` /
+    ``BookingConflict`` if the authorization no longer validates.
+    """
+    client = get_client(conn, owner)
+    resolved_role = str(client["role"]) if client is not None else ""
+    if resolved_role != "requester":
+        raise BookingUnauthorized(
+            "the resolved account role cannot create requester bookings"
+        )
+    idempotency_key = submitted_merge_key.get("idempotency_token", "")
+    payload_digest = _digest_json(submitted_merge_key)
+    prior_command = get_booking_command(conn, owner, idempotency_key)
+    if prior_command is not None:
+        if prior_command["payload_digest"] != payload_digest:
+            raise BookingInvalid(
+                "the idempotency key was already used with a different payload"
+            )
+        outcome = json.loads(prior_command["canonical_outcome_json"])
+        booking = get_booking(conn, str(outcome["booking_id"]))
+        if booking is None:
+            raise BookingInvalid(
+                "the committed command refers to a missing booking"
+            )
+        return booking, False
+    existing = get_booking_by_request(conn, request_id)
+    if existing is not None:
+        if existing["owner"] != owner:
+            raise BookingInvalid("the request belongs to another owner")
+        stored_key = json.loads(existing["merge_key_json"] or "{}")
+        if stored_key != submitted_merge_key:
+            raise BookingInvalid(
+                "the idempotent retry tuple does not match the existing exact "
+                "request/apartment-size/provider/quote/slot identity"
+            )
+        return existing, False
+    draft = get_draft(conn, owner)
+    if draft is None or draft["booking_ref"] != request_id:
+        raise BookingInvalid("no booking draft with this reference exists")
+    missing = [
+        field
+        for field in ("category", "apartment_size", "address_id", "slot_id")
+        if not draft.get(field)
+    ]
+    if missing:
+        raise BookingInvalid(
+            "the booking draft is incomplete; finish the wizard steps for: "
+            + ", ".join(missing)
+        )
+    if not draft.get("payment_flow_id") or (
+        str(draft.get("payment_status") or "").upper() != "APPROVED"
+    ):
+        raise BookingInvalid(
+            "the booking payment step is incomplete; authorize the test "
+            "payment before confirming"
+        )
+    slot = get_slot(conn, str(draft["slot_id"]))
+    if slot is None:
+        raise BookingInvalid("the drafted availability slot no longer exists")
+    size = get_size(conn, str(draft["apartment_size"]))
+    if size is None:
+        raise BookingInvalid("the drafted apartment size no longer exists")
+    tasker_id = submitted_merge_key.get("provider_id", "")
+    tasker = get_tasker(conn, tasker_id)
+    if tasker is None:
+        raise BookingInvalid("the submitted provider no longer exists")
+    request_version = f"request-v{draft['draft_version']}"
+    quote_id = f"quote-{tasker_id}-{request_id}-{request_version}"
+    quote_version = "quote-v1"
+    expected_merge_key = {
+        "idempotency_token": f"idem-{request_id}-{request_version}",
+        "owner_id": owner,
+        "session_id": submitted_merge_key.get("session_id", ""),
+        "request_id": request_id,
+        "request_version": request_version,
+        "category_id": str(draft["category"]),
+        "task_template_id": task_template_id_for_category(str(draft["category"])),
+        "apartment_size_id": str(draft["apartment_size"]),
+        "apartment_size_version": str(size["version"]),
+        "address_id": str(draft["address_id"]),
+        "service_date": str(slot["date"]),
+        "window_start": str(slot["window_start"]),
+        "window_end": str(slot["window_end"]),
+        "provider_id": tasker_id,
+        "provider_version": str(tasker["provider_version"]),
+        "quote_id": quote_id,
+        "quote_version": quote_version,
+        "quote_owner_id": owner,
+        "slot_id": str(slot["id"]),
+        "slot_version": str(slot["version"]),
+        "payment_flow_id": str(draft["payment_flow_id"] or ""),
+    }
+    if submitted_merge_key != expected_merge_key:
+        stale_fields = sorted(
+            field
+            for field, expected in expected_merge_key.items()
+            if submitted_merge_key.get(field) != expected
+        )
+        if {
+            "request_version",
+            "apartment_size_id",
+            "apartment_size_version",
+            "quote_id",
+            "slot_version",
+        } & set(stale_fields):
+            raise BookingConflict(
+                "the request/size/quote/slot tuple is stale; changed fields: "
+                + ", ".join(stale_fields)
+            )
+        raise BookingInvalid(
+            "the submitted exact confirm tuple differs from server facts: "
+            + ", ".join(stale_fields)
+        )
+    if slot["version"] != submitted_merge_key["slot_version"]:
+        raise BookingConflict(
+            f"the server-owned slot version is {slot['version']}"
+        )
+    if slot_is_past(slot):
+        raise BookingInvalid("the drafted availability slot is in the past")
+    if not tasker_available(conn, tasker_id, slot["id"]):
+        raise BookingInvalid("that Tasker is not available for this slot")
+    address = get_owned_address(conn, owner, str(draft["address_id"]))
+    if address is None:
+        raise BookingInvalid("the drafted address does not belong to you")
+    # Spend the offline-sandbox authorization as the transaction's first write.
+    # A fact mismatch inside consume forces the ledger to COMMIT + reopen the
+    # transaction, so no booking write may precede it.
+    payment_amount_minor = int(draft["payment_amount_minor"] or 0)
+    if payment_consumer is not None:
+        payment_consumer(
+            conn,
+            flow_id=str(draft["payment_flow_id"]),
+            account_id=owner,
+            amount_minor=payment_amount_minor,
+            fingerprint_value=str(draft["payment_fingerprint"] or ""),
+        )
+    booking_id = f"booking-{next_sequence(conn, 'booking'):06d}"
+    receipt_id = f"receipt-{booking_id}"
+    conn.execute(
+        "INSERT INTO bookings"
+        " (id, owner, category, apartment_size, tasker_id, slot_id,"
+        "  slot_version, date, window, address, status, created_at,"
+        "  request_id, request_version, task_template_id,"
+        "  apartment_size_version, address_id, provider_version, quote_id,"
+        "  quote_version, quote_owner_id, session_id, idempotency_token,"
+        "  receipt_id, merge_key_json, hourly_rate, payment_flow_id,"
+        "  amount_minor)"
+        " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,"
+        " ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        (
+            booking_id,
+            owner,
+            draft["category"],
+            draft["apartment_size"],
+            tasker_id,
+            slot["id"],
+            slot["version"],
+            slot["date"],
+            f"{slot['window_start']}-{slot['window_end']}",
+            address_label(address),
+            BOOKING_STATUS_OPEN,
+            FROZEN_CLOCK,
+            request_id,
+            request_version,
+            task_template_id_for_category(str(draft["category"])),
+            size["version"],
+            draft["address_id"],
+            tasker["provider_version"],
+            quote_id,
+            quote_version,
+            owner,
+            submitted_merge_key["session_id"],
+            submitted_merge_key["idempotency_token"],
+            receipt_id,
+            json.dumps(
+                expected_merge_key,
+                ensure_ascii=False,
+                sort_keys=True,
+                separators=(",", ":"),
+            ),
+            int(tasker["rate"]),
+            str(draft["payment_flow_id"]),
+            payment_amount_minor,
+        ),
+    )
+    outcome = {
+        "booking_id": booking_id,
+        "receipt_id": receipt_id,
+        "result": "committed",
+    }
+    outcome_json = _canonical_json(outcome)
+    outcome_digest = hashlib.sha256(outcome_json.encode("utf-8")).hexdigest()
+    command_id = f"command-{next_sequence(conn, 'command'):06d}"
+    conn.execute(
+        "INSERT INTO booking_workflow_commands"
+        " (command_id, owner_id, resolved_role, idempotency_key,"
+        "  payload_digest, operation_kind, entity_id, expected_version,"
+        "  status, outcome_booking_id, canonical_outcome_json,"
+        "  outcome_digest, committed_at)"
+        " VALUES (?, ?, ?, ?, ?, 'confirm-booking', ?, ?, 'committed',"
+        "  ?, ?, ?, ?)",
+        (
+            command_id,
+            owner,
+            resolved_role,
+            idempotency_key,
+            payload_digest,
+            request_id,
+            request_version,
+            booking_id,
+            outcome_json,
+            outcome_digest,
+            FROZEN_CLOCK,
+        ),
+    )
+    conn.execute(
+        "INSERT INTO booking_workflow_version_journal"
+        " (entity_id, version, command_id, prior_version,"
+        "  booking_id, outcome_digest, committed_at)"
+        " VALUES (?, 1, ?, 0, ?, ?, ?)",
+        (
+            request_id,
+            command_id,
+            booking_id,
+            outcome_digest,
+            FROZEN_CLOCK,
+        ),
+    )
+    conn.execute(
+        "UPDATE bookings SET command_id = ?, committed_version = 1 "
+        "WHERE id = ?",
+        (command_id, booking_id),
+    )
+    delete_draft(conn, owner)
+    booking = get_booking(conn, booking_id)
+    assert booking is not None
+    return booking, True

tasks/taskrabbit/solution/site/implementation/clone/backend/service_booking_catalog.py

@@ -0,0 +1,85 @@
+"""Source-bound booking identities for every captured Service CTA."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+from urllib.parse import parse_qs, urlsplit
+
+
+CATALOG_PATH = Path(__file__).with_name("service_booking_catalog.json")
+SCHEMA_VERSION = "websitebench.taskrabbit.service-booking-catalog.v1"
+
+
+def _load() -> dict[str, Any]:
+    value = json.loads(CATALOG_PATH.read_text(encoding="utf-8"))
+    entries = value.get("entries")
+    if (
+        value.get("schema_version") != SCHEMA_VERSION
+        or value.get("expected_template_count") != 169
+        or value.get("covered_service_detail_page_count") != 267
+        or not re.fullmatch(r"[0-9a-f]{64}", str(value.get("source_pages_sha256", "")))
+        or not isinstance(entries, list)
+        or len(entries) != 169
+    ):
+        raise RuntimeError("Taskrabbit service booking catalog is inconsistent")
+
+    ids: set[str] = set()
+    templates: set[str] = set()
+    for entry in entries:
+        category_id = str(entry.get("id", ""))
+        template_id = str(entry.get("source_task_template_id", ""))
+        sizes = entry.get("size_options")
+        if (
+            not re.fullmatch(r"service-[1-9]\d*-[1-9]\d*", category_id)
+            or not re.fullmatch(r"[1-9]\d*", template_id)
+            or category_id in ids
+            or template_id in templates
+            or entry.get("booking_href") != f"/book/task/{category_id}"
+            or not str(entry.get("label", "")).strip()
+            or not str(entry.get("source_category_name", "")).strip()
+            or not str(entry.get("size_legend", "")).strip()
+            or not isinstance(sizes, list)
+            or [row.get("id") for row in sizes]
+            != ["task-small", "task-medium", "task-large"]
+            or not entry.get("service_paths")
+            or any(
+                not str(path).startswith("/services/")
+                for path in entry["service_paths"]
+            )
+        ):
+            raise RuntimeError(
+                f"Taskrabbit service booking entry is inconsistent: {category_id}"
+            )
+        ids.add(category_id)
+        templates.add(template_id)
+    return value
+
+
+CATALOG = _load()
+ENTRIES: tuple[dict[str, Any], ...] = tuple(CATALOG["entries"])
+BY_CATEGORY_ID: dict[str, dict[str, Any]] = {
+    str(entry["id"]): entry for entry in ENTRIES
+}
+BY_TEMPLATE_ID: dict[str, dict[str, Any]] = {
+    str(entry["source_task_template_id"]): entry for entry in ENTRIES
+}
+CATEGORY_LABELS: dict[str, str] = {
+    category_id: str(entry["label"])
+    for category_id, entry in BY_CATEGORY_ID.items()
+}
+BOOKING_HREFS: dict[str, str] = {
+    category_id: str(entry["booking_href"])
+    for category_id, entry in BY_CATEGORY_ID.items()
+}
+
+
+def task(category_id: str) -> dict[str, Any] | None:
+    return BY_CATEGORY_ID.get(category_id)
+
+
+def task_from_source_cta(value: str) -> dict[str, Any] | None:
+    template_ids = parse_qs(urlsplit(value).query).get("task_template_id", [])
+    return BY_TEMPLATE_ID.get(str(template_ids[0])) if template_ids else None

tasks/taskrabbit/solution/site/implementation/clone/backend/task_catalog.json

@@ -0,0 +1,156 @@
+{
+  "schema_version": "websitebench.taskrabbit.task-catalog.v1",
+  "source_capture": "source-current/2026-07-29-v3/browser/home-dom.html",
+  "families": [
+    {
+      "id": "assembly",
+      "label": "Assembly",
+      "icon": "/static/home-icons/assembly.svg",
+      "image": "/static/assets/source-current/2026-07-25/home/hero-homepage-assembly.webp",
+      "image_alt": "Image of a Tasker assembling furniture",
+      "summary": "Assemble or disassemble furniture items by unboxing, building, and any cleanup.",
+      "trending": "Now Trending: Curved sofas, computer desks, and sustainable materials.",
+      "tasks": [
+        {"id": "furniture-assembly", "label": "General Furniture Assembly", "booking_href": "/book/furniture-assembly/furniture-assembly"},
+        {"id": "ikea-assembly", "label": "IKEA Assembly", "booking_href": "/book/task/ikea-assembly"},
+        {"id": "crib-assembly", "label": "Crib Assembly", "booking_href": "/book/task/crib-assembly"},
+        {"id": "bookshelf-assembly", "label": "Bookshelf Assembly", "booking_href": "/book/furniture-assembly/bookshelf-assembly"},
+        {"id": "desk-assembly", "label": "Desk Assembly", "booking_href": "/book/furniture-assembly/desk-assembly"}
+      ]
+    },
+    {
+      "id": "mounting",
+      "label": "Mounting",
+      "icon": "/static/home-icons/mounting.svg",
+      "image": "/static/assets/source-current/2026-08-09-home-auth-assets/home-mounting.png",
+      "image_alt": "Image of a Tasker mounting a picture frame",
+      "summary": "Securely mount your TV, shelves, art, mirrors, dressers, and more.",
+      "trending": "Now Trending: Gallery walls, art TVs, and wraparound bookcases.",
+      "tasks": [
+        {"id": "hang-art-mirror-decor", "label": "Hang Art, Mirror & Decor", "booking_href": "/book/task/hang-art-mirror-decor"},
+        {"id": "install-blinds-window-treatments", "label": "Install Blinds & Window Treatments", "booking_href": "/book/task/install-blinds-window-treatments"},
+        {"id": "mount-anchor-furniture", "label": "Mount & Anchor Furniture", "booking_href": "/book/task/mount-anchor-furniture"},
+        {"id": "install-shelves-rods-hooks", "label": "Install Shelves, Rods & Hooks", "booking_href": "/book/task/install-shelves-rods-hooks"},
+        {"id": "other-mounting", "label": "Other Mounting", "booking_href": "/book/task/other-mounting"},
+        {"id": "tv-mounting", "label": "TV Mounting", "booking_href": "/book/task/tv-mounting"}
+      ]
+    },
+    {
+      "id": "moving",
+      "label": "Moving",
+      "icon": "/static/home-icons/moving.svg",
+      "image": "/static/assets/source-current/2026-08-09-home-auth-assets/home-moving.png",
+      "image_alt": "Image of a Tasker moving boxes",
+      "summary": "Moving help such as packing/unpacking, loading, and lifting heavy items.",
+      "trending": "Now Trending: Single-item moves, apartment moves, and junk removal.",
+      "tasks": [
+        {"id": "help-moving", "label": "Help Moving", "booking_href": "/book/help-moving"},
+        {"id": "truck-assisted-help-moving", "label": "Truck-Assisted Help Moving", "booking_href": "/book/task/truck-assisted-help-moving"},
+        {"id": "flat-rate-move", "label": "Flat-Rate Move", "booking_href": "/book/task/flat-rate-move"},
+        {"id": "trash-furniture-removal", "label": "Trash & Furniture Removal", "booking_href": "/book/task/trash-furniture-removal"},
+        {"id": "heavy-lifting-loading", "label": "Heavy Lifting & Loading", "booking_href": "/book/task/heavy-lifting-loading"},
+        {"id": "rearrange-furniture", "label": "Rearrange Furniture", "booking_href": "/book/task/rearrange-furniture"},
+        {"id": "junk-haul-away", "label": "Junk Haul Away", "booking_href": "/book/task/junk-haul-away"}
+      ]
+    },
+    {
+      "id": "cleaning",
+      "label": "Cleaning",
+      "icon": "/static/home-icons/cleaning.svg",
+      "image": "/static/assets/source-current/2026-08-09-home-auth-assets/home-cleaning.png",
+      "image_alt": "Image of a Tasker cleaning in the kitchen",
+      "summary": "Clean your home or office; deep clean appliances and other spaces.",
+      "trending": "Now Trending: Eco-friendly products, home cleaning checklists, and cleaning hacks.",
+      "tasks": [
+        {"id": "cleaning", "label": "Cleaning", "booking_href": "/book/task/cleaning"},
+        {"id": "apartment-cleaning", "label": "Apartment Cleaning", "booking_href": "/book/task/apartment-cleaning"},
+        {"id": "deep-clean", "label": "Deep Clean", "booking_href": "/book/task/deep-clean"},
+        {"id": "garage-cleaning", "label": "Garage Cleaning", "booking_href": "/book/task/garage-cleaning"},
+        {"id": "move-out-clean", "label": "Move Out Clean", "booking_href": "/book/task/move-out-clean"}
+      ]
+    },
+    {
+      "id": "outdoor-help",
+      "label": "Outdoor Help",
+      "icon": "/static/home-icons/outdoor-help.svg",
+      "image": "/static/assets/source-current/2026-08-09-home-auth-assets/home-outdoor-help.png",
+      "image_alt": "Image of a Tasker mowing a yard.",
+      "summary": "Beat the heat with lawn mowing, garden maintenance, patio cleanup, and pressure washing for a summer-ready yard.",
+      "trending": "Now Trending: Pressure washing, hedge trimming, lawn maintenance, and exterior painting to keep your curb appeal shining this summer.",
+      "tasks": [
+        {"id": "yard-work", "label": "Yard Work", "booking_href": "/book/task/yard-work"},
+        {"id": "lawn-care", "label": "Lawn Care", "booking_href": "/book/task/lawn-care"},
+        {"id": "lawn-mowing", "label": "Lawn Mowing", "booking_href": "/book/task/lawn-mowing"},
+        {"id": "branch-hedge-trimming", "label": "Branch & Hedge Trimming", "booking_href": "/book/task/branch-hedge-trimming"},
+        {"id": "gardening-weeding", "label": "Gardening & Weeding", "booking_href": "/book/task/gardening-weeding"},
+        {"id": "pressure-washing", "label": "Pressure Washing", "booking_href": "/book/task/pressure-washing"}
+      ]
+    },
+    {
+      "id": "home-repairs",
+      "label": "Home Repairs",
+      "icon": "/static/home-icons/home-repairs.svg",
+      "image": "/static/assets/source-current/2026-08-09-home-auth-assets/home-repairs.png",
+      "image_alt": "Image of a Tasker providing plumbing help for a sink",
+      "summary": "Home improvements like plumbing, electrical, and appliance installation.",
+      "trending": "Now Trending: Chandeliers, brass faucets, and smart toilets.",
+      "tasks": [
+        {"id": "door-cabinet-furniture-repair", "label": "Door, Cabinet, & Furniture Repair", "booking_href": "/book/task/door-cabinet-furniture-repair"},
+        {"id": "wall-repair", "label": "Wall Repair", "booking_href": "/book/task/wall-repair"},
+        {"id": "sealing-caulking", "label": "Sealing & Caulking", "booking_href": "/book/task/sealing-caulking"},
+        {"id": "appliance-installation-repairs", "label": "Appliance Installation & Repairs", "booking_href": "/book/task/appliance-installation-repairs"},
+        {"id": "window-blinds-repair", "label": "Window & Blinds Repair", "booking_href": "/book/task/window-blinds-repair"},
+        {"id": "flooring-tiling-help", "label": "Flooring & Tiling Help", "booking_href": "/book/task/flooring-tiling-help"},
+        {"id": "electrical-help", "label": "Electrical Help", "booking_href": "/book/task/electrical-help"},
+        {"id": "plumbing-help", "label": "Plumbing Help", "booking_href": "/book/task/plumbing-help"},
+        {"id": "light-carpentry", "label": "Light Carpentry", "booking_href": "/book/task/light-carpentry"}
+      ]
+    },
+    {
+      "id": "painting",
+      "label": "Painting",
+      "icon": "/static/home-icons/painting.svg",
+      "image": "/static/assets/source-current/2026-08-09-home-auth-assets/home-painting.png",
+      "image_alt": "Image of a Tasker painting a wall",
+      "summary": "Paint walls, ceilings, molding, and doors; includes prep and cleanup.",
+      "trending": "Now Trending: Color blocking, stripe details, and statement colors.",
+      "tasks": [
+        {"id": "indoor-painting", "label": "Indoor Painting", "booking_href": "/book/task/indoor-painting"},
+        {"id": "wallpapering", "label": "Wallpapering", "booking_href": "/book/task/wallpapering"},
+        {"id": "outdoor-painting", "label": "Outdoor Painting", "booking_href": "/book/task/outdoor-painting"},
+        {"id": "concrete-brick-painting", "label": "Concrete & Brick Painting", "booking_href": "/book/task/concrete-brick-painting"},
+        {"id": "accent-wall-painting", "label": "Accent Wall Painting", "booking_href": "/book/task/accent-wall-painting"},
+        {"id": "wallpaper-removal", "label": "Wallpaper Removal", "booking_href": "/book/task/wallpaper-removal"}
+      ]
+    },
+    {
+      "id": "trending",
+      "label": "Trending",
+      "icon": "/static/home-icons/trending.svg",
+      "image": "/static/assets/source-current/2026-08-09-home-auth-assets/home-trending.jpg",
+      "image_alt": "A man wearing a green taskrabbit shirt kneeling beside a white washing machine. He is holding a yellow drill performing maintenance on it.",
+      "summary": "Discover the hottest tasks that will level up your space.",
+      "trending": "Explore these trending tasks and book a skilled Tasker to enjoy the convenience and peace of mind that comes with it all!",
+      "tasks": [
+        {"id": "furniture-assembly", "label": "General Furniture Assembly", "booking_href": "/book/furniture-assembly/furniture-assembly"},
+        {"id": "other-mounting", "label": "General Mounting", "booking_href": "/book/task/other-mounting"},
+        {"id": "tv-mounting", "label": "TV Mounting", "booking_href": "/book/task/tv-mounting"},
+        {"id": "help-moving", "label": "Help Moving", "booking_href": "/book/help-moving"},
+        {"id": "cleaning", "label": "Cleaning", "booking_href": "/book/task/cleaning"},
+        {"id": "donation-drop-off", "label": "Donation Drop Off", "booking_href": "/book/task/donation-drop-off"},
+        {"id": "personal-assistant", "label": "Personal Assistant", "booking_href": "/book/task/personal-assistant"}
+      ]
+    }
+  ],
+  "popular_projects": [
+    {"label": "Furniture Assembly", "category_id": "furniture-assembly", "booking_href": "/book/furniture-assembly/furniture-assembly", "image": "/static/assets/source-current/2026-07-25/home/category-furniture-assembly.webp", "image_alt": "Furniture Assembly", "price_copy": "Projects starting at $49"},
+    {"label": "Mount Art or Shelves", "category_id": "hang-art-mirror-decor", "booking_href": "/book/task/hang-art-mirror-decor", "image": "/static/assets/source-current/2026-07-25/home/category-hang-pictures.webp", "image_alt": "Mount Art or Shelves", "price_copy": "Projects starting at $65"},
+    {"label": "Mount a TV", "category_id": "tv-mounting", "booking_href": "/book/task/tv-mounting", "image": "/static/assets/source-current/2026-07-25/home/category-mount-tv.webp", "image_alt": "Mount a TV", "price_copy": "Projects starting at $69"},
+    {"label": "Help Moving", "category_id": "help-moving", "booking_href": "/book/help-moving", "image": "/static/home-assets/help-moving-8ff5b956fe8d.webp", "image_alt": "Help Moving", "price_copy": "Projects starting at $67"},
+    {"label": "Flat-Rate Move", "category_id": "flat-rate-move", "booking_href": "/book/task/flat-rate-move", "image": "/static/assets/source-current/2026-07-25/home/category-help-moving.webp", "image_alt": "Flat-Rate Move", "price_copy": "Flat rate from $139"},
+    {"label": "Home & Apartment Cleaning", "category_id": "cleaning", "booking_href": "/book/task/cleaning", "image": "/static/assets/source-current/2026-07-25/home/category-cleaning.webp", "image_alt": "Home and Apartment Cleaning", "price_copy": "Projects starting at $49"},
+    {"label": "Minor Plumbing Repairs", "category_id": "plumbing-help", "booking_href": "/book/task/plumbing-help", "image": "/static/assets/source-current/2026-07-25/home/category-yardwork.webp", "image_alt": "Minor Plumbing Repairs", "price_copy": "Projects starting at $74"},
+    {"label": "Electrical Help", "category_id": "electrical-help", "booking_href": "/book/task/electrical-help", "image": "/static/assets/source-current/2026-07-25/home/category-electrical-help.webp", "image_alt": "Electrical Help", "price_copy": "Projects starting at $69"},
+    {"label": "Heavy Lifting", "category_id": "heavy-lifting-loading", "booking_href": "/book/task/heavy-lifting-loading", "image": "/static/assets/source-current/2026-07-25/home/category-furniture-removal.webp", "image_alt": "Heavy Lifting", "price_copy": "Projects starting at $61", "image_state": "source-unloaded-project-image"}
+  ]
+}

tasks/taskrabbit/solution/site/implementation/clone/backend/task_catalog.py

@@ -0,0 +1,63 @@
+"""Validated source-bound task catalog shared by pages and persistence."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+CATALOG_PATH = Path(__file__).with_name("task_catalog.json")
+
+
+def _load() -> dict[str, Any]:
+    value = json.loads(CATALOG_PATH.read_text(encoding="utf-8"))
+    if value.get("schema_version") != "websitebench.taskrabbit.task-catalog.v1":
+        raise RuntimeError("Taskrabbit task catalog schema is inconsistent")
+    families = value.get("families")
+    projects = value.get("popular_projects")
+    if not isinstance(families, list) or len(families) != 8:
+        raise RuntimeError("Taskrabbit task families are inconsistent")
+    if not isinstance(projects, list) or len(projects) != 9:
+        raise RuntimeError("Taskrabbit popular projects are inconsistent")
+    seen_families: set[str] = set()
+    category_labels: dict[str, str] = {}
+    booking_hrefs: dict[str, str] = {}
+    for family in families:
+        family_id = str(family.get("id", ""))
+        if not family_id or family_id in seen_families:
+            raise RuntimeError("Taskrabbit task family identity is inconsistent")
+        seen_families.add(family_id)
+        for task in family.get("tasks", []):
+            category_id = str(task.get("id", ""))
+            label = str(task.get("label", ""))
+            href = str(task.get("booking_href", ""))
+            if not category_id or not label or not href.startswith("/"):
+                raise RuntimeError("Taskrabbit task entry is inconsistent")
+            category_labels.setdefault(category_id, label)
+            booking_hrefs.setdefault(category_id, href)
+    for project in projects:
+        category_id = str(project.get("category_id", ""))
+        if category_id not in category_labels:
+            raise RuntimeError("Taskrabbit popular project has no task category")
+    value["category_labels"] = category_labels
+    value["booking_hrefs"] = booking_hrefs
+    return value
+
+
+CATALOG = _load()
+FAMILIES: tuple[dict[str, Any], ...] = tuple(CATALOG["families"])
+POPULAR_PROJECTS: tuple[dict[str, Any], ...] = tuple(CATALOG["popular_projects"])
+CATEGORY_LABELS: dict[str, str] = dict(CATALOG["category_labels"])
+BOOKING_HREFS: dict[str, str] = dict(CATALOG["booking_hrefs"])
+TASKS: tuple[dict[str, str], ...] = tuple(
+    {
+        "id": category_id,
+        "label": label,
+        "booking_href": BOOKING_HREFS[category_id],
+    }
+    for category_id, label in CATEGORY_LABELS.items()
+)
+
+
+def task(category_id: str) -> dict[str, str] | None:
+    return next((item for item in TASKS if item["id"] == category_id), None)

tasks/taskrabbit/solution/site/implementation/clone/frontend/phone_regions.json

@@ -0,0 +1,1480 @@
+{
+  "schema_version": "websitebench.taskrabbit.phone-regions.v1",
+  "sources": {
+    "calling_codes": "Google libphonenumber PhoneNumberMetadata.xml (retrieved 2026-08-09)",
+    "region_names": "Unicode CLDR names exposed by Intl.DisplayNames",
+    "symbols": "Unicode regional-indicator flag sequences derived from ISO region codes"
+  },
+  "regions": [
+    {
+      "code": "US",
+      "name": "United States",
+      "dial_code": "+1",
+      "symbol": "🇺🇸"
+    },
+    {
+      "code": "AF",
+      "name": "Afghanistan",
+      "dial_code": "+93",
+      "symbol": "🇦🇫"
+    },
+    {
+      "code": "AX",
+      "name": "Åland Islands",
+      "dial_code": "+358",
+      "symbol": "🇦🇽"
+    },
+    {
+      "code": "AL",
+      "name": "Albania",
+      "dial_code": "+355",
+      "symbol": "🇦🇱"
+    },
+    {
+      "code": "DZ",
+      "name": "Algeria",
+      "dial_code": "+213",
+      "symbol": "🇩🇿"
+    },
+    {
+      "code": "AS",
+      "name": "American Samoa",
+      "dial_code": "+1",
+      "symbol": "🇦🇸"
+    },
+    {
+      "code": "AD",
+      "name": "Andorra",
+      "dial_code": "+376",
+      "symbol": "🇦🇩"
+    },
+    {
+      "code": "AO",
+      "name": "Angola",
+      "dial_code": "+244",
+      "symbol": "🇦🇴"
+    },
+    {
+      "code": "AI",
+      "name": "Anguilla",
+      "dial_code": "+1",
+      "symbol": "🇦🇮"
+    },
+    {
+      "code": "AG",
+      "name": "Antigua & Barbuda",
+      "dial_code": "+1",
+      "symbol": "🇦🇬"
+    },
+    {
+      "code": "AR",
+      "name": "Argentina",
+      "dial_code": "+54",
+      "symbol": "🇦🇷"
+    },
+    {
+      "code": "AM",
+      "name": "Armenia",
+      "dial_code": "+374",
+      "symbol": "🇦🇲"
+    },
+    {
+      "code": "AW",
+      "name": "Aruba",
+      "dial_code": "+297",
+      "symbol": "🇦🇼"
+    },
+    {
+      "code": "AC",
+      "name": "Ascension Island",
+      "dial_code": "+247",
+      "symbol": "🇦🇨"
+    },
+    {
+      "code": "AU",
+      "name": "Australia",
+      "dial_code": "+61",
+      "symbol": "🇦🇺"
+    },
+    {
+      "code": "AT",
+      "name": "Austria",
+      "dial_code": "+43",
+      "symbol": "🇦🇹"
+    },
+    {
+      "code": "AZ",
+      "name": "Azerbaijan",
+      "dial_code": "+994",
+      "symbol": "🇦🇿"
+    },
+    {
+      "code": "BS",
+      "name": "Bahamas",
+      "dial_code": "+1",
+      "symbol": "🇧🇸"
+    },
+    {
+      "code": "BH",
+      "name": "Bahrain",
+      "dial_code": "+973",
+      "symbol": "🇧🇭"
+    },
+    {
+      "code": "BD",
+      "name": "Bangladesh",
+      "dial_code": "+880",
+      "symbol": "🇧🇩"
+    },
+    {
+      "code": "BB",
+      "name": "Barbados",
+      "dial_code": "+1",
+      "symbol": "🇧🇧"
+    },
+    {
+      "code": "BY",
+      "name": "Belarus",
+      "dial_code": "+375",
+      "symbol": "🇧🇾"
+    },
+    {
+      "code": "BE",
+      "name": "Belgium",
+      "dial_code": "+32",
+      "symbol": "🇧🇪"
+    },
+    {
+      "code": "BZ",
+      "name": "Belize",
+      "dial_code": "+501",
+      "symbol": "🇧🇿"
+    },
+    {
+      "code": "BJ",
+      "name": "Benin",
+      "dial_code": "+229",
+      "symbol": "🇧🇯"
+    },
+    {
+      "code": "BM",
+      "name": "Bermuda",
+      "dial_code": "+1",
+      "symbol": "🇧🇲"
+    },
+    {
+      "code": "BT",
+      "name": "Bhutan",
+      "dial_code": "+975",
+      "symbol": "🇧🇹"
+    },
+    {
+      "code": "BO",
+      "name": "Bolivia",
+      "dial_code": "+591",
+      "symbol": "🇧🇴"
+    },
+    {
+      "code": "BA",
+      "name": "Bosnia & Herzegovina",
+      "dial_code": "+387",
+      "symbol": "🇧🇦"
+    },
+    {
+      "code": "BW",
+      "name": "Botswana",
+      "dial_code": "+267",
+      "symbol": "🇧🇼"
+    },
+    {
+      "code": "BR",
+      "name": "Brazil",
+      "dial_code": "+55",
+      "symbol": "🇧🇷"
+    },
+    {
+      "code": "IO",
+      "name": "British Indian Ocean Territory",
+      "dial_code": "+246",
+      "symbol": "🇮🇴"
+    },
+    {
+      "code": "VG",
+      "name": "British Virgin Islands",
+      "dial_code": "+1",
+      "symbol": "🇻🇬"
+    },
+    {
+      "code": "BN",
+      "name": "Brunei",
+      "dial_code": "+673",
+      "symbol": "🇧🇳"
+    },
+    {
+      "code": "BG",
+      "name": "Bulgaria",
+      "dial_code": "+359",
+      "symbol": "🇧🇬"
+    },
+    {
+      "code": "BF",
+      "name": "Burkina Faso",
+      "dial_code": "+226",
+      "symbol": "🇧🇫"
+    },
+    {
+      "code": "BI",
+      "name": "Burundi",
+      "dial_code": "+257",
+      "symbol": "🇧🇮"
+    },
+    {
+      "code": "KH",
+      "name": "Cambodia",
+      "dial_code": "+855",
+      "symbol": "🇰🇭"
+    },
+    {
+      "code": "CM",
+      "name": "Cameroon",
+      "dial_code": "+237",
+      "symbol": "🇨🇲"
+    },
+    {
+      "code": "CA",
+      "name": "Canada",
+      "dial_code": "+1",
+      "symbol": "🇨🇦"
+    },
+    {
+      "code": "CV",
+      "name": "Cape Verde",
+      "dial_code": "+238",
+      "symbol": "🇨🇻"
+    },
+    {
+      "code": "BQ",
+      "name": "Caribbean Netherlands",
+      "dial_code": "+599",
+      "symbol": "🇧🇶"
+    },
+    {
+      "code": "KY",
+      "name": "Cayman Islands",
+      "dial_code": "+1",
+      "symbol": "🇰🇾"
+    },
+    {
+      "code": "CF",
+      "name": "Central African Republic",
+      "dial_code": "+236",
+      "symbol": "🇨🇫"
+    },
+    {
+      "code": "TD",
+      "name": "Chad",
+      "dial_code": "+235",
+      "symbol": "🇹🇩"
+    },
+    {
+      "code": "CL",
+      "name": "Chile",
+      "dial_code": "+56",
+      "symbol": "🇨🇱"
+    },
+    {
+      "code": "CN",
+      "name": "China",
+      "dial_code": "+86",
+      "symbol": "🇨🇳"
+    },
+    {
+      "code": "CX",
+      "name": "Christmas Island",
+      "dial_code": "+61",
+      "symbol": "🇨🇽"
+    },
+    {
+      "code": "CC",
+      "name": "Cocos (Keeling) Islands",
+      "dial_code": "+61",
+      "symbol": "🇨🇨"
+    },
+    {
+      "code": "CO",
+      "name": "Colombia",
+      "dial_code": "+57",
+      "symbol": "🇨🇴"
+    },
+    {
+      "code": "KM",
+      "name": "Comoros",
+      "dial_code": "+269",
+      "symbol": "🇰🇲"
+    },
+    {
+      "code": "CG",
+      "name": "Congo - Brazzaville",
+      "dial_code": "+242",
+      "symbol": "🇨🇬"
+    },
+    {
+      "code": "CD",
+      "name": "Congo - Kinshasa",
+      "dial_code": "+243",
+      "symbol": "🇨🇩"
+    },
+    {
+      "code": "CK",
+      "name": "Cook Islands",
+      "dial_code": "+682",
+      "symbol": "🇨🇰"
+    },
+    {
+      "code": "CR",
+      "name": "Costa Rica",
+      "dial_code": "+506",
+      "symbol": "🇨🇷"
+    },
+    {
+      "code": "CI",
+      "name": "Côte d’Ivoire",
+      "dial_code": "+225",
+      "symbol": "🇨🇮"
+    },
+    {
+      "code": "HR",
+      "name": "Croatia",
+      "dial_code": "+385",
+      "symbol": "🇭🇷"
+    },
+    {
+      "code": "CU",
+      "name": "Cuba",
+      "dial_code": "+53",
+      "symbol": "🇨🇺"
+    },
+    {
+      "code": "CW",
+      "name": "Curaçao",
+      "dial_code": "+599",
+      "symbol": "🇨🇼"
+    },
+    {
+      "code": "CY",
+      "name": "Cyprus",
+      "dial_code": "+357",
+      "symbol": "🇨🇾"
+    },
+    {
+      "code": "CZ",
+      "name": "Czechia",
+      "dial_code": "+420",
+      "symbol": "🇨🇿"
+    },
+    {
+      "code": "DK",
+      "name": "Denmark",
+      "dial_code": "+45",
+      "symbol": "🇩🇰"
+    },
+    {
+      "code": "DJ",
+      "name": "Djibouti",
+      "dial_code": "+253",
+      "symbol": "🇩🇯"
+    },
+    {
+      "code": "DM",
+      "name": "Dominica",
+      "dial_code": "+1",
+      "symbol": "🇩🇲"
+    },
+    {
+      "code": "DO",
+      "name": "Dominican Republic",
+      "dial_code": "+1",
+      "symbol": "🇩🇴"
+    },
+    {
+      "code": "EC",
+      "name": "Ecuador",
+      "dial_code": "+593",
+      "symbol": "🇪🇨"
+    },
+    {
+      "code": "EG",
+      "name": "Egypt",
+      "dial_code": "+20",
+      "symbol": "🇪🇬"
+    },
+    {
+      "code": "SV",
+      "name": "El Salvador",
+      "dial_code": "+503",
+      "symbol": "🇸🇻"
+    },
+    {
+      "code": "GQ",
+      "name": "Equatorial Guinea",
+      "dial_code": "+240",
+      "symbol": "🇬🇶"
+    },
+    {
+      "code": "ER",
+      "name": "Eritrea",
+      "dial_code": "+291",
+      "symbol": "🇪🇷"
+    },
+    {
+      "code": "EE",
+      "name": "Estonia",
+      "dial_code": "+372",
+      "symbol": "🇪🇪"
+    },
+    {
+      "code": "SZ",
+      "name": "Eswatini",
+      "dial_code": "+268",
+      "symbol": "🇸🇿"
+    },
+    {
+      "code": "ET",
+      "name": "Ethiopia",
+      "dial_code": "+251",
+      "symbol": "🇪🇹"
+    },
+    {
+      "code": "FK",
+      "name": "Falkland Islands",
+      "dial_code": "+500",
+      "symbol": "🇫🇰"
+    },
+    {
+      "code": "FO",
+      "name": "Faroe Islands",
+      "dial_code": "+298",
+      "symbol": "🇫🇴"
+    },
+    {
+      "code": "FJ",
+      "name": "Fiji",
+      "dial_code": "+679",
+      "symbol": "🇫🇯"
+    },
+    {
+      "code": "FI",
+      "name": "Finland",
+      "dial_code": "+358",
+      "symbol": "🇫🇮"
+    },
+    {
+      "code": "FR",
+      "name": "France",
+      "dial_code": "+33",
+      "symbol": "🇫🇷"
+    },
+    {
+      "code": "GF",
+      "name": "French Guiana",
+      "dial_code": "+594",
+      "symbol": "🇬🇫"
+    },
+    {
+      "code": "PF",
+      "name": "French Polynesia",
+      "dial_code": "+689",
+      "symbol": "🇵🇫"
+    },
+    {
+      "code": "GA",
+      "name": "Gabon",
+      "dial_code": "+241",
+      "symbol": "🇬🇦"
+    },
+    {
+      "code": "GM",
+      "name": "Gambia",
+      "dial_code": "+220",
+      "symbol": "🇬🇲"
+    },
+    {
+      "code": "GE",
+      "name": "Georgia",
+      "dial_code": "+995",
+      "symbol": "🇬🇪"
+    },
+    {
+      "code": "DE",
+      "name": "Germany",
+      "dial_code": "+49",
+      "symbol": "🇩🇪"
+    },
+    {
+      "code": "GH",
+      "name": "Ghana",
+      "dial_code": "+233",
+      "symbol": "🇬🇭"
+    },
+    {
+      "code": "GI",
+      "name": "Gibraltar",
+      "dial_code": "+350",
+      "symbol": "🇬🇮"
+    },
+    {
+      "code": "GR",
+      "name": "Greece",
+      "dial_code": "+30",
+      "symbol": "🇬🇷"
+    },
+    {
+      "code": "GL",
+      "name": "Greenland",
+      "dial_code": "+299",
+      "symbol": "🇬🇱"
+    },
+    {
+      "code": "GD",
+      "name": "Grenada",
+      "dial_code": "+1",
+      "symbol": "🇬🇩"
+    },
+    {
+      "code": "GP",
+      "name": "Guadeloupe",
+      "dial_code": "+590",
+      "symbol": "🇬🇵"
+    },
+    {
+      "code": "GU",
+      "name": "Guam",
+      "dial_code": "+1",
+      "symbol": "🇬🇺"
+    },
+    {
+      "code": "GT",
+      "name": "Guatemala",
+      "dial_code": "+502",
+      "symbol": "🇬🇹"
+    },
+    {
+      "code": "GG",
+      "name": "Guernsey",
+      "dial_code": "+44",
+      "symbol": "🇬🇬"
+    },
+    {
+      "code": "GN",
+      "name": "Guinea",
+      "dial_code": "+224",
+      "symbol": "🇬🇳"
+    },
+    {
+      "code": "GW",
+      "name": "Guinea-Bissau",
+      "dial_code": "+245",
+      "symbol": "🇬🇼"
+    },
+    {
+      "code": "GY",
+      "name": "Guyana",
+      "dial_code": "+592",
+      "symbol": "🇬🇾"
+    },
+    {
+      "code": "HT",
+      "name": "Haiti",
+      "dial_code": "+509",
+      "symbol": "🇭🇹"
+    },
+    {
+      "code": "HN",
+      "name": "Honduras",
+      "dial_code": "+504",
+      "symbol": "🇭🇳"
+    },
+    {
+      "code": "HK",
+      "name": "Hong Kong SAR China",
+      "dial_code": "+852",
+      "symbol": "🇭🇰"
+    },
+    {
+      "code": "HU",
+      "name": "Hungary",
+      "dial_code": "+36",
+      "symbol": "🇭🇺"
+    },
+    {
+      "code": "IS",
+      "name": "Iceland",
+      "dial_code": "+354",
+      "symbol": "🇮🇸"
+    },
+    {
+      "code": "IN",
+      "name": "India",
+      "dial_code": "+91",
+      "symbol": "🇮🇳"
+    },
+    {
+      "code": "ID",
+      "name": "Indonesia",
+      "dial_code": "+62",
+      "symbol": "🇮🇩"
+    },
+    {
+      "code": "IR",
+      "name": "Iran",
+      "dial_code": "+98",
+      "symbol": "🇮🇷"
+    },
+    {
+      "code": "IQ",
+      "name": "Iraq",
+      "dial_code": "+964",
+      "symbol": "🇮🇶"
+    },
+    {
+      "code": "IE",
+      "name": "Ireland",
+      "dial_code": "+353",
+      "symbol": "🇮🇪"
+    },
+    {
+      "code": "IM",
+      "name": "Isle of Man",
+      "dial_code": "+44",
+      "symbol": "🇮🇲"
+    },
+    {
+      "code": "IL",
+      "name": "Israel",
+      "dial_code": "+972",
+      "symbol": "🇮🇱"
+    },
+    {
+      "code": "IT",
+      "name": "Italy",
+      "dial_code": "+39",
+      "symbol": "🇮🇹"
+    },
+    {
+      "code": "JM",
+      "name": "Jamaica",
+      "dial_code": "+1",
+      "symbol": "🇯🇲"
+    },
+    {
+      "code": "JP",
+      "name": "Japan",
+      "dial_code": "+81",
+      "symbol": "🇯🇵"
+    },
+    {
+      "code": "JE",
+      "name": "Jersey",
+      "dial_code": "+44",
+      "symbol": "🇯🇪"
+    },
+    {
+      "code": "JO",
+      "name": "Jordan",
+      "dial_code": "+962",
+      "symbol": "🇯🇴"
+    },
+    {
+      "code": "KZ",
+      "name": "Kazakhstan",
+      "dial_code": "+7",
+      "symbol": "🇰🇿"
+    },
+    {
+      "code": "KE",
+      "name": "Kenya",
+      "dial_code": "+254",
+      "symbol": "🇰🇪"
+    },
+    {
+      "code": "KI",
+      "name": "Kiribati",
+      "dial_code": "+686",
+      "symbol": "🇰🇮"
+    },
+    {
+      "code": "XK",
+      "name": "Kosovo",
+      "dial_code": "+383",
+      "symbol": "🇽🇰"
+    },
+    {
+      "code": "KW",
+      "name": "Kuwait",
+      "dial_code": "+965",
+      "symbol": "🇰🇼"
+    },
+    {
+      "code": "KG",
+      "name": "Kyrgyzstan",
+      "dial_code": "+996",
+      "symbol": "🇰🇬"
+    },
+    {
+      "code": "LA",
+      "name": "Laos",
+      "dial_code": "+856",
+      "symbol": "🇱🇦"
+    },
+    {
+      "code": "LV",
+      "name": "Latvia",
+      "dial_code": "+371",
+      "symbol": "🇱🇻"
+    },
+    {
+      "code": "LB",
+      "name": "Lebanon",
+      "dial_code": "+961",
+      "symbol": "🇱🇧"
+    },
+    {
+      "code": "LS",
+      "name": "Lesotho",
+      "dial_code": "+266",
+      "symbol": "🇱🇸"
+    },
+    {
+      "code": "LR",
+      "name": "Liberia",
+      "dial_code": "+231",
+      "symbol": "🇱🇷"
+    },
+    {
+      "code": "LY",
+      "name": "Libya",
+      "dial_code": "+218",
+      "symbol": "🇱🇾"
+    },
+    {
+      "code": "LI",
+      "name": "Liechtenstein",
+      "dial_code": "+423",
+      "symbol": "🇱🇮"
+    },
+    {
+      "code": "LT",
+      "name": "Lithuania",
+      "dial_code": "+370",
+      "symbol": "🇱🇹"
+    },
+    {
+      "code": "LU",
+      "name": "Luxembourg",
+      "dial_code": "+352",
+      "symbol": "🇱🇺"
+    },
+    {
+      "code": "MO",
+      "name": "Macao SAR China",
+      "dial_code": "+853",
+      "symbol": "🇲🇴"
+    },
+    {
+      "code": "MG",
+      "name": "Madagascar",
+      "dial_code": "+261",
+      "symbol": "🇲🇬"
+    },
+    {
+      "code": "MW",
+      "name": "Malawi",
+      "dial_code": "+265",
+      "symbol": "🇲🇼"
+    },
+    {
+      "code": "MY",
+      "name": "Malaysia",
+      "dial_code": "+60",
+      "symbol": "🇲🇾"
+    },
+    {
+      "code": "MV",
+      "name": "Maldives",
+      "dial_code": "+960",
+      "symbol": "🇲🇻"
+    },
+    {
+      "code": "ML",
+      "name": "Mali",
+      "dial_code": "+223",
+      "symbol": "🇲🇱"
+    },
+    {
+      "code": "MT",
+      "name": "Malta",
+      "dial_code": "+356",
+      "symbol": "🇲🇹"
+    },
+    {
+      "code": "MH",
+      "name": "Marshall Islands",
+      "dial_code": "+692",
+      "symbol": "🇲🇭"
+    },
+    {
+      "code": "MQ",
+      "name": "Martinique",
+      "dial_code": "+596",
+      "symbol": "🇲🇶"
+    },
+    {
+      "code": "MR",
+      "name": "Mauritania",
+      "dial_code": "+222",
+      "symbol": "🇲🇷"
+    },
+    {
+      "code": "MU",
+      "name": "Mauritius",
+      "dial_code": "+230",
+      "symbol": "🇲🇺"
+    },
+    {
+      "code": "YT",
+      "name": "Mayotte",
+      "dial_code": "+262",
+      "symbol": "🇾🇹"
+    },
+    {
+      "code": "MX",
+      "name": "Mexico",
+      "dial_code": "+52",
+      "symbol": "🇲🇽"
+    },
+    {
+      "code": "FM",
+      "name": "Micronesia",
+      "dial_code": "+691",
+      "symbol": "🇫🇲"
+    },
+    {
+      "code": "MD",
+      "name": "Moldova",
+      "dial_code": "+373",
+      "symbol": "🇲🇩"
+    },
+    {
+      "code": "MC",
+      "name": "Monaco",
+      "dial_code": "+377",
+      "symbol": "🇲🇨"
+    },
+    {
+      "code": "MN",
+      "name": "Mongolia",
+      "dial_code": "+976",
+      "symbol": "🇲🇳"
+    },
+    {
+      "code": "ME",
+      "name": "Montenegro",
+      "dial_code": "+382",
+      "symbol": "🇲🇪"
+    },
+    {
+      "code": "MS",
+      "name": "Montserrat",
+      "dial_code": "+1",
+      "symbol": "🇲🇸"
+    },
+    {
+      "code": "MA",
+      "name": "Morocco",
+      "dial_code": "+212",
+      "symbol": "🇲🇦"
+    },
+    {
+      "code": "MZ",
+      "name": "Mozambique",
+      "dial_code": "+258",
+      "symbol": "🇲🇿"
+    },
+    {
+      "code": "MM",
+      "name": "Myanmar (Burma)",
+      "dial_code": "+95",
+      "symbol": "🇲🇲"
+    },
+    {
+      "code": "NA",
+      "name": "Namibia",
+      "dial_code": "+264",
+      "symbol": "🇳🇦"
+    },
+    {
+      "code": "NR",
+      "name": "Nauru",
+      "dial_code": "+674",
+      "symbol": "🇳🇷"
+    },
+    {
+      "code": "NP",
+      "name": "Nepal",
+      "dial_code": "+977",
+      "symbol": "🇳🇵"
+    },
+    {
+      "code": "NL",
+      "name": "Netherlands",
+      "dial_code": "+31",
+      "symbol": "🇳🇱"
+    },
+    {
+      "code": "NC",
+      "name": "New Caledonia",
+      "dial_code": "+687",
+      "symbol": "🇳🇨"
+    },
+    {
+      "code": "NZ",
+      "name": "New Zealand",
+      "dial_code": "+64",
+      "symbol": "🇳🇿"
+    },
+    {
+      "code": "NI",
+      "name": "Nicaragua",
+      "dial_code": "+505",
+      "symbol": "🇳🇮"
+    },
+    {
+      "code": "NE",
+      "name": "Niger",
+      "dial_code": "+227",
+      "symbol": "🇳🇪"
+    },
+    {
+      "code": "NG",
+      "name": "Nigeria",
+      "dial_code": "+234",
+      "symbol": "🇳🇬"
+    },
+    {
+      "code": "NU",
+      "name": "Niue",
+      "dial_code": "+683",
+      "symbol": "🇳🇺"
+    },
+    {
+      "code": "NF",
+      "name": "Norfolk Island",
+      "dial_code": "+672",
+      "symbol": "🇳🇫"
+    },
+    {
+      "code": "KP",
+      "name": "North Korea",
+      "dial_code": "+850",
+      "symbol": "🇰🇵"
+    },
+    {
+      "code": "MK",
+      "name": "North Macedonia",
+      "dial_code": "+389",
+      "symbol": "🇲🇰"
+    },
+    {
+      "code": "MP",
+      "name": "Northern Mariana Islands",
+      "dial_code": "+1",
+      "symbol": "🇲🇵"
+    },
+    {
+      "code": "NO",
+      "name": "Norway",
+      "dial_code": "+47",
+      "symbol": "🇳🇴"
+    },
+    {
+      "code": "OM",
+      "name": "Oman",
+      "dial_code": "+968",
+      "symbol": "🇴🇲"
+    },
+    {
+      "code": "PK",
+      "name": "Pakistan",
+      "dial_code": "+92",
+      "symbol": "🇵🇰"
+    },
+    {
+      "code": "PW",
+      "name": "Palau",
+      "dial_code": "+680",
+      "symbol": "🇵🇼"
+    },
+    {
+      "code": "PS",
+      "name": "Palestinian Territories",
+      "dial_code": "+970",
+      "symbol": "🇵🇸"
+    },
+    {
+      "code": "PA",
+      "name": "Panama",
+      "dial_code": "+507",
+      "symbol": "🇵🇦"
+    },
+    {
+      "code": "PG",
+      "name": "Papua New Guinea",
+      "dial_code": "+675",
+      "symbol": "🇵🇬"
+    },
+    {
+      "code": "PY",
+      "name": "Paraguay",
+      "dial_code": "+595",
+      "symbol": "🇵🇾"
+    },
+    {
+      "code": "PE",
+      "name": "Peru",
+      "dial_code": "+51",
+      "symbol": "🇵🇪"
+    },
+    {
+      "code": "PH",
+      "name": "Philippines",
+      "dial_code": "+63",
+      "symbol": "🇵🇭"
+    },
+    {
+      "code": "PL",
+      "name": "Poland",
+      "dial_code": "+48",
+      "symbol": "🇵🇱"
+    },
+    {
+      "code": "PT",
+      "name": "Portugal",
+      "dial_code": "+351",
+      "symbol": "🇵🇹"
+    },
+    {
+      "code": "PR",
+      "name": "Puerto Rico",
+      "dial_code": "+1",
+      "symbol": "🇵🇷"
+    },
+    {
+      "code": "QA",
+      "name": "Qatar",
+      "dial_code": "+974",
+      "symbol": "🇶🇦"
+    },
+    {
+      "code": "RE",
+      "name": "Réunion",
+      "dial_code": "+262",
+      "symbol": "🇷🇪"
+    },
+    {
+      "code": "RO",
+      "name": "Romania",
+      "dial_code": "+40",
+      "symbol": "🇷🇴"
+    },
+    {
+      "code": "RU",
+      "name": "Russia",
+      "dial_code": "+7",
+      "symbol": "🇷🇺"
+    },
+    {
+      "code": "RW",
+      "name": "Rwanda",
+      "dial_code": "+250",
+      "symbol": "🇷🇼"
+    },
+    {
+      "code": "WS",
+      "name": "Samoa",
+      "dial_code": "+685",
+      "symbol": "🇼🇸"
+    },
+    {
+      "code": "SM",
+      "name": "San Marino",
+      "dial_code": "+378",
+      "symbol": "🇸🇲"
+    },
+    {
+      "code": "ST",
+      "name": "São Tomé & Príncipe",
+      "dial_code": "+239",
+      "symbol": "🇸🇹"
+    },
+    {
+      "code": "SA",
+      "name": "Saudi Arabia",
+      "dial_code": "+966",
+      "symbol": "🇸🇦"
+    },
+    {
+      "code": "SN",
+      "name": "Senegal",
+      "dial_code": "+221",
+      "symbol": "🇸🇳"
+    },
+    {
+      "code": "RS",
+      "name": "Serbia",
+      "dial_code": "+381",
+      "symbol": "🇷🇸"
+    },
+    {
+      "code": "SC",
+      "name": "Seychelles",
+      "dial_code": "+248",
+      "symbol": "🇸🇨"
+    },
+    {
+      "code": "SL",
+      "name": "Sierra Leone",
+      "dial_code": "+232",
+      "symbol": "🇸🇱"
+    },
+    {
+      "code": "SG",
+      "name": "Singapore",
+      "dial_code": "+65",
+      "symbol": "🇸🇬"
+    },
+    {
+      "code": "SX",
+      "name": "Sint Maarten",
+      "dial_code": "+1",
+      "symbol": "🇸🇽"
+    },
+    {
+      "code": "SK",
+      "name": "Slovakia",
+      "dial_code": "+421",
+      "symbol": "🇸🇰"
+    },
+    {
+      "code": "SI",
+      "name": "Slovenia",
+      "dial_code": "+386",
+      "symbol": "🇸🇮"
+    },
+    {
+      "code": "SB",
+      "name": "Solomon Islands",
+      "dial_code": "+677",
+      "symbol": "🇸🇧"
+    },
+    {
+      "code": "SO",
+      "name": "Somalia",
+      "dial_code": "+252",
+      "symbol": "🇸🇴"
+    },
+    {
+      "code": "ZA",
+      "name": "South Africa",
+      "dial_code": "+27",
+      "symbol": "🇿🇦"
+    },
+    {
+      "code": "KR",
+      "name": "South Korea",
+      "dial_code": "+82",
+      "symbol": "🇰🇷"
+    },
+    {
+      "code": "SS",
+      "name": "South Sudan",
+      "dial_code": "+211",
+      "symbol": "🇸🇸"
+    },
+    {
+      "code": "ES",
+      "name": "Spain",
+      "dial_code": "+34",
+      "symbol": "🇪🇸"
+    },
+    {
+      "code": "LK",
+      "name": "Sri Lanka",
+      "dial_code": "+94",
+      "symbol": "🇱🇰"
+    },
+    {
+      "code": "BL",
+      "name": "St. Barthélemy",
+      "dial_code": "+590",
+      "symbol": "🇧🇱"
+    },
+    {
+      "code": "SH",
+      "name": "St. Helena",
+      "dial_code": "+290",
+      "symbol": "🇸🇭"
+    },
+    {
+      "code": "KN",
+      "name": "St. Kitts & Nevis",
+      "dial_code": "+1",
+      "symbol": "🇰🇳"
+    },
+    {
+      "code": "LC",
+      "name": "St. Lucia",
+      "dial_code": "+1",
+      "symbol": "🇱🇨"
+    },
+    {
+      "code": "MF",
+      "name": "St. Martin",
+      "dial_code": "+590",
+      "symbol": "🇲🇫"
+    },
+    {
+      "code": "PM",
+      "name": "St. Pierre & Miquelon",
+      "dial_code": "+508",
+      "symbol": "🇵🇲"
+    },
+    {
+      "code": "VC",
+      "name": "St. Vincent & Grenadines",
+      "dial_code": "+1",
+      "symbol": "🇻🇨"
+    },
+    {
+      "code": "SD",
+      "name": "Sudan",
+      "dial_code": "+249",
+      "symbol": "🇸🇩"
+    },
+    {
+      "code": "SR",
+      "name": "Suriname",
+      "dial_code": "+597",
+      "symbol": "🇸🇷"
+    },
+    {
+      "code": "SJ",
+      "name": "Svalbard & Jan Mayen",
+      "dial_code": "+47",
+      "symbol": "🇸🇯"
+    },
+    {
+      "code": "SE",
+      "name": "Sweden",
+      "dial_code": "+46",
+      "symbol": "🇸🇪"
+    },
+    {
+      "code": "CH",
+      "name": "Switzerland",
+      "dial_code": "+41",
+      "symbol": "🇨🇭"
+    },
+    {
+      "code": "SY",
+      "name": "Syria",
+      "dial_code": "+963",
+      "symbol": "🇸🇾"
+    },
+    {
+      "code": "TW",
+      "name": "Taiwan",
+      "dial_code": "+886",
+      "symbol": "🇹🇼"
+    },
+    {
+      "code": "TJ",
+      "name": "Tajikistan",
+      "dial_code": "+992",
+      "symbol": "🇹🇯"
+    },
+    {
+      "code": "TZ",
+      "name": "Tanzania",
+      "dial_code": "+255",
+      "symbol": "🇹🇿"
+    },
+    {
+      "code": "TH",
+      "name": "Thailand",
+      "dial_code": "+66",
+      "symbol": "🇹🇭"
+    },
+    {
+      "code": "TL",
+      "name": "Timor-Leste",
+      "dial_code": "+670",
+      "symbol": "🇹🇱"
+    },
+    {
+      "code": "TG",
+      "name": "Togo",
+      "dial_code": "+228",
+      "symbol": "🇹🇬"
+    },
+    {
+      "code": "TK",
+      "name": "Tokelau",
+      "dial_code": "+690",
+      "symbol": "🇹🇰"
+    },
+    {
+      "code": "TO",
+      "name": "Tonga",
+      "dial_code": "+676",
+      "symbol": "🇹🇴"
+    },
+    {
+      "code": "TT",
+      "name": "Trinidad & Tobago",
+      "dial_code": "+1",
+      "symbol": "🇹🇹"
+    },
+    {
+      "code": "TA",
+      "name": "Tristan da Cunha",
+      "dial_code": "+290",
+      "symbol": "🇹🇦"
+    },
+    {
+      "code": "TN",
+      "name": "Tunisia",
+      "dial_code": "+216",
+      "symbol": "🇹🇳"
+    },
+    {
+      "code": "TR",
+      "name": "Türkiye",
+      "dial_code": "+90",
+      "symbol": "🇹🇷"
+    },
+    {
+      "code": "TM",
+      "name": "Turkmenistan",
+      "dial_code": "+993",
+      "symbol": "🇹🇲"
+    },
+    {
+      "code": "TC",
+      "name": "Turks & Caicos Islands",
+      "dial_code": "+1",
+      "symbol": "🇹🇨"
+    },
+    {
+      "code": "TV",
+      "name": "Tuvalu",
+      "dial_code": "+688",
+      "symbol": "🇹🇻"
+    },
+    {
+      "code": "VI",
+      "name": "U.S. Virgin Islands",
+      "dial_code": "+1",
+      "symbol": "🇻🇮"
+    },
+    {
+      "code": "UG",
+      "name": "Uganda",
+      "dial_code": "+256",
+      "symbol": "🇺🇬"
+    },
+    {
+      "code": "UA",
+      "name": "Ukraine",
+      "dial_code": "+380",
+      "symbol": "🇺🇦"
+    },
+    {
+      "code": "AE",
+      "name": "United Arab Emirates",
+      "dial_code": "+971",
+      "symbol": "🇦🇪"
+    },
+    {
+      "code": "GB",
+      "name": "United Kingdom",
+      "dial_code": "+44",
+      "symbol": "🇬🇧"
+    },
+    {
+      "code": "UY",
+      "name": "Uruguay",
+      "dial_code": "+598",
+      "symbol": "🇺🇾"
+    },
+    {
+      "code": "UZ",
+      "name": "Uzbekistan",
+      "dial_code": "+998",
+      "symbol": "🇺🇿"
+    },
+    {
+      "code": "VU",
+      "name": "Vanuatu",
+      "dial_code": "+678",
+      "symbol": "🇻🇺"
+    },
+    {
+      "code": "VA",
+      "name": "Vatican City",
+      "dial_code": "+39",
+      "symbol": "🇻🇦"
+    },
+    {
+      "code": "VE",
+      "name": "Venezuela",
+      "dial_code": "+58",
+      "symbol": "🇻🇪"
+    },
+    {
+      "code": "VN",
+      "name": "Vietnam",
+      "dial_code": "+84",
+      "symbol": "🇻🇳"
+    },
+    {
+      "code": "WF",
+      "name": "Wallis & Futuna",
+      "dial_code": "+681",
+      "symbol": "🇼🇫"
+    },
+    {
+      "code": "EH",
+      "name": "Western Sahara",
+      "dial_code": "+212",
+      "symbol": "🇪🇭"
+    },
+    {
+      "code": "YE",
+      "name": "Yemen",
+      "dial_code": "+967",
+      "symbol": "🇾🇪"
+    },
+    {
+      "code": "ZM",
+      "name": "Zambia",
+      "dial_code": "+260",
+      "symbol": "🇿🇲"
+    },
+    {
+      "code": "ZW",
+      "name": "Zimbabwe",
+      "dial_code": "+263",
+      "symbol": "🇿🇼"
+    }
+  ]
+}

tasks/taskrabbit/solution/site/implementation/clone/frontend/services_catalog.json

@@ -0,0 +1,919 @@
+{
+  "schema_version": "websitebench.taskrabbit.services-catalog.v1",
+  "source_capture": "source-current/2026-07-29-v3/browser/services-dom.html",
+  "hero": {
+    "heading": "Your to-do list is on us.",
+    "subtitle": "Hire a trusted Tasker presto.",
+    "image": "/static/category-assets/services/xabvokgynbkytiuukhqq-w1920.webp"
+  },
+  "groups": [
+    {
+      "label": "Featured Tasks",
+      "href": "/services/featured",
+      "image": "/static/category-assets/services/uvhli36lpkyxpgrkwblj-w640.webp",
+      "subtitle": "Let Taskers help tackle your to-do list.",
+      "services": [
+        {
+          "label": "Furniture Assembly",
+          "href": "/services/featured/assemble-furniture"
+        },
+        {
+          "label": "Home Repairs",
+          "href": "/services/featured/general-handyman"
+        },
+        {
+          "label": "Help Moving",
+          "href": "/services/featured/help-moving"
+        },
+        {
+          "label": "Yard Work Services",
+          "href": "/services/featured/yard-work-removal"
+        },
+        {
+          "label": "Spring Cleaning",
+          "href": "/services/featured/spring-cleaning"
+        },
+        {
+          "label": "TV Mounting",
+          "href": "/services/featured/wall-mount-tv"
+        },
+        {
+          "label": "Plumbing",
+          "href": "/services/featured/plumbing"
+        },
+        {
+          "label": "Hang Art, Mirror & Decor",
+          "href": "/services/featured/hang-pictures"
+        },
+        {
+          "label": "Electrical Help",
+          "href": "/services/featured/electrical-work"
+        },
+        {
+          "label": "Wait in Line",
+          "href": "/services/featured/waiting-in-line"
+        },
+        {
+          "label": "Closet Organization Service",
+          "href": "/services/featured/closet-organization"
+        }
+      ]
+    },
+    {
+      "label": "Handyman",
+      "href": "/services/handyman",
+      "image": "/static/category-assets/services/iakiz9oyfy0rt5tcw74k-w640.webp",
+      "subtitle": "Hire a Tasker for help around the house",
+      "services": [
+        {
+          "label": "Door, Cabinet, & Furniture Repair",
+          "href": "/services/handyman/door-and-cabinet-repair"
+        },
+        {
+          "label": "Appliance Installation & Repairs",
+          "href": "/services/handyman/appliance-repairs"
+        },
+        {
+          "label": "Furniture Assembly",
+          "href": "/services/handyman/assemble-furniture"
+        },
+        {
+          "label": "TV Mounting",
+          "href": "/services/handyman/wall-mount-tv"
+        },
+        {
+          "label": "Drywall Repair Service",
+          "href": "/services/handyman/drywall-repair"
+        },
+        {
+          "label": "Flooring & Tiling Help",
+          "href": "/services/handyman/flooring-tiling-help"
+        },
+        {
+          "label": "Electrical Help",
+          "href": "/services/handyman/electrical-work"
+        },
+        {
+          "label": "Sealing & Caulking",
+          "href": "/services/handyman/sealing-caulking"
+        },
+        {
+          "label": "Plumbing",
+          "href": "/services/handyman/plumbing"
+        },
+        {
+          "label": "Window & Blinds Repair",
+          "href": "/services/handyman/window-repair"
+        },
+        {
+          "label": "Ceiling Fan Installation",
+          "href": "/services/handyman/ceiling-fan-installation"
+        },
+        {
+          "label": "Smart Home Installation",
+          "href": "/services/handyman/smart-home-installation"
+        },
+        {
+          "label": "Heavy Lifting",
+          "href": "/services/handyman/heavy-lifting"
+        },
+        {
+          "label": "Install Air Conditioner",
+          "href": "/services/handyman/install-air-conditioner"
+        },
+        {
+          "label": "Painting",
+          "href": "/services/handyman/painting"
+        },
+        {
+          "label": "Install Shelves, Rods & Hooks",
+          "href": "/services/handyman/shelf-mounting"
+        },
+        {
+          "label": "Home Maintenance",
+          "href": "/services/handyman/home-maintenance"
+        },
+        {
+          "label": "Install Blinds & Window Treatments",
+          "href": "/services/handyman/blinds-installation"
+        },
+        {
+          "label": "Home Repairs",
+          "href": "/services/handyman/general-handyman"
+        },
+        {
+          "label": "Baby Proofing",
+          "href": "/services/handyman/baby-proofing"
+        },
+        {
+          "label": "Yard Work Services",
+          "href": "/services/handyman/yard-work-removal"
+        },
+        {
+          "label": "Light Installation",
+          "href": "/services/handyman/light-installation"
+        },
+        {
+          "label": "Carpentry Services",
+          "href": "/services/handyman/carpentry-construction"
+        },
+        {
+          "label": "Hang Art, Mirror & Decor",
+          "href": "/services/handyman/hang-pictures"
+        },
+        {
+          "label": "General Mounting",
+          "href": "/services/handyman/mounting-all"
+        },
+        {
+          "label": "Cabinet Installation",
+          "href": "/services/handyman/cabinet-installation"
+        },
+        {
+          "label": "Wallpapering Service",
+          "href": "/services/handyman/wallpapering"
+        },
+        {
+          "label": "Fence Installation & Repair Services",
+          "href": "/services/handyman/fence-installation"
+        },
+        {
+          "label": "Deck Restoration Services",
+          "href": "/services/handyman/deck-restoration"
+        },
+        {
+          "label": "Doorbell Installation",
+          "href": "/services/handyman/doorbell-installation"
+        },
+        {
+          "label": "Home Theater Installing",
+          "href": "/services/handyman/home-theater-setup"
+        }
+      ]
+    },
+    {
+      "label": "Moving Services",
+      "href": "/services/moving",
+      "image": "/static/category-assets/services/qsneajnue7udlov0smkb-w640.webp",
+      "subtitle": "From the heavy lifting to unpacking and organizing make your move with Taskrabbit!",
+      "services": [
+        {
+          "label": "Help Moving",
+          "href": "/services/moving/help-moving"
+        },
+        {
+          "label": "Truck Assisted Help Moving",
+          "href": "/services/moving/truck-assisted-help-moving"
+        },
+        {
+          "label": "Packing Services & Help",
+          "href": "/services/moving/packing"
+        },
+        {
+          "label": "Unpacking Services",
+          "href": "/services/moving/unpacking"
+        },
+        {
+          "label": "Heavy Lifting",
+          "href": "/services/moving/heavy-lifting"
+        },
+        {
+          "label": "Local Movers",
+          "href": "/services/moving/local-movers"
+        },
+        {
+          "label": "Junk Pickup",
+          "href": "/services/moving/junk-removal"
+        },
+        {
+          "label": "Furniture Movers",
+          "href": "/services/moving/furniture-movers"
+        },
+        {
+          "label": "One Item Movers",
+          "href": "/services/moving/one-piece-of-furniture"
+        },
+        {
+          "label": "Storage Unit Moving",
+          "href": "/services/moving/storage-unit-moving"
+        },
+        {
+          "label": "Couch Removal",
+          "href": "/services/moving/couch-removal"
+        },
+        {
+          "label": "Mattress Pick-Up & Removal",
+          "href": "/services/moving/mattress-removal"
+        },
+        {
+          "label": "Furniture Removal",
+          "href": "/services/moving/furniture-removal"
+        },
+        {
+          "label": "Pool Table Movers",
+          "href": "/services/moving/pool-table-movers"
+        },
+        {
+          "label": "Appliance Removal",
+          "href": "/services/moving/appliance-removal"
+        },
+        {
+          "label": "Heavy Furniture Moving",
+          "href": "/services/moving/heavy-furniture"
+        },
+        {
+          "label": "Rearranging Furniture",
+          "href": "/services/moving/rearranging-furniture"
+        },
+        {
+          "label": "Full Service Help Moving",
+          "href": "/services/moving/full-service-movers"
+        },
+        {
+          "label": "In-Home Furniture Movers",
+          "href": "/services/moving/in-home-furniture-movers"
+        }
+      ]
+    },
+    {
+      "label": "Furniture Assembly",
+      "href": "/services/furniture-assembly",
+      "image": "/static/category-assets/services/qlnbm9iobu3jukhqw5q1-w640.webp",
+      "subtitle": "Furniture Assembly",
+      "services": [
+        {
+          "label": "Furniture Assembly",
+          "href": "/services/furniture-assembly/assemble-furniture"
+        },
+        {
+          "label": "Patio Furniture Assembly",
+          "href": "/services/furniture-assembly/patio-furniture-assembly"
+        },
+        {
+          "label": "Desk Assembly",
+          "href": "/services/furniture-assembly/desk-assembly"
+        },
+        {
+          "label": "Dresser Assembly",
+          "href": "/services/furniture-assembly/dresser-assembly"
+        },
+        {
+          "label": "Bed Assembly",
+          "href": "/services/furniture-assembly/bed-assembly"
+        },
+        {
+          "label": "Bookshelf Assembly",
+          "href": "/services/furniture-assembly/bookshelf-assembly"
+        },
+        {
+          "label": "Couch Assembly",
+          "href": "/services/furniture-assembly/couch-assembly"
+        },
+        {
+          "label": "Chair Assembly",
+          "href": "/services/furniture-assembly/chair-assembly"
+        },
+        {
+          "label": "Wardrobe Assembly",
+          "href": "/services/furniture-assembly/wardrobe-assembly"
+        },
+        {
+          "label": "Table Assembly",
+          "href": "/services/furniture-assembly/table-assembly"
+        },
+        {
+          "label": "Disassemble furniture",
+          "href": "/services/furniture-assembly/furniture-disassembly"
+        }
+      ]
+    },
+    {
+      "label": "Mounting & Installation",
+      "href": "/services/mounting",
+      "image": "/static/category-assets/services/cm4icsesada13e5qwvwe-w640.webp",
+      "subtitle": "Wall Mounting",
+      "services": [
+        {
+          "label": "TV Mounting",
+          "href": "/services/mounting/wall-mount-tv"
+        },
+        {
+          "label": "Install Shelves, Rods & Hooks",
+          "href": "/services/mounting/shelf-mounting"
+        },
+        {
+          "label": "Ceiling Fan Installation",
+          "href": "/services/mounting/ceiling-fan-installation"
+        },
+        {
+          "label": "Install Blinds & Window Treatments",
+          "href": "/services/mounting/blinds-installation"
+        },
+        {
+          "label": "Hang Art, Mirror & Decor",
+          "href": "/services/mounting/hang-pictures"
+        },
+        {
+          "label": "General Mounting",
+          "href": "/services/mounting/mounting-all"
+        },
+        {
+          "label": "Hang Christmas Lights",
+          "href": "/services/mounting/christmas-light-installation"
+        }
+      ]
+    },
+    {
+      "label": "Cleaning",
+      "href": "/services/cleaning",
+      "image": "/static/category-assets/services/v4derwxej8iigyyri4ua-w640.webp",
+      "subtitle": "Taskers will make your home sparkle!",
+      "services": [
+        {
+          "label": "House Cleaning Services",
+          "href": "/services/cleaning/house-cleaning"
+        },
+        {
+          "label": "Deep Cleaning",
+          "href": "/services/cleaning/deep-cleaning"
+        },
+        {
+          "label": "Disinfecting Services",
+          "href": "/services/cleaning/disinfecting-service"
+        },
+        {
+          "label": "Move In Cleaning",
+          "href": "/services/cleaning/move-in"
+        },
+        {
+          "label": "Move Out Cleaning",
+          "href": "/services/cleaning/move-out"
+        },
+        {
+          "label": "Vacation Rental Cleaning",
+          "href": "/services/cleaning/airbnb"
+        },
+        {
+          "label": "Carpet Cleaning Service",
+          "href": "/services/cleaning/carpet-cleaning"
+        },
+        {
+          "label": "Garage Cleaning",
+          "href": "/services/cleaning/garage-cleaning"
+        },
+        {
+          "label": "One Time Cleaning Services",
+          "href": "/services/cleaning/one-time"
+        },
+        {
+          "label": "Car Washing",
+          "href": "/services/cleaning/mobile-car-wash"
+        },
+        {
+          "label": "Laundry Help",
+          "href": "/services/cleaning/laundry-help"
+        },
+        {
+          "label": "Pressure Washing",
+          "href": "/services/cleaning/pressure-washing"
+        },
+        {
+          "label": "Spring Cleaning",
+          "href": "/services/cleaning/spring-cleaning"
+        }
+      ]
+    },
+    {
+      "label": "Shopping + Delivery",
+      "href": "/services/shopping-delivery",
+      "image": "/static/category-assets/services/jymnwqzhwmi9gt5ppz8d-w640.webp",
+      "subtitle": "Get anything from groceries to furniture",
+      "services": [
+        {
+          "label": "Delivery Service",
+          "href": "/services/shopping-delivery/delivery-service"
+        },
+        {
+          "label": "Grocery Shopping & Delivery",
+          "href": "/services/shopping-delivery/grocery-shopping"
+        },
+        {
+          "label": "Running Your Errands",
+          "href": "/services/shopping-delivery/run-errands"
+        },
+        {
+          "label": "Christmas Tree Delivery",
+          "href": "/services/shopping-delivery/christmas-tree-delivery"
+        },
+        {
+          "label": "Wait in Line",
+          "href": "/services/shopping-delivery/waiting-in-line"
+        },
+        {
+          "label": "Deliver Big Piece of Furniture",
+          "href": "/services/shopping-delivery/deliver-big-piece-of-furniture"
+        },
+        {
+          "label": "Drop Off Donations",
+          "href": "/services/shopping-delivery/drop-off-donations"
+        },
+        {
+          "label": "Contactless Delivery",
+          "href": "/services/shopping-delivery/pick-up-delivery"
+        },
+        {
+          "label": "Pet Food Delivery",
+          "href": "/services/shopping-delivery/dog-food-delivery"
+        },
+        {
+          "label": "Baby Food Delivery",
+          "href": "/services/shopping-delivery/baby-food-delivery"
+        },
+        {
+          "label": "Return Items",
+          "href": "/services/shopping-delivery/return-items"
+        },
+        {
+          "label": "Wait for Delivery",
+          "href": "/services/shopping-delivery/wait-for-delivery"
+        },
+        {
+          "label": "Shipping",
+          "href": "/services/shopping-delivery/shipping"
+        },
+        {
+          "label": "Breakfast Delivery",
+          "href": "/services/shopping-delivery/breakfast-delivery"
+        },
+        {
+          "label": "Coffee Delivery",
+          "href": "/services/shopping-delivery/coffee-delivery"
+        }
+      ]
+    },
+    {
+      "label": "IKEA Services",
+      "href": "/services/ikea-services",
+      "image": "/static/category-assets/services/zpfridasq1xhzgjbkhgz-w640.webp",
+      "subtitle": "Hire a Tasker for all your IKEA needs",
+      "services": [
+        {
+          "label": "Light Installation",
+          "href": "/services/ikea-services/light-installation"
+        },
+        {
+          "label": "Furniture Removal",
+          "href": "/services/ikea-services/furniture-removal"
+        },
+        {
+          "label": "Smart Home Installation",
+          "href": "/services/ikea-services/smart-home-installation"
+        },
+        {
+          "label": "Organization",
+          "href": "/services/ikea-services/organization"
+        },
+        {
+          "label": "Furniture Assembly",
+          "href": "/services/ikea-services/assemble-furniture"
+        },
+        {
+          "label": "General Mounting",
+          "href": "/services/ikea-services/mounting-all"
+        }
+      ]
+    },
+    {
+      "label": "Yardwork Services",
+      "href": "/services/yardwork-removal",
+      "image": "/static/category-assets/services/vg0ayodhdpmqj07ypkoa-w640.webp",
+      "subtitle": "Hire a Tasker to help with yardwork & landscaping!",
+      "services": [
+        {
+          "label": "Gardening Services",
+          "href": "/services/yardwork-removal/gardening"
+        },
+        {
+          "label": "Weed Removal",
+          "href": "/services/yardwork-removal/weeding"
+        },
+        {
+          "label": "Lawn Care Services",
+          "href": "/services/yardwork-removal/lawn-care"
+        },
+        {
+          "label": "Lawn Mowing Services",
+          "href": "/services/yardwork-removal/lawn-mowing"
+        },
+        {
+          "label": "Landscaping Services",
+          "href": "/services/yardwork-removal/landscaping"
+        },
+        {
+          "label": "Gutter Cleaning",
+          "href": "/services/yardwork-removal/gutter-cleaning"
+        },
+        {
+          "label": "Tree Trimming Service",
+          "href": "/services/yardwork-removal/tree-trimming"
+        },
+        {
+          "label": "Vacation Plant Watering",
+          "href": "/services/yardwork-removal/vacation-plant-watering"
+        },
+        {
+          "label": "Patio Cleaning",
+          "href": "/services/yardwork-removal/patio-cleaning"
+        },
+        {
+          "label": "Hot Tub Cleaning",
+          "href": "/services/yardwork-removal/hot-tub-cleaning"
+        },
+        {
+          "label": "Fence Installation & Repair Services",
+          "href": "/services/yardwork-removal/fence-installation"
+        },
+        {
+          "label": "Deck Restoration Services",
+          "href": "/services/yardwork-removal/deck-restoration"
+        },
+        {
+          "label": "Patio Furniture Assembly",
+          "href": "/services/yardwork-removal/patio-furniture-assembly"
+        },
+        {
+          "label": "Fence Staining",
+          "href": "/services/yardwork-removal/fence-staining"
+        },
+        {
+          "label": "Mulching Services",
+          "href": "/services/yardwork-removal/mulching"
+        },
+        {
+          "label": "Lawn Fertilizer Service",
+          "href": "/services/yardwork-removal/lawn-fertilizer"
+        },
+        {
+          "label": "Hedge Trimming Service",
+          "href": "/services/yardwork-removal/hedge-trimming"
+        },
+        {
+          "label": "Outdoor Party Setup",
+          "href": "/services/yardwork-removal/outdoor-party-setup"
+        },
+        {
+          "label": "Urban Gardening Service",
+          "href": "/services/yardwork-removal/urban-gardening"
+        },
+        {
+          "label": "Leaf Raking & Removal",
+          "href": "/services/yardwork-removal/leaf-removal"
+        },
+        {
+          "label": "Produce Gardening",
+          "href": "/services/yardwork-removal/produce-gardening"
+        },
+        {
+          "label": "Hose Installation",
+          "href": "/services/yardwork-removal/hose-installation"
+        },
+        {
+          "label": "Shed Maintenance",
+          "href": "/services/yardwork-removal/shed-maintenance"
+        },
+        {
+          "label": "Pressure Washing",
+          "href": "/services/yardwork-removal/pressure-washing"
+        }
+      ]
+    },
+    {
+      "label": "Holidays",
+      "href": "/services/holidays",
+      "image": "/static/category-assets/services/blxahxpngxgsm9tzdm4v-w640.webp",
+      "subtitle": "Holiday Help",
+      "services": [
+        {
+          "label": "Gift Wrapping Services",
+          "href": "/services/holidays/gift-wrapping"
+        },
+        {
+          "label": "Hang Christmas Lights",
+          "href": "/services/holidays/christmas-light-installation"
+        },
+        {
+          "label": "Christmas Tree Delivery",
+          "href": "/services/holidays/christmas-tree-delivery"
+        },
+        {
+          "label": "Holiday Decorating",
+          "href": "/services/holidays/christmas-decorator"
+        },
+        {
+          "label": "Party Cleaning",
+          "href": "/services/holidays/party-cleaning"
+        },
+        {
+          "label": "Toy Assembly Service",
+          "href": "/services/holidays/toy-assembly"
+        },
+        {
+          "label": "Wait in Line",
+          "href": "/services/holidays/waiting-in-line"
+        },
+        {
+          "label": "Christmas Tree Removal",
+          "href": "/services/holidays/tree-removal"
+        }
+      ]
+    },
+    {
+      "label": "Winter Tasks",
+      "href": "/services/winter-tasks",
+      "image": "/static/category-assets/services/b8zxzgkmmy0hxjrca1sr-w640.webp",
+      "subtitle": "Get help with winter tasks",
+      "services": [
+        {
+          "label": "Snow Removal",
+          "href": "/services/winter-tasks/snow-removal"
+        },
+        {
+          "label": "Sidewalk Salting",
+          "href": "/services/winter-tasks/sidewalk-snow-removal"
+        },
+        {
+          "label": "Window Winterization",
+          "href": "/services/winter-tasks/window-winterization"
+        },
+        {
+          "label": "Residential Snow Removal",
+          "href": "/services/winter-tasks/residential-snow-removal"
+        },
+        {
+          "label": "Christmas Tree Removal",
+          "href": "/services/winter-tasks/tree-removal"
+        },
+        {
+          "label": "AC Winterization",
+          "href": "/services/winter-tasks/ac-winterization"
+        },
+        {
+          "label": "Winter Yardwork",
+          "href": "/services/winter-tasks/winter-yardwork"
+        },
+        {
+          "label": "Pipe Insulation",
+          "href": "/services/winter-tasks/pipe-insulation"
+        },
+        {
+          "label": "Storm Door Installation",
+          "href": "/services/winter-tasks/storm-door-installation"
+        },
+        {
+          "label": "Winter Deck Maintenance",
+          "href": "/services/winter-tasks/winter-deck-maintenance"
+        },
+        {
+          "label": "Water Heater Maintenance",
+          "href": "/services/winter-tasks/water-heater-maintenance"
+        },
+        {
+          "label": "Wait in Line",
+          "href": "/services/winter-tasks/waiting-in-line"
+        }
+      ]
+    },
+    {
+      "label": "Personal Assistant",
+      "href": "/services/personal-assistant",
+      "image": "/static/category-assets/services/nqbgzuk5vyyok4fud9ek-w640.webp",
+      "subtitle": "Hire a Tasker to be your personal assistant! Get help on an hourly or ongoing basis.",
+      "services": [
+        {
+          "label": "Personal Assistant",
+          "href": "/services/personal-assistant/personal-assistant"
+        },
+        {
+          "label": "Running Your Errands",
+          "href": "/services/personal-assistant/run-errands"
+        },
+        {
+          "label": "Wait in Line",
+          "href": "/services/personal-assistant/waiting-in-line"
+        },
+        {
+          "label": "Organization",
+          "href": "/services/personal-assistant/organization"
+        },
+        {
+          "label": "Organize Home",
+          "href": "/services/personal-assistant/home-organization"
+        },
+        {
+          "label": "Closet Organization Service",
+          "href": "/services/personal-assistant/closet-organization"
+        },
+        {
+          "label": "Interior Design Service",
+          "href": "/services/personal-assistant/interior-design"
+        },
+        {
+          "label": "Virtual Assistant",
+          "href": "/services/personal-assistant/virtual-assistant"
+        }
+      ]
+    },
+    {
+      "label": "Baby Prep",
+      "href": "/services/baby-prep",
+      "image": "/static/category-assets/services/c9v2pvqasz3zdicwoz9z-w640.webp",
+      "subtitle": "Set up the nursery, childproof your home, and more.",
+      "services": [
+        {
+          "label": "Baby Proofing",
+          "href": "/services/baby-prep/baby-proofing"
+        },
+        {
+          "label": "Baby Food Delivery",
+          "href": "/services/baby-prep/baby-food-delivery"
+        },
+        {
+          "label": "Organize a Room",
+          "href": "/services/baby-prep/organize-a-room"
+        },
+        {
+          "label": "Painting",
+          "href": "/services/baby-prep/painting"
+        },
+        {
+          "label": "Toy Assembly Service",
+          "href": "/services/baby-prep/toy-assembly"
+        },
+        {
+          "label": "Smart Home Installation",
+          "href": "/services/baby-prep/smart-home-installation"
+        },
+        {
+          "label": "Shopping",
+          "href": "/services/baby-prep/need-us-to-shop-for-something"
+        },
+        {
+          "label": "General Cleaning",
+          "href": "/services/baby-prep/need-something-else-cleaned"
+        }
+      ]
+    },
+    {
+      "label": "Virtual & Online Tasks",
+      "href": "/services/online-tasks",
+      "image": "/static/category-assets/services/o6a4y0b3tps7vd1l73vm-w640.webp",
+      "subtitle": "Virtual assistance, organization, research, & more",
+      "services": [
+        {
+          "label": "Virtual Assistant",
+          "href": "/services/online-tasks/virtual-assistant"
+        },
+        {
+          "label": "Organization",
+          "href": "/services/online-tasks/organization"
+        },
+        {
+          "label": "Data Entry",
+          "href": "/services/online-tasks/data-entry-clerk"
+        },
+        {
+          "label": "Computer Help",
+          "href": "/services/online-tasks/computer-help"
+        }
+      ]
+    },
+    {
+      "label": "Office Services",
+      "href": "/services/office",
+      "image": "/static/category-assets/services/lisxdsrupath54uwhuda-w640.webp",
+      "subtitle": "Hire a Tasker to help around the office!",
+      "services": [
+        {
+          "label": "Office Cleaning",
+          "href": "/services/office/commercial-cleaning"
+        },
+        {
+          "label": "Office Tech Setup",
+          "href": "/services/office/conference-room"
+        },
+        {
+          "label": "Office Movers",
+          "href": "/services/office/movers"
+        },
+        {
+          "label": "Office Supply & Snack Delivery",
+          "href": "/services/office/supply-snack-delivery"
+        },
+        {
+          "label": "Office Furniture Assembly",
+          "href": "/services/office/furniture-assembly-setup"
+        },
+        {
+          "label": "Office Setup & Organization",
+          "href": "/services/office/organization-setup"
+        },
+        {
+          "label": "Office Administration",
+          "href": "/services/office/office-administration"
+        },
+        {
+          "label": "Office Interior Design",
+          "href": "/services/office/office-interior-design"
+        },
+        {
+          "label": "Moving Office Furniture",
+          "href": "/services/office/office-furniture-moving"
+        },
+        {
+          "label": "Office Mounting Service",
+          "href": "/services/office/office-mounting"
+        }
+      ]
+    },
+    {
+      "label": "Contactless Tasks",
+      "href": "/services/contactless",
+      "image": "/static/category-assets/services/lhzrtzwcud6onusl4sef-w640.webp",
+      "subtitle": "No-contact delivery, shopping, errands",
+      "services": [
+        {
+          "label": "Contactless Delivery",
+          "href": "/services/contactless/pick-up-delivery"
+        },
+        {
+          "label": "Contactless Prescription Pick-up & Delivery",
+          "href": "/services/contactless/prescription-delivery"
+        },
+        {
+          "label": "Running Your Errands",
+          "href": "/services/contactless/run-errands"
+        },
+        {
+          "label": "Grocery Shopping & Delivery",
+          "href": "/services/contactless/grocery-shopping"
+        },
+        {
+          "label": "Disinfecting Services",
+          "href": "/services/contactless/disinfecting-service"
+        },
+        {
+          "label": "Drop Off Donations",
+          "href": "/services/contactless/drop-off-donations"
+        },
+        {
+          "label": "Yard Work Services",
+          "href": "/services/contactless/yard-work-removal"
+        },
+        {
+          "label": "Virtual Assistant",
+          "href": "/services/contactless/virtual-assistant"
+        }
+      ]
+    }
+  ]
+}

tasks/taskrabbit/solution/site/implementation/clone/harbor_entry.py

@@ -0,0 +1,184 @@
+"""WebsiteBench Harbor foreground entrypoint for the frozen clone."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import smtplib
+import urllib.error
+import urllib.parse
+import urllib.request
+from email.message import EmailMessage
+from http.cookies import SimpleCookie
+from pathlib import Path
+
+import uvicorn
+
+
+ROOT = Path(__file__).resolve().parent
+SITE_ROOT = ROOT.parent
+RUNTIME = json.loads((SITE_ROOT / "backend" / "runtime.json").read_text(encoding="utf-8"))
+SITE_ID = str(RUNTIME["site"]["id"])
+DATA_DIR = Path(os.environ["DATA_DIR"])
+if not DATA_DIR.is_absolute():
+    raise RuntimeError("DATA_DIR must be absolute")
+DATA_DIR = DATA_DIR.resolve()
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+os.environ["WEBSITEBENCH_DATA_DIR"] = str(DATA_DIR)
+os.environ["WEBSITEBENCH_SITE_BACKEND_RUNTIME"] = str(SITE_ROOT / "backend" / "runtime.json")
+os.environ["WEBSITEBENCH_SITE_BACKEND_DATABASE"] = str(DATA_DIR / RUNTIME["database"]["filename"])
+if os.environ.get("WEBSITEBENCH_MAILBOX_BOOTSTRAP_URL", "").strip():
+    os.environ["WEBSITEBENCH_DEPLOYMENT_PROFILE"] = "offline-harbor"
+os.environ["WEBSITEBENCH_PAYMENT_PROFILE"] = "local-sandbox"
+
+
+class _NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, request, fp, code, msg, headers, newurl):
+        del request, fp, code, msg, headers, newurl
+        return None
+
+
+def _harbor_mailbox_identity() -> dict[str, object] | None:
+    """Acquire a short-lived mailbox capability from a loopback bootstrap."""
+
+    bootstrap_url = os.environ.get("WEBSITEBENCH_MAILBOX_BOOTSTRAP_URL", "").strip()
+    bootstrap_token = os.environ.get(
+        "WEBSITEBENCH_MAILBOX_BOOTSTRAP_TOKEN", ""
+    ).strip()
+    if not bootstrap_url and not bootstrap_token:
+        return None
+    parsed = urllib.parse.urlsplit(bootstrap_url)
+    if (
+        parsed.scheme != "http"
+        or parsed.hostname not in {
+            "127.0.0.1",
+            "::1",
+            "localhost",
+            "mailbox-internal",
+        }
+        or parsed.username is not None
+        or parsed.password is not None
+        or len(bootstrap_token) < 32
+    ):
+        raise RuntimeError("Harbor mailbox bootstrap configuration is invalid")
+    request = urllib.request.Request(
+        bootstrap_url,
+        headers={
+            "Accept": "application/json",
+            "Authorization": f"Bearer {bootstrap_token}",
+        },
+        method="GET",
+    )
+    try:
+        with urllib.request.build_opener(_NoRedirect).open(
+            request, timeout=10
+        ) as response:
+            raw = response.read(64 * 1024 + 1)
+    except (OSError, urllib.error.URLError) as exc:
+        raise RuntimeError("Harbor mailbox bootstrap is unavailable") from exc
+    if len(raw) > 64 * 1024:
+        raise RuntimeError("Harbor mailbox bootstrap response is too large")
+    try:
+        identity = json.loads(raw.decode("utf-8"))
+        namespace = str(identity["namespace"])
+        capability = str(identity["capability"])
+        smtp_host = str(identity["smtp_host"])
+        smtp_port = int(identity["smtp_port"])
+    except (KeyError, TypeError, ValueError, UnicodeError, json.JSONDecodeError) as exc:
+        raise RuntimeError("Harbor mailbox bootstrap response is invalid") from exc
+    if (
+        re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]*", namespace) is None
+        or len(namespace) > 128
+        or len(capability) < 32
+        or smtp_host not in {"127.0.0.1", "::1", "localhost", "mailbox-internal"}
+        or not 1 <= smtp_port <= 65535
+    ):
+        raise RuntimeError("Harbor mailbox identity is invalid")
+    return {
+        "namespace": namespace,
+        "capability": capability,
+        "smtp_host": smtp_host,
+        "smtp_port": smtp_port,
+    }
+
+
+MAILBOX_IDENTITY = _harbor_mailbox_identity()
+DELIVERED_MAIL_IDS: set[int] = set()
+
+import app as clone_module  # noqa: E402
+
+clone_app = clone_module.app
+
+
+def _session_tokens(scope, response_headers: list[tuple[bytes, bytes]]) -> set[str]:
+    tokens: set[str] = set()
+    raw_cookies = [
+        value.decode("latin-1")
+        for name, value in scope.get("headers", [])
+        if name.lower() == b"cookie"
+    ]
+    raw_cookies.extend(
+        value.decode("latin-1")
+        for name, value in response_headers
+        if name.lower() == b"set-cookie"
+    )
+    for raw in raw_cookies:
+        parsed = SimpleCookie()
+        try:
+            parsed.load(raw)
+        except Exception:
+            continue
+        name = clone_module.SESSION_COOKIE
+        if name in parsed and parsed[name].value:
+            tokens.add(parsed[name].value)
+    return tokens
+
+
+def _deliver_harbor_mail(session_tokens: set[str]) -> None:
+    """Compatibility hook; the auth store delivers synchronously to Mailpit."""
+
+    return None
+
+HEALTH_BODY = b'{"status":"ok"}'
+# /healthz is the contract (ADR-0010); the private path stays mounted
+# so bundles frozen before the migration keep answering.
+HEALTH_PATHS = ("/healthz", "/__websitebench/health")
+
+
+async def application(scope, receive, send):
+    if scope.get("type") == "http" and scope.get("path") in HEALTH_PATHS:
+        await send({
+            "type": "http.response.start",
+            "status": 200,
+            "headers": [
+                (b"content-type", b"application/json"),
+                (b"content-length", str(len(HEALTH_BODY)).encode("ascii")),
+                (b"cache-control", b"no-store"),
+            ],
+        })
+        await send({"type": "http.response.body", "body": HEALTH_BODY})
+        return
+    response_headers: list[tuple[bytes, bytes]] = []
+
+    async def deliver_before_final_body(message):
+        if message.get("type") == "http.response.start":
+            response_headers[:] = list(message.get("headers", []))
+        if (
+            message.get("type") == "http.response.body"
+            and not message.get("more_body", False)
+        ):
+            _deliver_harbor_mail(_session_tokens(scope, response_headers))
+        await send(message)
+
+    await clone_app(scope, receive, deliver_before_final_body)
+
+
+if __name__ == "__main__":
+    uvicorn.run(
+        application,
+        host=os.environ["HOST"],
+        port=int(os.environ["PORT"]),
+        access_log=False,
+        timeout_graceful_shutdown=2,
+    )

tasks/taskrabbit/solution/site/implementation/clone/static/app.js

@@ -0,0 +1,535 @@
+/* Taskrabbit navigation, overlay, and booking-form behavior. */
+
+(function () {
+  "use strict";
+
+  function ready(fn) {
+    if (document.readyState !== "loading") { fn(); return; }
+    document.addEventListener("DOMContentLoaded", fn);
+  }
+
+  ready(function () {
+    // Mobile navigation toggle (390 viewport).
+    var toggle = document.querySelector(".nav-toggle");
+    var nav = document.getElementById("main-nav");
+    if (toggle && nav) {
+      toggle.addEventListener("click", function () {
+        var expanded = toggle.getAttribute("aria-expanded") === "true";
+        toggle.setAttribute("aria-expanded", String(!expanded));
+        nav.classList.toggle("open", !expanded);
+      });
+    }
+
+    // Help overlay: open via trigger, close via button or Escape,
+    // and restore focus to the opener on close.
+    var trigger = document.querySelector(".help-trigger");
+    var dialog = document.getElementById("help-dialog");
+    if (trigger && dialog) {
+      var close = dialog.querySelector(".help-close");
+      var lastFocus = null;
+      var FOCUSABLE = [
+        "a[href]", "button:not([disabled])", "input:not([disabled])",
+        "select:not([disabled])", "textarea:not([disabled])", "[tabindex]"
+      ].join(",");
+      var focusable = function () {
+        return Array.prototype.filter.call(
+          dialog.querySelectorAll(FOCUSABLE),
+          function (el) {
+            return el.offsetWidth > 0 || el.offsetHeight > 0;
+          }
+        );
+      };
+      var openDialog = function () {
+        lastFocus = document.activeElement;
+        dialog.hidden = false;
+        dialog.setAttribute("aria-hidden", "false");
+        trigger.setAttribute("aria-expanded", "true");
+        (close || dialog).focus();
+      };
+      var closeDialog = function () {
+        dialog.hidden = true;
+        dialog.setAttribute("aria-hidden", "true");
+        trigger.setAttribute("aria-expanded", "false");
+        if (lastFocus && lastFocus.focus) { lastFocus.focus(); }
+      };
+      trigger.setAttribute("aria-expanded", "false");
+      dialog.setAttribute("aria-hidden", "true");
+      trigger.addEventListener("click", openDialog);
+      if (close) { close.addEventListener("click", closeDialog); }
+      document.addEventListener("keydown", function (event) {
+        if (dialog.hidden) { return; }
+        if (event.key === "Escape") { closeDialog(); return; }
+        // Real focus trap: Tab off either end wraps inside the dialog.
+        if (event.key !== "Tab") { return; }
+        var items = focusable();
+        if (!items.length) { return; }
+        var first = items[0];
+        var last = items[items.length - 1];
+        if (event.shiftKey && document.activeElement === first) {
+          event.preventDefault();
+          last.focus();
+        } else if (!event.shiftKey && document.activeElement === last) {
+          event.preventDefault();
+          first.focus();
+        }
+      });
+    }
+
+    // Service search band: an ARIA combobox layered over a real GET form.
+    // Debounced, single-flight via AbortController, with a monotonic sequence
+    // guard so a slow early response can never overwrite a newer one.  With
+    // scripting off the form still submits to /services and the server
+    // renders the same result set.
+    var searchForm = document.querySelector("[data-service-search]");
+    if (searchForm) {
+      var input = searchForm.querySelector("[data-service-search-input]");
+      var list = searchForm.querySelector("[data-service-search-list]");
+      var status = searchForm.querySelector("[data-service-search-status]");
+      var endpoint = searchForm.getAttribute("data-suggest-endpoint");
+      var timer = null;
+      var controller = null;
+      var sequence = 0;
+      var settled = 0;
+      var active = -1;
+
+      var closeList = function () {
+        list.hidden = true;
+        list.innerHTML = "";
+        input.setAttribute("aria-expanded", "false");
+        input.removeAttribute("aria-activedescendant");
+        active = -1;
+      };
+
+      var highlight = function (next) {
+        var options = list.querySelectorAll("[role=option]");
+        if (!options.length) { return; }
+        if (next < 0) { next = options.length - 1; }
+        if (next >= options.length) { next = 0; }
+        active = next;
+        Array.prototype.forEach.call(options, function (option, index) {
+          var on = index === active;
+          option.setAttribute("aria-selected", String(on));
+          option.classList.toggle("active", on);
+          if (on) { input.setAttribute("aria-activedescendant", option.id); }
+        });
+      };
+
+      var draw = function (results) {
+        if (!results.length) { closeList(); status.textContent = "No matching services."; return; }
+        list.innerHTML = "";
+        results.forEach(function (result, index) {
+          var item = document.createElement("li");
+          item.id = "home-search-option-" + index;
+          item.setAttribute("role", "option");
+          item.setAttribute("aria-selected", "false");
+          var link = document.createElement("a");
+          link.href = result.href;
+          link.textContent = result.label;
+          item.appendChild(link);
+          list.appendChild(item);
+        });
+        list.hidden = false;
+        input.setAttribute("aria-expanded", "true");
+        active = -1;
+        status.textContent =
+          results.length + (results.length === 1 ? " service" : " services") + " suggested.";
+      };
+
+      var fetchSuggestions = function (query) {
+        if (controller) { controller.abort(); }
+        controller = new AbortController();
+        var ticket = ++sequence;
+        fetch(endpoint + "?q=" + encodeURIComponent(query), {
+          signal: controller.signal,
+          headers: { "Accept": "application/json" }
+        })
+          .then(function (response) {
+            if (!response.ok) { throw new Error("suggest failed"); }
+            return response.json();
+          })
+          .then(function (payload) {
+            // Sequence guard: ignore anything older than what already landed.
+            if (ticket <= settled) { return; }
+            settled = ticket;
+            draw((payload && payload.results) || []);
+          })
+          .catch(function (error) {
+            if (error && error.name === "AbortError") { return; }
+            // The GET form remains the reliable path; say so rather than
+            // leaving a stale list on screen.
+            closeList();
+            status.textContent = "Suggestions unavailable. Press Enter to search.";
+          });
+      };
+
+      input.addEventListener("input", function () {
+        var query = input.value.trim();
+        if (timer) { window.clearTimeout(timer); }
+        if (query.length < 2) {
+          if (controller) { controller.abort(); }
+          closeList();
+          status.textContent = "";
+          return;
+        }
+        timer = window.setTimeout(function () { fetchSuggestions(query); }, 180);
+      });
+
+      input.addEventListener("keydown", function (event) {
+        if (list.hidden) { return; }
+        if (event.key === "ArrowDown") { event.preventDefault(); highlight(active + 1); }
+        else if (event.key === "ArrowUp") { event.preventDefault(); highlight(active - 1); }
+        else if (event.key === "Escape") { closeList(); }
+        else if (event.key === "Enter" && active >= 0) {
+          var chosen = list.querySelectorAll("[role=option] a")[active];
+          if (chosen) { event.preventDefault(); window.location.assign(chosen.href); }
+        }
+      });
+
+      // A click outside the band dismisses the list without eating the click.
+      document.addEventListener("click", function (event) {
+        if (!searchForm.contains(event.target)) { closeList(); }
+      });
+      closeList();
+    }
+
+    // Home category families. Every tab is a real GET link first; scripting
+    // upgrades it to the source's in-place panel switch without weakening the
+    // no-script navigation path.
+    var tabs = Array.from(
+      document.querySelectorAll("[data-home-category-tab]")
+    );
+    var categoryPanels = Array.from(
+      document.querySelectorAll("[data-home-category-panel]")
+    );
+    function activateHomeCategory(categoryId, updateUrl) {
+      if (!tabs.some(function (tab) {
+        return tab.dataset.homeCategoryTab === categoryId;
+      })) { return; }
+      tabs.forEach(function (tab) {
+        var selected = tab.dataset.homeCategoryTab === categoryId;
+        tab.classList.toggle("active", selected);
+        tab.setAttribute("aria-selected", String(selected));
+        tab.setAttribute("tabindex", selected ? "0" : "-1");
+        var blob = tab.querySelector(".category-symbol-blob");
+        if (blob) {
+          blob.src = selected ? blob.dataset.selectedSrc : blob.dataset.unselectedSrc;
+        }
+      });
+      categoryPanels.forEach(function (panel) {
+        panel.hidden = panel.dataset.homeCategoryPanel !== categoryId;
+      });
+      var selectedTab = tabs.find(function (tab) {
+        return tab.dataset.homeCategoryTab === categoryId;
+      });
+      if (selectedTab && window.matchMedia("(max-width: 767px)").matches) {
+        selectedTab.scrollIntoView({ behavior: "smooth", block: "nearest", inline: "nearest" });
+      }
+      if (updateUrl && window.history && window.history.pushState) {
+        var url = new URL(window.location.href);
+        url.searchParams.set("category", categoryId);
+        window.history.pushState({ homeCategory: categoryId }, "", url);
+      }
+    }
+    tabs.forEach(function (tab, index) {
+      tab.addEventListener("click", function (event) {
+        if (
+          event.button !== 0 || event.metaKey || event.ctrlKey ||
+          event.shiftKey || event.altKey
+        ) { return; }
+        event.preventDefault();
+        activateHomeCategory(tab.dataset.homeCategoryTab, true);
+      });
+      tab.addEventListener("keydown", function (event) {
+        var targetIndex = index;
+        if (event.key === "ArrowRight") { targetIndex = (index + 1) % tabs.length; }
+        else if (event.key === "ArrowLeft") {
+          targetIndex = (index - 1 + tabs.length) % tabs.length;
+        } else if (event.key === "Home") { targetIndex = 0; }
+        else if (event.key === "End") { targetIndex = tabs.length - 1; }
+        else { return; }
+        event.preventDefault();
+        tabs[targetIndex].focus();
+        activateHomeCategory(tabs[targetIndex].dataset.homeCategoryTab, true);
+      });
+    });
+    window.addEventListener("popstate", function () {
+      var selected = new URL(window.location.href).searchParams.get("category");
+      activateHomeCategory(selected || "assembly", false);
+    });
+
+    // Source-like account popover: native details keeps the menu usable with
+    // scripting off; these handlers add the expected dismissal behavior.
+    var accountMenus = Array.from(document.querySelectorAll("details.account-menu"));
+    accountMenus.forEach(function (menu) {
+      var summary = menu.querySelector("summary");
+      function refreshAccountMenuLabel() {
+        if (summary) {
+          summary.setAttribute(
+            "aria-label",
+            menu.open ? "Close account menu" : "Open account menu"
+          );
+        }
+      }
+      refreshAccountMenuLabel();
+      menu.addEventListener("toggle", refreshAccountMenuLabel);
+      menu.addEventListener("keydown", function (event) {
+        if (event.key !== "Escape" || !menu.open) { return; }
+        event.preventDefault();
+        menu.open = false;
+        if (summary) { summary.focus(); }
+      });
+    });
+    document.addEventListener("click", function (event) {
+      accountMenus.forEach(function (menu) {
+        if (menu.open && !menu.contains(event.target)) { menu.open = false; }
+      });
+    });
+
+    document.querySelectorAll("[data-password-toggle]").forEach(function (button) {
+      var wrapper = button.closest(".auth-password-row") || button.parentElement;
+      var input = wrapper && wrapper.querySelector("[data-password-input]");
+      if (!input) { return; }
+      button.addEventListener("click", function () {
+        var reveal = input.type === "password";
+        input.type = reveal ? "text" : "password";
+        button.setAttribute("aria-label", reveal ? "Hide password" : "Show password");
+        input.focus();
+      });
+    });
+
+    // Upgrade the no-script region select to an offline, searchable combobox.
+    // Every visual marker is an ISO badge or CSS-painted flag: this avoids the
+    // platform-dependent regional-indicator emoji that Chromium renders as
+    // tofu on minimal Linux images. The real select remains the form owner.
+    document.querySelectorAll("[data-phone-region-select]").forEach(function (select) {
+      var form = select.closest("form");
+      var callingCode = form && form.querySelector("[data-phone-dial-code]");
+      if (!callingCode) { return; }
+      var picker = select.parentElement.querySelector("[data-phone-region-combobox]");
+      function syncCallingCode() {
+        var option = select.options[select.selectedIndex];
+        callingCode.value = option ? option.dataset.dialCode : "+1";
+      }
+      select.addEventListener("change", syncCallingCode);
+      syncCallingCode();
+      if (!picker) { return; }
+
+      var trigger = picker.querySelector("[data-phone-region-trigger]");
+      var popover = picker.querySelector("[data-phone-region-popover]");
+      var search = picker.querySelector("[data-phone-region-search]");
+      var listbox = picker.querySelector("[data-phone-region-listbox]");
+      var status = picker.querySelector("[data-phone-region-status]");
+      var selectedName = picker.querySelector("[data-phone-region-name]");
+      var selectedDial = picker.querySelector("[data-phone-region-selected-dial]");
+      var selectedBadge = trigger.querySelector(".phone-region-badge");
+      var options = Array.from(listbox.querySelectorAll("[role=option]"));
+      var activeOption = null;
+
+      function visibleOptions() {
+        return options.filter(function (option) { return !option.hidden; });
+      }
+
+      function setActive(option, focus) {
+        options.forEach(function (item) {
+          item.classList.toggle("is-active", item === option);
+        });
+        activeOption = option || null;
+        if (option && focus) { option.focus(); }
+      }
+
+      function filterOptions(query) {
+        var needle = query.trim().toLocaleLowerCase();
+        var count = 0;
+        options.forEach(function (option) {
+          var matches = !needle || option.dataset.searchValue.toLocaleLowerCase().includes(needle);
+          option.hidden = !matches;
+          if (matches) { count += 1; }
+        });
+        status.textContent = count + (count === 1 ? " country or region" : " countries and regions");
+        setActive(visibleOptions()[0] || null, false);
+      }
+
+      function openPicker() {
+        popover.hidden = false;
+        trigger.setAttribute("aria-expanded", "true");
+        search.value = "";
+        filterOptions("");
+        var selected = options.find(function (option) {
+          return option.dataset.regionCode === select.value;
+        });
+        setActive(selected || visibleOptions()[0] || null, false);
+        window.requestAnimationFrame(function () {
+          search.focus();
+          if (selected) { selected.scrollIntoView({ block: "nearest" }); }
+        });
+      }
+
+      function closePicker(restoreFocus) {
+        popover.hidden = true;
+        trigger.setAttribute("aria-expanded", "false");
+        setActive(null, false);
+        if (restoreFocus) { trigger.focus(); }
+      }
+
+      function choose(option) {
+        if (!option) { return; }
+        select.value = option.dataset.regionCode;
+        selectedBadge.dataset.regionCode = option.dataset.regionCode;
+        selectedBadge.textContent = option.dataset.regionCode;
+        selectedName.textContent = option.dataset.regionName;
+        selectedDial.textContent = option.dataset.dialCode;
+        trigger.setAttribute(
+          "aria-label",
+          "Phone country or region: " + option.dataset.regionName + " " + option.dataset.dialCode
+        );
+        options.forEach(function (item) {
+          item.setAttribute("aria-selected", String(item === option));
+        });
+        select.dispatchEvent(new Event("change", { bubbles: true }));
+        closePicker(true);
+      }
+
+      function moveActive(direction, focus) {
+        var visible = visibleOptions();
+        if (!visible.length) { return; }
+        var index = visible.indexOf(activeOption);
+        if (direction === "first") { index = 0; }
+        else if (direction === "last") { index = visible.length - 1; }
+        else if (direction === "next") { index = index < visible.length - 1 ? index + 1 : 0; }
+        else { index = index > 0 ? index - 1 : visible.length - 1; }
+        setActive(visible[index], focus);
+      }
+
+      trigger.addEventListener("click", function () {
+        if (popover.hidden) { openPicker(); } else { closePicker(true); }
+      });
+      trigger.addEventListener("keydown", function (event) {
+        if (["Enter", " ", "ArrowDown", "ArrowUp"].indexOf(event.key) === -1) { return; }
+        event.preventDefault();
+        if (popover.hidden) { openPicker(); }
+      });
+      picker.addEventListener("keydown", function (event) {
+        if (event.key !== "Escape" || popover.hidden) { return; }
+        event.preventDefault();
+        event.stopPropagation();
+        closePicker(true);
+      });
+      search.addEventListener("input", function () { filterOptions(search.value); });
+      search.addEventListener("keydown", function (event) {
+        if (event.key === "ArrowDown") { event.preventDefault(); moveActive("next", true); }
+        else if (event.key === "ArrowUp") { event.preventDefault(); moveActive("previous", true); }
+        else if (event.key === "Enter" && activeOption) { event.preventDefault(); choose(activeOption); }
+        else if (event.key === "Escape") { event.preventDefault(); closePicker(true); }
+      });
+      options.forEach(function (option) {
+        option.addEventListener("click", function () { choose(option); });
+        option.addEventListener("focus", function () { setActive(option, false); });
+        option.addEventListener("keydown", function (event) {
+          if (event.key === "ArrowDown") { event.preventDefault(); moveActive("next", true); }
+          else if (event.key === "ArrowUp") { event.preventDefault(); moveActive("previous", true); }
+          else if (event.key === "Home") { event.preventDefault(); moveActive("first", true); }
+          else if (event.key === "End") { event.preventDefault(); moveActive("last", true); }
+          else if (event.key === "Enter" || event.key === " ") { event.preventDefault(); choose(option); }
+          else if (event.key === "Escape") { event.preventDefault(); closePicker(true); }
+        });
+      });
+      document.addEventListener("pointerdown", function (event) {
+        if (!popover.hidden && !picker.contains(event.target)) { closePicker(false); }
+      });
+
+      // Keep the real form control visible in the offline runtime. The native
+      // select is deterministic across both formal executors and remains the
+      // accessible owner of the submitted region value.
+      select.hidden = false;
+      select.removeAttribute("aria-hidden");
+      select.removeAttribute("tabindex");
+      picker.hidden = true;
+    });
+
+    document.querySelectorAll("[data-auth-submit-readiness]").forEach(function (button) {
+      var form = button.closest("form");
+      if (!form) { return; }
+      var status = form.querySelector("[data-auth-verification-status]");
+      function refreshReadiness() {
+        if (
+          status && status.dataset.state === "success" &&
+          status.textContent === "Email verified. Complete the form and select Continue."
+        ) {
+          status.textContent = "Email verified. Complete the form and select Sign Up."
+        }
+        var verificationReady = !status || status.dataset.state === "success";
+        button.dataset.ready = String(form.checkValidity() && verificationReady);
+      }
+      form.addEventListener("input", refreshReadiness);
+      form.addEventListener("change", refreshReadiness);
+      if (status) {
+        new MutationObserver(refreshReadiness).observe(status, {
+          attributes: true,
+          childList: true,
+        });
+      }
+      refreshReadiness();
+    });
+
+    // Task Book recommendation controls move the same horizontal card rail
+    // that touch and trackpad users can scroll directly.
+    var taskbookTrack = document.querySelector("[data-taskbook-carousel-track]");
+    if (taskbookTrack) {
+      var previousTaskers = document.querySelector("[data-taskbook-carousel=previous]");
+      var nextTaskers = document.querySelector("[data-taskbook-carousel=next]");
+      function taskbookStep() {
+        var card = taskbookTrack.querySelector(".taskbook-tasker-card");
+        return card ? card.getBoundingClientRect().width + 20 : taskbookTrack.clientWidth;
+      }
+      function refreshTaskbookControls() {
+        var maximum = Math.max(0, taskbookTrack.scrollWidth - taskbookTrack.clientWidth);
+        if (previousTaskers) { previousTaskers.disabled = taskbookTrack.scrollLeft <= 1; }
+        if (nextTaskers) { nextTaskers.disabled = taskbookTrack.scrollLeft >= maximum - 1; }
+      }
+      if (previousTaskers) {
+        previousTaskers.addEventListener("click", function () {
+          taskbookTrack.scrollBy({ left: -taskbookStep(), behavior: "smooth" });
+        });
+      }
+      if (nextTaskers) {
+        nextTaskers.addEventListener("click", function () {
+          taskbookTrack.scrollBy({ left: taskbookStep(), behavior: "smooth" });
+        });
+      }
+      taskbookTrack.addEventListener("scroll", refreshTaskbookControls, { passive: true });
+      window.addEventListener("resize", refreshTaskbookControls);
+      refreshTaskbookControls();
+    }
+
+    // Tasker roster: enforce the single-selection UI contract visually.
+    var taskerCards = document.querySelectorAll(".tasker-card");
+    taskerCards.forEach(function (card) {
+      var radio = card.querySelector("input[type=radio]");
+      if (!radio) { return; }
+      radio.addEventListener("change", function () {
+        taskerCards.forEach(function (other) {
+          var otherRadio = other.querySelector("input[type=radio]");
+          other.classList.toggle(
+            "selected", Boolean(otherRadio && otherRadio.checked)
+          );
+        });
+      });
+    });
+
+    // Booking option rows: reflect radio selection state.
+    var optionRows = document.querySelectorAll("label.option");
+    optionRows.forEach(function (row) {
+      var radio = row.querySelector("input[type=radio]");
+      if (!radio || radio.disabled) { return; }
+      radio.addEventListener("change", function () {
+        var group = document.querySelectorAll(
+          "label.option input[name=\"" + radio.name + "\"]"
+        );
+        group.forEach(function (input) {
+          var label = input.closest("label.option");
+          if (label) { label.classList.toggle("selected", input.checked); }
+        });
+      });
+    });
+  });
+})();

tasks/taskrabbit/solution/site/implementation/clone/static/auth-fidelity.css

@@ -0,0 +1,555 @@
+body:has(.login-shell) {
+  background: #f7f8f7;
+}
+
+.auth-source-page {
+  min-height: 100vh;
+  background: #000 url("/static/assets/source-current/2026-08-09-home-auth-assets/auth-register-background.webp") center top / cover fixed no-repeat;
+}
+
+.auth-source-shell {
+  position: relative;
+  z-index: 1;
+  display: grid;
+  min-height: 100vh;
+  place-items: start center;
+  padding: 80px 24px;
+}
+
+.auth-source-card {
+  width: 520px;
+  max-width: 100%;
+  border-radius: 16px;
+  padding: 48px;
+  background: #fff;
+}
+
+.auth-source-logo {
+  display: inline-flex;
+  margin-bottom: 22px;
+}
+
+.auth-source-logo svg {
+  width: 242px;
+  height: auto;
+  fill: #0d7a5f;
+}
+
+.auth-source-card .auth-heading,
+.verify-page-heading h1 {
+  margin: 0 0 30px;
+  color: #092d16;
+  font-size: 36px;
+  font-weight: 750;
+  letter-spacing: -.6px;
+  line-height: 1.18;
+}
+
+.auth-source-card .auth-form {
+  display: grid;
+  max-width: none;
+  gap: 0;
+  margin: 0;
+}
+
+.auth-source-card .auth-form > label:not(.auth-terms),
+.auth-source-card .auth-phone-group > label,
+.auth-source-card .auth-code-panel > label {
+  margin: 0 0 8px;
+  color: #202523;
+  font-size: 12px;
+  font-weight: 700;
+  line-height: 1.35;
+}
+
+.auth-source-card .auth-form > input:not([type="hidden"]),
+.auth-source-card .auth-password-row,
+.auth-source-card .auth-phone-row {
+  width: 100%;
+  height: 48px;
+  margin: 0 0 24px;
+  border: 1px solid #c9cace;
+  border-radius: 999px;
+  background: #fff;
+}
+
+.auth-source-card .auth-form > input:not([type="hidden"]) {
+  padding: 0 24px;
+  color: #1e212a;
+  font-size: 16px;
+}
+
+.auth-source-card .auth-form > input:not([type="hidden"]):focus,
+.auth-source-card .auth-password-row:focus-within,
+.auth-source-card .auth-phone-row:focus-within {
+  border-color: #0d7a5f;
+  box-shadow: 0 0 0 1px #0d7a5f;
+  outline: none;
+}
+
+.auth-phone-group { display: grid; }
+.auth-source-card .auth-phone-row {
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  overflow: visible;
+  padding: 0 20px 0 24px;
+}
+.auth-source-card .auth-phone-row select {
+  min-width: 116px;
+  max-width: 56%;
+  flex: 0 1 190px;
+  border: 0;
+  padding: 0 22px 0 4px;
+  background: transparent;
+  color: #1e212a;
+  font: inherit;
+  outline: 0;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.phone-region-picker {
+  position: relative;
+  width: 228px;
+  max-width: 56%;
+  min-width: 0;
+  flex: 0 0 228px;
+  border-right: 1px solid #d7dbd9;
+  padding-right: 8px;
+}
+.phone-region-trigger {
+  display: grid;
+  width: 100%;
+  height: 46px;
+  min-width: 0;
+  grid-template-columns: 32px minmax(28px, 1fr) auto 12px;
+  align-items: center;
+  gap: 8px;
+  border: 0;
+  padding: 0;
+  background: transparent;
+  color: #1e212a;
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+.phone-region-selected-name {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.phone-region-selected-dial { color: #555d59; font-size: 14px; }
+.phone-region-chevron {
+  width: 8px;
+  height: 8px;
+  border-right: 1.5px solid #4d5551;
+  border-bottom: 1.5px solid #4d5551;
+  transform: translateY(-2px) rotate(45deg);
+}
+.phone-region-trigger[aria-expanded="true"] .phone-region-chevron {
+  transform: translateY(2px) rotate(225deg);
+}
+.phone-region-popover {
+  position: absolute;
+  z-index: 120;
+  top: calc(100% + 8px);
+  left: -24px;
+  width: min(424px, calc(100vw - 48px));
+  border: 1px solid #c9cfcc;
+  border-radius: 12px;
+  padding: 12px;
+  background: #fff;
+  box-shadow: 0 16px 38px rgba(20, 31, 27, .2);
+}
+.phone-region-popover[hidden],
+.phone-region-picker[hidden],
+.phone-region-option[hidden] { display: none !important; }
+.auth-source-card .auth-phone-row .phone-region-search {
+  width: 100%;
+  height: 42px;
+  border: 1px solid #9ba29f;
+  border-radius: 8px;
+  margin: 0;
+  padding: 0 13px;
+  font: inherit;
+}
+.auth-source-card .auth-phone-row .phone-region-search:focus {
+  border-color: #0d7a5f;
+  box-shadow: 0 0 0 2px rgba(13, 122, 95, .15);
+  outline: none;
+}
+.phone-region-status {
+  margin: 8px 3px 6px;
+  color: #656c68;
+  font-size: 12px;
+}
+.phone-region-listbox {
+  max-height: 286px;
+  overflow-y: auto;
+  overscroll-behavior: contain;
+}
+.phone-region-option {
+  display: grid;
+  width: 100%;
+  min-height: 45px;
+  grid-template-columns: 32px minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 10px;
+  border: 0;
+  border-radius: 7px;
+  padding: 6px 9px;
+  background: #fff;
+  color: #202523;
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+.phone-region-option:hover,
+.phone-region-option.is-active,
+.phone-region-option[aria-selected="true"] { background: #edf7f3; }
+.phone-region-option:focus-visible { outline: 2px solid #0d7a5f; outline-offset: -2px; }
+.phone-region-option-name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.phone-region-option-dial { color: #5b625f; font-variant-numeric: tabular-nums; }
+.phone-region-badge {
+  position: relative;
+  display: grid;
+  width: 32px;
+  height: 22px;
+  overflow: hidden;
+  place-items: center;
+  border: 1px solid rgba(13, 54, 36, .22);
+  border-radius: 4px;
+  background: #e9f4ef;
+  color: #075f49;
+  font-family: Arial, sans-serif;
+  font-size: 10px;
+  font-weight: 800;
+  letter-spacing: .04em;
+  line-height: 1;
+}
+
+/* Frequently selected regions receive recognizable local CSS flags. Other
+   entries retain their stable two-letter ISO badge, so all 245 remain
+   distinct without downloading assets or relying on an emoji font. */
+.phone-region-badge[data-region-code="US"] {
+  color: transparent;
+  background: repeating-linear-gradient(to bottom, #b22234 0 2px, #fff 2px 4px);
+}
+.phone-region-badge[data-region-code="US"]::after {
+  position: absolute; top: 0; left: 0; width: 14px; height: 11px; background: #3c3b6e; content: "";
+}
+.phone-region-badge[data-region-code="GB"] {
+  color: transparent;
+  background: linear-gradient(90deg, transparent 42%, #cf142b 42% 58%, transparent 58%), linear-gradient(transparent 37%, #fff 37% 63%, transparent 63%), linear-gradient(transparent 43%, #cf142b 43% 57%, transparent 57%), #21468b;
+}
+.phone-region-badge[data-region-code="FR"] { color: transparent; background: linear-gradient(90deg, #0055a4 0 33.33%, #fff 33.33% 66.66%, #ef4135 66.66%); }
+.phone-region-badge[data-region-code="CN"] { color: transparent; background: radial-gradient(circle at 26% 30%, #ffde00 0 3px, transparent 3.5px), #de2910; }
+.phone-region-badge[data-region-code="JP"] { color: transparent; background: radial-gradient(circle, #bc002d 0 6px, transparent 6.5px), #fff; }
+.phone-region-badge[data-region-code="DE"] { color: transparent; background: linear-gradient(#000 0 33.33%, #dd0000 33.33% 66.66%, #ffce00 66.66%); }
+.phone-region-badge[data-region-code="IN"] { color: transparent; background: radial-gradient(circle, #1a5dab 0 2px, transparent 2.5px), linear-gradient(#ff9933 0 33.33%, #fff 33.33% 66.66%, #138808 66.66%); }
+.phone-region-badge[data-region-code="BR"] { color: transparent; background: radial-gradient(circle, #002776 0 4px, transparent 4.5px), linear-gradient(32deg, transparent 27%, #ffdf00 28% 72%, transparent 73%), #009c3b; }
+.phone-region-badge[data-region-code="CA"] { color: transparent; background: linear-gradient(90deg, #d80621 0 25%, #fff 25% 75%, #d80621 75%); }
+.phone-region-badge[data-region-code="CA"]::after { position: absolute; top: 7px; left: 13px; width: 6px; height: 8px; border-radius: 50% 15%; background: #d80621; content: ""; }
+.phone-region-badge[data-region-code="AU"] { color: transparent; background: radial-gradient(circle at 72% 33%, #fff 0 1px, transparent 1.5px), radial-gradient(circle at 79% 72%, #fff 0 1px, transparent 1.5px), radial-gradient(circle at 58% 64%, #fff 0 1px, transparent 1.5px), #012169; }
+.auth-source-card .auth-phone-row input[type="tel"] {
+  min-width: 0;
+  height: 46px;
+  flex: 1;
+  border: 0;
+  margin: 0;
+  padding: 0 4px;
+  background: transparent;
+  font: inherit;
+  outline: 0;
+}
+
+.auth-password-row { display: flex; align-items: center; overflow: hidden; padding-left: 24px; }
+.auth-source-card .auth-password-row input {
+  min-width: 0;
+  height: 46px;
+  flex: 1;
+  border: 0;
+  margin: 0;
+  padding: 0;
+  background: transparent;
+  font: inherit;
+  outline: 0;
+}
+.auth-password-toggle {
+  position: relative;
+  width: 54px;
+  height: 46px;
+  border: 0;
+  background: transparent;
+  color: #65676e;
+  cursor: pointer;
+}
+.auth-password-toggle span {
+  position: absolute;
+  top: 15px;
+  left: 17px;
+  width: 20px;
+  height: 14px;
+  border: 2px solid currentColor;
+  border-radius: 50% / 60%;
+}
+.auth-password-toggle span::after {
+  position: absolute;
+  top: 3px;
+  left: 6px;
+  width: 4px;
+  height: 4px;
+  border: 1.5px solid currentColor;
+  border-radius: 50%;
+  content: "";
+}
+
+.auth-source-card .auth-form label.auth-terms {
+  display: grid;
+  grid-template-columns: 24px 1fr;
+  gap: 12px;
+  margin: 0 0 26px;
+  color: #1e212a;
+  font-size: 14px;
+  font-weight: 400;
+  line-height: 1.6;
+}
+.auth-source-card .auth-form label.auth-terms input[type="checkbox"] {
+  width: 24px;
+  height: 24px;
+  margin: 2px 0 0;
+  accent-color: #0d7a5f;
+}
+
+.auth-source-card .auth-submit {
+  width: 100%;
+  min-height: 42px;
+  border: 1px solid #0d7a5f;
+  border-radius: 999px;
+}
+.auth-source-card .auth-submit:disabled { border-color: #bfc2c1; background: #dadcdb; color: #8a8d8c; }
+.auth-source-card .auth-submit[data-ready="false"] {
+  border-color: #bfc2c1;
+  background: #dadcdb;
+  color: #8a8d8c;
+}
+.auth-login-instead {
+  display: grid;
+  width: 100%;
+  min-height: 42px;
+  margin-top: 16px;
+  place-items: center;
+  border: 1px solid #c9cace;
+  border-radius: 999px;
+  color: #1e212a;
+  font-weight: 600;
+  text-decoration: none;
+}
+.auth-login-instead:hover,
+.auth-login-instead:focus-visible { border-color: #0d7a5f; color: #075f49; outline: none; }
+
+.auth-source-help {
+  display: flex;
+  width: auto;
+  height: 54px;
+  align-items: center;
+  gap: 10px;
+  border-radius: 999px;
+  padding: 0 20px;
+  font-size: 16px;
+  font-weight: 650;
+}
+.auth-source-help > span:first-child {
+  display: grid;
+  width: 18px;
+  height: 18px;
+  place-items: center;
+  border: 1.5px solid #fff;
+  border-radius: 50%;
+  font-size: 12px;
+}
+
+.login-shell {
+  width: min(540px, calc(100% - 32px));
+  margin: 44px auto 72px;
+  border: 1px solid #dce0de;
+  border-radius: 12px;
+  padding: 36px 40px 40px;
+  background: #fff;
+  box-shadow: 0 7px 24px rgba(20, 31, 27, .08);
+}
+
+.login-shell .auth-heading,
+.verify-page-heading h1 {
+  margin: 0;
+  color: #0a2b14;
+  font-size: 30px;
+  line-height: 1.25;
+}
+
+.login-shell .auth-form { max-width: none; }
+.login-shell .auth-submit { width: 100%; min-height: 48px; }
+
+.auth-verification {
+  display: grid;
+  gap: 14px;
+  margin: 0 0 24px;
+  border: 1px solid #cfd6d2;
+  border-radius: 10px;
+  padding: 18px;
+  background: #fafcfb;
+}
+
+.auth-verification-heading,
+.verify-page-heading {
+  display: flex;
+  align-items: flex-start;
+  gap: 13px;
+}
+
+.auth-verification-heading h2 {
+  margin: 0 0 3px;
+  color: #0a2b14;
+  font-size: 17px;
+  line-height: 1.35;
+}
+
+.auth-verification-heading p,
+.verify-page-heading p,
+.auth-code-help {
+  margin: 0;
+  color: #626a66;
+  font-size: 13px;
+  font-weight: 400;
+}
+
+.auth-verification-icon {
+  position: relative;
+  display: block;
+  width: 38px;
+  height: 30px;
+  flex: 0 0 38px;
+  border: 2px solid #0d7a5f;
+  border-radius: 4px;
+  background: #edf7f0;
+}
+
+.auth-verification-icon::before,
+.auth-verification-icon::after {
+  position: absolute;
+  top: 5px;
+  width: 21px;
+  height: 2px;
+  background: #0d7a5f;
+  content: "";
+}
+.auth-verification-icon::before { left: 1px; transform: rotate(35deg); }
+.auth-verification-icon::after { right: 1px; transform: rotate(-35deg); }
+
+.auth-code-action {
+  min-height: 46px;
+  border: 1px solid #0d7a5f;
+  border-radius: 999px;
+  padding: 10px 18px;
+  font: inherit;
+  font-weight: 700;
+  cursor: pointer;
+  transition: background-color .15s ease, color .15s ease, box-shadow .15s ease;
+}
+
+.auth-code-send {
+  display: flex;
+  width: 100%;
+  align-items: center;
+  justify-content: center;
+  gap: 9px;
+  background: #fff;
+  color: #075f49;
+}
+
+.auth-code-send:hover,
+.auth-code-send:focus-visible {
+  background: #edf7f0;
+  box-shadow: 0 0 0 3px rgba(13, 122, 95, .14);
+  outline: none;
+}
+
+.auth-action-arrow { font-size: 22px; font-weight: 400; line-height: 14px; }
+
+.auth-code-panel {
+  display: grid;
+  gap: 7px;
+  border-top: 1px solid #dce0de;
+  padding-top: 15px;
+}
+.auth-code-panel[hidden] { display: none !important; }
+.auth-code-panel > label { font-size: 14px; }
+.auth-code-row { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 9px; }
+
+.auth-form .auth-code-row input,
+.auth-form .server-verification-code {
+  min-height: 48px;
+  border-color: #8a918e;
+  padding: 8px 14px;
+  font-size: 20px;
+  font-weight: 650;
+  letter-spacing: .28em;
+  text-align: center;
+}
+
+.auth-form .auth-code-row input::placeholder,
+.auth-form .server-verification-code::placeholder { color: #a4aaa7; opacity: .75; }
+
+.auth-code-verify {
+  min-width: 128px;
+  border: 0;
+  background: #0d7a5f;
+  color: #fff;
+}
+.auth-code-verify:hover,
+.auth-code-verify:focus-visible { background: #075f49; box-shadow: 0 0 0 3px rgba(13, 122, 95, .16); outline: none; }
+.auth-code-action:disabled { cursor: wait; opacity: .62; }
+
+.auth-verification-status {
+  margin: 0;
+  border-radius: 7px;
+  padding: 10px 12px;
+  background: #f2f4f3;
+  color: #515956;
+  font-size: 13px;
+  font-weight: 550;
+}
+.auth-verification-status:empty { display: none; }
+.auth-verification-status[data-state="success"] { background: #e4f4eb; color: #075f49; }
+.auth-verification-status[data-state="error"] { background: #fff0ec; color: #9d3518; }
+
+.verify-page { margin-top: 0; }
+.verify-page-heading { padding-bottom: 22px; border-bottom: 1px solid #e2e5e3; }
+.verify-page-heading .auth-verification-icon { margin-top: 4px; }
+.verify-code-form { gap: 16px; margin-bottom: 16px; }
+.verify-submit { width: 100%; min-height: 48px; }
+.verify-message-link { margin: 4px 0 0; text-align: center; }
+
+@media (max-width: 560px) {
+  .auth-source-page { background: #fff; }
+  .auth-source-shell {
+    display: block;
+    min-height: 100vh;
+    padding: 30px 24px 80px;
+  }
+  .auth-source-card { width: 100%; border-radius: 0; padding: 0; }
+  .auth-source-logo { margin-bottom: 24px; }
+  .auth-source-logo svg { width: 248px; }
+  .auth-source-card .auth-heading,
+  .verify-page-heading h1 { margin-bottom: 34px; font-size: 28px; }
+  .auth-source-card .auth-form > input:not([type="hidden"]),
+  .auth-source-card .auth-password-row,
+  .auth-source-card .auth-phone-row { margin-bottom: 24px; }
+  .auth-source-help { right: auto; bottom: 16px; left: 16px; }
+  .login-shell { margin-top: 24px; padding: 28px 20px 32px; }
+  .auth-verification { padding: 16px; }
+  .auth-code-row { grid-template-columns: 1fr; }
+  .auth-code-verify { width: 100%; }
+  .phone-region-picker { width: 190px; flex-basis: 190px; }
+  .phone-region-popover { left: -24px; }
+}

tasks/taskrabbit/solution/site/implementation/clone/static/category-assets/README.md

@@ -0,0 +1,24 @@
+# Category raster provenance
+
+These 41 WebP files are the browser-negotiated bytes for the exact frozen
+Cloudinary transform URLs already represented in `source-assets/manifest.json`.
+They are not newly selected imagery and do not change the logical asset census:
+17 files belong to `/services`, and 24 belong to the two moving aliases.
+
+The bytes were fetched three independent times with Chromium's image
+`Accept` value:
+
+`image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8`
+
+Every per-file SHA-256 was identical across all three downloads. The three
+frozen source network logs independently bind every one of the 41 exact URLs
+to `content_type: image/webp`; the corresponding three DOM snapshots bind the
+same public IDs and transforms to the page image candidates. The contract test
+in `clone/tests/test_category_visual_assets.py` locks those six evidence sets,
+the local WebP signatures, dimensions, hashes, rendered `src` bindings, and
+runtime response MIME types.
+
+The authoritative manifest may retain the earlier direct-capture bytes or
+migrate its existing same-`source_url` rows to these negotiated WebP bytes.
+The contract deliberately permits that in-place migration while rejecting a
+URL, transform, dimension, or WebP-byte mismatch.

tasks/taskrabbit/solution/site/implementation/clone/static/category-fidelity.css

@@ -0,0 +1,1102 @@
+/*
+ * Taskrabbit category surfaces, reconstructed from the three independent
+ * 2026-07-29-v3 source captures.  This stylesheet is loaded only by the
+ * services and moving templates so the shared shell remains independently
+ * owned.
+ */
+
+body:has(.source-category-page) {
+  color: #1a1e1d;
+  background: #fff;
+}
+
+body:has(.source-category-page) .site-header {
+  height: 70px;
+  border: 0;
+}
+
+body:has(.source-category-page) .header-inner {
+  width: min(1136px, calc(100% - 48px));
+  height: 70px;
+  padding: 0;
+  flex-wrap: nowrap;
+}
+
+body:has(.source-category-page) .main-nav {
+  height: 43px;
+  gap: 32px;
+}
+
+body:has(.source-category-page) .main-nav > a {
+  display: flex;
+  height: 36px;
+  align-items: center;
+  font-size: 16px;
+  font-weight: 600;
+  line-height: normal;
+  letter-spacing: -.12px;
+}
+
+body:has(.source-category-page) .main-nav .account-button {
+  padding: 0;
+  border: 0;
+}
+
+body:has(.source-category-page) .main-nav .become-tasker {
+  display: flex;
+  width: 180px;
+  height: 43px;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  border: 1px solid #0d7a5f;
+  border-radius: 1000px;
+  color: #0d7a5f;
+  font-size: 16px;
+  font-weight: 600;
+  line-height: normal;
+  letter-spacing: -.12px;
+}
+
+.source-category-page {
+  background: #fbfdfc;
+}
+
+.source-category-page .services-hero,
+.source-category-page .moving-hero,
+.source-category-page .services-hero img,
+.source-category-page .moving-hero img {
+  height: 420px;
+}
+
+.source-category-page .services-hero::after,
+.source-category-page .moving-hero::after {
+  background: rgba(0, 0, 0, .25);
+}
+
+.source-category-page .services-hero-copy h1,
+.source-category-page .moving-hero-copy h1 {
+  font-size: 34px;
+  font-weight: 800;
+  line-height: 47.6px;
+}
+
+.source-category-page .services-hero-copy h1 {
+  padding-bottom: 24px;
+}
+
+.services-source-page .category-grid-section {
+  display: flex;
+  max-width: 1200px;
+  flex-direction: column;
+  align-items: center;
+  padding: 24px 24px 0;
+}
+
+.services-source-page .services-subtitle {
+  margin: 0 0 8px;
+  color: #1a1e1d;
+  font-size: 30px;
+  font-weight: 700;
+  line-height: 42px;
+}
+
+.services-source-page .category-grid {
+  display: flex;
+  width: 100%;
+  flex-flow: row wrap;
+  align-items: stretch;
+  justify-content: space-between;
+  gap: 0;
+  margin: 16px 0;
+}
+
+.services-source-page .category-card {
+  width: 31%;
+  min-height: 0 !important;
+  padding-bottom: 14.7px;
+  color: #1a1e1d;
+}
+
+.services-source-page .category-card h3,
+.services-source-page .category-card h3 a {
+  color: #0d7a5f;
+  font-size: 16px;
+  font-weight: 600;
+  line-height: 25.6px;
+  letter-spacing: -.12px;
+  text-decoration: none;
+}
+
+.services-source-page .category-card h3 a {
+  color: #0d7a5f;
+  line-height: 25.6px;
+}
+
+.services-source-page .category-card p {
+  position: relative;
+  min-height: 0;
+  margin-bottom: 18.4px;
+  padding-bottom: 0;
+  border-bottom: 0;
+  color: #1a1e1d;
+  font-size: 16px;
+  font-weight: 600;
+  line-height: 25.6px;
+  letter-spacing: -.12px;
+}
+
+.services-source-page .category-card p::after {
+  position: absolute;
+  right: 1px;
+  bottom: -11px;
+  left: 0;
+  height: 2px;
+  background: linear-gradient(to bottom, #9a9a9a 0 1px, #eee 1px 2px);
+  content: "";
+}
+
+.services-source-page .category-card ul {
+  margin: 0 20px;
+  padding: 8px 0;
+  color: #0d7a5f;
+  font-size: 16px;
+  font-weight: 600;
+  line-height: 25.6px;
+  letter-spacing: -.12px;
+}
+
+.services-source-page .category-card li {
+  display: flex;
+  min-height: 31.2px;
+  align-items: center;
+  padding: 2.4px 0;
+}
+
+.services-source-page .category-card li,
+.services-source-page .category-card li span {
+  color: #0d7a5f;
+}
+
+.moving-source-page .moving-hero img {
+  object-position: center;
+}
+
+.moving-source-page .moving-hero-copy p {
+  max-width: 900px;
+  margin: 0;
+  padding-bottom: 24px;
+  color: #fff;
+  font-size: 18px;
+  line-height: 24.66px;
+  letter-spacing: -.09px;
+}
+
+.moving-source-page .moving-hero-copy h1 {
+  margin-bottom: 0;
+  padding-bottom: 24px;
+}
+
+.moving-source-page .breadcrumb {
+  display: flex;
+  width: min(1152px, calc(100% - 40px));
+  max-width: 1152px;
+  height: 59px;
+  padding: 32px 0 0;
+  color: #0d7a5f;
+  font-size: 18px;
+  font-weight: 600;
+  line-height: 25.6px;
+  letter-spacing: -.09px;
+}
+
+.moving-source-page .breadcrumb > span[aria-hidden="true"] {
+  margin-right: 7px;
+  margin-left: 8px;
+}
+
+.moving-source-page .breadcrumb > a:nth-of-type(2) {
+  margin-right: -1px;
+}
+
+.moving-source-page .moving-main-layout {
+  width: min(1152px, calc(100% - 40px));
+  max-width: 1152px;
+  grid-template-columns: minmax(0, 816px) minmax(0, 288px);
+  gap: 48px;
+  padding: 0 0 32px;
+}
+
+.moving-source-page .moving-services {
+  gap: 32px;
+}
+
+.moving-source-page .service-row {
+  width: 100%;
+  height: auto;
+  min-height: 223px;
+  grid-template-columns: 175px minmax(0, 1fr);
+  gap: 32px;
+  padding: 24px 16px;
+  border: 0;
+  border-radius: 16px;
+  background: #fff;
+  box-shadow: 0 1px 8px rgba(0, 0, 0, .15);
+}
+
+.moving-source-page .service-row img {
+  width: 175px;
+  height: 175px;
+  border-radius: 50%;
+}
+
+.moving-source-page .service-row h2 {
+  margin: 0 0 8px;
+  color: #1a1e1d;
+  font-size: 20px;
+  font-weight: 600;
+  line-height: 26.4px;
+  letter-spacing: -.3px;
+}
+
+.moving-source-page .service-row p {
+  margin: 0 0 24px;
+  color: #1a1e1d;
+  font-size: 16px;
+  line-height: 25.6px;
+  letter-spacing: -.08px;
+}
+
+.moving-source-page .service-row .btn-primary,
+.moving-source-page .service-row .btn-secondary {
+  display: inline-flex;
+  width: 127px;
+  height: 43px;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  border: 1px solid #0d7a5f;
+  border-radius: 1000px;
+  background: #0d7a5f;
+  color: #fff;
+  font-size: 16px;
+  font-weight: 600;
+  line-height: normal;
+  letter-spacing: -.12px;
+}
+
+.moving-source-page .moving-sidebar {
+  position: static;
+  gap: 32px;
+}
+
+.moving-source-page .moving-sidebar-card {
+  padding: 0;
+}
+
+.moving-source-page .moving-sidebar-card h2 {
+  margin: 0 0 16px;
+  color: #1a1e1d;
+  font-size: 18px;
+  line-height: 23.76px;
+  letter-spacing: -.09px;
+}
+
+.moving-source-page .moving-sidebar .three-step {
+  gap: 0;
+  margin: 0;
+  padding: 0;
+}
+
+.moving-source-page .moving-sidebar .three-step li {
+  grid-template-columns: 41px 1fr;
+  column-gap: 0;
+  padding: 8px 16px;
+}
+
+.moving-source-page .moving-sidebar .step-number {
+  width: 25px;
+  height: 25px;
+  background: #1a1e1d;
+  font-size: 16px;
+  font-weight: 400;
+  line-height: 24px;
+}
+
+.moving-source-page .moving-sidebar .three-step li:first-child .step-number,
+.moving-source-page .moving-sidebar .three-step li:first-child h3,
+.moving-source-page .moving-sidebar .three-step li:nth-child(2) p {
+  transform: translateY(-1px);
+}
+
+.moving-source-page .moving-sidebar .three-step h3 {
+  margin: 0 0 8px;
+  color: #1a1e1d;
+  font-size: 16px;
+  font-weight: 800;
+  line-height: 22.4px;
+}
+
+.moving-source-page .moving-sidebar .three-step p {
+  margin: 0;
+  color: #1a1e1d;
+  font-size: 18px;
+  line-height: 24.66px;
+  letter-spacing: -.09px;
+}
+
+.moving-source-page .moving-sidebar .reviews-grid {
+  gap: 24px;
+}
+
+.moving-source-page .moving-sidebar .reviews-grid blockquote {
+  display: grid;
+  min-height: 0;
+  grid-template-columns: 50px minmax(0, 1fr);
+  column-gap: 20px;
+  padding: 0;
+  color: #1a1e1d;
+  font-size: 16px;
+  line-height: 25.6px;
+}
+
+.moving-source-page .moving-sidebar .reviews-grid img {
+  grid-row: 1 / span 2;
+  grid-column: 1;
+  width: 50px;
+  height: 50px;
+  margin-right: 0;
+}
+
+.moving-source-page .moving-sidebar .reviews-grid p {
+  grid-column: 2;
+  margin: 0 0 8px;
+  letter-spacing: -.08px;
+}
+
+.moving-source-page .moving-sidebar .reviews-grid cite {
+  grid-column: 2;
+  color: #1a1e1d;
+  font-weight: 600;
+  letter-spacing: -.12px;
+}
+
+.moving-source-page .faq-band {
+  max-width: none;
+  padding: 80px max(20px, calc((100% - 1136px) / 2));
+  background: #fff;
+}
+
+.moving-source-page .faq-band h2 {
+  margin: 0 0 48px;
+  color: #2b4c32;
+  font-size: 30px;
+  line-height: 42px;
+}
+
+.moving-source-page .faq-list li {
+  border: 0;
+}
+
+.moving-source-page .faq-list {
+  display: grid;
+  height: 328px;
+  grid-template-rows: repeat(5, 1fr);
+}
+
+.moving-source-page .faq-list details {
+  height: 100%;
+}
+
+.moving-source-page .faq-list details summary {
+  display: flex;
+  box-sizing: border-box;
+  height: 100%;
+  min-height: 48px;
+  align-items: center;
+  padding: 8px 16px;
+  border-top: 1px solid #dadcdb;
+  cursor: pointer;
+  list-style: none;
+}
+
+.moving-source-page .faq-list details summary::-webkit-details-marker {
+  display: none;
+}
+
+.moving-source-page .faq-list .faq-chevron {
+  width: 16px;
+  height: 16px;
+  flex: none;
+  color: rgba(0, 0, 0, .54);
+  fill: currentColor;
+}
+
+.moving-source-page .faq-list details[open] .faq-chevron {
+  transform: rotate(180deg);
+}
+
+.moving-source-page .faq-list h3 {
+  height: auto;
+  flex: 1;
+  margin: 12px 6px 12px 0;
+  padding: 0;
+  color: #0a2b14;
+  font-size: 18px;
+  font-weight: 400;
+  line-height: 24.66px;
+  letter-spacing: -.09px;
+}
+
+.moving-source-page .faq-list details > p {
+  margin: 0;
+  padding: 0 16px 17px;
+}
+
+.moving-source-page .moving-affordable-band {
+  padding: 40px 0;
+  background: #fbfdfc;
+}
+
+.moving-source-page .moving-banner {
+  display: block;
+  width: min(1200px, 100%);
+  max-width: 1200px;
+  padding: 0 24px;
+}
+
+.moving-source-page .moving-banner h2 {
+  margin: 0;
+  font-size: 24px;
+  line-height: 31.68px;
+  letter-spacing: -.12px;
+}
+
+.moving-source-page .moving-affordable-content {
+  display: flex;
+  height: 576px;
+  gap: 48px;
+  align-items: stretch;
+}
+
+.moving-source-page .moving-affordable-copy {
+  min-width: 0;
+  flex: 7;
+  letter-spacing: -.09px;
+}
+
+.moving-source-page .moving-affordable-copy p {
+  margin: 16px 0;
+  font-size: 16px;
+  line-height: 24px;
+  letter-spacing: -.09px;
+}
+
+.moving-source-page .moving-blurbs {
+  display: block;
+  margin: 0;
+}
+
+.moving-source-page .moving-blurbs strong {
+  font-weight: 700;
+}
+
+.moving-source-page .affordable-emphasis {
+  color: #0a2b14;
+  font-weight: 600;
+  text-decoration: underline;
+  text-underline-offset: 2px;
+}
+
+.moving-source-page .moving-affordable-content img {
+  width: auto;
+  min-width: 0;
+  max-width: 461px;
+  height: auto;
+  max-height: 345px;
+  flex: 0 0 40%;
+  margin-top: 0;
+  aspect-ratio: 464 / 345;
+  border-radius: 0;
+  object-fit: contain;
+  object-position: top;
+}
+
+.moving-source-page .search-other-tasks {
+  width: min(1200px, 100%);
+  max-width: 1200px;
+  padding: 32px 24px 48px;
+  background: #fff;
+  box-shadow: 0 0 0 100vmax #fff;
+  clip-path: inset(0 -100vmax);
+}
+
+.moving-source-page .search-other-tasks h2 {
+  margin: 0 0 32px;
+  text-align: center;
+  font-size: 30px;
+  line-height: 42px;
+}
+
+.moving-source-page .search-other-tasks .chip-row {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  grid-auto-rows: 26px;
+  gap: 16px;
+  margin: 0 0 16px;
+}
+
+.moving-source-page .search-other-tasks .chip {
+  padding: 0;
+  border: 0;
+  border-radius: 0;
+  color: #0d7a5f;
+  font-size: 16px;
+  font-weight: 600;
+  line-height: 25.6px;
+  letter-spacing: -.12px;
+}
+
+body:has(.source-category-page) .help-trigger {
+  right: auto;
+  bottom: 16px;
+  left: 16px;
+  display: flex;
+  width: 111px;
+  height: 43px;
+  align-items: center;
+  justify-content: center;
+  border-radius: 1000px;
+  background: #0d7a5f;
+  font-size: 0;
+}
+
+body:has(.source-category-page) .help-trigger > span:first-child {
+  display: none;
+}
+
+body:has(.source-category-page) .help-trigger::before {
+  margin-right: 8px;
+  content: "ⓘ";
+  font-size: 16px;
+  line-height: 1;
+}
+
+body:has(.source-category-page) .help-trigger::after {
+  content: "Help";
+  font-size: 16px;
+  font-weight: 600;
+  line-height: normal;
+  letter-spacing: -.12px;
+}
+
+body:has(.source-category-page) .help-dialog {
+  right: auto;
+  bottom: 72px;
+  left: 16px;
+}
+
+body:has(.source-category-page) .site-footer {
+  height: 387px;
+  min-height: 387px;
+  padding: 24px 0;
+}
+
+body:has(.source-category-page) .site-footer .footer-main {
+  width: min(1200px, 100%);
+  max-width: 1200px;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 0 16px;
+  padding: 0 24px;
+}
+
+body:has(.source-category-page) .site-footer .footer-col:first-child {
+  display: flex;
+  height: 42px;
+  grid-column: 1 / -1;
+  align-items: flex-start;
+}
+
+body:has(.source-category-page) .site-footer .footer-col h3 {
+  margin: 0;
+  color: #b1b9c3;
+  font-size: 18px;
+  font-weight: 400;
+  line-height: 24.66px;
+  letter-spacing: -.09px;
+}
+
+body:has(.source-category-page) .site-footer .footer-col:first-child h3 {
+  width: 212px;
+  white-space: nowrap;
+}
+
+body:has(.source-category-page) .site-footer .footer-social {
+  position: relative;
+  width: 188px;
+  height: 26px;
+  gap: 17px;
+  align-items: center;
+  margin-left: 13px;
+}
+
+body:has(.source-category-page) .site-footer .footer-social img {
+  width: 24px;
+  height: 24px;
+}
+
+body:has(.source-category-page) .site-footer .footer-social::after {
+  position: absolute;
+  top: 0;
+  left: 32px;
+  width: 1px;
+  height: 26px;
+  background: #b1b9c3;
+  box-shadow: 41px 0 #b1b9c3, 82px 0 #b1b9c3, 123px 0 #b1b9c3;
+  content: "";
+  opacity: .65;
+  pointer-events: none;
+}
+
+body:has(.source-category-page) .site-footer .footer-col:not(:first-child) h3 {
+  height: 33px;
+}
+
+body:has(.source-category-page) .site-footer .footer-col a,
+body:has(.source-category-page) .site-footer .footer-col span {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+  line-height: 24px;
+}
+
+body:has(.source-category-page) .site-footer .footer-main > :nth-child(3) > span:nth-of-type(7),
+body:has(.source-category-page) .site-footer .footer-main > :nth-child(3) > span:nth-of-type(8) {
+  margin-top: 8px;
+}
+
+body:has(.source-category-page) .site-footer .footer-main > :nth-child(4) > p {
+  transform: translateY(-9px);
+}
+
+body:has(.source-category-page) .site-footer .footer-main > :nth-child(4) > p {
+  position: relative;
+  top: 1px;
+}
+
+body:has(.source-category-page) .site-footer .footer-col p {
+  margin: 0;
+  color: #fff;
+  font-size: 18px;
+  line-height: 24.66px;
+  letter-spacing: -.09px;
+}
+
+body:has(.source-category-page) .site-footer .footer-badges {
+  position: relative;
+  top: 1px;
+  display: grid;
+  width: 175px;
+  gap: 6px;
+  margin-right: auto;
+  margin-left: auto;
+  padding-top: 24px;
+  transform: translateY(-2px);
+}
+
+body:has(.source-category-page) .site-footer .footer-badges img {
+  width: 175px;
+  height: 58px;
+}
+
+@media (min-width: 1200px) {
+  body:has(.source-category-page) .site-footer {
+    height: 388px;
+    min-height: 388px;
+  }
+
+  body:has(.moving-source-page) .site-footer {
+    height: 387px;
+    min-height: 387px;
+  }
+
+  .moving-source-page .search-other-tasks {
+    padding-bottom: 49px;
+  }
+
+  body:has(.moving-source-page) .site-footer .footer-main > :first-child,
+  body:has(.moving-source-page) .site-footer .footer-main > :nth-child(2),
+  body:has(.moving-source-page) .site-footer .footer-main > :nth-child(3) {
+    transform: translateY(-1px);
+  }
+
+  body:has(.moving-source-page) .site-footer .footer-main > :nth-child(4) {
+    transform: translateY(1px);
+  }
+}
+
+@media (min-width: 600px) {
+  .services-source-page .category-card h3 {
+    transform: translateY(1px);
+  }
+
+  .services-source-page .category-card p {
+    transform: translateY(-2px);
+  }
+
+  .services-source-page .category-card ul {
+    transform: translateY(-.6px);
+  }
+}
+
+@media (min-width: 768px) and (max-width: 1199px) {
+  body:has(.source-category-page) .header-inner {
+    width: calc(100% - 80px);
+  }
+
+  .moving-source-page .moving-main-layout {
+    width: min(1152px, calc(100% - 48px));
+    grid-template-columns: minmax(0, calc(100% - 292px)) 244px;
+    gap: 48px;
+    padding-bottom: 31px;
+  }
+
+  .moving-source-page .moving-hero-copy p {
+    max-width: 500px;
+  }
+
+  .moving-source-page .breadcrumb {
+    width: min(1152px, calc(100% - 48px));
+  }
+
+  .moving-source-page .service-row {
+    grid-template-columns: 175px minmax(0, 1fr);
+  }
+
+  .moving-source-page .moving-sidebar {
+    grid-template-columns: 1fr;
+  }
+
+  .moving-source-page .faq-band {
+    padding-right: 16px;
+    padding-bottom: 81px;
+    padding-left: 16px;
+  }
+
+  .moving-source-page .faq-list {
+    width: 87.55%;
+  }
+
+  body:has(.source-category-page) .site-footer .footer-badges {
+    top: 2px;
+  }
+
+  body:has(.moving-source-page) .site-footer {
+    height: 388px;
+    min-height: 388px;
+  }
+
+  body:has(.moving-source-page) .site-footer .footer-main {
+    transform: translateY(1px);
+  }
+
+  body:has(.moving-source-page) .site-footer .footer-main > :nth-child(4) {
+    transform: translateY(-1px);
+  }
+
+  .moving-source-page .moving-affordable-content {
+    height: 624px;
+    gap: 32px;
+  }
+}
+
+@media (min-width: 768px) {
+  .moving-source-page .service-row {
+    display: flex;
+    flex-direction: row;
+    gap: 0;
+  }
+
+  .moving-source-page .service-row img {
+    min-width: 175px;
+    flex: 0 0 175px;
+    margin-right: 32px;
+  }
+
+  .moving-source-page .service-row > div {
+    display: flex;
+    min-width: 0;
+    flex-direction: column;
+    align-items: flex-start;
+  }
+
+  .moving-source-page .service-row p {
+    transform: translateY(-1px);
+  }
+
+  .moving-source-page .service-row .btn-primary,
+  .moving-source-page .service-row .btn-secondary {
+    transform: translateY(-1px);
+  }
+
+  .moving-source-page .moving-affordable-content img {
+    height: 345px;
+  }
+}
+
+@media (min-width: 768px) and (max-width: 1199px) {
+  .moving-source-page .service-row:nth-child(6) h2,
+  .moving-source-page .service-row:nth-child(7) h2,
+  .moving-source-page .service-row:nth-child(10) h2,
+  .moving-source-page .service-row:nth-child(n + 12):nth-child(-n + 16) h2 {
+    transform: translateY(-1px);
+  }
+
+  .moving-source-page .service-row:nth-child(3) p,
+  .moving-source-page .service-row:nth-child(n + 5):nth-child(-n + 8) p,
+  .moving-source-page .service-row:nth-child(n + 10):nth-child(-n + 17) p,
+  .moving-source-page .service-row:nth-child(19) p {
+    transform: none;
+  }
+
+  .moving-source-page .service-row:nth-child(3) .btn-primary,
+  .moving-source-page .service-row:nth-child(4) .btn-primary,
+  .moving-source-page .service-row:nth-child(n + 7):nth-child(-n + 10) .btn-primary,
+  .moving-source-page .service-row:nth-child(13) .btn-primary,
+  .moving-source-page .service-row:nth-child(n + 16):nth-child(-n + 18) .btn-primary {
+    transform: none;
+  }
+
+  .moving-source-page .service-row:nth-child(3) img,
+  .moving-source-page .service-row:nth-child(4) img,
+  .moving-source-page .service-row:nth-child(8) img,
+  .moving-source-page .service-row:nth-child(9) img,
+  .moving-source-page .service-row:nth-child(13) img,
+  .moving-source-page .service-row:nth-child(14) img,
+  .moving-source-page .service-row:nth-child(17) img,
+  .moving-source-page .service-row:nth-child(18) img {
+    transform: translateY(-1px);
+  }
+}
+
+@media (max-width: 767px) {
+  body:has(.source-category-page) .header-inner {
+    width: calc(100% - 32px);
+  }
+
+  body:has(.source-category-page) .site-header:not(.furniture-header) .brand svg {
+    width: 226px;
+    height: 30px;
+  }
+
+  .services-source-page .services-hero,
+  .services-source-page .services-hero img {
+    height: 350px;
+  }
+
+  .moving-source-page .moving-hero,
+  .moving-source-page .moving-hero img {
+    height: 420px;
+  }
+
+  .services-source-page .services-hero img {
+    object-position: center;
+  }
+
+  .source-category-page .services-hero-copy h1,
+  .source-category-page .moving-hero-copy h1 {
+    font-size: 26px;
+    line-height: 36.4px;
+  }
+
+  .source-category-page .services-hero-copy h1 {
+    padding-bottom: 16px;
+  }
+
+  .services-source-page .category-grid-section {
+    width: 100%;
+    padding: 24px 16px 0;
+  }
+
+  .services-source-page .services-subtitle {
+    margin-bottom: 8px;
+    font-size: 23px;
+    line-height: 32.2px;
+  }
+
+  .services-source-page .category-grid {
+    grid-template-columns: 1fr;
+    margin: 16px 0;
+  }
+
+  .services-source-page .category-card {
+    width: 100%;
+    min-height: 0 !important;
+    margin-bottom: 32px;
+  }
+
+  .services-source-page .category-card h3,
+  .services-source-page .category-card h3 a,
+  .services-source-page .category-card ul {
+    font-size: 14px;
+    line-height: 18.62px;
+    letter-spacing: -.105px;
+  }
+
+  .services-source-page .category-card p {
+    font-size: 14px;
+    line-height: 18.48px;
+    letter-spacing: -.07px;
+    transform: translateY(3px);
+  }
+
+  .services-source-page .category-card h3 {
+    transform: translateY(5px);
+  }
+
+  .services-source-page .category-card ul {
+    transform: translateY(6.5px);
+  }
+
+  .services-source-page .category-card li {
+    min-height: 29.2px;
+  }
+
+  .services-source-page .category-card img {
+    height: 200px;
+  }
+
+  .moving-source-page .moving-hero-copy {
+    width: calc(100% - 48px);
+    transform: none;
+  }
+
+  .moving-source-page .moving-hero-copy h1 {
+    padding-bottom: 16px;
+  }
+
+  .moving-source-page .moving-hero-copy p {
+    max-width: 200px;
+    padding-bottom: 16px;
+    font-size: 16px;
+    line-height: 21.92px;
+  }
+
+  .moving-source-page .breadcrumb {
+    width: 100%;
+    height: 54px;
+    padding: 31px 16px 0;
+    font-size: 16px;
+    line-height: 24px;
+    letter-spacing: -.12px;
+  }
+
+  .moving-source-page .moving-main-layout {
+    width: 100%;
+    grid-template-columns: 1fr;
+    gap: 0;
+    padding: 0 16px 48px;
+  }
+
+  .moving-source-page .moving-services {
+    gap: 32px;
+  }
+
+  .moving-source-page .service-row {
+    height: auto;
+    min-height: 0;
+    grid-template-columns: 1fr;
+    gap: 24px;
+    padding: 24px 16px 32px;
+    text-align: center;
+  }
+
+  .moving-source-page .service-row img {
+    width: 145px;
+    height: 145px;
+    margin: 0 auto;
+  }
+
+  .moving-source-page .service-row h2 {
+    font-size: 18px;
+    line-height: 23.76px;
+    letter-spacing: -.09px;
+  }
+
+  .moving-source-page .service-row p {
+    margin-bottom: 24px;
+    font-size: 14px;
+    line-height: 18.62px;
+    letter-spacing: -.07px;
+  }
+
+  .moving-source-page .service-row .btn-primary,
+  .moving-source-page .service-row .btn-secondary {
+    margin: 0 auto;
+  }
+
+  .moving-source-page .moving-sidebar {
+    display: none;
+  }
+
+  .moving-source-page .faq-band {
+    padding: 64px 13px 72px;
+  }
+
+  .moving-source-page .faq-band h2 {
+    font-size: 24px;
+    line-height: 33.6px;
+  }
+
+  .moving-source-page .moving-affordable-band {
+    padding: 40px 0;
+  }
+
+  .moving-source-page .moving-banner {
+    width: 100%;
+    padding: 0 20px;
+  }
+
+  .moving-source-page .moving-affordable-content {
+    height: auto;
+    flex-direction: column;
+    gap: 32px;
+  }
+
+  .moving-source-page .moving-affordable-content img,
+  .moving-source-page .moving-affordable-copy {
+    width: 100%;
+    max-width: none;
+    flex: none;
+  }
+
+  .moving-source-page .moving-affordable-content img {
+    margin-top: 0;
+  }
+
+  .moving-source-page .search-other-tasks {
+    width: 100%;
+    padding: 32px 20px 48px;
+  }
+
+  .moving-source-page .search-other-tasks .chip-row {
+    grid-template-columns: repeat(2, 1fr);
+  }
+
+  body:has(.source-category-page) .help-trigger {
+    display: none;
+  }
+
+  body:has(.source-category-page) .site-footer {
+    height: auto;
+    min-height: 0;
+  }
+
+  body:has(.source-category-page) .site-footer .footer-main {
+    grid-template-columns: 1fr;
+  }
+
+  body:has(.source-category-page) .site-footer .footer-col:first-child {
+    grid-column: 1;
+  }
+}

tasks/taskrabbit/solution/site/implementation/clone/static/dashboard-fidelity.css

@@ -0,0 +1,615 @@
+.dashboard-shell {
+  width: min(1120px, calc(100% - 48px));
+  margin: 0 auto;
+}
+
+.dashboard-eyebrow {
+  margin: 0 0 6px;
+  color: #65706b;
+  font-size: 13px;
+  font-weight: 700;
+  letter-spacing: .08em;
+  text-transform: uppercase;
+}
+
+.my-tasks-page h1,
+.account-page h1 {
+  margin: 0;
+  color: #0a2b14;
+  font-size: 40px;
+  line-height: 1.18;
+}
+
+.taskbook-page {
+  min-height: calc(100vh - 91px);
+  padding: 0 0 80px;
+  background: #fff;
+}
+
+.taskbook-shell {
+  width: min(1200px, calc(100% - 64px));
+  margin: 0 auto;
+}
+
+.taskbook-launcher {
+  width: min(824px, 100%);
+  margin: 0 auto;
+  padding-top: 43px;
+  text-align: center;
+}
+
+.taskbook-launcher h1 {
+  margin: 0;
+  color: #171a19;
+  font-size: 40px;
+  font-weight: 750;
+  letter-spacing: -.7px;
+  line-height: 1.25;
+}
+
+.taskbook-search {
+  display: flex;
+  width: 100%;
+  height: 84px;
+  margin: 31px auto 0;
+  overflow: hidden;
+  border: 1.5px solid #676d6a;
+  border-radius: 999px;
+  background: #fff;
+}
+
+.taskbook-search:focus-within {
+  border-color: #0d7a5f;
+  box-shadow: 0 0 0 3px rgba(13, 122, 95, .14);
+}
+
+.taskbook-search input {
+  min-width: 0;
+  flex: 1;
+  border: 0;
+  padding: 0 42px;
+  background: transparent;
+  color: #242a30;
+  font: inherit;
+  font-size: 23px;
+  outline: 0;
+}
+
+.taskbook-search input::placeholder { color: #a1a3a2; opacity: 1; }
+
+.taskbook-search button {
+  position: relative;
+  width: 114px;
+  flex: 0 0 114px;
+  border: 0;
+  background: #0d8065;
+  cursor: pointer;
+}
+
+.taskbook-search button:hover { background: #086f56; }
+
+.taskbook-search button span,
+.taskbook-search button span::after {
+  position: absolute;
+  display: block;
+  content: "";
+}
+
+.taskbook-search button span {
+  top: 27px;
+  left: 44px;
+  width: 24px;
+  height: 24px;
+  border: 3px solid #fff;
+  border-radius: 50%;
+}
+
+.taskbook-search button span::after {
+  right: -8px;
+  bottom: -5px;
+  width: 12px;
+  height: 3px;
+  border-radius: 2px;
+  background: #fff;
+  transform: rotate(45deg);
+}
+
+.taskbook-chip-row {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  gap: 10px;
+  margin: 60px auto 0;
+}
+
+.taskbook-chip-row a {
+  display: inline-flex;
+  min-height: 44px;
+  align-items: center;
+  justify-content: center;
+  border: 1.5px solid #0d8065;
+  border-radius: 999px;
+  padding: 7px 21px;
+  color: #0d8065;
+  font-size: 18px;
+  font-weight: 650;
+  line-height: 1.2;
+  text-decoration: none;
+}
+
+.taskbook-chip-row a:hover,
+.taskbook-chip-row a:focus-visible {
+  background: #eaf6f2;
+  outline: none;
+}
+
+.taskbook-more { margin-top: 10px; }
+.taskbook-more summary {
+  display: inline-block;
+  color: #087a5f;
+  font-size: 19px;
+  font-weight: 700;
+  list-style: none;
+  cursor: pointer;
+}
+.taskbook-more summary::-webkit-details-marker { display: none; }
+.taskbook-see-less { display: none; }
+.taskbook-more[open] .taskbook-see-more { display: none; }
+.taskbook-more[open] .taskbook-see-less { display: inline; }
+.taskbook-more .taskbook-chip-row { margin-top: 13px; }
+
+.taskbook-search-results {
+  margin: 24px 0 -38px;
+  text-align: left;
+}
+.taskbook-result-heading {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 24px;
+}
+.taskbook-result-heading p,
+.taskbook-no-results { margin: 0; color: #555d59; }
+.taskbook-result-heading a { font-weight: 650; }
+.taskbook-result-chips { justify-content: flex-start; margin-top: 12px; }
+.taskbook-no-results { margin-top: 8px; }
+
+.taskbook-recommendations { margin-top: 47px; }
+.taskbook-recommendations-heading {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 24px;
+  margin-bottom: 31px;
+}
+.taskbook-recommendations-heading h2 {
+  margin: 0;
+  color: #171a19;
+  font-size: 39px;
+  font-weight: 750;
+  letter-spacing: -.8px;
+  line-height: 1.25;
+}
+
+.taskbook-carousel-controls { display: flex; gap: 10px; }
+.taskbook-carousel-controls button {
+  display: grid;
+  width: 52px;
+  height: 52px;
+  place-items: center;
+  border: 1px solid #c8cdca;
+  border-radius: 50%;
+  background: #fff;
+  color: #9da3a0;
+  cursor: pointer;
+}
+.taskbook-carousel-controls button span {
+  transform: translateY(-2px);
+  font-family: Arial, sans-serif;
+  font-size: 38px;
+  font-weight: 200;
+  line-height: 1;
+}
+.taskbook-carousel-controls button:not(:disabled):hover { border-color: #0d8065; color: #0d8065; }
+.taskbook-carousel-controls button:disabled { cursor: default; opacity: .62; }
+
+.taskbook-carousel {
+  display: flex;
+  gap: 20px;
+  overflow-x: auto;
+  padding: 0 0 8px;
+  scroll-behavior: smooth;
+  scroll-snap-type: x mandatory;
+  scrollbar-width: none;
+}
+.taskbook-carousel::-webkit-scrollbar { display: none; }
+
+.taskbook-tasker-card {
+  min-width: calc((100% - 20px) / 2);
+  overflow: hidden;
+  border: 1px solid #c9cfcc;
+  border-radius: 20px 20px 0 0;
+  background: #fff;
+  scroll-snap-align: start;
+}
+.taskbook-tasker-card > h3 {
+  margin: 0;
+  padding: 21px 20px;
+  border-bottom: 1px solid #c9cfcc;
+  background: #f6f8f7;
+  color: #171a19;
+  font-size: 23px;
+  font-weight: 700;
+  line-height: 1.35;
+  text-align: center;
+}
+.taskbook-tasker-body { padding: 20px 21px 30px; }
+.taskbook-tasker-profile-link {
+  display: block;
+  width: fit-content;
+  color: inherit;
+  text-decoration: none;
+}
+.taskbook-tasker-avatar {
+  display: block;
+  width: 92px;
+  height: 92px;
+  border-radius: 50%;
+  object-fit: cover;
+}
+.taskbook-tasker-body h4 {
+  margin: 8px 0 14px;
+  color: #171a19;
+  font-size: 23px;
+  line-height: 1.25;
+}
+.taskbook-tasker-profile-link:hover h4,
+.taskbook-tasker-profile-link:focus-visible h4 { color: #0d8065; }
+.taskbook-tasker-profile-link:focus-visible { border-radius: 6px; outline: 2px solid #0d8065; outline-offset: 3px; }
+.taskbook-elite {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  margin: 0 0 13px;
+  border-radius: 5px;
+  padding: 4px 8px;
+  background: #f3dfff;
+  color: #8b43a9;
+  font-size: 14px;
+  font-weight: 700;
+  letter-spacing: .03em;
+  line-height: 1.4;
+  text-transform: uppercase;
+}
+.taskbook-tasker-stat {
+  margin: 0 0 10px;
+  color: #242927;
+  font-size: 20px;
+  line-height: 1.35;
+}
+.taskbook-check {
+  display: inline-grid;
+  width: 17px;
+  height: 17px;
+  place-items: center;
+  border: 2px solid currentColor;
+  border-radius: 50%;
+  font-size: 10px;
+  font-weight: 800;
+  vertical-align: 2px;
+}
+.taskbook-star { font-size: 24px; vertical-align: -1px; }
+.taskbook-review-count { color: #666c69; }
+.taskbook-skill-divider {
+  display: flex;
+  align-items: center;
+  gap: 13px;
+  margin: 28px 0 16px;
+  color: #242927;
+  font-size: 17px;
+  text-align: center;
+}
+.taskbook-skill-divider::before,
+.taskbook-skill-divider::after {
+  height: 1px;
+  flex: 1;
+  background: #d4d8d6;
+  content: "";
+}
+.taskbook-skill {
+  display: grid;
+  border: 1.5px solid #0d8065;
+  border-radius: 999px;
+  padding: 13px 31px;
+  color: #0d8065;
+  text-decoration: none;
+}
+.taskbook-skill strong { font-size: 20px; line-height: 1.35; }
+.taskbook-skill span { font-size: 17px; }
+.taskbook-skill:hover,
+.taskbook-skill:focus-visible { background: #eaf6f2; outline: none; }
+.taskbook-view-profile {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  margin-top: 18px;
+  color: #0d8065;
+  font-weight: 700;
+  text-decoration: none;
+}
+.taskbook-view-profile:hover,
+.taskbook-view-profile:focus-visible { text-decoration: underline; }
+
+.taskbook-deep-page {
+  min-height: calc(100vh - 91px);
+  padding: 30px 0 80px;
+  background: #fff;
+}
+.taskbook-deep-shell,
+.taskbook-profile-shell {
+  width: min(1120px, calc(100% - 64px));
+  margin: 0 auto;
+}
+.taskbook-profile-shell { width: min(820px, calc(100% - 64px)); }
+.taskbook-breadcrumb {
+  display: flex;
+  align-items: center;
+  gap: 9px;
+  margin-bottom: 28px;
+  color: #626966;
+  font-size: 14px;
+}
+.taskbook-breadcrumb a { color: #0d8065; font-weight: 650; text-decoration: none; }
+.taskbook-breadcrumb a:hover,
+.taskbook-breadcrumb a:focus-visible { text-decoration: underline; }
+
+.taskbook-category-hero {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(320px, 44%);
+  min-height: 330px;
+  overflow: hidden;
+  border-radius: 18px;
+  background: #edf7f3;
+}
+.taskbook-category-copy {
+  align-self: center;
+  padding: 48px 52px;
+}
+.taskbook-deep-eyebrow {
+  margin: 0 0 7px;
+  color: #52605a;
+  font-size: 13px;
+  font-weight: 750;
+  letter-spacing: .08em;
+  text-transform: uppercase;
+}
+.taskbook-category-copy h1 {
+  margin: 0;
+  color: #123c27;
+  font-size: 44px;
+  line-height: 1.15;
+}
+.taskbook-category-copy > p:not(.taskbook-deep-eyebrow) {
+  margin: 15px 0 0;
+  color: #39433e;
+  font-size: 17px;
+}
+.taskbook-category-copy .taskbook-category-trending {
+  font-size: 14px;
+  font-weight: 600;
+}
+.taskbook-category-hero > img {
+  width: 100%;
+  height: 100%;
+  min-height: 330px;
+  object-fit: cover;
+}
+.taskbook-category-list { padding: 46px 0 0; }
+.taskbook-category-list h2 {
+  margin: 0 0 22px;
+  color: #171a19;
+  font-size: 30px;
+}
+.taskbook-category-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  overflow: hidden;
+  border: 1px solid #d7dcda;
+  border-radius: 14px;
+}
+.taskbook-category-grid a {
+  display: flex;
+  min-height: 66px;
+  align-items: center;
+  justify-content: space-between;
+  gap: 20px;
+  padding: 17px 22px;
+  border-bottom: 1px solid #e2e6e4;
+  color: #202522;
+  font-size: 17px;
+  font-weight: 650;
+  text-decoration: none;
+}
+.taskbook-category-grid a:nth-child(odd) { border-right: 1px solid #e2e6e4; }
+.taskbook-category-grid a:hover,
+.taskbook-category-grid a:focus-visible { background: #edf7f3; color: #0d8065; outline: none; }
+.taskbook-category-grid a span:last-child { color: #0d8065; font-size: 28px; font-weight: 400; }
+
+.taskbook-profile-card {
+  overflow: hidden;
+  border: 1px solid #cfd5d2;
+  border-radius: 18px;
+  background: #fff;
+  box-shadow: 0 5px 20px rgba(30, 42, 36, .07);
+}
+.taskbook-profile-heading {
+  display: flex;
+  align-items: center;
+  gap: 28px;
+  padding: 34px 38px;
+  border-bottom: 1px solid #dde2df;
+  background: #f7faf8;
+}
+.taskbook-profile-heading > img {
+  width: 112px;
+  height: 112px;
+  border-radius: 50%;
+  object-fit: cover;
+}
+.taskbook-profile-heading .taskbook-elite { margin-bottom: 9px; }
+.taskbook-profile-heading h1 {
+  margin: 0;
+  color: #171a19;
+  font-size: 36px;
+  line-height: 1.15;
+}
+.taskbook-profile-popular { margin: 7px 0 0; color: #626966; }
+.taskbook-profile-stats {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  margin: 0;
+  padding: 30px 38px;
+  border-bottom: 1px solid #dde2df;
+}
+.taskbook-profile-stats div + div { border-left: 1px solid #dde2df; padding-left: 28px; }
+.taskbook-profile-stats dt { color: #68706c; font-size: 13px; font-weight: 700; text-transform: uppercase; }
+.taskbook-profile-stats dd { margin: 5px 0 0; color: #171a19; font-size: 24px; font-weight: 750; }
+.taskbook-profile-skill {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 28px;
+  padding: 31px 38px;
+}
+.taskbook-profile-skill p { margin: 0; color: #68706c; font-size: 13px; font-weight: 700; text-transform: uppercase; }
+.taskbook-profile-skill h2 { margin: 4px 0 1px; color: #183d2a; font-size: 25px; }
+.taskbook-profile-skill strong { color: #0d8065; font-size: 18px; }
+.taskbook-profile-skill .btn-primary { white-space: nowrap; }
+.taskbook-profile-note { margin: 0; padding: 0 38px 31px; color: #626966; font-size: 14px; }
+
+.dashboard-empty {
+  max-width: 620px;
+  margin: 50px auto;
+  padding: 48px 32px;
+  border: 1px solid #dce0de;
+  border-radius: 12px;
+  background: #fafcfb;
+  text-align: center;
+}
+.dashboard-empty h2 { margin: 0 0 8px; color: #0a2b14; }
+.dashboard-empty p { margin: 0 0 24px; color: #65706b; }
+
+.my-tasks-page,
+.account-page { min-height: 620px; padding: 56px 0 80px; }
+.my-tasks-heading { display: flex; align-items: end; justify-content: space-between; gap: 24px; }
+.task-view-tabs { display: flex; gap: 32px; margin-top: 36px; border-bottom: 1px solid #dce0de; }
+.task-view-tabs a {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  border-bottom: 3px solid transparent;
+  padding: 0 2px 13px;
+  color: #59615e;
+  font-weight: 650;
+  text-decoration: none;
+}
+.task-view-tabs a.active { border-color: #0d7a5f; color: #075f49; }
+.task-view-tabs span { min-width: 24px; border-radius: 999px; padding: 2px 7px; background: #edf1ef; font-size: 12px; text-align: center; }
+.task-card-list { display: grid; gap: 18px; margin-top: 28px; }
+.task-summary-card {
+  display: grid;
+  grid-template-columns: 74px 1fr;
+  gap: 22px;
+  border: 1px solid #dce0de;
+  border-radius: 12px;
+  padding: 24px;
+  box-shadow: 0 3px 12px rgba(20, 31, 27, .06);
+}
+.task-date-badge {
+  align-self: start;
+  overflow: hidden;
+  border: 1px solid #b9c2bd;
+  border-radius: 9px;
+  text-align: center;
+}
+.task-date-badge span { display: block; padding: 4px; background: #0d7a5f; color: #fff; font-size: 12px; font-weight: 700; text-transform: uppercase; }
+.task-date-badge strong { display: block; padding: 8px; color: #0a2b14; font-size: 25px; }
+.task-summary-title { display: flex; align-items: start; justify-content: space-between; gap: 20px; }
+.task-status { margin: 0 0 3px; color: #0d7a5f; font-size: 13px; font-weight: 700; text-transform: uppercase; }
+.task-summary-title h2 { margin: 0; color: #0a2b14; font-size: 22px; }
+.task-total { color: #0a2b14; font-size: 18px; }
+.task-summary-main dl { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px 30px; margin: 20px 0; }
+.task-summary-main dl div { min-width: 0; }
+.task-summary-main dt { color: #65706b; font-size: 12px; font-weight: 700; text-transform: uppercase; }
+.task-summary-main dd { margin: 2px 0 0; overflow-wrap: anywhere; }
+.task-details-link { font-weight: 700; text-decoration: none; }
+.my-tasks-empty { margin-top: 42px; }
+.empty-calendar { display: block; width: 58px; height: 54px; margin: 0 auto 18px; border: 3px solid #0d7a5f; border-radius: 7px; box-shadow: inset 0 12px #dff1e8; }
+
+.account-layout { display: grid; grid-template-columns: 220px minmax(0, 1fr); gap: 32px; margin-top: 34px; }
+.account-side-nav { display: grid; align-content: start; overflow: hidden; border: 1px solid #dce0de; border-radius: 10px; }
+.account-side-nav a { padding: 13px 16px; color: #333a37; text-decoration: none; }
+.account-side-nav a + a { border-top: 1px solid #e7e9e8; }
+.account-side-nav a.active { border-left: 4px solid #0d7a5f; background: #f1f8f4; color: #075f49; font-weight: 700; }
+.account-profile-card { display: grid; grid-template-columns: auto 1fr; gap: 4px 18px; border: 1px solid #dce0de; border-radius: 12px; padding: 30px; }
+.profile-avatar { display: grid; grid-row: span 1; width: 56px; height: 56px; place-items: center; border-radius: 50%; background: #dff1e8; color: #075f49; font-size: 23px; font-weight: 700; }
+.account-profile-card h2 { margin: 2px 0 0; color: #0a2b14; }
+.account-profile-card .secondary-note { margin: 4px 0; }
+.account-profile-card dl { grid-column: 1 / -1; margin: 28px 0; border-top: 1px solid #e4e7e5; }
+.account-profile-card dl div { display: grid; grid-template-columns: 180px 1fr; gap: 20px; padding: 16px 0; border-bottom: 1px solid #e4e7e5; }
+.account-profile-card dt { color: #65706b; font-weight: 650; }
+.account-profile-card dd { margin: 0; }
+.account-profile-actions { grid-column: 1 / -1; display: flex; flex-wrap: wrap; gap: 12px; }
+.account-profile-actions .btn-secondary { text-decoration: none; }
+
+@media (max-width: 760px) {
+  .dashboard-shell { width: calc(100% - 32px); }
+  .my-tasks-page h1,
+  .account-page h1 { font-size: 32px; }
+  .my-tasks-heading { align-items: flex-start; flex-direction: column; }
+  .taskbook-shell { width: calc(100% - 32px); }
+  .taskbook-launcher { padding-top: 34px; }
+  .taskbook-launcher h1 { font-size: 32px; }
+  .taskbook-search { height: 64px; margin-top: 24px; }
+  .taskbook-search input { padding: 0 20px; font-size: 16px; }
+  .taskbook-search button { width: 72px; flex-basis: 72px; }
+  .taskbook-search button span { top: 20px; left: 24px; width: 19px; height: 19px; border-width: 2px; }
+  .taskbook-chip-row { gap: 8px; margin-top: 34px; }
+  .taskbook-chip-row a { min-height: 39px; padding: 7px 14px; font-size: 15px; }
+  .taskbook-recommendations { margin-top: 39px; }
+  .taskbook-recommendations-heading { align-items: flex-end; margin-bottom: 20px; }
+  .taskbook-recommendations-heading h2 { max-width: 250px; font-size: 28px; }
+  .taskbook-carousel-controls button { width: 42px; height: 42px; }
+  .taskbook-carousel-controls button span { font-size: 30px; }
+  .taskbook-tasker-card { min-width: min(88%, 390px); }
+  .taskbook-tasker-card > h3 { font-size: 19px; }
+  .taskbook-tasker-stat { font-size: 17px; }
+  .taskbook-result-heading { align-items: flex-start; flex-direction: column; gap: 6px; }
+  .taskbook-deep-page { padding-top: 20px; }
+  .taskbook-deep-shell,
+  .taskbook-profile-shell { width: calc(100% - 32px); }
+  .taskbook-category-hero { grid-template-columns: 1fr; }
+  .taskbook-category-copy { padding: 34px 26px; }
+  .taskbook-category-copy h1 { font-size: 34px; }
+  .taskbook-category-hero > img { min-height: 230px; max-height: 280px; }
+  .taskbook-category-grid { grid-template-columns: 1fr; }
+  .taskbook-category-grid a:nth-child(odd) { border-right: 0; }
+  .taskbook-category-list h2 { font-size: 26px; }
+  .taskbook-profile-heading { align-items: flex-start; gap: 20px; padding: 26px 22px; }
+  .taskbook-profile-heading > img { width: 84px; height: 84px; }
+  .taskbook-profile-heading h1 { font-size: 29px; }
+  .taskbook-profile-stats { gap: 17px; padding: 24px 22px; }
+  .taskbook-profile-stats div + div { padding-left: 17px; }
+  .taskbook-profile-stats dt { font-size: 11px; }
+  .taskbook-profile-stats dd { font-size: 19px; }
+  .taskbook-profile-skill { align-items: flex-start; flex-direction: column; padding: 27px 22px; }
+  .taskbook-profile-note { padding: 0 22px 27px; }
+  .task-summary-card { grid-template-columns: 58px 1fr; gap: 15px; padding: 18px 16px; }
+  .task-summary-main dl { grid-template-columns: 1fr; }
+  .task-summary-title { flex-direction: column; gap: 8px; }
+  .account-layout { grid-template-columns: 1fr; }
+  .account-side-nav { grid-template-columns: 1fr 1fr; }
+  .account-side-nav a + a { border-top: 0; border-left: 1px solid #e7e9e8; }
+  .account-profile-card { padding: 22px 18px; }
+  .account-profile-card dl div { grid-template-columns: 1fr; gap: 4px; }
+}

tasks/taskrabbit/solution/site/implementation/clone/static/furniture-detail-fidelity.css

@@ -0,0 +1,423 @@
+.furniture-detail-width {
+  width: min(1144px, calc(100% - 48px));
+  margin-inline: auto;
+}
+
+.furniture-detail-hero {
+  position: relative;
+  display: grid;
+  min-height: 550px;
+  place-items: center;
+  overflow: hidden;
+}
+
+.furniture-detail-hero > img {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+}
+
+.furniture-detail-hero-card {
+  position: relative;
+  width: min(574px, calc(100% - 48px));
+  padding: 42px 44px 34px;
+  border-radius: 16px;
+  background: #fff;
+  text-align: center;
+}
+
+.furniture-detail-hero-card h1 {
+  margin: 0 0 30px;
+  font-size: 36px;
+  line-height: 1.15;
+}
+
+.furniture-detail-hero-card p {
+  max-width: 460px;
+  margin: 0 auto 30px;
+  font-size: 16px;
+  line-height: 1.45;
+}
+
+.furniture-detail-button {
+  display: inline-flex;
+  min-width: 258px;
+  min-height: 44px;
+  align-items: center;
+  justify-content: center;
+  padding: 11px 24px;
+  border-radius: 999px;
+  background: #0d7a5f;
+  color: #fff;
+  font-weight: 700;
+  text-decoration: none;
+}
+
+.furniture-detail-breadcrumb {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  padding-block: 17px 18px;
+  color: #0d7a5f;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.furniture-detail-breadcrumb a {
+  color: inherit;
+  text-decoration: none;
+}
+
+.furniture-detail-article {
+  position: relative;
+  min-height: 420px;
+  padding: 20px 0 60px;
+}
+
+.furniture-detail-prose {
+  width: 62%;
+  color: #242a30;
+  font-size: 16px;
+  line-height: 1.45;
+}
+
+.furniture-detail-prose h2 {
+  margin: 20px 0 14px;
+  font-size: 26px;
+  line-height: 1.2;
+}
+
+.furniture-detail-prose > h2:first-child {
+  margin-top: 0;
+}
+
+.furniture-detail-prose p {
+  margin: 0 0 14px;
+}
+
+.furniture-detail-prose li {
+  margin: 2px 0;
+}
+
+.furniture-detail-article > img {
+  position: absolute;
+  top: 30px;
+  right: 0;
+  width: 39%;
+  height: auto;
+  max-height: 360px;
+  object-fit: cover;
+}
+
+.furniture-detail-how {
+  padding: 44px 0 54px;
+  background: #f6f7f7;
+}
+
+.furniture-detail-how h2 {
+  margin: 0 0 24px;
+  text-align: center;
+  font-size: 26px;
+}
+
+.furniture-detail-how ol {
+  display: grid;
+  margin: 0;
+  padding: 0;
+  grid-template-columns: repeat(3, 1fr);
+  gap: 60px;
+  list-style: none;
+}
+
+.furniture-detail-how li img {
+  display: block;
+  width: 144px;
+  height: 120px;
+  margin: 0 auto 12px;
+  object-fit: contain;
+}
+
+.furniture-detail-how h3 {
+  margin: 0 0 6px;
+  color: #173d31;
+  font-size: 17px;
+}
+
+.furniture-detail-how h3 span {
+  display: inline-grid;
+  width: 20px;
+  height: 20px;
+  margin-right: 8px;
+  border: 1px solid #7d8782;
+  border-radius: 50%;
+  color: #5f6965;
+  place-items: center;
+  font-size: 12px;
+  font-weight: 400;
+}
+
+.furniture-detail-how p {
+  margin: 0;
+  color: #58615e;
+  line-height: 1.45;
+}
+
+.furniture-detail-ready {
+  padding: 48px 0;
+  background: #fffde1;
+}
+
+.furniture-detail-ready > div {
+  display: grid;
+  align-items: center;
+  grid-template-columns: 2fr 1fr;
+  gap: 48px;
+}
+
+.furniture-detail-ready img {
+  width: 100%;
+  height: 360px;
+  object-fit: cover;
+}
+
+.furniture-detail-ready h2 {
+  margin: 0 0 24px;
+  font-size: 31px;
+}
+
+.furniture-detail-ready .furniture-detail-button {
+  min-width: 150px;
+}
+
+.furniture-detail-faq {
+  padding-block: 62px 82px;
+}
+
+.furniture-detail-faq h2 {
+  margin: 0 0 32px;
+  color: #25563f;
+  font-size: 31px;
+}
+
+.furniture-detail-faq details {
+  border-bottom: 1px solid #dce0e0;
+}
+
+.furniture-detail-faq summary {
+  padding: 19px 18px;
+  color: #25563f;
+  cursor: pointer;
+  list-style-position: outside;
+}
+
+.furniture-detail-locations {
+  padding: 72px 0 90px;
+  background: #f6f7f7;
+}
+
+.furniture-detail-locations h2 {
+  margin: 0 0 34px;
+  font-size: 25px;
+}
+
+.furniture-detail-locations ul {
+  display: grid;
+  margin: 0;
+  padding: 0;
+  grid-template-columns: repeat(5, 1fr);
+  gap: 20px 42px;
+  list-style: none;
+}
+
+.furniture-detail-locations a {
+  color: #0d7a5f;
+  font-weight: 700;
+  text-decoration: none;
+}
+
+.furniture-detail-help {
+  position: fixed;
+  z-index: 10;
+  bottom: 18px;
+  left: 16px;
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  padding: 11px 20px;
+  border-radius: 999px;
+  background: #0d7a5f;
+  color: #fff;
+  font-weight: 700;
+  text-decoration: none;
+}
+
+.furniture-detail-help span {
+  display: grid;
+  width: 18px;
+  height: 18px;
+  border: 1px solid currentColor;
+  border-radius: 50%;
+  place-items: center;
+  font-size: 12px;
+}
+
+@media (max-width: 700px) {
+  .furniture-detail-width {
+    width: calc(100% - 32px);
+  }
+
+  .furniture-detail-hero {
+    min-height: 365px;
+    align-items: end;
+    padding-bottom: 24px;
+  }
+
+  .furniture-detail-hero-card {
+    width: calc(100% - 32px);
+    padding: 22px 20px 20px;
+    border-radius: 12px;
+  }
+
+  .furniture-detail-hero-card h1 {
+    margin-bottom: 22px;
+    font-size: 25px;
+  }
+
+  .furniture-detail-hero-card p {
+    margin-bottom: 18px;
+    font-size: 14px;
+  }
+
+  .furniture-detail-button {
+    width: 100%;
+    min-width: 0;
+    min-height: 39px;
+    padding-block: 8px;
+  }
+
+  .furniture-detail-breadcrumb {
+    padding-block: 15px;
+    gap: 5px;
+    font-size: 12px;
+  }
+
+  .furniture-detail-article {
+    display: flex;
+    min-height: 0;
+    padding: 18px 0 36px;
+    flex-direction: column;
+  }
+
+  .furniture-detail-prose {
+    width: 100%;
+    font-size: 14px;
+  }
+
+  .furniture-detail-prose h2 {
+    font-size: 21px;
+  }
+
+  .furniture-detail-article > img {
+    position: static;
+    width: 100%;
+    max-height: none;
+    margin: 2px 0 18px;
+    order: -1;
+  }
+
+  .furniture-detail-prose:not(.furniture-detail-prose-after-image) + img {
+    order: 0;
+  }
+
+  .furniture-detail-how {
+    padding: 36px 0 28px;
+  }
+
+  .furniture-detail-how h2 {
+    font-size: 19px;
+  }
+
+  .furniture-detail-how ol {
+    display: block;
+  }
+
+  .furniture-detail-how li {
+    margin-bottom: 24px;
+  }
+
+  .furniture-detail-how li img {
+    width: 116px;
+    height: 96px;
+  }
+
+  .furniture-detail-how h3,
+  .furniture-detail-how p {
+    font-size: 13px;
+  }
+
+  .furniture-detail-ready {
+    padding: 24px 16px 32px;
+  }
+
+  .furniture-detail-ready > div {
+    width: 100%;
+    display: block;
+    text-align: center;
+  }
+
+  .furniture-detail-ready img {
+    height: auto;
+    margin-bottom: 22px;
+  }
+
+  .furniture-detail-ready h2 {
+    margin-bottom: 15px;
+    font-size: 20px;
+  }
+
+  .furniture-detail-ready .furniture-detail-button {
+    width: auto;
+    min-width: 130px;
+  }
+
+  .furniture-detail-faq {
+    padding-block: 38px 46px;
+  }
+
+  .furniture-detail-faq h2 {
+    font-size: 20px;
+  }
+
+  .furniture-detail-faq summary {
+    padding: 16px 4px;
+    font-size: 13px;
+  }
+
+  .furniture-detail-locations {
+    padding: 45px 0 56px;
+  }
+
+  .furniture-detail-locations h2 {
+    font-size: 19px;
+  }
+
+  .furniture-detail-locations ul {
+    grid-template-columns: repeat(2, 1fr);
+    gap: 18px 24px;
+  }
+
+  .furniture-detail-locations a {
+    font-size: 12px;
+  }
+
+  .furniture-detail-help {
+    position: static;
+    display: flex;
+    border-radius: 0;
+    padding: 24px 16px;
+    background: #fff;
+    color: #6d7775;
+  }
+}

tasks/taskrabbit/solution/site/implementation/clone/static/furniture-p1.css

@@ -0,0 +1,609 @@
+.furniture-card-title {
+  color: #1a1e1d;
+  text-decoration: none;
+}
+
+.furniture-card-title:hover,
+.furniture-card-title:focus-visible {
+  color: #055240;
+  text-decoration: underline;
+  text-underline-offset: 3px;
+}
+
+.furniture-faq-list details p a {
+  color: #0d7a5f;
+  font-weight: 600;
+}
+
+/* Source-direct furniture landing calibration. These rules intentionally live
+   in the page stylesheet so the shared home, services, and moving chrome keep
+   their independently calibrated geometry. */
+body:has(.furniture-header) {
+  color: #242a30;
+}
+
+.furniture-header {
+  border-bottom-color: #dce0e6;
+}
+
+.furniture-brand {
+  color: #0d7a5f;
+}
+
+.furniture-brand svg {
+  height: auto;
+  fill: currentColor;
+}
+
+.furniture-main-nav a,
+.furniture-auth-control {
+  color: #1a1e1d;
+  line-height: normal;
+}
+
+.furniture-tasker-control {
+  border-color: #0d7a5f;
+  color: #0d7a5f;
+  line-height: normal;
+}
+
+.furniture-menu-icon {
+  display: block;
+  width: 24px;
+  height: 24px;
+  background: none;
+  color: #0d7a5f;
+  fill: currentColor;
+}
+
+.furniture-menu-icon::before,
+.furniture-menu-icon::after {
+  display: none;
+  content: none;
+}
+
+.furniture-menu-icon path {
+  fill: currentColor;
+}
+
+.furniture-hero-shade {
+  background: #00000040;
+}
+
+.furniture-hero-copy {
+  width: 50%;
+  text-shadow: none;
+}
+
+.furniture-hero-copy p {
+  width: 100%;
+}
+
+@media (min-width: 900px) {
+  .furniture-hero > img {
+    object-position: 50% 15%;
+  }
+}
+
+.furniture-page-body {
+  padding-top: 32px;
+}
+
+.furniture-breadcrumb {
+  height: 27px;
+  gap: 0;
+  color: #0d7a5f;
+  font-size: 18px;
+  line-height: 25.2px;
+}
+
+.furniture-breadcrumb > span[aria-hidden="true"] {
+  display: flex;
+  margin: 0 8px;
+  font-size: 16px;
+  line-height: 25.6px;
+  letter-spacing: -0.12px;
+}
+
+@media (min-width: 600px) {
+  .furniture-breadcrumb > * {
+    transform: translateY(-1px);
+  }
+}
+
+.furniture-main-layout {
+  padding-bottom: 0;
+}
+
+.furniture-card-list {
+  display: block;
+}
+
+.furniture-card {
+  display: flex;
+  align-items: center;
+  min-height: 223px;
+  margin-bottom: 32px;
+  gap: 0;
+  box-shadow: 0 1px 8px rgba(0, 0, 0, 0.15);
+}
+
+.furniture-image-frame {
+  position: relative;
+  width: 175px;
+  height: 175px;
+  min-width: 175px;
+  flex: 0 0 175px;
+  margin-right: 32px;
+  overflow: hidden;
+  border-radius: 1000px;
+}
+
+.furniture-image-frame > img {
+  position: absolute;
+  inset: 0;
+  display: block;
+  width: 175px;
+  height: 175px;
+  max-width: none;
+  object-fit: cover;
+}
+
+.furniture-card-copy {
+  display: flex;
+  min-width: 0;
+  flex: 1;
+  align-items: flex-start;
+  flex-direction: column;
+}
+
+.furniture-book-button {
+  width: 127px;
+  height: 43px;
+  min-width: 127px;
+  min-height: 43px;
+  padding: 12px 24px;
+  border-radius: 1000px;
+  font-size: 16px;
+  line-height: normal;
+}
+
+@media (min-width: 1200px) {
+  .furniture-card:nth-child(-n + 10) .furniture-card-copy p,
+  .furniture-card:nth-child(-n + 10) .furniture-book-button {
+    transform: translateY(-1px);
+  }
+}
+
+@media (min-width: 600px) and (max-width: 1199px) {
+  .furniture-card:nth-child(2) .furniture-image-frame,
+  .furniture-card:nth-child(5) .furniture-image-frame,
+  .furniture-card:nth-child(10) .furniture-image-frame,
+  .furniture-card:nth-child(11) .furniture-image-frame {
+    transform: translateY(-1px);
+  }
+
+  .furniture-card:nth-child(1) .furniture-card-copy p,
+  .furniture-card:nth-child(1) .furniture-book-button,
+  .furniture-card:nth-child(n + 3):nth-child(-n + 5) .furniture-card-copy p,
+  .furniture-card:nth-child(n + 3):nth-child(-n + 5) .furniture-book-button {
+    transform: translateY(-1px);
+  }
+}
+
+.furniture-review-list blockquote p {
+  margin-bottom: 8px;
+  font-size: 16px;
+  line-height: 25.6px;
+  letter-spacing: -0.08px;
+}
+
+.furniture-review-list cite {
+  font-weight: 600;
+  line-height: 25.6px;
+  letter-spacing: -0.12px;
+}
+
+.furniture-step-number {
+  background: #1a1e1d;
+  font-size: 16px;
+  font-weight: 400;
+  line-height: 24px;
+}
+
+.furniture-steps li:first-child .furniture-step-number,
+.furniture-steps li:first-child h3,
+.furniture-steps li:nth-child(2) p {
+  transform: translateY(-1px);
+}
+
+.furniture-other-tasks {
+  padding: 32px 0;
+}
+
+.furniture-other-tasks ul {
+  gap: 0;
+  margin-bottom: 16px;
+}
+
+.furniture-other-tasks li {
+  margin-bottom: 16px;
+}
+
+.furniture-other-tasks a,
+.furniture-other-tasks span {
+  color: #0d7a5f;
+}
+
+body:has(.furniture-header) .furniture-help-trigger {
+  background: #0d7a5f;
+  right: auto;
+  bottom: 16px;
+  left: 16px;
+  width: 111px;
+  min-width: 0;
+  height: 43px;
+  gap: 0;
+  border-radius: 1000px;
+  padding: 12px 24px;
+  font-size: 16px;
+  font-family: "Inter", Helvetica, sans-serif;
+  font-weight: 600;
+  line-height: normal;
+  letter-spacing: -0.12px;
+}
+
+body:has(.furniture-header) .furniture-help-icon {
+  display: block;
+  width: 20px;
+  height: 20px;
+  margin: -2px 8px 0 -2px;
+}
+
+.furniture-footer-social {
+  gap: 5px;
+  min-height: 26px;
+  line-height: 24.66px;
+  letter-spacing: -0.09px;
+}
+
+.furniture-footer-social > div {
+  align-self: flex-start;
+  gap: 0;
+  margin-left: 8px;
+}
+
+.furniture-footer-social > div > * + * {
+  margin-left: 8px;
+}
+
+.furniture-footer-social img {
+  width: 24px;
+  height: 24px;
+}
+
+.furniture-social-separator {
+  align-self: stretch;
+  width: 1px;
+  border-right: 1px solid #fff;
+}
+
+.furniture-footer-column a,
+.furniture-footer-column span {
+  font-weight: 600;
+}
+
+.furniture-footer-column > h2 + span,
+.furniture-footer-company-primary,
+.furniture-footer-company-secondary {
+  padding-top: 8px;
+}
+
+.furniture-footer-company-primary,
+.furniture-footer-company-secondary {
+  display: flex;
+  align-items: flex-start;
+  flex-direction: column;
+}
+
+.furniture-footer-terms {
+  display: flex;
+  gap: 4px;
+  min-height: 25px;
+  padding-top: 8px;
+}
+
+.furniture-footer-app p {
+  max-width: none;
+}
+
+.furniture-footer-app img {
+  width: 175px;
+  height: 58px;
+  margin-bottom: 6px;
+}
+
+.furniture-footer-badges {
+  padding-top: 8px;
+}
+
+.furniture-faq details {
+  border-color: #dadcdb;
+}
+
+.furniture-faq summary::after {
+  content: none;
+}
+
+.furniture-faq-chevron {
+  position: absolute;
+  top: 50%;
+  right: 16px;
+  width: 16px;
+  height: 16px;
+  color: rgba(0, 0, 0, 0.54);
+  fill: currentColor;
+  transform: translateY(-50%);
+}
+
+.furniture-faq details[open] .furniture-faq-chevron {
+  transform: translateY(-50%) rotate(180deg);
+}
+
+@media (max-width: 1199px) {
+  body:has(.furniture-header) .site-footer.furniture-footer {
+    min-height: 387px;
+  }
+
+  .furniture-header .header-inner {
+    width: 92%;
+  }
+
+  .furniture-faq {
+    width: 100vw;
+    margin-left: calc(50% - 50vw);
+    padding-right: 16px;
+    padding-left: 16px;
+  }
+
+  .furniture-faq-list {
+    width: 87.55%;
+  }
+
+  .furniture-main-layout {
+    height: 2814px;
+  }
+
+  .furniture-other-tasks {
+    min-height: 239px;
+  }
+}
+
+@media (max-width: 899px) {
+  .furniture-main-layout {
+    grid-template-columns: 1fr;
+  }
+
+  .furniture-sidebar {
+    position: static;
+    padding: 16px;
+  }
+}
+
+@media (min-width: 600px) and (max-width: 899px) {
+  .furniture-faq {
+    padding-top: 48px;
+    padding-bottom: 48px;
+  }
+
+  .furniture-faq-list {
+    width: 70%;
+  }
+}
+
+@media (max-width: 599px) {
+  .furniture-breadcrumb {
+    gap: 0.45rem;
+  }
+
+  .furniture-breadcrumb > span[aria-hidden="true"] {
+    display: inline;
+    margin: 0;
+    font-size: inherit;
+    line-height: inherit;
+    letter-spacing: inherit;
+  }
+
+  .furniture-breadcrumb > * {
+    transform: none;
+  }
+
+  .furniture-hero-copy {
+    width: 255px;
+    transform: none;
+  }
+
+  .furniture-hero-copy h1 {
+    padding-bottom: 16px;
+    font-size: 26px;
+    font-weight: 800;
+    line-height: 36.4px;
+    letter-spacing: normal;
+  }
+
+  .furniture-hero-copy p {
+    padding-bottom: 16px;
+    font-size: 16px;
+    line-height: 21.92px;
+    letter-spacing: -0.08px;
+  }
+
+  .furniture-breadcrumb {
+    height: 22px;
+    font-size: 16px;
+    line-height: 22.4px;
+    letter-spacing: -0.08px;
+  }
+
+  .furniture-card {
+    min-height: 0;
+    flex-direction: column;
+    gap: 24px;
+    padding: 24px 16px;
+  }
+
+.furniture-image-frame {
+    width: 145px;
+    height: 145px;
+    min-width: 145px;
+    flex-basis: 145px;
+    margin-right: 0;
+  }
+
+  .furniture-image-frame > img {
+    width: 145px;
+    height: 145px;
+  }
+
+  .furniture-card-copy {
+    display: flex;
+    align-items: center;
+    flex-direction: column;
+  }
+
+  .furniture-card-copy h2 {
+    font-size: 18px;
+    line-height: 23.76px;
+    letter-spacing: -0.09px;
+  }
+
+  .furniture-card-copy p {
+    margin-bottom: 24px;
+    font-size: 14px;
+    line-height: 18.62px;
+    letter-spacing: -0.07px;
+    text-align: center;
+  }
+
+  .furniture-faq {
+    padding-top: 48px;
+    padding-bottom: 48px;
+  }
+
+  .furniture-faq > h2,
+  .furniture-other-tasks h2 {
+    font-size: 23px;
+    line-height: 32.2px;
+  }
+
+  .furniture-faq-list {
+    width: 100%;
+    max-width: 375px;
+  }
+
+  .furniture-other-tasks {
+    padding: 32px 0;
+  }
+}
+
+.furniture-detail-breadcrumb {
+  padding-bottom: 0;
+  padding-top: 32px;
+}
+
+.furniture-detail-shell {
+  align-items: center;
+  display: grid;
+  gap: 56px;
+  grid-template-columns: minmax(260px, 420px) minmax(0, 1fr);
+  margin: 0 auto;
+  max-width: 1152px;
+  min-height: 560px;
+  padding: 56px 24px 88px;
+}
+
+.furniture-detail-shell img {
+  background: #f4f7f6;
+  border-radius: 16px;
+  height: auto;
+  max-width: 100%;
+  object-fit: cover;
+  width: 100%;
+}
+
+.furniture-detail-shell h1,
+.furniture-related-shell h1 {
+  color: #1a1e1d;
+  font-size: clamp(2rem, 4vw, 3.5rem);
+  line-height: 1.08;
+  margin: 8px 0 24px;
+}
+
+.furniture-detail-shell p {
+  color: #454947;
+  font-size: 18px;
+  line-height: 1.55;
+  margin: 0 0 18px;
+}
+
+.furniture-detail-eyebrow {
+  color: #0d7a5f !important;
+  font-size: 14px !important;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.furniture-detail-book {
+  display: inline-flex;
+  margin-top: 14px;
+}
+
+.furniture-related-shell {
+  margin: 0 auto;
+  max-width: 900px;
+  min-height: 420px;
+  padding: 72px 24px 104px;
+}
+
+.furniture-related-shell > p:not(.furniture-detail-eyebrow) {
+  color: #454947;
+  font-size: 18px;
+  line-height: 1.55;
+  max-width: 650px;
+}
+
+.furniture-related-actions {
+  align-items: center;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 24px;
+  margin-top: 32px;
+}
+
+.furniture-related-back {
+  color: #0d7a5f;
+  font-weight: 600;
+}
+
+@media (max-width: 767px) {
+  .furniture-detail-breadcrumb {
+    padding-top: 20px;
+  }
+
+  .furniture-detail-shell {
+    gap: 28px;
+    grid-template-columns: 1fr;
+    min-height: auto;
+    padding: 32px 16px 64px;
+  }
+
+  .furniture-detail-shell img {
+    margin: 0 auto;
+    max-width: 320px;
+  }
+
+  .furniture-related-shell {
+    padding: 48px 16px 72px;
+  }
+}

tasks/taskrabbit/solution/site/implementation/clone/static/home-fidelity.css

@@ -0,0 +1,1638 @@
+@font-face {
+  font-family: "Ivy Presto";
+  src: url("/static/assets/source-current/2026-07-25/home/ivy-presto-headline.otf") format("opentype");
+  font-display: swap;
+}
+
+body:has(.home-fidelity) {
+  background: #fff;
+  color: #242a30;
+}
+
+body:has(.home-fidelity) .site-header {
+  position: relative;
+  z-index: 61;
+}
+
+body:has(.home-fidelity) .site-header .header-inner {
+  width: 100%;
+  max-width: 1440px;
+  padding-right: 4%;
+  padding-left: 4%;
+}
+
+body:has(.home-fidelity) .site-header:not(.furniture-header) .main-nav {
+  height: 43px;
+  letter-spacing: -0.12px;
+}
+
+body:has(.home-fidelity) .site-header:not(.furniture-header) .main-nav > a {
+  display: inline-flex;
+  height: 36px;
+  align-items: center;
+  line-height: normal;
+}
+
+body:has(.home-fidelity) .site-header:not(.furniture-header) .main-nav .become-tasker {
+  width: 180px;
+  height: 43px;
+  padding: 12px 24px;
+  line-height: normal;
+  white-space: nowrap;
+}
+
+body:has(.home-fidelity) .site-footer {
+  position: relative;
+  z-index: 2;
+}
+
+.home-fidelity {
+  position: relative;
+  overflow: hidden;
+  background: #fff;
+  color: #242a30;
+}
+
+.home-shapes {
+  position: absolute;
+  z-index: 0;
+  inset: 0;
+  pointer-events: none;
+}
+
+.home-shape {
+  position: absolute;
+  max-width: none;
+}
+
+.home-shape.top-right { top: 0; right: 0; width: 445px; height: 262px; }
+.home-shape.top-left { top: 50px; left: 0; width: 145px; height: 462px; }
+.home-shape.middle-right-one { top: 1240px; right: 0; width: 77px; height: 314px; }
+.home-shape.middle-left { top: 2053px; left: 0; width: 136px; height: 386px; }
+.home-shape.middle-right-two { top: 3440px; right: 0; width: 144px; height: 446px; }
+.home-shape.bottom-right { top: 4646px; right: 0; width: 150px; height: 343px; }
+.home-shape.bottom-left { top: 4964px; left: 0; width: 161px; height: 182px; }
+
+/* The source capture paints the first middle ornament above the stats and
+   projects section backgrounds.  Its two bottom ornaments were present in
+   the DOM but did not paint in any of the three independent browser frames. */
+.home-shape.middle-right-one { z-index: 2; }
+.home-shape.bottom-right,
+.home-shape.bottom-left { display: none; }
+
+.home-intro,
+.home-stats,
+.popular-projects,
+.testimonial-band,
+.guarantee-band,
+.how-it-works,
+.get-help {
+  position: relative;
+  z-index: 1;
+}
+
+.home-title-block {
+  position: relative;
+  width: 1200px;
+  height: 450px;
+  margin: 0 auto;
+  padding-top: 112px;
+}
+
+.home-title-block h1 {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  margin: 0;
+  color: #2b4c32;
+  font-family: "Ivy Presto", "Inter", sans-serif;
+  font-size: 55px;
+  font-weight: 800;
+  line-height: 77px;
+}
+
+.home-ikea-badge {
+  object-fit: contain;
+}
+
+.intro-badge {
+  position: absolute;
+  top: 16px;
+  left: 32px;
+  width: 90px;
+  height: 90px;
+}
+
+.home-search {
+  display: flex;
+  width: 630px;
+  height: 64px;
+  margin: 56px auto 0;
+  overflow: hidden;
+  border: 1px solid #8a8d8c;
+  border-radius: 1000px;
+  background: #fff;
+}
+
+.home-search input {
+  min-width: 0;
+  flex: 1;
+  border: 0;
+  outline: 0;
+  padding: 4px 0 5px 24px;
+  background: transparent;
+  color: #242a30;
+  font: inherit;
+  font-size: 18px;
+}
+
+.home-search input::placeholder { color: #8a8d8c; opacity: 1; }
+
+.home-search button {
+  position: relative;
+  width: 88px;
+  border: 0;
+  border-radius: 0 1000px 1000px 0;
+  background: #0d7a5f;
+}
+
+.home-search button span,
+.home-search button span::after {
+  position: absolute;
+  display: block;
+  content: "";
+}
+
+.home-search button span {
+  top: 20px;
+  left: 32px;
+  width: 15px;
+  height: 15px;
+  border: 2px solid #fff;
+  border-radius: 50%;
+}
+
+.home-search button span::after {
+  right: -5px;
+  bottom: -4px;
+  width: 7px;
+  height: 2px;
+  background: #fff;
+  transform: rotate(45deg);
+}
+
+.home-category-panel {
+  width: 1200px;
+  height: 201px;
+  margin: 0 auto;
+  padding: 0 24px;
+}
+
+.home-category-panel .category-tabs {
+  display: grid;
+  grid-template-columns: repeat(8, 1fr);
+  gap: 0;
+  height: 101px;
+  margin: 0;
+  border-bottom: 1px solid #dce0e6;
+}
+
+.home-category-panel .category-tab {
+  display: flex;
+  height: 101px;
+  flex-direction: column;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 2px;
+  border: 0;
+  border-bottom: 2px solid transparent;
+  border-radius: 0;
+  padding: 1px 6px 7px;
+  background: transparent;
+  color: #242a30;
+  font-size: 14px;
+  font-weight: 700;
+  line-height: 19px;
+  text-decoration: none;
+}
+
+.home-category-panel .category-tab.active {
+  border-bottom-color: #066599;
+  color: #066599;
+}
+
+.category-symbol {
+  position: relative;
+  display: block;
+  width: 60px;
+  height: 52px;
+}
+
+.category-symbol-blob {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 60px;
+  height: 50px;
+}
+
+.category-symbol-icon {
+  position: absolute;
+  top: 9px;
+  left: 15px;
+  width: 32px;
+  height: 32px;
+}
+
+.home-category-panel .trending-list {
+  display: flex;
+  flex-wrap: nowrap;
+  gap: 24px;
+  margin: 24px 0 32px;
+  color: #242a30;
+  font-size: 16px;
+}
+
+.home-category-panel .trending-list li {
+  flex: 1;
+  border: 1px solid #8a8d8c;
+  border-radius: 1000px;
+  padding: 0;
+  overflow: hidden;
+  text-align: center;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.home-category-panel .trending-list a {
+  display: block;
+  padding: 9px 17px;
+  overflow: hidden;
+  color: inherit;
+  text-decoration: none;
+  text-overflow: ellipsis;
+}
+
+.home-category-panel .trending-list a:hover,
+.home-category-panel .trending-list a:focus-visible {
+  background: #f1f8f4;
+  color: #075f49;
+  outline: none;
+}
+
+.home-category-panel [data-home-category-panel][hidden],
+.home-family-showcase[hidden] {
+  display: none !important;
+}
+
+.assembly-showcase {
+  position: relative;
+  width: 1200px;
+  height: 574px;
+  margin: 0 auto;
+  border-radius: 16px;
+  background: rgba(186, 231, 255, .5);
+  overflow: hidden;
+}
+
+.assembly-photo {
+  position: absolute;
+  top: 40px;
+  left: 165px;
+  width: 950px;
+  height: 491px;
+  border-radius: 8px;
+  object-fit: cover;
+}
+
+.assembly-card {
+  position: absolute;
+  z-index: 2;
+  top: 104px;
+  left: 40px;
+  width: 384px;
+  min-height: 366px;
+  border-radius: 8px;
+  padding: 64px 40px 40px;
+  background: #fff;
+}
+
+.assembly-card h2 {
+  margin: 0 0 30px;
+  color: #0a2b14;
+  font-size: 24px;
+  line-height: 32px;
+}
+
+.assembly-card p {
+  display: grid;
+  grid-template-columns: 8px 1fr;
+  gap: 24px;
+  margin: 0 0 28px;
+  font-size: 18px;
+  line-height: 24.66px;
+  letter-spacing: -.09px;
+}
+
+.assembly-card p span { font-size: 9px; padding-top: 4px; }
+
+.home-stats {
+  height: 188px;
+  background: linear-gradient(
+    to bottom,
+    #fff 0%,
+    #fbfdfc 5.3%,
+    #f8fcf9 13.4%,
+    #f5fbf7 26.7%,
+    #f3faf5 40.1%,
+    #f1f9f3 53.5%,
+    #f0f9f2 66.8%,
+    #eef8f0 80.2%,
+    #edf7f0 93.6%,
+    #ecf7ef 100%
+  );
+}
+
+.home-stats-inner {
+  display: grid;
+  width: 1200px;
+  height: 188px;
+  grid-template-columns: 179px 179px 179px 179px 179px 130px;
+  gap: 8px;
+  align-items: center;
+  margin: 0 auto;
+  padding: 0 24px 0 64px;
+}
+
+.home-stats-inner > div {
+  display: flex;
+  height: 82px;
+  flex-direction: column;
+  justify-content: center;
+}
+
+.home-stats-inner span {
+  color: #0a2b14;
+  font-size: 18px;
+  font-weight: 600;
+  line-height: 25.2px;
+  letter-spacing: -.09px;
+}
+
+.home-stats-inner strong {
+  color: #0d7a5f;
+  font-size: 24px;
+  font-weight: 600;
+  line-height: 31.68px;
+  letter-spacing: -.12px;
+}
+
+.stats-badge {
+  width: 130px;
+  height: 86px;
+}
+
+.popular-projects {
+  width: 1200px;
+  height: 1122px;
+  margin: 0 auto;
+  padding: 88px 24px;
+}
+
+.popular-projects h2,
+.testimonial-band h2,
+.get-help h2 {
+  margin: 0 0 30px;
+  color: #0a2b14;
+  font-size: 30px;
+  font-weight: 700;
+  line-height: 42px;
+}
+
+.popular-projects .project-grid {
+  display: grid;
+  grid-template-columns: repeat(4, 240px);
+  grid-auto-rows: 273px;
+  gap: 32px 48px;
+  padding-left: 40px;
+}
+
+.popular-projects .project-card {
+  display: flex;
+  height: 250px;
+  flex-direction: column;
+  border: 0;
+  border-radius: 16px;
+  background: #f5f7f7;
+  box-shadow: 0 2px 8px rgba(20, 31, 27, .16);
+  overflow: hidden;
+  text-align: center;
+}
+
+.popular-projects .project-card a { color: inherit; text-decoration: none; }
+
+.popular-projects .project-card img,
+.source-missing-project-image {
+  display: block;
+  width: 240px;
+  height: 163px;
+  background: #f5f7f7;
+  object-fit: cover;
+}
+
+.source-unloaded-project-image {
+  visibility: hidden;
+}
+
+.popular-projects .project-card h3,
+.popular-projects .project-card h4 {
+  margin: 16px 16px 0;
+  overflow: hidden;
+  color: #0a2b14;
+  font-size: 16px;
+  font-weight: 600;
+  letter-spacing: -.12px;
+  line-height: 25.6px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.popular-projects .project-card p {
+  margin: 8px 16px 0;
+  color: #0a2b14;
+  font-size: 14px;
+  letter-spacing: -.07px;
+  line-height: 20.16px;
+}
+
+.testimonial-band {
+  height: 841px;
+  background: #fff;
+}
+
+.testimonial-inner {
+  width: 1136px;
+  margin: 0 auto;
+  padding: 80px 0;
+}
+
+.testimonial-band h2 {
+  margin-bottom: 48px;
+  color: #2b4c32;
+}
+
+.testimonial-band .reviews-grid {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  grid-auto-rows: 236px;
+  gap: 48px 56px;
+}
+
+.testimonial-band blockquote {
+  margin: 0;
+  border: 0;
+  padding: 0;
+  color: #0a2b14;
+}
+
+.testimonial-band blockquote header {
+  display: flex;
+  align-items: center;
+  height: 30px;
+  gap: 0;
+  margin-bottom: 17px;
+  font-size: 20px;
+  line-height: 26.4px;
+}
+
+.testimonial-band blockquote header strong {
+  padding-right: 9.6px;
+  font-weight: 600;
+  letter-spacing: -.3px;
+}
+
+.testimonial-band .review-stars {
+  display: inline-flex;
+  align-items: flex-start;
+  width: 144px;
+  height: 30px;
+  gap: 6px;
+  color: #fdbb30;
+  font-size: 0;
+  letter-spacing: 0;
+  line-height: 0;
+}
+
+.testimonial-band .review-stars svg {
+  flex: 0 0 24px;
+}
+
+.testimonial-band blockquote p {
+  display: -webkit-box;
+  width: 313px;
+  margin: 0 0 16px;
+  overflow: hidden;
+  font-size: 18px;
+  letter-spacing: -.09px;
+  line-height: 24.66px;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: 6;
+}
+
+.testimonial-band blockquote cite {
+  color: #007a5e;
+  font-size: 18px;
+  font-style: normal;
+  font-weight: 600;
+  letter-spacing: -.09px;
+  line-height: 25.2px;
+}
+
+.guarantee-band {
+  height: 459px;
+  padding: 16px 0;
+  background: #fbfdfc;
+}
+
+.guarantee-inner {
+  width: 1440px;
+  height: 427px;
+  margin: 0 auto;
+  padding: 80px 152px;
+}
+
+.guarantee-band h2 {
+  margin: 0 0 48px;
+  color: #2b4c32;
+  font-size: 34px;
+  font-weight: 800;
+  line-height: 47.6px;
+}
+
+.guarantee-band h2 em {
+  color: #625be7;
+  font-style: normal;
+}
+
+.guarantee-band .guarantee-grid {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: 80px;
+}
+
+.guarantee-grid > div {
+  display: flex;
+  min-height: 171px;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.guarantee-grid img {
+  width: 150px;
+  height: 28px;
+}
+
+/* The logo request did not produce painted pixels in the frozen source
+   frames; retain its semantic image in the DOM without inventing pixels. */
+.guarantee-grid img { visibility: hidden; }
+
+.guarantee-grid h3 {
+  margin: 0;
+  color: #0a2b14;
+  font-size: 24px;
+  font-weight: 600;
+  letter-spacing: -.12px;
+  line-height: 31.68px;
+}
+
+.guarantee-grid p {
+  margin: 0;
+  color: #1a1e1d;
+  font-size: 18px;
+  letter-spacing: -.09px;
+  line-height: 24.66px;
+}
+
+.how-it-works {
+  height: 670px;
+  background: #fffce4;
+}
+
+.how-inner {
+  position: relative;
+  width: 1136px;
+  height: 510px;
+  margin: 0 auto;
+  padding-top: 80px;
+}
+
+.how-media {
+  position: absolute;
+  top: 80px;
+  left: 80px;
+  width: 1056px;
+  height: 510px;
+  max-width: none;
+  border-radius: 0;
+  object-fit: cover;
+}
+
+.how-card {
+  position: absolute;
+  z-index: 2;
+  top: 108px;
+  left: 0;
+  width: 393px;
+  height: 450px;
+  border-radius: 24px;
+  padding: 24px;
+  background: #fff;
+}
+
+.how-card h2 {
+  margin: 0 0 40px;
+  padding-top: 41px;
+  color: #0a2b14;
+  font-size: 24px;
+  letter-spacing: -.12px;
+  line-height: 31.68px;
+}
+
+.how-card .three-step {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 40px;
+  margin: 0;
+}
+
+.how-card .three-step li {
+  display: grid;
+  grid-template-columns: 56px 1fr;
+  gap: 24px;
+  align-items: center;
+}
+
+.how-card .step-number {
+  width: 56px;
+  height: 56px;
+  background: #d7d4ff;
+  color: #0a2b14;
+  font-size: 24px;
+  font-weight: 700;
+  letter-spacing: -.12px;
+  line-height: 31.68px;
+}
+
+.how-card li:nth-child(2) .step-number { background: #fff9df; }
+.how-card li:nth-child(3) .step-number { background: #dcfaec; }
+.how-card p {
+  margin: 0;
+  color: #0a2b14;
+  font-size: 18px;
+  letter-spacing: -.09px;
+  line-height: 24.66px;
+}
+
+.get-help {
+  width: 1200px;
+  height: 517px;
+  margin: 0 auto;
+  padding: 88px 24px;
+}
+
+.get-help h2 { margin-bottom: 48px; color: #2b4c32; }
+
+.get-help-grid {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 24px;
+  margin-bottom: 48px;
+}
+
+.get-help-grid a {
+  display: inline-flex;
+  height: 43px;
+  align-items: center;
+  border: 1px solid #8a8d8c;
+  border-radius: 1000px;
+  padding: 12px 24px;
+  color: #1a1e1d;
+  font-size: 16px;
+  font-weight: 600;
+  letter-spacing: -.12px;
+  line-height: normal;
+  text-decoration: none;
+}
+
+.see-all-services {
+  display: inline-flex;
+  height: 26px;
+  align-items: center;
+  color: #007a5e;
+  font-size: 16px;
+  font-weight: 600;
+  text-decoration: none;
+}
+
+.see-all-services span { margin-left: 8px; color: #242a30; font-size: 30px; vertical-align: -3px; }
+
+.home-shape.bottom-left {
+  width: 160px;
+  height: 181px;
+}
+
+.promotion-modal {
+  position: fixed;
+  z-index: 70;
+  inset: 0;
+  display: grid;
+  place-items: center;
+  padding: 0;
+}
+
+.promotion-backdrop {
+  position: absolute;
+  inset: 0;
+  background: transparent;
+}
+
+.promotion-card {
+  position: relative;
+  z-index: 1;
+  display: grid;
+  width: min(75vw, 1080px);
+  height: auto;
+  aspect-ratio: 730 / 455;
+  grid-template-columns: 1fr 1fr;
+  border: max(2px, .21vw) solid #0d7a5f;
+  border-radius: 0;
+  background: #fff;
+  box-shadow: none;
+  overflow: hidden;
+}
+
+.promotion-card picture {
+  min-width: 0;
+  height: 100%;
+  overflow: hidden;
+}
+
+.promotion-card picture img {
+  display: block;
+  width: 100%;
+  height: 100%;
+  max-width: none;
+  object-fit: cover;
+}
+
+.promotion-copy {
+  display: flex;
+  align-self: stretch;
+  flex-direction: column;
+  align-items: center;
+  justify-content: flex-start;
+  padding: clamp(17px, 1.7vw, 24px) clamp(25px, 3.6vw, 52px) 10px;
+  color: #000;
+  text-align: center;
+  transform: translateX(clamp(-61px, -4.24vw, -43px));
+}
+
+.promotion-copy h2 {
+  margin: 0 0 clamp(23px, 2.3vw, 33px);
+  color: #000;
+  font-family: Arial, Helvetica, sans-serif;
+  font-size: clamp(29px, 2.88vw, 41px);
+  font-weight: 900;
+  line-height: 1.08;
+  text-transform: uppercase;
+}
+
+.promotion-title-wide,
+.promotion-title-mobile,
+.promotion-body-wide,
+.promotion-body-mobile {
+  display: block;
+}
+
+.promotion-title-mobile,
+.promotion-body-mobile {
+  display: none;
+}
+
+.promotion-copy > p {
+  margin: 0 0 clamp(38px, 3.8vw, 55px);
+  color: #000;
+  font-family: Arial, Helvetica, sans-serif;
+  font-size: clamp(16px, 1.64vw, 23px);
+  font-weight: 700;
+  line-height: 1.17;
+}
+
+.promotion-copy form {
+  display: grid;
+  justify-items: center;
+  gap: clamp(29px, 2.9vw, 42px);
+}
+
+.promotion-copy input {
+  width: min(25.7vw, 370px);
+  height: min(5.14vw, 74px);
+  border: 2px solid #202020;
+  border-radius: 8px;
+  background: #fffbe5;
+  color: #000;
+  font-size: clamp(16px, 1.6vw, 23px);
+  text-align: center;
+}
+
+.promotion-copy .btn-primary {
+  width: min(25.7vw, 370px);
+  height: min(4.65vw, 67px);
+  margin: 0;
+  border: 2px solid #111;
+  border-radius: 6px;
+  padding: 0;
+  background: #118468;
+  font-size: clamp(17px, 1.7vw, 24px);
+  font-weight: 400;
+}
+
+.promotion-copy small {
+  display: block;
+  margin-top: clamp(31px, 3.1vw, 45px);
+  color: #000;
+  font-family: Arial, Helvetica, sans-serif;
+  font-size: clamp(7px, .7vw, 10px);
+  line-height: 1.08;
+}
+
+.promotion-close {
+  position: absolute;
+  z-index: 2;
+  top: clamp(13px, 1.3vw, 19px);
+  right: clamp(14px, 1.4vw, 20px);
+  display: grid;
+  width: clamp(11px, 1.1vw, 16px);
+  height: clamp(11px, 1.1vw, 16px);
+  place-items: center;
+  background: transparent;
+}
+
+.promotion-close img { display: block; width: 100%; height: 100%; }
+
+body:has(.promotion-modal) .help-trigger { display: none; }
+
+body:has(.promotion-modal) .how-media {
+  visibility: hidden;
+}
+
+body:has(.home-fidelity) .site-footer {
+  min-height: 387px;
+  padding: 24px 0;
+  background: #67727e;
+}
+
+body:has(.home-fidelity) .site-footer .footer-main {
+  display: grid;
+  width: 1200px;
+  max-width: none;
+  min-height: 339px;
+  grid-template-columns: 373px 373px 373px;
+  gap: 16px;
+  margin: 0 auto;
+  padding: 42px 24px 0;
+}
+
+body:has(.home-fidelity) .site-footer .footer-main > .footer-col:first-child {
+  position: absolute;
+  width: 1152px;
+  margin-top: -42px;
+}
+
+body:has(.home-fidelity) .site-footer .footer-main > :nth-child(2) { grid-column: 1; }
+body:has(.home-fidelity) .site-footer .footer-main > :nth-child(3) { grid-column: 2; }
+body:has(.home-fidelity) .site-footer .footer-main > :nth-child(4) { grid-column: 3; }
+
+body:has(.home-fidelity) .site-footer .footer-col h3 {
+  margin: 0 0 10px;
+  color: #b1b9c3;
+  font-size: 18px;
+  font-weight: 400;
+  line-height: 24.66px;
+}
+
+body:has(.home-fidelity) .site-footer .footer-main > :not(:first-child) h3 {
+  margin-bottom: 8px;
+}
+
+body:has(.home-fidelity) .site-footer .footer-col a,
+body:has(.home-fidelity) .site-footer .footer-col span {
+  margin: 0;
+  color: #fff;
+  font-size: 16px;
+  font-weight: 600;
+  line-height: 24px;
+}
+
+body:has(.home-fidelity) .site-footer .footer-col p {
+  margin: 0;
+  color: #fff;
+  font-size: 18px;
+  line-height: 24.66px;
+  letter-spacing: -.09px;
+}
+
+body:has(.home-fidelity) .site-footer .footer-social {
+  position: absolute;
+  top: 0;
+  left: 225px;
+  gap: 17px;
+}
+
+body:has(.home-fidelity) .site-footer .footer-social img {
+  width: 24px;
+  height: 24px;
+  opacity: 0;
+}
+
+body:has(.home-fidelity) .site-footer .footer-social {
+  background:
+    repeating-linear-gradient(
+      90deg,
+      transparent 0 32px,
+      #b1b9c3 32px 33px,
+      transparent 33px 41px
+    );
+}
+
+body:has(.home-fidelity) .site-footer .footer-badges {
+  display: grid;
+  visibility: hidden;
+  gap: 6px;
+  margin-top: 16px;
+}
+
+body:has(.home-fidelity) .site-footer .footer-badges img {
+  width: 175px;
+  height: 58px;
+}
+
+body:has(.home-fidelity) .site-footer .footer-main > :nth-child(2) > :not(h3) {
+  transform: translateY(-1px);
+}
+
+body:has(.home-fidelity) .site-footer .footer-main > :nth-child(3) > span:nth-of-type(-n + 7) {
+  transform: translateY(-1px);
+}
+
+body:has(.home-fidelity) .site-footer .footer-main > :nth-child(3) > span:nth-of-type(7) {
+  margin-top: 8px;
+  margin-bottom: 8px;
+}
+
+body:has(.home-fidelity) .site-footer .footer-main > :nth-child(3) > span:nth-of-type(3) {
+  height: 24px;
+  font-size: 0;
+  line-height: 24px;
+}
+
+body:has(.home-fidelity) .site-footer .footer-main > :nth-child(3) > span:nth-of-type(3)::before {
+  content: "Partner with Taskrabbit";
+  font-size: 16px;
+}
+
+body:has(.home-fidelity) .site-footer .footer-main > :nth-child(4) {
+  transform: translateX(1px);
+}
+
+body:has(.home-fidelity) .site-footer .footer-main > :nth-child(4) > p {
+  transform: translateY(-9px);
+}
+
+@media (min-width: 900px) {
+  .promotion-card {
+    width: 730px;
+    height: 455px;
+    aspect-ratio: auto;
+    border-width: 2px;
+  }
+
+  .promotion-copy {
+    padding: 12px 35px 7px;
+    transform: translateX(-41px);
+  }
+
+  .promotion-copy h2 {
+    margin-bottom: 30px;
+    font-size: 28px;
+    line-height: 1.08;
+    transform: translate(12px, -.5px) scale(1.07, 1.09);
+    transform-origin: top center;
+  }
+
+  .promotion-copy > p {
+    margin-bottom: 35px;
+    font-size: 16px;
+    line-height: 18px;
+    transform: translateX(2px);
+  }
+
+  .promotion-copy form {
+    gap: 28px;
+  }
+
+  .promotion-copy input {
+    width: 250px;
+    height: 50px;
+    border-width: 2px;
+    border-radius: 5px;
+    font-size: 16px;
+    transform: translate(-1px, 1px) scaleY(1.02);
+  }
+
+  .promotion-copy .btn-primary {
+    width: 250px;
+    height: 45px;
+    border-width: 1px;
+    border-radius: 4px;
+    font-size: 16px;
+    transform: translateY(1px);
+  }
+
+  .promotion-copy small {
+    margin-top: 30px;
+    font-size: 9px;
+    line-height: 1.06;
+    transform: translate(-1px, 1px);
+  }
+
+  .promotion-close {
+    top: 13px;
+    right: 14px;
+    width: 36px;
+    height: 36px;
+  }
+
+  .promotion-close img {
+    width: 10px;
+    height: 10px;
+  }
+
+  .promotion-card picture img {
+    width: calc(100% - 18px);
+    margin-left: 8px;
+  }
+}
+
+@media (min-width: 1200px) {
+  .promotion-card {
+    transform: scale(1.4794520547945205);
+  }
+
+  body:has(.home-fidelity) .site-header .header-inner {
+    padding-right: 152px;
+    padding-left: 152px;
+  }
+
+  .assembly-showcase {
+    background: transparent;
+  }
+
+  .assembly-showcase::before {
+    position: absolute;
+    inset: 0 44px;
+    border-radius: 16px;
+    background: rgba(186, 231, 255, .5);
+    content: "";
+  }
+
+  .assembly-card {
+    left: 85px;
+  }
+}
+
+@media (min-width: 900px) and (max-width: 1199px) {
+  body:has(.home-fidelity) .site-header:not(.furniture-header) .brand svg {
+    transform: translateY(-1px);
+  }
+
+  body:has(.home-fidelity) .site-header:not(.furniture-header) .main-nav {
+    transform: translateX(-0.32px);
+  }
+
+  .promotion-card {
+    transform: scale(1.052054794520548);
+  }
+
+  .home-shapes {
+    display: none;
+  }
+
+  .home-title-block,
+  .home-category-panel,
+  .assembly-showcase,
+  .home-stats-inner,
+  .popular-projects,
+  .get-help,
+  body:has(.home-fidelity) .site-footer .footer-main {
+    width: 100%;
+  }
+
+  .home-title-block { height: 517px; }
+  .home-category-panel { padding-right: 36px; padding-left: 36px; }
+  body:has(.home-fidelity) .home-fidelity .home-category-panel .category-tabs {
+    min-height: 0;
+    grid-template-columns: repeat(8, 1fr);
+    gap: 0;
+    padding-bottom: 0;
+    transform: translateY(-67px);
+  }
+  body:has(.home-fidelity) .home-fidelity .home-category-panel .category-tab {
+    padding: 1px 6px 7px;
+    background: transparent;
+    font-weight: 700;
+  }
+  body:has(.home-fidelity) .home-fidelity .home-category-panel .trending-list {
+    display: grid;
+    min-height: 112px;
+    grid-template-columns: repeat(auto-fit, minmax(142px, 1fr));
+    gap: 12px;
+    font-weight: 600;
+    transform: translateY(-66px);
+  }
+  body:has(.home-fidelity) .home-fidelity .home-category-panel .trending-list li {
+    width: auto !important;
+    border-color: #595c5b;
+    padding: 0;
+    overflow: visible;
+    text-overflow: clip;
+  }
+  body:has(.home-fidelity) .home-fidelity .home-category-panel .trending-list li:nth-child(1) { width: 262px; }
+  body:has(.home-fidelity) .home-fidelity .home-category-panel .trending-list li:nth-child(2) { width: 166px; }
+  body:has(.home-fidelity) .home-fidelity .home-category-panel .trending-list li:nth-child(3) { width: 162px; }
+  body:has(.home-fidelity) .home-fidelity .home-category-panel .trending-list li:nth-child(4) { width: 206px; }
+  body:has(.home-fidelity) .home-fidelity .home-category-panel .trending-list li:nth-child(5) { width: 168px; }
+  .assembly-showcase { border-radius: 16px; }
+  .assembly-photo { left: 120px; width: calc(100% - 160px); }
+  .assembly-card { left: 40px; }
+
+  .home-stats-inner {
+    grid-template-columns: repeat(5, 153.5px) 86px;
+    padding-right: 40px;
+    padding-left: 40px;
+    transform: translateY(-1px);
+  }
+
+  .home-stats-inner > div {
+    justify-content: flex-start;
+    transform: translateY(-1px);
+  }
+  .home-stats-inner > div:nth-child(4),
+  .home-stats-inner > div:nth-child(5) { transform: translate(-1px, -1px); }
+
+  .home-stats-inner span { font-size: 18px; }
+  .home-stats-inner strong { font-size: 24px; }
+  .stats-badge {
+    width: 86px;
+    height: 86px;
+    margin-left: 21.5px;
+    transform: translateY(1px);
+  }
+
+  .popular-projects {
+    height: 1080px;
+    padding-right: 24px;
+    padding-left: 24px;
+  }
+
+  .popular-projects .project-grid {
+    grid-template-columns: repeat(3, 240px);
+    grid-auto-rows: 249px;
+    gap: 32px 80px;
+    justify-content: start;
+    padding-left: 40px;
+  }
+
+  .testimonial-band { height: 1119px; }
+  .testimonial-inner {
+    width: 100%;
+    padding: 74px 16px 80px;
+  }
+  .testimonial-band h2 { margin-bottom: 66px; }
+  .testimonial-band blockquote header { margin-bottom: 15px; }
+  .testimonial-band .reviews-grid {
+    grid-template-columns: repeat(2, 305px);
+    grid-auto-rows: 236px;
+    gap: 48px 56px;
+  }
+
+  .guarantee-band { height: 531px; }
+  .guarantee-inner {
+    width: 100%;
+    height: 499px;
+    padding: 64px 16px 80px;
+  }
+  .guarantee-band .guarantee-grid {
+    grid-template-columns: 448px 464px;
+    gap: 56px 80px;
+  }
+  .guarantee-grid > div { min-height: 0; }
+  .guarantee-grid > div:first-child img { height: 31px; }
+
+  .how-it-works { height: 670px; }
+  .how-inner { width: 100%; padding-right: 16px; padding-left: 16px; }
+  .how-media { left: 16px; width: calc(100% - 32px); }
+  .how-card { left: 16px; }
+  .how-card h2 {
+    margin-bottom: 37px;
+    padding-top: 40px;
+  }
+
+  .get-help { height: 516px; padding-right: 24px; padding-left: 24px; }
+
+  body:has(.home-fidelity) .site-footer .footer-main {
+    grid-template-columns: repeat(3, 1fr);
+    padding-right: 24px;
+    padding-left: 24px;
+  }
+
+  body:has(.home-fidelity) .site-footer {
+    min-height: 388px;
+  }
+
+  body:has(.home-fidelity) .site-footer .footer-badges {
+    display: none;
+  }
+}
+
+@media (max-width: 899px) {
+  body:has(.home-fidelity) .site-header .header-inner {
+    width: 100%;
+    padding-right: 16px;
+    padding-left: 16px;
+  }
+
+  .home-shapes { display: none; }
+  .category-symbol-icon {
+    top: 12px;
+    left: 19px;
+    width: 24px;
+    height: 24px;
+  }
+  .home-title-block {
+    width: 100%;
+    height: 420px;
+    padding: 105px 16px 0;
+  }
+  .home-title-block h1 {
+    align-items: flex-start;
+    font-size: 40px;
+    line-height: 56px;
+  }
+  .intro-badge { top: 16px; left: 16px; width: 64px; height: 64px; }
+  .home-search { width: 100%; margin-top: 24px; }
+
+  .home-category-panel {
+    width: 100%;
+    height: 201px;
+    padding: 0 16px;
+    overflow-x: auto;
+    overflow-y: hidden;
+    overscroll-behavior-inline: contain;
+    scroll-snap-type: x proximity;
+    scrollbar-width: none;
+  }
+  .home-category-panel::-webkit-scrollbar { display: none; }
+  .home-category-panel .category-tabs {
+    width: 768px;
+    grid-template-columns: repeat(8, 96px);
+    transform: translateX(0);
+  }
+  .home-category-panel .category-tab { scroll-snap-align: start; }
+  .home-category-panel .trending-list {
+    width: max-content;
+  }
+
+  .assembly-showcase {
+    width: 100%;
+    height: 574px;
+    border-radius: 0;
+    overflow: visible;
+  }
+  .assembly-photo {
+    top: 130px;
+    left: 0;
+    width: 100%;
+    height: auto;
+    border-radius: 8px;
+    clip-path: inset(0 16px 0 0 round 8px);
+  }
+  .assembly-card {
+    top: -98px;
+    left: 16px;
+    width: calc(100% - 32px);
+    min-height: 340px;
+    padding: 24px 0;
+    background: transparent;
+  }
+
+  .home-stats,
+  .popular-projects,
+  .testimonial-band,
+  .guarantee-band,
+  .how-it-works,
+  .get-help,
+  body:has(.home-fidelity) .site-footer {
+    height: auto;
+  }
+}
+
+@media (max-width: 640px) {
+  body:has(.promotion-modal) {
+    position: fixed;
+    inset: 0;
+    width: 100%;
+    height: 100vh;
+    overflow: hidden;
+  }
+
+  .home-title-block .home-search {
+    width: calc(100% + 16px);
+    height: 56px;
+    margin-top: 12px;
+    margin-left: -8px;
+  }
+
+  .home-category-panel {
+    transform: translateY(-100px);
+  }
+
+  .category-symbol { height: 46px; }
+
+  .promotion-card {
+    width: 272px;
+    height: 526px;
+    aspect-ratio: auto;
+    grid-template-columns: 1fr;
+    grid-template-rows: 210px 1fr;
+    border-width: 1px;
+    padding: 1px;
+    box-shadow:
+      0 0 0 1px rgba(13, 122, 95, .25),
+      inset 0 0 0 1px rgba(13, 122, 95, .38);
+  }
+
+  .promotion-card picture {
+    height: 210px;
+  }
+
+  .promotion-card picture img {
+    width: 268px;
+    height: 212px;
+    object-fit: cover;
+    object-position: center top;
+  }
+
+  .promotion-copy {
+    padding: 8px 18px 10px;
+    transform: translateX(8px);
+  }
+
+  .promotion-copy h2 {
+    margin-bottom: 10px;
+    font-size: 13px;
+    line-height: 1.05;
+  }
+
+  .promotion-title-wide {
+    display: none;
+  }
+
+  .promotion-title-mobile {
+    display: block;
+    transform: translateX(.625px) scaleX(.95);
+  }
+
+  .promotion-body-wide {
+    display: none;
+  }
+
+  .promotion-body-mobile {
+    display: block;
+    transform: translateX(-.25px) scaleX(.91);
+  }
+
+  .promotion-copy > p {
+    margin-bottom: 12px;
+    font-size: 11px;
+    line-height: 1.05;
+  }
+
+  .promotion-copy form {
+    gap: 10px;
+    transform: translate(-1.375px, .375px);
+  }
+
+  .promotion-copy input {
+    width: 99px;
+    height: 27px;
+    border-width: 1px;
+    border-radius: 4px;
+    padding: 2px;
+    background: #fffce4;
+    font-size: 10px;
+  }
+
+  .promotion-copy .btn-primary {
+    width: 113px;
+    height: 24px;
+    border-width: 1px;
+    border-radius: 3px;
+    background: #0d7a5f;
+    font-size: 9px;
+    transform: scale(1.00885, 1.041667);
+    transform-origin: top left;
+  }
+
+  .promotion-copy small {
+    margin-top: 14px;
+    font-size: 6px;
+    transform: translate(-.625px, -.375px);
+  }
+
+  .promotion-copy small .promotion-desktop-break {
+    display: initial;
+  }
+
+  .promotion-close {
+    top: 13px;
+    right: 13px;
+    width: 8px;
+    height: 8px;
+  }
+
+  .promotion-desktop-break { display: none; }
+
+  .assembly-showcase {
+    background: #fff;
+  }
+
+  .assembly-card h2 {
+    visibility: hidden;
+  }
+
+  .assembly-card p {
+    grid-template-columns: 8px 1fr;
+    gap: 17px;
+    margin-bottom: 14px;
+  }
+
+  body:has(.home-fidelity) .site-footer .footer-main {
+    position: static;
+    display: grid;
+    width: 100%;
+    min-height: 0;
+    grid-template-columns: 1fr;
+    padding: 24px 16px;
+  }
+
+  body:has(.home-fidelity) .site-footer .footer-main > .footer-col:first-child {
+    position: static;
+    width: auto;
+    margin: 0;
+  }
+
+  body:has(.home-fidelity) .site-footer .footer-main > :nth-child(n) { grid-column: 1; }
+  body:has(.home-fidelity) .site-footer .footer-social { position: static; }
+}
+
+/*
+ * The shared stylesheet contains a historical promotion-page reconstruction
+ * keyed only on `body:has(.promotion-modal)`.  The source-faithful home owns
+ * its layout, so explicitly reset every inherited positioning/layout property
+ * rather than clipping the resulting overflow.
+ */
+body:has(.home-fidelity) .home-fidelity .home-category-panel .category-tabs {
+  position: static;
+  top: auto;
+  left: auto;
+  width: auto;
+  padding: 0;
+}
+
+body:has(.home-fidelity) .home-fidelity .home-category-panel .trending-list {
+  position: static;
+  top: auto;
+  left: auto;
+  width: auto;
+}
+
+body:has(.home-fidelity) .home-fidelity .popular-projects {
+  order: initial;
+  width: 1200px;
+  min-height: 0;
+  padding-top: 88px;
+  padding-bottom: 72px;
+}
+
+body:has(.home-fidelity) .home-fidelity .popular-projects .project-grid {
+  grid-template-columns: repeat(4, 240px);
+  gap: 32px 48px;
+}
+
+body:has(.home-fidelity) .home-fidelity .popular-projects .project-card {
+  height: 249px;
+}
+
+body:has(.home-fidelity) .home-fidelity .testimonial-band {
+  order: initial;
+  width: 100%;
+  min-height: 0;
+}
+
+body:has(.home-fidelity) .home-fidelity .testimonial-band h2 {
+  margin-bottom: 64px;
+}
+
+body:has(.home-fidelity) .home-fidelity .testimonial-band .reviews-grid {
+  grid-template-columns: repeat(3, 313px);
+  gap: 48px;
+}
+
+body:has(.home-fidelity) .home-fidelity .guarantee-band {
+  order: initial;
+  width: 100%;
+  max-width: none;
+  margin-top: 72px;
+  padding: 16px 0;
+}
+
+body:has(.home-fidelity) .home-fidelity .how-it-works {
+  order: initial;
+  width: 100%;
+  max-width: none;
+  min-height: 0;
+  padding: 0;
+  background: #fffce4;
+}
+
+body:has(.home-fidelity) .home-fidelity .how-it-works .how-media {
+  display: block;
+}
+
+body:has(.home-fidelity) .home-fidelity .how-it-works .three-step {
+  width: auto;
+  padding: 0;
+}
+
+@media (min-width: 900px) and (max-width: 1199px) {
+  body:has(.home-fidelity) .home-fidelity .popular-projects {
+    width: 100%;
+  }
+
+  body:has(.home-fidelity) .home-fidelity .popular-projects .project-grid {
+    grid-template-columns: repeat(3, 240px);
+    grid-auto-rows: 249px;
+    gap: 32px 80px;
+  }
+
+  body:has(.home-fidelity) .home-fidelity .testimonial-band .reviews-grid {
+    grid-template-columns: repeat(2, 305px);
+    grid-auto-rows: 236px;
+    gap: 48px 56px;
+  }
+
+  body:has(.home-fidelity) .home-fidelity .testimonial-band blockquote header strong {
+    transform: translateY(2px);
+  }
+
+  body:has(.home-fidelity) .home-fidelity .testimonial-band blockquote p,
+  body:has(.home-fidelity) .home-fidelity .testimonial-band blockquote cite {
+    position: relative;
+    top: 1px;
+  }
+
+  body:has(.home-fidelity) .home-fidelity .how-it-works .how-media {
+    display: none;
+  }
+
+  body:has(.home-fidelity) .site-footer .footer-main > .footer-col:first-child {
+    width: calc(100% - 48px);
+    transform: translateX(-1px);
+  }
+
+  body:has(.home-fidelity) .site-footer .footer-main > :nth-child(2),
+  body:has(.home-fidelity) .site-footer .footer-main > :nth-child(3) {
+    transform: translateY(1px);
+  }
+
+  body:has(.home-fidelity) .site-footer .footer-main > :nth-child(4) {
+    transform: translateY(1px);
+  }
+}
+
+@media (max-width: 899px) {
+  body:has(.home-fidelity) .home-fidelity .popular-projects {
+    width: 100%;
+  }
+}