Separate user intent from planner output via day assertions

The calendar mixed two kinds of truth in one table. `planned_leave_day` was
simultaneously the allocator's output cache, the user's override store
(`is_pinned`, plus ad-hoc rows with no `wish_id`), and the resource ledger that
analytics and the age-4 maths read. The planner therefore had to ask "am I
allowed to touch this row?" on every sync, and got it wrong at the edges.

Every user assertion is now one `day_assertion` row — a concrete `day_type`
replaces a pinned day, a row with no `wish_id` replaces an ad-hoc day, and
`day_type='none'` replaces `planned_day_exclusion`. `planned_leave_day` becomes
purely derived with a single writer, and `PlanningService.pinned_keys()` is the
single answer to "is this day pinned", used by the allocator's loader, by
`sync_plan` and by the read router alike.

On top of that, every calendar band is now a real event: an ad-hoc band opens
the same full editor as a wish-backed one and saving it promotes it to a
`LeaveWish`, so it can be named, repeated yearly, assigned to either or both
parents, and handed to the planner. "Planering" is a `moveable` toggle plus a
from/to month bound plus a separate lock/unlock action on the days themselves,
replacing a three-rung ladder whose "planner decides" rung set a search window
equal to the drawn dates and so could never move anything.

Bugs found and fixed along the way:

- The plan erased its own history. Fixed windows clip to today, so an elapsed
  auto-placed day fell into `stale_keys` and was deleted on the next sync —
  and a background sync runs on every workspace load. Past rows are now frozen
  and counted as spent.
- Migration 010's downgrade silently destroyed every pinned day and exclusion
  (`is_pinned` returned as DEFAULT 0, the exclusion table came back empty,
  exit 0, no warning). It now reconstructs both from `day_assertion`, and 009
  itemises what it cannot recover before dropping the table.
- Deleting a period left its assertions behind, locking those dates forever
  with no UI path to clear them. Wish deletion now clears them by `wish_id`.
- `DayAssertionService` and `LeaveWishService` committed multi-statement writes
  without a transaction; a crash mid-write diverged the tables or half-deleted
  a series. Both now run in a unit of work.
- A sibling year's shortfall was never surfaced: the toast only inspected the
  edited occurrence's outcome, so a fully unfunded later year rendered as an
  empty band with no warning.
- A flexible window whose bound had entirely elapsed was dropped from the
  proposal with no outcome at all. It now reports as `unplaced`.
- Unlocking a period deleted its days instead of returning them to the planner.
- The e2e global setup posted to a route deleted in this change, which would
  have failed the whole suite before its first test.

Gates: backend 938 tests / 91% coverage, frontend 1351 / 97.4 | 92.2 | 94.37 |
97.4. Migrations 009 and 010 audited against a hand-built realistic database:
the upgrade reconciles exactly and a constraint violation fails safe, leaving
the schema at 008.

Not complete. Step 4's toggle, month picker and lock/unlock action are verified
by browser walk and unit tests, but the partial-lock readout was not exercised.
`ideas.md` §7 adds a full plan for the vacation-forfeiture defect (the planner
detects expiring days and then does nothing about them) — not implemented here.
Remaining smaller items are listed in the session's restructure notes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01T4wjgbVL4HAC5Rdaw75VbV

backend/tests/unit/test_plan_sync_with_wish_router.py

@@ -0,0 +1,133 @@
+"""API-level test for `POST /api/plan/sync-with-wish`.
+
+Exercises the router + Pydantic wire models (not just the service directly,
+which `tests/unit/test_planning_service_sync_with_wish.py` already covers) —
+this catches the class of bug where the router/model layer drops or
+mis-names a field on the way to `PlanningService.sync_with_wish`, or where
+the "exactly one of wish_create/wish_update" request validation is wired
+wrong.
+"""
+
+from uuid import uuid4
+
+from httpx import AsyncClient
+
+from tests.conftest import SeededIds
+
+
+class TestSyncWithWishRequestValidation:
+    async def test_neither_wish_create_nor_wish_update_is_422(
+        self, authed_client: AsyncClient, seeded_ids: SeededIds
+    ) -> None:
+        response = await authed_client.post(
+            "/api/plan/sync-with-wish", json={"workspace_id": str(seeded_ids.workspace_id)}
+        )
+        assert response.status_code == 422
+
+    async def test_both_wish_create_and_wish_update_is_422(
+        self, authed_client: AsyncClient, seeded_ids: SeededIds
+    ) -> None:
+        response = await authed_client.post(
+            "/api/plan/sync-with-wish",
+            json={
+                "workspace_id": str(seeded_ids.workspace_id),
+                "wish_create": {
+                    "name": "X",
+                    "window_start_month": 6,
+                    "window_start_day": 1,
+                    "window_end_month": 6,
+                    "window_end_day": 7,
+                    "target_weeks": 1,
+                    "first_year": 2027,
+                },
+                "wish_update": {"leave_wish_id": str(uuid4()), "patch": {}},
+            },
+        )
+        assert response.status_code == 422
+
+
+class TestSyncWithWishCreatesAndFunds:
+    async def test_wish_create_round_trips_and_days_are_persisted(
+        self, authed_client: AsyncClient, seeded_ids: SeededIds
+    ) -> None:
+        response = await authed_client.post(
+            "/api/plan/sync-with-wish",
+            json={
+                "workspace_id": str(seeded_ids.workspace_id),
+                "wish_create": {
+                    "child_id": str(seeded_ids.child_id),
+                    "name": "Sommar",
+                    "window_start_month": 6,
+                    "window_start_day": 1,
+                    "window_end_month": 6,
+                    "window_end_day": 7,
+                    "target_weeks": 1,
+                    "target_days": 7,
+                    "first_year": 2027,
+                },
+            },
+        )
+        assert response.status_code == 200, response.text
+        body = response.json()
+        assert body["wish"]["name"] == "Sommar"
+        assert body["sync"]["apply_result"]["accepted"] is True
+
+        wish_id = body["wish"]["id"]
+        wishes = await authed_client.get(f"/api/leave-wishes/{seeded_ids.workspace_id}")
+        assert any(w["id"] == wish_id for w in wishes.json())
+
+        days = await authed_client.get(
+            "/api/planned-days", params={"child_id": str(seeded_ids.child_id)}
+        )
+        assert any(d["wish_id"] == wish_id for d in days.json())
+
+    async def test_day_actions_attach_an_ad_hoc_pinned_day_to_the_new_wish(
+        self, authed_client: AsyncClient, seeded_ids: SeededIds
+    ) -> None:
+        # An ad-hoc, hand-pinned day (restructure step 3b: `POST
+        # /api/day-assertions`, which mirrors into `planned_leave_day`
+        # immediately) — the "day_actions" below need that mirrored row's
+        # id, not the assertion's own.
+        created_assertion = await authed_client.post(
+            "/api/day-assertions",
+            json={
+                "workspace_id": str(seeded_ids.workspace_id),
+                "child_id": str(seeded_ids.child_id),
+                "parent_personal_data_uuid": str(seeded_ids.personal_data_uuid),
+                "date": "2027-08-02",
+                "day_type": "vacation",
+            },
+        )
+        assert created_assertion.status_code == 201, created_assertion.text
+
+        planned = await authed_client.get(
+            "/api/planned-days", params={"child_id": str(seeded_ids.child_id)}
+        )
+        day_id = next(d["id"] for d in planned.json() if d["date"] == "2027-08-02")
+
+        response = await authed_client.post(
+            "/api/plan/sync-with-wish",
+            json={
+                "workspace_id": str(seeded_ids.workspace_id),
+                "wish_create": {
+                    "child_id": str(seeded_ids.child_id),
+                    "name": "Promoted",
+                    "window_start_month": 8,
+                    "window_start_day": 2,
+                    "window_end_month": 8,
+                    "window_end_day": 2,
+                    "target_weeks": 1,
+                    "target_days": 1,
+                    "first_year": 2027,
+                    "window_mode": "fixed",
+                },
+                "day_actions": [{"planned_day_id": day_id, "action": "attach"}],
+            },
+        )
+        assert response.status_code == 200, response.text
+        body = response.json()
+        assert body["sync"]["apply_result"]["accepted"] is True
+
+        day_after = await authed_client.get(f"/api/planned-days/{day_id}")
+        assert day_after.json()["wish_id"] == body["wish"]["id"]
+        assert day_after.json()["is_pinned"] is True