Harden the API and the data layer after a security and performance audit

Security
- Every route now requires a login and refuses ids outside the caller's
  workspace with 404: plan, leave-wishes, day-overrides and vacation-days
  were fully anonymous; every other router trusted client-supplied
  workspace/child/parent ids. Scraper sessions are bound to their owner.
- Invitations can no longer be created for a foreign workspace, and a
  redeemer who is already a member (or a full workspace) is refused.
- Production refuses the default JWT secret; API docs are hidden in
  production; a failed migration aborts startup instead of serving.
- Login and register no longer reveal whether an email exists; inactive
  accounts are rejected; /auth/refresh is rate limited.
- The FK scraper writes debug artefacts only when explicitly enabled,
  logs no scraped values or page text, clears the BankID QR as soon as it
  is scanned and purges finished sessions after five minutes.
- Real FK page captures are removed from the tree (history rewrite
  follows); the parser tests use a synthetic fixture.

Performance and correctness
- Plan apply/sync run inside one locked transaction with batched writes
  instead of one commit per row, so a failure mid-batch leaves nothing
  half-applied and concurrent syncs no longer corrupt each other.
- SQLite runs in WAL mode with a busy timeout; 14 indexes cover the
  filters that were full scans; argon2 hashing runs off the event loop;
  responses are gzipped.
- Frontend: a 401 now refreshes the token once and retries, so sessions
  no longer die silently after 15 minutes; every data hook discards
  stale responses; logout clears state even when the server call fails.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CsXCCcDfmV4Sps4ZQSvNEY

backend/app/services/workspace_service.py

@@ -21,6 +21,7 @@ from app.repositories.leave_wish_repository import LeaveWishRepository
 from app.repositories.parental_leave_repository import ParentalLeaveRepository
 from app.repositories.personal_data_repository import PersonalDataRepository
 from app.repositories.planned_leave_repository import PlannedLeaveRepository
+from app.repositories.unit_of_work import NoOpUnitOfWork, UnitOfWork
 from app.repositories.user_repository import UserRepository
 from app.repositories.vacation_days_repository import VacationDaysRepository
 from app.repositories.workspace_repository import (
@@ -43,6 +44,7 @@ class WorkspaceService:
         planned_leave_repo: PlannedLeaveRepository,
         parental_leave_repo: ParentalLeaveRepository,
         vacation_days_repo: VacationDaysRepository,
+        uow: UnitOfWork | None = None,
     ) -> None:
         self._ws = ws_repo
         self._inv = inv_repo
@@ -52,6 +54,11 @@ class WorkspaceService:
         self._planned_leave = planned_leave_repo
         self._parental_leave = parental_leave_repo
         self._vacation_days = vacation_days_repo
+        # Defaults to a no-op so pre-existing direct-construction call sites
+        # (scripts/seed_demo.py, test fixtures) keep today's per-write-commit
+        # behavior; `app.dependencies.get_workspace_service` always wires a
+        # real `SQLiteUnitOfWork`.
+        self._uow = uow or NoOpUnitOfWork()
 
     # ------------------------------------------------------------------
     # Workspace CRUD
@@ -264,16 +271,30 @@ class WorkspaceService:
         pd = await self._pd.get_by_id(personal_data_uuid)
         if pd is None:
             raise NotFoundError(f"PersonalData {personal_data_uuid} not found")
-        pd.workspace_id = inv.workspace_id
-        await self._pd.update(pd.uuid, pd)
 
-        inv.status = "accepted"
-        inv.accepted_at = datetime.now()
-        return await self._inv.update(inv.id, inv)
+        if pd.workspace_id == inv.workspace_id:
+            raise InvitationError("You already belong to this workspace")
 
-    async def revoke_invitation(self, invitation_id: UUID) -> None:
+        existing_members = await self._pd.list_by_workspace(inv.workspace_id)
+        if len(existing_members) >= 2:
+            raise InvitationError("This workspace already has its maximum number of members")
+
+        # Both writes must land together: a crash between them would leave
+        # the redeemer either moved to the new workspace with a still-pending
+        # (re-usable) invitation, or stuck in their old workspace with an
+        # invitation marked accepted.
+        async with self._uow():
+            pd.workspace_id = inv.workspace_id
+            await self._pd.update(pd.uuid, pd)
+
+            inv.status = "accepted"
+            inv.accepted_at = datetime.now()
+            inv = await self._inv.update(inv.id, inv)
+        return inv
+
+    async def revoke_invitation(self, invitation_id: UUID, workspace_id: UUID) -> None:
         inv = await self._inv.get_by_id(invitation_id)
-        if inv is None:
+        if inv is None or inv.workspace_id != workspace_id:
             raise NotFoundError(f"Invitation {invitation_id} not found")
         if inv.status != "pending":
             raise ValidationError(f"Cannot revoke a {inv.status} invitation")