diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 00000000..7603e418
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,12 @@
+.git
+.venv
+__pycache__
+*.pyc
+.pytest_cache
+backend/.venv
+backend/data
+frontend/node_modules
+frontend/.next
+frontend/out
+frontend/test-results
+docs
diff --git a/.env.example b/.env.example
new file mode 100644
index 00000000..9b229f34
--- /dev/null
+++ b/.env.example
@@ -0,0 +1 @@
+OPENROUTER_API_KEY=
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 00000000..7755d4bf
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,108 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  backend:
+    name: Backend tests
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: backend
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "latest"
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: uv sync --locked
+
+      - name: Run pytest
+        # OPENROUTER_API_KEY is intentionally not set here: the handful of
+        # tests that make a real OpenRouter call skip themselves without it
+        # (see backend/tests/test_ai.py, test_chat.py).
+        run: uv run pytest
+
+  frontend:
+    name: Frontend unit tests
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: frontend
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: "npm"
+          cache-dependency-path: frontend/package-lock.json
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Lint
+        run: npm run lint
+
+      - name: Unit tests
+        run: npm run test:unit
+
+  e2e:
+    name: Frontend e2e tests (Playwright)
+    runs-on: ubuntu-latest
+    needs: [backend, frontend]
+    # AI-driven scenarios (e.g. chat.spec.ts) call the real OpenRouter API
+    # and are known to fail without a working OPENROUTER_API_KEY secret
+    # configured on this repo (see docs/PLAN.md, Parts 8-10). Non-AI specs
+    # (auth, kanban) still exercise the real backend + frontend end to end,
+    # so this job stays informational rather than blocking merges on an
+    # external dependency outside the PR's control.
+    continue-on-error: true
+    defaults:
+      run:
+        working-directory: frontend
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "latest"
+          python-version: "3.12"
+
+      - name: Install backend dependencies
+        working-directory: backend
+        run: uv sync --locked
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: "npm"
+          cache-dependency-path: frontend/package-lock.json
+
+      - name: Install frontend dependencies
+        run: npm ci
+
+      - name: Install Playwright browsers
+        run: npx playwright install --with-deps chromium
+
+      - name: Run e2e tests
+        env:
+          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
+        run: npm run test:e2e
+
+      - name: Upload Playwright report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-report
+          path: frontend/playwright-report/
+          retention-days: 7
diff --git a/.gitignore b/.gitignore
index b1d22cc1..00fe1cbe 100644
--- a/.gitignore
+++ b/.gitignore
@@ -174,3 +174,10 @@ cython_debug/
 
 .DS_Store
 
+# Project-specific
+*.db
+*.db-journal
+backend/data/
+frontend/out/
+
+
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..a90d6521
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,58 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this is
+
+A Project Management MVP: single-user (hardcoded `user`/`password`) Kanban board with an AI chat sidebar that can create/edit/move cards. NextJS frontend statically exported and served by a FastAPI backend, everything packaged into one Docker container. See [AGENTS.md](AGENTS.md) for the business requirements and [docs/PLAN.md](docs/PLAN.md) for what's implemented per part.
+
+Detailed, up-to-date conventions live in per-directory `AGENTS.md` files — read them before working in that area:
+- [backend/AGENTS.md](backend/AGENTS.md) — FastAPI structure, auth, db, AI/chat internals
+- [frontend/AGENTS.md](frontend/AGENTS.md) — Next.js structure, data model, state/drag-and-drop, test gotchas
+- [docs/DATABASE.md](docs/DATABASE.md) — SQLite schema and seeding
+
+## Commands
+
+Backend (from `backend/`, uses `uv`):
+```
+uv sync                              # install deps
+uv run uvicorn app.main:app --reload # run dev server (port 8000)
+uv run pytest                        # run all tests
+uv run pytest tests/test_board.py -k test_name  # run a single test
+```
+
+Frontend (from `frontend/`):
+```
+npm run dev          # dev server, port 3000 (proxies /api/* to backend on 8000)
+npm run build         # static export (output: "export")
+npm run lint
+npm run test:unit     # Vitest (or: npm run test)
+npm run test:unit:watch
+npm run test:e2e      # Playwright e2e; starts backend + next dev itself
+npm run test:all       # unit + e2e
+```
+Single Vitest file: `npx vitest run src/lib/kanban.test.ts`. Single Playwright spec: `npx playwright test tests/auth.spec.ts`.
+
+Full stack via Docker (from repo root):
+```
+scripts/start.sh   # or start.ps1 on Windows — docker compose up -d --build, app at :8000
+scripts/stop.sh    # or stop.ps1
+```
+
+CI (`.github/workflows/`) runs backend pytest, frontend lint + unit tests, and a non-blocking e2e job on every push/PR to `main`.
+
+## Architecture
+
+- FastAPI serves both the API (`/api/*`) and the pre-built Next.js static export (everything else), via a custom `NextStaticFiles` class in `backend/app/main.py` that resolves routes like `/login` to their exported `login.html`.
+- Frontend is a static export (no Next server-side features); local dev (`next dev`) proxies `/api/*` to a locally-running backend since there's no server to answer those routes itself.
+- Data model is normalized and shared in shape across three layers: SQLite (`columns`/`cards` tables) → backend pydantic models (`backend/app/board.py`) → frontend TS types (`frontend/src/lib/kanban.ts`) — columns hold ordered `cardIds`, cards are keyed by id.
+- Auth is a single hardcoded credential pair; sessions and (per Part 9) AI chat history are both in-memory dicts/sets on the backend process, not persisted — acceptable for this MVP, cleared on restart/logout.
+- AI chat (`backend/app/chat.py`, `backend/app/ai.py`) calls OpenRouter (`openai/gpt-oss-120b`) requesting structured JSON output (`{reply, board_update}`); a returned `board_update` is a full-board replacement, validated for internal consistency, then persisted via `replace_board` — not a diff/patch.
+- `backend/app/mcp_server.py` (untracked/in progress) exposes the board as MCP tools over stdio, talking to `app.board`/`app.db` directly rather than through the HTTP API.
+
+## Coding standards (from AGENTS.md)
+
+- Use latest versions of libraries and idiomatic approaches.
+- Keep it simple — no over-engineering, no unnecessary defensive programming, no speculative features.
+- Be concise; no emojis, ever.
+- When hitting issues, find root cause with evidence before fixing — don't guess.
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 00000000..7fa66d5d
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,26 @@
+FROM node:22-bookworm-slim AS frontend-build
+
+WORKDIR /app/frontend
+
+COPY frontend/package.json frontend/package-lock.json ./
+RUN npm ci
+
+COPY frontend/ ./
+RUN npm run build
+
+FROM ghcr.io/astral-sh/uv:python3.12-bookworm-slim
+
+WORKDIR /app
+
+COPY backend/pyproject.toml backend/uv.lock ./
+RUN uv sync --locked --no-install-project --no-dev
+
+COPY backend/app ./app
+COPY --from=frontend-build /app/frontend/out ./static
+
+ENV PATH="/app/.venv/bin:$PATH"
+ENV PYTHONUNBUFFERED=1
+
+EXPOSE 8000
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
diff --git a/backend/.python-version b/backend/.python-version
new file mode 100644
index 00000000..e4fba218
--- /dev/null
+++ b/backend/.python-version
@@ -0,0 +1 @@
+3.12
diff --git a/backend/AGENTS.md b/backend/AGENTS.md
index 6d2147f0..f10b3710 100644
--- a/backend/AGENTS.md
+++ b/backend/AGENTS.md
@@ -1 +1,39 @@
-This file should be updated with a description of the Backend
\ No newline at end of file
+# Backend
+
+FastAPI backend, managed with `uv`. Serves the API and (from Part 3 onward) the built frontend.
+
+## Structure
+
+```text
+app/
+  main.py          FastAPI app; lifespan runs db.init_db(); NextStaticFiles mount; all routes
+  auth.py          Hardcoded credential check, in-memory session store, require_session dependency
+  db.py            SQLite schema (DDL), seeding from the frontend's initialData, get_db per-request dependency
+  board.py          BoardData/Column/Card pydantic models + CRUD functions operating on a sqlite3.Connection
+  ai.py             OpenRouter client (complete/complete_structured); loads root .env locally, reads OPENROUTER_API_KEY
+  chat.py            /api/chat's logic: system prompt, response JSON schema, per-session history, board_update parsing/validation
+static/             Static files served at "/" (placeholder index.html until Part 3 replaces it with the built frontend)
+tests/
+  test_health.py         pytest + FastAPI TestClient
+  test_static_routing.py  NextStaticFiles path resolution, incl. the login.html/login/ directory collision
+  test_auth.py            login/logout/session routes, require_session dependency
+  test_board.py            board CRUD routes, incl. persistence across a fresh connection to the same db file
+  test_ai.py                OpenRouter client error handling (mocked httpx) + one real call, skipped if no API key
+  test_chat.py               board_update validation, /api/chat route (mocked OpenRouter call) + 2 real-call tests, skipped if no API key
+```
+
+## Conventions
+
+- Routes live under `/api/*`; everything else falls through to `NextStaticFiles` (mounted last, `html=True`) so `/` serves `static/index.html` and other routes resolve to their pre-rendered `<path>.html` — see the class docstring in `main.py` for why a plain `StaticFiles` isn't enough (Next 16's static export writes a same-named directory alongside each route's HTML file).
+- Auth (`auth.py`): single hardcoded user (`user`/`password`), session tokens are random strings held in an in-memory `set` — cleared on process restart, which is fine for this MVP. `require_session` gates the board routes via `dependencies=[Depends(require_session)]`. The session cookie is HttpOnly; static/page serving is intentionally *not* gated server-side (static export has no per-request logic) — the frontend's `AuthGate` component checks `/api/session` and redirects client-side instead.
+- Database (`db.py`): SQLite file at `DATABASE_PATH` env var (default `data/pm.db`, relative to cwd — resolves to `/app/data/pm.db` in Docker, matching the `db-data` volume in `docker-compose.yml`; resolves to `backend/data/pm.db` for local dev, gitignored). Schema/seed run once per process via `init_db()` in `main.py`'s `lifespan`. Read the path lazily (not a module-level constant) so tests can point `DATABASE_PATH` at a `tmp_path` file before the app's lifespan runs. `get_db()` opens and closes a fresh connection per request — simplest correct approach for SQLite, no shared-connection threading concerns.
+- Board (`board.py`): `users`/`boards` tables exist for the FK relationship and future multi-user support, but auth and board lookup don't use them for identity — see `docs/DATABASE.md` and `_get_board_id`'s comment. Every mutating function takes a `sqlite3.Connection` and commits internally; routes in `main.py` catch `ColumnNotFound`/`CardNotFound`/`BoardNotFound` and turn them into 404s.
+- AI (`ai.py`): `complete(messages)` and `complete_structured(messages, schema_name, schema)` both POST to OpenRouter (`openai/gpt-oss-120b`) via a shared `_post_chat_completion`/`_extract_content` pair — `complete_structured` adds a `response_format: {type: "json_schema", json_schema: {strict: true, ...}}` for Part 9's chat route. Both raise `OpenRouterError` for a missing key, network failure, non-200, or an unexpected response shape — routes map that to a 502. `load_dotenv()` runs at import time pointed at the repo-root `.env` (`parents[2]` from `app/ai.py`) since local `uv run` has `cwd=backend/`; in Docker, `OPENROUTER_API_KEY` is already injected via `docker-compose.yml`'s `env_file`, so the (absent) `.env` load there is just a no-op.
+- Chat (`chat.py`): `/api/chat` always sends the current board (as JSON, `cards` as an **array** — see below) plus per-session history plus the new message, requesting structured output matching `RESPONSE_SCHEMA` (`{reply, board_update}`). `board_update`, if present, is a **full-board replacement** (not a diff/patch) — `parse_board_update` converts its array-of-cards wire shape into the internal dict-keyed `BoardData`, then `_validate_board_update` checks internal consistency (unique column ids, each card referenced by exactly one column, no dangling/orphaned ids) before `board.py`'s `replace_board` (delete-and-reinsert) persists it. An invalid `board_update` is silently ignored — the reply still comes back, the board just doesn't change. `cards` must be an array in the wire schema (not the dict-by-id shape used elsewhere) because strict-mode JSON Schema structured outputs don't support a dynamic-keyed object. Conversation history lives in an in-memory `dict[session_id, list[message]]`, cleared on logout — same "in-memory is fine for this MVP" call as sessions themselves (Part 5).
+- Dependencies split into runtime (`dependencies`) and dev-only (`dependency-groups.dev`, currently just `pytest`) in `pyproject.toml`. `httpx` is a runtime dependency (used by both `ai.py` and `TestClient`), not dev-only, despite mostly showing up in tests.
+- Run locally: `uv sync`, `uv run uvicorn app.main:app --reload`, `uv run pytest`.
+- The Docker image (root `Dockerfile`) installs deps with `uv sync --locked --no-dev` — keep `uv.lock` committed and up to date via `uv add`/`uv remove`, not manual edits.
+- For local e2e testing, `frontend/playwright.config.ts` runs this backend on port 8000 (`uv run --directory ../backend uvicorn ...`) alongside `next dev` on port 3000, which proxies `/api/*` to it (see `frontend/next.config.ts`).
+- Tests that hit the database must use `with TestClient(app) as client:` (not a bare `TestClient(app)`) — only the context-manager form runs the FastAPI `lifespan`, which is what creates/seeds the SQLite schema. Tests that don't touch the DB (health/auth/static routing) intentionally use the bare form so they don't trigger it.
+
+See [../docs/PLAN.md](../docs/PLAN.md) for what's implemented per part and [../docs/DATABASE.md](../docs/DATABASE.md) for the schema.
diff --git a/backend/README.md b/backend/README.md
new file mode 100644
index 00000000..803e3b1a
--- /dev/null
+++ b/backend/README.md
@@ -0,0 +1,11 @@
+# Backend
+
+FastAPI backend for the PM Kanban app. See [AGENTS.md](AGENTS.md) and [../docs/PLAN.md](../docs/PLAN.md).
+
+## Development
+
+```
+uv sync
+uv run uvicorn app.main:app --reload
+uv run pytest
+```
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/backend/app/ai.py b/backend/app/ai.py
new file mode 100644
index 00000000..aeba9982
--- /dev/null
+++ b/backend/app/ai.py
@@ -0,0 +1,75 @@
+import os
+from pathlib import Path
+from typing import Any
+
+import httpx
+from dotenv import load_dotenv
+
+# In Docker, OPENROUTER_API_KEY is already injected via docker-compose's
+# env_file. For local `uv run` (cwd is backend/), load the root .env
+# explicitly; a missing file here is a no-op, not an error.
+load_dotenv(Path(__file__).resolve().parents[2] / ".env")
+
+OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
+MODEL = "openai/gpt-oss-120b"
+
+
+class OpenRouterError(Exception):
+    pass
+
+
+def _get_api_key() -> str:
+    api_key = os.environ.get("OPENROUTER_API_KEY")
+    if not api_key:
+        raise OpenRouterError("OPENROUTER_API_KEY is not set")
+    return api_key
+
+
+def _post_chat_completion(
+    messages: list[dict[str, str]], response_format: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    api_key = _get_api_key()
+    payload: dict[str, Any] = {"model": MODEL, "messages": messages}
+    if response_format is not None:
+        payload["response_format"] = response_format
+
+    try:
+        response = httpx.post(
+            OPENROUTER_URL,
+            headers={"Authorization": f"Bearer {api_key}"},
+            json=payload,
+            timeout=30.0,
+        )
+    except httpx.HTTPError as exc:
+        raise OpenRouterError(f"Network error calling OpenRouter: {exc}") from exc
+
+    if response.status_code != 200:
+        raise OpenRouterError(
+            f"OpenRouter request failed with status {response.status_code}: {response.text}"
+        )
+
+    return response.json()
+
+
+def _extract_content(data: dict[str, Any]) -> str:
+    try:
+        return data["choices"][0]["message"]["content"]
+    except (KeyError, IndexError) as exc:
+        raise OpenRouterError(f"Unexpected OpenRouter response shape: {data}") from exc
+
+
+def complete(messages: list[dict[str, str]]) -> str:
+    return _extract_content(_post_chat_completion(messages))
+
+
+def complete_structured(messages: list[dict[str, str]], schema_name: str, schema: dict[str, Any]) -> str:
+    """Like `complete`, but requests (and returns, still as a string) a
+    response conforming to `schema` via OpenRouter's structured outputs."""
+    data = _post_chat_completion(
+        messages,
+        response_format={
+            "type": "json_schema",
+            "json_schema": {"name": schema_name, "strict": True, "schema": schema},
+        },
+    )
+    return _extract_content(data)
diff --git a/backend/app/auth.py b/backend/app/auth.py
new file mode 100644
index 00000000..b9468ffa
--- /dev/null
+++ b/backend/app/auth.py
@@ -0,0 +1,35 @@
+import secrets
+from typing import Annotated
+
+from fastapi import Cookie, HTTPException, status
+
+USERNAME = "user"
+PASSWORD = "password"
+SESSION_COOKIE = "session_id"
+
+_sessions: set[str] = set()
+
+
+def verify_credentials(username: str, password: str) -> bool:
+    return username == USERNAME and password == PASSWORD
+
+
+def create_session() -> str:
+    token = secrets.token_urlsafe(32)
+    _sessions.add(token)
+    return token
+
+
+def destroy_session(token: str | None) -> None:
+    if token:
+        _sessions.discard(token)
+
+
+def is_valid_session(token: str | None) -> bool:
+    return token is not None and token in _sessions
+
+
+def require_session(session_id: Annotated[str | None, Cookie()] = None) -> str:
+    if not is_valid_session(session_id):
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Not authenticated")
+    return session_id
diff --git a/backend/app/board.py b/backend/app/board.py
new file mode 100644
index 00000000..c62cf35d
--- /dev/null
+++ b/backend/app/board.py
@@ -0,0 +1,206 @@
+import secrets
+import sqlite3
+
+from pydantic import BaseModel
+
+
+class Card(BaseModel):
+    id: str
+    title: str
+    details: str
+
+
+class Column(BaseModel):
+    id: str
+    title: str
+    cardIds: list[str]
+
+
+class BoardData(BaseModel):
+    columns: list[Column]
+    cards: dict[str, Card]
+
+
+class BoardNotFound(Exception):
+    pass
+
+
+class ColumnNotFound(Exception):
+    pass
+
+
+class CardNotFound(Exception):
+    pass
+
+
+def create_id(prefix: str) -> str:
+    return f"{prefix}-{secrets.token_hex(4)}"
+
+
+def _get_board_id(conn: sqlite3.Connection) -> int:
+    # Single-user MVP: there is only ever one board, so no need to resolve it
+    # from the session (sessions don't carry a user identity, see auth.py).
+    row = conn.execute("SELECT id FROM boards LIMIT 1").fetchone()
+    if row is None:
+        raise BoardNotFound
+    return row["id"]
+
+
+def get_board(conn: sqlite3.Connection) -> BoardData:
+    board_id = _get_board_id(conn)
+    column_rows = conn.execute(
+        "SELECT id, title FROM columns WHERE board_id = ? ORDER BY position", (board_id,)
+    ).fetchall()
+
+    cards: dict[str, Card] = {}
+    columns: list[Column] = []
+    for column_row in column_rows:
+        card_rows = conn.execute(
+            "SELECT id, title, details FROM cards WHERE column_id = ? ORDER BY position",
+            (column_row["id"],),
+        ).fetchall()
+        card_ids: list[str] = []
+        for card_row in card_rows:
+            cards[card_row["id"]] = Card(
+                id=card_row["id"], title=card_row["title"], details=card_row["details"]
+            )
+            card_ids.append(card_row["id"])
+        columns.append(Column(id=column_row["id"], title=column_row["title"], cardIds=card_ids))
+
+    return BoardData(columns=columns, cards=cards)
+
+
+def rename_column(conn: sqlite3.Connection, column_id: str, title: str) -> None:
+    cursor = conn.execute("UPDATE columns SET title = ? WHERE id = ?", (title, column_id))
+    if cursor.rowcount == 0:
+        raise ColumnNotFound
+    conn.commit()
+
+
+def add_card(conn: sqlite3.Connection, column_id: str, title: str, details: str) -> str:
+    column = conn.execute("SELECT id FROM columns WHERE id = ?", (column_id,)).fetchone()
+    if column is None:
+        raise ColumnNotFound
+
+    conn.execute("BEGIN IMMEDIATE")
+    try:
+        next_position = conn.execute(
+            "SELECT COALESCE(MAX(position) + 1, 0) AS next_position FROM cards WHERE column_id = ?",
+            (column_id,),
+        ).fetchone()["next_position"]
+
+        card_id = create_id("card")
+        conn.execute(
+            "INSERT INTO cards (id, column_id, title, details, position) VALUES (?, ?, ?, ?, ?)",
+            (card_id, column_id, title, details, next_position),
+        )
+        conn.commit()
+    except Exception:
+        conn.rollback()
+        raise
+    return card_id
+
+
+def update_card(
+    conn: sqlite3.Connection,
+    card_id: str,
+    title: str | None = None,
+    details: str | None = None,
+    column_id: str | None = None,
+    position: int | None = None,
+) -> None:
+    card = conn.execute("SELECT column_id FROM cards WHERE id = ?", (card_id,)).fetchone()
+    if card is None:
+        raise CardNotFound
+
+    if title is not None or details is not None:
+        fields = []
+        values: list[str] = []
+        if title is not None:
+            fields.append("title = ?")
+            values.append(title)
+        if details is not None:
+            fields.append("details = ?")
+            values.append(details)
+        values.append(card_id)
+        conn.execute(f"UPDATE cards SET {', '.join(fields)} WHERE id = ?", values)
+
+    if column_id is not None or position is not None:
+        target_column_id = column_id or card["column_id"]
+        target_column = conn.execute(
+            "SELECT id FROM columns WHERE id = ?", (target_column_id,)
+        ).fetchone()
+        if target_column is None:
+            raise ColumnNotFound
+        _move_card(conn, card_id, card["column_id"], target_column_id, position)
+
+    conn.commit()
+
+
+def _move_card(
+    conn: sqlite3.Connection,
+    card_id: str,
+    source_column_id: str,
+    target_column_id: str,
+    position: int | None,
+) -> None:
+    source_card_ids = [
+        row["id"]
+        for row in conn.execute(
+            "SELECT id FROM cards WHERE column_id = ? AND id != ? ORDER BY position",
+            (source_column_id, card_id),
+        ).fetchall()
+    ]
+
+    if source_column_id == target_column_id:
+        target_card_ids = source_card_ids
+    else:
+        target_card_ids = [
+            row["id"]
+            for row in conn.execute(
+                "SELECT id FROM cards WHERE column_id = ? ORDER BY position", (target_column_id,)
+            ).fetchall()
+        ]
+
+    insert_at = len(target_card_ids) if position is None else max(0, min(position, len(target_card_ids)))
+    target_card_ids.insert(insert_at, card_id)
+
+    conn.execute("UPDATE cards SET column_id = ? WHERE id = ?", (target_column_id, card_id))
+    for index, target_card_id in enumerate(target_card_ids):
+        conn.execute("UPDATE cards SET position = ? WHERE id = ?", (index, target_card_id))
+
+    if source_column_id != target_column_id:
+        for index, source_card_id in enumerate(source_card_ids):
+            conn.execute("UPDATE cards SET position = ? WHERE id = ?", (index, source_card_id))
+
+
+def delete_card(conn: sqlite3.Connection, card_id: str) -> None:
+    cursor = conn.execute("DELETE FROM cards WHERE id = ?", (card_id,))
+    if cursor.rowcount == 0:
+        raise CardNotFound
+    conn.commit()
+
+
+def replace_board(conn: sqlite3.Connection, board: BoardData) -> None:
+    """Replace the entire board with `board` (AI chat updates, Part 9).
+
+    Deletes all existing columns (cascading to their cards) and re-inserts
+    from scratch. Simpler and just as correct as diffing against current
+    state, at this scale (a handful of columns/cards).
+    """
+    board_id = _get_board_id(conn)
+    conn.execute("DELETE FROM columns WHERE board_id = ?", (board_id,))
+
+    for position, column in enumerate(board.columns):
+        conn.execute(
+            "INSERT INTO columns (id, board_id, title, position) VALUES (?, ?, ?, ?)",
+            (column.id, board_id, column.title, position),
+        )
+        for card_position, card_id in enumerate(column.cardIds):
+            card = board.cards[card_id]
+            conn.execute(
+                "INSERT INTO cards (id, column_id, title, details, position) VALUES (?, ?, ?, ?, ?)",
+                (card.id, column.id, card.title, card.details, card_position),
+            )
+
+    conn.commit()
diff --git a/backend/app/chat.py b/backend/app/chat.py
new file mode 100644
index 00000000..6077e375
--- /dev/null
+++ b/backend/app/chat.py
@@ -0,0 +1,133 @@
+import json
+from typing import Any
+
+from pydantic import ValidationError
+
+from app.ai import OpenRouterError, complete_structured
+from app.board import BoardData, Card, Column
+
+# In-memory, per-session conversation history (Part 5 decided sessions stay
+# in-memory too — consistent, and fine for a single hardcoded user).
+_HISTORY: dict[str, list[dict[str, str]]] = {}
+
+SYSTEM_PROMPT = (
+    "You are an assistant embedded in a single-board Kanban app. You are given the current "
+    "board as JSON: columns in display order, each with an ordered list of card ids, plus a "
+    "flat list of cards. Respond to the user's message conversationally in `reply`. "
+    "If, and only if, the user asks you to create, edit, move, or reorder cards, or rename "
+    "columns, set `board_update` to the COMPLETE new board: every column and every card, "
+    "including all the ones you didn't change. Never omit an existing card or column the user "
+    "didn't ask you to remove. If the user is just asking a question or chatting, set "
+    "`board_update` to null and don't change anything."
+)
+
+RESPONSE_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "reply": {"type": "string"},
+        "board_update": {
+            "type": ["object", "null"],
+            "properties": {
+                "columns": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "id": {"type": "string"},
+                            "title": {"type": "string"},
+                            "cardIds": {"type": "array", "items": {"type": "string"}},
+                        },
+                        "required": ["id", "title", "cardIds"],
+                        "additionalProperties": False,
+                    },
+                },
+                "cards": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "id": {"type": "string"},
+                            "title": {"type": "string"},
+                            "details": {"type": "string"},
+                        },
+                        "required": ["id", "title", "details"],
+                        "additionalProperties": False,
+                    },
+                },
+            },
+            "required": ["columns", "cards"],
+            "additionalProperties": False,
+        },
+    },
+    "required": ["reply", "board_update"],
+    "additionalProperties": False,
+}
+
+
+class InvalidBoardUpdate(Exception):
+    pass
+
+
+def get_history(session_id: str) -> list[dict[str, str]]:
+    return _HISTORY.setdefault(session_id, [])
+
+
+def clear_history(session_id: str | None) -> None:
+    if session_id:
+        _HISTORY.pop(session_id, None)
+
+
+def _board_to_prompt_json(board: BoardData) -> dict[str, Any]:
+    return {
+        "columns": [column.model_dump() for column in board.columns],
+        "cards": [card.model_dump() for card in board.cards.values()],
+    }
+
+
+def request_chat_completion(
+    board: BoardData, history: list[dict[str, str]], message: str
+) -> dict[str, Any]:
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "system", "content": f"Current board: {json.dumps(_board_to_prompt_json(board))}"},
+        *history,
+        {"role": "user", "content": message},
+    ]
+
+    content = complete_structured(messages, schema_name="kanban_reply", schema=RESPONSE_SCHEMA)
+
+    try:
+        return json.loads(content)
+    except json.JSONDecodeError as exc:
+        raise OpenRouterError(f"Model response was not valid JSON: {content}") from exc
+
+
+def parse_board_update(raw: dict[str, Any] | None) -> BoardData | None:
+    if raw is None:
+        return None
+
+    try:
+        columns = [Column(**column) for column in raw["columns"]]
+        cards = {card["id"]: Card(**card) for card in raw["cards"]}
+    except (KeyError, TypeError, ValidationError) as exc:
+        raise InvalidBoardUpdate(f"Malformed board_update: {exc}") from exc
+
+    board = BoardData(columns=columns, cards=cards)
+    _validate_board_update(board)
+    return board
+
+
+def _validate_board_update(board: BoardData) -> None:
+    column_ids = [column.id for column in board.columns]
+    if len(column_ids) != len(set(column_ids)):
+        raise InvalidBoardUpdate("Duplicate column ids in board_update")
+
+    referenced_card_ids: list[str] = []
+    for column in board.columns:
+        referenced_card_ids.extend(column.cardIds)
+
+    if len(referenced_card_ids) != len(set(referenced_card_ids)):
+        raise InvalidBoardUpdate("A card is referenced by more than one column in board_update")
+
+    if set(referenced_card_ids) != set(board.cards.keys()):
+        raise InvalidBoardUpdate("board_update's columns and cards disagree about which cards exist")
diff --git a/backend/app/db.py b/backend/app/db.py
new file mode 100644
index 00000000..1a9ef9b7
--- /dev/null
+++ b/backend/app/db.py
@@ -0,0 +1,117 @@
+import os
+import sqlite3
+from pathlib import Path
+from typing import Iterator
+
+from app.auth import PASSWORD, USERNAME
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS users (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    username TEXT NOT NULL UNIQUE,
+    password TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS boards (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id INTEGER NOT NULL UNIQUE REFERENCES users(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS columns (
+    id TEXT PRIMARY KEY,
+    board_id INTEGER NOT NULL REFERENCES boards(id) ON DELETE CASCADE,
+    title TEXT NOT NULL,
+    position INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_columns_board_position ON columns(board_id, position);
+
+CREATE TABLE IF NOT EXISTS cards (
+    id TEXT PRIMARY KEY,
+    column_id TEXT NOT NULL REFERENCES columns(id) ON DELETE CASCADE,
+    title TEXT NOT NULL,
+    details TEXT NOT NULL DEFAULT '',
+    position INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_cards_column_position ON cards(column_id, position);
+"""
+
+INITIAL_COLUMNS = [
+    ("col-backlog", "Backlog"),
+    ("col-discovery", "Discovery"),
+    ("col-progress", "In Progress"),
+    ("col-review", "Review"),
+    ("col-done", "Done"),
+]
+
+INITIAL_CARDS: dict[str, list[tuple[str, str, str]]] = {
+    "col-backlog": [
+        ("card-1", "Align roadmap themes", "Draft quarterly themes with impact statements and metrics."),
+        ("card-2", "Gather customer signals", "Review support tags, sales notes, and churn feedback."),
+    ],
+    "col-discovery": [
+        ("card-3", "Prototype analytics view", "Sketch initial dashboard layout and key drill-downs."),
+    ],
+    "col-progress": [
+        ("card-4", "Refine status language", "Standardize column labels and tone across the board."),
+        ("card-5", "Design card layout", "Add hierarchy and spacing for scanning dense lists."),
+    ],
+    "col-review": [
+        ("card-6", "QA micro-interactions", "Verify hover, focus, and loading states."),
+    ],
+    "col-done": [
+        ("card-7", "Ship marketing page", "Final copy approved and asset pack delivered."),
+        ("card-8", "Close onboarding sprint", "Document release notes and share internally."),
+    ],
+}
+
+
+def _database_path() -> Path:
+    # Read lazily (not at import time) so tests can point this at a temp file.
+    return Path(os.environ.get("DATABASE_PATH", "data/pm.db"))
+
+
+def get_connection(path: Path | str | None = None) -> sqlite3.Connection:
+    resolved_path = Path(path) if path is not None else _database_path()
+    resolved_path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(resolved_path)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON")
+    return conn
+
+
+def init_db(conn: sqlite3.Connection) -> None:
+    conn.executescript(SCHEMA)
+    _seed_if_empty(conn)
+
+
+def _seed_if_empty(conn: sqlite3.Connection) -> None:
+    user = conn.execute("SELECT id FROM users WHERE username = ?", (USERNAME,)).fetchone()
+    if user is None:
+        conn.execute("INSERT INTO users (username, password) VALUES (?, ?)", (USERNAME, PASSWORD))
+        user = conn.execute("SELECT id FROM users WHERE username = ?", (USERNAME,)).fetchone()
+    user_id = user["id"]
+
+    board = conn.execute("SELECT id FROM boards WHERE user_id = ?", (user_id,)).fetchone()
+    if board is None:
+        cursor = conn.execute("INSERT INTO boards (user_id) VALUES (?)", (user_id,))
+        board_id = cursor.lastrowid
+        for position, (column_id, title) in enumerate(INITIAL_COLUMNS):
+            conn.execute(
+                "INSERT INTO columns (id, board_id, title, position) VALUES (?, ?, ?, ?)",
+                (column_id, board_id, title, position),
+            )
+            for card_position, (card_id, card_title, details) in enumerate(INITIAL_CARDS[column_id]):
+                conn.execute(
+                    "INSERT INTO cards (id, column_id, title, details, position) VALUES (?, ?, ?, ?, ?)",
+                    (card_id, column_id, card_title, details, card_position),
+                )
+
+    conn.commit()
+
+
+def get_db() -> Iterator[sqlite3.Connection]:
+    conn = get_connection()
+    try:
+        yield conn
+    finally:
+        conn.close()
diff --git a/backend/app/main.py b/backend/app/main.py
new file mode 100644
index 00000000..4cda2112
--- /dev/null
+++ b/backend/app/main.py
@@ -0,0 +1,233 @@
+import sqlite3
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import AsyncIterator, Annotated
+
+from fastapi import Cookie, Depends, FastAPI, HTTPException, Response, status
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel, Field
+
+from app.ai import OpenRouterError, complete
+from app.auth import (
+    SESSION_COOKIE,
+    create_session,
+    destroy_session,
+    is_valid_session,
+    require_session,
+    verify_credentials,
+)
+from app.board import (
+    BoardData,
+    BoardNotFound,
+    CardNotFound,
+    ColumnNotFound,
+    add_card,
+    delete_card,
+    get_board,
+    rename_column,
+    replace_board,
+    update_card,
+)
+from app.chat import (
+    InvalidBoardUpdate,
+    clear_history,
+    get_history,
+    parse_board_update,
+    request_chat_completion,
+)
+from app.db import get_connection, get_db, init_db
+
+STATIC_DIR = Path(__file__).resolve().parent.parent / "static"
+
+
+class NextStaticFiles(StaticFiles):
+    """Resolve paths to their pre-rendered `<path>.html` file first.
+
+    Next.js's static export writes one HTML file per route (e.g. `login.html`
+    for `/login`) *and* a same-named directory of RSC prefetch data (`login/`,
+    with no `index.html` inside). Plain StaticFiles matches that directory
+    first and then 404s, since it never finds an `index.html` inside it. Try
+    `<path>.html` before the raw path so the actual page wins.
+    """
+
+    def lookup_path(self, path: str) -> tuple[str, object]:
+        if path not in ("", "."):
+            full_path, stat_result = super().lookup_path(f"{path}.html")
+            if stat_result is not None:
+                return full_path, stat_result
+        return super().lookup_path(path)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncIterator[None]:
+    conn = get_connection()
+    try:
+        init_db(conn)
+    finally:
+        conn.close()
+    yield
+
+
+app = FastAPI(title="pm-backend", lifespan=lifespan)
+
+
+@app.get("/api/health")
+def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+class Credentials(BaseModel):
+    username: str
+    password: str
+
+
+@app.post("/api/login")
+def login(credentials: Credentials, response: Response) -> dict[str, str]:
+    if not verify_credentials(credentials.username, credentials.password):
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid username or password")
+    response.set_cookie(SESSION_COOKIE, create_session(), httponly=True, samesite="lax")
+    return {"status": "ok"}
+
+
+@app.post("/api/logout")
+def logout(response: Response, session_id: Annotated[str | None, Cookie()] = None) -> dict[str, str]:
+    destroy_session(session_id)
+    clear_history(session_id)
+    response.delete_cookie(SESSION_COOKIE)
+    return {"status": "ok"}
+
+
+@app.get("/api/session")
+def session_status(session_id: Annotated[str | None, Cookie()] = None) -> dict[str, bool]:
+    return {"authenticated": is_valid_session(session_id)}
+
+
+class RenameColumnRequest(BaseModel):
+    title: str = Field(min_length=1)
+
+
+class CreateCardRequest(BaseModel):
+    column_id: str
+    title: str = Field(min_length=1)
+    details: str = ""
+
+
+class UpdateCardRequest(BaseModel):
+    title: str | None = None
+    details: str | None = None
+    column_id: str | None = None
+    position: int | None = None
+
+
+@app.get("/api/board", dependencies=[Depends(require_session)])
+def read_board(conn: sqlite3.Connection = Depends(get_db)) -> BoardData:
+    try:
+        return get_board(conn)
+    except BoardNotFound:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Board not found")
+
+
+@app.patch("/api/columns/{column_id}", dependencies=[Depends(require_session)])
+def rename_column_route(
+    column_id: str, payload: RenameColumnRequest, conn: sqlite3.Connection = Depends(get_db)
+) -> BoardData:
+    try:
+        rename_column(conn, column_id, payload.title)
+    except ColumnNotFound:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Column not found")
+    return get_board(conn)
+
+
+@app.post("/api/cards", dependencies=[Depends(require_session)])
+def create_card_route(payload: CreateCardRequest, conn: sqlite3.Connection = Depends(get_db)) -> BoardData:
+    try:
+        add_card(conn, payload.column_id, payload.title, payload.details)
+    except ColumnNotFound:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Column not found")
+    return get_board(conn)
+
+
+@app.patch("/api/cards/{card_id}", dependencies=[Depends(require_session)])
+def update_card_route(
+    card_id: str, payload: UpdateCardRequest, conn: sqlite3.Connection = Depends(get_db)
+) -> BoardData:
+    try:
+        update_card(
+            conn,
+            card_id,
+            title=payload.title,
+            details=payload.details,
+            column_id=payload.column_id,
+            position=payload.position,
+        )
+    except CardNotFound:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Card not found")
+    except ColumnNotFound:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Column not found")
+    return get_board(conn)
+
+
+@app.delete("/api/cards/{card_id}", dependencies=[Depends(require_session)])
+def delete_card_route(card_id: str, conn: sqlite3.Connection = Depends(get_db)) -> BoardData:
+    try:
+        delete_card(conn, card_id)
+    except CardNotFound:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Card not found")
+    return get_board(conn)
+
+
+class AiTestResponse(BaseModel):
+    reply: str
+
+
+@app.post("/api/ai/test", dependencies=[Depends(require_session)])
+def ai_test_route() -> AiTestResponse:
+    try:
+        reply = complete([{"role": "user", "content": "What is 2+2? Answer with just the number."}])
+    except OpenRouterError as exc:
+        raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc))
+    return AiTestResponse(reply=reply)
+
+
+class ChatRequest(BaseModel):
+    message: str
+
+
+class ChatResponse(BaseModel):
+    reply: str
+    board: BoardData
+
+
+@app.post("/api/chat", dependencies=[Depends(require_session)])
+def chat_route(
+    payload: ChatRequest,
+    conn: sqlite3.Connection = Depends(get_db),
+    session_id: str = Depends(require_session),
+) -> ChatResponse:
+    board = get_board(conn)
+    history = get_history(session_id)
+
+    try:
+        raw = request_chat_completion(board, history, payload.message)
+    except OpenRouterError as exc:
+        raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=str(exc))
+
+    reply = raw.get("reply", "")
+
+    try:
+        board_update = parse_board_update(raw.get("board_update"))
+    except InvalidBoardUpdate:
+        # Reject rather than risk corrupting the board with a malformed update.
+        board_update = None
+
+    if board_update is not None:
+        replace_board(conn, board_update)
+        board = get_board(conn)
+
+    history.append({"role": "user", "content": payload.message})
+    history.append({"role": "assistant", "content": reply})
+
+    return ChatResponse(reply=reply, board=board)
+
+
+app.mount("/", NextStaticFiles(directory=STATIC_DIR, html=True), name="static")
diff --git a/backend/app/mcp_server.py b/backend/app/mcp_server.py
new file mode 100644
index 00000000..ea84757d
--- /dev/null
+++ b/backend/app/mcp_server.py
@@ -0,0 +1,140 @@
+"""MCP server exposing the PM board as tools for Claude.
+
+Talks to the SQLite board storage directly (reusing app.board), bypassing
+the FastAPI HTTP layer entirely — there's no multi-user auth to satisfy
+for a single local board, so going through the session-cookie flow would
+be pure overhead. Run locally via stdio; see README.md for setup.
+"""
+
+import os
+from pathlib import Path
+from typing import Annotated
+
+from fastmcp import FastMCP
+from pydantic import Field
+
+from app.board import (
+    BoardNotFound,
+    CardNotFound,
+    ColumnNotFound,
+    add_card,
+    delete_card as delete_card_row,
+    get_board as get_board_row,
+    rename_column as rename_column_row,
+    update_card as update_card_row,
+)
+from app.db import get_connection, init_db
+
+DEFAULT_DB_PATH = Path(__file__).resolve().parent.parent / "data" / "pm.db"
+
+mcp = FastMCP(
+    name="pm-board",
+    instructions=(
+        "Tools for reading and editing a personal kanban board (columns and cards). "
+        "Call get_board first to see current column and card IDs before creating, "
+        "moving, or deleting cards."
+    ),
+)
+
+
+def _db_path() -> Path:
+    override = os.environ.get("DATABASE_PATH")
+    return Path(override) if override else DEFAULT_DB_PATH
+
+
+@mcp.tool(annotations={"readOnlyHint": True, "title": "Get board"})
+def get_board_tool() -> dict:
+    """Fetch the full board: all columns in order, and all cards keyed by ID.
+
+    Call this first — you need column IDs and card IDs before calling any
+    other tool.
+    """
+    conn = get_connection(_db_path())
+    try:
+        init_db(conn)
+        try:
+            board = get_board(conn)
+        except BoardNotFound:
+            return {"columns": [], "cards": {}}
+        return board.model_dump()
+    finally:
+        conn.close()
+
+
+@mcp.tool(annotations={"readOnlyHint": False, "destructiveHint": False, "title": "Create card"})
+def create_card(
+    column_id: Annotated[str, Field(description="ID of the column to add the card to, from get_board.")],
+    title: Annotated[str, Field(description="Card title.", min_length=1)],
+    details: Annotated[str, Field(description="Card body/description. Defaults to empty.")] = "",
+) -> dict:
+    """Create a new card at the end of the given column. Returns the new card's ID."""
+    conn = get_connection(_db_path())
+    try:
+        try:
+            card_id = add_card(conn, column_id, title, details)
+        except ColumnNotFound:
+            return {"error": f"Column {column_id!r} not found. Call get_board to see valid column IDs."}
+        return {"card_id": card_id}
+    finally:
+        conn.close()
+
+
+@mcp.tool(annotations={"readOnlyHint": False, "destructiveHint": False, "idempotentHint": True, "title": "Update card"})
+def update_card(
+    card_id: Annotated[str, Field(description="ID of the card to update, from get_board.")],
+    title: Annotated[str | None, Field(description="New title. Omit to leave unchanged.")] = None,
+    details: Annotated[str | None, Field(description="New body/description. Omit to leave unchanged.")] = None,
+    column_id: Annotated[
+        str | None, Field(description="Move the card to this column ID. Omit to leave in its current column.")
+    ] = None,
+    position: Annotated[
+        int | None, Field(description="0-based position within the target column. Omit to append at the end.")
+    ] = None,
+) -> dict:
+    """Update a card's title, details, and/or move it to a different column/position."""
+    conn = get_connection(_db_path())
+    try:
+        try:
+            update_card_row(conn, card_id, title=title, details=details, column_id=column_id, position=position)
+        except CardNotFound:
+            return {"error": f"Card {card_id!r} not found. Call get_board to see valid card IDs."}
+        except ColumnNotFound:
+            return {"error": f"Column {column_id!r} not found. Call get_board to see valid column IDs."}
+        return {"status": "ok"}
+    finally:
+        conn.close()
+
+
+@mcp.tool(annotations={"readOnlyHint": False, "destructiveHint": True, "idempotentHint": True, "title": "Delete card"})
+def delete_card(card_id: Annotated[str, Field(description="ID of the card to delete, from get_board.")]) -> dict:
+    """Permanently delete a card. This cannot be undone."""
+    conn = get_connection(_db_path())
+    try:
+        try:
+            delete_card_row(conn, card_id)
+        except CardNotFound:
+            return {"error": f"Card {card_id!r} not found. Call get_board to see valid card IDs."}
+        return {"status": "ok"}
+    finally:
+        conn.close()
+
+
+@mcp.tool(annotations={"readOnlyHint": False, "destructiveHint": False, "idempotentHint": True, "title": "Rename column"})
+def rename_column(
+    column_id: Annotated[str, Field(description="ID of the column to rename, from get_board.")],
+    title: Annotated[str, Field(description="New column title.", min_length=1)],
+) -> dict:
+    """Rename a column (e.g. rename 'In Progress' to 'Doing')."""
+    conn = get_connection(_db_path())
+    try:
+        try:
+            rename_column_row(conn, column_id, title)
+        except ColumnNotFound:
+            return {"error": f"Column {column_id!r} not found. Call get_board to see valid column IDs."}
+        return {"status": "ok"}
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    mcp.run()
diff --git a/backend/pyproject.toml b/backend/pyproject.toml
new file mode 100644
index 00000000..6d5e7de0
--- /dev/null
+++ b/backend/pyproject.toml
@@ -0,0 +1,17 @@
+[project]
+name = "pm-backend"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fastapi>=0.141.1",
+    "httpx>=0.28.1",
+    "python-dotenv>=1.2.2",
+    "uvicorn[standard]>=0.52.1",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]
diff --git a/backend/static/index.html b/backend/static/index.html
new file mode 100644
index 00000000..2fa3dfb7
--- /dev/null
+++ b/backend/static/index.html
@@ -0,0 +1,11 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>PM Backend</title>
+  </head>
+  <body>
+    <h1>Hello world</h1>
+    <p>Placeholder page served by FastAPI. The built frontend replaces this in Part 3.</p>
+  </body>
+</html>
diff --git a/backend/tests/__init__.py b/backend/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/backend/tests/test_ai.py b/backend/tests/test_ai.py
new file mode 100644
index 00000000..a25b2388
--- /dev/null
+++ b/backend/tests/test_ai.py
@@ -0,0 +1,80 @@
+import os
+from unittest.mock import patch
+
+import httpx
+import pytest
+from fastapi.testclient import TestClient
+
+from app.ai import OpenRouterError, complete
+from app.main import app
+
+VALID_CREDENTIALS = {"username": "user", "password": "password"}
+
+
+def test_complete_raises_when_api_key_missing(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("OPENROUTER_API_KEY", raising=False)
+
+    with pytest.raises(OpenRouterError, match="not set"):
+        complete([{"role": "user", "content": "hi"}])
+
+
+def test_complete_raises_on_network_error(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("OPENROUTER_API_KEY", "test-key")
+    monkeypatch.setattr(httpx, "post", lambda *args, **kwargs: (_ for _ in ()).throw(httpx.ConnectError("boom")))
+
+    with pytest.raises(OpenRouterError, match="Network error"):
+        complete([{"role": "user", "content": "hi"}])
+
+
+def test_complete_raises_on_non_200(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("OPENROUTER_API_KEY", "test-key")
+
+    class FakeResponse:
+        status_code = 401
+        text = "unauthorized"
+
+    monkeypatch.setattr(httpx, "post", lambda *args, **kwargs: FakeResponse())
+
+    with pytest.raises(OpenRouterError, match="401"):
+        complete([{"role": "user", "content": "hi"}])
+
+
+def test_complete_raises_on_unexpected_response_shape(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("OPENROUTER_API_KEY", "test-key")
+
+    class FakeResponse:
+        status_code = 200
+        text = "{}"
+
+        def json(self) -> dict:
+            return {}
+
+    monkeypatch.setattr(httpx, "post", lambda *args, **kwargs: FakeResponse())
+
+    with pytest.raises(OpenRouterError, match="Unexpected"):
+        complete([{"role": "user", "content": "hi"}])
+
+
+@pytest.mark.skipif(not os.environ.get("OPENROUTER_API_KEY"), reason="OPENROUTER_API_KEY not set")
+def test_complete_real_2_plus_2() -> None:
+    reply = complete([{"role": "user", "content": "What is 2+2? Answer with just the number."}])
+
+    assert "4" in reply
+
+
+def test_ai_test_route_requires_authentication() -> None:
+    client = TestClient(app)
+
+    response = client.post("/api/ai/test")
+
+    assert response.status_code == 401
+
+
+def test_ai_test_route_returns_502_on_openrouter_error() -> None:
+    client = TestClient(app)
+    client.post("/api/login", json=VALID_CREDENTIALS)
+
+    with patch("app.main.complete", side_effect=OpenRouterError("boom")):
+        response = client.post("/api/ai/test")
+
+    assert response.status_code == 502
diff --git a/backend/tests/test_auth.py b/backend/tests/test_auth.py
new file mode 100644
index 00000000..6cdd3303
--- /dev/null
+++ b/backend/tests/test_auth.py
@@ -0,0 +1,77 @@
+from fastapi import Depends, FastAPI
+from fastapi.testclient import TestClient
+
+from app.auth import SESSION_COOKIE, create_session, require_session
+from app.main import app
+
+VALID_CREDENTIALS = {"username": "user", "password": "password"}
+
+
+def test_login_with_correct_credentials_sets_session_cookie() -> None:
+    client = TestClient(app)
+
+    response = client.post("/api/login", json=VALID_CREDENTIALS)
+
+    assert response.status_code == 200
+    assert SESSION_COOKIE in response.cookies
+
+
+def test_login_with_incorrect_credentials_is_rejected() -> None:
+    client = TestClient(app)
+
+    response = client.post("/api/login", json={"username": "user", "password": "wrong"})
+
+    assert response.status_code == 401
+    assert SESSION_COOKIE not in response.cookies
+
+
+def test_session_persists_across_requests_via_cookie() -> None:
+    client = TestClient(app)
+    client.post("/api/login", json=VALID_CREDENTIALS)
+
+    response = client.get("/api/session")
+
+    assert response.json() == {"authenticated": True}
+
+
+def test_session_is_unauthenticated_without_a_cookie() -> None:
+    client = TestClient(app)
+
+    response = client.get("/api/session")
+
+    assert response.json() == {"authenticated": False}
+
+
+def test_logout_invalidates_the_session() -> None:
+    client = TestClient(app)
+    client.post("/api/login", json=VALID_CREDENTIALS)
+
+    client.post("/api/logout")
+    response = client.get("/api/session")
+
+    assert response.json() == {"authenticated": False}
+
+
+def make_protected_client() -> TestClient:
+    protected_app = FastAPI()
+
+    @protected_app.get("/protected")
+    def protected(_: None = Depends(require_session)) -> dict[str, str]:
+        return {"status": "ok"}
+
+    return TestClient(protected_app)
+
+
+def test_require_session_rejects_requests_without_a_valid_session() -> None:
+    response = make_protected_client().get("/protected")
+
+    assert response.status_code == 401
+
+
+def test_require_session_allows_requests_with_a_valid_session() -> None:
+    client = make_protected_client()
+    client.cookies.set(SESSION_COOKIE, create_session())
+
+    response = client.get("/protected")
+
+    assert response.status_code == 200
diff --git a/backend/tests/test_board.py b/backend/tests/test_board.py
new file mode 100644
index 00000000..31c47a43
--- /dev/null
+++ b/backend/tests/test_board.py
@@ -0,0 +1,145 @@
+from pathlib import Path
+from typing import Iterator
+
+import pytest
+from fastapi.testclient import TestClient
+
+from app.main import app
+
+VALID_CREDENTIALS = {"username": "user", "password": "password"}
+
+
+@pytest.fixture
+def client(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Iterator[TestClient]:
+    monkeypatch.setenv("DATABASE_PATH", str(tmp_path / "test.db"))
+    with TestClient(app) as test_client:
+        test_client.post("/api/login", json=VALID_CREDENTIALS)
+        yield test_client
+
+
+def test_get_board_returns_seeded_data(client: TestClient) -> None:
+    response = client.get("/api/board")
+
+    assert response.status_code == 200
+    body = response.json()
+    assert len(body["columns"]) == 5
+    assert body["columns"][0]["id"] == "col-backlog"
+    assert body["columns"][0]["cardIds"] == ["card-1", "card-2"]
+    assert body["cards"]["card-1"]["title"] == "Align roadmap themes"
+
+
+def test_get_board_requires_authentication(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("DATABASE_PATH", str(tmp_path / "test.db"))
+    with TestClient(app) as unauthenticated_client:
+        response = unauthenticated_client.get("/api/board")
+
+    assert response.status_code == 401
+
+
+def test_rename_column(client: TestClient) -> None:
+    response = client.patch("/api/columns/col-backlog", json={"title": "Triage"})
+
+    assert response.status_code == 200
+    assert response.json()["columns"][0]["title"] == "Triage"
+
+
+def test_rename_unknown_column_is_404(client: TestClient) -> None:
+    response = client.patch("/api/columns/does-not-exist", json={"title": "Triage"})
+
+    assert response.status_code == 404
+
+
+def test_create_card_appends_to_column(client: TestClient) -> None:
+    response = client.post(
+        "/api/cards", json={"column_id": "col-backlog", "title": "New card", "details": "Some notes"}
+    )
+
+    assert response.status_code == 200
+    body = response.json()
+    backlog = next(column for column in body["columns"] if column["id"] == "col-backlog")
+    new_card_id = backlog["cardIds"][-1]
+    assert body["cards"][new_card_id]["title"] == "New card"
+    assert body["cards"][new_card_id]["details"] == "Some notes"
+
+
+def test_create_card_in_unknown_column_is_404(client: TestClient) -> None:
+    response = client.post("/api/cards", json={"column_id": "does-not-exist", "title": "x", "details": ""})
+
+    assert response.status_code == 404
+
+
+def test_update_card_fields(client: TestClient) -> None:
+    response = client.patch(
+        "/api/cards/card-1", json={"title": "Updated title", "details": "Updated details"}
+    )
+
+    assert response.status_code == 200
+    assert response.json()["cards"]["card-1"]["title"] == "Updated title"
+    assert response.json()["cards"]["card-1"]["details"] == "Updated details"
+
+
+def test_update_unknown_card_is_404(client: TestClient) -> None:
+    response = client.patch("/api/cards/does-not-exist", json={"title": "x"})
+
+    assert response.status_code == 404
+
+
+def test_move_card_to_another_column(client: TestClient) -> None:
+    response = client.patch("/api/cards/card-1", json={"column_id": "col-done"})
+
+    assert response.status_code == 200
+    body = response.json()
+    backlog = next(column for column in body["columns"] if column["id"] == "col-backlog")
+    done = next(column for column in body["columns"] if column["id"] == "col-done")
+    assert "card-1" not in backlog["cardIds"]
+    assert done["cardIds"][-1] == "card-1"
+
+
+def test_move_card_to_specific_position_within_column(client: TestClient) -> None:
+    # col-backlog starts as [card-1, card-2]; move card-2 to position 0.
+    response = client.patch("/api/cards/card-2", json={"column_id": "col-backlog", "position": 0})
+
+    assert response.status_code == 200
+    backlog = next(column for column in response.json()["columns"] if column["id"] == "col-backlog")
+    assert backlog["cardIds"] == ["card-2", "card-1"]
+
+
+def test_move_card_to_unknown_column_is_404(client: TestClient) -> None:
+    response = client.patch("/api/cards/card-1", json={"column_id": "does-not-exist"})
+
+    assert response.status_code == 404
+
+
+def test_delete_card(client: TestClient) -> None:
+    response = client.delete("/api/cards/card-1")
+
+    assert response.status_code == 200
+    body = response.json()
+    assert "card-1" not in body["cards"]
+    backlog = next(column for column in body["columns"] if column["id"] == "col-backlog")
+    assert "card-1" not in backlog["cardIds"]
+
+
+def test_delete_unknown_card_is_404(client: TestClient) -> None:
+    response = client.delete("/api/cards/does-not-exist")
+
+    assert response.status_code == 404
+
+
+def test_board_persists_across_reconnects_to_the_same_database(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv("DATABASE_PATH", str(tmp_path / "persist.db"))
+
+    with TestClient(app) as first_client:
+        first_client.post("/api/login", json=VALID_CREDENTIALS)
+        first_client.post(
+            "/api/cards", json={"column_id": "col-backlog", "title": "Persisted card", "details": ""}
+        )
+
+    with TestClient(app) as second_client:
+        second_client.post("/api/login", json=VALID_CREDENTIALS)
+        response = second_client.get("/api/board")
+
+    titles = [card["title"] for card in response.json()["cards"].values()]
+    assert "Persisted card" in titles
diff --git a/backend/tests/test_chat.py b/backend/tests/test_chat.py
new file mode 100644
index 00000000..9a977469
--- /dev/null
+++ b/backend/tests/test_chat.py
@@ -0,0 +1,210 @@
+import os
+from pathlib import Path
+from typing import Iterator
+from unittest.mock import patch
+
+import pytest
+from fastapi.testclient import TestClient
+
+from app.ai import OpenRouterError
+from app.chat import InvalidBoardUpdate, parse_board_update
+from app.main import app
+
+VALID_CREDENTIALS = {"username": "user", "password": "password"}
+
+
+@pytest.fixture
+def client(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Iterator[TestClient]:
+    monkeypatch.setenv("DATABASE_PATH", str(tmp_path / "test.db"))
+    with TestClient(app) as test_client:
+        test_client.post("/api/login", json=VALID_CREDENTIALS)
+        yield test_client
+
+
+# --- parse_board_update / validation ---
+
+
+def test_parse_board_update_returns_none_for_none() -> None:
+    assert parse_board_update(None) is None
+
+
+def test_parse_board_update_accepts_a_valid_update() -> None:
+    raw = {
+        "columns": [{"id": "col-a", "title": "A", "cardIds": ["card-1"]}],
+        "cards": [{"id": "card-1", "title": "Card 1", "details": ""}],
+    }
+
+    board = parse_board_update(raw)
+
+    assert board is not None
+    assert board.columns[0].id == "col-a"
+    assert board.cards["card-1"].title == "Card 1"
+
+
+def test_parse_board_update_rejects_malformed_shape() -> None:
+    with pytest.raises(InvalidBoardUpdate):
+        parse_board_update({"columns": [{"id": "col-a"}], "cards": []})
+
+
+def test_parse_board_update_rejects_duplicate_column_ids() -> None:
+    raw = {
+        "columns": [
+            {"id": "col-a", "title": "A", "cardIds": []},
+            {"id": "col-a", "title": "A again", "cardIds": []},
+        ],
+        "cards": [],
+    }
+
+    with pytest.raises(InvalidBoardUpdate, match="Duplicate column"):
+        parse_board_update(raw)
+
+
+def test_parse_board_update_rejects_card_referenced_by_two_columns() -> None:
+    raw = {
+        "columns": [
+            {"id": "col-a", "title": "A", "cardIds": ["card-1"]},
+            {"id": "col-b", "title": "B", "cardIds": ["card-1"]},
+        ],
+        "cards": [{"id": "card-1", "title": "Card 1", "details": ""}],
+    }
+
+    with pytest.raises(InvalidBoardUpdate, match="more than one column"):
+        parse_board_update(raw)
+
+
+def test_parse_board_update_rejects_dangling_card_reference() -> None:
+    raw = {"columns": [{"id": "col-a", "title": "A", "cardIds": ["card-missing"]}], "cards": []}
+
+    with pytest.raises(InvalidBoardUpdate, match="disagree"):
+        parse_board_update(raw)
+
+
+def test_parse_board_update_rejects_orphaned_card() -> None:
+    raw = {
+        "columns": [{"id": "col-a", "title": "A", "cardIds": []}],
+        "cards": [{"id": "card-1", "title": "Card 1", "details": ""}],
+    }
+
+    with pytest.raises(InvalidBoardUpdate, match="disagree"):
+        parse_board_update(raw)
+
+
+# --- route (mocked OpenRouter call) ---
+
+
+def test_chat_requires_authentication() -> None:
+    response = TestClient(app).post("/api/chat", json={"message": "hi"})
+
+    assert response.status_code == 401
+
+
+def test_chat_reply_only_leaves_board_unchanged(client: TestClient) -> None:
+    board_before = client.get("/api/board").json()
+
+    with patch(
+        "app.main.request_chat_completion", return_value={"reply": "Hi there!", "board_update": None}
+    ):
+        response = client.post("/api/chat", json={"message": "hello"})
+
+    assert response.status_code == 200
+    body = response.json()
+    assert body["reply"] == "Hi there!"
+    assert body["board"] == board_before
+
+
+def test_chat_applies_a_valid_board_update(client: TestClient) -> None:
+    board_before = client.get("/api/board").json()
+    first_column_id = board_before["columns"][0]["id"]
+    updated_board = {"columns": [{"id": first_column_id, "title": "Renamed by AI", "cardIds": []}], "cards": []}
+
+    with patch(
+        "app.main.request_chat_completion",
+        return_value={"reply": "Done!", "board_update": updated_board},
+    ):
+        response = client.post("/api/chat", json={"message": "rename the first column"})
+
+    assert response.status_code == 200
+    body = response.json()
+    assert body["reply"] == "Done!"
+    assert body["board"]["columns"] == [{"id": first_column_id, "title": "Renamed by AI", "cardIds": []}]
+
+    board_after = client.get("/api/board").json()
+    assert board_after["columns"][0]["title"] == "Renamed by AI"
+
+
+def test_chat_ignores_an_invalid_board_update(client: TestClient) -> None:
+    board_before = client.get("/api/board").json()
+    invalid_update = {"columns": [{"id": "col-x", "title": "X", "cardIds": ["card-missing"]}], "cards": []}
+
+    with patch(
+        "app.main.request_chat_completion",
+        return_value={"reply": "I moved it!", "board_update": invalid_update},
+    ):
+        response = client.post("/api/chat", json={"message": "do something"})
+
+    assert response.status_code == 200
+    body = response.json()
+    assert body["reply"] == "I moved it!"
+    assert body["board"] == board_before
+
+
+def test_chat_returns_502_on_openrouter_error(client: TestClient) -> None:
+    with patch("app.main.request_chat_completion", side_effect=OpenRouterError("boom")):
+        response = client.post("/api/chat", json={"message": "hi"})
+
+    assert response.status_code == 502
+
+
+def test_chat_accumulates_conversation_history(client: TestClient) -> None:
+    captured_histories = []
+
+    def fake_request(board, history, message):
+        captured_histories.append(list(history))
+        return {"reply": f"echo: {message}", "board_update": None}
+
+    with patch("app.main.request_chat_completion", side_effect=fake_request):
+        client.post("/api/chat", json={"message": "first"})
+        client.post("/api/chat", json={"message": "second"})
+
+    assert captured_histories[0] == []
+    assert captured_histories[1] == [
+        {"role": "user", "content": "first"},
+        {"role": "assistant", "content": "echo: first"},
+    ]
+
+
+# --- real OpenRouter integration ---
+
+
+@pytest.mark.skipif(not os.environ.get("OPENROUTER_API_KEY"), reason="OPENROUTER_API_KEY not set")
+def test_chat_real_question_does_not_change_board(client: TestClient) -> None:
+    board_before = client.get("/api/board").json()
+
+    response = client.post(
+        "/api/chat", json={"message": "What is this app for? Just answer, don't change anything."}
+    )
+
+    assert response.status_code == 200
+    body = response.json()
+    assert body["reply"]
+    assert body["board"] == board_before
+
+
+@pytest.mark.skipif(not os.environ.get("OPENROUTER_API_KEY"), reason="OPENROUTER_API_KEY not set")
+def test_chat_real_instruction_moves_a_card(client: TestClient) -> None:
+    board_before = client.get("/api/board").json()
+    first_card_id = next(iter(board_before["cards"]))
+    first_card_title = board_before["cards"][first_card_id]["title"]
+
+    response = client.post(
+        "/api/chat", json={"message": f'Move the card titled "{first_card_title}" to the Done column.'}
+    )
+
+    assert response.status_code == 200
+    body = response.json()
+    done_column = next(c for c in body["board"]["columns"] if c["title"] == "Done")
+    assert first_card_id in done_column["cardIds"]
+
+    board_after = client.get("/api/board").json()
+    done_column_after = next(c for c in board_after["columns"] if c["title"] == "Done")
+    assert first_card_id in done_column_after["cardIds"]
diff --git a/backend/tests/test_health.py b/backend/tests/test_health.py
new file mode 100644
index 00000000..48a2a047
--- /dev/null
+++ b/backend/tests/test_health.py
@@ -0,0 +1,19 @@
+from fastapi.testclient import TestClient
+
+from app.main import app
+
+client = TestClient(app)
+
+
+def test_health_returns_ok() -> None:
+    response = client.get("/api/health")
+
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+
+
+def test_root_serves_placeholder_page() -> None:
+    response = client.get("/")
+
+    assert response.status_code == 200
+    assert "Hello world" in response.text
diff --git a/backend/tests/test_static_routing.py b/backend/tests/test_static_routing.py
new file mode 100644
index 00000000..be7173e0
--- /dev/null
+++ b/backend/tests/test_static_routing.py
@@ -0,0 +1,54 @@
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from app.main import NextStaticFiles
+
+
+def make_client(static_dir: Path) -> TestClient:
+    app = FastAPI()
+    app.mount("/", NextStaticFiles(directory=static_dir, html=True), name="static")
+    return TestClient(app)
+
+
+def test_serves_index_at_root(tmp_path: Path) -> None:
+    (tmp_path / "index.html").write_text("<h1>Board</h1>")
+
+    response = make_client(tmp_path).get("/")
+
+    assert response.status_code == 200
+    assert "Board" in response.text
+
+
+def test_resolves_unmatched_path_to_its_prerendered_html_file(tmp_path: Path) -> None:
+    (tmp_path / "index.html").write_text("<h1>Board</h1>")
+    (tmp_path / "login.html").write_text("<h1>Login</h1>")
+
+    response = make_client(tmp_path).get("/login")
+
+    assert response.status_code == 200
+    assert "Login" in response.text
+
+
+def test_html_file_wins_over_a_same_named_directory(tmp_path: Path) -> None:
+    """Next's static export writes both `login.html` and a `login/` dir of
+    RSC prefetch data (no `index.html` inside) for a route named `login`."""
+    (tmp_path / "index.html").write_text("<h1>Board</h1>")
+    (tmp_path / "login.html").write_text("<h1>Login</h1>")
+    login_dir = tmp_path / "login"
+    login_dir.mkdir()
+    (login_dir / "__next.login.txt").write_text("rsc data, not a page")
+
+    response = make_client(tmp_path).get("/login")
+
+    assert response.status_code == 200
+    assert "Login" in response.text
+
+
+def test_path_with_no_matching_html_file_is_404(tmp_path: Path) -> None:
+    (tmp_path / "index.html").write_text("<h1>Board</h1>")
+
+    response = make_client(tmp_path).get("/does-not-exist")
+
+    assert response.status_code == 404
diff --git a/backend/uv.lock b/backend/uv.lock
new file mode 100644
index 00000000..0d960554
--- /dev/null
+++ b/backend/uv.lock
@@ -0,0 +1,650 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.14.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", hash = "sha256:cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f", size = 260176, upload-time = "2026-07-12T20:29:07.082Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", hash = "sha256:9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494", size = 125813, upload-time = "2026-07-12T20:29:05.763Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.7.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/d4/81420972a676e8ffea40450d8c8c92943e7218a78fe9b64359836cc9876b/click-8.4.2.tar.gz", hash = "sha256:9a6cea6e60b17ebe0a44c5cc636d94f09bd66142c1cd7d8b4cd731c4917a15f6", size = 338000, upload-time = "2026-06-24T17:45:15.148Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl", hash = "sha256:e6f9f66136c816745b9d65817da91d61d957fb16e02e4dcd0552553c5a197b76", size = 119243, upload-time = "2026-06-24T17:45:13.73Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.141.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8a/02/91e3416a8fdd715abb903a952a6bec7cdd8d14eed55d415fc8595524c319/fastapi-0.141.1.tar.gz", hash = "sha256:e8822fc40db1e1858054d7a949a888695bc9bdce70139178e33bd2871a453ca1", size = 425799, upload-time = "2026-07-29T17:18:05.568Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/03/10388a42375ee7e4ac9b94eb2c5c569c8b5795e377e701c9ac3ad63de890/fastapi-0.141.1-py3-none-any.whl", hash = "sha256:bfb91aa2d334c61cb35ba9a116fc123b3d3df31640b801cf57a7a78ec3f603b3", size = 131954, upload-time = "2026-07-29T17:18:04.364Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httptools"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/e5/d471fcb0e14523fe1c3f4ba58ca52480e7bd70ad7109a3846bc75892f7fb/httptools-0.8.0.tar.gz", hash = "sha256:6b2a32f18d97e16e90827d7a819ffa8dbd8cc245fc4e1fa9d1095b54ef4bd999", size = 271342, upload-time = "2026-05-25T22:17:48.841Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/88/1d21a36da8f5cb0fa49eafd4b169eba5608d57e75bbcf61845cbc6243216/httptools-0.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:880490234c10f70a9830743097e8958d6e4b9f5a0ffc24515023afeef984054d", size = 208247, upload-time = "2026-05-25T22:17:07.843Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/42/cc4feea2945cb3051038f090c9b36bd5b8a9d7f5a894a506a8983e33fd1c/httptools-0.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5931891fb7b441b8a3853cf1b85c82c903defce084dd5f6771ca46e31bf862c5", size = 113064, upload-time = "2026-05-25T22:17:09.136Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/a6/febbb8b8db0f58b38e44ad6cb946e6a255ae49b55f2e8543408fb7501ccd/httptools-0.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b15fc622b0f869d19207c4089a501d9bcc63ca5e071ffdd2f03f922df882dcb2", size = 523851, upload-time = "2026-05-25T22:17:10.106Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/e4/f90a0df0b83beff265b7e3b65f2a4cefd95792d4be0ac3e16049f2acd3c2/httptools-0.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:425f83884fd6343828d8c565f046cb72b6d19063f6924093e11bcd8e1548cd09", size = 518842, upload-time = "2026-05-25T22:17:11.218Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/2d/0c9ac76dd2c893841fbf6498d6acec4f2442e1b7067f6e3e316a80e494e8/httptools-0.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ef7c3c97f4311c7be57e2986629df89d49cb434dbff78eafcd48c2bff986b15a", size = 501238, upload-time = "2026-05-25T22:17:12.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/42/906adc91ae3a5fa9c59c0a2f21c139725bd7e5b41ae6acd485cd14123ebf/httptools-0.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a1afd7c9fbff0d9f5d489c4ce2768bd09c84a46ddefc7161e6aa82ae35c85745", size = 509567, upload-time = "2026-05-25T22:17:13.842Z" },
+    { url = "https://files.pythonhosted.org/packages/05/0b/4240efeb672751ee5b9b380cb0e3fdc050bc05f68adc7a8aefc4fcd9a69a/httptools-0.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:cd96f29b4bab1d42fa6e3d008711c75e0f79e94e06827330160e3a304227f150", size = 90918, upload-time = "2026-05-25T22:17:15.155Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/e5/8cfcabc5546e8022f168be28bcdaa128a240a0befdd03b59d558b4f18bd6/httptools-0.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:614ceea8ea606848bece2338ac03b3ce5324bcb4be8dc7d377ed708012fa4db8", size = 205148, upload-time = "2026-05-25T22:17:16.333Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/0e/0fb14848c19a686c8062ff9067c1a48793e3224b47bc5b201535b6036fce/httptools-0.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2d689918c15a013c65ef52d9fd495d766893ab831a2c8d89f2ac5940a5df847c", size = 111368, upload-time = "2026-05-25T22:17:17.586Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/46f1cecf06b9bbde8e4b8c88034ac7908989e5ff7a3a388ef38392949c1f/httptools-0.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:eb3028cca2fc0a6d720e52ef61d8ebb62fcbfeb1de56874546d858d3f25a26b7", size = 486447, upload-time = "2026-05-25T22:17:18.564Z" },
+    { url = "https://files.pythonhosted.org/packages/77/00/258bfc0837221f81d9725c45f9b948a6a6b2994a147a4fb66e85100c668f/httptools-0.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:88bdd940f2b5d487b4d032c6afa5489a7dc4694410d43de3c38c4fb3af0dc45d", size = 482448, upload-time = "2026-05-25T22:17:19.912Z" },
+    { url = "https://files.pythonhosted.org/packages/04/ab/d1cef3b5523f4d272a70f42a776c3169a2dddfe3a54de4b2ce4a36341528/httptools-0.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6a43c9dd399758ccc0531acb0a3c4a6c299ee893ee9400e9c893b7bdcfae0681", size = 464460, upload-time = "2026-05-25T22:17:20.882Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/48/5d1d072442277bb2b3434e0e60690b8e8c23840ef7de8b6ea54040a536d3/httptools-0.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0770728beb05094c809b98e814edff5fef69d26ad7d21185f2f6d5884a0ba683", size = 471312, upload-time = "2026-05-25T22:17:22.085Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/66/b96623b27e51a68199ef4efdda0613cced9233fe3062ac74e50749c5ad37/httptools-0.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:7685df791fad561384bfb139e77fde27a1ffd93134e016f95a0db424ffbf77b1", size = 90117, upload-time = "2026-05-25T22:17:23.074Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/12/fa3fbf5f9517b273edea2dc982aa82a8c634091e67c590792b729017bc6f/httptools-0.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:de242a49b5d18e0a8776e654e9f6bf6d89f3875a5c35b425a0e7ce940feb3fd6", size = 206183, upload-time = "2026-05-25T22:17:24.004Z" },
+    { url = "https://files.pythonhosted.org/packages/30/fc/5e7c4cb443370f2090a3aba0453a07384d29ff66b7435bb90e77e1037599/httptools-0.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:159e9ab5f701ccd42e555a12f1ad8ff69702910fc1c996cf2bb66e5fcb7a231b", size = 112079, upload-time = "2026-05-25T22:17:25.216Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/53/771bd891eb0f236f32145d6a1775777ec85745f3cc983a1f23d1a3b8ddfe/httptools-0.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c4a9f1707e4823d54dfec6c33fa3697d302aed536ed352a7ebb5a061ddb869d0", size = 481596, upload-time = "2026-05-25T22:17:26.186Z" },
+    { url = "https://files.pythonhosted.org/packages/62/42/94e15bc68ce3d423243c45d7f1b0c7561f13844f97dc52ae23182fb65628/httptools-0.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d76ad7b951387e3632c8716a9bb03ac5b45c5f16119aa409db0459520887944e", size = 480865, upload-time = "2026-05-25T22:17:27.542Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/7c/fe2980fc03723272e30f135b62360b075f513dfe7cc73aef36c7f04012bd/httptools-0.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a3b7387147361c3fd47a0bde763c5c91b5b4cd4dc9989b8ece84ff436c99843b", size = 463189, upload-time = "2026-05-25T22:17:28.546Z" },
+    { url = "https://files.pythonhosted.org/packages/15/1b/47fc5fff68acd1bfa20b4734059c9a06cadb88119dcd5258b5b0d21d91c8/httptools-0.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f256d6ce930c52ca1cb2a960b7da03548c454e7d28b06059ad41bfe789036ce0", size = 466610, upload-time = "2026-05-25T22:17:29.816Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bd/07b13c93ffd9bec9546e0d43f8e19378dd696dbd278511406bc07371ef1f/httptools-0.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:19d1ee275bb59ba2643ba9a3a1e51cc0c788caf2b8df506368e03f56fdd08527", size = 92705, upload-time = "2026-05-25T22:17:31.133Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/c4/121648f68ce066d7bd762d6b6d97e620847642d38d54f3d90ff11d947629/httptools-0.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:de1ed58a974e75d56560acc7e7fed01a454994429456f65209789992e41f2568", size = 215023, upload-time = "2026-05-25T22:17:32.401Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/b0/312a062ae741ae3e8baa8c8bf20be81b2e67337b259ab4349bebc7b6142e/httptools-0.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e93c227b595c6926c1acee96891dd9da4be338cfbe82e5cd3bb9d8dd7dc4ac0b", size = 117405, upload-time = "2026-05-25T22:17:33.742Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/37/fccd705f795386bb05bf413012fecff2a33e5aa8c2f069096de3e9fd8702/httptools-0.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2a021c3a8e65cc125390d72f59b968afca3bdcaff25bd67965e0a055a14946ca", size = 558497, upload-time = "2026-05-25T22:17:34.732Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/39/f172e8003576de35f5ba77ff417cf0e34429d35dc014deef15afa337a72c/httptools-0.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48774d39cbb70e2b1f71f88852a3087ae1d3a1eb80482bb48c13067ab080c14f", size = 571585, upload-time = "2026-05-25T22:17:35.813Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/b9/f5564760af99f3dbbf3f9104dc00e5da27e96cf433c6bdcf77617f70bf3f/httptools-0.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:88eead8ec8680a9f146c655bc88445a325bd7921cfd8194c7337e9467282427d", size = 543297, upload-time = "2026-05-25T22:17:37.08Z" },
+    { url = "https://files.pythonhosted.org/packages/99/67/8d9f2c313618e161b82f3873188e7196126da1d6e29688df40eb3997c77a/httptools-0.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2c032fa028f46871ec7e1fc59fc15e8023eab3e6bbe6ece786a1611719a5d081", size = 539535, upload-time = "2026-05-25T22:17:38.032Z" },
+    { url = "https://files.pythonhosted.org/packages/48/63/b906c01e53f50d432c0defe43ce52764a111dc1bdd028bafbeb54dcfd008/httptools-0.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:384c17174464c8e873398b7af24f0b1f44d992c820328413951a625323155d77", size = 108209, upload-time = "2026-05-25T22:17:39.473Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pm-backend"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "fastapi" },
+    { name = "httpx" },
+    { name = "python-dotenv" },
+    { name = "uvicorn", extra = ["standard"] },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "fastapi", specifier = ">=0.141.1" },
+    { name = "httpx", specifier = ">=0.28.1" },
+    { name = "python-dotenv", specifier = ">=1.2.2" },
+    { name = "uvicorn", extras = ["standard"], specifier = ">=0.52.1" },
+]
+
+[package.metadata.requires-dev]
+dev = [{ name = "pytest", specifier = ">=9.1.1" }]
+
+[[package]]
+name = "pydantic"
+version = "2.13.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fd/7b/122376b1fd3c62c1ed9dc80c931ace4844b3c55407b6fb2d199377c9736f/pydantic-2.13.4-py3-none-any.whl", hash = "sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba", size = 472262, upload-time = "2026-05-06T13:43:02.641Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.46.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/8c/af022f0af448d7747c5154288d46b5f2bc5f17366eaa0e23e9aa04d59f3b/pydantic_core-2.46.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2", size = 2106158, upload-time = "2026-05-06T13:38:57.215Z" },
+    { url = "https://files.pythonhosted.org/packages/19/95/6195171e385007300f0f5574592e467c568becce2d937a0b6804f218bc49/pydantic_core-2.46.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f", size = 1951724, upload-time = "2026-05-06T13:37:02.697Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/bc/f47d1ff9cbb1620e1b5b697eef06010035735f07820180e74178226b27b3/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7", size = 1975742, upload-time = "2026-05-06T13:37:09.448Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/11/9b9a5b0306345664a2da6410877af6e8082481b5884b3ddd78d47c6013ce/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7", size = 2052418, upload-time = "2026-05-06T13:37:38.234Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/b7/a65fec226f5d78fc39f4a13c4cc0c768c22b113438f60c14adc9d2865038/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712", size = 2232274, upload-time = "2026-05-06T13:38:27.753Z" },
+    { url = "https://files.pythonhosted.org/packages/68/f0/92039db98b907ef49269a8271f67db9cb78ae2fc68062ef7e4e77adb5f61/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4", size = 2309940, upload-time = "2026-05-06T13:38:05.353Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/97/2aab507d3d00ca626e8e57c1eac6a79e4e5fbcc63eb99733ff55d1717f65/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce", size = 2094516, upload-time = "2026-05-06T13:39:10.577Z" },
+    { url = "https://files.pythonhosted.org/packages/22/37/a8aca44d40d737dde2bc05b3c6c07dff0de07ce6f82e9f3167aeaf4d5dea/pydantic_core-2.46.4-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987", size = 2136854, upload-time = "2026-05-06T13:40:22.59Z" },
+    { url = "https://files.pythonhosted.org/packages/24/99/fcef1b79238c06a8cbec70819ac722ba76e02bc8ada9b0fd66eba40da01b/pydantic_core-2.46.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b", size = 2180306, upload-time = "2026-05-06T13:40:10.666Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/6c/fc44000918855b42779d007ae63b0532794739027b2f417321cddbc44f6a/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458", size = 2190044, upload-time = "2026-05-06T13:40:43.231Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/65/d9cadc9f1920d7a127ad2edba16c1db7916e59719285cd6c94600b0080ba/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b", size = 2329133, upload-time = "2026-05-06T13:39:57.365Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/cf/c873d91679f3a30bcf5e7ac280ce5573483e72295307685120d0d5ad3416/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c", size = 2374464, upload-time = "2026-05-06T13:38:06.976Z" },
+    { url = "https://files.pythonhosted.org/packages/47/bd/6f2fc8188f31bf10590f1e98e7b306336161fac930a8c514cd7bd828c7dc/pydantic_core-2.46.4-cp312-cp312-win32.whl", hash = "sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894", size = 1974823, upload-time = "2026-05-06T13:40:47.985Z" },
+    { url = "https://files.pythonhosted.org/packages/40/8c/985c1d41ea1107c2534abd9870e4ed5c8e7669b5c308297835c001e7a1c4/pydantic_core-2.46.4-cp312-cp312-win_amd64.whl", hash = "sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89", size = 2072919, upload-time = "2026-05-06T13:39:21.153Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ba/f463d006e0c47373ca7ec5e1a261c59dc01ef4d62b2657af925fb0deee3a/pydantic_core-2.46.4-cp312-cp312-win_arm64.whl", hash = "sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a", size = 2027604, upload-time = "2026-05-06T13:39:03.753Z" },
+    { url = "https://files.pythonhosted.org/packages/51/a2/5d30b469c5267a17b39dec53208222f76a8d351dfac4af661888c5aee77d/pydantic_core-2.46.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008", size = 2106306, upload-time = "2026-05-06T13:37:48.029Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/81/4fa520eaffa8bd7d1525e644cd6d39e7d60b1592bc5b516693c7340b50f1/pydantic_core-2.46.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4", size = 1951906, upload-time = "2026-05-06T13:37:17.012Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d5/fd02da45b659668b05923b17ba3a0100a0a3d5541e3bd8fcc4ecb711309e/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76", size = 1976802, upload-time = "2026-05-06T13:37:35.113Z" },
+    { url = "https://files.pythonhosted.org/packages/21/f2/95727e1368be3d3ed485eaab7adbd7dda408f33f7a36e8b48e0144002b91/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e739fee756ba1010f8bcccb534252e85a35fe45ae92c295a06059ce58b74ccd3", size = 2052446, upload-time = "2026-05-06T13:37:12.313Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/86/5d99feea3f77c7234b8718075b23db11532773c1a0dbd9b9490215dc2eeb/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d56801be94b86a9da183e5f3766e6310752b99ff647e38b09a9500d88e46e76", size = 2232757, upload-time = "2026-05-06T13:39:01.149Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/3a/508ac615935ef7588cf6d9e9b91309fdc2da751af865e02a9098de88258c/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2412e734dcb48da14d4e4006b82b46b74f2518b8a26ee7e58c6844a6cd6d03c4", size = 2309275, upload-time = "2026-05-06T13:37:41.406Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f8/41db9de19d7987d6b04715a02b3b40aea467000275d9d758ffaa31af7d50/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9551187363ffc0de2a00b2e47c25aeaeb1020b69b668762966df15fc5659dd5a", size = 2094467, upload-time = "2026-05-06T13:39:18.847Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/e2/f35033184cb11d0052daf4416e8e10a502ea2ac006fc4f459aee872727d1/pydantic_core-2.46.4-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0186750b482eefa11d7f435892b09c5c606193ef3375bcf94aa00ae6bfb66262", size = 2134417, upload-time = "2026-05-06T13:40:17.944Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/7b/6ceeb1cc90e193862f444ebe373d8fdf613f0a82572dde03fb10734c6c71/pydantic_core-2.46.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5855698a4856556d86e8e6cd8434bc3ac0314ee8e12089ae0e143f64c6256e4e", size = 2179782, upload-time = "2026-05-06T13:40:32.618Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f2/c8d7773ede6af08036423a00ae0ceffce266c3c52a096c435d68c896083f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:cbaf13819775b7f769bf4a1f066cb6df7a28d4480081a589828ef190226881cd", size = 2188782, upload-time = "2026-05-06T13:36:51.018Z" },
+    { url = "https://files.pythonhosted.org/packages/59/31/0c864784e31f09f05cdd87606f08923b9c9e7f6e51dd27f20f62f975ce9f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:633147d34cf4550417f12e2b1a0383973bdf5cdfde212cb09e9a581cf10820be", size = 2328334, upload-time = "2026-05-06T13:40:37.764Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/eb/4f6c8a41efa30baa755590f4141abf3a8c370fab610915733e74134a7270/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:82cf5301172168103724d49a1444d3378cb20cdee30b116a1bd6031236298a5d", size = 2372986, upload-time = "2026-05-06T13:39:34.152Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/24/b375a480d53113860c299764bfe9f349a3dc9108b3adc0d7f0d786492ebf/pydantic_core-2.46.4-cp313-cp313-win32.whl", hash = "sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb", size = 1973693, upload-time = "2026-05-06T13:37:55.072Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/e8/cff247591966f2d22ec8c003cd7587e27b7ba7b81ab2fb888e3ab75dc285/pydantic_core-2.46.4-cp313-cp313-win_amd64.whl", hash = "sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292", size = 2071819, upload-time = "2026-05-06T13:38:49.139Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/1a/f4aee670d5670e9e148e0c82c7db98d780be566c6e6a97ee8035528ca0b3/pydantic_core-2.46.4-cp313-cp313-win_arm64.whl", hash = "sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d", size = 2027411, upload-time = "2026-05-06T13:40:45.796Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/74/228a26ddad29c6672b805d9fd78e8d251cd04004fa7eed0e622096cd0250/pydantic_core-2.46.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:428e04521a40150c85216fc8b85e8d39fece235a9cf5e383761238c7fa9b96fb", size = 2102079, upload-time = "2026-05-06T13:38:41.019Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/1f/8970b150a4b4365623ae00fc88603491f763c627311ae8031e3111356d6e/pydantic_core-2.46.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23ace664830ee0bfe014a0c7bc248b1f7f25ed7ad103852c317624a1083af462", size = 1952179, upload-time = "2026-05-06T13:36:59.812Z" },
+    { url = "https://files.pythonhosted.org/packages/95/30/5211a831ae054928054b2f79731661087a2bc5c01e825c672b3a4a8f1b3e/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce5c1d2a8b27468f433ca974829c44060b8097eedc39933e3c206a90ee49c4a9", size = 1978926, upload-time = "2026-05-06T13:37:39.933Z" },
+    { url = "https://files.pythonhosted.org/packages/57/e9/689668733b1eb67adeef047db3c2e8788fcf65a7fd9c9e2b46b7744fe245/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7283d57845ecf5a163403eb0702dfc220cc4fbdd18919cb5ccea4f95ee1cdab4", size = 2046785, upload-time = "2026-05-06T13:38:01.995Z" },
+    { url = "https://files.pythonhosted.org/packages/60/d9/6715260422ff50a2109878fd24d948a6c3446bb2664f34ee78cd972b3acd/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8daafc69c93ee8a0204506a3b6b30f586ef54028f52aeeeb5c4cfc5184fd5914", size = 2228733, upload-time = "2026-05-06T13:40:50.371Z" },
+    { url = "https://files.pythonhosted.org/packages/18/ae/fdb2f64316afca925640f8e70bb1a564b0ec2721c1389e25b8eb4bf9a299/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd2213145bcc2ba85884d0ac63d222fece9209678f77b9b4d76f054c561adb28", size = 2307534, upload-time = "2026-05-06T13:37:21.531Z" },
+    { url = "https://files.pythonhosted.org/packages/89/1d/8eff589b45bb8190a9d12c49cfad0f176a5cbd1534908a6b5125e2886239/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a5f930472650a82629163023e630d160863fce524c616f4e5186e5de9d9a49b", size = 2099732, upload-time = "2026-05-06T13:39:31.942Z" },
+    { url = "https://files.pythonhosted.org/packages/06/d5/ee5a3366637fee41dee51a1fc91562dcf12ddbc68fda34e6b253da2324bb/pydantic_core-2.46.4-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:c1b3f518abeca3aa13c712fd202306e145abf59a18b094a6bafb2d2bbf59192c", size = 2129627, upload-time = "2026-05-06T13:37:25.033Z" },
+    { url = "https://files.pythonhosted.org/packages/94/33/2414be571d2c6a6c4d08be21f9292b6d3fdb08949a97b6dfe985017821db/pydantic_core-2.46.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a7dd0b3ee80d90150e3495a3a13ac34dbcbfd4f012996a6a1d8900e91b5c0fb", size = 2179141, upload-time = "2026-05-06T13:37:14.046Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/79/7daa95be995be0eecc4cf75064cb33f9bbbfe3fe0158caf2f0d4a996a5c7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:3fb702cd90b0446a3a1c5e470bfa0dd23c0233b676a9099ddcc964fa6ca13898", size = 2184325, upload-time = "2026-05-06T13:36:53.615Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/cb/d0a382f5c0de8a222dc61c65348e0ce831b1f68e0a018450d31c2cace3a5/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b8458003118a712e66286df6a707db01c52c0f52f7db8e4a38f0da1d3b94fc4e", size = 2323990, upload-time = "2026-05-06T13:40:29.971Z" },
+    { url = "https://files.pythonhosted.org/packages/05/db/d9ba624cc4a5aced1598e88c04fdbd8310c8a69b9d38b9a3d39ce3a61ed7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:372429a130e469c9cd698925ce5fc50940b7a1336b0d82038e63d5bbc4edc519", size = 2369978, upload-time = "2026-05-06T13:37:23.027Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/20/d15df15ba918c423461905802bfd2981c3af0bfa0e40d05e13edbfa48bc3/pydantic_core-2.46.4-cp314-cp314-win32.whl", hash = "sha256:85bb3611ff1802f3ee7fdd7dbff26b56f343fb432d57a4728fdd49b6ef35e2f4", size = 1966354, upload-time = "2026-05-06T13:38:03.499Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/b6/6b8de4c0a7d7ab3004c439c80c5c1e0a3e8d78bbae19379b01960383d9e5/pydantic_core-2.46.4-cp314-cp314-win_amd64.whl", hash = "sha256:811ff8e9c313ab425368bcbb36e5c4ebd7108c2bbf4e4089cfbb0b01eff63fac", size = 2072238, upload-time = "2026-05-06T13:39:40.807Z" },
+    { url = "https://files.pythonhosted.org/packages/32/36/51eb763beec1f4cf59b1db243a7dcc39cbb41230f050a09b9d69faaf0a48/pydantic_core-2.46.4-cp314-cp314-win_arm64.whl", hash = "sha256:bfec22eab3c8cc2ceec0248aec886624116dc079afa027ecc8ad4a7e62010f8a", size = 2018251, upload-time = "2026-05-06T13:37:26.72Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/91/855af51d625b23aa987116a19e231d2aaef9c4a415273ddc189b79a45fee/pydantic_core-2.46.4-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:af8244b2bef6aaad6d92cda81372de7f8c8d36c9f0c3ea36e827c60e7d9467a0", size = 2099593, upload-time = "2026-05-06T13:39:47.682Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/1b/8784a54c65edb5f49f0a14d6977cf1b209bba85a4c77445b255c2de58ab3/pydantic_core-2.46.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a4330cdbc57162e4b3aa303f588ba752257694c9c9be3e7ebb11b4aca659b5d", size = 1935226, upload-time = "2026-05-06T13:40:40.428Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/e7/1955d28d1afc56dd4b3ad7cc0cf39df1b9852964cf16e5d13912756d6d6b/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29c61fc04a3d840155ff08e475a04809278972fe6aef51e2720554e96367e34b", size = 1974605, upload-time = "2026-05-06T13:37:32.029Z" },
+    { url = "https://files.pythonhosted.org/packages/93/e2/3fedbf0ba7a22850e6e9fd78117f1c0f10f950182344d8a6c535d468fdd8/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c50f2528cf200c5eed56faf3f4e22fcd5f38c157a8b78576e6ba3168ec35f000", size = 2030777, upload-time = "2026-05-06T13:38:55.239Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/61/46be275fcaaba0b4f5b9669dd852267ce1ff616592dccf7a7845588df091/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0cbe8b01f948de4286c74cdd6c667aceb38f5c1e26f0693b3983d9d74887c65e", size = 2236641, upload-time = "2026-05-06T13:37:08.096Z" },
+    { url = "https://files.pythonhosted.org/packages/60/db/12e93e46a8bac9988be3c016860f83293daea8c716c029c9ace279036f2f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:617d7e2ca7dcb8c5cf6bcb8c59b8832c94b36196bbf1cbd1bfb56ed341905edd", size = 2286404, upload-time = "2026-05-06T13:40:20.221Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/4a/4d8b19008f38d31c53b8219cfedc2e3d5de5fe99d90076b7e767de29274f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7027560ee92211647d0d34e3f7cd6f50da56399d26a9c8ad0da286d3869a53f3", size = 2109219, upload-time = "2026-05-06T13:38:12.153Z" },
+    { url = "https://files.pythonhosted.org/packages/88/70/3cbc40978fefb7bb09c6708d40d4ad1a5d70fd7213c3d17f971de868ec1f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:f99626688942fb746e545232e7726926f3be91b5975f8b55327665fafda991c7", size = 2110594, upload-time = "2026-05-06T13:40:02.971Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/20/b8d36736216e29491125531685b2f9e61aa5b4b2599893f8268551da3338/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fc3e9034a63de20e15e8ade85358bc6efc614008cab72898b4b4952bea0509ff", size = 2159542, upload-time = "2026-05-06T13:39:27.506Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/a2/367df868eb584dacf6bf82a389272406d7178e301c4ac82545ab98bc2dd9/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:97e7cf2be5c77b7d1a9713a05605d49460d02c6078d38d8bef3cbe323c548424", size = 2168146, upload-time = "2026-05-06T13:38:31.93Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/b8/4460f77f7e201893f649a29ab355dddd3beee8a97bcb1a320db414f9a06e/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:3bf92c5d0e00fefaab325a4d27828fe6b6e2a21848686b5b60d2d9eeb09d76c6", size = 2306309, upload-time = "2026-05-06T13:37:44.717Z" },
+    { url = "https://files.pythonhosted.org/packages/64/c4/be2639293acd87dc8ddbcec41a73cee9b2ebf996fe6d892a1a74e88ad3f7/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:3ecbc122d18468d06ca279dc26a8c2e2d5acb10943bb35e36ae92096dc3b5565", size = 2369736, upload-time = "2026-05-06T13:37:05.645Z" },
+    { url = "https://files.pythonhosted.org/packages/30/a6/9f9f380dbb301f67023bf8f707aaa75daadf84f7152d95c410fd7e81d994/pydantic_core-2.46.4-cp314-cp314t-win32.whl", hash = "sha256:e846ae7835bf0703ae43f534ab79a867146dadd59dc9ca5c8b53d5c8f7c9ef02", size = 1955575, upload-time = "2026-05-06T13:38:51.116Z" },
+    { url = "https://files.pythonhosted.org/packages/40/1f/f1eb9eb350e795d1af8586289746f5c5677d16043040d63710e22abc43c9/pydantic_core-2.46.4-cp314-cp314t-win_amd64.whl", hash = "sha256:2108ba5c1c1eca18030634489dc544844144ee36357f2f9f780b93e7ddbb44b5", size = 2051624, upload-time = "2026-05-06T13:38:21.672Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/d2/42dd53d0a85c27606f316d3aa5d2869c4e8470a5ed6dec30e4a1abe19192/pydantic_core-2.46.4-cp314-cp314t-win_arm64.whl", hash = "sha256:4fcbe087dbc2068af7eda3aa87634eba216dbda64d1ae73c8684b621d33f6596", size = 2017325, upload-time = "2026-05-06T13:40:52.723Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/1d/8987ad40f65ae1432753072f214fb5c74fe47ffbd0698bb9cbbb585664f8/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7", size = 2095527, upload-time = "2026-05-06T13:39:52.283Z" },
+    { url = "https://files.pythonhosted.org/packages/64/d3/84c282a7eee1d3ac4c0377546ef5a1ea436ce26840d9ac3b7ed54a377507/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df", size = 1936024, upload-time = "2026-05-06T13:40:15.671Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ca/eac61596cdeb4d7e174d3dc0bd8a6238f14f75f97a24e7b7db4c7e7340a0/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526", size = 1990696, upload-time = "2026-05-06T13:38:34.717Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/c3/7c8b240552251faf6b3a957db200fcfbbcec36763c050428b601e0c9b83b/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0", size = 2147590, upload-time = "2026-05-06T13:39:29.883Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b5/b4/205b0d5241d934e8add0c38aa924c4f9fb7330834ff11e5444db964ec3f9/starlette-1.6.0.tar.gz", hash = "sha256:d4e3ac5e546444960c710297a3c9fc3f7ebae1b7e963f3d36173b49da535be9b", size = 2716969, upload-time = "2026-08-08T18:27:57.512Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c8/cb/6a6a47d5b464bd08695d254f3da6e7986cc70c9fa5d778eda57538edfe56/starlette-1.6.0-py3-none-any.whl", hash = "sha256:a86dd39d14bb45f85a3d18525215a9ef0cfd1f192ac793220e72598c90335f0c", size = 75969, upload-time = "2026-08-08T18:27:56.196Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.52.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/03/18/ccce41535dee1be77735592bd19965f3972c82e07ee703d324709496b716/uvicorn-0.52.1.tar.gz", hash = "sha256:112ec661814189acbccd3f7b86460147cc065fc92c0821afa78918780e4354dd", size = 100571, upload-time = "2026-08-01T18:19:30.732Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/d5/68e6e9bca63c0badf67002890a46d3784c958de45b65e1275ec583ca1f06/uvicorn-0.52.1-py3-none-any.whl", hash = "sha256:e4403f9d93188cf9d1088e9f40e3acd12630e2df8675316704379a7fc20fff6a", size = 79859, upload-time = "2026-08-01T18:19:29.294Z" },
+]
+
+[package.optional-dependencies]
+standard = [
+    { name = "httptools" },
+    { name = "python-dotenv" },
+    { name = "pyyaml" },
+    { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" },
+    { name = "watchfiles" },
+    { name = "websockets" },
+]
+
+[[package]]
+name = "uvloop"
+version = "0.22.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" },
+    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" },
+    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" },
+    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" },
+    { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" },
+    { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" },
+    { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" },
+    { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" },
+    { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" },
+    { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" },
+    { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" },
+]
+
+[[package]]
+name = "watchfiles"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cd/41/5e1a4bb12aac5f1493fa1bdc11154eca3b258ca4eba65d39c473fe19d8e9/watchfiles-1.2.0.tar.gz", hash = "sha256:c995fba777f1ea992f090f9236e9284cf7a5d1a0130dd5a3d82c598cacd76838", size = 108252, upload-time = "2026-05-18T04:32:04.251Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b8/2f/e42c992d2afda3108ea1c02acecc991b9f31d05c14adc2a7cee9ee211fc4/watchfiles-1.2.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:bc13eb17538be00c874699dc0abe4ee2bc8d50bb1166a6b9e175ef3fd7eb8f26", size = 400115, upload-time = "2026-05-18T04:32:02.06Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/8f/6af2ea19065c91d8b0ea3516fdfc8c0d349f407e8e9fbf4e5a17360de8ad/watchfiles-1.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2d95ddc1eb6914154253d239089900813f6a767e174b8e6a50e7fdacb7e4236c", size = 393659, upload-time = "2026-05-18T04:30:50.951Z" },
+    { url = "https://files.pythonhosted.org/packages/13/01/b32a967c56fb3e3e5be3db52c3d3b87fa4513aa367d8ed1ad96d42952e5f/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f70d8b291ef6e88d19b1f297a6905ddb978888d9272b0d05e6f53309856bcfc", size = 453207, upload-time = "2026-05-18T04:31:04.231Z" },
+    { url = "https://files.pythonhosted.org/packages/04/98/97557a812180338cb1abd32e1cffcc4588f59b5f23e0cb006b2ba95ba64a/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:56d8641cf834c2836922899105bd3ce3d0dfc69291d52edf0b4d0436829b34c0", size = 459273, upload-time = "2026-05-18T04:31:50.377Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/a8/b4b08dcb7653b8087c6586f7ce649505900e866bbcfe40dc9587af02e686/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2581a94056e55d7d0a31a823ea92bf73749c489ca2285bfdc0fbe6b2bb49d50c", size = 489927, upload-time = "2026-05-18T04:31:42.485Z" },
+    { url = "https://files.pythonhosted.org/packages/50/94/3dceea03545d2e5ddfd839f0ddd5e1cecbf1697b5a428d5ba11cef6af95d/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:41bc1199f7523b3f82843c88cbb979180c949caef0342cf90968f178e5d49b01", size = 570476, upload-time = "2026-05-18T04:31:03.071Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/f2/d39a5450c3532092b91f81d274360e613c2371bc874a89c7a1a3c5e8d138/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7571e4464cb6e434958f867f7f730b8ab0b75e3f8e5eac0499168486ab3c33a8", size = 465650, upload-time = "2026-05-18T04:30:12.701Z" },
+    { url = "https://files.pythonhosted.org/packages/22/24/ed72f68cbc1333ca9b9f2200aa048bb6658ae41709bc1caad4310f4bdffd/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e53a384f76b631c3ae5334ce6a52f0baa3a911eb94a4eac7f160079868b716d5", size = 456398, upload-time = "2026-05-18T04:30:13.784Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/64/982ef4a4e5bab5b6e5b6becc8cd5e732f6130a78b855f0abec6439a9a135/watchfiles-1.2.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:d20029a60a71a052a24c4db7673bc4de39ab89adbaccbfb5d67987c5d73f424d", size = 465140, upload-time = "2026-05-18T04:31:52.111Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/0c/95282abf4ed680b6096010bcfc30c5fa7a041fc5aa5a2ad17a2cc6c75bba/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2cb93af48550faf1cea04c303107c8b75833de7013e57ce27d3b8d21d8d0f58c", size = 630259, upload-time = "2026-05-18T04:31:25.676Z" },
+    { url = "https://files.pythonhosted.org/packages/30/45/607c1de1530c4bdcf2cf1d1ecc2505ddba5d96bd43ba9f2b0e79876f850f/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2995c176de7692b86a2e4c58d9ec718f753150a979cb4a754e2b4ffa38e70906", size = 659859, upload-time = "2026-05-18T04:30:24.333Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/08/d9e2e0f9e8e6791d33aefc694ad7eefa7f901f63caff84a81ded38692f9c/watchfiles-1.2.0-cp312-cp312-win32.whl", hash = "sha256:7a2cffd17d27d2ecbb310c2b1d8174f222a5495b1a721894afa88ec11e25b898", size = 275480, upload-time = "2026-05-18T04:30:31.307Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/e6/9d42569c0102645cc8cea5d8c7d8a1e9d4ada2cb7f05f75e554b8aa2202a/watchfiles-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:f155b3a1b2a5fc89cdc70d47ee5d54e3b75e88efa34982028a35daef9ba00379", size = 288718, upload-time = "2026-05-18T04:32:10.745Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/26/88e0dc6ee3898169d7fa22bb6a69cabf2502d2ee25cb8c876d1262d204f8/watchfiles-1.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:8fa585ede612ee9f9e91b18bebf9ba11b9ae29a4e3a0d0cf6fca3e382133f0d5", size = 281026, upload-time = "2026-05-18T04:30:22.23Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/4d/70a7feced9f87e2ff26dba42667290f41694fc64646c67261fbb8cab5d5c/watchfiles-1.2.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:01ea8d66f0693b9b60a6541c8d10263091ca9a9060d242f3c1f3143f9aad2c98", size = 399730, upload-time = "2026-05-18T04:31:38.162Z" },
+    { url = "https://files.pythonhosted.org/packages/31/3a/0da302f2307aee316922806ebd5726c542cbd787c938271cf14a074c7daf/watchfiles-1.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ba0480b9a74af058f43b337e937a451e109295c420916d68ad24e3dc02f5e44", size = 392842, upload-time = "2026-05-18T04:30:27.051Z" },
+    { url = "https://files.pythonhosted.org/packages/db/ef/d5bdb705c224dbc256aa0c1ec47bf4e61ec52558f2afb44a71a1fe4d7015/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f34e26a19f91f710c08e0183429f0d1d15df734e6bc78c31e77b9ea9c433658", size = 452989, upload-time = "2026-05-18T04:31:11.945Z" },
+    { url = "https://files.pythonhosted.org/packages/71/29/5495f2c1661949ef7a35e4d71111d129cfe7606414a26887a919d0a55406/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b4e77f6a55f858504069abd35d336a637555c09bca453dde1ee1e5ada8a6a1fb", size = 458978, upload-time = "2026-05-18T04:30:52.606Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/8c/7f9c07c433811c2fffd93e13fdfb7135de9aab5f2ae41be08960fa0047dc/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0cb4d80e212f116474a545c21c912b445f16bb0cef9e6a73a498164223e14e2f", size = 490248, upload-time = "2026-05-18T04:31:36.003Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/11/d93632febc52fbc21be90231bb7c17fd5387f46c9076fd40a5f9c2ae6910/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b974946a10af379d425e2eef5b62f5c6ebeaccf91d45eaad6f5b27ecd4f91aa0", size = 571847, upload-time = "2026-05-18T04:31:10.862Z" },
+    { url = "https://files.pythonhosted.org/packages/55/b4/383173e73aabb07ad1d9c7aa859d95437ac46a6d6a1e11005facda0c9d19/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86bc13c25a8d1fcd70b51d0ce7c9b65e90de5666fcbfd3e34957cc73ee19aeb5", size = 465974, upload-time = "2026-05-18T04:30:17.006Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/6c/89b1a230a78f57c52dd8893adb1f92f94411721b6ec12596c56d98c74356/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca148d73dea36c9763aaa351e4d7a51780ec1584217c45276f4fe8239c768b71", size = 454782, upload-time = "2026-05-18T04:30:35.656Z" },
+    { url = "https://files.pythonhosted.org/packages/24/62/1732118367cfff0a9fce3bf62ff4bfded09ef5df21d9d446b858b3f70a96/watchfiles-1.2.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:c525543d91961c6955b2636b308569e84a1d1c5f5f2932041ab9ef46422f43e3", size = 465182, upload-time = "2026-05-18T04:30:20.846Z" },
+    { url = "https://files.pythonhosted.org/packages/28/96/716f7e5f51339bf22963f3345f9f27d7f3b30e2eadc597e257c881dd3c53/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:a204794696ffb8f9b10fba6f7cb5216d42f3b2b71860ccac6b6e42f5f10973b0", size = 629841, upload-time = "2026-05-18T04:31:05.397Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/fe/c40783950fd771ccf66ab3ec2722d188a9af1c7f96c6e811f36e40c6e03f/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:10d86db20695afe7997ac9e1717637d6714a8d0220458c33f3d2061f54cec427", size = 658028, upload-time = "2026-05-18T04:31:48.22Z" },
+    { url = "https://files.pythonhosted.org/packages/71/72/4508db1856d1d87fcbb3b63f4839bab1b5682cb0e8d224d122263c09654a/watchfiles-1.2.0-cp313-cp313-win32.whl", hash = "sha256:eb283ee99e21ad6443c8cdb06ac5b34b1308c329cbdf03fa02b445363714c799", size = 275183, upload-time = "2026-05-18T04:30:59.57Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/36/14b76ca57652e5cc5fd1c11f32a261292c08a0d19a00351013c2549cbfb2/watchfiles-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:a0f27f01bee51861392bb6b7c4fdb290b27d1eb194e9e28788d68102a0e898d9", size = 288059, upload-time = "2026-05-18T04:32:07.937Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/8d/0a85e395398d8d20fadfe5c5d32c726eee17a519e78fb356f2cf7531bffe/watchfiles-1.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:3651aa7058595e9cfb75d35dd5ada2bf9f48a5b8a0f3562821d3e210c507e077", size = 280186, upload-time = "2026-05-18T04:31:54.484Z" },
+    { url = "https://files.pythonhosted.org/packages/37/68/36db056f1fdcc5f07302f56e631774d6835bcd6fa3ace402304621d5f9e5/watchfiles-1.2.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:faea288b6f0ab1902ef08f4ca6de005dccf856c4e0c4f21b8c5fce02d90a1b08", size = 399031, upload-time = "2026-05-18T04:30:44.576Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/64/01a9d6f66a82a5c101ce939274106cc72759d62427e153f01edd2b9f87c2/watchfiles-1.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01859b11fd9fbca670f4d5da00fbac282cfea9bd67a2125d8b2833a3b5617ea9", size = 391205, upload-time = "2026-05-18T04:30:25.413Z" },
+    { url = "https://files.pythonhosted.org/packages/84/2c/0a44fe058cb4bb7b8ede6b6670698bbb7c0400740e378d00022189b7b31d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fff610d7bb2256a317bb1e96f0d7862c7aa8076733ee5df0fd41bbe76a24a4f4", size = 451892, upload-time = "2026-05-18T04:32:14.005Z" },
+    { url = "https://files.pythonhosted.org/packages/67/a1/351e0d56cd35e6488b5c8b4fb11a809a5bc923e8fe8fed9faf8920be0c89/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b141a4891c995a039cd89e9a49e62df1dc8a559a5d1a6e4c7106d16c12777a55", size = 458867, upload-time = "2026-05-18T04:31:22.279Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/7d/9d09605187f1b838998624049fcf8bf47b73c1a3b76901fcac1782f62277/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f22943b7770483f6ea0721c6b11d022947a98eb0acae14694de034f4d0d38925", size = 490217, upload-time = "2026-05-18T04:31:43.657Z" },
+    { url = "https://files.pythonhosted.org/packages/60/5d/a17a16eccb182f04188cd308ec24b1a71a9b5c4e7098269cf35d9fa56d02/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1bc6195825b7dcd217968bb1f801a60fd4c16e8eeab5bedc7fe917d7d5995ab4", size = 571458, upload-time = "2026-05-18T04:32:11.875Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/3d/4dd457062083ab1938e5dfd45032eb425cee2ac817287ca8ff4356183e5d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d4a4b147f5dca2a5d325a06a832fb43f345751adfbc63204aec30e0d9ca965a2", size = 464707, upload-time = "2026-05-18T04:30:43.492Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/71/ea8c57b128f5383de74d0c7d2d9c57ad7c9a65a930c451bd25d524b295b7/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4543579a9bdb0c9560039b4ffddbdb39545707659fbc430ce4c10f3f68d557f9", size = 454663, upload-time = "2026-05-18T04:30:16.061Z" },
+    { url = "https://files.pythonhosted.org/packages/53/fd/2e812bf938406d7db351f0703ddd3fc6c061cf30d96153a77bc79a943a44/watchfiles-1.2.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:20aa0e708b920bde876a4aa82dc7dd6ebea228a63a67cda6632c2fc87b787efa", size = 463537, upload-time = "2026-05-18T04:31:44.9Z" },
+    { url = "https://files.pythonhosted.org/packages/86/56/d17a7f1dd1bc3035f1072694a551301272f1739c2d8e319c927cb9e29b38/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:d413349d565dab74297f2a63e84a097936be69bf8f3b3801f27f380e32040f44", size = 629194, upload-time = "2026-05-18T04:31:14.141Z" },
+    { url = "https://files.pythonhosted.org/packages/be/06/f1ff66bf5cae50aa4062779a0ecd0bbaf15e466195719074078947d9a17d/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f28b2725eb8cce327b9b3ab02415c853011dc55c95832fe90de6bc56f5315f72", size = 656194, upload-time = "2026-05-18T04:31:47.14Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/54/a9c7ea9a82a4ac65e7004c0a03920b5cdd2f9c3b678757d9cd425aa51d53/watchfiles-1.2.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:b8c8358484d5fa12ef34f05b7f4168eaf1932f408725ff6d023c33ec17bd79d4", size = 400205, upload-time = "2026-05-18T04:32:05.153Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/5d/c9ab3534374a4a67450696905d6ef16a04405448b8dc52bd752ae50423d4/watchfiles-1.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f04b092229ad2c50126dd3c922c8822e51e605993764a33058d4a791ab42281", size = 392508, upload-time = "2026-05-18T04:30:54.849Z" },
+    { url = "https://files.pythonhosted.org/packages/26/ca/1ad30103535cf0cecd7b993e8d50edc5351b1820e38f2d22e3df58962feb/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a7ce236284f002a156f70add88efe5c70879cccbb658be0822c54b1306fc09d", size = 452448, upload-time = "2026-05-18T04:30:53.727Z" },
+    { url = "https://files.pythonhosted.org/packages/37/a1/ceee2cdf2afbd715fa07758d39c9859513eae411b23196f7fd039e5feedd/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b9909cc2b48468b575eefa944919e1fe8a36c5849d5c7c168f80a8c1db69398e", size = 459605, upload-time = "2026-05-18T04:30:23.312Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/f6/421e30fd1cb3907a84ed92ab3f1983e37ba2dca015e9a894a048418417a2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a37faaed405c67e28e6be45a1fa4f206ef5a2860f27c237db9fa30704c38242", size = 490757, upload-time = "2026-05-18T04:30:47.358Z" },
+    { url = "https://files.pythonhosted.org/packages/41/b0/55ed1b97ed08be7bba6f9a541cac15f2a858e1d74d2b07b6da70a82aab00/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9649193aa27bd9ff2e80ff29bfaa93085496c7a3a377592823cc58b77ee88add", size = 568672, upload-time = "2026-05-18T04:30:38.915Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/cf/d8ae8a80dd7bafab395ea7681c10237311bbf34d37704a8c744e7cf31fc7/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e4ff8e37f99cf1da89e255e07c9c4b37c214038c4283707bdec308cb1b0ea1f", size = 464197, upload-time = "2026-05-18T04:30:09.914Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/8a/3076c496ca8dafe0e8cd03fcebdfc47be4b1174b4e5b24ff6e396e6b3af2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:054dc20fd2e3132b4c3883b4a00d72fd6e1f56fdaf89fccd12e8057d74cd74d7", size = 453181, upload-time = "2026-05-18T04:30:14.829Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/10/9745e17c98e7b8a86454df0a3c7b5686bd650383f1e9f26e4ebcbd6cc0c0/watchfiles-1.2.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e140ed30ebde76796b686e67c182cff10ea2fbab186fafd1560f74bb5a473a6e", size = 465109, upload-time = "2026-05-18T04:30:28.123Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/95/8ef4a95481d3e0cb52d62a06fa6e972e81424be2d9698b91a2fecca9904c/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:bb7e52ecf68ba46d22df23467b87cffeb2146908aa523ebfe803019618cfda06", size = 630653, upload-time = "2026-05-18T04:31:49.304Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/e4/3b3bf36b0f829b50c6ebcb8d031583863c59f923d6a6af3d485e470d0fac/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:23282a321c8baf9b3a3c4afff673f9fe65eb7fdc2338d765ccad9d3d1916a5ba", size = 657838, upload-time = "2026-05-18T04:31:06.497Z" },
+    { url = "https://files.pythonhosted.org/packages/21/b1/6cbbb50c1f3002ab568777d44aa21206dfb8807a840990c4037523b51812/watchfiles-1.2.0-cp314-cp314-win32.whl", hash = "sha256:c0db965c5f79aa49fe672d297cf1febc5ad149b658594944f49a54a2b96270a7", size = 275108, upload-time = "2026-05-18T04:30:06.891Z" },
+    { url = "https://files.pythonhosted.org/packages/92/45/190ce6db8dcb4536682cf75d3889ff1a27182a58cb519d343cb6d9ea63d8/watchfiles-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:71283b39fd17e5408eb123bd37aeecfd9d54c81fc184421943208aadb879d103", size = 288441, upload-time = "2026-05-18T04:32:12.901Z" },
+    { url = "https://files.pythonhosted.org/packages/74/0d/3eae1c2313ab08378431d907c3f8095ecca00f3eda33111cf4f0f2591799/watchfiles-1.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:c5c19526f4e54a00f2666a6c0e9e40d582c09e865055ea7378bf0009aab857b3", size = 280684, upload-time = "2026-05-18T04:31:26.902Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/75/fb64e6c25d6b5ca636d03df34ffb1c6e9873303e76d27967e045f8df088f/watchfiles-1.2.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:d73a585accffa5ae39c17264c36ec3166d2fad7000c780f5ef83b2722afb9dd2", size = 398857, upload-time = "2026-05-18T04:32:17.108Z" },
+    { url = "https://files.pythonhosted.org/packages/73/4e/9f7adf01754cbf81843722ccfec169d8f26c69778281a302855cecd2ee08/watchfiles-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ae99b14c5f21e026e0e9d96f40e07d8570ebee6cafd9d8fc318354606daa7a28", size = 392413, upload-time = "2026-05-18T04:31:07.911Z" },
+    { url = "https://files.pythonhosted.org/packages/47/c8/bec626bcc2d69f44b9acb24ce7d60ed7b16b73628eea747fcbd169d8edda/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4429f3b105524a10b72c3a819b091c495d2811d419c1e1e8df773a5a5974f831", size = 452409, upload-time = "2026-05-18T04:31:20.142Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b7/b6362068e81e7c556d155a34c35d40ac3ef42d747b06d7f6e5bf58e359c2/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:43d818978d06062d9b22c4fab2ebe44cf5213d42dc8e62bda8c2760cfa2eeb33", size = 458827, upload-time = "2026-05-18T04:32:06.219Z" },
+    { url = "https://files.pythonhosted.org/packages/67/f8/9a813fa42afb1e0b4625e75f0479826644d3ee8dc287e093799bc01f390c/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b9f732dc58b2dbe69e464ccf8fff7a03b0dd0be439da4c0720d3558527d3d6b4", size = 490104, upload-time = "2026-05-18T04:31:56.034Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/bf/27dfb6094ca4c9aad21298b5525b6c53cb36121ee454331d05161e58d130/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f200104103feb097de4cab8fe4f5dd18a2026934c7dea98c55a2f5fd6d5a33b", size = 571360, upload-time = "2026-05-18T04:31:57.133Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/39/44a096d67270ea93df91d33877dbe91fbda3aa4f8ec2edf799d93eda8736/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:63ac26eefbf4af1741247d6fb68b11c49a25b2f7413fbd318a83a12aaa9cf666", size = 464644, upload-time = "2026-05-18T04:30:57.33Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/80/c7472203bad6268e3ef1ad260739704847898938ad7ea8b63a5131f46b50/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c4997d4e4a55f0d02b6cde327322daf3a0400e5df6c6b15948994bf72497925", size = 454771, upload-time = "2026-05-18T04:30:48.736Z" },
+    { url = "https://files.pythonhosted.org/packages/51/cf/3b10b268b4b7f0fc26e9debb5eef1998b515887840f444cd3ec80c688755/watchfiles-1.2.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:4c887eba18b7945ac73067a8b4a66f21cd46c2539b2bc68588f7be6c7eb6d26b", size = 463494, upload-time = "2026-05-18T04:31:33.826Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/3e/a4302545cd589262a0dc7d140e86f7688eba3f9c72776c27f7e23b8864c4/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:3416ff151bb6b5a8d8d11664974fbef4d9305b9b2957839ab5a270468fd8df30", size = 629383, upload-time = "2026-05-18T04:31:15.596Z" },
+    { url = "https://files.pythonhosted.org/packages/db/99/d5649df0a9a410d45b7c882304d0b790903ac9b6e8f2cfd12114e0c6b9f2/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:0e831a271c035d89789cffc386b6aa1375f39f1cd25eb7ca0997e4970d152fc5", size = 656093, upload-time = "2026-05-18T04:31:58.707Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b9/362702539275019a54dd2e94511b31a9b89c5f9e6a21966de7eb692549fc/watchfiles-1.2.0-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:37a6721cdf3f65dbb13aa9503510ccb4451603ac837e44d265d7992a597e1374", size = 400109, upload-time = "2026-05-18T04:31:16.879Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/75/71d5ba62db781e5587bded1d944c675374bc4aa37ff33d5018d98e8b6538/watchfiles-1.2.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2b37d10b5a63bd4d87e18472d80fa525bd670586fae62e5dd580452764879b65", size = 392167, upload-time = "2026-05-18T04:31:28.058Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/01/c66dd95d0423fe30d31820e2d1d5bda773764131bbb6ac0cb1cf303ac328/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a105bc2283f67e8fbec74253ec2d94925de92ed72c0393f1206bf326b7b7b69", size = 452372, upload-time = "2026-05-18T04:31:00.836Z" },
+    { url = "https://files.pythonhosted.org/packages/91/15/2fe99557e72f85627c6a8eed50d889e8d101623e060a22ad75b875cb932d/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5327989a465505f05cfe06f04fa9d0c2fd5432bb243e10e6f012b1bdca3c8579", size = 459596, upload-time = "2026-05-18T04:31:34.96Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/d4acfa0023367428ed48351b3b9b267893037b6cadae55620c61c24bcfd4/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ecb47f183a8025b2aa18b546725c3657e542112ae9c0613a2af79b4fa8d04ad7", size = 490869, upload-time = "2026-05-18T04:31:59.923Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/5f/3164cbdce06c9fb95c4f7b9e2f9760b5e2797af43a9ecc317ef42a23a278/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8520a4ab0e37f770afc34459c4f8f7019e153f9124dc101c15538365875d1ab2", size = 571641, upload-time = "2026-05-18T04:32:00.948Z" },
+    { url = "https://files.pythonhosted.org/packages/41/e6/85d3731c55e65cd7690f3f803d24c139588aaf863e4bf2148fe7a7fa1a19/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:71cd71740ed2c15211ebb237ced4e39a1cdf6f80566e5fe95428da1626f4fde6", size = 464444, upload-time = "2026-05-18T04:30:34.298Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/7d/562641012b8b09872742c3b8adf9629ec479fd78f8d68ae4a0c13da8add6/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f88af53d6ddaf72179ef613ddc905e6f4785f712b49b80b3bef9f3525e6194b4", size = 453593, upload-time = "2026-05-18T04:31:23.464Z" },
+    { url = "https://files.pythonhosted.org/packages/56/fe/cb8ef3d6f929d14158fdaaad9925985b7310abc9384dcd4d82dd0016fb59/watchfiles-1.2.0-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:cee9d5efd929efdac5f7e58f72b3376f676b64050a91c5b99a7094c5b2317488", size = 465096, upload-time = "2026-05-18T04:31:30.384Z" },
+    { url = "https://files.pythonhosted.org/packages/25/91/80908e835e100527a9267147b08c0eee1fa6ab0ffec15edc04d1d44885f7/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:b718bf356bbc15e559bd8ef41782b573b8ae0e3f177ab244b440568d7ea02cfb", size = 630638, upload-time = "2026-05-18T04:30:49.89Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4b/95ab2f256bb4af3cb2eb23b9317bda984ee6e0f11733a5c004a6c95b06e3/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:922c0e019fe68b3ae392965a766b02a71ba1168c932cebc3733cd52c5fe5b377", size = 657684, upload-time = "2026-05-18T04:31:32.027Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "17.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/96/e01084f83a64bcb3a27994bd0cb0db68ff29d9c6707fae37ec19b18ba990/websockets-17.0.1.tar.gz", hash = "sha256:5baa9bc0dfbae8c507e51c8cf1b6d4628086f7a87bbd3a9952bd5f035451f1cc", size = 183298, upload-time = "2026-07-31T11:31:27.665Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/50/ff/6199a52d864215750af8668d84b0274775011a90052081f5a9495807a92b/websockets-17.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:10f461191125c63902ea7394ae9e752b1b5785641850c1d365bb30b0f88bc53f", size = 212603, upload-time = "2026-07-31T11:29:30.771Z" },
+    { url = "https://files.pythonhosted.org/packages/54/7e/439a962bcada88dcf586da77a1b2385f91e2d2910e9359540934c827156b/websockets-17.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cffc84ddec6da7f447677266fee2a3c40ecc78172f00752aa1150b8a8d65df1d", size = 210286, upload-time = "2026-07-31T11:29:32.157Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/82/123660edc759c225626b3b91952c7625f85c77a8362acbc35a4623120f7d/websockets-17.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c23e532c8a2325a1e7486de8763a60dc43e83f01bcaeca07e3ba79652c156db1", size = 210549, upload-time = "2026-07-31T11:29:33.388Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/2f/2940e57080cf56f28190287516400126d5a76b52b9a61dc10ba6f6400dbe/websockets-17.0.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:c09e097d0e46e3c289bedab9a475ae344b70c30ff5646e46af22b4e6fdc97b21", size = 219874, upload-time = "2026-07-31T11:29:34.608Z" },
+    { url = "https://files.pythonhosted.org/packages/42/28/9ec976c16d63cc51c28dfec74b66854048c0b8b6579946e902f91b69e8bf/websockets-17.0.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f47b0815af3948ec6a440b3afa02f05b18cc0939549e91b5c677b5d9c2c8472a", size = 220150, upload-time = "2026-07-31T11:29:35.831Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/a4/850c699a16bbc451723856360c59bd997bec075e637154f3fa96e80d5760/websockets-17.0.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8848c207049ad49d318e5f64a3d4d7bb189f8328d0d98e65647788f2a085785c", size = 221389, upload-time = "2026-07-31T11:29:37.189Z" },
+    { url = "https://files.pythonhosted.org/packages/47/e1/f60a891c1a4b3420d5052333a84eb7241e1fb4a71866dec1562f5fa30027/websockets-17.0.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2604de7228506b13a44a256a9d223943340c0e725af5d367dc068e192b027761", size = 224169, upload-time = "2026-07-31T11:29:38.61Z" },
+    { url = "https://files.pythonhosted.org/packages/26/fb/e2a893be6fae4fddfe50ddc3035a331d3f381103d5467b7900026bdb3a64/websockets-17.0.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:07abc3bd196a48af476a82fd47f3f79a6a3f70937a9f930cef703cfa0c9d83b6", size = 222025, upload-time = "2026-07-31T11:29:39.897Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/72/e3144b2d79276fab9798ed7d4aea2f0847434f186800b6f56a1eddcb3114/websockets-17.0.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:769ce7e2acfd9a89f2bed3a9c0da229459516bbc00bd4c9e2ca492c613ae4861", size = 220779, upload-time = "2026-07-31T11:29:41.084Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/5e/69c02174fbcf1c40c6adc45d3c316a401558392fe7bab8969ef8c46f1689/websockets-17.0.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:07d78a509c3333f5908c83d7f78144ea68a6c9ec28110f5c54d81d8fcdc262c4", size = 218053, upload-time = "2026-07-31T11:29:42.322Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/09/7574778b095b99cfa0856583462f56568df784f9b41485145169b2ec9c64/websockets-17.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ffad64ce7ad3703d652a3fd9af26238377d24ce52c6ad8ff35d26d82f61f493f", size = 220825, upload-time = "2026-07-31T11:29:43.553Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/e6/f46571f38765dbc4cbc0d0b47de8db65768006dbbd4340e6f5f51bc1d895/websockets-17.0.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:e95e321d0d763f2b6633512605f6112ebd70d5746f3ce05c941909d4a25233f2", size = 219427, upload-time = "2026-07-31T11:29:44.731Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/31/6ff1fee057bd7e9dd5237fc064a749615378d003aa045b5bfc2d12b2f4f7/websockets-17.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:cd526c8228e759c1006c4b7c9ac71dc4e925ced1a6a6a5a8e94643709738f63e", size = 220198, upload-time = "2026-07-31T11:29:45.997Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/4f/d41847227a44b9ad87c3d5a9fddbfad8b7c4d6032878d8460d9d37c2d44f/websockets-17.0.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8cd3369e42c0246afaf9d669cfc19797e3a49e8c0a639544459c57597108b966", size = 221304, upload-time = "2026-07-31T11:29:47.314Z" },
+    { url = "https://files.pythonhosted.org/packages/63/30/21a7e326c6ad2eb526cd5b816383d59cdeb28b8805b65a543c3cfbd8e8ce/websockets-17.0.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:b580794e926cab7ff42ee4371ef14e0b22cb2bb722a607f77769136468f49a3f", size = 218858, upload-time = "2026-07-31T11:29:48.587Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/48/55b0331cd5bec9ce29748f79edc00075805450a47011d0c8e3b1c61dbf04/websockets-17.0.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5033ffe6804dd53afafa7d08e8c3eef2d2431f34d58ca30507a8442dd04a033a", size = 219840, upload-time = "2026-07-31T11:29:49.791Z" },
+    { url = "https://files.pythonhosted.org/packages/78/6e/2e8bc06e546f49b32a58a2bc2957902d1809ecc37552d3d7ccd6639a126e/websockets-17.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6db9e5bf3649ab506c6ae8a3ac85a00fb1ae3816d75962771b2df8adbc5d40d2", size = 220116, upload-time = "2026-07-31T11:29:51.026Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/ad/4bac01fa41aca54307157b9c9f68b066a6bb51fb18716ba618078a67b283/websockets-17.0.1-cp312-cp312-win32.whl", hash = "sha256:bc0bca48ba24c6c866847fd20478a51dd547fa0ad258dab9615c414ec534bbc0", size = 213050, upload-time = "2026-07-31T11:29:52.328Z" },
+    { url = "https://files.pythonhosted.org/packages/82/d8/c3a78cccc74a554780e9e76e323d5cde891048627025f0f82623e22dc3df/websockets-17.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:2b3f3020171202b135ca078e20434977c6b2b02af647130d6980c9e39b9462e3", size = 213348, upload-time = "2026-07-31T11:29:53.891Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/25/e1b8824bd632c8a5a62d504b61e9e35e470b67e4be0206f5c28f90c7f86d/websockets-17.0.1-cp312-cp312-win_arm64.whl", hash = "sha256:41d6aa06b5ab832aee72fedf47a149535b121ac900b6bb4d3fe14712afac9a79", size = 213276, upload-time = "2026-07-31T11:29:55.299Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/a8/79c577bc2f874ee22f6f5ccdab97ba9ce6b96806be3fcc3a6d8490f88a21/websockets-17.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:55b12e47dcee83673a40d07686cfb6f9d6dfc285976ade9463f61d2bef3fad22", size = 212593, upload-time = "2026-07-31T11:29:56.518Z" },
+    { url = "https://files.pythonhosted.org/packages/db/99/e1cfaf419bb3b2fcfd6792a846f1d936293132b0b9a56530ced016c83c7b/websockets-17.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c1c118a6b0e25bfc9a6802075d748fa6321714ffbdf3c88d29d9a0e3c7386c75", size = 210280, upload-time = "2026-07-31T11:29:57.768Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/ef/cc994494bf7d97e41833f6ff55c24f535e4d527a10370b9631737e9c2f00/websockets-17.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:734d20364dc2cfe03674883cafcf580b6e431c5ce42b476312b9285310230cf9", size = 210538, upload-time = "2026-07-31T11:29:59.021Z" },
+    { url = "https://files.pythonhosted.org/packages/87/32/fbf2d132f63ba3e67f675bccf333469786a24e0418969ce1d8e6ff9e6f02/websockets-17.0.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:9493314a99e599163c854fb5900ad7f7ea38c5cb9d9103aa30b3c6b8181c01fa", size = 219925, upload-time = "2026-07-31T11:30:00.298Z" },
+    { url = "https://files.pythonhosted.org/packages/16/50/64eee3d25a47fe744a9490e0627cc373dca096755db740f91c28bd61cd35/websockets-17.0.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:18ded646ce98cdd3c0235825b3252f1df55765ba49b616bb10282f758667b4d0", size = 220206, upload-time = "2026-07-31T11:30:01.52Z" },
+    { url = "https://files.pythonhosted.org/packages/15/56/10ed4bc4dd75f204e3c62bd4898e44a8742a27773c80b188cfa7888aad2d/websockets-17.0.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c1bec5d6a19f5fbe87e4940739cfc65e7bb53d8b353e1029b8037a1653b321bc", size = 221445, upload-time = "2026-07-31T11:30:02.788Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/be/bb14328614c068ab09569962fbf218fc00413ce3febc6d2684c764b6f37e/websockets-17.0.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:872273e629ca7e3d35f16a2dc6ede84e1d5c831e616b8277de6e4f83114e7c58", size = 222887, upload-time = "2026-07-31T11:30:03.943Z" },
+    { url = "https://files.pythonhosted.org/packages/32/1b/4cb0eec2fee310007104687493175af190019f705940c864f9c523fe9f6f/websockets-17.0.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1df81d174c1561292de9e40b141cafc04f69077272f6c352afe1d743e20810df", size = 222072, upload-time = "2026-07-31T11:30:05.258Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/9c/14e6391de777ddb39c439c450deb551406d445e25a5877d6fa25c49d4544/websockets-17.0.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:759adeb5b0c5775b563254ec63b5b79089fc0045b479143a0b1b8c0ebaae1253", size = 220826, upload-time = "2026-07-31T11:30:06.53Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/57/96e94e384442247bbed5d3ab67381c7257355c2d66b62c3ad33a17f5d385/websockets-17.0.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4d1d99db29b5444e3982f1ce2ba8a833508ad44b2f1fbd0bd99e81d825c0b461", size = 218107, upload-time = "2026-07-31T11:30:07.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/8c/9c9dedd14c3919435df9b35cdee7111268c751252b87652f3a6a4f56e760/websockets-17.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:02ed63bf26dda9fa27df730a41f6664586c4ee05972c8fb667ce1725b3fd13d3", size = 220889, upload-time = "2026-07-31T11:30:09.035Z" },
+    { url = "https://files.pythonhosted.org/packages/94/4d/ca73c2ac82c00f50c529784bacb323e42da4816333211bc1543d90c9cf11/websockets-17.0.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:eab6de8a98b9a7772cf686d00b4de439fc7efb8ab05ae106ef227291d06f87c5", size = 219486, upload-time = "2026-07-31T11:30:10.289Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/da/fb37ac09dcd7c69dd73bac979ed393df35f78a3c232e293d1ff3bd586d24/websockets-17.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2a855b6dfe21c4d3420be265ae031829ba8ba0be0ea350d9f7c3ef30ae63ebe2", size = 220258, upload-time = "2026-07-31T11:30:11.605Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/04/9693f191d968a93f37326a17301a101d49580889c688f466699f89ecdee1/websockets-17.0.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7002d5f9e1c3ddd991cdfdbfee18cc8c8b196b2445022892badacd6cb338bbbc", size = 221358, upload-time = "2026-07-31T11:30:12.858Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/29/ad0d85c01db5dcf22898d51648bd2c25af0dd0a4a41c550b11acddeeeba7/websockets-17.0.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c395bda8e7d8f51a02e80261fb57127979e5c472675d9a96b2860619ad47da48", size = 218921, upload-time = "2026-07-31T11:30:14.064Z" },
+    { url = "https://files.pythonhosted.org/packages/18/3b/bf8e855e495dcca63f2b8aa019cf2ada3160e1fa66d833c7417f3b1f7f38/websockets-17.0.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aadc298969ad229d8e3029fc5cc751fdad286696230f9cf014e90ff9cd8e6ea0", size = 219871, upload-time = "2026-07-31T11:30:15.358Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/db/c7abd6639a93a40279cd1ddc57e09e1c4f8381c4cfccdb775aa5aac9770a/websockets-17.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f11a398d8170b7ac5000baf7f258dcda579ef3ea744e0cc6a165e0dfbc0d3198", size = 220154, upload-time = "2026-07-31T11:30:16.96Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/2a/25a9f8f2e5a6ef34e911d2f55d9f756bdeb92b4c28cfb77b8430bbc73cb1/websockets-17.0.1-cp313-cp313-win32.whl", hash = "sha256:846a4a8b0833e3cad57523d9e3bd50ec8ea05ab9d06c582f82a1340ba096af5f", size = 213038, upload-time = "2026-07-31T11:30:18.434Z" },
+    { url = "https://files.pythonhosted.org/packages/81/2f/ea1380f72bb11b64fc5bc7ae0d42de5bbf3e6dc13b965706b2a1d4e17cdf/websockets-17.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:409d93efcaa14f7a99592c5baaef5ec6ca94fba0f5aec1a86f693977c69c9c1c", size = 213348, upload-time = "2026-07-31T11:30:19.693Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/c7/b956ed9151c3c74530ebc62d716fbfdbde7507a6acc6423a64f9ecfb6b8a/websockets-17.0.1-cp313-cp313-win_arm64.whl", hash = "sha256:90246fa9e6cb192a778ce6ce024057ec54317a894db7899c922dcdc1f4cbf6a5", size = 213282, upload-time = "2026-07-31T11:30:21.045Z" },
+    { url = "https://files.pythonhosted.org/packages/98/dc/cadab608924ac605647031472fb1f8792d7d4ea07565ba1899ec42028e0d/websockets-17.0.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:53b90c00bc6201ab6695c7ff51a04d0e425514c37515e9eeecd2c1b978ac6c0e", size = 212640, upload-time = "2026-07-31T11:30:22.436Z" },
+    { url = "https://files.pythonhosted.org/packages/16/7a/b034d13ca181211bbd58bb50835cb196a7784cd505b5a2079d4d03374f9f/websockets-17.0.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:5f33a649bfcb8312524173cc4bbafa7dbb236e18eee9aa31a1d324ca0ddda28c", size = 210332, upload-time = "2026-07-31T11:30:23.608Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/4d/943ede39b53744768edf1ed84a3f9401527388228a3d6c1249c02c3d6bd7/websockets-17.0.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cddc675ec31bca65473321f9a9794e488b43b3b8de5d02c8ef4810c5d5792163", size = 210546, upload-time = "2026-07-31T11:30:24.932Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e3/88dc159d2ae66743c669443246243f28d873b0c5e58271b8cc1ca0440334/websockets-17.0.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b3ff0ad440ad52dda64138f16895f66403f40192365e39b1010e889f289746b0", size = 219928, upload-time = "2026-07-31T11:30:26.221Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/f2/ff27eaefa15851a5cf7f004ab827a022bf2d6632cb520f89cb100db7e84b/websockets-17.0.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:72d7f2a5aeb4e82daa4ee18f125b4277f427033359be5c745ad709608446cc2c", size = 220279, upload-time = "2026-07-31T11:30:27.49Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2e/a5166149f363d2449c1cb2dde6486a245521979509d53b87a09f3e79662b/websockets-17.0.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6fd88365da261c53d3e943fb37e0d0721b9cde119f6b2e3fc84369b6ab234d63", size = 221525, upload-time = "2026-07-31T11:30:28.872Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/b5/f46931269b3ff3bde65d27c65ddb22f9bb8ce92ac2c6c4df0910128f6219/websockets-17.0.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ab9f962a5b64a5c3c845d556b7dc4e6fb683f7b67179f8205e814bb2e0213ffe", size = 222897, upload-time = "2026-07-31T11:30:30.164Z" },
+    { url = "https://files.pythonhosted.org/packages/42/f4/deccf3439f35df953ec35e13fe07986821c5f1ab5785d69614283bdb9034/websockets-17.0.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8c07f145d0b9e90cbd96035f31fb79199aef4da1872854e36ebeb258e3d57594", size = 222129, upload-time = "2026-07-31T11:30:31.489Z" },
+    { url = "https://files.pythonhosted.org/packages/35/a5/e1b57a59da92ade37fd021567a17b518ea8267b28e5530075844cdb525fe/websockets-17.0.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9f7747d3daa41a11f25f7cca5dc988fc51da97b311bed4c9d843860f79779283", size = 220875, upload-time = "2026-07-31T11:30:32.805Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/30/e7d0889c790a854156de424575fd67af79ddbaed9ff3157ae863dfd1c1dc/websockets-17.0.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:2abb1ba0a5133b7d2ef3c1c9f4b0c1e8a101012dce0b594ab2b2888d9a64820e", size = 218160, upload-time = "2026-07-31T11:30:34.512Z" },
+    { url = "https://files.pythonhosted.org/packages/09/2e/43db785d6ed9ae7594fae7b62bbc9cb4dfee2b015e06a1005f1e5ce283b6/websockets-17.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f3fd9a1f87f8f0f3f8e9f9bd0195f7516562d13f5b178db8c5784d1f60b60bed", size = 220951, upload-time = "2026-07-31T11:30:35.806Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/f5/4ac3cab3d5e8a830657a822f64a8910e3803229c6783e59c3fd9a3487427/websockets-17.0.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2bc14b481e05e331811108daa1aeb41a5e237a5564ef2f02ec5a356a0f102f78", size = 219460, upload-time = "2026-07-31T11:30:37.273Z" },
+    { url = "https://files.pythonhosted.org/packages/03/0e/c3a4020673ffc17c82cf1a467835038a196a555d3b4f2a50f0f063cf8ccc/websockets-17.0.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:57d2ee9b24b404ce75f3814f92073c0ed88106c950148d2427fe8d25ca254d1f", size = 220248, upload-time = "2026-07-31T11:30:38.527Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/87/e47a6a278cc1dfade38444c893ce18322943c25d4b780a74450d9d164be1/websockets-17.0.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:1b363bfd72a52c0658a3154a4cff219f15a474b35a235057d38853bf151acce7", size = 221421, upload-time = "2026-07-31T11:30:39.879Z" },
+    { url = "https://files.pythonhosted.org/packages/da/8f/473d5fc4e3836e375b0233c6ef26777e6e5e3f7bfc84ccd524eae4090ed5/websockets-17.0.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:10b1587c599fa0f2c89154587c80e0fda98ade6c9fa8c0260a2823fb1800b685", size = 218975, upload-time = "2026-07-31T11:30:41.192Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/b9/819ec2dcdf69031d7e9cab11247f3a6ff9bbc8c7c53ada1dbcb9055b227b/websockets-17.0.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d7d72843691f50b91127c50688df10cb72ec6f4c4b1d7e2c11ab33b16acf8e51", size = 219925, upload-time = "2026-07-31T11:30:42.524Z" },
+    { url = "https://files.pythonhosted.org/packages/85/b9/6c0da301f6118502e079cf92f4e864adf28e56b3f8c0f6085076ced7b876/websockets-17.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90973a3a00f23afdfd1c9b06fb84289bf0220f247ef8a62501a1967c7af54f7b", size = 220218, upload-time = "2026-07-31T11:30:44.04Z" },
+    { url = "https://files.pythonhosted.org/packages/55/f9/cba32dc9dd856565263d6272f594255bd0e2781deb8cd982c026a54760ad/websockets-17.0.1-cp314-cp314-win32.whl", hash = "sha256:599b03beb77633bffc095334338fad79cafc2b01fbd58953838130a9ae967d7b", size = 212626, upload-time = "2026-07-31T11:30:45.579Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/95/91cdd8c192287d7ea741f37cf7d64fdc1a14410f06f73805e428a1a590af/websockets-17.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:81ce19c6046ace11da7001781be7317bb1dc389f399af4b2ed962190f76f9add", size = 212969, upload-time = "2026-07-31T11:30:46.983Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/fd/8c98a1e431960661c5769ab1a4dd66494e87ab02d791cc79e51e0d9a289f/websockets-17.0.1-cp314-cp314-win_arm64.whl", hash = "sha256:efe0ae052a8d023b87198921e8a7ce1dc7768816bcd2fbc20df171ac73a04891", size = 212850, upload-time = "2026-07-31T11:30:48.304Z" },
+    { url = "https://files.pythonhosted.org/packages/13/c1/142f5186ee7dc3beee0426b998a79e223e067b7689afcaa95890d64aa800/websockets-17.0.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ab56439c9f74c52770690c7b2f616b3bf775cb3920453ee355ac765c032d8bbf", size = 212967, upload-time = "2026-07-31T11:30:49.688Z" },
+    { url = "https://files.pythonhosted.org/packages/02/de/4b03ed316c9dee180365286c298219809ff247be39beeaaf9958b21167ab/websockets-17.0.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:20a92f78ac8250984ed459faa9ca48c285adbfc0038ddc3fdac6046990a9c9ed", size = 210504, upload-time = "2026-07-31T11:30:50.987Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/d8/ad2b3e8f867e1e8cac3077e2f33ffb60b71bd763d6cfc71bd916f113c3bf/websockets-17.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6a434e59962a4fb9016bea327e1d14d6cd67670ecfb8942b4f4a0c24036634ce", size = 210702, upload-time = "2026-07-31T11:30:52.261Z" },
+    { url = "https://files.pythonhosted.org/packages/48/18/7a77a82ce9d6f831c07b176da3942f7e71acd0f115f3ecdb1d00a040eb01/websockets-17.0.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:2503c7e2a5049a12d5dac917a46d5d52591283a766165b8176bb167560421b38", size = 220290, upload-time = "2026-07-31T11:30:53.582Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/af/43c3e3c3ea7ba4693c2181743f3221957df28bededadcbd9fc8a0661bde0/websockets-17.0.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:28012a54510fe8301bb893ef143cec30a2780a2d3bc20b7bbdf4379d7a63945d", size = 220573, upload-time = "2026-07-31T11:30:54.966Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/bd/ed48eca15725743ee7e2dc172e15c61de29e85ec98dace7b14257f366836/websockets-17.0.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22bd00f8bae2bccdb5dbe41e20f58ba44ca9fff0b4b561aaf39099c35da762ed", size = 221747, upload-time = "2026-07-31T11:30:56.762Z" },
+    { url = "https://files.pythonhosted.org/packages/99/50/838deb7937a8225c4925dd4a977eafea473fabf444178a99de0bc7e92bb0/websockets-17.0.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e98ec9ec61cce5bc4b8b218322ad090b0994eb060bb04da704c62ef0a3d864e6", size = 223891, upload-time = "2026-07-31T11:30:58.127Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e9/657fb70c6eb6bcd01adfa5d2b06496e9911e1c1a8813d353b8c00f7591cd/websockets-17.0.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8e387adb0c692c6b5571bdeafc8ac9d1901ea30f10309134780b16ecd35e6605", size = 222317, upload-time = "2026-07-31T11:30:59.416Z" },
+    { url = "https://files.pythonhosted.org/packages/07/4c/82cb722afa5428fed981331210c4c07600570db01bb1620579f655b5adaf/websockets-17.0.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bd1470d2c53fe53269bf5619da7725d30dd9b9693f1689f7a85eab8dea734442", size = 221047, upload-time = "2026-07-31T11:31:00.757Z" },
+    { url = "https://files.pythonhosted.org/packages/90/84/bd6d67d6bc65f0de0cb50de55dab42f256a9876a351c4736522eb168fda0/websockets-17.0.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:884af729b8ab50486acd94d9768c2b60914bf39b579ebba0a5cb73bfdfd61fd2", size = 218626, upload-time = "2026-07-31T11:31:02.48Z" },
+    { url = "https://files.pythonhosted.org/packages/96/cb/6a372c8553976f0d8f97f5115826ed47e34b3be6b8bf0d0249af249a7416/websockets-17.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a60fa1a25cca1bcc2bf87b8d6be37a741f0a3239fb5e9cfb7a37173b68ffcf87", size = 221299, upload-time = "2026-07-31T11:31:03.795Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/31/f966e8472337974f74d788b3ef6c6f3b8b9a5f201efd16a843c91d269fa5/websockets-17.0.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:e8208f2729cba030ff872a92064c97584eeb9502f53d32a05a0f05d5a17ca6c6", size = 219789, upload-time = "2026-07-31T11:31:05.08Z" },
+    { url = "https://files.pythonhosted.org/packages/57/34/404e83a6cc7b0efcac810b7041bffd72ff76900e6fd0aa45a26c92fb2ffe/websockets-17.0.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:54cdcaa56f5d3eafd57058f0fa4a3de93a310b43a3c4699f06efc4c0bd054a5a", size = 220678, upload-time = "2026-07-31T11:31:06.635Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/70/8946188c2a68d67251859b589a3634918cf7867bf0b891347a5ecaa43d30/websockets-17.0.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:4d41c0a1d47a478bc432b3b9068097bee1ce0c5b19327ea6f75c2ab34ab1f2fb", size = 221697, upload-time = "2026-07-31T11:31:08.023Z" },
+    { url = "https://files.pythonhosted.org/packages/04/16/ee73fc2083a2938ac6209f4ec804960496835b20a0068dbcfe8424957c04/websockets-17.0.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f991247276797d0c61ab7770bc9791eadc16f683b4d83517f624932adc1a8bab", size = 219390, upload-time = "2026-07-31T11:31:09.378Z" },
+    { url = "https://files.pythonhosted.org/packages/94/6a/d5f88033c69932af6cdaa72da62516ade47c257e3bf69f4c0ba5f40e12a2/websockets-17.0.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:733e3cc7171fa1b899edbe725ef9382d0e960657dc1fd933f3281ae910c01dab", size = 220161, upload-time = "2026-07-31T11:31:10.915Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2e/6183dd2c0370287ecf4afe0bb33aca364208e5e7b0e1a286adcaecc0c78b/websockets-17.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:810cb3fb5fa6e447216f4e82d9a85cb8aed0929ae3538153ddfe8a6e3121a58d", size = 220591, upload-time = "2026-07-31T11:31:12.289Z" },
+    { url = "https://files.pythonhosted.org/packages/26/93/70f6516d85b9744f7eac224c4b1b9ef4e84133f80b53be02080cb1c3e663/websockets-17.0.1-cp314-cp314t-win32.whl", hash = "sha256:17ac37716c0244e82c9e384c41653c090b1864c6610224ca3857e7f7b58fce10", size = 212755, upload-time = "2026-07-31T11:31:13.883Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/2c/9d9c1da5a7ea9af307b386d25f64d1dead4729644198d2b92e36db5dfd41/websockets-17.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:bb31f42ea095ea826463c770829aa188a86c9a5c976b1467cbbf583c811de833", size = 213094, upload-time = "2026-07-31T11:31:15.367Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/24/a585e7573e128070605d003b5544729bcd58d9756c7e99d550818ca4b916/websockets-17.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:dbfae8e75b342e31fc6fd1a8bbb393b7cbb91d6cfd581650300a94381e7b7e2b", size = 213009, upload-time = "2026-07-31T11:31:16.776Z" },
+    { url = "https://files.pythonhosted.org/packages/09/ce/3929538b2b9918f5eee623fbf3346893973191f6df93f19bbda097bd7bb7/websockets-17.0.1-py3-none-any.whl", hash = "sha256:c6be9cba65c65cc76dfa3d4619e359ff02a4476c74e179b215236c11a0b32345", size = 206718, upload-time = "2026-07-31T11:31:26.037Z" },
+]
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 00000000..17c0922d
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,19 @@
+services:
+  app:
+    build: .
+    ports:
+      - "8000:8000"
+    env_file:
+      - path: .env
+        required: true
+    volumes:
+      - db-data:/app/data
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/api/health')"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s
+
+volumes:
+  db-data:
diff --git a/docs/DATABASE.md b/docs/DATABASE.md
new file mode 100644
index 00000000..7391a6da
--- /dev/null
+++ b/docs/DATABASE.md
@@ -0,0 +1,28 @@
+# Database
+
+SQLite, created on first backend startup if the file doesn't exist (per [../AGENTS.md](../AGENTS.md)). Schema: [schema.json](schema.json).
+
+## Shape
+
+Four tables, mirroring the frontend's normalized `BoardData` type ([../frontend/src/lib/kanban.ts](../frontend/src/lib/kanban.ts)) directly rather than introducing a different in-DB representation:
+
+```text
+users (id, username, password)
+  └─ boards (id, user_id UNIQUE)         -- UNIQUE enforces "1 board per user" for the MVP
+       └─ columns (id, board_id, title, position)
+            └─ cards (id, column_id, title, details, position)
+```
+
+- `columns.id` / `cards.id` are `TEXT`, using the same string ids the frontend already generates (`col-backlog`, `card-1`, ids from `createId()`), so the API layer can pass ids straight through without an int↔string mapping.
+- `users.id` / `boards.id` are `INTEGER AUTOINCREMENT` — internal-only, never sent to the frontend.
+- Ordering: the frontend's `Column.cardIds` array (and the board's column order) becomes a `position` integer column, read back with `ORDER BY position`.
+- `ON DELETE CASCADE` on both FKs so removing a board/column cleans up its children without the API doing it manually.
+
+## Seeding
+
+On first run: insert the hardcoded user row (`user` / `password`), then a board for that user seeded with the frontend's existing `initialData` (5 columns, 8 cards) so the Part 6 API has something to return immediately.
+
+## Decisions (approved)
+
+1. **The `users.password` column is not used for authentication.** Login keeps checking the hardcoded constants in `backend/app/auth.py`, not the database. The `users` table exists to give `boards` a real foreign-key owner and to model the future multi-user shape `AGENTS.md` calls for, not to drive login.
+2. **Sessions stay in-memory, not DB-backed.** No `sessions` table. Session loss on a backend restart is a non-issue for local MVP dev.
diff --git a/docs/PLAN.md b/docs/PLAN.md
index 974fc652..51d86f3d 100644
--- a/docs/PLAN.md
+++ b/docs/PLAN.md
@@ -1,37 +1,200 @@
 # High level steps for project
 
-Part 1: Plan
+See [../AGENTS.md](../AGENTS.md) for business requirements, technical decisions, and coding standards. See [../frontend/AGENTS.md](../frontend/AGENTS.md) for the existing frontend code.
 
-Enrich this document to plan out each of these parts in detail, with substeps listed out as a checklist to be checked off by the agent, and with tests and success critieria for each. Also create an AGENTS.md file inside the frontend directory that describes the existing code there. Ensure the user checks and approves the plan.
+Work through parts in order. Each part ends with the checkboxes ticked, its tests passing, and (where noted) explicit user sign-off before moving to the next part.
 
-Part 2: Scaffolding
+## Part 1: Plan
 
-Set up the Docker infrastructure, the backend in backend/ with FastAPI, and write the start and stop scripts in the scripts/ directory. This should serve example static HTML to confirm that a 'hello world' example works running locally and also make an API call.
+- [x] Enrich this document with substeps, tests, and success criteria per part
+- [x] Create `frontend/AGENTS.md` describing the existing frontend code
+- [ ] User reviews and approves this plan
 
-Part 3: Add in Frontend
+**Success criteria:** user has explicitly approved this plan before Part 2 starts.
 
-Now update so that the frontend is statically built and served, so that the app has the demo Kanban board displayed at /. Comprehensive unit and integration tests.
+## Part 2: Scaffolding
 
-Part 4: Add in a fake user sign in experience
+Set up Docker infrastructure, the FastAPI backend, and start/stop scripts. Prove the container runs, serves a static "hello world" page, and answers an API call.
 
-Now update so that on first hitting /, you need to log in with dummy credentials ("user", "password") in order to see the Kanban, and you can log out. Comprehensive tests.
+- [x] `backend/pyproject.toml` set up for `uv`, FastAPI + uvicorn as dependencies
+- [x] `backend/app/main.py`: FastAPI app with a `GET /api/health` route returning `{"status": "ok"}`
+- [x] `backend/app/main.py`: mount a `static/` directory at `/` (placeholder `index.html` with "Hello world" for now — real frontend build comes in Part 3)
+- [x] `Dockerfile` at project root: multi-stage or single-stage build using `uv` to install backend deps, copies a `static/` placeholder, runs uvicorn on container start
+- [x] `docker-compose.yml` (or plain `docker run` documented in scripts) exposing the app port, mounting a volume for the SQLite db file so data persists across container restarts
+- [x] `scripts/start.sh`, `scripts/stop.sh` (Mac/Linux) and `scripts/start.ps1`, `scripts/stop.ps1` (Windows/PowerShell) that build/run and stop the container
+- [x] `.env.example` documenting `OPENROUTER_API_KEY` (root `.env` does not exist yet in this checkout — copy `.env.example` to `.env` and fill in the key; `docker-compose.yml` treats it as optional so the container still starts without it)
+- [x] `.gitignore` covers `.env`, `__pycache__`, `.venv`, `node_modules`, `*.db`, `.next`, docker build artifacts
 
-Part 5: Database modeling
+**Tests / verification:**
 
-Now propose a database schema for the Kanban, saving it as JSON. Document the database approach in docs/ and get user sign off.
+- `scripts/start.sh` (or `.ps1`) brings the container up; `curl http://localhost:8000/` returns the placeholder HTML page — verified
+- `curl http://localhost:8000/api/health` returns `{"status": "ok"}` with HTTP 200 — verified
+- `scripts/stop.sh` cleanly stops the container — verified
+- `uv run pytest` in `backend/` (2 tests: health route, root page) — verified
 
-Part 6: Backend
+**Success criteria:** a fresh clone + `.env` with a valid key + running the start script serves both the hello-world page and a working health-check API call, entirely inside Docker. Met, except no valid `OPENROUTER_API_KEY` was available to test with — the key isn't needed until Part 8, so this doesn't block Part 2.
 
-Now add API routes to allow the backend to read and change the Kanban for a given user; test this thoroughly with backend unit tests. The database should be created if it doesn't exist.
+## Part 3: Add in Frontend
 
-Part 7: Frontend + Backend
+Statically build the existing Next.js frontend and serve it from FastAPI at `/`, replacing the placeholder page. Comprehensive unit and integration tests.
 
-Now have the frontend actually use the backend API, so that the app is a proper persistent Kanban board. Test very throughly.
+- [x] Configure Next.js for static export (`output: "export"` in `next.config.ts`) since FastAPI serves static files, not a Node server
+- [x] Update `Dockerfile` to a multi-stage build: Node stage runs `npm run build` (static export) into `frontend/out`, copied into the backend's static directory in the final Python stage
+- [x] FastAPI serves the built frontend at `/` (and its assets); unmatched paths resolve to their pre-rendered `<path>.html` file (`NextStaticFiles` in `backend/app/main.py`) — more precise than a blind index.html fallback, since Next's static export pre-renders each route (e.g. `/login`) to its own HTML file rather than one SPA shell
+- [x] `scripts/start.sh`/`.ps1` rebuild the Docker image so frontend changes are picked up (already true via `docker compose up --build`)
+- [x] Existing frontend unit tests (`npm run test:unit`) and e2e tests (`npm run test:e2e`) still pass — verified against `next dev` (Playwright's existing config), and separately against the real static export by curling the running Docker container
+- [x] Add a backend test asserting static routing behavior, incl. serving prerendered pages by path (`backend/tests/test_static_routing.py`, exercising `NextStaticFiles` directly with a temp directory rather than depending on a real frontend build being present for `pytest` to run)
 
-Part 8: AI connectivity
+**Tests / verification:**
 
-Now allow the backend to make an AI call via OpenRouter. Test connectivity with a simple "2+2" test and ensure the AI call is working.
+- `npm run test:all` in `frontend/` passes unchanged — verified (6 unit tests, 3 e2e tests)
+- Backend: 5 pytest tests pass, including the new static-routing tests — verified
+- Manual: `docker compose up --build`, `curl http://localhost:8000/` returns the real "Kanban Studio" board HTML (not the Part 2 placeholder), `curl http://localhost:8000/api/health` still OK — verified
 
-Part 9: Now extend the backend call so that it always calls the AI with the JSON of the Kanban board, plus the user's question (and conversation history). The AI should respond with Structured Outputs that includes the response to the user and optionaly an update to the Kanban. Test thoroughly.
+**Success criteria:** the Kanban demo is served from the Dockerized backend at `/`, indistinguishable in behavior from running `npm run dev` directly, with all existing frontend tests green. Met.
 
-Part 10: Now add a beautiful sidebar widget to the UI supporting full AI chat, and allowing the LLM (as it determines) to update the Kanban based on its Structured Outputs. If the AI updates the Kanban, then the UI should refresh automatically.
\ No newline at end of file
+## Part 4: Add in a fake user sign in experience
+
+Gate `/` behind a hardcoded login (`user` / `password`); support logout. Comprehensive tests.
+
+- [x] Backend: `POST /api/login` accepts `{username, password}`, checks against hardcoded `user`/`password`, on success sets an HttpOnly session cookie (`backend/app/auth.py`: random token via `secrets.token_urlsafe`, stored server-side in-memory in a module-level set — will move to the SQLite db in Part 6 if needed, but an in-memory session is fine for a single hardcoded user)
+- [x] Backend: `POST /api/logout` clears the session
+- [x] Backend: `GET /api/session` returns whether the current request is authenticated
+- [x] Backend: static file serving for `/` and other app routes does not require a session (unauthenticated requests still get the SPA shell; `AuthGate` on the frontend handles the redirect client-side, since static export has no per-request server logic); a reusable `require_session` dependency exists in `auth.py` for Part 6's board routes to enforce 401 when unauthenticated
+- [x] Frontend: `/login` route with a simple form (username, password, submit button styled with the existing color tokens), calls `POST /api/login`, redirects to `/` on success, shows an error on failure
+- [x] Frontend: on load, `/` (`AuthGate`) checks `GET /api/session`; if unauthenticated, redirect to `/login`
+- [x] Frontend: a logout control in the board header that calls `POST /api/logout` and redirects to `/login`
+
+**Tests / verification:**
+
+- Backend: 13 pytest tests (up from 5) — login with correct/incorrect credentials, session persists across requests via cookie, logout invalidates the session, `require_session` dependency rejects/allows correctly — verified
+- Frontend unit tests: `src/lib/auth.test.ts`, `src/app/login/page.test.tsx`, `src/components/AuthGate.test.tsx` (mocked `fetch`/`next/navigation`) — 15 tests total, verified
+- Playwright e2e (`tests/auth.spec.ts`): logged-out redirect to `/login`, correct-credentials login reaches the board, wrong credentials show an error and stay on `/login`, logout returns to `/login` and blocks board access again — all verified against the real Docker container
+- `tests/kanban.spec.ts` updated to log in via `page.request.post("/api/login", ...)` in a `beforeEach` (the board is now gated) — still passing
+- Manual: full login → session → logout → session curl sequence against the running container — verified
+
+**Success criteria:** the Kanban board is unreachable without logging in with the hardcoded credentials, and logout fully revokes access, verified end-to-end by Playwright. Met.
+
+**Notable fixes/decisions made along the way:**
+
+- **Static export + `/api/*` don't mix in `next dev`.** `output: "export"` forbids `rewrites()` in `next.config.ts`, but without a rewrite, `next dev`'s relative `/api/login` calls have nowhere to go. Fixed with Next's supported phase-based config (`next.config.ts` is now a function of `phase`): dev mode gets a rewrite proxying `/api/*` to `http://127.0.0.1:8000`, production/export mode gets `output: "export"`. `playwright.config.ts` now starts both `uvicorn` (port 8000) and `next dev` (port 3000) via an array of `webServer` entries.
+- **Next.js 16's static export directory collision.** For a route like `/login`, Next writes both `login.html` (the real page) *and* a `login/` directory (RSC prefetch data, no `index.html` inside). Starlette's `StaticFiles` matches the directory first and then 404s. `NextStaticFiles` in `backend/app/main.py` now tries `<path>.html` *before* the raw path, with a regression test (`test_html_file_wins_over_a_same_named_directory`) covering it — caught by curling `/login` against the real built container, not by any local test alone, so container-level manual verification remains part of the checklist for a reason.
+
+## Part 5: Database modeling
+
+Propose a schema for the Kanban data, get sign-off before building on it.
+
+- [x] Design SQLite schema: `users` (id, username, password — hardcoded row seeded on first run), `boards` (id, user_id, FK to users, one board per user per MVP constraint), `columns` (id, board_id, title, position), `cards` (id, column_id, title, details, position)
+- [x] Write the schema as JSON (e.g. `docs/schema.json`) describing tables, columns, types, and relationships, mirroring the SQL design
+- [x] Document the approach in `docs/DATABASE.md`: why this shape (maps directly onto the frontend's normalized `BoardData`/`Column`/`Card` types), how positions/ordering work, how it'll be created on first run
+- [x] Present schema to user, get explicit sign-off — approved; login stays checking the hardcoded constants in `auth.py` (not the `users` table), and sessions stay in-memory (no `sessions` table)
+
+**Tests / verification:** none (design-only phase) — verification is user approval of `docs/schema.json` and `docs/DATABASE.md`.
+
+**Success criteria:** user has explicitly approved the schema before any backend code touches the database. Met.
+
+## Part 6: Backend
+
+Implement the API routes for reading/changing the Kanban board, backed by SQLite, created on first run if missing.
+
+- [x] SQLite setup: on backend startup, create the db file and tables from the Part 5 schema if they don't exist; seed the hardcoded user and an initial board (reusing the frontend's `initialData` shape) if empty (`backend/app/db.py`: `init_db`, run from a FastAPI `lifespan` in `main.py`)
+- [x] `GET /api/board` — returns the current user's board as `BoardData` JSON (columns + cards, matching `frontend/src/lib/kanban.ts` types)
+- [x] `PATCH /api/columns/:id` — rename a column
+- [x] `POST /api/cards` — create a card in a column
+- [x] `PATCH /api/cards/:id` — edit a card's title/details, and/or move it (column + position)
+- [x] `DELETE /api/cards/:id` — remove a card
+- [x] All board routes require an authenticated session (401 otherwise) — `require_session` dependency from Part 4
+- [x] Backend unit tests (pytest) for every route: happy path, not-found cases, unauthenticated case, and (for move/reorder) that column/card ordering persists correctly (`backend/tests/test_board.py`, 15 tests)
+
+**Tests / verification:**
+
+- `pytest` in `backend/` covers all routes above with real SQLite (temp db per test run via a `DATABASE_PATH` env var + `tmp_path`, not the dev db) — 27 tests total, verified
+- Manual: created a card via `curl`, ran `docker restart pm-app-1` (not a fresh container — a real restart of the same one, volume intact), logged back in, confirmed the card was still there — verified
+- Also added an in-process equivalent (`test_board_persists_across_reconnects_to_the_same_database`) that closes and reopens the SQLite connection against the same file, for a fast regression check without needing Docker
+
+**Success criteria:** every board mutation available in the current frontend UI has a corresponding, tested backend route, and data survives a container restart. Met.
+
+**Notable decisions:**
+
+- **Board lookup ignores user identity.** Sessions (Part 4) are just a set of valid tokens with no user id attached, and there's only ever one board in this MVP, so `_get_board_id` in `board.py` does `SELECT id FROM boards LIMIT 1` rather than threading a user id through. Documented in the function's own comment so it isn't mistaken for an oversight if Part 5's "keep login on hardcoded constants" decision is revisited later.
+- **Every mutating route returns the full updated `BoardData`**, not just the changed row — simplest contract for Part 7's frontend integration (replace local state with the response), and matches how the AI chat in Part 9/10 will need to push whole-board updates anyway.
+- **Reordering renumbers positions sequentially** (0..n-1) on every move rather than using a gap/fractional scheme — simplest correct approach at this scale (a handful of cards per column), avoids ever needing to "rebalance" positions.
+
+## Part 7: Frontend + Backend
+
+Wire the frontend to the real backend so the app is a persistent Kanban board end to end.
+
+- [x] Add a small fetch-based API client in `frontend/src/lib/` (`api.ts`) for board/card/column requests, using relative `/api/...` paths (same-origin, since FastAPI serves the static build)
+- [x] Replace `KanbanBoard`'s hardcoded `initialData` with a fetch of `GET /api/board` on mount (loading state while fetching)
+- [x] Wire `onRename`, `onAddCard`, `onDeleteCard`, and drag-end (move) handlers to call the corresponding backend routes instead of only updating local state; keep optimistic local updates for responsiveness, reconciling with the server response or rolling back on error
+- [x] Handle the 401 case (session expired) by redirecting to `/login` (`UnauthorizedError` from `api.ts`, `onUnauthorized` prop threaded through `AuthGate` → `KanbanBoard`)
+
+**Tests / verification:**
+
+- Frontend unit tests updated to mock the API client instead of relying on `initialData` (`KanbanBoard.test.tsx`) — plus new `src/lib/api.test.ts` for the client itself; 25 frontend unit tests total, verified
+- New Playwright e2e run against `next dev` + local backend (both started by `playwright.config.ts`'s `webServer` array from Part 4): log in, add a card, rename a column, drag a card between columns, reload the page, confirm changes persisted — verified, plus re-verified against the real Docker container via `curl`
+- Backend pytest suite still green — 27 tests, verified
+
+**Success criteria:** reloading the page (or restarting the container) never loses board changes made through the UI; the frontend has no more hardcoded board data. Met.
+
+**Notable decisions:**
+
+- **Every mutation reconciles by replacing the whole board with the server's response** (`.then(setBoard, handleApiError)`), and on error, `handleApiError` refetches the whole board from the server rather than manually rolling back to a locally-tracked "previous" snapshot per handler — simpler, and more correct (it converges on true server state instead of a possibly-stale local one).
+- **Column rename is debounced (400ms)**, not sent on every keystroke — `onRename` fires on every `input` change (existing behavior from the local-state days), and calling the API per keystroke would be excessive. Local state still updates immediately for a responsive input; only the network call is debounced.
+- **e2e tests no longer assume pristine seed data.** Once the board is really persisted, an assumption like "card-1 starts in col-backlog" only holds on the very first run — a later run (or a concurrent one) may have already moved it. `kanban.spec.ts` now creates its own uniquely-titled column rename / card per test instead. Also set `workers: 1` in `playwright.config.ts` since the board is shared, persistent state across all tests in a run — parallel workers would race each other mutating it. (`board.py`'s `add_card` originally had a real TOCTOU race on position assignment too, flagged here — since fixed with an explicit `BEGIN IMMEDIATE` transaction around the read-then-insert.)
+- **The optimistic add-card update uses a temporary id** (`card-pending-<timestamp>`) swapped for the real server id on reconciliation — this briefly unmounts/remounts the card's DOM node (React key changes), which flaked the Playwright drag test until it was changed to wait for the `POST /api/cards` response before computing drag coordinates, rather than grabbing them right after the optimistic render.
+
+## Part 8: AI connectivity
+
+Add a minimal OpenRouter call from the backend, proven working before building the real chat feature.
+
+- [x] `backend` OpenRouter client using `OPENROUTER_API_KEY` from `.env` (`backend/app/ai.py`: `complete()`), model `openai/gpt-oss-120b`
+- [x] `POST /api/ai/test` (auth-gated like the other routes) sends a "what is 2+2?" prompt and returns the reply
+- [x] Handle and surface API errors (missing key, network failure, non-2xx from OpenRouter) clearly — all raise `OpenRouterError`, mapped to a 502 at the route
+
+**Tests / verification:** integration test (marked to skip if `OPENROUTER_API_KEY` is absent) that calls OpenRouter with the 2+2 prompt and checks the answer, plus unit tests (mocked `httpx.post`) for missing-key/network-error/non-200/malformed-response, plus route tests for the auth gate and 502 mapping — `backend/tests/test_ai.py`, 8 tests.
+
+**Success criteria:** a real OpenRouter call succeeds against `openai/gpt-oss-120b` and the test asserts on the actual model output, not a mock. **Not yet met** — the `.env` key currently returns `401: {"error":{"message":"User not found.","code":401}}` from OpenRouter itself (not a bug here: the other 7 tests in `test_ai.py`, including auth gating and every error-handling path, pass). Everything else in this part is implemented and tested; re-run `uv run pytest tests/test_ai.py::test_complete_real_2_plus_2` once `.env` has a working key to close this out.
+
+## Part 9: Structured AI board updates
+
+Extend the AI call to always include the current board JSON plus the user's message and conversation history, and require Structured Outputs with a chat reply and an optional board update.
+
+- [x] Define the Structured Output JSON schema: `{ reply: string, board_update: BoardData | null }` — full-board replacement, not a diff (see decisions below for why, and for how `board_update`'s wire shape differs slightly from the internal `BoardData`)
+- [x] `POST /api/chat` — accepts `{message}` (see decisions: history is server-tracked per session, not client-supplied), loads the current board, calls OpenRouter with system prompt + board JSON + history + message, requests the structured schema, applies `board_update` to the database if present, returns `{reply, board: <updated BoardData or unchanged>}`
+- [x] Validate `board_update` before applying (referenced column/card ids exist, no orphaned cards, no duplicate column ids, no card claimed by two columns) and reject/ignore invalid updates rather than corrupting the board (`backend/app/chat.py`: `parse_board_update` / `_validate_board_update`)
+- [x] Conversation history persisted per session for the duration of the chat (in-memory `dict[session_id, list[message]]` in `chat.py`, cleared on logout — consistent with Part 5's decision to keep sessions themselves in-memory too)
+
+**Tests / verification:**
+
+- Backend tests (real OpenRouter call, skipped without an API key) for: a question that shouldn't change the board (reply only), and an instruction that should create/move/edit a card (board updates correctly and persists) — written, **blocked on the same `.env` key issue as Part 8** (`401: User not found`); everything else in this part is implemented and tested
+- Backend unit tests (mocked OpenRouter response) for schema validation/rejection of a malformed `board_update` — plus route-level tests (reply-only, valid update applied+persisted, invalid update ignored, 401 without auth, 502 on `OpenRouterError`, history accumulates across calls) — `backend/tests/test_chat.py`, 15 tests, 13 passing / 2 blocked on the key
+- Full backend suite: 49 tests, 46 passing (3 blocked on the key: 1 from Part 8's `test_ai.py`, 2 from `test_chat.py`) — verified
+- Manual: rebuilt the Docker container, confirmed `/api/chat` returns 401 unauthenticated and a clean 502 (not a crash) with the current broken key
+
+**Success criteria:** a chat message like "move the login bug card to Done" results in the correct database change and a sensible reply, verified against the real model at least once. **Not yet met** — blocked on a working `OPENROUTER_API_KEY`, same as Part 8. Re-run `uv run pytest tests/test_chat.py -k real` once `.env` has a working key.
+
+**Notable decisions:**
+
+- **`board_update` is a full-board replacement**, not a diff/patch — matches what was already flagged as the likely direction back in Part 6's notes. Applying it is a delete-and-reinsert (`board.py`'s new `replace_board`), simpler than diffing at this scale. The real risk with full-replacement is the AI silently *dropping* a card/column it wasn't asked to touch — mitigated only by an explicit system-prompt instruction ("include all the ones you didn't change"), not by any structural check (a valid-but-incomplete board is still schema-valid). Worth watching once this is tested against the real model.
+- **`board_update`'s wire shape differs slightly from the internal `BoardData`**: `cards` is sent as an **array** of `{id, title, details}`, not the dict-keyed-by-id shape the frontend and internal API use. Strict-mode JSON Schema structured outputs don't support a dynamic dict of properties (`additionalProperties` with arbitrary keys isn't compatible with `strict: true`), so the array form is what's requested from the model; `parse_board_update` converts it to the dict-keyed `BoardData` immediately after parsing.
+- **History is server-tracked per session, not client-supplied**, despite the plan's original `{message, history}` wording — the server already has to track sessions in memory (Part 4/5), so also holding conversation history there avoids the client re-sending a growing transcript on every request and avoids trusting client-supplied history. `POST /api/chat` only takes `{message}`.
+- **`/api/ai/test` and `/api/chat` now duplicate less**: refactored `ai.py`'s `complete()` into a shared `_post_chat_completion` / `_extract_content` pair, with `complete()` (plain) and `complete_structured()` (JSON-schema mode) both thin wrappers over it — `chat.py` doesn't reimplement the OpenRouter HTTP/error-handling logic.
+
+## Part 10: AI chat sidebar UI
+
+Add the chat sidebar to the frontend, wired to `/api/chat`, refreshing the board automatically on AI-driven updates.
+
+- [x] Sidebar component (collapsible, styled with the existing color tokens) with message list and input, alongside the Kanban board (`frontend/src/components/ChatSidebar.tsx`)
+- [x] Sends user messages to `POST /api/chat` (history is server-tracked per session, per Part 9's decision — the sidebar just sends `{message}`), appends the AI reply to the message list
+- [x] If the response includes an updated board, replace local board state with it so the Kanban UI reflects AI-made changes immediately (no manual refresh) — `onBoardUpdate` prop wired straight to `KanbanBoard`'s `setBoard`
+- [x] Loading ("Thinking…") and error states for the chat call
+
+**Tests / verification:**
+
+- Frontend unit tests for the sidebar (mocked `@/lib/api`): starts collapsed, sending a message appends both messages, a response with a board update calls `onBoardUpdate`, a failed request shows an error and does not call `onBoardUpdate` — `ChatSidebar.test.tsx`, 3 tests; plus a `KanbanBoard.test.tsx` check that the toggle renders — 27 frontend unit tests total, all passing
+- Playwright e2e (real backend): `tests/chat.spec.ts` creates a card, asks the assistant to move it to Done, confirms it moved without a reload — written and correctly exercises the whole path, but **currently fails for the same reason as Parts 8–9**: `/api/chat` returns 502 because of the `.env` key issue, so the card never moves. Re-run once the key works.
+- Manual: visually checked the sidebar in a real browser (Playwright screenshot) and caught a real layout bug doing so — the fixed-position sidebar overlapped the rightmost board columns at normal viewport widths. Fixed by lifting the open/closed state into `KanbanBoard` (`ChatSidebar`'s new `onOpenChange` prop) so the board reserves right-padding (`xl:pr-[400px]`) while the sidebar is open. Re-verified with another screenshot.
+- Full suites re-verified after the fix: 27/27 frontend unit tests, 7/8 e2e (1 blocked on the key), 46/49 backend (3 blocked on the key) — rebuilt and manually checked in the real Docker container too.
+
+**Success criteria:** using the chat sidebar to ask the AI to create, edit, or move a card produces an immediate, correct, visible update to the Kanban board. **Not yet verified end-to-end** — blocked on the same `OPENROUTER_API_KEY` issue as Parts 8–9. Everything up to and including the OpenRouter call itself is implemented, tested, and (for the non-AI parts) working; re-run `npx playwright test chat.spec.ts` once `.env` has a working key to close this out — that's the single remaining gate on the whole app being fully functional.
diff --git a/docs/review.md b/docs/review.md
new file mode 100644
index 00000000..02ad8da2
--- /dev/null
+++ b/docs/review.md
@@ -0,0 +1,62 @@
+# Code Review
+
+Date: 2026-08-10
+Scope: full repository (`backend/`, `frontend/`, Docker/deploy config), as of the current working tree (no commits yet in this repo).
+
+## Summary
+
+This is a small, well-scoped Kanban MVP (FastAPI + SQLite backend, Next.js static-export frontend, single hardcoded user, AI chat that can edit the board via OpenRouter). Overall quality is high for an MVP: clear separation of concerns (`auth.py` / `db.py` / `board.py` / `ai.py` / `chat.py`), decent test coverage on the backend (auth, board CRUD, chat, static routing, AI error paths) and reasonable frontend test coverage (unit + Playwright e2e). `docs/PLAN.md` and `docs/DATABASE.md` show that several things that might otherwise look like bugs (hardcoded auth, in-memory sessions, unused `users.password` column) are **deliberate, documented MVP simplifications** — those are not re-flagged as findings below.
+
+Only one finding rises above "low": the Docker healthcheck is likely broken because `curl` probably isn't installed in the final image.
+
+## Findings
+
+### 1. ~~Docker healthcheck likely always fails~~ — FIXED
+
+`docker-compose.yml` ran `CMD ["curl", "-f", "http://localhost:8000/api/health"]` inside the container, but the final stage's base image, `ghcr.io/astral-sh/uv:python3.12-bookworm-slim`, does not install `curl` (the Dockerfile never runs `apt-get install`). Debian slim images don't ship `curl` by default, so the healthcheck command would most likely have failed with "executable file not found," making the container permanently report `unhealthy` even though the app is running fine.
+
+- `docker-compose.yml:11-16`, `Dockerfile:11-26`
+- `docs/PLAN.md` documents curling the app from the **host** (`curl http://localhost:8000/...`) as verification, which is a different thing from the in-container `HEALTHCHECK`.
+- **Fix applied**: swapped the healthcheck to `python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/api/health')"`, which uses the Python already present in the image instead of an uninstalled `curl`. **Verified** via `docker compose up --build`: `docker compose ps` / `docker inspect` show `STATUS: healthy` once the app is up (the one check during the `start_period` before uvicorn is listening fails with connection-refused as expected and doesn't count against the retry budget).
+
+### 2. Card title can be blanked out with no server-side validation
+
+`CreateCardRequest.title` requires `min_length=1` (`backend/app/main.py:111`), but `UpdateCardRequest.title` has no such constraint (`backend/app/main.py:116`) and `Card`/`Column` in `board.py` place no constraints on `title` either. Two consequences:
+
+- `PATCH /api/cards/{id}` with `{"title": ""}` succeeds and blanks the card's title. The UI never sends this today, but the API allows it.
+- The AI chat's `board_update` JSON schema (`backend/app/chat.py:24-64`) also has no `minLength` on `title`, so a model response with an empty title would pass `_validate_board_update` and get written to the board.
+- Suggested fix: add `Field(min_length=1)` to `UpdateCardRequest.title`/`RenameColumnRequest` is already fine, and add `"minLength": 1` to the `title` fields in `RESPONSE_SCHEMA`.
+
+### 3. `ChatSidebar` doesn't handle session expiry the way the rest of the app does
+
+`KanbanBoard` routes every API failure through `handleApiError`, which specifically checks for `UnauthorizedError` and calls `onUnauthorized` to redirect to `/login` (`frontend/src/components/KanbanBoard.tsx:70-77`). `ChatSidebar.handleSubmit` calls `api.sendChatMessage` directly and catches everything generically as "Something went wrong sending that message" (`frontend/src/components/ChatSidebar.tsx:46-54`), without distinguishing a `401`/expired session. If the session cookie is gone (server restart clears in-memory sessions, or manual logout in another tab), the chat just shows a generic error instead of sending the user to `/login` like every other board action does. No test covers this path either (`ChatSidebar.test.tsx` has no 401 case).
+
+- Suggested fix: thread `onUnauthorized` (or reuse `handleApiError`) into `ChatSidebar`, same as `KanbanBoard`.
+
+### 4. `replace_board` isn't transactionally safe against partial failure
+
+`add_card` wraps its read-modify-write in `BEGIN IMMEDIATE` / `commit` / `rollback` (`backend/app/board.py:85-100`), but `replace_board` — used for every AI-driven board update — does a bare `DELETE` followed by a loop of `INSERT`s and a single `commit()` at the end with no `try`/`except`/`rollback` (`backend/app/board.py:184-206`). If an exception is raised partway through the insert loop (e.g. a future schema constraint violation), the columns for the board would already be deleted with no rollback, leaving the board empty. Low likelihood today since `_validate_board_update` pre-validates shape, but the inconsistency with `add_card`'s pattern is worth closing.
+
+### 5. Stale/incorrect statement in `docs/PLAN.md` about the env file being optional
+
+`docs/PLAN.md:25` says "`docker-compose.yml` treats it as optional so the container still starts without it," but the current `docker-compose.yml:6-8` sets `env_file: { path: .env, required: true }` — `docker compose up` will now fail outright if `.env` is missing, contradicting the doc. Not a code bug (a `.env` is present in this checkout), but worth fixing the doc or reverting the compose file to match the documented intent, since a new contributor following the doc's "just skip `.env`" claim will hit a hard failure.
+
+### 6. Per-session chat history grows unbounded
+
+`_HISTORY` in `backend/app/chat.py:11` accumulates every user/assistant turn for the lifetime of a session with no cap or truncation, and the full history plus the full board JSON is sent to OpenRouter on every `/api/chat` call (`backend/app/chat.py:87-97`). For a short-lived local MVP session this is fine, but a long chat session will make each request slower and more expensive, and could eventually exceed the model's context window. Worth a note for whenever this moves past MVP (e.g. cap history length, or summarize older turns).
+
+### 7. No CI
+
+There's no `.github/workflows` (or equivalent) running `pytest` / `npm run test:all` / lint on push. Given the project already has solid test suites on both sides, wiring them into CI would be low effort and catch regressions before they reach `main`.
+
+## Nice to have / not blocking
+
+- The final image's base tag (`ghcr.io/astral-sh/uv:python3.12-bookworm-slim`) isn't digest-pinned, so a rebuild months from now could pick up a different `uv`/Python patch version silently. Fine for an MVP; consider pinning by digest if reproducibility matters later.
+- `frontend/src/components/KanbanBoard.tsx:125` generates optimistic temp card ids from `Date.now()`; two adds within the same millisecond (not realistically reachable via the UI's own click-to-open-form flow) would collide. Not worth changing given `NewCardForm` can't produce that in practice.
+
+## Strengths worth keeping
+
+- Backend tests are thorough and test the *right* things: auth boundaries on every route, 404s on all not-found paths, AI-failure paths (`OpenRouterError` → 502), and a real "board update gets rejected if malformed" contract (`test_chat.py`, `chat.py`'s `_validate_board_update`).
+- `NextStaticFiles` (`backend/app/main.py:43-58`) and its dedicated test file solve a genuinely subtle Next.js static-export routing gotcha, with a clear docstring explaining *why*.
+- Frontend keeps optimistic UI updates simple and self-healing: on any API error the board just refetches from the server (`handleApiError` in `KanbanBoard.tsx`), rather than hand-rolling rollback logic per action.
+- `docs/PLAN.md` and `docs/DATABASE.md` clearly record *why* certain shortcuts were taken (hardcoded auth, in-memory sessions, unused `users.password`), which made this review far easier — most "looks like a bug" candidates turned out to be documented, intentional MVP tradeoffs.
diff --git a/docs/schema.json b/docs/schema.json
new file mode 100644
index 00000000..442930f2
--- /dev/null
+++ b/docs/schema.json
@@ -0,0 +1,55 @@
+{
+  "$comment": "SQLite schema for the PM Kanban app. See DATABASE.md for rationale.",
+  "tables": {
+    "users": {
+      "description": "Single hardcoded user for the MVP; table exists so boards have a real FK owner and the schema supports multiple users later.",
+      "columns": {
+        "id": { "type": "INTEGER", "primaryKey": true, "autoincrement": true },
+        "username": { "type": "TEXT", "notNull": true, "unique": true },
+        "password": { "type": "TEXT", "notNull": true }
+      },
+      "seed": [{ "username": "user", "password": "password" }]
+    },
+    "boards": {
+      "description": "One board per user (MVP constraint enforced via UNIQUE on user_id).",
+      "columns": {
+        "id": { "type": "INTEGER", "primaryKey": true, "autoincrement": true },
+        "user_id": {
+          "type": "INTEGER",
+          "notNull": true,
+          "unique": true,
+          "references": { "table": "users", "column": "id", "onDelete": "CASCADE" }
+        }
+      }
+    },
+    "columns": {
+      "description": "Kanban columns. `id` matches the frontend's string Column.id (e.g. 'col-backlog'). `position` gives display order within a board.",
+      "columns": {
+        "id": { "type": "TEXT", "primaryKey": true },
+        "board_id": {
+          "type": "INTEGER",
+          "notNull": true,
+          "references": { "table": "boards", "column": "id", "onDelete": "CASCADE" }
+        },
+        "title": { "type": "TEXT", "notNull": true },
+        "position": { "type": "INTEGER", "notNull": true }
+      },
+      "indexes": [{ "columns": ["board_id", "position"] }]
+    },
+    "cards": {
+      "description": "Kanban cards. `id` matches the frontend's string Card.id (e.g. 'card-1'). `position` gives display order within a column.",
+      "columns": {
+        "id": { "type": "TEXT", "primaryKey": true },
+        "column_id": {
+          "type": "TEXT",
+          "notNull": true,
+          "references": { "table": "columns", "column": "id", "onDelete": "CASCADE" }
+        },
+        "title": { "type": "TEXT", "notNull": true },
+        "details": { "type": "TEXT", "notNull": true, "default": "" },
+        "position": { "type": "INTEGER", "notNull": true }
+      },
+      "indexes": [{ "columns": ["column_id", "position"] }]
+    }
+  }
+}
diff --git a/frontend/AGENTS.md b/frontend/AGENTS.md
new file mode 100644
index 00000000..b1fdabd5
--- /dev/null
+++ b/frontend/AGENTS.md
@@ -0,0 +1,91 @@
+# Frontend
+
+Next.js (App Router) frontend for the Kanban board, statically exported (`output: "export"` in `next.config.ts`) and served by the FastAPI backend — see [../backend/AGENTS.md](../backend/AGENTS.md) for how (`NextStaticFiles` resolves `/login` etc. to their pre-rendered `login.html`). `/` is gated behind a hardcoded login (Part 4). The board is backed by the real API and SQLite (Part 7) — no more hardcoded `initialData` in the running app; it survives reloads and container restarts. A collapsible AI chat sidebar (Part 10, `ChatSidebar.tsx`) lets the user ask the assistant to create/edit/move cards, applying `POST /api/chat`'s board response directly (see [../docs/PLAN.md](../docs/PLAN.md)) — this is the last piece of the MVP, and end-to-end verification of the AI path itself is currently blocked on a working `OPENROUTER_API_KEY` (see Part 8's note in the plan).
+
+Because of static export, no Next.js server-side features (API routes, SSR, `next start`) are available — everything server-side goes through FastAPI. `npm run dev` still works normally for local development, but relative `/api/*` calls need something to answer them: `next.config.ts` is a phase-based function (`output: "export"` for builds, a dev-only rewrite proxying `/api/*` to `http://127.0.0.1:8000` for `next dev`) since `output: "export"` and `rewrites()` can't both be set. Run the backend locally (`uv run uvicorn app.main:app --reload` from `backend/`, or let `playwright.config.ts` start it) for `/login` to work under `npm run dev`.
+
+## Stack
+
+- Next.js 16 (App Router), React 19, TypeScript
+- Tailwind CSS v4 (CSS-based config via `@theme inline` in `globals.css`, no `tailwind.config.js`)
+- `@dnd-kit/core` + `@dnd-kit/sortable` for drag and drop
+- Vitest + Testing Library for unit/component tests, Playwright for e2e
+
+## Structure
+
+```text
+src/
+  app/
+    layout.tsx      RootLayout: Space Grotesk (display) + Manrope (body) fonts, metadata
+    page.tsx         "/" route, renders <AuthGate /> (session check, then <KanbanBoard />)
+    login/page.tsx    "/login" route: username/password form, calls lib/auth login()
+    globals.css       Tailwind import + color tokens (--accent-yellow, --primary-blue, etc.)
+  components/
+    AuthGate.tsx             Client-side session check + redirect to /login; renders KanbanBoard with onLogout/onUnauthorized when authenticated
+    KanbanBoard.tsx        Fetches BoardData from the API on mount (loading state), owns it in useState, DndContext, drag handlers, DragOverlay, renders ChatSidebar; mutations call lib/api with optimistic local updates
+    ChatSidebar.tsx          Collapsible AI chat: message list + input, POSTs to lib/api's sendChatMessage, calls onBoardUpdate with the response's board; reports its open/closed state via onOpenChange so KanbanBoard can reserve layout space
+    KanbanColumn.tsx        Droppable column: title edit, SortableContext over card ids, add-card form
+    KanbanCard.tsx           Sortable card (useSortable): title, details, remove button
+    KanbanCardPreview.tsx    Static card visual rendered inside DragOverlay while dragging
+    NewCardForm.tsx           Inline toggle form to add a card to a column
+  lib/
+    kanban.ts        Types (Card, Column, BoardData), initialData (now only used as e2e/test fixture data, not by the app), pure logic (moveCard, createId)
+    auth.ts            login()/logout()/getSession() fetch wrappers around /api/login, /api/logout, /api/session
+    api.ts              fetchBoard/renameColumn/createCard/moveCard/deleteCard/sendChatMessage fetch wrappers around the backend routes; throws UnauthorizedError on a 401
+tests/
+  kanban.spec.ts      Playwright e2e: rename a column, add+drag a card, reload, confirm both persisted — logs in via helpers.ts in beforeEach since / is gated
+  auth.spec.ts         Playwright e2e: logged-out redirect, login, wrong credentials, logout
+  chat.spec.ts          Playwright e2e: add a card, ask the assistant to move it, confirm it moves without a reload — real backend call, currently blocked on the OpenRouter key (see docs/PLAN.md Part 10)
+  helpers.ts            loginAsTestUser(page): logs in via page.request.post so UI tests don't repeat the login flow
+```
+
+Two routes exist: `/` (gated) and `/login`. The chat sidebar is not a route — it's a fixed-position overlay rendered on `/`.
+
+## Data model (`src/lib/kanban.ts`)
+
+```ts
+export type Card = { id: string; title: string; details: string };
+export type Column = { id: string; title: string; cardIds: string[] };
+export type BoardData = { columns: Column[]; cards: Record<string, Card> };
+```
+
+Normalized shape: columns hold ordered `cardIds`; cards are keyed by id. This matches the MVP's "1 board per user" constraint — there is no `Board` wrapper type, and it mirrors the backend's `BoardData` pydantic model in `backend/app/board.py` exactly (routes return this shape directly). `initialData` (5 columns, 8 cards) is no longer used by the running app — it's kept only as fixture data for tests. `moveCard(columns, activeId, overId)` is a pure function handling same-column reorder, cross-column move, and drop-on-column-vs-drop-on-card — it only touches `columns`, not `cards`; `KanbanBoard` uses it to compute the optimistic local state during a drag, then derives the moved card's new column/position from the result to call `api.moveCard`.
+
+## State management
+
+Plain React `useState` in `KanbanBoard.tsx`, holding a `BoardData | null` (`null` while the initial `GET /api/board` is in flight). No Context/Redux/Zustand — a small fetch/mutation layer (`lib/api.ts`) plus local state was enough for a single-board app, no state management library needed.
+
+Mutation pattern (`onRename`, `onAddCard`, `onDeleteCard`, drag-end): apply an optimistic local update to `board` immediately, fire the corresponding `lib/api` call, then `.then(setBoard, handleApiError)` — success replaces local state with the server's authoritative response (not just the changed piece), and `handleApiError` either calls `onUnauthorized` (401) or refetches the whole board to reconcile (any other error), rather than manually tracking a "previous" snapshot to roll back to per handler. Column rename is debounced 400ms (fires on every keystroke locally, but only the network call is throttled).
+
+## Drag and drop
+
+`dnd-kit`: `KanbanBoard` sets up `DndContext` (`PointerSensor`, 6px activation distance, `closestCorners` collision), tracks `activeCardId` for the `DragOverlay`. `KanbanColumn` uses `useDroppable` + `SortableContext` (`verticalListSortingStrategy`). `KanbanCard` uses `useSortable`. Reordering logic is delegated to `moveCard`.
+
+## Styling
+
+Tailwind v4, no config file — theme tokens are CSS custom properties in `globals.css`:
+
+```css
+--accent-yellow: #ecad0a;
+--primary-blue: #209dd7;
+--secondary-purple: #753991;
+--navy-dark: #032147;
+--gray-text: #888888;
+```
+
+plus derived `--surface`, `--surface-strong`, `--stroke`, `--shadow`. Consumed via arbitrary-value classes, e.g. `text-[var(--navy-dark)]`. This already matches the color scheme in the root [AGENTS.md](../AGENTS.md) — keep new UI (e.g. the future chat sidebar) consistent with these tokens rather than introducing new colors, as the login form (`src/app/login/page.tsx`) does.
+
+## Tests
+
+- `npm run test` / `test:unit` — Vitest: `src/lib/kanban.test.ts` (moveCard logic), `src/lib/auth.test.ts` and `src/lib/api.test.ts` (fetch wrappers, mocked `fetch`), `src/app/login/page.test.tsx` and `src/components/AuthGate.test.tsx` (mocked `fetch` + `next/navigation`), `src/components/KanbanBoard.test.tsx` (RTL, mocks `@/lib/api` entirely rather than `fetch` directly — renders columns, rename column, add/remove card, chat toggle present), `src/components/ChatSidebar.test.tsx` (mocks `@/lib/api`: starts collapsed, send a message, error case). 27 tests total.
+  - When mocking `next/navigation`'s `useRouter` with `vi.mock`, return a **stable object reference** (module-level constant), not a new object literal per call — a fresh object each call changes a `useEffect([router])` dependency's identity on every render, causing the effect (and any `fetch` it makes) to re-run repeatedly. Bit us in `AuthGate.test.tsx`.
+  - When a test mocks multiple endpoints on the same `fetch`, use `mockImplementation` (branch on the URL), not `mockResolvedValue` with one shared `Response` — a `Response` body can only be read once, so a single mocked instance breaks the second real endpoint it's reused for. Also bit us in `AuthGate.test.tsx` once `KanbanBoard` started calling `/api/board` itself alongside `AuthGate`'s own `/api/session` check.
+- `npm run test:e2e` — Playwright. `playwright.config.ts` starts **two** `webServer`s: the backend (`uv run --directory ../backend uvicorn ...` on port 8000, `DATABASE_PATH=data/e2e.db` so it doesn't touch your manual-testing dev db) and `next dev` (port 3000, baseURL). `workers: 1` — the board is now real, shared, persistent state across the whole run, so parallel workers would race each other mutating it. `tests/kanban.spec.ts`, `tests/auth.spec.ts`, and `tests/chat.spec.ts` all need the backend since `/` is gated.
+  - Because the board persists across separate `npx playwright test` invocations (not just within one run), tests don't assume pristine seed data (no "card-1 starts in col-backlog") — each creates its own uniquely-titled column rename / card per test instead.
+  - When asserting on a card right after an optimistic-then-reconciled mutation (e.g. add-card), wait for the mutation's network response before computing anything DOM-position-dependent (`page.waitForResponse`) — the optimistic card has a temp id, gets swapped for a differently-`key`'d DOM node once the real one lands, and grabbing a bounding box mid-swap flakes.
+  - `chat.spec.ts` is currently failing, not flaky — blocked on the same `OPENROUTER_API_KEY` issue as the backend's real-call tests (see `docs/PLAN.md` Part 8). Everything else (7/8 e2e tests) is green.
+  - Verify new UI in an actual browser, not just tests: a Playwright screenshot of the chat sidebar caught a real layout bug (fixed-position sidebar overlapping the rightmost board columns) that no unit or e2e assertion would have noticed, since nothing was checking element positions.
+
+## Integration points for later phases
+
+None currently planned beyond Part 10 — this is the last part of `docs/PLAN.md`. The one open item across the whole app is the `OPENROUTER_API_KEY` in `.env` needing to be replaced with a working one (Parts 8, 9, and 10's AI-dependent tests are all blocked on it); everything else is implemented, tested, and verified.
diff --git a/frontend/next.config.ts b/frontend/next.config.ts
index e9ffa308..01d234b7 100644
--- a/frontend/next.config.ts
+++ b/frontend/next.config.ts
@@ -1,7 +1,23 @@
 import type { NextConfig } from "next";
+import { PHASE_DEVELOPMENT_SERVER } from "next/constants";
 
-const nextConfig: NextConfig = {
-  /* config options here */
-};
+// `output: "export"` (needed so FastAPI can serve the built static files)
+// disallows rewrites, so dev mode proxies /api/* to a local backend instead.
+export default function nextConfig(phase: string): NextConfig {
+  if (phase === PHASE_DEVELOPMENT_SERVER) {
+    return {
+      async rewrites() {
+        return [
+          {
+            source: "/api/:path*",
+            destination: "http://127.0.0.1:8000/api/:path*",
+          },
+        ];
+      },
+    };
+  }
 
-export default nextConfig;
+  return {
+    output: "export",
+  };
+}
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index c3ef7b4c..e308d1cf 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -5438,7 +5438,6 @@
       "version": "2.3.2",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
       "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
-      "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
       "optional": true,
diff --git a/frontend/playwright.config.ts b/frontend/playwright.config.ts
index e85e9b04..58777fe7 100644
--- a/frontend/playwright.config.ts
+++ b/frontend/playwright.config.ts
@@ -3,6 +3,12 @@ import { defineConfig, devices } from "@playwright/test";
 export default defineConfig({
   testDir: "./tests",
   timeout: 60_000,
+  // The board is real, shared, persistent state now (Part 7) — run tests
+  // one at a time so they don't race each other mutating the same board.
+  // Tests also don't assume a pristine seed (each creates its own card
+  // rather than relying on e.g. "card-1 starts in col-backlog"), since the
+  // db at DATABASE_PATH below persists across separate test runs.
+  workers: 1,
   expect: {
     timeout: 10_000,
   },
@@ -10,12 +16,21 @@ export default defineConfig({
     baseURL: "http://127.0.0.1:3000",
     trace: "retain-on-failure",
   },
-  webServer: {
-    command: "npm run dev -- --hostname 127.0.0.1 --port 3000",
-    url: "http://127.0.0.1:3000",
-    reuseExistingServer: true,
-    timeout: 120_000,
-  },
+  webServer: [
+    {
+      command: "uv run --directory ../backend uvicorn app.main:app --host 127.0.0.1 --port 8000",
+      url: "http://127.0.0.1:8000/api/health",
+      reuseExistingServer: true,
+      timeout: 60_000,
+      env: { DATABASE_PATH: "data/e2e.db" },
+    },
+    {
+      command: "npm run dev -- --hostname 127.0.0.1 --port 3000",
+      url: "http://127.0.0.1:3000",
+      reuseExistingServer: true,
+      timeout: 120_000,
+    },
+  ],
   projects: [
     {
       name: "chromium",
diff --git a/frontend/src/app/login/page.test.tsx b/frontend/src/app/login/page.test.tsx
new file mode 100644
index 00000000..b8df3565
--- /dev/null
+++ b/frontend/src/app/login/page.test.tsx
@@ -0,0 +1,40 @@
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import LoginPage from "@/app/login/page";
+
+const replace = vi.fn();
+const router = { replace };
+
+vi.mock("next/navigation", () => ({
+  useRouter: () => router,
+}));
+
+describe("LoginPage", () => {
+  beforeEach(() => {
+    replace.mockClear();
+    vi.stubGlobal("fetch", vi.fn());
+  });
+
+  it("redirects to / on successful login", async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(null, { status: 200 }));
+    render(<LoginPage />);
+
+    await userEvent.type(screen.getByLabelText("Username"), "user");
+    await userEvent.type(screen.getByLabelText("Password"), "password");
+    await userEvent.click(screen.getByRole("button", { name: /sign in/i }));
+
+    expect(replace).toHaveBeenCalledWith("/");
+  });
+
+  it("shows an error and does not redirect on failed login", async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(null, { status: 401 }));
+    render(<LoginPage />);
+
+    await userEvent.type(screen.getByLabelText("Username"), "user");
+    await userEvent.type(screen.getByLabelText("Password"), "wrong");
+    await userEvent.click(screen.getByRole("button", { name: /sign in/i }));
+
+    expect(await screen.findByText(/invalid username or password/i)).toBeInTheDocument();
+    expect(replace).not.toHaveBeenCalled();
+  });
+});
diff --git a/frontend/src/app/login/page.tsx b/frontend/src/app/login/page.tsx
new file mode 100644
index 00000000..5fa95419
--- /dev/null
+++ b/frontend/src/app/login/page.tsx
@@ -0,0 +1,75 @@
+"use client";
+
+import { useState, type FormEvent } from "react";
+import { useRouter } from "next/navigation";
+import { login } from "@/lib/auth";
+
+export default function LoginPage() {
+  const router = useRouter();
+  const [username, setUsername] = useState("");
+  const [password, setPassword] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+
+  const handleSubmit = async (event: FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+    setError(null);
+    setIsSubmitting(true);
+    const success = await login(username, password);
+    setIsSubmitting(false);
+
+    if (success) {
+      router.replace("/");
+    } else {
+      setError("Invalid username or password.");
+    }
+  };
+
+  return (
+    <main className="flex min-h-screen items-center justify-center px-6">
+      <form
+        onSubmit={handleSubmit}
+        className="w-full max-w-sm space-y-5 rounded-[32px] border border-[var(--stroke)] bg-white/80 p-8 shadow-[var(--shadow)] backdrop-blur"
+      >
+        <div>
+          <p className="text-xs font-semibold uppercase tracking-[0.35em] text-[var(--gray-text)]">
+            Kanban Studio
+          </p>
+          <h1 className="mt-3 font-display text-2xl font-semibold text-[var(--navy-dark)]">
+            Sign in
+          </h1>
+        </div>
+
+        <div className="space-y-3">
+          <input
+            value={username}
+            onChange={(event) => setUsername(event.target.value)}
+            placeholder="Username"
+            aria-label="Username"
+            className="w-full rounded-xl border border-[var(--stroke)] bg-white px-3 py-2 text-sm font-medium text-[var(--navy-dark)] outline-none transition focus:border-[var(--primary-blue)]"
+            required
+          />
+          <input
+            type="password"
+            value={password}
+            onChange={(event) => setPassword(event.target.value)}
+            placeholder="Password"
+            aria-label="Password"
+            className="w-full rounded-xl border border-[var(--stroke)] bg-white px-3 py-2 text-sm font-medium text-[var(--navy-dark)] outline-none transition focus:border-[var(--primary-blue)]"
+            required
+          />
+        </div>
+
+        {error ? <p className="text-sm text-red-600">{error}</p> : null}
+
+        <button
+          type="submit"
+          disabled={isSubmitting}
+          className="w-full rounded-full bg-[var(--secondary-purple)] px-4 py-2 text-xs font-semibold uppercase tracking-wide text-white transition hover:brightness-110 disabled:opacity-60"
+        >
+          {isSubmitting ? "Signing in…" : "Sign in"}
+        </button>
+      </form>
+    </main>
+  );
+}
diff --git a/frontend/src/app/page.tsx b/frontend/src/app/page.tsx
index e7c512b8..b721894f 100644
--- a/frontend/src/app/page.tsx
+++ b/frontend/src/app/page.tsx
@@ -1,5 +1,5 @@
-import { KanbanBoard } from "@/components/KanbanBoard";
+import { AuthGate } from "@/components/AuthGate";
 
 export default function Home() {
-  return <KanbanBoard />;
+  return <AuthGate />;
 }
diff --git a/frontend/src/components/AuthGate.test.tsx b/frontend/src/components/AuthGate.test.tsx
new file mode 100644
index 00000000..ce06c48c
--- /dev/null
+++ b/frontend/src/components/AuthGate.test.tsx
@@ -0,0 +1,64 @@
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { AuthGate } from "@/components/AuthGate";
+import { initialData } from "@/lib/kanban";
+
+const replace = vi.fn();
+const router = { replace };
+
+vi.mock("next/navigation", () => ({
+  useRouter: () => router,
+}));
+
+// A Response body can only be read once, so a shared `mockResolvedValue`
+// instance breaks as soon as two endpoints are fetched (session + board).
+// Use `mockImplementation` so every call gets its own fresh Response.
+function mockFetch(sessionAuthenticated: boolean) {
+  return (input: RequestInfo | URL) => {
+    const url = typeof input === "string" ? input : input.toString();
+    if (url === "/api/session") {
+      return Promise.resolve(
+        new Response(JSON.stringify({ authenticated: sessionAuthenticated }), { status: 200 })
+      );
+    }
+    if (url === "/api/board") {
+      return Promise.resolve(new Response(JSON.stringify(initialData), { status: 200 }));
+    }
+    return Promise.resolve(new Response(null, { status: 200 }));
+  };
+}
+
+describe("AuthGate", () => {
+  beforeEach(() => {
+    replace.mockClear();
+    vi.stubGlobal("fetch", vi.fn());
+  });
+
+  it("redirects to /login when the session is unauthenticated", async () => {
+    vi.mocked(fetch).mockImplementation(mockFetch(false));
+
+    render(<AuthGate />);
+
+    await vi.waitFor(() => expect(replace).toHaveBeenCalledWith("/login"));
+  });
+
+  it("renders the board when the session is authenticated", async () => {
+    vi.mocked(fetch).mockImplementation(mockFetch(true));
+
+    render(<AuthGate />);
+
+    expect(await screen.findByText("Kanban Studio")).toBeInTheDocument();
+    expect(replace).not.toHaveBeenCalled();
+  });
+
+  it("logs out and redirects to /login when the logout control is used", async () => {
+    vi.mocked(fetch).mockImplementation(mockFetch(true));
+
+    render(<AuthGate />);
+
+    const logoutButton = await screen.findByRole("button", { name: /log out/i });
+    await userEvent.click(logoutButton);
+
+    expect(replace).toHaveBeenCalledWith("/login");
+  });
+});
diff --git a/frontend/src/components/AuthGate.tsx b/frontend/src/components/AuthGate.tsx
new file mode 100644
index 00000000..68a3fce9
--- /dev/null
+++ b/frontend/src/components/AuthGate.tsx
@@ -0,0 +1,45 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { useRouter } from "next/navigation";
+import { getSession, logout } from "@/lib/auth";
+import { KanbanBoard } from "@/components/KanbanBoard";
+
+export const AuthGate = () => {
+  const router = useRouter();
+  const [authenticated, setAuthenticated] = useState(false);
+
+  useEffect(() => {
+    let active = true;
+
+    getSession().then((isAuthenticated) => {
+      if (!active) {
+        return;
+      }
+      if (isAuthenticated) {
+        setAuthenticated(true);
+      } else {
+        router.replace("/login");
+      }
+    });
+
+    return () => {
+      active = false;
+    };
+  }, [router]);
+
+  const handleLogout = async () => {
+    await logout();
+    router.replace("/login");
+  };
+
+  if (!authenticated) {
+    return (
+      <div className="flex min-h-screen items-center justify-center text-sm text-[var(--gray-text)]">
+        Loading…
+      </div>
+    );
+  }
+
+  return <KanbanBoard onLogout={handleLogout} onUnauthorized={() => router.replace("/login")} />;
+};
diff --git a/frontend/src/components/ChatSidebar.test.tsx b/frontend/src/components/ChatSidebar.test.tsx
new file mode 100644
index 00000000..12b84f08
--- /dev/null
+++ b/frontend/src/components/ChatSidebar.test.tsx
@@ -0,0 +1,53 @@
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { ChatSidebar } from "@/components/ChatSidebar";
+import { initialData } from "@/lib/kanban";
+import * as api from "@/lib/api";
+
+vi.mock("@/lib/api", () => ({
+  sendChatMessage: vi.fn(),
+}));
+
+const openSidebar = async () => {
+  await userEvent.click(screen.getByRole("button", { name: /ask ai/i }));
+};
+
+describe("ChatSidebar", () => {
+  it("starts collapsed, showing only a toggle button", () => {
+    render(<ChatSidebar onBoardUpdate={vi.fn()} />);
+
+    expect(screen.getByRole("button", { name: /ask ai/i })).toBeInTheDocument();
+    expect(screen.queryByLabelText("Chat message")).not.toBeInTheDocument();
+  });
+
+  it("sends a message, appends both messages, and applies a board update", async () => {
+    const onBoardUpdate = vi.fn();
+    const updatedBoard = { ...initialData };
+    vi.mocked(api.sendChatMessage).mockResolvedValue({ reply: "Moved it!", board: updatedBoard });
+
+    render(<ChatSidebar onBoardUpdate={onBoardUpdate} />);
+    await openSidebar();
+
+    await userEvent.type(screen.getByLabelText("Chat message"), "move the card to Done");
+    await userEvent.click(screen.getByRole("button", { name: /send/i }));
+
+    expect(api.sendChatMessage).toHaveBeenCalledWith("move the card to Done");
+    expect(screen.getByText("move the card to Done")).toBeInTheDocument();
+    expect(await screen.findByText("Moved it!")).toBeInTheDocument();
+    expect(onBoardUpdate).toHaveBeenCalledWith(updatedBoard);
+  });
+
+  it("shows an error and does not call onBoardUpdate when the request fails", async () => {
+    const onBoardUpdate = vi.fn();
+    vi.mocked(api.sendChatMessage).mockRejectedValue(new Error("network error"));
+
+    render(<ChatSidebar onBoardUpdate={onBoardUpdate} />);
+    await openSidebar();
+
+    await userEvent.type(screen.getByLabelText("Chat message"), "hello");
+    await userEvent.click(screen.getByRole("button", { name: /send/i }));
+
+    expect(await screen.findByText(/something went wrong/i)).toBeInTheDocument();
+    expect(onBoardUpdate).not.toHaveBeenCalled();
+  });
+});
diff --git a/frontend/src/components/ChatSidebar.tsx b/frontend/src/components/ChatSidebar.tsx
new file mode 100644
index 00000000..8d4d762d
--- /dev/null
+++ b/frontend/src/components/ChatSidebar.tsx
@@ -0,0 +1,129 @@
+"use client";
+
+import { useState, type FormEvent } from "react";
+import * as api from "@/lib/api";
+import type { BoardData } from "@/lib/kanban";
+
+type ChatMessage = {
+  role: "user" | "assistant";
+  content: string;
+};
+
+type ChatSidebarProps = {
+  onBoardUpdate: (board: BoardData) => void;
+  onOpenChange?: (isOpen: boolean) => void;
+};
+
+export const ChatSidebar = ({ onBoardUpdate, onOpenChange }: ChatSidebarProps) => {
+  const [isOpen, setIsOpen] = useState(false);
+  const [messages, setMessages] = useState<ChatMessage[]>([]);
+  const [input, setInput] = useState("");
+  const [isSending, setIsSending] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const open = () => {
+    setIsOpen(true);
+    onOpenChange?.(true);
+  };
+
+  const close = () => {
+    setIsOpen(false);
+    onOpenChange?.(false);
+  };
+
+  const handleSubmit = async (event: FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+    const message = input.trim();
+    if (!message || isSending) {
+      return;
+    }
+
+    setMessages((prev) => [...prev, { role: "user", content: message }]);
+    setInput("");
+    setIsSending(true);
+    setError(null);
+
+    try {
+      const { reply, board } = await api.sendChatMessage(message);
+      setMessages((prev) => [...prev, { role: "assistant", content: reply }]);
+      onBoardUpdate(board);
+    } catch {
+      setError("Something went wrong sending that message.");
+    } finally {
+      setIsSending(false);
+    }
+  };
+
+  if (!isOpen) {
+    return (
+      <button
+        type="button"
+        onClick={open}
+        className="fixed bottom-6 right-6 rounded-full bg-[var(--secondary-purple)] px-5 py-3 text-xs font-semibold uppercase tracking-wide text-white shadow-[var(--shadow)] transition hover:brightness-110"
+      >
+        Ask AI
+      </button>
+    );
+  }
+
+  return (
+    <aside className="fixed bottom-6 right-6 flex h-[520px] w-[360px] flex-col overflow-hidden rounded-[28px] border border-[var(--stroke)] bg-white/95 shadow-[var(--shadow)] backdrop-blur">
+      <div className="flex items-center justify-between border-b border-[var(--stroke)] px-5 py-4">
+        <div>
+          <p className="text-xs font-semibold uppercase tracking-[0.25em] text-[var(--gray-text)]">
+            Assistant
+          </p>
+          <p className="mt-1 font-display text-base font-semibold text-[var(--navy-dark)]">Ask AI</p>
+        </div>
+        <button
+          type="button"
+          onClick={close}
+          aria-label="Close chat"
+          className="rounded-full border border-transparent px-2 py-1 text-xs font-semibold text-[var(--gray-text)] transition hover:border-[var(--stroke)] hover:text-[var(--navy-dark)]"
+        >
+          Close
+        </button>
+      </div>
+
+      <div className="flex-1 space-y-3 overflow-y-auto px-5 py-4">
+        {messages.length === 0 ? (
+          <p className="text-sm text-[var(--gray-text)]">
+            Ask me to create, edit, or move cards — or just ask a question about the board.
+          </p>
+        ) : (
+          messages.map((message, index) => (
+            <div
+              key={index}
+              className={
+                message.role === "user"
+                  ? "ml-auto max-w-[85%] rounded-2xl bg-[var(--secondary-purple)] px-4 py-2 text-sm text-white"
+                  : "mr-auto max-w-[85%] rounded-2xl bg-[var(--surface)] px-4 py-2 text-sm text-[var(--navy-dark)]"
+              }
+            >
+              {message.content}
+            </div>
+          ))
+        )}
+        {isSending ? <p className="text-xs text-[var(--gray-text)]">Thinking…</p> : null}
+        {error ? <p className="text-xs font-semibold text-red-600">{error}</p> : null}
+      </div>
+
+      <form onSubmit={handleSubmit} className="flex items-center gap-2 border-t border-[var(--stroke)] p-4">
+        <input
+          value={input}
+          onChange={(event) => setInput(event.target.value)}
+          placeholder="Ask the assistant…"
+          aria-label="Chat message"
+          className="flex-1 rounded-full border border-[var(--stroke)] bg-white px-4 py-2 text-sm text-[var(--navy-dark)] outline-none transition focus:border-[var(--primary-blue)]"
+        />
+        <button
+          type="submit"
+          disabled={isSending}
+          className="rounded-full bg-[var(--secondary-purple)] px-4 py-2 text-xs font-semibold uppercase tracking-wide text-white transition hover:brightness-110 disabled:opacity-60"
+        >
+          Send
+        </button>
+      </form>
+    </aside>
+  );
+};
diff --git a/frontend/src/components/KanbanBoard.test.tsx b/frontend/src/components/KanbanBoard.test.tsx
index 833fcb88..cfa2d632 100644
--- a/frontend/src/components/KanbanBoard.test.tsx
+++ b/frontend/src/components/KanbanBoard.test.tsx
@@ -1,18 +1,45 @@
 import { render, screen, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { KanbanBoard } from "@/components/KanbanBoard";
+import { initialData } from "@/lib/kanban";
+import * as api from "@/lib/api";
 
-const getFirstColumn = () => screen.getAllByTestId(/column-/i)[0];
+vi.mock("@/lib/api", () => ({
+  fetchBoard: vi.fn(),
+  renameColumn: vi.fn(),
+  createCard: vi.fn(),
+  moveCard: vi.fn(),
+  deleteCard: vi.fn(),
+  sendChatMessage: vi.fn(),
+  UnauthorizedError: class UnauthorizedError extends Error {},
+}));
+
+const cloneBoard = () => JSON.parse(JSON.stringify(initialData));
 
 describe("KanbanBoard", () => {
-  it("renders five columns", () => {
+  beforeEach(() => {
+    vi.mocked(api.fetchBoard).mockResolvedValue(cloneBoard());
+    vi.mocked(api.renameColumn).mockResolvedValue(cloneBoard());
+    vi.mocked(api.createCard).mockResolvedValue(cloneBoard());
+    vi.mocked(api.moveCard).mockResolvedValue(cloneBoard());
+    vi.mocked(api.deleteCard).mockResolvedValue(cloneBoard());
+  });
+
+  it("fetches and renders five columns", async () => {
     render(<KanbanBoard />);
-    expect(screen.getAllByTestId(/column-/i)).toHaveLength(5);
+    expect(await screen.findAllByTestId(/column-/i)).toHaveLength(5);
+    expect(api.fetchBoard).toHaveBeenCalledTimes(1);
+  });
+
+  it("renders the chat sidebar toggle", async () => {
+    render(<KanbanBoard />);
+    await screen.findAllByTestId(/column-/i);
+    expect(screen.getByRole("button", { name: /ask ai/i })).toBeInTheDocument();
   });
 
   it("renames a column", async () => {
     render(<KanbanBoard />);
-    const column = getFirstColumn();
+    const column = (await screen.findAllByTestId(/column-/i))[0];
     const input = within(column).getByLabelText("Column title");
     await userEvent.clear(input);
     await userEvent.type(input, "New Name");
@@ -20,11 +47,15 @@ describe("KanbanBoard", () => {
   });
 
   it("adds and removes a card", async () => {
+    const boardWithCard = cloneBoard();
+    boardWithCard.cards["card-new"] = { id: "card-new", title: "New card", details: "Notes" };
+    boardWithCard.columns[0].cardIds.push("card-new");
+    vi.mocked(api.createCard).mockResolvedValue(boardWithCard);
+    vi.mocked(api.deleteCard).mockResolvedValue(cloneBoard());
+
     render(<KanbanBoard />);
-    const column = getFirstColumn();
-    const addButton = within(column).getByRole("button", {
-      name: /add a card/i,
-    });
+    const column = (await screen.findAllByTestId(/column-/i))[0];
+    const addButton = within(column).getByRole("button", { name: /add a card/i });
     await userEvent.click(addButton);
 
     const titleInput = within(column).getByPlaceholderText(/card title/i);
@@ -34,13 +65,13 @@ describe("KanbanBoard", () => {
 
     await userEvent.click(within(column).getByRole("button", { name: /add card/i }));
 
-    expect(within(column).getByText("New card")).toBeInTheDocument();
+    expect(await within(column).findByText("New card")).toBeInTheDocument();
+    expect(api.createCard).toHaveBeenCalledWith("col-backlog", "New card", "Notes");
 
-    const deleteButton = within(column).getByRole("button", {
-      name: /delete new card/i,
-    });
+    const deleteButton = within(column).getByRole("button", { name: /delete new card/i });
     await userEvent.click(deleteButton);
 
     expect(within(column).queryByText("New card")).not.toBeInTheDocument();
+    expect(api.deleteCard).toHaveBeenCalledWith("card-new");
   });
 });
diff --git a/frontend/src/components/KanbanBoard.tsx b/frontend/src/components/KanbanBoard.tsx
index dc6bf5fb..32445e51 100644
--- a/frontend/src/components/KanbanBoard.tsx
+++ b/frontend/src/components/KanbanBoard.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import { useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import {
   DndContext,
   DragOverlay,
@@ -11,13 +11,53 @@ import {
   type DragEndEvent,
   type DragStartEvent,
 } from "@dnd-kit/core";
+import clsx from "clsx";
+import { ChatSidebar } from "@/components/ChatSidebar";
 import { KanbanColumn } from "@/components/KanbanColumn";
 import { KanbanCardPreview } from "@/components/KanbanCardPreview";
-import { createId, initialData, moveCard, type BoardData } from "@/lib/kanban";
+import { moveCard as computeMovedColumns, type BoardData } from "@/lib/kanban";
+import * as api from "@/lib/api";
+import { UnauthorizedError } from "@/lib/api";
 
-export const KanbanBoard = () => {
-  const [board, setBoard] = useState<BoardData>(() => initialData);
+const RENAME_DEBOUNCE_MS = 400;
+
+type KanbanBoardProps = {
+  onLogout?: () => void;
+  onUnauthorized?: () => void;
+};
+
+export const KanbanBoard = ({ onLogout, onUnauthorized }: KanbanBoardProps) => {
+  const [board, setBoard] = useState<BoardData | null>(null);
   const [activeCardId, setActiveCardId] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [isChatOpen, setIsChatOpen] = useState(false);
+  const renameTimeouts = useRef<Record<string, ReturnType<typeof setTimeout>>>({});
+
+  useEffect(() => {
+    let active = true;
+    api.fetchBoard().then(
+      (data) => {
+        if (active) {
+          setBoard(data);
+        }
+      },
+      (err) => {
+        if (!active) return;
+        handleApiError(err);
+      }
+    );
+    return () => {
+      active = false;
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  useEffect(() => {
+    const timeouts = renameTimeouts.current;
+    return () => {
+      Object.values(timeouts).forEach(clearTimeout);
+    };
+  }, []);
 
   const sensors = useSensors(
     useSensor(PointerSensor, {
@@ -25,7 +65,16 @@ export const KanbanBoard = () => {
     })
   );
 
-  const cardsById = useMemo(() => board.cards, [board.cards]);
+  const cardsById = useMemo(() => board?.cards ?? {}, [board]);
+
+  const handleApiError = (err: unknown) => {
+    if (err instanceof UnauthorizedError) {
+      onUnauthorized?.();
+      return;
+    }
+    setError("Something went wrong. Refreshing the board.");
+    api.fetchBoard().then(setBoard).catch(() => undefined);
+  };
 
   const handleDragStart = (event: DragStartEvent) => {
     setActiveCardId(event.active.id as string);
@@ -35,60 +84,79 @@ export const KanbanBoard = () => {
     const { active, over } = event;
     setActiveCardId(null);
 
-    if (!over || active.id === over.id) {
+    if (!board || !over || active.id === over.id) {
       return;
     }
 
-    setBoard((prev) => ({
-      ...prev,
-      columns: moveCard(prev.columns, active.id as string, over.id as string),
-    }));
+    const cardId = active.id as string;
+    const nextColumns = computeMovedColumns(board.columns, cardId, over.id as string);
+    setBoard({ ...board, columns: nextColumns });
+
+    const targetColumn = nextColumns.find((column) => column.cardIds.includes(cardId));
+    if (!targetColumn) {
+      return;
+    }
+    const position = targetColumn.cardIds.indexOf(cardId);
+
+    api.moveCard(cardId, targetColumn.id, position).then(setBoard, handleApiError);
   };
 
   const handleRenameColumn = (columnId: string, title: string) => {
-    setBoard((prev) => ({
-      ...prev,
-      columns: prev.columns.map((column) =>
-        column.id === columnId ? { ...column, title } : column
-      ),
-    }));
+    setBoard((prev) =>
+      prev
+        ? {
+            ...prev,
+            columns: prev.columns.map((column) =>
+              column.id === columnId ? { ...column, title } : column
+            ),
+          }
+        : prev
+    );
+
+    clearTimeout(renameTimeouts.current[columnId]);
+    renameTimeouts.current[columnId] = setTimeout(() => {
+      api.renameColumn(columnId, title).then(setBoard, handleApiError);
+    }, RENAME_DEBOUNCE_MS);
   };
 
   const handleAddCard = (columnId: string, title: string, details: string) => {
-    const id = createId("card");
-    setBoard((prev) => ({
-      ...prev,
-      cards: {
-        ...prev.cards,
-        [id]: { id, title, details: details || "No details yet." },
-      },
-      columns: prev.columns.map((column) =>
-        column.id === columnId
-          ? { ...column, cardIds: [...column.cardIds, id] }
-          : column
+    if (!board) return;
+    const resolvedDetails = details || "No details yet.";
+    const tempId = `card-pending-${Date.now()}`;
+    setBoard({
+      ...board,
+      cards: { ...board.cards, [tempId]: { id: tempId, title, details: resolvedDetails } },
+      columns: board.columns.map((column) =>
+        column.id === columnId ? { ...column, cardIds: [...column.cardIds, tempId] } : column
       ),
-    }));
+    });
+
+    api.createCard(columnId, title, resolvedDetails).then(setBoard, handleApiError);
   };
 
   const handleDeleteCard = (columnId: string, cardId: string) => {
-    setBoard((prev) => {
-      return {
-        ...prev,
-        cards: Object.fromEntries(
-          Object.entries(prev.cards).filter(([id]) => id !== cardId)
-        ),
-        columns: prev.columns.map((column) =>
-          column.id === columnId
-            ? {
-                ...column,
-                cardIds: column.cardIds.filter((id) => id !== cardId),
-              }
-            : column
-        ),
-      };
+    if (!board) return;
+    setBoard({
+      ...board,
+      cards: Object.fromEntries(Object.entries(board.cards).filter(([id]) => id !== cardId)),
+      columns: board.columns.map((column) =>
+        column.id === columnId
+          ? { ...column, cardIds: column.cardIds.filter((id) => id !== cardId) }
+          : column
+      ),
     });
+
+    api.deleteCard(cardId).then(setBoard, handleApiError);
   };
 
+  if (!board) {
+    return (
+      <div className="flex min-h-screen items-center justify-center text-sm text-[var(--gray-text)]">
+        Loading…
+      </div>
+    );
+  }
+
   const activeCard = activeCardId ? cardsById[activeCardId] : null;
 
   return (
@@ -96,7 +164,12 @@ export const KanbanBoard = () => {
       <div className="pointer-events-none absolute left-0 top-0 h-[420px] w-[420px] -translate-x-1/3 -translate-y-1/3 rounded-full bg-[radial-gradient(circle,_rgba(32,157,215,0.25)_0%,_rgba(32,157,215,0.05)_55%,_transparent_70%)]" />
       <div className="pointer-events-none absolute bottom-0 right-0 h-[520px] w-[520px] translate-x-1/4 translate-y-1/4 rounded-full bg-[radial-gradient(circle,_rgba(117,57,145,0.18)_0%,_rgba(117,57,145,0.05)_55%,_transparent_75%)]" />
 
-      <main className="relative mx-auto flex min-h-screen max-w-[1500px] flex-col gap-10 px-6 pb-16 pt-12">
+      <main
+        className={clsx(
+          "relative mx-auto flex min-h-screen max-w-[1500px] flex-col gap-10 px-6 pb-16 pt-12 transition-[padding]",
+          isChatOpen && "xl:pr-[400px]"
+        )}
+      >
         <header className="flex flex-col gap-6 rounded-[32px] border border-[var(--stroke)] bg-white/80 p-8 shadow-[var(--shadow)] backdrop-blur">
           <div className="flex flex-wrap items-start justify-between gap-6">
             <div>
@@ -111,13 +184,24 @@ export const KanbanBoard = () => {
                 and capture quick notes without getting buried in settings.
               </p>
             </div>
-            <div className="rounded-2xl border border-[var(--stroke)] bg-[var(--surface)] px-5 py-4">
-              <p className="text-xs font-semibold uppercase tracking-[0.25em] text-[var(--gray-text)]">
-                Focus
-              </p>
-              <p className="mt-2 text-lg font-semibold text-[var(--primary-blue)]">
-                One board. Five columns. Zero clutter.
-              </p>
+            <div className="flex flex-wrap items-start gap-4">
+              <div className="rounded-2xl border border-[var(--stroke)] bg-[var(--surface)] px-5 py-4">
+                <p className="text-xs font-semibold uppercase tracking-[0.25em] text-[var(--gray-text)]">
+                  Focus
+                </p>
+                <p className="mt-2 text-lg font-semibold text-[var(--primary-blue)]">
+                  One board. Five columns. Zero clutter.
+                </p>
+              </div>
+              {onLogout ? (
+                <button
+                  type="button"
+                  onClick={onLogout}
+                  className="rounded-full border border-[var(--stroke)] px-4 py-2 text-xs font-semibold uppercase tracking-wide text-[var(--gray-text)] transition hover:border-[var(--primary-blue)] hover:text-[var(--primary-blue)]"
+                >
+                  Log out
+                </button>
+              ) : null}
             </div>
           </div>
           <div className="flex flex-wrap items-center gap-4">
@@ -131,6 +215,9 @@ export const KanbanBoard = () => {
               </div>
             ))}
           </div>
+          {error ? (
+            <p className="text-xs font-semibold uppercase tracking-wide text-red-600">{error}</p>
+          ) : null}
         </header>
 
         <DndContext
@@ -160,6 +247,8 @@ export const KanbanBoard = () => {
           </DragOverlay>
         </DndContext>
       </main>
+
+      <ChatSidebar onBoardUpdate={setBoard} onOpenChange={setIsChatOpen} />
     </div>
   );
 };
diff --git a/frontend/src/lib/api.test.ts b/frontend/src/lib/api.test.ts
new file mode 100644
index 00000000..2db87e0d
--- /dev/null
+++ b/frontend/src/lib/api.test.ts
@@ -0,0 +1,104 @@
+import {
+  fetchBoard,
+  renameColumn,
+  createCard,
+  moveCard,
+  deleteCard,
+  sendChatMessage,
+  UnauthorizedError,
+} from "@/lib/api";
+
+const board = { columns: [], cards: {} };
+
+describe("api", () => {
+  beforeEach(() => {
+    vi.stubGlobal("fetch", vi.fn());
+  });
+
+  it("fetchBoard requests /api/board", async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(JSON.stringify(board), { status: 200 }));
+
+    const result = await fetchBoard();
+
+    expect(fetch).toHaveBeenCalledWith(
+      "/api/board",
+      expect.objectContaining({ headers: { "Content-Type": "application/json" } })
+    );
+    expect(result).toEqual(board);
+  });
+
+  it("renameColumn PATCHes the column with the new title", async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(JSON.stringify(board), { status: 200 }));
+
+    await renameColumn("col-backlog", "Triage");
+
+    expect(fetch).toHaveBeenCalledWith(
+      "/api/columns/col-backlog",
+      expect.objectContaining({ method: "PATCH", body: JSON.stringify({ title: "Triage" }) })
+    );
+  });
+
+  it("createCard POSTs to /api/cards", async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(JSON.stringify(board), { status: 200 }));
+
+    await createCard("col-backlog", "Title", "Details");
+
+    expect(fetch).toHaveBeenCalledWith(
+      "/api/cards",
+      expect.objectContaining({
+        method: "POST",
+        body: JSON.stringify({ column_id: "col-backlog", title: "Title", details: "Details" }),
+      })
+    );
+  });
+
+  it("moveCard PATCHes the card with column and position", async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(JSON.stringify(board), { status: 200 }));
+
+    await moveCard("card-1", "col-done", 2);
+
+    expect(fetch).toHaveBeenCalledWith(
+      "/api/cards/card-1",
+      expect.objectContaining({
+        method: "PATCH",
+        body: JSON.stringify({ column_id: "col-done", position: 2 }),
+      })
+    );
+  });
+
+  it("deleteCard DELETEs the card", async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(JSON.stringify(board), { status: 200 }));
+
+    await deleteCard("card-1");
+
+    expect(fetch).toHaveBeenCalledWith("/api/cards/card-1", expect.objectContaining({ method: "DELETE" }));
+  });
+
+  it("sendChatMessage POSTs to /api/chat and returns reply + board", async () => {
+    const chatResponse = { reply: "Done!", board };
+    vi.mocked(fetch).mockResolvedValue(new Response(JSON.stringify(chatResponse), { status: 200 }));
+
+    const result = await sendChatMessage("move the card to Done");
+
+    expect(fetch).toHaveBeenCalledWith(
+      "/api/chat",
+      expect.objectContaining({
+        method: "POST",
+        body: JSON.stringify({ message: "move the card to Done" }),
+      })
+    );
+    expect(result).toEqual(chatResponse);
+  });
+
+  it("throws UnauthorizedError on a 401 response", async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(null, { status: 401 }));
+
+    await expect(fetchBoard()).rejects.toBeInstanceOf(UnauthorizedError);
+  });
+
+  it("throws a generic error on other non-ok responses", async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(null, { status: 500 }));
+
+    await expect(fetchBoard()).rejects.toThrow();
+  });
+});
diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts
new file mode 100644
index 00000000..4ff7cec5
--- /dev/null
+++ b/frontend/src/lib/api.ts
@@ -0,0 +1,60 @@
+import type { BoardData } from "@/lib/kanban";
+
+export class UnauthorizedError extends Error {}
+
+async function request<T>(path: string, init?: RequestInit): Promise<T> {
+  const response = await fetch(path, {
+    headers: { "Content-Type": "application/json" },
+    ...init,
+  });
+
+  if (response.status === 401) {
+    throw new UnauthorizedError();
+  }
+  if (!response.ok) {
+    throw new Error(`Request to ${path} failed with status ${response.status}`);
+  }
+
+  return (await response.json()) as T;
+}
+
+export function fetchBoard(): Promise<BoardData> {
+  return request<BoardData>("/api/board");
+}
+
+export function renameColumn(columnId: string, title: string): Promise<BoardData> {
+  return request<BoardData>(`/api/columns/${columnId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ title }),
+  });
+}
+
+export function createCard(columnId: string, title: string, details: string): Promise<BoardData> {
+  return request<BoardData>("/api/cards", {
+    method: "POST",
+    body: JSON.stringify({ column_id: columnId, title, details }),
+  });
+}
+
+export function moveCard(cardId: string, columnId: string, position: number): Promise<BoardData> {
+  return request<BoardData>(`/api/cards/${cardId}`, {
+    method: "PATCH",
+    body: JSON.stringify({ column_id: columnId, position }),
+  });
+}
+
+export function deleteCard(cardId: string): Promise<BoardData> {
+  return request<BoardData>(`/api/cards/${cardId}`, { method: "DELETE" });
+}
+
+export type ChatResponse = {
+  reply: string;
+  board: BoardData;
+};
+
+export function sendChatMessage(message: string): Promise<ChatResponse> {
+  return request<ChatResponse>("/api/chat", {
+    method: "POST",
+    body: JSON.stringify({ message }),
+  });
+}
diff --git a/frontend/src/lib/auth.test.ts b/frontend/src/lib/auth.test.ts
new file mode 100644
index 00000000..c1babb5d
--- /dev/null
+++ b/frontend/src/lib/auth.test.ts
@@ -0,0 +1,48 @@
+import { login, logout, getSession } from "@/lib/auth";
+
+describe("auth", () => {
+  beforeEach(() => {
+    vi.stubGlobal("fetch", vi.fn());
+  });
+
+  it("login posts credentials and reports success", async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(null, { status: 200 }));
+
+    const result = await login("user", "password");
+
+    expect(result).toBe(true);
+    expect(fetch).toHaveBeenCalledWith(
+      "/api/login",
+      expect.objectContaining({
+        method: "POST",
+        body: JSON.stringify({ username: "user", password: "password" }),
+      })
+    );
+  });
+
+  it("login reports failure on a non-ok response", async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(null, { status: 401 }));
+
+    const result = await login("user", "wrong");
+
+    expect(result).toBe(false);
+  });
+
+  it("logout posts to the logout endpoint", async () => {
+    vi.mocked(fetch).mockResolvedValue(new Response(null, { status: 200 }));
+
+    await logout();
+
+    expect(fetch).toHaveBeenCalledWith("/api/logout", { method: "POST" });
+  });
+
+  it("getSession returns the authenticated flag from the response", async () => {
+    vi.mocked(fetch).mockResolvedValue(
+      new Response(JSON.stringify({ authenticated: true }), { status: 200 })
+    );
+
+    const result = await getSession();
+
+    expect(result).toBe(true);
+  });
+});
diff --git a/frontend/src/lib/auth.ts b/frontend/src/lib/auth.ts
new file mode 100644
index 00000000..865763cc
--- /dev/null
+++ b/frontend/src/lib/auth.ts
@@ -0,0 +1,18 @@
+export async function login(username: string, password: string): Promise<boolean> {
+  const response = await fetch("/api/login", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ username, password }),
+  });
+  return response.ok;
+}
+
+export async function logout(): Promise<void> {
+  await fetch("/api/logout", { method: "POST" });
+}
+
+export async function getSession(): Promise<boolean> {
+  const response = await fetch("/api/session");
+  const data: { authenticated: boolean } = await response.json();
+  return data.authenticated;
+}
diff --git a/frontend/src/lib/kanban.ts b/frontend/src/lib/kanban.ts
index fd380df4..0f47e7df 100644
--- a/frontend/src/lib/kanban.ts
+++ b/frontend/src/lib/kanban.ts
@@ -162,7 +162,5 @@ export const moveCard = (
 };
 
 export const createId = (prefix: string) => {
-  const randomPart = Math.random().toString(36).slice(2, 8);
-  const timePart = Date.now().toString(36);
-  return `${prefix}-${randomPart}${timePart}`;
+  return `${prefix}-${crypto.randomUUID()}`;
 };
diff --git a/frontend/src/test/vitest.d.ts b/frontend/src/test/vitest.d.ts
index 7ef85e4b..edfa8b53 100644
--- a/frontend/src/test/vitest.d.ts
+++ b/frontend/src/test/vitest.d.ts
@@ -1,2 +1,2 @@
-/// <reference types="vitest" />
+/// <reference types="vitest/globals" />
 /// <reference types="@testing-library/jest-dom" />
diff --git a/frontend/test-results/.last-run.json b/frontend/test-results/.last-run.json
index cbcc1fba..ebd6e8f2 100644
--- a/frontend/test-results/.last-run.json
+++ b/frontend/test-results/.last-run.json
@@ -1,4 +1,6 @@
 {
-  "status": "passed",
-  "failedTests": []
+  "status": "failed",
+  "failedTests": [
+    "6dac514d5d837ca37b9e-206d4268fa73323ca9b9"
+  ]
 }
\ No newline at end of file
diff --git a/frontend/tests/auth.spec.ts b/frontend/tests/auth.spec.ts
new file mode 100644
index 00000000..ac76781b
--- /dev/null
+++ b/frontend/tests/auth.spec.ts
@@ -0,0 +1,40 @@
+import { expect, test } from "@playwright/test";
+
+test("redirects to /login when not authenticated", async ({ page }) => {
+  await page.goto("/");
+  await expect(page).toHaveURL(/\/login$/);
+});
+
+test("logs in with correct credentials and reaches the board", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByLabel("Username").fill("user");
+  await page.getByLabel("Password").fill("password");
+  await page.getByRole("button", { name: /sign in/i }).click();
+
+  await expect(page).toHaveURL("/");
+  await expect(page.getByRole("heading", { name: "Kanban Studio" })).toBeVisible();
+});
+
+test("shows an error and stays on /login with wrong credentials", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByLabel("Username").fill("user");
+  await page.getByLabel("Password").fill("wrong");
+  await page.getByRole("button", { name: /sign in/i }).click();
+
+  await expect(page.getByText(/invalid username or password/i)).toBeVisible();
+  await expect(page).toHaveURL(/\/login$/);
+});
+
+test("logs out and blocks board access again", async ({ page }) => {
+  await page.goto("/login");
+  await page.getByLabel("Username").fill("user");
+  await page.getByLabel("Password").fill("password");
+  await page.getByRole("button", { name: /sign in/i }).click();
+  await expect(page.getByRole("heading", { name: "Kanban Studio" })).toBeVisible();
+
+  await page.getByRole("button", { name: /log out/i }).click();
+  await expect(page).toHaveURL(/\/login$/);
+
+  await page.goto("/");
+  await expect(page).toHaveURL(/\/login$/);
+});
diff --git a/frontend/tests/chat.spec.ts b/frontend/tests/chat.spec.ts
new file mode 100644
index 00000000..9baf7903
--- /dev/null
+++ b/frontend/tests/chat.spec.ts
@@ -0,0 +1,35 @@
+import { expect, test } from "@playwright/test";
+import { loginAsTestUser } from "./helpers";
+
+// Real backend, real OpenRouter call — currently blocked on the same
+// OPENROUTER_API_KEY issue flagged in docs/PLAN.md for Parts 8 and 9.
+
+test.beforeEach(async ({ page }) => {
+  await loginAsTestUser(page);
+});
+
+test("asking the assistant to move a card updates the board without a reload", async ({ page }) => {
+  await page.goto("/");
+  const firstColumn = page.locator('[data-testid^="column-"]').first();
+  const cardTitle = `Chat card ${Date.now()}`;
+
+  await firstColumn.getByRole("button", { name: /add a card/i }).click();
+  await firstColumn.getByPlaceholder("Card title").fill(cardTitle);
+  const cardCreated = page.waitForResponse(
+    (response) => response.url().includes("/api/cards") && response.request().method() === "POST"
+  );
+  await firstColumn.getByRole("button", { name: /add card/i }).click();
+  await cardCreated;
+
+  await page.getByRole("button", { name: /ask ai/i }).click();
+  await page.getByLabel("Chat message").fill(`Move the card titled "${cardTitle}" to the Done column.`);
+
+  const chatReplied = page.waitForResponse(
+    (response) => response.url().includes("/api/chat") && response.request().method() === "POST"
+  );
+  await page.getByRole("button", { name: /send/i }).click();
+  await chatReplied;
+
+  const doneColumn = page.getByTestId("column-col-done");
+  await expect(doneColumn.locator('[data-testid^="card-"]').filter({ hasText: cardTitle })).toBeVisible();
+});
diff --git a/frontend/tests/helpers.ts b/frontend/tests/helpers.ts
new file mode 100644
index 00000000..b4e81e62
--- /dev/null
+++ b/frontend/tests/helpers.ts
@@ -0,0 +1,10 @@
+import type { Page } from "@playwright/test";
+
+export async function loginAsTestUser(page: Page): Promise<void> {
+  const response = await page.request.post("/api/login", {
+    data: { username: "user", password: "password" },
+  });
+  if (!response.ok()) {
+    throw new Error(`Failed to log in test user: ${response.status()}`);
+  }
+}
diff --git a/frontend/tests/kanban.spec.ts b/frontend/tests/kanban.spec.ts
index adea248a..8eab732b 100644
--- a/frontend/tests/kanban.spec.ts
+++ b/frontend/tests/kanban.spec.ts
@@ -1,4 +1,13 @@
 import { expect, test } from "@playwright/test";
+import { loginAsTestUser } from "./helpers";
+
+// The board is real, persisted state (Part 7) shared across test runs, so
+// these tests create their own data rather than assuming a pristine seed
+// (e.g. "card-1 starts in col-backlog").
+
+test.beforeEach(async ({ page }) => {
+  await loginAsTestUser(page);
+});
 
 test("loads the kanban board", async ({ page }) => {
   await page.goto("/");
@@ -6,36 +15,62 @@ test("loads the kanban board", async ({ page }) => {
   await expect(page.locator('[data-testid^="column-"]')).toHaveCount(5);
 });
 
-test("adds a card to a column", async ({ page }) => {
+test("renames a column and the rename persists after reload", async ({ page }) => {
   await page.goto("/");
   const firstColumn = page.locator('[data-testid^="column-"]').first();
-  await firstColumn.getByRole("button", { name: /add a card/i }).click();
-  await firstColumn.getByPlaceholder("Card title").fill("Playwright card");
-  await firstColumn.getByPlaceholder("Details").fill("Added via e2e.");
-  await firstColumn.getByRole("button", { name: /add card/i }).click();
-  await expect(firstColumn.getByText("Playwright card")).toBeVisible();
+  const titleInput = firstColumn.getByLabel("Column title");
+  const newTitle = `Renamed ${Date.now()}`;
+
+  const renameSaved = page.waitForResponse(
+    (response) => response.url().includes("/api/columns/") && response.request().method() === "PATCH"
+  );
+  await titleInput.fill(newTitle);
+  await renameSaved;
+
+  await page.reload();
+  await expect(
+    page.locator('[data-testid^="column-"]').first().getByLabel("Column title")
+  ).toHaveValue(newTitle);
 });
 
-test("moves a card between columns", async ({ page }) => {
+test("adds a card, drags it to another column, and both persist after reload", async ({ page }) => {
   await page.goto("/");
-  const card = page.getByTestId("card-card-1");
+  const firstColumn = page.locator('[data-testid^="column-"]').first();
   const targetColumn = page.getByTestId("column-col-review");
+  const cardTitle = `Playwright card ${Date.now()}`;
+
+  await firstColumn.getByRole("button", { name: /add a card/i }).click();
+  await firstColumn.getByPlaceholder("Card title").fill(cardTitle);
+  await firstColumn.getByPlaceholder("Details").fill("Added via e2e.");
+
+  // Wait for the server-confirmed card (not just the optimistic one, which
+  // gets a temp id and is swapped for a differently-keyed DOM node once the
+  // real response lands — grabbing coordinates mid-swap flakes).
+  const cardCreated = page.waitForResponse(
+    (response) => response.url().includes("/api/cards") && response.request().method() === "POST"
+  );
+  await firstColumn.getByRole("button", { name: /add card/i }).click();
+  await cardCreated;
+
+  const card = firstColumn.locator('[data-testid^="card-"]').filter({ hasText: cardTitle });
+  await expect(card).toBeVisible();
+
   const cardBox = await card.boundingBox();
   const columnBox = await targetColumn.boundingBox();
   if (!cardBox || !columnBox) {
     throw new Error("Unable to resolve drag coordinates.");
   }
 
-  await page.mouse.move(
-    cardBox.x + cardBox.width / 2,
-    cardBox.y + cardBox.height / 2
-  );
+  await page.mouse.move(cardBox.x + cardBox.width / 2, cardBox.y + cardBox.height / 2);
   await page.mouse.down();
-  await page.mouse.move(
-    columnBox.x + columnBox.width / 2,
-    columnBox.y + 120,
-    { steps: 12 }
-  );
+  await page.mouse.move(columnBox.x + columnBox.width / 2, columnBox.y + 120, { steps: 12 });
   await page.mouse.up();
-  await expect(targetColumn.getByTestId("card-card-1")).toBeVisible();
+
+  const movedCard = targetColumn.locator('[data-testid^="card-"]').filter({ hasText: cardTitle });
+  await expect(movedCard).toBeVisible();
+
+  await page.reload();
+  await expect(
+    page.getByTestId("column-col-review").locator('[data-testid^="card-"]').filter({ hasText: cardTitle })
+  ).toBeVisible();
 });
diff --git a/scripts/start.ps1 b/scripts/start.ps1
new file mode 100644
index 00000000..5c3574db
--- /dev/null
+++ b/scripts/start.ps1
@@ -0,0 +1,5 @@
+Set-Location (Join-Path $PSScriptRoot "..")
+
+docker compose up -d --build
+
+Write-Host "App running at http://localhost:8000"
diff --git a/scripts/start.sh b/scripts/start.sh
new file mode 100644
index 00000000..a9700533
--- /dev/null
+++ b/scripts/start.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd "$(dirname "$0")/.."
+
+docker compose up -d --build
+
+echo "App running at http://localhost:8000"
diff --git a/scripts/stop.ps1 b/scripts/stop.ps1
new file mode 100644
index 00000000..0ce6fb83
--- /dev/null
+++ b/scripts/stop.ps1
@@ -0,0 +1,3 @@
+Set-Location (Join-Path $PSScriptRoot "..")
+
+docker compose down
diff --git a/scripts/stop.sh b/scripts/stop.sh
new file mode 100644
index 00000000..a2b9ccfb
--- /dev/null
+++ b/scripts/stop.sh
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd "$(dirname "$0")/.."
+
+docker compose down