Complete NextSteps roadmap: planning engine UI, calendar cluster, flexible wishes

Works through every numbered item in NextSteps260913.md section 3, plus the
three known verification issues in section 4.1.

Surface what the backend already computed:
- 3.1 render surplus_advice in PlanResults, mirroring the shortfall remedies
- 3.2 surface VacationBalance.is_assumed so assumed statutory years are visible
- 3.3 age-4 expiry given the proposed plan, via a new Age4Projection reusing
  the existing _age4_projections arithmetic (Dashboard stat verified, not rebuilt)

Calendar cluster (one pass over the holiday data):
- new GET /api/calendar/days exposing roda dagar, klamdagar and day overrides,
  paginated four years at a time
- 3.4 shade roda dagar/klamdagar, with R/K badges so colour is not the only signal
- 3.6 click-to-override behind an explicit mode toggle, leaving drag multi-select intact
- 3.7 click month/year to advance
- 3.8 per-year red-days list in Settings, statutory days plus overrides

i18n:
- 3.5 five backend-generated Swedish surfaces converted to message_key + data,
  following the tips_service pattern; old string fields replaced, not kept

Flexible wishes (3.9):
- PLANNING_ENGINE_SPEC section 10: window_mode, candidate search, cost function,
  deterministic tie-break, two-pass ordering, test matrix rows 15-24
- backend: entity, migration 006, _FULL_SCHEMA sync, repository, allocator
- frontend: season-preset toggle in WishEditor, unplaced outcome rendering

Fixes (4.1):
- pin typecheck to the local tsc rather than npx resolving a newer TypeScript
- ignore generated coverage/ and dist/ in the ESLint flat config
- fix the flaky usePlanApply test properly, with waitFor rather than a retry

Tests: backend 361 -> 404, frontend 540 -> 704. Coverage 89.47% -> 96.52% lines.

Not yet verified in a browser.

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

backend/app/dependencies.py

@@ -18,8 +18,9 @@ from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 
 from app.config import settings
 from app.entities.user import User
-from app.repositories.break_period_repository import BreakPeriodRepository
 from app.repositories.child_repository import ChildRepository
+from app.repositories.day_override_repository import DayOverrideRepository
+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
@@ -29,8 +30,9 @@ from app.repositories.workspace_repository import (
     WorkspaceInvitationRepository,
     WorkspaceRepository,
 )
-from app.repositories_impl.sqlite.break_period_repository import SQLiteBreakPeriodRepository
 from app.repositories_impl.sqlite.child_repository import SQLiteChildRepository
+from app.repositories_impl.sqlite.day_override_repository import SQLiteDayOverrideRepository
+from app.repositories_impl.sqlite.leave_wish_repository import SQLiteLeaveWishRepository
 from app.repositories_impl.sqlite.parental_leave_repository import SQLiteParentalLeaveRepository
 from app.repositories_impl.sqlite.personal_data_repository import SQLitePersonalDataRepository
 from app.repositories_impl.sqlite.planned_leave_repository import SQLitePlannedLeaveRepository
@@ -40,10 +42,14 @@ from app.repositories_impl.sqlite.workspace_repository import (
     SQLiteWorkspaceInvitationRepository,
     SQLiteWorkspaceRepository,
 )
+from app.services.allocation_service import AllocationInputLoader, PlanningEngineService
 from app.services.analytics_service import AnalyticsService
 from app.services.auth_service import AuthService
-from app.services.break_period_service import BreakPeriodService
+from app.services.calendar_service import CalendarService
 from app.services.child_service import ChildService
+from app.services.day_override_service import DayOverrideService
+from app.services.leave_wish_service import LeaveWishService
+from app.services.personal_data_service import PersonalDataService
 from app.services.planning_service import PlanningService
 from app.services.vacation_days_service import VacationDaysService
 from app.services.workspace_service import WorkspaceService
@@ -151,13 +157,22 @@ def get_vacation_days_repository(conn: ConnectionDep) -> VacationDaysRepository:
 VacationDaysRepositoryDep = Annotated[VacationDaysRepository, Depends(get_vacation_days_repository)]
 
 
-def get_break_period_repository(conn: ConnectionDep) -> BreakPeriodRepository:
+def get_leave_wish_repository(conn: ConnectionDep) -> LeaveWishRepository:
     if settings.database_type == "sqlite":
-        return SQLiteBreakPeriodRepository(conn)
+        return SQLiteLeaveWishRepository(conn)
     raise ValueError(f"Unsupported database_type: {settings.database_type}")
 
 
-BreakPeriodRepositoryDep = Annotated[BreakPeriodRepository, Depends(get_break_period_repository)]
+LeaveWishRepositoryDep = Annotated[LeaveWishRepository, Depends(get_leave_wish_repository)]
+
+
+def get_day_override_repository(conn: ConnectionDep) -> DayOverrideRepository:
+    if settings.database_type == "sqlite":
+        return SQLiteDayOverrideRepository(conn)
+    raise ValueError(f"Unsupported database_type: {settings.database_type}")
+
+
+DayOverrideRepositoryDep = Annotated[DayOverrideRepository, Depends(get_day_override_repository)]
 
 
 # ---------------------------------------------------------------------------
@@ -183,11 +198,25 @@ def get_vacation_days_service(repo: VacationDaysRepositoryDep) -> VacationDaysSe
 VacationDaysServiceDep = Annotated[VacationDaysService, Depends(get_vacation_days_service)]
 
 
-def get_break_period_service(repo: BreakPeriodRepositoryDep) -> BreakPeriodService:
-    return BreakPeriodService(repo)
+def get_leave_wish_service(repo: LeaveWishRepositoryDep) -> LeaveWishService:
+    return LeaveWishService(repo)
 
 
-BreakPeriodServiceDep = Annotated[BreakPeriodService, Depends(get_break_period_service)]
+LeaveWishServiceDep = Annotated[LeaveWishService, Depends(get_leave_wish_service)]
+
+
+def get_day_override_service(repo: DayOverrideRepositoryDep) -> DayOverrideService:
+    return DayOverrideService(repo)
+
+
+DayOverrideServiceDep = Annotated[DayOverrideService, Depends(get_day_override_service)]
+
+
+def get_calendar_service(day_override_service: DayOverrideServiceDep) -> CalendarService:
+    return CalendarService(day_override_service)
+
+
+CalendarServiceDep = Annotated[CalendarService, Depends(get_calendar_service)]
 
 
 def get_child_service(repo: ChildRepositoryDep) -> ChildService:
@@ -197,6 +226,13 @@ def get_child_service(repo: ChildRepositoryDep) -> ChildService:
 ChildServiceDep = Annotated[ChildService, Depends(get_child_service)]
 
 
+def get_personal_data_service(repo: PersonalDataRepositoryDep) -> PersonalDataService:
+    return PersonalDataService(repo)
+
+
+PersonalDataServiceDep = Annotated[PersonalDataService, Depends(get_personal_data_service)]
+
+
 def get_workspace_service(
     ws_repo: WorkspaceRepositoryDep,
     inv_repo: WorkspaceInvitationRepositoryDep,
@@ -223,13 +259,46 @@ AnalyticsServiceDep = Annotated[AnalyticsService, Depends(get_analytics_service)
 def get_planning_service(
     repo: PlannedLeaveRepositoryDep,
     analytics_service: AnalyticsServiceDep,
+    parental_leave_repo: ParentalLeaveRepositoryDep,
 ) -> PlanningService:
-    return PlanningService(repo, analytics_service)
+    return PlanningService(repo, analytics_service, parental_leave_repo)
 
 
 PlanningServiceDep = Annotated[PlanningService, Depends(get_planning_service)]
 
 
+def get_allocation_input_loader(
+    workspace_repo: WorkspaceRepositoryDep,
+    child_repo: ChildRepositoryDep,
+    pd_repo: PersonalDataRepositoryDep,
+    parental_leave_repo: ParentalLeaveRepositoryDep,
+    vacation_repo: VacationDaysRepositoryDep,
+    planned_leave_repo: PlannedLeaveRepositoryDep,
+    leave_wish_repo: LeaveWishRepositoryDep,
+    day_override_repo: DayOverrideRepositoryDep,
+) -> AllocationInputLoader:
+    return AllocationInputLoader(
+        workspace_repo=workspace_repo,
+        child_repo=child_repo,
+        personal_data_repo=pd_repo,
+        parental_leave_repo=parental_leave_repo,
+        vacation_repo=vacation_repo,
+        planned_leave_repo=planned_leave_repo,
+        leave_wish_repo=leave_wish_repo,
+        day_override_repo=day_override_repo,
+    )
+
+
+AllocationInputLoaderDep = Annotated[AllocationInputLoader, Depends(get_allocation_input_loader)]
+
+
+def get_planning_engine_service(loader: AllocationInputLoaderDep) -> PlanningEngineService:
+    return PlanningEngineService(loader)
+
+
+PlanningEngineServiceDep = Annotated[PlanningEngineService, Depends(get_planning_engine_service)]
+
+
 # ---------------------------------------------------------------------------
 # Current-user dependency (JWT bearer)
 # ---------------------------------------------------------------------------