Merge pull request 'v0.22.2 — commit ORCHESTRATOR.md manual' (#38 ) from docs/orchestrator-md-v2 into master

docs: make ORCHESTRATOR.md durable — drop specifics that rot (test counts, CI run numbers, paint values)
docs: document GITEA_TOKEN in .env.example
2026-09-20 09:57:56 +02:00 · 2026-09-20 07:50:11 +00:00 · 2026-09-20 07:41:55 +00:00 · 2026-09-20 07:34:04 +00:00 · 2026-09-20 09:06:59 +02:00 · 2026-09-20 06:58:42 +00:00
59 changed files with 3830 additions and 379 deletions
@@ -1,4 +1,6 @@
-node_modules
+# node_modules is intentionally IN the build context: the Dockerfile copies it straight
+# into the image (deps are installed by the CI job / dev host, which have working network;
+# the runner's dind daemon has broken outbound DNS for build containers).
 .next
 data/*.db
 # game state DB (v0.6.0): host-side, volume-mounted at runtime — never baked in
@@ -8,7 +10,8 @@ test-results
 .git
 .env
 .codenomad
-# e2e harness: @playwright/test is a host-global install, not a project dependency
+# e2e harness: the suite runs on the host / CI job, never inside the image
+# (@playwright/test is a devDependency of the runner, excluded from prod-deps)
 e2e
 playwright.config.ts
 # docs/deployment files never affect the app build — excluding them keeps
@@ -1 +1,2 @@
-# No environment variables required yet.
+# No environment variables required yet.
+GITEA_TOKEN=gitea-api-token
@@ -0,0 +1,203 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+  workflow_dispatch:
+
+jobs:
+  ci:
+    name: build + unit + e2e
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      # The runner provides a working docker CLI out of the box (full-dind) — no endpoint
+      # resolution needed. Job and app containers share the daemon, so put them on one
+      # user-defined network with a pinned subnet; the app gets a STATIC IP (172.39.0.10,
+      # declared in docker-compose.ci.yml) because Chromium got ERR_SSL_PROTOCOL_ERROR via
+      # the DNS alias while node-side HTTP to the same name worked — bypassing DNS removes
+      # that variable entirely. A stale network with a different subnet is recreated.
+      - name: Prepare e2e network
+        run: |
+          set -u
+          # Interrupted runs skip the end-of-run cleanup, leaking a USED DB volume into later
+          # runs (tests assume seeded state) — drop it so every run starts fresh.
+          docker volume rm flight-ci_flight-db 2>/dev/null || true
+          SUBNET=172.39.0.0/24
+          if docker network inspect flight-ci-e2e >/dev/null 2>&1; then
+            cur=$(docker network inspect flight-ci-e2e --format '{{(index .IPAM.Config 0).Subnet}}')
+            if [ "$cur" != "$SUBNET" ]; then
+              echo "stale flight-ci-e2e with subnet $cur — recreating with $SUBNET"
+              docker network rm flight-ci-e2e || true
+              docker network create --subnet "$SUBNET" flight-ci-e2e
+            fi
+          else
+            docker network create --subnet "$SUBNET" flight-ci-e2e
+          fi
+          if ! docker network connect flight-ci-e2e "$(hostname)"; then
+            echo "::error::failed to attach job container '$(hostname)' to flight-ci-e2e — the job must run in a container on the shared daemon (check runner config)" >&2
+            exit 1
+          fi
+          docker network inspect flight-ci-e2e --format 'containers on flight-ci-e2e: {{range .Containers}}{{.Name}} {{end}}'
+          echo "E2E_BASE_URL=http://172.39.0.10:3000" >> "$GITHUB_ENV"
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      # bun drives installs (repo ships bun.lock, no package-lock.json); pinned to 1.4.2.
+      # Retried: the runner's outbound network/DNS is flaky (transient EAI_AGAIN seen in CI).
+      - name: Install bun
+        run: |
+          set -u
+          ok=0
+          for i in 1 2 3; do
+            if npm i -g bun@1.4.2; then ok=1; break; fi
+            echo "::warning::bun install attempt $i/3 failed (likely transient network) — retrying in 5s" >&2
+            sleep 5
+          done
+          [ "$ok" = "1" ] || { echo "::error::bun install failed after 3 attempts" >&2; exit 1; }
+          bun --version
+
+      # Job-level dep cache via the runner's built-in cache server. continue-on-error on
+      # both steps: an unreachable/broken cache server must never break the run.
+      - name: Restore deps cache
+        uses: actions/cache@v4
+        continue-on-error: true
+        with:
+          path: |
+            node_modules
+            $HOME/.bun/install/cache
+          key: ${{ runner.os }}-deps-bun-${{ hashFiles('bun.lock') }}
+
+      # Retried: the runner's outbound network/DNS is flaky (transient EAI_AGAIN seen in CI).
+      - name: Install dependencies
+        run: |
+          set -u
+          ok=0
+          for i in 1 2 3; do
+            if bun install --frozen-lockfile; then ok=1; break; fi
+            echo "::warning::dependency install attempt $i/3 failed (likely transient network) — retrying in 5s" >&2
+            sleep 5
+          done
+          [ "$ok" = "1" ] || { echo "::error::dependency install failed after 3 attempts" >&2; exit 1; }
+
+      # No explicit save step: caches marked by the restore steps are uploaded automatically at job end.
+
+      # Map e2e tests abort ALL *.openfreemap.org traffic (page.route → route.abort()), assuming
+      # styles/fonts/sprites are SELF-HOSTED from /styles, /fonts, /sprites — locally that pack is
+      # produced by `npm run assets:download` and reaches the app via the compose volume mount.
+      # CI must reproduce it or lib/mapStyles.ts probes /map-assets-manifest.json, finds nothing,
+      # falls back to remote OFM styles — which the tests abort → style never loads (the
+      # deterministic map.spec.ts wheel-zoom + style-switcher failures). The script needs no env
+      # vars/args and writes into ./public (git-ignored, docker-excluded; the app container gets
+      # it via the volume mount in docker-compose.ci.yml).
+      - name: Restore map assets cache
+        uses: actions/cache@v4
+        continue-on-error: true
+        with:
+          path: public/
+          key: ${{ runner.os }}-map-assets-${{ hashFiles('scripts/download-map-assets.mjs') }}
+
+      # Retried: the runner's uplink is flaky (same transient EAI_AGAIN pattern as dep install).
+      # The job-end cache upload seeds public/ for future runs; a partial pack without
+      # map-assets-manifest.json is harmless — the app probes that manifest and falls back to
+      # remote styles when it's missing.
+      - name: Download map assets (retries)
+        run: |
+          set -u
+          ok=0
+          for i in 1 2 3 4 5 6; do
+            if npm run assets:download; then ok=1; break; fi
+            echo "::warning::map assets download attempt $i/6 failed (likely transient network) — retrying in 5s" >&2
+            sleep 5
+          done
+          [ "$ok" = "1" ] || { echo "::error::map assets download failed after 6 attempts" >&2; exit 1; }
+
+      - name: Build
+        run: npm run build
+
+      - name: Unit tests
+        run: npx vitest run
+
+      # Browsers run locally in CI (PW_REMOTE_BROWSER=0 below): the shared remote browser
+      # server at 192.168.1.4 cannot reach a stack inside dind, and local chromium keeps
+      # the job self-contained.
+      # Browser binaries (~187 MiB) cached across runs: the runner's uplink is flaky and
+      # cdn.playwright.dev downloads time out mid-transfer; once seeded, installs skip the download.
+      - name: Restore browser cache
+        uses: actions/cache@v4
+        continue-on-error: true
+        with:
+          path: $HOME/.cache/ms-playwright
+          key: ${{ runner.os }}-pw-browsers-${{ hashFiles('package.json') }}
+
+      # Retried: cdn.playwright.dev is flaky from this runner — Playwright's internal 5-retry
+      # window (~40-90s) is often not enough, but runs get through with a longer one. Progress
+      # accumulates across attempts: playwright skips already-installed browsers.
+      - name: Install browsers (local)
+        run: |
+          set -u
+          ok=0
+          for i in 1 2 3 4 5 6; do
+            if npx playwright install --with-deps chromium; then ok=1; break; fi
+            echo "::warning::browser install attempt $i/6 failed (flaky cdn.playwright.dev) — retrying in 5s" >&2
+            sleep 5
+          done
+          [ "$ok" = "1" ] || { echo "::error::browser install failed after 6 attempts" >&2; exit 1; }
+
+      # Cache the base image on the shared daemon up front: a single loud failure here
+      # beats a 6-minute BuildKit "failed to solve" when the daemon's outbound net is down.
+      - name: Pull e2e base image
+        run: docker pull node:22-slim
+
+      # Pre-build the e2e image with retries (flaky runner network); the E2E step's own
+      # build then becomes a fast no-op. Plain progress keeps BuildKit output visible.
+      - name: Build e2e image (retries)
+        run: |
+          set -u
+          ok=0
+          for i in 1 2 3; do
+            if docker compose -f docker-compose.ci.yml -p flight-ci build --progress=plain; then ok=1; break; fi
+            echo "::warning::e2e image build attempt $i/3 failed (likely transient network) — retrying in 5s" >&2
+            sleep 5
+          done
+          [ "$ok" = "1" ] || { echo "::error::e2e image build failed after 3 attempts" >&2; exit 1; }
+
+      # E2E against an isolated stack on the shared daemon — never the production instance.
+      # docker-compose.ci.yml joins the flight-ci-e2e network prepared above; project name
+      # flight-ci keeps it distinct from production. E2E_DEPLOY_CMD makes the config's
+      # webServer block deploy + wait for readiness (http://app:3000 via service DNS);
+      # E2E_COMPOSE_ARGS points state.spec.ts' mid-run `docker compose restart flight` at
+      # the same file + project. E2E_BASE_URL comes from GITHUB_ENV (Prepare e2e network).
+      - name: E2E (isolated stack in dind)
+        env:
+          PW_REMOTE_BROWSER: "0"
+          # Build separately with plain progress so BuildKit step output is visible in the
+          # job log (auto progress hides it). Playwright's webServer needs a long-running
+          # command — `up -d` returns immediately and triggers "exited early"; `logs -f`
+          # keeps it alive, streams app logs into CI output for debugging, and is killed with
+          # the job (an orphaned `logs -f` dies on its own when cleanup removes the container).
+          E2E_DEPLOY_CMD: "docker compose -f docker-compose.ci.yml -p flight-ci build --progress=plain && docker compose -f docker-compose.ci.yml -p flight-ci up -d && docker compose -f docker-compose.ci.yml -p flight-ci logs -f"
+          E2E_COMPOSE_ARGS: "-f docker-compose.ci.yml -p flight-ci"
+          # Chromium honors proxy env vars on Linux (node-side HTTP does not) — keep the
+          # in-network app host out of any proxy path.
+          NO_PROXY: app,localhost,127.0.0.1,.kkhost.pl
+          no_proxy: app,localhost,127.0.0.1,.kkhost.pl
+        # Connectivity diagnostics now run post-deploy in e2e/ci-diagnostics.ts (globalSetup).
+        # --reporter=list prints each test as it completes (name + ✓/× + duration) for progress
+        # visibility in the job log; failure error context/snapshots are unchanged.
+        run: npx playwright test --reporter=list
+
+      # The daemon is shared with production — never leave our stack or network behind.
+      # -v drops the named DB volume so every run seeds fresh (no schema drift between PRs).
+      - name: Cleanup e2e stack + network
+        if: always()
+        run: |
+          docker compose -f docker-compose.ci.yml -p flight-ci down --remove-orphans -v || true
+          docker network remove flight-ci-e2e 2>/dev/null || true
@@ -1,15 +1,16 @@
 # Flight Simulator — Workflow Rules

 ## Change process (mandatory)
-1. **Small, incremental changes** — work is done one change at a time, in smaller parts; each part must be tested thoroughly with unit and e2e tests covering it before moving on.
-2. **Changelog entry** — every such change is listed in `CHANGELOG.md` with date, time and version (format: `## v<version> — YYYY-MM-DD HH:MM`, then bullet points of what changed).
-3. **Version bump** — the version is updated in `package.json`.
-4. **Commit + tag** — a commit is created for each change, tagged with the version (e.g. `v0.1.0`), push it to remote repo.
+1. **Small, incremental changes** — work is done one change at a time, in smaller parts; each part must be tested thoroughly with unit and e2e tests covering it before moving on. Connected issues/tasks that reference the same part of code MAY be done together on one branch/PR with a single version bump (e.g. two UI tweaks to the same panel).
+2. **Feature branch + PR** — every change lands on a feature branch off `master` (no direct pushes to master). The branch carries the commits below; open a pull request to `master`.
+3. **Changelog entry** — every such change is listed in `CHANGELOG.md` with date, time and version (format: `## v<version> — YYYY-MM-DD HH:MM`, then bullet points of what changed).
+4. **Version bump** — the version is updated in `package.json`.
+5. **CI must pass** — enforced by branch protection on `master` (required status check `CI / build + unit + e2e (pull request)`): the PR cannot be merged until CI is green. Merge via auto-merge (`POST /repos/{owner}/{repo}/pulls/{n}/merge` with body `{"do":"merge","merge_style":"merge","merge_when_checks_succeed":true}`) so it merges automatically once CI passes. CI never deploys to production; its e2e runs against an isolated stack inside dind.
+6. **Tag + manual deploy after merge** — once merged, tag the version on `master` (e.g. `v0.13.0`). Production (`https://flight.dev.kkhost.pl`) is updated manually afterwards: `docker compose up -d --build` on the host.

 ## E2E tests (mandatory)
-1. **Docker compose instance is the app under test** — e2e always runs against the docker-compose build behind Traefik (`https://flight.dev.kkhost.pl`), never a local `next dev` on :3000 (dev builds don't render for non-loopback clients, and a second instance splits state).
-2. **Update before testing** — deploy current code first: `docker compose up -d --build`.
-3. **Remote browsers** — tests run through the shared Playwright server at `192.168.1.4:3000` (Docker image tag must match this repo's @playwright/test version); plain `npx playwright test` handles deploy + readiness + remote connect (see `playwright.config.ts`).
+1. **CI-only** — e2e runs ONLY in CI, against an isolated docker stack inside dind built from `docker-compose.ci.yml` (project name `flight-ci`, app container on a static IP; see `.gitea/workflows/ci.yml`). There are NO local e2e runs at all: locally you verify with `tsc --noEmit` + `npx vitest run` + `npx playwright test --list` (typecheck, unit suite, specs compile and list), and the full e2e suite is verified by CI on every PR. **CI never deploys to or modifies production.**
+2. **CI env vars** (`playwright.config.ts`, all optional) — `E2E_BASE_URL` (app under test; CI sets it to the in-network app host, so the config's default of the live Traefik instance at `https://flight.dev.kkhost.pl` is never used), `E2E_DEPLOY_CMD` (runs as Playwright webServer: deploys the stack and waits for readiness before tests start; CI uses build + `up -d` + `logs -f`), `PW_REMOTE_BROWSER=0` (CI runs local chromium because the shared remote browser server at 192.168.1.4 cannot reach a stack inside dind — when unset, the config defaults to that remote server and to the live instance as baseURL), and `E2E_COMPOSE_ARGS`, read by `e2e/state.spec.ts` for its mid-run `docker compose restart flight` (CI points it at `-f docker-compose.ci.yml -p flight-ci`).

 ## API
 1. **Live base URL** — `https://flight.dev.kkhost.pl` (the docker-compose build behind Traefik).
@@ -1,5 +1,138 @@
 # Changelog

+## v0.22.2 — 2026-09-20 07:32
+- Docs: ORCHESTRATOR.md successor-agent manual committed to the repo; its token reference now points to the gitignored local .env (GITEA_TOKEN, rotated after the Sept 2026 incident); §9 rewritten as durable 'how to find current state' guidance instead of a stale snapshot; no code changes
+
+## v0.22.1 — 2026-09-20 06:57
+- Hygiene: gitignore the local-only ORCHESTRATOR.md successor-agent manual (it references host-specific setup and must never be version-controlled); no code changes
+
+## v0.22.0 — 2026-09-19 21:42
+- **Hover route trace on job-list rows (ISS-022).** Hovering an open package in the right pane now draws the ENTIRE great-circle trace between origin and destination, not just the two endpoint rings. Zero pane edits — the rows already sent `{kind:'package', originIcao, destIcao}`; `components/Map.tsx` now derives from/to for any hover target carrying two ICAOs and pushes a new pure builder's output (`hoverRouteGeoJson(fromIcao, toIcao, airportsByIcao)` in `lib/mapData.ts`: one LineString via the existing `greatCircleArc` slerp, empty FeatureCollection when either endpoint is missing from the airport index or the `''` no-hover sentinel) into a NEW dedicated `hover-routes` GeoJSON source + top-most dashed `hover-route` LineLayer (paint: `#facc15` matching the airports-highlight ring, width 4, `line-dasharray [2,2]`). The shared `routes` source can't carry this — it only holds FLYING legs, so an open package's or a grounded relocation's planned route was never in it. The layer is added in `ensureLayers` after the highlight layers so style switches keep it; `applyHoverRef` re-pushes data on every hover
+- **Same trace on On-board cargo rows (ISS-025).** Each `onboard-package-{id}` row in the left pane's On board section now reports `{kind:'package', originIcao, destIcao, planeId: plane.id}` on mouseenter — same full trace as job-list rows PLUS the carrying plane's halo stays lit via the new optional `planeId` field (Map uses `h.planeId ?? ''` for the planes/routes-highlight filters). Mouseleave restores the block's plain `{kind:'plane', id}` highlight; leaving the whole block still ends at null because React fires the child's mouseleave before the parent's
+- **Relocate panel hover previews the planned flight (ISS-027).** The left pane's Relocate section gains `data-testid="relocate-section"` + enter/leave handlers: with a grounded plane AND destination selected it reports `{kind:'route', fromIcao: relocatePlane.locationIcao, toIcao: relocateDest.icao}` (else null), and Map draws the planned trace AND rings ONLY the target airport in airports-highlight (origin stays unmarked — the destination is what the issue asks to see). `HoverTarget` (`components/hoverTypes.ts`) extends to `{kind:'plane';id} | {kind:'package';originIcao;destIcao;planeId?} | {kind:'route';fromIcao;toIcao}`. Existing semantics unchanged: plane hovers filter the three highlight layers exactly as before, package hovers keep BOTH endpoint rings (now plus the trace)
+- **Target airport highlighted in a distinct color on job-list / relocation hover (ISS-022).** The destination of any two-endpoint hover now gets its own ring in a NEW top-most `airports-target-highlight` circle layer (`components/Map.tsx`, same `airports` source and r=9 transparent-fill geometry as airports-highlight, but green `#4ade80` stroke width 3 vs the yellow `#facc15` endpoint rings) — added last in `ensureLayers` so it also sits above the hover-route line at its endpoint; `applyHoverRef` filters it to the destination icao for BOTH `'package'` and `'route'` hovers (empty-string sentinel otherwise). airports-highlight itself is untouched, so the existing both-endpoints / target-only assertions stay valid
+- Tests: unit — new `describe('hoverRouteGeoJson …')` in `lib/mapData.test.ts`: no-hover sentinel → empty; two known airports → one arc with exact dataset endpoints; reversed-input symmetry; missing from/to ICAO → empty (baseline 283 → 288). e2e (`e2e/hover.spec.ts`) — open-package test extended with hover-route endpoint assertions (line geometry first/last coords compared against `/api/airports` lookups) + trace-clear check; new `hovering an on-board cargo row draws its trace and keeps the plane halo` (load via API, hover the row, assert trace endpoints + planes-highlight for that plane, abandon the package afterwards to leave a clean instance); new `hovering the Relocate section previews the planned route and target airport` (selects starter + LEMD via the existing testids, hovers `[data-testid="relocate-section"]`, asserts trace endpoints + target-only ring). New helpers: `airportLonLat(page, icao)` and `expectHoverRoute(page, fromIcao, toIcao)`; all new/extended assertions call `fitToAirports` first since `queryRenderedFeatures` is viewport-scoped
+- Verified: `tsc --noEmit` clean; unit suite green locally (288); `npx playwright test --list` = 41 tests (was 39, +2 new in hover.spec.ts); e2e not run locally by design — CI verifies against an isolated stack
+- **Fix: hover-route e2e timeouts (CI run #69).** All three trace tests failed at `expectHoverRoute` with the 15 s "waiting for the hover-route line EDDF → LEMD" timeout although the dashed trace WAS drawn correctly — the helper assumed `queryRenderedFeatures(undefined, {layers:['hover-route']})` returns exactly one feature whose endpoints are bit-identical to the `/api/airports` dataset coords. MapLibre GL JS stores GeoJSON geometry in per-tile INTEGER grids (`Math.round(extent·(x·2^z − tx))`, maplibre-gl 6.10) and clips long lines across tiles, so a 1420 km leg comes back as one feature PER intersecting tile (empirically 4 at z=4 / 5 at z=5 for EDDF→LEMD, verified against the installed build's GeoJSONVT) with endpoints quantized by up to ~half a grid step (~0.001° observed at z≥4, ~0.02° worst case at z=0): both the `feats.length !== 1` guard and the strict `===` coordinate comparisons could never be true. The helper now accepts any number of segments and matches endpoints within 0.05° (~5 km — above worst-case quantization at any zoom, below the distance between any two EU airports): some segment must start at origin and some end at destination; all other assertions unchanged. App side verified correct (no race: `ensureLayers` awaits the airport fetch before creating sources/layers and re-applies hover afterwards; layer/source ids match) — no app changes
+- **Fix: hover-route e2e — evaluate maplibre geometry in-page before Playwright serialization (CI runs #69–#71).** All three trace tests failed for a serialization reason, not a data one: `renderedFeatures` returned live `GeoJSONFeature` instances from `queryRenderedFeatures`, whose `geometry` is a lazy PROTOTYPE getter — and Playwright's evaluate serialization copies only own enumerable properties (verified empirically), so every feature arrived in test context WITHOUT geometry. Run #69 timed out on the strict length guard before touching it, run #70 threw `TypeError: Cannot read properties of undefined (reading 'coordinates')`, run #71's defensive filter found nothing and timed out. The helper now maps each feature to a plain object inside page.evaluate so the getter is evaluated in-page; the endpoint-matching predicate keeps its degenerate-segment filter as belt-and-braces — no app changes
+
+## v0.21.0 — 2026-09-19 21:01
+- **Relocate panel moves to the left pane (ISS-023).** Flying an empty/grounded plane to another airport is "anything with our plane", so it belongs in the left pane, not as a market row on the right. The `.market-row.market-row-relocate` JSX (`relocate-plane` select of grounded planes labeled `{planeName} — {icao}`, `relocate-dest` name-sorted select, `relocate-go` button → `POST /api/planes/{id}/fly {destIcao}`) moved verbatim from `components/RightPane.tsx` into a new "Relocate" `<section>` in `components/LeftPane.tsx`, inserted between On board and Time. Its state (`relocatePlaneId` / `relocateDestIcao`) and the one-time `/api/airports` fetch (promise-ref pattern, GeoJSON → `{name, icao}[]` sorted by name) moved with it — the relocate-dest select was that fetch's only consumer in RightPane, so nothing else there changed. Busy gating rewired from RightPane's `busy` to LeftPane's own `useGameAction` instance (`actionsBusy`); a grounded-plane filter was added next to the existing `onboard` compute; plane labels reuse the expression already inlined in the Fleet rows. Testids kept byte-identical (`relocate-plane` / `relocate-dest` / `relocate-go`) and the row keeps its `.market-row market-row-relocate` classes (global CSS, works in the 360 px left pane); stale "280 px right pane" comment updated in `app/globals.css`. The map-popup relocation controls (`airport-popup-*`, Map.tsx) are a separate surface fed by the snapshot only — untouched
+- Tests: e2e — only `relocation.spec.ts` touches these testids and all locators are global, so no locator changes; the first test's title (which mentioned "right pane") and the file header comments now say left-pane Relocate section. No unit-test changes (baseline 283)
+- Verified: `tsc --noEmit` clean; unit suite green locally; e2e not run locally by design — CI verifies against an isolated stack
+
+## v0.20.0 — 2026-09-19 19:21
+- **On board moved to the left pane (ISS-021).** The "On board" section (per-plane blocks with loaded/expired cargo rows, Refuel-for-leg / Fly-to / Abandon + penalty preview) now renders in `components/LeftPane.tsx` between Fleet and Time — wallet stays on top. The JSX moved verbatim (same testids: `onboard-{planeId}`, `onboard-package-{pkg.id}`, `refuel-for-*`, `fly-to-*`, `abandon-*` + penalty preview), along with the `onboard` computation (`planes.filter(flying || slotsUsedFor > 0)`) and per-plane cargo filter. All onboard e2e locators are global testids, so existing specs work unchanged
+- **Left pane widened: grid swapped to 360/1fr/280.** `.app-shell` in `app/globals.css` goes from `280px minmax(0, 1fr) 360px` to `360px minmax(0, 1fr) 280px` — total fixed width stays 640 px, so the map column is pixel-identical (map.spec.ts clicks via dynamic `map.project()`). Stale comments updated (on-board blocks now in the left pane; Relocate row comment reflects the 280 px right pane)
+- **Shared action runner hook.** RightPane's local `runAction` (busy gate, inline pane error + shell toast on failure, full post-action snapshot pushed via `applySnapshot`) extracted to new `lib/useGameAction.ts`: `useGameAction(state, applySnapshot, onError) → { runAction, busy, actionError }`, exact semantics kept incl. the non-2xx throw/catch and inline-error auto-clear on the next snapshot. Used in BOTH panes; LeftPane receives `applySnapshot` from the shell (`app/page.tsx`). RightPane keeps `[data-testid="right-error"]`; LeftPane gains a matching `[data-testid="left-action-error"]`. Pure helpers `slotsUsedFor` / `loadEligiblePlanes` stay exported from RightPane (unit tests import them there; LeftPane imports `slotsUsedFor` from it); the Market Relocate row + `/api/airports` fetch stay in RightPane
+- Tests: e2e — `panes.spec.ts` first test now also asserts the "On board" heading is visible inside `[data-testid="left-pane"]` and absent from the right pane; stale header comments updated in `actions.spec.ts` / `right-pane.spec.ts`. No unit-test changes (baseline 283)
+- Verified: `tsc --noEmit` clean; unit suite green locally; e2e not run locally by design — CI verifies against an isolated stack
+- **On-board cargo rows are two lines (ISS-028).** Each `onboard-package-*` row now stacks a full-width "Fly to <airport>" button on its own line above Refuel + Abandon side by side: `components/LeftPane.tsx` moves the fly-to button out of `.contract-main` into the row root and wraps refuel-for + abandon in a new `.onboard-actions` div — all testids, label text, penalty preview and disabled states unchanged. Long destination names in the fly-to label truncate with an ellipsis instead of overflowing: the label's inner span gets `min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap`, full name preserved via a `title` attribute (CSS in `app/globals.css`: `.onboard-block .contract-row` becomes flex-column, new `.onboard-fly-btn` / `.onboard-fly-label` / `.onboard-actions`). No e2e changes — specs locate everything by testid and assert no layout or button order; no version bump (part 2 of v0.20.0)
+
+## v0.19.2 — 2026-09-19 20:06
+- **AGENTS.md "Change process" item 1** — connected issues/tasks that reference the same part of code may now be done together on one branch/PR with a single version bump (e.g. two UI tweaks to the same panel)
+- **AGENTS.md "E2E tests" section rewritten to match current reality** — e2e runs ONLY in CI, against an isolated docker stack inside dind (`docker-compose.ci.yml`); there are NO local e2e runs at all (local verification = `tsc --noEmit` + `npx vitest run` + `npx playwright test --list`; the full suite is verified by CI on every PR). Dropped the stale local-run instructions (deploying to the Traefik-routed instance before testing, driving browsers through the remote Playwright server at 192.168.1.4:3000); kept and reworded the CI env vars that actually exist in `playwright.config.ts` (`E2E_BASE_URL`, `E2E_DEPLOY_CMD`, `PW_REMOTE_BROWSER=0`, `E2E_COMPOSE_ARGS`)
+
+## v0.19.1 — 2026-09-19 18:48
+- AGENTS.md: document that CI-green is enforced on master by branch protection (required status check) and that merges use auto-merge (`merge_when_checks_succeed`) so PRs merge automatically once CI passes
+
+## v0.19.0 — 2026-09-19 18:05
+- **Auto-slow to 1× when all planes have landed (ISS-011).** When the last plane in flight lands, the sim slows down on its own so an idle fleet doesn't sit at 1000×. Server-side and authoritative: `tickOnce` (`lib/sim/engine.ts`) now remembers how many planes `deliverPackages` finalized during a tick, and when ≥1 plane landed this tick AND no plane remains with status `'flying'` AND the sim is not paused, it persists `timeScale = 1` on the same `sim_state` write as the clock — so the UI slider reflects it on the very next snapshot (no API or OpenAPI change: timeScale is still set via the existing `POST /api/sim`, and `clampTimeScale` semantics are untouched since 1 is a valid ladder value)
+- **Arrival-triggered, not idle-enforced.** The trigger fires only on the tick that processes a landing — a grounded fleet at high scale with no flight ever happening is left alone (this keeps the existing slider e2e in `panes.spec.ts` green: it sets 1000× and expects the server to confirm it while nothing is flying). Paused state is untouched: while paused no landings are processed, so a paused sim never auto-slows
+- **No auto-restore by design.** The previous scale is not remembered — once the game slows to 1× after the last landing, the player speeds up manually again (slider or `POST /api/sim`). Deliberately minimal scope: no "resume my old speed" behavior
+- Tests: unit — new `describe('auto-slow …')` block in `lib/sim/engine.test.ts`: last plane lands → stored timeScale becomes 1; a landing while another plane is still flying → no change; already at 1× → stays 1; paused sim with all planes landed → no change. e2e — new `e2e/auto-slow.spec.ts` (serial mode, SCALE=1000, self-heal fly-home in afterEach like relocation.spec.ts): sets 1000× via the API, dispatches plane-starter on the shortest leg from its hub (EDDF → nearest airport), waits for the landing and asserts the server's `timeScale` is exactly 1 in that snapshot, then proves manual override still works (`POST /api/sim {timeScale: 1000}` confirmed by response + fresh snapshot)
+- **e2e suite adapted to the new behavior.** Every existing spec that flies out-and-back relied on 1000× persisting across a landing — with ISS-011 it no longer does, so each return leg now re-sets SCALE explicitly: `flyHomeViaApi` in actions/relocation/right-pane/hover (re-set before the repositioning flight after waiting for an in-flight leg to land) and the restore legs inside the test bodies of actions.spec.ts (core loop, expired packages, validation paths ×2), right-pane.spec.ts (fly-to-destination, refuel-for-leg) and hover.spec.ts (flying-plane route highlight). map-interactions.spec.ts needed no change — its `loadAndFly` helper already re-sets SCALE before every landing wait
+- Verified: `tsc --noEmit` clean; unit suite green locally; e2e not run locally by design — CI verifies against an isolated stack
+
+## v0.18.0 — 2026-09-19 16:02
+- **Relocate a grounded (empty) plane to any airport (ISS-010).** `flyPlane` has allowed pure repositioning since v0.12.0, but the UI only exposed flying for planes that carried cargo — an empty grounded plane had no fly control anywhere. Two new surfaces now drive the EXISTING `POST /api/planes/{id}/fly {destIcao}` endpoint (no API or OpenAPI change):
+  - **Right-pane market row** (`components/RightPane.tsx`): a fourth `.market-row` with `[data-testid="relocate-plane"]` (grounded planes, "ATR 72-600 — EDDF" labels), `[data-testid="relocate-dest"]` (all airports from a one-time `GET /api/airports` fetch per page life — same promise-ref pattern as Map.tsx — sorted by name for stable e2e selection) and the `[data-testid="relocate-go"]` "Relocate" button, disabled while busy or until both selects have a value. Same effective-selection + `runAction` pattern as the buy/sell/refuel rows (first grounded plane / first airport preselected); the row wraps (`market-row-relocate`) since two selects don't fit one 360 px line
+  - **Airport popup Relocate row** (`components/Map.tsx`): after the name/ICAO/local-time/weather lines, a `.popup-relocate` block with `[data-testid="airport-popup-plane"]` (grounded planes from the latest polled snapshot at click time) and `[data-testid="airport-popup-relocate"]` "Relocate here" — disabled until a plane is picked; on click it POSTs fly to the clicked airport, pushes the response snapshot through the shell's `applySnapshot` (new Map prop, same callback RightPane receives), and reports success/failure in `[data-testid="airport-popup-relocate-status"]`. With no grounded planes the row shows `[data-testid="airport-popup-no-planes"]` instead. Popups are plain HTML, not React — controls wired via `popup.getElement().querySelector(...)` after `.addTo(map)`
+- **Bigger airport markers (ISS-010).** The r=3 dots were hard to click: `airports-circles` paint in `components/Map.tsx` goes from radius 3 / stroke 1 to radius 5 / stroke 1.5, and the hover highlight ring follows (r=8 → r=9). Paint-only — no data or interaction changes
+- No server or OpenAPI changes — both surfaces reuse the existing fly endpoint (validations unchanged: 404 unknown plane / 409 flying or insufficient fuel / 400 unknown ICAO, strict unknown-field rejection kept)
+- Tests: e2e — new `e2e/relocation.spec.ts` (serial mode, SCALE=1000, self-heal fly-home in afterEach like actions.spec.ts): market-row test ensures plane-starter grounded at the hub via API, picks it + the nearest non-hub airport (shortest leg) and asserts `/api/state` shows `flying` with that destIcao after clicking Relocate; popup test clicks the isolated LFRS marker (projected-center pattern from map.spec.ts), asserts the select lists "ATR 72-600 — EDDF" and the button is disabled until a plane is picked, then relocates via the popup. Marker-size regression gate = the existing map.spec.ts click tests keep passing
+- Verified: `tsc --noEmit` clean; unit suite green locally (no lib/ changes — flyPlane's zero-package case already covered by actions.test.ts); e2e not run locally by design — CI verifies against an isolated stack
+- **Fix (CI run #50): POPUP_AIRPORT scoping in the popup relocation e2e.** The LFRS marker click passed `POPUP_AIRPORT` into a `page.evaluate(() => …)` callback that runs in the BROWSER, where Node-scope constants don't exist — deterministic `ReferenceError: POPUP_AIRPORT is not defined` (relocation.spec.ts popup test, both attempts of run #50). The constant is now passed as an evaluate argument (`page.evaluate(({lon, lat}) => …, POPUP_AIRPORT)`); the other evaluate in the file only touches browser globals and needed no change. Test-only — no app code touched
+- **Fix (CI run #51): strict-mode locator in the popup relocation e2e.** `expect(planeSel.locator('option')).toContainText(…)` resolved to BOTH options (placeholder + plane) → strict mode violation (relocation.spec.ts popup test, both attempts of run #51; the app rendered correctly). The assertion now targets `option[value="plane-starter"]` specifically with `toHaveText`. Test-only — no app code touched
+
+## v0.17.0 — 2026-09-19 14:49
+- **Bottom-right toasts for action errors (ISS-008).** Error messages like "insufficient funds: a ATR 72-600 costs 200000, you have 62721" now appear as toasts in the bottom-right corner — new `lib/useToasts.ts` hook (`useToasts() → {toasts, push(kind, msg), dismiss(id)}`, auto-dismiss after ~5 s, queue capped at 4 dropping the oldest; pure core `pushToast` unit-tested) and new `components/Toasts.tsx` `<ToastStack>` (fixed container `.toasts`, items `[data-testid="toast"]` with class `toast toast-error|toast-info` + a × dismiss button). Wired into BOTH error paths: `RightPane.runAction`'s catch now calls the shell's `onError` in addition to keeping the inline `[data-testid="right-error"]` pane error, and `LeftPane.applySimControls`'s catch (previously console.error-only) reports "Failed to update time controls (…)" through the same callback. The shell (`app/page.tsx`) owns the hook and renders the stack; CSS in `app/globals.css`
+- **Event messages via snapshot diffing.** No server event feed exists, so new pure `lib/deriveEvents.ts` — `diffSnapshots(prev: StateSnapshot | null, next) → {kind:'info', message}[]` — derives human-readable events from the fields already in `/api/state`: plane landing (`flying→available`, "ATR 72-600 landed at Frankfurt"), package delivery (`loaded→delivered`, "Package delivered: +€X" with the reward), expiry (`open|loaded→expired`, "Package expired: A → B"), new packages (id only in next, "New package available: A → B") and planes bought/sold (plane id set changed, "Bought/Sold {model}"). The shell keeps a `prevRef` and diffs on every snapshot change, pushing each event as an info toast; the first snapshot after load emits nothing (no baseline — no page-load spam)
+- **Browser notifications when the window is not focused.** Each derived event also fires `new Notification('Flight Ops', {body})` when `document.hidden && 'Notification' in window && Notification.permission === 'granted'`. The left-pane Time section gains an explicit opt-in button (`[data-testid="enable-notifications"]`) calling `Notification.requestPermission()`; its label reflects the result ("Enable notifications" → "Notifications enabled"/"Notifications blocked"), and it renders disabled with a tooltip title when the API is absent. SSR-safe: permission state starts null and is read in an effect after hydration
+- No server or OpenAPI changes — diffing uses only existing snapshot fields (verified: planes by id/status/locationName, packages by id/status/reward/origin+dest names)
+- Tests: unit — new `lib/deriveEvents.test.ts` suite pins every event format (landing, delivery with reward, expiry from open and loaded, new-package appearance, bought/sold, identical snapshots → [], first snapshot → [], non-events like takeoff/load ignored); `lib/useToasts.test.ts` covers the queue cap. e2e — new `e2e/toasts.spec.ts`: deterministic insufficient-funds path (select the most expensive model in `[data-testid="market-buy-model"]`, click Buy, expect a visible error toast matching /insufficient funds/ AND the inline `right-error` still showing; skips only if cash already covers the plane on a long-lived local instance) and the notifications opt-in (unsupported → disabled + title; otherwise fresh context shows "Enable notifications" and after clicking the label reflects the result — soft, since headless CI may deny permission)
+- Verified: `tsc --noEmit` clean; unit suite green locally; e2e not run locally by design — CI verifies against an isolated stack
+- **Fix (CI runs #44/#47): sim-control POSTs are retried before surfacing the error.** A dropped `POST /api/sim` on the runner's flaky uplink left the UI optimistic while the server kept the old scale — panes.spec.ts:74 timed out with timeScale stuck at 1000 (run #47). `applySimControls` now retries each commit up to 3× total (~500 ms backoff) before surfacing the error toast; a newer intent arriving mid-retry supersedes the in-flight body instead of waiting out its retries (last-wins queueing kept), and the endpoint's set-semantics make re-sending an already-applied value idempotent. Pure retry core `retrySimPost` exported from LeftPane + unit-tested. Also run #47: toasts.spec.ts Part B is now permission-state-aware — headless Chromium reports `Notification.permission` as 'denied' (not 'default'), so the test branches on the actual state (denied → assert blocked label without clicking; granted → enabled label; default → prompt, click, accept either resulting label)
+
+## v0.16.1 — 2026-09-19 14:00
+- **Smooth client-side sim clock with per-snapshot re-sync (ISS-007).** The left-pane "Time" display used to jump once per 1 s poll because it rendered the snapshot's `clockMs` verbatim. It now ticks smoothly on the client between polls: new hook `lib/useSimClock.ts` keeps an anchor `{clockMs, at, timeScale, paused}` and re-derives the display clock every ~100 ms as `anchor.clockMs + (now − at) × timeScale` — exactly the server's own tick model (`tickOnce`: real-time × timeScale), so client extrapolation mirrors authoritative game time. Every new snapshot re-anchors to server truth, bounding any drift by network latency only; while paused the display is frozen at the anchor value (advance 0). The pure core `advanceSimClock(anchor, nowMs)` is exported and unit-tested in node
+- **LeftPane consumes it for the `sim-clock` paragraph ONLY** (`components/LeftPane.tsx`): fed with EFFECTIVE controls `{timeScale: pendingScale ?? snapshot scale, paused}` so a slider drag or pause click takes effect on click/drag without waiting for a confirming snapshot; the `(paused)` suffix keeps coming from the effective paused flag. Right-pane deadline/penalty previews are untouched — they stay computed from the snapshot's `clockMs` (deterministic against server truth)
+- No server or OpenAPI changes — display-only client work
+- Tests: unit — new suite in `lib/useSimClock.test.ts` pins the extrapolation math (exact elapsed × scale advance, frozen while paused at any scale, zero-elapsed identity, clock-skew clamp never goes backwards, mirrors the tickOnce formula under the 2 s clamp). e2e (`panes.spec.ts`) — new test: at scale 1000 sample `sim-clock` three times ~1.3 s apart real time and assert the displayed clock strictly advances between CONSECUTIVE samples (with poll-only rendering a pair could straddle zero snapshots and not change), plus format check and a total-advance sanity bound
+- Verified: `tsc --noEmit` clean; unit suite green locally; e2e not run locally by design — CI verifies against an isolated stack
+
+## v0.16.0 — 2026-09-19 12:18
+- **Weight-proportional fuel burn (ISS-005, part A).** Fuel no longer burns at a constant L/km — the instantaneous rate is proportional to total weight, `r(F) = k·(We + ρF)` L/km with We the empty weight and ρ = 0.8 kg/L (Jet-A1), so a heavier plane burns more per km and a tank gets lighter as it empties. The constant `k` is calibrated so a FULL tank burns exactly the catalog's old `burnPerKm`, keeping full-tank departure behavior identical to before; divergence only grows in flight as fuel drops off. Closed forms of `dF/dx = −k(We + ρF)` live in `lib/sim/movement.ts` (single source of truth):
+  - `fuelAtWeighted(startFuel, burnPerKm, emptyWeightKg, maxFuel, distanceKm, progress)` — fuel remaining after flying `progress` of the leg (replaces the old constant-rate `fuelAt`, which is removed)
+  - `requiredFuelFor(burnPerKm, emptyWeightKg, maxFuel, distanceKm)` — liters needed to cover the distance arriving empty, independent of starting load; a leg is flyable iff current fuel ≥ this and fits at all iff it ≤ tank capacity
+  - `burnRateConstant(...)` + exported `FUEL_DENSITY_KG_PER_L` (0.8)
+- **Catalog gains `emptyWeightKg`** (`lib/game/catalog.ts`, ATR 72-600 OEW ≈ 9300 kg), exposed in the snapshot's `catalog[]` so clients can mirror the model; OpenAPI `CatalogEntry` follows
+- **All three burn call sites moved to the weighted model**: landing fuel on arrival (`lib/sim/engine.ts`), live in-flight fuel in the state snapshot (`lib/game/state.ts`), and fly validation (`lib/game/actions.ts` — a leg now needs `requiredFuelFor`, not `burnPerKm × km`)
+- **Refuel "just enough for the loaded package" (ISS-005, part B).** `POST /api/planes/{planeId}/refuel` takes an OPTIONAL JSON body `{ mode?: 'full' | 'forFlight', packageId?: string }`: no body or `mode:'full'` is exactly today's fill-to-max behavior; `mode:'forFlight'` adds just enough fuel to fly that loaded package's destination leg — liters = `requiredFuelFor(haversine(plane → pkg.destIcao)) − current fuel`, 409 if the package isn't loaded on this plane / is expired, or the leg doesn't fit even a full tank; bad bodies (unknown field/mode, forFlight without packageId) are 400. OpenAPI gains `RefuelRequest` + the 400
+- **UI** (`components/RightPane.tsx`): each on-board cargo row gets a "Refuel" button (`refuel-for-{pkg.id}` → `{mode:'forFlight', packageId}`, disabled while flying or busy, mirroring fly-to/abandon); the market fill-up button is renamed **"Refuel to full"** (testid `market-refuel` and behavior unchanged)
+- Tests: unit — new weighted-burn suite in `lib/sim/movement.test.ts` (full-tank calibration ≈ old constant, closed form vs numeric integration of r(F), F_req monotonic + empty-arrival identity, lighter-start burns less, clamping); `refuelPlane` forFlight cases in `lib/game/actions.test.ts` (exact liters/cost, no-op when enough, 409 not-loaded/expired/doesn't-fit via the ~7670 km UNNT↔LPPD pair, 404 unknown package, 400 missing packageId); refuel route body-validation tests; `lib/openapi.test.ts` updated (optional RefuelRequest, errorCodes `['400','404','409']`, CatalogEntry.emptyWeightKg). Adjusted where the model legitimately shifts numbers: landing-fuel assertions in `lib/sim/engine.test.ts` and `e2e/actions.spec.ts` now use the weighted closed form; the e2e "return leg unfuelable" scenario is reworked — under weight-proportional burn a full tank covers the EDDF↔LEZL round trip (the plane lightens as it flies), so the 409 insufficient-fuel assertion moves to the SECOND outbound after landing back with a partial tank
+- e2e (`right-pane.spec.ts`): new test — fly the longest hub leg on a full tank, load a package back to the hub at the far end, click the row "Refuel" and assert via the endpoint's own response snapshot that cash drops by exactly L×price and fuel rises by exactly L (L from the mirrored closed form); also asserts the market button label is "Refuel to full". `e2e/api.spec.ts` path list unchanged
+- Verified: `tsc --noEmit` clean; unit suite green locally; e2e not run locally by design — CI verifies against an isolated stack
+- **Fix (CI run #40): forFlight refuel leaves an exactly-feasible tank, and the new e2e's premise corrected.** The right-pane e2e picked the dataset's absolute farthest airport from EDDF — UNNT at ~4803 km, whose leg needs ~6955 L > the 6300 L tank (max range from empty is ~4436 km) — so the full-tank fly rightly 409'd; `farthestToHub` becomes `farthestFlyableToHub`, picking the farthest airport whose leg still fits a full tank (UWUU, ~3195 km). Server hardening in the same area: forFlight now sets fuel to EXACTLY `requiredFuelFor(...)` instead of `fuel + liters` — that sum is not guaranteed ≥ R in IEEE754 (`f + fl(R − f)` can round a hair below), and flyPlane's strict comparison would then 409 on an otherwise-feasible leg; cost math unchanged (still the added liters × price). New unit regression test: forFlight on an empty-ish tank → immediate `flyPlane` to the package destination succeeds
+- **E2e flake hardening (runs #36/#41): full-core-loop Load/Fly precondition races** — test mechanics only, no app code changes. Two independent races in `e2e/actions.spec.ts`: (1) the Fly click fires its POST asynchronously (`runAction` is fire-and-forget from the test's view), so the immediate `getState` could race ahead of it and still see status 'available' — now an `expect.poll` waits until the server shows 'flying' with the expected destIcao before proceeding; (2) `flyHomeViaApi` made its repositioning decision from a snapshot taken BEFORE waiting for a leftover in-flight leg to land — while flying, locationIcao stays at the departure airport, so a plane that landed away from home was still believed to be home and never repositioned (run #41 retry: starter stranded at EDFH) — state is now re-read after landing; plus an explicit server-side precondition poll (starter grounded at the package origin) before clicking Load
+
+## v0.15.1 — 2026-09-19 11:04
+- **Right pane widened, "On board" wrapping fixed (ISS-004).** The 3-pane shell grid (`app/globals.css` `.app-shell`) moves from `300px / 1fr / 320px` to `280px / 1fr / 360px` — the map column absorbs the delta (MapLibre sizes itself from its container, no JS change). Three wrap offenders in the right pane's "On board" blocks are fixed:
+  - In-flight leg header (`components/RightPane.tsx`, `.contract-route` span): the class already had `white-space: nowrap; overflow: hidden; text-overflow: ellipsis`, but as a flex item with default `min-width: auto` it could not shrink below its full text width, so long routes (e.g. "Frankfurt → Madrid–Barajas") overflowed instead of ellipsizing — `.contract-route` now has `min-width: 0`
+  - Cargo-row buttons ("Fly to {dest}" / "Abandon −€X" in `.contract-main`): labels wrapped mid-text at the old width — `.pane-btn` now has `white-space: nowrap`
+  - Cargo sub-line route span had no white-space rule and wrapped mid-route — it now carries the existing `contract-route` class (nowrap + ellipsis)
+- **Left pane sanity-checked at its new 280px**: fleet-row location span (`.plane-loc`) already had nowrap+ellipsis but lacked `min-width: 0`, so a long in-flight leg would have overflowed instead of truncating — same one-line guard added. Fuel/loadout spans are short fixed strings and need no guard
+- Verified: `tsc --noEmit` clean; unit suite **238/238** green locally (no lib changes); e2e not run locally by design — CI verifies against an isolated stack
+- **Unrelated test-stability fix included on this branch to unblock the pipeline** (`e2e/map-interactions.spec.ts`, no app changes): the mid-flight marker click now targets the plane's RENDERED position — it polls up to ~5 s for the rendered feature via `window.__flightMap.queryRenderedFeatures` on layers `planes-flying`/`planes-grounded` and projects that feature's coordinates, instead of fetching a fresh `/api/state`. With the sim paused the server position is static, but the map renders from its own ~1 s poll — right after the freeze confirmation the last rendered frame can still be up to one poll interval stale (tens of px at scale 1000 on EDDF→LEMD), so a click projected from a fresh fetch misses the small circle layer: the render-lag race that flaked CI run #37. Pause + freeze confirmation, popup assertions and resume are unchanged
+
+## v0.15.0 — 2026-09-19 09:35
+- **Hover visualization from the side panels (ISS-002).** Hovering a fleet row in the left pane, an "On board" block (including its cargo rows) or an open-package row in the right pane now highlights the matching object on the map. The shared `HoverTarget` type (`components/hoverTypes.ts`: `{kind:'plane', id}` | `{kind:'package', originIcao, destIcao}`) is owned by the shell as a single `useState` and prop-drilled down — panes report via an `onHover` callback, `<Map>` consumes it. No React contexts introduced; the established prop-drilling pattern is kept
+- **Three top-most highlight layers** (`components/Map.tsx`, added inside idempotent `ensureLayers()` so they survive every `setStyle`): `planes-highlight` (circle over both plane layers, filter `['==',['get','id'],<planeId>]`, r=10, #38bdf8 fill + white stroke), `routes-highlight` (line over `routes-legs`, filter on the leg's `planeId`, width 6, #ef4444) and `airports-highlight` (circle ring over `airports-circles`, filter matching the hovered package's two ICAOs via `['any', …]`, r=8 stroke-only). All start filtered to match nothing — an empty-string sentinel no feature can have. Consumption follows the existing ref + effect pattern: a `[hovered]` effect calls `map.setFilter(...)` on the three layers (guarded by `getLayer`), and `ensureLayers` re-applies the current filter at its end so a hover outliving a style switch stays highlighted
+- e2e — new `e2e/hover.spec.ts` (3 tests, same SCALE/self-heal/`window.__flightMap` conventions as the other specs): fleet-row hover → `planes-highlight` renders exactly plane-starter, clears on mouseleave; open-package hover → `airports-highlight` shows both endpoint ICAOs (hook-created EDDF→LEMD package), clears on mouseleave; on-board block of a flying plane → `routes-highlight` shows the leg's planeId (sim paused mid-flight so the ~10 s leg can't land under the assertions, then resumed + fly-home cleanup)
+- Verified: `tsc --noEmit` clean; unit suite **238/238** green locally (no lib changes); e2e not run locally by design — CI verifies against an isolated stack
+- **E2e hover spec mechanics fixed after CI run #32** (`e2e/hover.spec.ts`, no app changes): the fleet-row wait now polls up to 30 s with a diagnostic that distinguishes "server has no plane-starter" from "DOM didn't render" (the browser's /api/state poll can lag node-side requests right after page load, leaving the pane in its loading state); the open-package test fits the map to both endpoint airports before asserting — `queryRenderedFeatures` only returns features inside the current viewport and the default Frankfurt-centered view leaves LEMD off-screen
+- **Decisive hover test-1 diagnostics (run #33 transient)**: the fleet-row poll now reports on every failed attempt what the NODE side sees (`/api/state` plane ids + cash via `page.request`) vs what the BROWSER last polled — new dev hook `window.__flightLastSnapshot` set in `lib/useGameState.ts` after each successful fetch (planeIds/cash/timeScale/timestamp, client-only) — plus the fleet section's HTML (`fleet-list` outerHTML or left-pane text), so a future failure can distinguish server divergence from a render bug
+- **CI removes the stale e2e DB volume at run start** (`.gitea/workflows/ci.yml`, "Prepare e2e network"): `docker volume rm flight-ci_flight-db 2>/dev/null || true` — an interrupted run skips the end-of-run cleanup and leaks its used game state into later runs (run #33's instance showed spent cash from a pre-#26 seed), while tests assume seeded state
+- **Hover e2e test 1 used the wrong fleet-row testid** (`e2e/hover.spec.ts`): it waited for `data-testid="plane-starter"`, but rows are rendered as `plane-${p.id}` and the server id already carries the `plane-` prefix — so the real testid is **`plane-plane-starter`** and the "missing row" failures in runs #32–#34 were deterministic selector misses, not transient state (run #34's diagnostics proved it: the fleet-list HTML contained `<li data-testid="plane-plane-starter">`). The selector is now derived from `/api/state` (starter plane id, or the single plane) and used for both the visibility poll and the hover
+
+## v0.14.0 — 2026-09-19 08:45
+- **Time-scale slider reworked to a 10-step ladder up to 1000× (ISS-006).** The old power-of-two ladder `1/2/4/8/16/32/64` is replaced by the discrete values `1, 2, 5, 10, 25, 50, 100, 250, 500, 1000` (each step roughly doubles the speed). The server clamp range widens from `[1, 64]` to `[1, 1000]` (`MAX_TIME_SCALE` in `lib/sim/engine.ts`, enforced by `clampTimeScale`; out-of-range values are still clamped, never rejected), and the OpenAPI spec's `timeScale` bounds + description follow. The slider mapping helpers in `lib/timeScale.ts` now place off-ladder scales at the nearest ladder step **by log distance** (the old `log2` formula assumed a pure power-of-two ladder); round-trip, monotonicity and endpoint-exactness are preserved
+- **E2e suite runs at the fastest time.** Every spec's fast-forward scale moves from 60× to the new top of 1000× (`sim`, `actions`, `right-pane`, `map-interactions`), so flights/expiries resolve in seconds instead of minutes. The map mid-flight test (`map-interactions.spec.ts`) needed a longer leg to keep its click assertions inside the flight window at 1000×: destination moves EDDV (Hannover, ~2 s real) → LEMD (Madrid–Barajas, ~10 s real), with a full-tank refuel before departure so the ~4970 L round trip always fits the 6300 L tank. The slider e2e (`panes.spec.ts`) now asserts End→`1000×` / Home→`1×`, and the clamp tests post `2000` → expect `1000` (500 is a valid ladder value, so it passes through unclamped)
+- Tests: unit — `lib/timeScale.test.ts` covers the 10-position ladder + log-distance nearest-step mapping; new `clampTimeScale` boundary suite in `lib/sim/engine.test.ts` (`[1, 1000]`, full ladder pass-through); `app/api/sim/route.test.ts` and `lib/openapi.test.ts` updated to the new bounds. Verified: unit suite **238/238** green locally (was 234 before this change)
+- e2e `map-interactions.spec.ts`: the plane-popup test now pauses the sim around the marker click — at 1000× the rendered marker lags a fresh `/api/state` fetch by up to one map poll (~1 s), tens of px of drift on the EDDF→LEMD leg, so `page.mouse.click` missed the small circle layer (CI run #29); the sim is paused until the popup assertions pass, then resumed
+
+## v0.13.1 — 2026-09-19 08:09
+- CI e2e step now uses Playwright's list reporter so every test prints as it runs in the job log (progress visibility); failures still get full error context
+
+## v0.12.3 — 2026-09-19 07:36
+- **e2e: removed the unreliable curved-route assertion from `map-interactions.spec.ts`.** The "route line has >2 coordinates in the routes source" check (added with v0.12.2) failed in CI and against the live instance even though the arc renders correctly — MapLibre's `querySourceFeatures` returns tile-simplified geometry at low zoom, so coordinate counts from it are not a reliable signal for what was pushed into the source. The curved arc remains fully covered by unit tests (`lib/mapData.test.ts`: 25 sampled coordinates, exact endpoints, curvature on long routes); the spec keeps all other steps (grounded plane draws no line, marker moves across polls, plane popup with status + route)
+
+## v0.13.0 — 2026-09-18 15:31
+- **CI + pull-request workflow** (process/infra): new `.gitea/workflows/ci.yml` runs build → unit tests → e2e on every PR to master and on push to master, in one job with a `docker:dind` service. E2E isolation: the suite targets a fresh compose stack inside dind (`docker-compose.ci.yml` — mirrors docker-compose.yml minus Traefik/dev_net; app served directly on port 3000 of the dind container; game state in a named volume so it is fresh per run and survives `state.spec.ts`'s mid-run restart) — **CI never deploys to or touches production**. The dind endpoint is resolved at job start (tries `tcp://localhost:2375`, then `tcp://docker:2375` — Gitea services are sibling containers reachable by service id on the job network) and exported as `DOCKER_HOST` + `E2E_BASE_URL`; build context is tarred by the compose client in the job, so nothing needs to be visible from inside dind
+- **Playwright config made CI-aware, backward-compatible** (`playwright.config.ts`): new optional env vars — `PW_REMOTE_BROWSER=0` (local chromium instead of the shared remote server at 192.168.1.4:3000), `E2E_DEPLOY_CMD` (runs as webServer + readiness wait; unset = current local behavior with no auto-deploy); `E2E_BASE_URL` already existed. `e2e/state.spec.ts` reads `E2E_COMPOSE_ARGS` for its mid-run `docker compose restart flight` (default empty → unchanged locally)
+- **@playwright/test pinned as devDependency** (`1.63.0`, matching the shared remote browser server image and the global install) so CI is self-contained; still excluded from the runtime image via .dockerignore (comment updated), prod-deps stage unaffected
+- `AGENTS.md`: "Change process" + "E2E tests" rewritten for the PR workflow — feature branch off master → commits with CHANGELOG entry + version bump → PR to master → CI (build→unit→e2e) green → merge → tag on master → manual production deploy via `docker compose up -d --build`; no direct pushes to master, CI never deploys
+- **CI build reliability + caching** (after first dind runs): the e2e image is now built with `--progress=plain` before `up -d` so BuildKit step output lands in job logs instead of being hidden by auto progress; Dockerfile bun installs use a BuildKit cache mount (`/root/.bun/install/cache`) that persists on the runner's shared daemon, and CI restores/saves node_modules + the bun cache via actions/cache around dependency install (both steps `continue-on-error` — safe while the runner's cache server is being fixed)
+- **CI flaky-network handling settled on retry wrappers** (transient EAI_AGAIN failures seen in runs #10/#11): bun install, dependency install and the e2e image build each retry up to 3× with 5s between attempts before failing — run #12 with this setup got furthest (build + unit + browsers green). A short-lived "DNS diagnostics" step was tried but removed: its daemon-side probe pulled an image not present on the runner's docker daemon and stalled runs #13/#14 at Setup Node
+- **E2e image build needs no outbound network from dind build containers** (DNSResolveFailed in `RUN bun install` across runs #10/#12/#15): node_modules is now installed in the CI job / dev host and copied into the build context (.dockerignore no longer excludes it; Dockerfile COPYs it instead of running any install inside the image); base images switched alpine → node:22-slim (glibc) for native-module ABI compatibility with the job-installed tree (@next/swc-*, sharp are prebuilt per platform — CI job and prod host are x86_64 glibc linux); a "Pull e2e base image" step fails fast if the daemon can't fetch node:22-slim
+- **CI e2e deploy command stays alive** (`E2E_DEPLOY_CMD` now ends with `docker compose … logs -f`): Playwright's webServer requires a long-running process — `up -d` returns immediately and triggered "Process from config.webServer exited early" (run #16); `logs -f` also streams app logs into CI output for debugging
+- **CI e2e step bypasses proxies for the in-network app host** (`NO_PROXY`/`no_proxy=app,localhost,127.0.0.1,.kkhost.pl`) and prints proxy/DNS/curl diagnostics before the suite — run #18 showed Chromium getting `ERR_SSL_PROTOCOL_ERROR` on http://app:3000 while node-side HTTP worked (9 API-only tests passed), pointing at a TLS-terminating proxy env var that Chromium honors but Node's HTTP client ignores
+- **CI e2e targets the app at a static in-network IP** (`172.39.0.10`, pinned subnet `172.39.0.0/24` created by "Prepare e2e network"; stale networks with other subnets are recreated) instead of the DNS alias — Chromium got `ERR_SSL_PROTOCOL_ERROR` via the hostname while node-side HTTP worked, so DNS is removed from the equation; post-deploy connectivity diagnostics added as a CI-gated globalSetup (`e2e/ci-diagnostics.ts`, no-op locally) comparing node resolution/HTTP against Chromium navigation on both hostname and static IP
+- **CI caches Playwright browser binaries across runs** (`$HOME/.cache/ms-playwright` via actions/cache): the flaky runner uplink makes the ~187 MiB Chrome-for-Testing download unreliable (runs #20/#21 died mid-download at "Install browsers"); also removed the no-op "Save deps cache" step — on this runner caches marked by a restore step are uploaded automatically at job end, so an explicit save never did anything
+- **CI browser install runs in a bounded 6-attempt loop** — cdn.playwright.dev is flaky from the runner and Playwright's internal retry window (~40–90s) was often insufficient (runs #21–#23), while longer windows get through (runs #12/#18); already-installed browsers are skipped so progress accumulates across attempts
+- Verified: unit suite 234 green locally; e2e not run locally by design (would deploy to production) — first real pass happens in the PR's CI run
+- **CI e2e now runs in self-hosted map-assets mode** — the workflow downloads the OpenFreeMap asset pack (`npm run assets:download` → styles/fonts/sprites into git-ignored `./public`, bounded 6-attempt retry like the other flaky-network steps) and caches it via actions/cache keyed on the download script (job-end upload seeds future runs; a partial pack without manifest is harmless — app falls back to remote); `docker-compose.ci.yml` mounts `./public:/app/public` mirroring docker-compose.yml, so map tests that abort all *.openfreemap.org traffic get self-hosted styles/fonts/sprites like local dev (fixes the deterministic map.spec.ts wheel-zoom + style-switcher failures)
+
 ## v0.12.2 — 2026-09-18 14:06
 - **Bugfix (ISS-003): route leg lines were drawn as straight two-point chords instead of following the curved great-circle path planes actually fly.** Root cause in `lib/mapData.ts`: `routesGeoJson` built each flying plane's leg LineString from only its origin and destination airport coordinates, so on long routes the drawn line cut across the chord (up to ~40 km off the true arc for a ~1400 km leg) while the plane marker moved along the curved path. Fix: new pure `greatCircleArc(from, to)` samples the same slerp used by the sim (`positionAt` in `lib/sim/movement.ts`) at t = i/24 for i = 0..24 — **25 coordinates** (exact endpoints + 23 intermediate points, `ROUTE_ARC_SEGMENTS = 24`) — so the drawn line matches the curved flight path; `routesGeoJson` now uses it instead of the two-point chord
 - Tests: unit — `lib/mapData.test.ts` updated (route feature is a sampled arc with exact endpoints) + new `greatCircleArc` suite (endpoint exactness, long-route midpoint deviates >5 km from the straight chord proving curvature, short route stays <5 km off). e2e — `map-interactions.spec.ts` now asserts the flying plane's route line has **>2 coordinates** in the routes source (curved arc, not a two-point chord)
@@ -1,21 +1,14 @@
-# Multi-stage build: bun for installs (fast), node for build + runtime.
-# No BuildKit type=cache mounts: they don't persist across builds on this daemon
-# (Docker 29 + containerd image store), and bun install is fast enough (~3s cold)
-# that cross-build tarball caching isn't worth the complexity.
-FROM oven/bun:1.4.2-alpine AS deps
+# Two-stage build needing ZERO outbound network at image-build time:
+# (a) deps are installed by the CI job / dev host (`bun install`) and copied in via the
+#     build context — the runner's dind daemon has broken outbound DNS for build containers,
+#     so any RUN that fetches packages fails;
+# (b) base images must be glibc (node:22-slim), NOT alpine/musl: native modules (@next/swc-*,
+#     sharp) are prebuilt for the platform that ran `bun install` — CI job and prod host are
+#     x86_64 glibc linux. Building on another platform requires reinstalling node_modules there first.
+FROM node:22-slim AS build
 WORKDIR /app
 COPY package.json bun.lock ./
-RUN bun install --frozen-lockfile
-
-# Production dependencies only — devDeps (typescript, vitest, @types) are build-time only.
-FROM oven/bun:1.4.2-alpine AS prod-deps
-WORKDIR /app
-COPY package.json bun.lock ./
-RUN bun install --production --frozen-lockfile
-
-FROM node:22-alpine AS build
-WORKDIR /app
-COPY --from=deps /app/node_modules ./node_modules
+COPY node_modules ./node_modules
 COPY . .
 ENV NEXT_TELEMETRY_DISABLED=1
 RUN npm run build
@@ -23,10 +16,12 @@ RUN npm run build
 # No `output: 'standalone'`: the runtime stage keeps node_modules because
 # /api/mlworker/[file] reads maplibre-gl dist files from disk at runtime, and
 # /api/airports reads data/*.csv — both resolved relative to process.cwd().
-FROM node:22-alpine AS runtime
+FROM node:22-slim AS runtime
 WORKDIR /app
 ENV NODE_ENV=production NEXT_TELEMETRY_DISABLED=1
-COPY --from=prod-deps /app/node_modules ./node_modules
+# Full tree (dev+prod deps): a prod-only slimmed copy would need an extra install step,
+# revisit if image size matters.
+COPY --from=build /app/node_modules ./node_modules
 COPY --from=build /app/.next ./.next
 COPY --from=build /app/package.json ./package.json
 COPY --from=build /app/data ./data
@@ -0,0 +1,69 @@
+# ORCHESTRATOR.md — Operating Manual for Successor Agents
+
+You are taking over the autonomous development loop on **Flight-Ops** (browser game: run an airplane transport company in Europe; server-authoritative sim, MapLibre GL JS map). This document captures operational knowledge that is NOT written down in AGENTS.md. Read AGENTS.md first — it defines the mandatory change process and this file complements it.
+
+Credentials are deliberately NOT stored in this file — see §1 for where they live. Never paste token values into any tracked file.
+
+## 1. Project identity
+- Repo: Gitea at https://git.kkhost.pl → org **OpenCode**, repo **Flight-Ops** (full name `OpenCode/Flight-Ops`). Every Gitea API/MCP call uses owner=`OpenCode`, repo=`Flight-Ops`.
+- Local workdir + prod deploy dir: `/home/krzyw/projects/sandbox/flight` (git checkout; `docker compose up -d --build` deploys from here).
+- Prod URL: https://flight.dev.kkhost.pl (Traefik → docker-compose stack on this host). `GET /api/version` reports the running version.
+- Gitea API access for git.kkhost.pl: prefer the gitea MCP tools — they are already configured with a token. For raw REST/curl, read the current token from the local .env file at repo root (variable `GITEA_TOKEN`; .env is gitignored and must never be committed): `source .env && curl -s -H "Authorization: token $GITEA_TOKEN" https://git.kkhost.pl/api/v1/user`. (Incident note, Sept 2026: an early draft of this doc committed a live token to the repo; that commit was purged from all refs and the token has since been rotated — never repeat this.)
+- Current user: kamilkrzywda (id 1).
+
+## 2. The loop (per issue)
+1. Small incremental change on a feature branch off `master`; connected issues may share one branch/PR with a single version bump.
+2. Bump `package.json` version + add CHANGELOG.md entry at top: `## v<version> — YYYY-MM-DD HH:MM` then bullet points of what changed (docs-only changes get patch bumps too — precedent v0.19.1/v0.19.2).
+3. Local verification ONLY (there are NO local e2e runs): `npx tsc --noEmit`, `npx vitest run` (the whole unit suite must pass — the test count grows over time, so compare against the previous green run, never a hardcoded number), `npx playwright test --list` (all specs compile and list).
+4. Push → CI (~7 min) → **auto-merge on green** (PRs have auto-merge configured; no manual merge needed — verify via `GET /pulls/{n}` that state=closed and merged_at is set). Note: if a PR was created via API rather than create-on-push, double-check auto-merge actually fires.
+5. Tag the version on master: `git tag v<version> origin/master && git push origin v<version>` (after `git fetch origin master`).
+6. Deploy prod in a PTY (long task): `cd /home/krzyw/projects/sandbox/flight && git checkout master && git reset --hard origin/master && docker compose up -d --build`; then verify `curl https://flight.dev.kkhost.pl/api/version` returns the new version and the root page is HTTP 200.
+7. Close each issue with a comment: what changed, version, PR number, merge commit SHA, deployed URL.
+8. Repeat for the next open issue: `GET /issues?state=open&type=issues` — note Gitea lists pull requests in this endpoint too; filter out entries with a `pull_request` key.
+
+## 3. Gitea API + MCP quirks (learned the hard way)
+- The gitea MCP tools work for issues/PRs/files/tags, and Actions endpoints work IF you pass owner=`OpenCode`, repo=`Flight-Ops`. A wrong owner/repo makes EVERY call return `{"message":"not found","url":"https://git.kkhost.pl/api/swagger"}` — that swagger URL inside a 404 is the signature of "wrong path", not "Gitea is down".
+- MCP merge endpoint 405s → don't bother; auto-merge handles merging. Manual fallback if ever needed: `POST /repos/OpenCode/Flight-Ops/pulls/{n}/merge` with body `{"do":"merge","merge_style":"merge"}`.
+- Gitea REST shapes (NOT GitHub's): list runs → `{workflow_runs:[...]}`; run jobs → `/actions/runs/{id}/jobs` returns `{"jobs":[...]}`; single job log via MCP `get_job_log_preview` (param tail_lines) or `download_job_log` to a file, then grep.
+- Failure anatomy in CI logs: the Playwright summary at the end lists "N failed" + test titles; each failure block has a code frame with line numbers plus an "Error Context:" path. The e2e step is the only one that can fail flakily; unit failures are real regressions.
+- CI watcher pattern that works: `run_background_process` (notify=true) running a loop that polls `GET /actions/runs/{id}` every 60 s and exits when status=completed, printing status+conclusion each tick. Don't poll in the foreground; don't sleep-loop on pty_read.
+
+## 4. CI facts (.gitea/workflows/ci.yml + docker-compose.ci.yml)
+- Single job "build + unit + e2e" on runner gitea-runner (docker-in-docker). Fresh DB per run (volume removed); compose project `flight-ci`; app container on a static IP → `E2E_BASE_URL=http://172.39.0.10:3000`; `PW_REMOTE_BROWSER=0` (CI runs local chromium — the shared remote browser server at 192.168.1.4 cannot reach a stack inside dind); `E2E_COMPOSE_ARGS="-f docker-compose.ci.yml -p flight-ci"` is read by e2e/state.spec.ts for its mid-run `docker compose restart flight`.
+- Flaky uplink → retry loops in ci.yml; an occasional "flaky" test (failed once, passed on retry) does NOT fail the run.
+- Branch protection requires status check `CI / build + unit + e2e (pull request)` — PRs cannot merge until green; CI never deploys to production.
+
+## 5. E2E conventions (e2e/*.spec.ts) — read before touching tests
+- Sim scale in tests: SCALE=1000; hub `HUB='EDDF'` (Frankfurt); typical destination LEMD.
+- `flyHomeViaApi(page)` self-heal at test start — interrupted runs can leave planes mid-flight; landing waits up to 240 s.
+- Pause-sim pattern for deterministic marker clicks: pause, act, assert, resume.
+- Dev hook: `window.__flightMap` exposes the live MapLibre map instance in dev builds (also `__flightLastSnapshot`).
+- `queryRenderedFeatures` is viewport-scoped → fitBounds/fitToAirports before asserting on far features; give the renderer ~300 ms after a camera jump.
+- **expect.poll callbacks must be total** — a throw inside fails the test instantly instead of retrying. Guard/filter everything you dereference.
+
+## 6. ⚠️ The big one: Playwright evaluate serialization drops prototype getters
+MapLibre's `queryRenderedFeatures` returns live `GeoJSONFeature` class instances whose `geometry` is a **lazy PROTOTYPE getter** (own properties are only type/properties/id/source/state plus private fields). Playwright serializes evaluate results by copying **own enumerable properties only**, so every feature arriving in test context has NO geometry — silently.
+- Verified empirically: `page.evaluate(() => { class A{constructor(){this.own=1} get geo(){return 42}} return [new A()] })` → `[{"own":1}]`.
+- Symptom matrix (how it masqueraded as "the line isn't drawn" while the trace rendered fine on screen, across three consecutive failed CI runs in Sept 2026): strict length guard → timeout; direct `.geometry.coordinates` access → `TypeError: Cannot read properties of undefined (reading 'coordinates')`; defensive filter → clean 15 s timeout.
+- **Rule: never return maplibre feature instances across page.evaluate — always map to plain objects in-page** (`{type, id, properties, geometry: f.geometry}` forces the getter to evaluate). Canonical pattern: `renderedFeatures()` in e2e/hover.spec.ts. Other specs that touch `.geometry` do so inside evaluate (safe) or only read array length (safe).
+
+## 7. MapLibre rendering facts (for map assertions)
+- GeoJSON geometry is stored per-tile in INTEGER grids; long lines are clipped → `queryRenderedFeatures` returns ONE FEATURE PER TILE the line crosses (the EDDF→LEMD leg ≈ 4–5 segments at z=4/5).
+- Coordinates are quantized to the grid: error up to ~half a grid step (~0.001° observed at z≥4, worst ~0.02° at z=0 with extent 8192). Endpoint assertions must use an EPS sized for this (the hover tests define one in `expectHoverRoute` in e2e/hover.spec.ts — ~5 km: above worst-case quantization at any zoom, below the distance between any two EU airports) and check endpoints ACROSS ALL SEGMENTS: some segment must START within EPS of origin AND some must END within EPS of destination. Never strict equality on a single feature.
+- The true line endpoints survive clipping verbatim in whichever tile contains them.
+
+## 8. App architecture quick map
+- `components/Map.tsx` — the MapLibre layer: sources/layers created in ensureLayers (dedicated `hover-routes` GeoJSON source + top-most dashed `hover-route` LineLayer, plus an `airports-target-highlight` ring layer added last so it sits above the line at its endpoint — current colors/widths live in Map.tsx, don't trust this doc for exact paint values); applyHoverRef re-pushes data on every hover; `window.__flightMap` dev hook.
+- `lib/mapData.ts` — pure GeoJSON builders (`hoverRouteGeoJson`, `routesGeoJson`, `greatCircleArc` slerp) + unit tests in lib/mapData.test.ts.
+- Hover protocol: panes report a HoverTarget via mouseenter/leave (`components/hoverTypes.ts`): `{kind:'plane';id} | {kind:'package';originIcao;destIcao;planeId?} | {kind:'route';fromIcao;toIcao}`; the `''` sentinel means no hover.
+- Server: sim ticks server-side, client polls /api/state; OpenAPI spec generated from lib/openapi.ts and served at /api/openapi — update it whenever an endpoint changes.
+
+## 9. Finding current state (this file keeps no snapshots)
+This manual is meant to stay valid long-term, so it deliberately contains NO version or issue snapshots — they rot. To orient yourself when you take over: `git log --oneline -10` + CHANGELOG.md for what has shipped; `GET /issues?state=open&type=issues` (filter out entries with a `pull_request` key) for what is left to do; PLAN.md's "Later" section for the roadmap backlog.
+
+## 10. Standing user instruction & etiquette
+- The user's standing order for this project: work through the issue list autonomously — implement → PR → CI green → merge → tag → deploy prod → close with comment → next — until told to stop.
+- Small incremental changes; each part fully tested (unit + e2e) before moving on.
+- Long terminal tasks → pty_* tools (deploys, builds). Background watchers → run_background_process with notify=true.
+- Never push directly to master; never deploy from a feature branch; CI never touches prod — production deploys are manual only (`docker compose up -d --build` after tagging).
+- **Never commit credentials.** Tokens/secrets live in the MCP server config or with the user, never in tracked files (see incident note in §1).
@@ -19,7 +19,7 @@ Accept job → dispatch a plane → watch it fly the route on the map → earn m

 ## Simulation engine
 - Server-authoritative state: sim ticks on the server, client polls and renders
- Time scale 1x–60x + pause; sim clock persisted across sessions
+- Time scale 1x–1000x (discrete ladder 1/2/5/10/25/50/100/250/500/1000) + pause; sim clock persisted across sessions
 - SQLite via Drizzle ORM — schema designed to switch to Postgres later
 - Demand/revenue/cost formulas per contract leg; fuel burn by distance/plane type

@@ -5,7 +5,11 @@ import { eq } from 'drizzle-orm';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import * as schema from '@/lib/db/schema';
 import { getGameDb } from '@/lib/db/client';
+import { loadAirportsGeoJson } from '@/lib/airports';
+import { haversineKm } from '@/lib/geo';
+import { requiredFuelFor } from '@/lib/sim/movement';
 import { FUEL_PRICE_PER_L, PLANE_TYPES } from '@/lib/game/catalog';
+import { HUB_ICAO } from '@/lib/game/seed';
 import { POST } from './route';

 let dir: string;
@@ -22,7 +26,15 @@ afterAll(async () => {
  await fs.rm(dir, { recursive: true, force: true });
 });

-const post = (planeId: string) => POST(new Request(`http://localhost/api/planes/${planeId}/refuel`), { params: Promise.resolve({ planeId }) });
+const post = (planeId: string, body?: unknown) =>
+  POST(
+    new Request(`http://localhost/api/planes/${planeId}/refuel`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: body === undefined ? undefined : JSON.stringify(body),
+    }),
+    { params: Promise.resolve({ planeId }) },
+  );

 describe('POST /api/planes/:planeId/refuel', () => {
  it('rejects an unknown id with 404', async () => {
@@ -74,4 +86,76 @@ describe('POST /api/planes/:planeId/refuel', () => {
    expect(res.status).toBe(409);
    expect(((await res.json()) as { error: string }).error).toMatch(/insufficient funds/i);
  });
+
+  it('accepts an explicit {mode:"full"} body exactly like no body', async () => {
+    const { db } = await getGameDb();
+    await db.update(schema.account).set({ cash: 50_000 }); // previous test left the account poor
+    await db.update(schema.planes).set({ fuel: 1_000 }).where(eq(schema.planes.id, 'plane-starter'));
+
+    const res = await post('plane-starter', { mode: 'full' });
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { planes: Array<{ id: string; fuel: number }> };
+    expect(body.planes.find((p) => p.id === 'plane-starter')!.fuel).toBe(PLANE_TYPES.atr72.maxFuel);
+  });
+
+  it('rejects an unknown mode with 400', async () => {
+    const res = await post('plane-starter', { mode: 'half' });
+    expect(res.status).toBe(400);
+    expect(((await res.json()) as { error: string }).error).toMatch(/mode/);
+  });
+
+  it('rejects forFlight without a packageId with 400', async () => {
+    const res = await post('plane-starter', { mode: 'forFlight' });
+    expect(res.status).toBe(400);
+    expect(((await res.json()) as { error: string }).error).toMatch(/packageId/);
+  });
+
+  it('rejects an unknown body field with 400', async () => {
+    const res = await post('plane-starter', { liters: 100 });
+    expect(res.status).toBe(400);
+    expect(((await res.json()) as { error: string }).error).toMatch(/unknown field/);
+  });
+
+  it('rejects invalid JSON with 400', async () => {
+    const res = await POST(
+      new Request(`http://localhost/api/planes/plane-starter/refuel`, { method: 'POST', body: '{nope' }),
+      { params: Promise.resolve({ planeId: 'plane-starter' }) },
+    );
+    expect(res.status).toBe(400);
+  });
+
+  it('forFlight tops up exactly the liters needed for the loaded package leg', async () => {
+    const { db } = await getGameDb();
+    await db.update(schema.account).set({ cash: 50_000 });
+    // A loaded EDDF → LEMD package on the starter (direct row — loadPackage is covered in actions tests).
+    await db.insert(schema.packages).values({
+      id: 'p-ff-api', originIcao: HUB_ICAO, destIcao: 'LEMD', reward: 1_000, cargoType: 'Mail', cargoCount: 4,
+      deadlineSimTime: Date.now() + 24 * 3_600_000, status: 'loaded', planeId: 'plane-starter', createdSimTime: Date.now(),
+    });
+
+    const fc = await loadAirportsGeoJson();
+    const from = fc.features.find((f) => f.properties.icao === HUB_ICAO)!.properties;
+    const to = fc.features.find((f) => f.properties.icao === 'LEMD')!.properties;
+    const km = haversineKm(from.lat, from.lon, to.lat, to.lon);
+    const type = PLANE_TYPES.atr72;
+    const required = requiredFuelFor(type.burnPerKm, type.emptyWeightKg, type.maxFuel, km);
+
+    const startFuel = Math.round(required / 2); // partial tank so L > 0
+    await db.update(schema.planes).set({ fuel: startFuel }).where(eq(schema.planes.id, 'plane-starter'));
+    const cashBefore = (await db.select().from(schema.account))[0].cash;
+
+    const res = await post('plane-starter', { mode: 'forFlight', packageId: 'p-ff-api' });
+    expect(res.status).toBe(200);
+
+    const body = (await res.json()) as {
+      account: { cash: number };
+      planes: Array<{ id: string; fuel: number }>;
+    };
+    const cost = Math.round((required - startFuel) * FUEL_PRICE_PER_L * 100) / 100;
+    expect(body.account.cash).toBeCloseTo(cashBefore - cost, 6);
+    expect(body.planes.find((p) => p.id === 'plane-starter')!.fuel).toBeCloseTo(required, 6);
+
+    // Clean up the test package.
+    await db.delete(schema.packages).where(eq(schema.packages.id, 'p-ff-api'));
+  });
 });
@@ -1,11 +1,47 @@
 import { performAction, refuelPlane } from '@/lib/game/actions';

-// POST /api/planes/:planeId/refuel (v0.8.0) — no body. Fills a grounded plane to
-// maxFuel at the fuel price per missing liter; deducts the cost from cash. 404
-// unknown id; 409 if the plane is flying or cash is insufficient. On success
-// returns the full state snapshot (fuel back to max, cash reduced by the cost).
+// POST /api/planes/:planeId/refuel (v0.8.0; optional body v0.16.0) — fills a grounded
+// plane at the fuel price per added liter and deducts the cost from cash. The body is
+// OPTIONAL: no body, {} or {mode:'full'} fill to maxFuel (the original behavior);
+// {mode:'forFlight', packageId} adds just enough for that loaded package's destination
+// leg. 400 bad body (unknown field, unknown mode, forFlight without packageId); 404
+// unknown plane/package id; 409 if the plane is flying, the package isn't loaded on it
+// (or is expired), the leg doesn't fit a full tank, or cash is insufficient. On success
+// returns the full state snapshot (fuel raised by exactly the added liters).

-export async function POST(_req: Request, ctx: { params: Promise<{ planeId: string }> }) {
+export async function POST(req: Request, ctx: { params: Promise<{ planeId: string }> }) {
  const { planeId } = await ctx.params;
-  return performAction((inst) => refuelPlane(inst, planeId));
+
+  let body: unknown;
+  try {
+    const text = await req.text();
+    body = text ? JSON.parse(text) : {};
+  } catch {
+    return Response.json({ error: 'invalid JSON body' }, { status: 400 });
+  }
+  if (typeof body !== 'object' || body === null || Array.isArray(body)) {
+    return Response.json({ error: 'body must be a JSON object' }, { status: 400 });
+  }
+  const input = body as Record<string, unknown>;
+  for (const key of Object.keys(input)) {
+    if (key !== 'mode' && key !== 'packageId') {
+      return Response.json({ error: `unknown field "${key}"` }, { status: 400 });
+    }
+  }
+  const mode = input.mode ?? 'full';
+  if (mode !== 'full' && mode !== 'forFlight') {
+    return Response.json({ error: 'mode must be "full" or "forFlight"' }, { status: 400 });
+  }
+  let packageId: string | undefined;
+  if (input.packageId !== undefined) {
+    if (typeof input.packageId !== 'string' || input.packageId.length === 0) {
+      return Response.json({ error: 'packageId must be a non-empty string' }, { status: 400 });
+    }
+    packageId = input.packageId;
+  }
+  if (mode === 'forFlight' && !packageId) {
+    return Response.json({ error: 'packageId is required when mode is "forFlight"' }, { status: 400 });
+  }
+
+  return performAction((inst) => refuelPlane(inst, planeId, { mode, packageId }));
 }
@@ -31,19 +31,24 @@ describe('POST /api/sim', () => {
    expect(body.paused).toBe(false);
  });

-  it('sets and clamps timeScale into [1, 64]', async () => {
-    const hi = await post({ timeScale: 500 });
+  it('sets and clamps timeScale into [1, 1000]', async () => {
+    const hi = await post({ timeScale: 2000 });
    expect(hi.status).toBe(200);
-    expect(((await hi.json()) as { timeScale: number }).timeScale).toBe(64);
+    expect(((await hi.json()) as { timeScale: number }).timeScale).toBe(1000);

    const lo = await post({ timeScale: 0.1 });
    expect(lo.status).toBe(200);
    expect(((await lo.json()) as { timeScale: number }).timeScale).toBe(1);

-    // The top of the power-of-two ladder passes through unclamped (v0.9.2).
-    const max = await post({ timeScale: 64 });
+    // The top of the ladder passes through unclamped (v0.14.0).
+    const max = await post({ timeScale: 1000 });
    expect(max.status).toBe(200);
-    expect(((await max.json()) as { timeScale: number }).timeScale).toBe(64);
+    expect(((await max.json()) as { timeScale: number }).timeScale).toBe(1000);
+
+    // In-range values pass through unclamped — ladder and off-ladder alike.
+    const ladder = await post({ timeScale: 500 });
+    expect(ladder.status).toBe(200);
+    expect(((await ladder.json()) as { timeScale: number }).timeScale).toBe(500);

    const mid = await post({ timeScale: 37 });
    expect(mid.status).toBe(200);
@@ -1,6 +1,6 @@
 import { applyTimeControls } from '@/lib/sim/engine';

-// POST /api/sim — set sim time controls (v0.7.0). Body: { timeScale?: 1–64, paused?: boolean }.
+// POST /api/sim — set sim time controls (v0.7.0). Body: { timeScale?: 1–1000, paused?: boolean }.
 // Ticks the clock first (so the response reflects current game time), then applies
 // and persists the new controls. Returns the updated simState.

@@ -23,7 +23,7 @@ export async function POST(req: Request) {
    }
  }
  if (input.timeScale !== undefined && (typeof input.timeScale !== 'number' || !Number.isFinite(input.timeScale))) {
-    return Response.json({ error: 'timeScale must be a finite number (1–64)' }, { status: 400 });
+    return Response.json({ error: 'timeScale must be a finite number (1–1000)' }, { status: 400 });
  }
  if (input.paused !== undefined && typeof input.paused !== 'boolean') {
    return Response.json({ error: 'paused must be a boolean' }, { status: 400 });
@@ -17,7 +17,7 @@ import { tickNow } from '@/lib/sim/engine';
 //     (game time) so the next fast tick expires it; 404 if unknown/not open.
 //   - without: creates a fresh open package with the same short deadline.

-const HOOK_DEADLINE_MS = 10_000; // game ms past the current clock (~0.2 s real at 60×)
+const HOOK_DEADLINE_MS = 10_000; // game ms past the current clock (≈ 0.01 s real at the fastest 1000×)

 export async function POST(req: Request) {
  if (process.env.FLIGHT_TEST_HOOKS !== '1') {
@@ -68,10 +68,46 @@ body {
  color: #cbd5e1;
 }

-/* v0.9.0 — single-screen 3-pane shell: left Assets / center map / right Jobs & Market */
+/* ISS-010 (v0.18.0) — Relocate row inside the airport popup (plain HTML, not React). */
+.popup-relocate {
+  margin-top: 8px;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-wrap: wrap;
+}
+
+.popup-relocate select {
+  font-size: 12px;
+  padding: 3px 6px;
+  border-radius: 4px;
+  border: 1px solid rgba(148, 163, 184, 0.4);
+}
+
+.popup-relocate button {
+  font-size: 12px;
+  padding: 3px 10px;
+  border-radius: 4px;
+  border: 1px solid rgba(148, 163, 184, 0.4);
+  cursor: pointer;
+}
+
+.popup-relocate button:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+
+[data-testid='airport-popup-relocate-status'] {
+  font-size: 11px;
+  color: #334155;
+}
+
+/* v0.9.0 — single-screen 3-pane shell: left Assets / center map / right Jobs & Market.
+   ISS-021 (v0.20.0): left widened to 360px (it now carries the On board section), right
+   narrowed to 280px — total fixed width stays 640px, so the map column is unchanged. */
 .app-shell {
  display: grid;
-  grid-template-columns: 300px minmax(0, 1fr) 320px;
+  grid-template-columns: 360px minmax(0, 1fr) 280px;
  height: 100%;
 }

@@ -201,6 +237,7 @@ body {
 }

 .plane-loc {
+  min-width: 0;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
@@ -265,6 +302,7 @@ body {
 }

 .contract-route {
+  min-width: 0;
  font-weight: 600;
  color: #f1f5f9;
  overflow: hidden;
@@ -284,6 +322,7 @@ body {

 .pane-btn {
  flex-shrink: 0;
+  white-space: nowrap;
  font-size: 12px;
  padding: 3px 10px;
  border-radius: 4px;
@@ -324,6 +363,12 @@ body {
  padding: 4px 0;
 }

+/* ISS-010 (v0.18.0) — the Relocate row carries TWO selects, so let it wrap instead of
+   squeezing both below their readable width in the 360 px left pane (moved there in ISS-023 v0.21.0). */
+.market-row-relocate {
+  flex-wrap: wrap;
+}
+
 .market-preview {
  font-size: 12px;
  color: #f8fafc;
@@ -331,7 +376,7 @@ body {
  font-variant-numeric: tabular-nums;
 }

-/* v0.12.0 — on-board blocks (per plane) in the right pane */
+/* v0.12.0 — on-board blocks (per plane); moved to the left pane in ISS-021 (v0.20.0) */
 .onboard-block {
  background: rgba(30, 41, 59, 0.6);
  border-radius: 6px;
@@ -339,8 +384,101 @@ body {
  margin-bottom: 8px;
 }

+/* ISS-028 (v0.20.0 part 2) — on-board cargo rows are two lines: a full-width fly-to button,
+   then refuel + abandon side by side below it; long destination names truncate with an ellipsis. */
 .onboard-block .contract-row {
  background: transparent;
  padding: 6px 0 0;
  border-top: 1px solid rgba(148, 163, 184, 0.2);
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+}
+
+.onboard-block .contract-row .contract-sub {
+  margin-top: 0; /* row spacing comes from the container's gap */
+}
+
+.onboard-fly-btn {
+  width: 100%;
+}
+
+.onboard-fly-label {
+  display: block;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.onboard-actions {
+  display: flex;
+  gap: 6px;
+}
+
+/* v0.17.0 — ISS-008: bottom-right toast stack (action errors + game events) */
+.toasts {
+  position: fixed;
+  bottom: 12px;
+  right: 12px;
+  z-index: 50; /* above map popups/controls and the app header */
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  max-width: 340px;
+}
+
+.toast {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+  padding: 8px 12px;
+  border-radius: 6px;
+  font-size: 13px;
+  background: rgba(15, 23, 42, 0.95);
+  color: #e2e8f0;
+  border: 1px solid rgba(148, 163, 184, 0.4);
+}
+
+.toast-error {
+  border-color: rgba(239, 68, 68, 0.7);
+  color: #fecaca;
+}
+
+.toast-info {
+  border-color: rgba(148, 163, 184, 0.5);
+}
+
+.toast-close {
+  flex-shrink: 0;
+  font-size: 14px;
+  line-height: 1;
+  padding: 2px 6px;
+  border-radius: 4px;
+  border: none;
+  background: transparent;
+  color: #94a3b8;
+  cursor: pointer;
+}
+
+.toast-close:hover {
+  color: #e2e8f0;
+}
+
+/* ISS-008 — the Time section's notifications opt-in button (same look as .time-controls buttons) */
+.notif-toggle {
+  margin-top: 8px;
+  font-size: 12px;
+  padding: 4px 10px;
+  border-radius: 4px;
+  border: 1px solid rgba(148, 163, 184, 0.4);
+  background: rgba(30, 41, 59, 0.9);
+  color: #e2e8f0;
+  cursor: pointer;
+}
+
+.notif-toggle:disabled {
+  opacity: 0.5;
+  cursor: default;
 }
@@ -1,9 +1,14 @@
 'use client';

 import dynamic from 'next/dynamic';
+import { useEffect, useRef, useState } from 'react';
 import LeftPane from '@/components/LeftPane';
 import RightPane from '@/components/RightPane';
+import ToastStack from '@/components/Toasts';
+import type { HoverTarget } from '@/components/hoverTypes';
 import { useGameState } from '@/lib/useGameState';
+import { useToasts } from '@/lib/useToasts';
+import { diffSnapshots } from '@/lib/deriveEvents';

 const Map = dynamic(() => import('@/components/Map'), { ssr: false });

@@ -13,12 +18,40 @@ export default function Home() {
  // lets a pane push an action endpoint's full response snapshot in immediately.
  const { state, loading, error, refresh, applySnapshot } = useGameState(1000);

+  // ISS-002 (v0.15.0): the side panels' hover target — shared here so hovering a row in
+  // either pane highlights the matching plane/route/airports on the map.
+  const [hovered, setHovered] = useState<HoverTarget | null>(null);
+
+  // ISS-008 (v0.17.0): bottom-right toasts — action errors from both panes plus game events
+  // derived by diffing consecutive snapshots (no server event feed exists).
+  const { toasts, push, dismiss } = useToasts();
+  const onError = (message: string) => push('error', message);
+
+  // Diff each new snapshot against the previous one → info toasts. When the window is hidden
+  // and notifications are granted, mirror them as browser notifications too.
+  const prevSnapshotRef = useRef<typeof state>(null);
+  useEffect(() => {
+    if (state === null) return;
+    for (const event of diffSnapshots(prevSnapshotRef.current, state)) {
+      push('info', event.message);
+      if (document.hidden && 'Notification' in window && Notification.permission === 'granted') {
+        new Notification('Flight Ops', { body: event.message });
+      }
+    }
+    prevSnapshotRef.current = state;
+  }, [state, push]);
+
  return (
    <div className="app-shell">
-      <LeftPane state={state} loading={loading} error={error} onRefresh={refresh} />
-      {/* v0.11.0 — the same polled snapshot drives the map's plane markers + route lines */}
-      <Map state={state} />
-      <RightPane state={state} loading={loading} applySnapshot={applySnapshot} />
+      {/* ISS-021 (v0.20.0) — applySnapshot also reaches the left pane: its On board section's
+          refuel/fly/abandon actions push their response snapshot into the shared state */}
+      <LeftPane state={state} loading={loading} error={error} onRefresh={refresh} applySnapshot={applySnapshot} onHover={setHovered} onError={onError} />
+      {/* v0.11.0 — the same polled snapshot drives the map's plane markers + route lines;
+          ISS-010 (v0.18.0) — applySnapshot lets the airport popup's Relocate row push its
+          action response into the shared state, exactly like RightPane does */}
+      <Map state={state} hovered={hovered} applySnapshot={applySnapshot} />
+      <RightPane state={state} loading={loading} applySnapshot={applySnapshot} onHover={setHovered} onError={onError} />
+      <ToastStack toasts={toasts} onDismiss={dismiss} />
    </div>
  );
 }
@@ -13,6 +13,7 @@
        "sql.js": "^1.14.2",
      },
      "devDependencies": {
+        "@playwright/test": "1.63.0",
        "@types/node": "^22.20.3",
        "@types/react": "^19.3.0",
        "@types/react-dom": "^19.3.0",
@@ -123,6 +124,8 @@

    "@oxc-project/types": ["@oxc-project/types@0.150.0", "", {}, "sha512-rDS5/31E9HfPl/CIzGrn0DOlvBbXFseQ5URJ9sYMfstbKLD/c6Gm9vmRzRGDdAXyOIL4zmO37lc9RIwYqVruZw=="],

+    "@playwright/test": ["@playwright/test@1.63.0", "", { "dependencies": { "playwright": "1.63.0" }, "bin": { "playwright": "cli.js" } }, "sha512-oxMK4vllB9RK5NQ2l1pq1IfOf2AvnEuj/vYGDj0H2nMtmtZpKtCwt/l00GEO6xjGfpBNAvjovvYdCm50dRQkpQ=="],
+
    "@rolldown/binding-android-arm-eabi": ["@rolldown/binding-android-arm-eabi@1.2.9", "", { "os": "android", "cpu": "arm" }, "sha512-tNISae1QEf/vkb3xkRcjV5SEdzPE97We5IVaa2Z8jSszQPZ8U60B/YCYpw4QI7VidYsBtKavczXf+DyDs9WGxw=="],

    "@rolldown/binding-android-arm64": ["@rolldown/binding-android-arm64@1.2.9", "", { "os": "android", "cpu": "arm64" }, "sha512-YC8YsI30o606GTZi0VyzYlsDKFP8W61i/QzayHDkLbNEz/IShqAmTa+hsJRj13xTHA0H+6fk4b2UmGn+Q/cMlg=="],
@@ -299,6 +302,10 @@

    "picomatch": ["picomatch@4.0.7", "", {}, "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA=="],

+    "playwright": ["playwright@1.63.0", "", { "dependencies": { "playwright-core": "1.63.0" }, "bin": { "playwright": "cli.js" } }, "sha512-+7ziBLidS4NaNCdt57SUDT+wYmmd5fmiQejUic/kb+YsYSCPyOOE9sebzMjNmQrsnNpDJqd4WHvV/8lfKfUDUg=="],
+
+    "playwright-core": ["playwright-core@1.63.0", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-rYCsBF/M5HjUch52bbtVONEFjv6Xu8sm8h72dNlR5bzIE1fvC/bxgspzkjSfU+MweEMmPM8KJebG6nnyxo5mCg=="],
+
    "postcss": ["postcss@8.5.23", "", { "dependencies": { "nanoid": "^3.3.16", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-g50586zr4bZmwFiTlflMu8E0bDTb5I5gertgwAKmsdUlTQIhZtunzUlD1WSzwcVWPoAVpsrA6vlfCD7oXvRwgg=="],

    "potpack": ["potpack@2.1.0", "", {}, "sha512-pcaShQc1Shq0y+E7GqJqvZj8DTthWV1KeHGdi0Z6IAin2Oi3JnLCOfwnCo84qc+HAp52wT9nK9H7FAJp5a44GQ=="],
@@ -1,10 +1,16 @@
 'use client';

 import { useCallback, useEffect, useRef, useState, type ChangeEvent } from 'react';
+import type { GeoJsonFeatureCollection } from '@/lib/airports';
 import type { PlaneState, StateSnapshot } from '@/lib/game/state';
 import { PLANE_TYPES } from '@/lib/game/catalog';
-import { formatCash, formatFuel, formatSimClock } from '@/lib/format';
+import { abandonPenalty } from '@/lib/game/penalty';
+import { formatCash, formatDeadlineRelative, formatFuel, formatSimClock } from '@/lib/format';
 import { TIME_SCALES, scaleToSlider, sliderToScale } from '@/lib/timeScale';
+import { useGameAction } from '@/lib/useGameAction';
+import { useSimClock } from '@/lib/useSimClock';
+import { slotsUsedFor } from './RightPane';
+import type { HoverTarget } from './hoverTypes';

 interface LeftPaneProps {
  state: StateSnapshot | null;
@@ -12,11 +18,19 @@ interface LeftPaneProps {
  error: string | null;
  // The shell's single-poll refresh — called after a sim-control POST so the pane updates immediately.
  onRefresh: () => void;
+  // ISS-021 (v0.20.0): push the full snapshot returned by an action endpoint into the shared shell
+  // state — needed now that the On board section's refuel/fly/abandon actions live in this pane.
+  applySnapshot: (snapshot: StateSnapshot) => void;
+  // ISS-002 (v0.15.0): report fleet-row hovers to the shell so the map can highlight the plane.
+  onHover: (target: HoverTarget | null) => void;
+  // ISS-008 (v0.17.0): report a failed sim-control POST to the shell as an error toast.
+  onError?: (message: string) => void;
 }

-// Power-of-two slider (v0.9.2): position t ∈ [0,1] → nearest step of the ladder
-// 1×/2×/4×/8×/16×/32×/64× — each of the 7 positions doubles the speed.
-const SCALE_SLIDER_STEP = 1 / (TIME_SCALES.length - 1); // one doubling per keyboard-arrow step
+// Discrete ladder slider (v0.9.2, values reworked in v0.14.0): position t ∈ [0,1] → nearest
+// step of the ladder 1×/2×/5×/10×/25×/50×/100×/250×/500×/1000× — each of the 10 positions
+// roughly doubles the speed.
+const SCALE_SLIDER_STEP = 1 / (TIME_SCALES.length - 1); // one ladder step per keyboard-arrow step
 const SCALE_COMMIT_DEBOUNCE_MS = 250;

 // Flying planes show their current leg from the snapshot's dest fields (v0.12.0).
@@ -41,16 +55,83 @@ export function pendingScaleConfirmed(pendingScale: number | null, serverTimeSca
  return pendingScale !== null && serverTimeScale === pendingScale;
 }

-export default function LeftPane({ state, loading, error, onRefresh }: LeftPaneProps) {
+// ISS-008 fix (v0.17.0, CI runs #44/#47): bounded retry for POST /api/sim — a commit dropped by
+// the runner's flaky uplink used to leave the UI optimistic while the server kept the old scale.
+// Up to maxAttempts tries with delayMs between them; stops early once superseded() flips (a newer
+// intent arrived and the caller's loop sends it instead). post is idempotent set-semantics, so
+// re-sending a body whose response was lost cannot double-apply. Pure core — unit-tested in node.
+export const SIM_POST_MAX_ATTEMPTS = 3;
+export const SIM_POST_RETRY_DELAY_MS = 500;
+
+export type SimPostRetryResult =
+  | { ok: true }
+  | { ok: false; reason: 'exhausted'; error: unknown }
+  | { ok: false; reason: 'superseded' };
+
+export async function retrySimPost(
+  post: () => Promise<void>,
+  superseded: () => boolean,
+  sleep: (ms: number) => Promise<void> = (ms) => new Promise((r) => setTimeout(r, ms)),
+  maxAttempts: number = SIM_POST_MAX_ATTEMPTS,
+  delayMs: number = SIM_POST_RETRY_DELAY_MS,
+): Promise<SimPostRetryResult> {
+  let lastError: unknown;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (superseded()) return { ok: false, reason: 'superseded' }; // a newer intent takes over — don't even send this body
+    try {
+      await post();
+      return { ok: true };
+    } catch (err) {
+      lastError = err;
+      if (superseded()) return { ok: false, reason: 'superseded' }; // a newer intent arrived during the attempt — don't wait out the backoff
+      if (attempt < maxAttempts) await sleep(delayMs);
+    }
+  }
+  return { ok: false, reason: 'exhausted', error: lastError };
+}
+
+export default function LeftPane({ state, loading, error, onRefresh, applySnapshot, onHover, onError }: LeftPaneProps) {
  const [busy, setBusy] = useState(false);

-  // POST /api/sim, then refetch the full snapshot immediately so the pane reflects the new
-  // controls without waiting for the next poll tick. On failure keep the stale UI — the
-  // running poll retries on its own and surfaces the error state. A commit that lands while
-  // another POST is in flight is held in a single slot (last intent wins) and flushed by the
-  // in-flight call, so every user intent reaches the server (the [1,64] clamp stays as backstop).
-  // The gate is a REF, not React state: closures never see a stale "busy" value, which used to
-  // let a flush re-queue instead of send and silently drop a commit.
+  // ISS-021 (v0.20.0): shared action runner for the On board section (moved here from RightPane).
+  const { runAction, busy: actionsBusy, actionError } = useGameAction(state, applySnapshot, onError);
+
+  // ISS-023 (v0.21.0): Relocate selections — moved here from the right-pane market row; same
+  // "effective selection" pattern as there: the user's pick while it stays valid, else a sensible
+  // default (first grounded plane / first airport).
+  const [relocatePlaneId, setRelocatePlaneId] = useState<string | null>(null);
+  const [relocateDestIcao, setRelocateDestIcao] = useState<string | null>(null);
+
+  // ISS-010 (v0.18.0): one-time /api/airports fetch per page life — destination options for the
+  // Relocate section, sorted by name so e2e selection is stable. Same promise-ref pattern as Map.tsx;
+  // on failure airportOptions stays null and the Relocate button simply remains disabled. Moved here
+  // from RightPane in ISS-023 (v0.21.0) — the relocate-dest select was its only consumer there.
+  const [airportOptions, setAirportOptions] = useState<Array<{ name: string; icao: string }> | null>(null);
+  const airportsPromiseRef = useRef<Promise<Array<{ name: string; icao: string }>> | null>(null);
+  useEffect(() => {
+    if (!airportsPromiseRef.current) {
+      airportsPromiseRef.current = fetch('/api/airports', { cache: 'no-store' })
+        .then((res) => {
+          if (!res.ok) throw new Error(`GET /api/airports → HTTP ${res.status}`);
+          return res.json() as Promise<GeoJsonFeatureCollection>;
+        })
+        .then((fc) =>
+          fc.features
+            .map((f) => ({ name: f.properties.name, icao: f.properties.icao }))
+            .sort((a, b) => a.name.localeCompare(b.name, 'en')),
+        );
+    }
+    void airportsPromiseRef.current.then(setAirportOptions).catch(() => {});
+  }, []);
+
+  // POST /api/sim (retried up to SIM_POST_MAX_ATTEMPTS× on failure — CI runs #44/#47), then
+  // refetch the full snapshot immediately so the pane reflects the new controls without waiting
+  // for the next poll tick. After the final attempt fails keep the stale UI and surface an error
+  // toast (the running poll retries on its own). A commit that lands while another POST is in
+  // flight — including mid-retry — is held in a single slot (last intent wins) and supersedes
+  // the in-flight body, so every user intent reaches the server (the [1,1000] clamp stays as
+  // backstop). The gate is a REF, not React state: closures never see a stale "busy" value,
+  // which used to let a flush re-queue instead of send and silently drop a commit.
  const queuedRef = useRef<{ timeScale?: number; paused?: boolean } | null>(null);
  const busyRef = useRef(false);

@@ -71,20 +152,32 @@ export default function LeftPane({ state, loading, error, onRefresh }: LeftPaneP
      try {
        let current: { timeScale?: number; paused?: boolean } | null = body;
        while (current !== null) {
-          const res = await fetch('/api/sim', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(current),
-            cache: 'no-store',
-          });
-          if (!res.ok) throw new Error(`POST /api/sim → HTTP ${res.status}`);
-          onRefresh();
-          if (current === body) sentOwn = true; // object identity — queued bodies are fresh literals
+          const target = current; // stable across this retry round
+          const result = await retrySimPost(
+            async () => {
+              const res = await fetch('/api/sim', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(target),
+                cache: 'no-store',
+              });
+              if (!res.ok) throw new Error(`POST /api/sim → HTTP ${res.status}`);
+            },
+            () => queuedRef.current !== null, // a newer intent supersedes the in-flight body mid-retry
+          );
+          if (result.ok) {
+            onRefresh();
+            if (target === body) sentOwn = true; // object identity — queued bodies are fresh literals
+          } else if (result.reason === 'exhausted') {
+            throw result.error; // only after the final attempt fails → error toast below
+          }
          current = queuedRef.current; // pick up anything that arrived while we were in flight
          queuedRef.current = null;
        }
      } catch (err) {
        console.error('failed to apply sim controls', err);
+        // ISS-008: surface the failure as an error toast too — previously console-only.
+        onError?.(`Failed to update time controls (${err instanceof Error ? err.message : String(err)})`);
        queuedRef.current = null; // don't replay a stale intent after a failed round-trip
      } finally {
        busyRef.current = false;
@@ -92,16 +185,30 @@ export default function LeftPane({ state, loading, error, onRefresh }: LeftPaneP
      }
      return sentOwn ? 'sent' : 'failed';
    },
-    [onRefresh],
+    [onRefresh, onError],
  );

  const paused = state?.simState.paused ?? false;
  const timeScale = state?.simState.timeScale ?? 1;

+  // On board (v0.12.0, moved from the right pane in ISS-021 v0.20.0): every plane that carries
+  // cargo or is mid-flight gets a block — its loaded/expired packages with fly-to-destination +
+  // abandon controls, and flying planes show their current leg.
+  const clockMs = state?.simState.clockMs ?? 0;
+  const onboard = state ? state.planes.filter((p) => p.status === 'flying' || slotsUsedFor(state, p.id) > 0) : [];
+
+  // ISS-023 (v0.21.0): Relocate — any GROUNDED plane can be repositioned to any airport via the
+  // existing fly endpoint (pure repositioning, no package needed since v0.12.0). Moved here from
+  // the right-pane market row; with state null both fall back to null and the section isn't rendered.
+  const grounded = state ? state.planes.filter((p) => p.status === 'available') : [];
+  const relocatePlane = grounded.find((p) => p.id === relocatePlaneId) ?? grounded[0] ?? null;
+  const relocateDest =
+    airportOptions === null ? null : airportOptions.find((a) => a.icao === relocateDestIcao) ?? airportOptions[0] ?? null;
+
  // Slider commit (v0.9.1): the displayed value follows the drag optimistically via
  // pendingScale; POST /api/sim fires after a 250 ms debounce, or immediately when the
  // user releases the slider (browsers fire a native 'change' on release). The server's
-  // [1,64] clamp stays as the backstop.
+  // [1,1000] clamp stays as the backstop.
  const [pendingScale, setPendingScaleState] = useState<number | null>(null);
  const pendingRef = useRef<number | null>(null);
  const commitTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
@@ -161,8 +268,33 @@ export default function LeftPane({ state, loading, error, onRefresh }: LeftPaneP
    [],
  );

+  // ISS-008: browser-notification opt-in. Starts null (SSR-safe — the real permission is read
+  // in an effect after hydration, so server and client render identically) and follows the
+  // result of Notification.requestPermission(). 'unsupported' = no Notification API at all.
+  const [notifPermission, setNotifPermission] = useState<string | null>(null);
+  useEffect(() => {
+    if ('Notification' in window) setNotifPermission(Notification.permission);
+    else setNotifPermission('unsupported');
+  }, []);
+
+  // null (pre-effect) and 'default' both read as the opt-in prompt.
+  const notifLabel: string =
+    notifPermission === 'granted'
+      ? 'Notifications enabled'
+      : notifPermission === 'denied'
+        ? 'Notifications blocked'
+        : notifPermission === 'unsupported'
+          ? 'Notifications unavailable'
+          : 'Enable notifications';
+
  const displayedScale = pendingScale ?? timeScale;

+  // ISS-007: the clock ticks client-side between polls, re-syncing to server truth on every
+  // snapshot. Fed with EFFECTIVE controls so a scale drag / pause click takes effect immediately,
+  // not when the confirming snapshot lands. Only the sim-clock paragraph uses this — deadline and
+  // penalty previews stay snapshot-based (deterministic against the server clock).
+  const simClockMs = useSimClock(state, { timeScale: displayedScale, paused });
+
  return (
    <aside data-testid="left-pane" className="pane left-pane">
      <h2 className="pane-title">Assets</h2>
@@ -188,7 +320,14 @@ export default function LeftPane({ state, loading, error, onRefresh }: LeftPaneP
            ) : (
              <ul data-testid="fleet-list" className="fleet-list">
                {state.planes.map((p) => (
-                  <li key={p.id} data-testid={`plane-${p.id}`} className="plane-row">
+                  // ISS-002: hovering a fleet row highlights the plane on the map.
+                  <li
+                    key={p.id}
+                    data-testid={`plane-${p.id}`}
+                    className="plane-row"
+                    onMouseEnter={() => onHover({ kind: 'plane', id: p.id })}
+                    onMouseLeave={() => onHover(null)}
+                  >
                    <div className="plane-main">
                      <span className="plane-model">{PLANE_TYPES[p.model]?.name ?? p.model}</span>
                      <span className={`plane-status status-${p.status}`}>{p.status}</span>
@@ -207,10 +346,171 @@ export default function LeftPane({ state, loading, error, onRefresh }: LeftPaneP
            )}
          </section>

+          {/* ISS-021 (v0.20.0): moved here from the right pane — between Fleet and Time. */}
+          <section className="pane-section">
+            <h3 className="pane-heading">On board</h3>
+            {onboard.length === 0 ? (
+              <p className="pane-muted">Nothing on board.</p>
+            ) : (
+              onboard.map((plane) => {
+                const cargo = state.packages.filter(
+                  (pkg) => pkg.planeId === plane.id && (pkg.status === 'loaded' || pkg.status === 'expired'),
+                );
+                return (
+                  // ISS-002: hovering the on-board block (including its cargo rows) highlights the plane.
+                  // Handlers live only on the outer div — React's enter/leave don't fire when moving to a
+                  // child, so this covers the whole block without flicker between sub-elements.
+                  <div
+                    key={plane.id}
+                    data-testid={`onboard-${plane.id}`}
+                    className="onboard-block"
+                    onMouseEnter={() => onHover({ kind: 'plane', id: plane.id })}
+                    onMouseLeave={() => onHover(null)}
+                  >
+                    <div className="contract-main">
+                      <span className="plane-model">{PLANE_TYPES[plane.model]?.name ?? plane.model}</span>
+                      {plane.status === 'flying' ? (
+                        <>
+                          <span className="plane-status status-flying">in flight</span>
+                          {plane.destName && (
+                            <span data-testid={`plane-leg-${plane.id}`} className="contract-route">
+                              {plane.locationName} → {plane.destName}
+                            </span>
+                          )}
+                        </>
+                      ) : (
+                        <span className="plane-status status-available">{plane.locationIcao}</span>
+                      )}
+                    </div>
+                    {cargo.map((pkg) => {
+                      const penalty = abandonPenalty(pkg, clockMs);
+                      return (
+                        // ISS-025 (v0.22.0): hovering a loaded package draws its full origin→dest trace on the map —
+                        // same as job-list rows — and keeps this plane's halo lit via planeId. Leaving the row restores
+                        // the block's plain plane highlight; leaving the whole block still ends at null (the child's
+                        // mouseleave fires before the parent's).
+                        <div
+                          key={pkg.id}
+                          data-testid={`onboard-package-${pkg.id}`}
+                          className="contract-row"
+                          onMouseEnter={() => onHover({ kind: 'package', originIcao: pkg.originIcao, destIcao: pkg.destIcao, planeId: plane.id })}
+                          onMouseLeave={() => onHover({ kind: 'plane', id: plane.id })}
+                        >
+                          <button
+                            type="button"
+                            data-testid={`fly-to-${pkg.id}`}
+                            className="pane-btn onboard-fly-btn"
+                            disabled={actionsBusy || plane.status !== 'available'}
+                            onClick={() => void runAction(`/api/planes/${plane.id}/fly`, { destIcao: pkg.destIcao })}
+                          >
+                            <span className="onboard-fly-label" title={`Fly to ${pkg.destName}`}>
+                              Fly to {pkg.destName}
+                            </span>
+                          </button>
+                          <div className="onboard-actions">
+                            <button
+                              type="button"
+                              data-testid={`refuel-for-${pkg.id}`}
+                              className="pane-btn"
+                              disabled={actionsBusy || plane.status !== 'available'}
+                              onClick={() => void runAction(`/api/planes/${plane.id}/refuel`, { mode: 'forFlight', packageId: pkg.id })}
+                            >
+                              Refuel
+                            </button>
+                            <button
+                              type="button"
+                              data-testid={`abandon-${pkg.id}`}
+                              className="pane-btn"
+                              disabled={actionsBusy || plane.status !== 'available'}
+                              onClick={() => void runAction(`/api/packages/${pkg.id}/abandon`)}
+                            >
+                              Abandon{' '}
+                              <span data-testid={`abandon-penalty-${pkg.id}`}>−{formatCash(penalty)}</span>
+                            </button>
+                          </div>
+                          <div className="contract-sub">
+                            <span className="contract-route">{pkg.originName} → {pkg.destName}</span>
+                            <span>{formatCash(pkg.reward)}</span>
+                            {pkg.status === 'expired' ? (
+                              <span data-testid={`onboard-expired-${pkg.id}`}>expired</span>
+                            ) : (
+                              <span>{formatDeadlineRelative(pkg.deadlineSimTime, clockMs)}</span>
+                            )}
+                          </div>
+                        </div>
+                      );
+                    })}
+                  </div>
+                );
+              })
+            )}
+          </section>
+
+          {/* ISS-023 (v0.21.0): moved here from the right-pane market row — it belongs with
+              everything else about our planes, between On board and Time. */}
+          {/* ISS-027 (v0.22.0): hovering the section previews the planned relocation on the map —
+              dashed trace from the selected plane's airport to the destination + a ring on the target.
+              With no grounded plane or no loaded airport options there is nothing to preview → null. */}
+          <section
+            className="pane-section"
+            data-testid="relocate-section"
+            onMouseEnter={() =>
+              onHover(
+                relocatePlane && relocateDest
+                  ? { kind: 'route', fromIcao: relocatePlane.locationIcao, toIcao: relocateDest.icao }
+                  : null,
+              )
+            }
+            onMouseLeave={() => onHover(null)}
+          >
+            <h3 className="pane-heading">Relocate</h3>
+            {/* ISS-010 (v0.18.0): relocate a grounded plane — the fly endpoint already allows pure
+                repositioning, this row just exposes it for planes with nothing on board. */}
+            <div className="market-row market-row-relocate">
+              <select
+                data-testid="relocate-plane"
+                aria-label="Plane to relocate"
+                value={relocatePlane?.id ?? ''}
+                onChange={(e) => setRelocatePlaneId(e.target.value || null)}
+              >
+                {grounded.map((p) => (
+                  <option key={p.id} value={p.id}>
+                    {PLANE_TYPES[p.model]?.name ?? p.model} — {p.locationIcao}
+                  </option>
+                ))}
+              </select>
+              <select
+                data-testid="relocate-dest"
+                aria-label="Relocation destination airport"
+                value={relocateDest?.icao ?? ''}
+                onChange={(e) => setRelocateDestIcao(e.target.value || null)}
+              >
+                {airportOptions?.map((a) => (
+                  <option key={a.icao} value={a.icao}>
+                    {a.name}
+                  </option>
+                ))}
+              </select>
+              <button
+                type="button"
+                data-testid="relocate-go"
+                className="pane-btn"
+                disabled={actionsBusy || relocatePlane === null || relocateDest === null}
+                onClick={() => {
+                  if (relocatePlane && relocateDest) {
+                    void runAction(`/api/planes/${relocatePlane.id}/fly`, { destIcao: relocateDest.icao });
+                  }
+                }}
+              >
+                Relocate
+              </button>
+            </div>
+          </section>
+
          <section className="pane-section">
            <h3 className="pane-heading">Time</h3>
            <p data-testid="sim-clock" className="sim-clock">
-              {formatSimClock(state.simState.clockMs)}
+              {simClockMs !== null && formatSimClock(simClockMs)}
              {paused ? ' (paused)' : ''}
            </p>
            <div className="time-controls">
@@ -235,6 +535,24 @@ export default function LeftPane({ state, loading, error, onRefresh }: LeftPaneP
              />
              <span data-testid="time-scale-value">{displayedScale}×</span>
            </div>
+            {/* ISS-008: explicit opt-in for browser notifications (fired when the window is hidden). */}
+            <button
+              type="button"
+              data-testid="enable-notifications"
+              className="notif-toggle"
+              disabled={notifPermission === 'unsupported'}
+              title={notifPermission === 'unsupported' ? 'This browser does not support notifications' : undefined}
+              onClick={() => {
+                // A rejection (rare — e.g. some headless setups) reads as "blocked".
+                if ('Notification' in window) {
+                  void Notification.requestPermission()
+                    .then(setNotifPermission)
+                    .catch(() => setNotifPermission('denied'));
+                }
+              }}
+            >
+              {notifLabel}
+            </button>
          </section>

          {error && (
@@ -242,6 +560,8 @@ export default function LeftPane({ state, loading, error, onRefresh }: LeftPaneP
              {error}
            </p>
          )}
+          {/* ISS-021 (v0.20.0): inline error from a failed On board action — mirrors right-error. */}
+          {actionError && <p data-testid="left-action-error" className="pane-error">{actionError}</p>}
        </>
      ) : null}
    </aside>
@@ -7,7 +7,8 @@ import pkg from '../package.json';
 import { DEFAULT_STYLE_ID, STYLES, STYLE_STORAGE_KEY, isStyleId, localAssetsAvailable, styleUrlFor } from '../lib/mapStyles';
 import type { GeoJsonFeatureCollection } from '../lib/airports';
 import type { StateSnapshot } from '../lib/game/state';
-import { planesGeoJson, routesGeoJson, type AirportCoord, type PlaneFeatureProps } from '../lib/mapData';
+import type { HoverTarget } from './hoverTypes';
+import { hoverRouteGeoJson, planesGeoJson, routesGeoJson, type AirportCoord, type PlaneFeatureProps } from '../lib/mapData';
 import { weatherFor } from '../lib/weather';
 import { approxLocalTime } from '../lib/localTime';

@@ -27,6 +28,20 @@ const PLANES_GROUNDED_LAYER_ID = 'planes-grounded';
 const PLANES_FLYING_LAYER_ID = 'planes-flying';
 const ROUTES_SOURCE_ID = 'routes';
 const ROUTES_LEGS_LAYER_ID = 'routes-legs';
+// ISS-002 (v0.15.0): top-most hover-highlight layers, added after the base layers so they
+// render above them. Each starts filtered to match nothing; applyHoverRef drives the filters.
+const PLANES_HIGHLIGHT_LAYER_ID = 'planes-highlight';
+const ROUTES_HIGHLIGHT_LAYER_ID = 'routes-highlight';
+const AIRPORTS_HIGHLIGHT_LAYER_ID = 'airports-highlight';
+// ISS-022/025/027 (v0.22.0): the hover route trace — its OWN source + top-most dashed line,
+// because the shared `routes` source only holds FLYING legs: an open package's or a grounded
+// relocation's planned route is never in it. applyHoverRef pushes data into it on every hover.
+const HOVER_ROUTES_SOURCE_ID = 'hover-routes';
+const HOVER_ROUTE_LAYER_ID = 'hover-route';
+// ISS-022 (v0.22.0): the DESTINATION airport's ring — a second, differently-colored circle over
+// the same `airports` source so the target stands out from the origin's plain yellow ring.
+// applyHoverRef filters it to the hovered target's destination icao only.
+const AIRPORTS_TARGET_HIGHLIGHT_LAYER_ID = 'airports-target-highlight';

 function escapeHtml(s: string): string {
  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
@@ -36,11 +51,18 @@ interface MapProps {
  // The shell's polled /api/state snapshot (v0.11.0) — drives the plane markers and
  // route lines. Null until the first successful poll.
  state?: StateSnapshot | null;
+  // ISS-002 (v0.15.0): the side panels' hover target — highlights the matching plane
+  // (+ its route leg if flying) or a package's endpoint airports, and (ISS-022/025/027 v0.22.0)
+  // draws the full great-circle trace between any hovered target's two endpoints. Null = nothing hovered.
+  hovered?: HoverTarget | null;
+  // ISS-010 (v0.18.0): push an action endpoint's full response snapshot into the shared
+  // shell state — same callback RightPane receives, used by the airport popup's Relocate row.
+  applySnapshot: (snapshot: StateSnapshot) => void;
 }

 // Named FlightMap (not Map): a component called `Map` would shadow the global
 // Map constructor inside its own body, breaking `new Map(...)` for the airport index.
-export default function FlightMap({ state }: MapProps) {
+export default function FlightMap({ state, hovered, applySnapshot }: MapProps) {
  const containerRef = useRef<HTMLDivElement>(null);
  const mapRef = useRef<maplibregl.Map | null>(null);
  // /api/airports is fetched at most once per page life: every styledata event
@@ -49,6 +71,12 @@ export default function FlightMap({ state }: MapProps) {
  // Latest snapshot + airport coordinate index, so the mount effect's styledata wiring
  // and the state-change effect can both push data without prop-drilling into closures.
  const stateRef = useRef<StateSnapshot | null>(null);
+  // ISS-010 (v0.18.0): the shell's applySnapshot is stable (useCallback with no deps), but the
+  // mount effect captures it once — keep a ref so the popup wiring always calls the latest one.
+  const applySnapshotRef = useRef(applySnapshot);
+  useEffect(() => {
+    applySnapshotRef.current = applySnapshot;
+  }, [applySnapshot]);
  const airportsIndexRef = useRef<Map<string, AirportCoord> | null>(null);
  const [airportCount, setAirportCount] = useState<number | null>(null);
  const [styleId, setStyleId] = useState<string>(DEFAULT_STYLE_ID);
@@ -74,6 +102,65 @@ export default function FlightMap({ state }: MapProps) {
    applyDynamicRef.current();
  }, [state]);

+  // ISS-002 (v0.15.0): hover highlight — same ref + effect pattern as the snapshot above.
+  // No-op until the layers exist; ensureLayers re-applies the current filter after every
+  // styledata re-establish, so a hover that outlives a style switch stays highlighted.
+  const hoveredRef = useRef<HoverTarget | null>(null);
+  const applyHoverRef = useRef<() => void>(() => {});
+  applyHoverRef.current = () => {
+    const map = mapRef.current;
+    if (!map) return;
+    const h = hoveredRef.current;
+    // The empty-string sentinel matches nothing: no feature has id/icao ''. A package hover may
+    // name its plane (ISS-025 on-board cargo rows), so that plane's halo stays lit too.
+    let planeId = '';
+    let fromIcao = '';
+    let toIcao = '';
+    if (h) {
+      if (h.kind === 'plane') planeId = h.id;
+      else if (h.kind === 'package') {
+        planeId = h.planeId ?? '';
+        fromIcao = h.originIcao;
+        toIcao = h.destIcao;
+      } else {
+        // 'route' — the Relocate panel's planned flight: trace + target airport only.
+        fromIcao = h.fromIcao;
+        toIcao = h.toIcao;
+      }
+    }
+    if (map.getLayer(PLANES_HIGHLIGHT_LAYER_ID)) {
+      map.setFilter(PLANES_HIGHLIGHT_LAYER_ID, ['==', ['get', 'id'], planeId]);
+    }
+    if (map.getLayer(ROUTES_HIGHLIGHT_LAYER_ID)) {
+      map.setFilter(ROUTES_HIGHLIGHT_LAYER_ID, ['==', ['get', 'planeId'], planeId]);
+    }
+    // ISS-022/025/027: the hover route trace — one great-circle line for any target carrying two
+    // ICAOs (package origin→dest / relocate fromIcao→toIcao); empty when either endpoint is unknown.
+    const hoverSource = map.getSource(HOVER_ROUTES_SOURCE_ID) as maplibregl.GeoJSONSource | undefined;
+    if (hoverSource) {
+      void hoverSource.setData(hoverRouteGeoJson(fromIcao, toIcao, airportsIndexRef.current ?? new Map()));
+    }
+    // Package hovers ring BOTH endpoints (v0.15.0 behavior); 'route' hovers ring the TARGET only —
+    // the relocation's destination is what ISS-027 asks to see. Plane hovers ring nothing.
+    const originIcao = h?.kind === 'package' ? fromIcao : '';
+    const destIcao = h?.kind === 'package' || h?.kind === 'route' ? toIcao : '';
+    if (map.getLayer(AIRPORTS_HIGHLIGHT_LAYER_ID)) {
+      map.setFilter(
+        AIRPORTS_HIGHLIGHT_LAYER_ID,
+        ['any', ['==', ['get', 'icao'], originIcao], ['==', ['get', 'icao'], destIcao]],
+      );
+    }
+    // ISS-022: the destination gets its own distinct-colored ring on top (package AND route hovers).
+    if (map.getLayer(AIRPORTS_TARGET_HIGHLIGHT_LAYER_ID)) {
+      map.setFilter(AIRPORTS_TARGET_HIGHLIGHT_LAYER_ID, ['==', ['get', 'icao'], destIcao]);
+    }
+  };
+
+  useEffect(() => {
+    hoveredRef.current = hovered ?? null;
+    applyHoverRef.current();
+  }, [hovered]);
+
  useEffect(() => {
    if (!containerRef.current) return;

@@ -115,16 +202,67 @@ export default function FlightMap({ state }: MapProps) {
        // deterministic generated weather — no gameplay effects per PLAN.md.
        const w = weatherFor(p.icao);
        const localTime = approxLocalTime(p.lon, Date.now());
-        new maplibregl.Popup({ offset: 10 })
+        // ISS-010 (v0.18.0): Relocate row — grounded planes from the latest snapshot can be
+        // repositioned to this airport via POST /api/planes/{id}/fly (pure repositioning).
+        const st = stateRef.current;
+        const groundedPlanes = st ? st.planes.filter((pl) => pl.status === 'available') : [];
+        const planeLabel = (model: string) => st?.catalog.find((c) => c.model === model)?.label ?? model;
+        const relocateHtml =
+          groundedPlanes.length > 0
+            ? `<select data-testid="airport-popup-plane" aria-label="Plane to relocate here">` +
+              `<option value="">Select a plane\u2026</option>` +
+              groundedPlanes.map(
+                (pl) =>
+                  `<option value="${escapeHtml(pl.id)}">${escapeHtml(planeLabel(pl.model))} \u2014 ${escapeHtml(pl.locationIcao)}</option>`,
+              ).join('') +
+              `</select><button type="button" data-testid="airport-popup-relocate" disabled>Relocate here</button>`
+            : `<span data-testid="airport-popup-no-planes">No grounded planes to relocate.</span>`;
+        const popup = new maplibregl.Popup({ offset: 10 })
          .setLngLat(f.geometry.coordinates as [number, number])
          .setHTML(
            `<div data-testid="airport-popup">` +
              `<strong>${escapeHtml(p.name)}</strong><br/>${escapeHtml(p.icao)}<br/>` +
              `<span data-testid="airport-local-time">${localTime} local (approx)</span><br/>` +
              `<span data-testid="airport-weather">${w.condition}, wind ${w.windDirDeg}\u00B0 / ${w.windKt} kt, vis ${w.visibilityM} m</span>` +
+              `<div class="popup-relocate">` + relocateHtml + `<span data-testid="airport-popup-relocate-status"></span></div>` +
            `</div>`,
          )
          .addTo(map);
+
+        // Popups are plain HTML, not React — the element only exists after addTo, so wire the
+        // controls via querySelector (the select enables the button once a plane is picked).
+        const el = popup.getElement();
+        const select = el?.querySelector<HTMLSelectElement>('[data-testid="airport-popup-plane"]');
+        const button = el?.querySelector<HTMLButtonElement>('[data-testid="airport-popup-relocate"]');
+        // The status span is always in the popup HTML (even with no grounded planes), so it
+        // exists whenever the select/button do.
+        const statusEl = el?.querySelector<HTMLElement>('[data-testid="airport-popup-relocate-status"]');
+        if (select && button && statusEl) {
+          select.addEventListener('change', () => {
+            button.disabled = select.value === '';
+          });
+          button.addEventListener('click', async () => {
+            const planeId = select.value;
+            if (!planeId || button.disabled) return;
+            button.disabled = true;
+            statusEl.textContent = 'Relocating\u2026';
+            try {
+              const res = await fetch(`/api/planes/${planeId}/fly`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ destIcao: p.icao }),
+                cache: 'no-store',
+              });
+              const data = (await res.json()) as StateSnapshot & { error?: string };
+              if (!res.ok) throw new Error(data.error ?? `HTTP ${res.status}`);
+              applySnapshotRef.current(data); // shared shell state updates immediately, like the panes' runAction
+              statusEl.textContent = 'Relocation started.';
+            } catch (err) {
+              statusEl.textContent = err instanceof Error ? err.message : String(err);
+              button.disabled = false; // allow retry / picking another plane
+            }
+          });
+        }
      };

      const onPlaneClick = (e: maplibregl.MapLayerMouseEvent) => {
@@ -183,9 +321,9 @@ export default function FlightMap({ state }: MapProps) {
            type: 'circle',
            source: AIRPORTS_SOURCE_ID,
            paint: {
-              'circle-radius': 3,
+              'circle-radius': 5, // ISS-010 (v0.18.0): bigger — the r=3 dots were hard to click
              'circle-color': '#e11d48',
-              'circle-stroke-width': 1,
+              'circle-stroke-width': 1.5,
              'circle-stroke-color': '#ffffff',
            },
          });
@@ -240,6 +378,84 @@ export default function FlightMap({ state }: MapProps) {
            },
          });
        }
+        // ISS-002 (v0.15.0): hover-highlight layers — added last so they sit top-most over
+        // both plane layers / the route line / the airport circles. Each starts filtered to
+        // match nothing; applyHoverRef sets the real filter on hover and re-applies it here.
+        if (!map.getLayer(PLANES_HIGHLIGHT_LAYER_ID)) {
+          map.addLayer({
+            id: PLANES_HIGHLIGHT_LAYER_ID,
+            type: 'circle',
+            source: PLANES_SOURCE_ID,
+            filter: ['==', ['get', 'id'], ''],
+            paint: {
+              'circle-radius': 10, // halo well above the base circles (3 grounded / 6 flying)
+              'circle-color': '#38bdf8',
+              'circle-stroke-width': 2.5,
+              'circle-stroke-color': '#ffffff',
+            },
+          });
+        }
+        if (!map.getLayer(ROUTES_HIGHLIGHT_LAYER_ID)) {
+          map.addLayer({
+            id: ROUTES_HIGHLIGHT_LAYER_ID,
+            type: 'line',
+            source: ROUTES_SOURCE_ID,
+            filter: ['==', ['get', 'planeId'], ''],
+            paint: {
+              'line-color': '#ef4444', // red — distinct from the amber routes-legs line
+              'line-width': 6,
+            },
+          });
+        }
+        if (!map.getLayer(AIRPORTS_HIGHLIGHT_LAYER_ID)) {
+          map.addLayer({
+            id: AIRPORTS_HIGHLIGHT_LAYER_ID,
+            type: 'circle',
+            source: AIRPORTS_SOURCE_ID,
+            filter: ['any', ['==', ['get', 'icao'], ''], ['==', ['get', 'icao'], '']],
+            paint: {
+              'circle-radius': 9, // ring around the base airport circles (r=5)
+              'circle-color': 'rgba(0, 0, 0, 0)', // transparent fill — stroke-only ring
+              'circle-stroke-width': 2.5,
+              'circle-stroke-color': '#facc15',
+            },
+          });
+        }
+        // ISS-022/025/027 (v0.22.0): the hover route trace — added LAST so it sits above every
+        // other layer, including the highlight rings at its endpoints. Own source: the shared
+        // `routes` source only holds flying legs, never a planned one. Empty until a hover sets data.
+        if (!map.getSource(HOVER_ROUTES_SOURCE_ID)) {
+          map.addSource(HOVER_ROUTES_SOURCE_ID, { type: 'geojson', data: { type: 'FeatureCollection', features: [] } });
+        }
+        if (!map.getLayer(HOVER_ROUTE_LAYER_ID)) {
+          map.addLayer({
+            id: HOVER_ROUTE_LAYER_ID,
+            type: 'line',
+            source: HOVER_ROUTES_SOURCE_ID,
+            paint: {
+              'line-color': '#facc15', // matches the airports-highlight ring — one "trace" color
+              'line-width': 4,
+              'line-dasharray': [2, 2], // dashed = planned route, distinct from solid flying legs
+            },
+          });
+        }
+        // ISS-022 (v0.22.0): the destination's ring — same geometry as airports-highlight but a
+        // DIFFERENT color so the target stands out over the origin's yellow ring; added last so it
+        // also sits above the hover-route line at its endpoint. Starts filtered to match nothing.
+        if (!map.getLayer(AIRPORTS_TARGET_HIGHLIGHT_LAYER_ID)) {
+          map.addLayer({
+            id: AIRPORTS_TARGET_HIGHLIGHT_LAYER_ID,
+            type: 'circle',
+            source: AIRPORTS_SOURCE_ID,
+            filter: ['==', ['get', 'icao'], ''],
+            paint: {
+              'circle-radius': 9, // same ring size as airports-highlight (r=5 base circles)
+              'circle-color': 'rgba(0, 0, 0, 0)', // transparent fill — stroke-only ring
+              'circle-stroke-width': 3,
+              'circle-stroke-color': '#4ade80', // green — distinct from the yellow endpoint rings
+            },
+          });
+        }
        // Layer-scoped listeners survive setStyle (they filter by layer id at event
        // time), so off+on with the same reference re-wires without duplicating.
        map.off('click', AIRPORTS_LAYER_ID, onAirportClick);
@@ -248,8 +464,10 @@ export default function FlightMap({ state }: MapProps) {
        map.on('click', PLANES_GROUNDED_LAYER_ID, onPlaneClick);
        map.off('click', PLANES_FLYING_LAYER_ID, onPlaneClick);
        map.on('click', PLANES_FLYING_LAYER_ID, onPlaneClick);
-        // Sources were (re)created above — push the latest game state into them.
+        // Sources were (re)created above — push the latest game state into them, and re-apply
+        // the current hover filter to the (re-created) highlight layers.
        applyDynamicRef.current();
+        applyHoverRef.current();
      };

      if (map.isStyleLoaded()) void ensureLayers();
@@ -1,10 +1,11 @@
 'use client';

-import { useCallback, useEffect, useState } from 'react';
+import { useState } from 'react';
 import type { PackageState, PlaneState, StateSnapshot } from '@/lib/game/state';
 import { PLANE_TYPES } from '@/lib/game/catalog';
-import { abandonPenalty } from '@/lib/game/penalty';
 import { formatCash, formatDeadlineRelative } from '@/lib/format';
+import { useGameAction } from '@/lib/useGameAction';
+import type { HoverTarget } from './hoverTypes';

 interface RightPaneProps {
  state: StateSnapshot | null;
@@ -12,6 +13,12 @@ interface RightPaneProps {
  // Push the full snapshot returned by an action endpoint into the shared shell state (v0.10.0),
  // so the pane updates on click without waiting for the next poll tick.
  applySnapshot: (snapshot: StateSnapshot) => void;
+  // ISS-002 (v0.15.0): report row hovers to the shell so the map can highlight the plane or
+  // the package's endpoint airports.
+  onHover: (target: HoverTarget | null) => void;
+  // ISS-008 (v0.17.0): report a failed action to the shell as an error toast — in ADDITION
+  // to the inline pane error, which stays (both surfaces by design).
+  onError?: (message: string) => void;
 }

 const planeName = (p: PlaneState): string => PLANE_TYPES[p.model]?.name ?? p.model;
@@ -100,14 +107,10 @@ function LoadControls({
  );
 }

-export default function RightPane({ state, loading, applySnapshot }: RightPaneProps) {
-  const [busy, setBusy] = useState(false);
-  // Inline error from a failed action — auto-clears on the next successful poll (the shell's
-  // snapshot prop changes every tick) or the next successful action.
-  const [actionError, setActionError] = useState<string | null>(null);
-  useEffect(() => {
-    if (state !== null) setActionError(null);
-  }, [state]);
+export default function RightPane({ state, loading, applySnapshot, onHover, onError }: RightPaneProps) {
+  // ISS-021 (v0.20.0): shared action runner — busy gate, inline pane error + shell toast on
+  // failure, full post-action snapshot pushed into the shared state on success.
+  const { runAction, busy, actionError } = useGameAction(state, applySnapshot, onError);

  // Market picker selections — same "effective selection" pattern as LoadControls: the
  // user's pick while it stays valid, else a sensible default (first catalog entry / first plane).
@@ -115,33 +118,8 @@ export default function RightPane({ state, loading, applySnapshot }: RightPanePr
  const [sellPlaneId, setSellPlaneId] = useState<string | null>(null);
  const [refuelPlaneId, setRefuelPlaneId] = useState<string | null>(null);

-  // POST an action endpoint. Every success returns the FULL post-action snapshot (v0.8.0
-  // convention) — pushed into the shared state immediately; a 4xx {error} body becomes the
-  // inline pane error and the stale UI stays until the next poll. Buttons are disabled while
-  // a request is in flight, so at most one action runs at a time.
-  const runAction = useCallback(
-    async (path: string, body?: unknown) => {
-      if (busy) return;
-      setBusy(true);
-      try {
-        const res = await fetch(path, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: body === undefined ? undefined : JSON.stringify(body),
-          cache: 'no-store',
-        });
-        const data = (await res.json()) as StateSnapshot & { error?: string };
-        if (!res.ok) throw new Error(data.error ?? `HTTP ${res.status}`);
-        setActionError(null);
-        applySnapshot(data);
-      } catch (err) {
-        setActionError(err instanceof Error ? err.message : String(err));
-      } finally {
-        setBusy(false);
-      }
-    },
-    [applySnapshot, busy],
-  );
+  // ISS-023 (v0.21.0): the Relocate row moved to the left pane — it belongs with everything else
+  // about our planes, not in the market. Its state + /api/airports fetch went with it.

  if (loading && !state) {
    return (
@@ -156,13 +134,6 @@ export default function RightPane({ state, loading, applySnapshot }: RightPanePr
  const clockMs = state.simState.clockMs;
  const open = state.packages.filter((p) => p.status === 'open');

-  // On board (v0.12.0): every plane that carries cargo or is mid-flight gets a block —
-  // its loaded/expired packages with fly-to-destination + abandon controls, and flying
-  // planes show their current leg.
-  const onboard = state.planes.filter(
-    (p) => p.status === 'flying' || slotsUsedFor(state, p.id) > 0,
-  );
-
  const catalog = state.catalog;
  const buyEntry = catalog.find((e) => e.model === buyModelId) ?? catalog[0] ?? null;

@@ -173,7 +144,6 @@ export default function RightPane({ state, loading, applySnapshot }: RightPanePr
    state.planes.find((p) => p.id === refuelPlaneId && p.status === 'available' && p.fuel < p.maxFuel) ??
    refuelable[0] ??
    null;
-
  // Previews computed client-side from the snapshot's catalog + economy constants (v0.10.0).
  const sellEntry = sellPlane ? catalog.find((e) => e.model === sellPlane.model) : undefined;
  const sellPayout = sellEntry ? Math.round(sellEntry.price * state.sellFraction * 100) / 100 : null;
@@ -192,7 +162,14 @@ export default function RightPane({ state, loading, applySnapshot }: RightPanePr
            {open.map((pkg) => {
              const eligible = loadEligiblePlanes(state, pkg);
              return (
-                <li key={pkg.id} data-testid={`open-package-${pkg.id}`} className="contract-row">
+                // ISS-002: hovering an open package highlights its two endpoint airports on the map.
+                <li
+                  key={pkg.id}
+                  data-testid={`open-package-${pkg.id}`}
+                  className="contract-row"
+                  onMouseEnter={() => onHover({ kind: 'package', originIcao: pkg.originIcao, destIcao: pkg.destIcao })}
+                  onMouseLeave={() => onHover(null)}
+                >
                  <div className="contract-main">
                    <span className="contract-route">{pkg.originName} → {pkg.destName}</span>
                    {eligible.length > 0 ? (
@@ -222,74 +199,7 @@ export default function RightPane({ state, loading, applySnapshot }: RightPanePr
        )}
      </section>

-      <section className="pane-section">
-        <h3 className="pane-heading">On board</h3>
-        {onboard.length === 0 ? (
-          <p className="pane-muted">Nothing on board.</p>
-        ) : (
-          onboard.map((plane) => {
-            const cargo = state.packages.filter(
-              (pkg) => pkg.planeId === plane.id && (pkg.status === 'loaded' || pkg.status === 'expired'),
-            );
-            return (
-              <div key={plane.id} data-testid={`onboard-${plane.id}`} className="onboard-block">
-                <div className="contract-main">
-                  <span className="plane-model">{planeName(plane)}</span>
-                  {plane.status === 'flying' ? (
-                    <>
-                      <span className="plane-status status-flying">in flight</span>
-                      {plane.destName && (
-                        <span data-testid={`plane-leg-${plane.id}`} className="contract-route">
-                          {plane.locationName} → {plane.destName}
-                        </span>
-                      )}
-                    </>
-                  ) : (
-                    <span className="plane-status status-available">{plane.locationIcao}</span>
-                  )}
-                </div>
-                {cargo.map((pkg) => {
-                  const penalty = abandonPenalty(pkg, clockMs);
-                  return (
-                    <div key={pkg.id} data-testid={`onboard-package-${pkg.id}`} className="contract-row">
-                      <div className="contract-main">
-                        <button
-                          type="button"
-                          data-testid={`fly-to-${pkg.id}`}
-                          className="pane-btn"
-                          disabled={busy || plane.status !== 'available'}
-                          onClick={() => void runAction(`/api/planes/${plane.id}/fly`, { destIcao: pkg.destIcao })}
-                        >
-                          Fly to {pkg.destName}
-                        </button>
-                        <button
-                          type="button"
-                          data-testid={`abandon-${pkg.id}`}
-                          className="pane-btn"
-                          disabled={busy || plane.status !== 'available'}
-                          onClick={() => void runAction(`/api/packages/${pkg.id}/abandon`)}
-                        >
-                          Abandon{' '}
-                          <span data-testid={`abandon-penalty-${pkg.id}`}>−{formatCash(penalty)}</span>
-                        </button>
-                      </div>
-                      <div className="contract-sub">
-                        <span>{pkg.originName} → {pkg.destName}</span>
-                        <span>{formatCash(pkg.reward)}</span>
-                        {pkg.status === 'expired' ? (
-                          <span data-testid={`onboard-expired-${pkg.id}`}>expired</span>
-                        ) : (
-                          <span>{formatDeadlineRelative(pkg.deadlineSimTime, clockMs)}</span>
-                        )}
-                      </div>
-                    </div>
-                  );
-                })}
-              </div>
-            );
-          })
-        )}
-      </section>
+      {/* ISS-021 (v0.20.0): the On board section moved to the left pane (between Fleet and Time). */}

      <section className="pane-section">
        <h3 className="pane-heading">Market</h3>
@@ -385,9 +295,11 @@ export default function RightPane({ state, loading, applySnapshot }: RightPanePr
              if (refuelPlane) void runAction(`/api/planes/${refuelPlane.id}/refuel`);
            }}
          >
-            Refuel
+            Refuel to full
          </button>
        </div>
+
+        {/* ISS-023 (v0.21.0): the Relocate row moved to the left pane's "Relocate" section. */}
      </section>

      {actionError && <p data-testid="right-error" className="pane-error">{actionError}</p>}
@@ -0,0 +1,24 @@
+'use client';
+
+import type { Toast } from '@/lib/useToasts';
+
+// ISS-008 (v0.17.0): the bottom-right toast stack — action errors and game events derived
+// from snapshot diffs. Fixed-position overlay above the map; each item auto-dismisses via
+// the hook's TTL or its × button.
+export default function ToastStack({ toasts, onDismiss }: { toasts: Toast[]; onDismiss?: (id: number) => void }) {
+  if (toasts.length === 0) return null;
+  return (
+    <div className="toasts" role="status">
+      {toasts.map((t) => (
+        <div key={t.id} data-testid="toast" className={`toast toast-${t.kind}`}>
+          <span>{t.message}</span>
+          {onDismiss && (
+            <button type="button" data-testid={`toast-dismiss-${t.id}`} className="toast-close" onClick={() => onDismiss(t.id)}>
+              ×
+            </button>
+          )}
+        </div>
+      ))}
+    </div>
+  );
+}
@@ -0,0 +1,12 @@
+// ISS-002 — what a side-panel hover highlights on the map (v0.15.0): a plane marker
+// (+ its route leg if flying) or both endpoint airports of an open package. The shell
+// owns this state and passes it to <Map>; panes report it via their onHover callback.
+// ISS-022/025/027 (v0.22.0): any target carrying two ICAOs also makes the map draw the full
+// great-circle trace between them — package hovers carry origin→dest, 'route' hovers (the
+// Relocate panel) carry fromIcao→toIcao; a package hover may additionally name its plane so
+// that plane's halo stays lit alongside the trace.
+
+export type HoverTarget =
+  | { kind: 'plane'; id: string }
+  | { kind: 'package'; originIcao: string; destIcao: string; planeId?: string }
+  | { kind: 'route'; fromIcao: string; toIcao: string };
@@ -1,5 +1,5 @@
-import { describe, expect, it } from 'vitest';
-import { pendingScaleConfirmed } from './LeftPane';
+import { describe, expect, it, vi } from 'vitest';
+import { pendingScaleConfirmed, retrySimPost, SIM_POST_MAX_ATTEMPTS, SIM_POST_RETRY_DELAY_MS } from './LeftPane';

 // ISS-001 — the optimistic slider value is cleared exactly when a rendered snapshot confirms
 // it (server scale === pending), never earlier. Clearing at commit time would snap the pointer
@@ -22,3 +22,70 @@ describe('pendingScaleConfirmed', () => {
    expect(pendingScaleConfirmed(1, 1)).toBe(true); // committing the current value confirms immediately
  });
 });
+
+// ISS-008 fix (CI runs #44/#47): a dropped POST /api/sim must be retried before surfacing the
+// error — up to SIM_POST_MAX_ATTEMPTS tries with SIM_POST_RETRY_DELAY_MS between them, and a newer
+// intent supersedes the in-flight body instead of waiting out its retries.
+
+describe('retrySimPost', () => {
+  it('pins the retry budget: 3 attempts total, ~500 ms backoff', () => {
+    expect(SIM_POST_MAX_ATTEMPTS).toBe(3);
+    expect(SIM_POST_RETRY_DELAY_MS).toBe(500);
+  });
+
+  it('succeeds on the first attempt without sleeping or retrying', async () => {
+    const post = vi.fn(async () => {});
+    const sleep = vi.fn(async () => {});
+    await expect(retrySimPost(post, () => false, sleep)).resolves.toEqual({ ok: true });
+    expect(post).toHaveBeenCalledTimes(1);
+    expect(sleep).not.toHaveBeenCalled();
+  });
+
+  it('retries with the backoff delay and succeeds on a later attempt', async () => {
+    let calls = 0;
+    const post = vi.fn(async () => {
+      if (++calls < 3) throw new Error('dropped');
+    });
+    const sleep = vi.fn(async () => {});
+    await expect(retrySimPost(post, () => false, sleep)).resolves.toEqual({ ok: true });
+    expect(post).toHaveBeenCalledTimes(3);
+    expect(sleep).toHaveBeenCalledTimes(2); // one backoff between each pair of attempts
+    expect(sleep).toHaveBeenCalledWith(SIM_POST_RETRY_DELAY_MS);
+  });
+
+  it('gives up after the final attempt with the last error (no trailing sleep)', async () => {
+    const err = new Error('down');
+    const post = vi.fn(async () => {
+      throw err;
+    });
+    const sleep = vi.fn(async () => {});
+    const result = await retrySimPost(post, () => false, sleep);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.reason).toBe('exhausted');
+      if (result.reason === 'exhausted') expect(result.error).toBe(err); // the LAST attempt's error
+    }
+    expect(post).toHaveBeenCalledTimes(SIM_POST_MAX_ATTEMPTS);
+    expect(sleep).toHaveBeenCalledTimes(SIM_POST_MAX_ATTEMPTS - 1);
+  });
+
+  it('stops retrying once a newer intent supersedes the in-flight body (no further attempts or sleeps)', async () => {
+    let calls = 0;
+    const post = vi.fn(async () => {
+      calls++; // flip "superseded" right after the first failure, like a queued commitNow would
+      throw new Error('dropped');
+    });
+    const sleep = vi.fn(async () => {});
+    await expect(retrySimPost(post, () => calls >= 1, sleep)).resolves.toEqual({ ok: false, reason: 'superseded' });
+    expect(post).toHaveBeenCalledTimes(1); // the caller's loop sends the newer body instead
+    expect(sleep).not.toHaveBeenCalled(); // supersede is checked before the backoff sleep
+  });
+
+  it('never even sends a body that is already superseded', async () => {
+    const post = vi.fn(async () => {});
+    const sleep = vi.fn(async () => {});
+    await expect(retrySimPost(post, () => true, sleep)).resolves.toEqual({ ok: false, reason: 'superseded' });
+    expect(post).not.toHaveBeenCalled();
+    expect(sleep).not.toHaveBeenCalled();
+  });
+});
@@ -8,7 +8,7 @@ import type { PackageState, PlaneState, StateSnapshot } from '@/lib/game/state';
 // directly on the single eligible plane, or shows a picker when several qualify.

 const CATALOG = [
-  { model: 'atr72', label: 'ATR 72-600', price: 200_000, maxFuel: 6300, burnPerKm: 1.75, speedKmh: 510, capacity: 6 },
+  { model: 'atr72', label: 'ATR 72-600', price: 200_000, maxFuel: 6300, burnPerKm: 1.75, emptyWeightKg: 9_300, speedKmh: 510, capacity: 6 },
 ];

 function plane(over: Partial<PlaneState> & Pick<PlaneState, 'id'>): PlaneState {
@@ -0,0 +1,35 @@
+# Isolated e2e stack for CI (.gitea/workflows/ci.yml) — runs on the runner's shared dind
+# daemon under project name flight-ci (distinct from production). Joins the external
+# network flight-ci-e2e that the workflow attaches the job container to; the app is reached
+# at its STATIC IP http://172.39.0.10:3000 — DNS bypassed for the browser because Chromium
+# got ERR_SSL_PROTOCOL_ERROR via the hostname while node-side HTTP worked (the `app` alias
+# stays as a convenience). Single deterministic address; survives `docker compose restart flight`.
+# The build context is tarred by the compose client in the job and sent over DOCKER_HOST,
+# so nothing here needs to be visible from inside dind; game state lives in a named volume
+# (fresh per run — CI cleanup removes it — survives `docker compose restart flight` for
+# e2e/state.spec.ts).
+services:
+  flight:
+    build: .
+    image: flight-ops-ci
+    environment:
+      FLIGHT_TEST_HOOKS: "1"
+    volumes:
+      # Self-hosted map-asset pack (styles/fonts/sprites): the workflow downloads it into ./public
+      # before build; absent/empty → app falls back to remote OFM styles. Mirrors docker-compose.yml's
+      # mount so e2e runs in self-hosted mode like local dev (map tests abort openfreemap.org traffic).
+      - "./public:/app/public"
+      - flight-db:/app/db
+    networks:
+      flight-ci-e2e:
+        aliases:
+          - app
+        ipv4_address: 172.39.0.10
+
+networks:
+  flight-ci-e2e:
+    name: flight-ci-e2e
+    external: true
+
+volumes:
+  flight-db:
@@ -3,21 +3,31 @@ import { expect, test } from '@playwright/test';

 // v0.12.0 package model against the live origin (https://flight.dev.kkhost.pl):
 // the full core loop through the UI — hook creates a short package at EDDF → Load
-// via the right pane → click its destination in the on-board list → fly at 60× →
+// via the right pane → click its destination in the on-board list (left pane since
+// v0.20.0, ISS-021) → fly at 1000× →
 // arrival delivers EXACTLY the reward + rep; abandon deducts exactly the formula
 // penalty while grounded; expired packages deliver/abandon with no reward and no
 // penalty. Mirrors lib/game/penalty.ts for exact-value assertions.

-const SCALE = 60; // fastest sim speed — keeps flights to seconds of real time
+const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top) — keeps flights to seconds of real time
 const HUB = 'EDDF'; // Frankfurt Main — the seeded starter plane's home base (lib/game/seed.ts)
-const FAR = 'LEZL'; // Seville — one-way burn 3174 L > half tank, so the return leg is unfuelable
+const FAR = 'LEZL'; // Seville — a long leg: under the v0.16.0 weighted model a full tank covers the
+                    // round trip, but the return leaves too little for another outbound

-// Mirrors lib/sim/movement.ts + lib/game/catalog.ts (atr72).
-const BURN_PER_KM = 1.75;
-const FUEL_PRICE_PER_L = 0.8;
+// Mirrors lib/sim/movement.ts (v0.16.0 weight-proportional burn) + lib/game/catalog.ts (atr72).
+const FUEL_DENSITY_KG_PER_L = 0.8; // Jet-A1 density — must match FUEL_DENSITY_KG_PER_L in movement.ts
+const FUEL_PRICE_PER_L = 0.8; // must match catalog.ts
 const REP_BASE = 1; // lib/sim/engine.ts
 const REP_PER_KM = 0.0005;

+// Fuel remaining after distanceKm from startFuel — closed form of dF/dx = −k(We + ρF),
+// k calibrated so a full tank burns exactly burnPerKm (mirrors fuelAtWeighted).
+function fuelAfter(startFuel: number, burnPerKm: number, emptyWeightKg: number, maxFuel: number, distanceKm: number): number {
+  const k = burnPerKm / (emptyWeightKg + FUEL_DENSITY_KG_PER_L * maxFuel);
+  const rho = FUEL_DENSITY_KG_PER_L;
+  return Math.max(0, (startFuel + emptyWeightKg / rho) * Math.exp(-k * rho * distanceKm) - emptyWeightKg / rho);
+}
+
 // Mirrors lib/game/penalty.ts — the exact abandon penalty at a given game clock.
 function penaltyFor(reward: number, createdSimTime: number, deadlineSimTime: number, clockMs: number): number {
  const span = deadlineSimTime - createdSimTime;
@@ -33,6 +43,7 @@ interface StateBody {
    id: string; originIcao: string; destIcao: string; reward: number; cargoType: string; cargoCount: number;
    deadlineSimTime: number; status: 'open' | 'loaded' | 'delivered' | 'expired' | 'abandoned'; planeId: string | null; createdSimTime: number;
  }>;
+  catalog: Array<{ model: string; burnPerKm: number; emptyWeightKg: number; maxFuel: number }>; // v0.16.0 weighted burn inputs
 }

 async function getState(page: Page): Promise<StateBody> {
@@ -90,17 +101,26 @@ test.describe.configure({ mode: 'serial' }); // shared live DB — order matters
 // (repositioning needs no package — v0.12.0 manual flight), and abandon any leftover cargo so
 // exact cash/rep assertions start from a clean baseline even after an interrupted previous run.
 async function flyHomeViaApi(page: Page): Promise<void> {
-  const s0 = await getState(page);
-  const plane = s0.planes.find((p) => p.id === 'plane-starter')!;
+  let s = await getState(page);
+  let plane = s.planes.find((p) => p.id === 'plane-starter')!;
  if (plane.status === 'flying' || plane.locationIcao !== HUB) {
-    // Fast-forward any leftover leg / repositioning flight (~3 min real time worst case at 60×).
+    // Fast-forward any leftover leg / repositioning flight (~20 s real time worst case at 1000×).
    await setScale(page, SCALE);
  }
  if (plane.status === 'flying') {
-    // Let the in-flight leg finish before repositioning.
+    // Let the in-flight leg finish before repositioning. While flying, locationIcao stays at the
+    // DEPARTURE airport, so the pre-landing snapshot can't tell us where the plane ends up — re-read
+    // state after landing before deciding whether a repositioning flight is needed (run #41 retry: a
+    // leftover EDDF→EDFH leg landed away from home but the helper still believed it was home and
+    // skipped the fly-home).
    await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.status), { timeout: 240_000 }).toBe('available');
+    s = await getState(page);
+    plane = s.planes.find((p) => p.id === 'plane-starter')!;
  }
  if (plane.locationIcao !== HUB) {
+    // ISS-011: the landing above auto-slown the sim to 1× — re-set SCALE so the return leg
+    // fast-forwards instead of taking real-time hours.
+    await setScale(page, SCALE);
    const res = await page.request.post(`/api/planes/${plane.id}/fly`, { data: { destIcao: HUB } });
    expect(res.ok()).toBeTruthy(); // repositioning needs no package (v0.12.0 manual flight)
    await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.locationIcao), { timeout: 240_000 }).toBe(HUB);
@@ -119,7 +139,7 @@ async function flyHomeViaApi(page: Page): Promise<void> {


 test('full core loop via UI: load → fly to destination → exact reward + rep on arrival', async ({ page }) => {
-  test.setTimeout(300_000); // self-heal (worst case ~3 min at 60×) + two short flights + refuel
+  test.setTimeout(300_000); // self-heal (worst case ~20 s at 1000×) + two short flights + refuel
  // Self-heal: the starter plane may be anywhere from a previous run/spec.
  await flyHomeViaApi(page);
  const before = await getState(page);
@@ -133,6 +153,14 @@ test('full core loop via UI: load → fly to destination → exact reward + rep
  expect(pkg.originIcao).toBe(HUB);
  expect(pkg.destIcao).toBe(nearest.icao);

+  // Precondition (server truth) before clicking Load: the starter must be grounded at the package's
+  // origin — that is exactly what makes it load-eligible, and a stale pane snapshot can't prove it.
+  await expect.poll(async () => {
+    const b = await getState(page);
+    const p = b.planes.find((x) => x.id === 'plane-starter')!;
+    return p.status === 'available' && p.locationIcao === pkg.originIcao;
+  }, { timeout: 30_000, message: 'waiting for plane-starter to be grounded at the package origin (self-heal incomplete?)' }).toBe(true);
+
  // LOAD via the UI: exactly one eligible plane (the starter at EDDF) → direct button.
  await page.goto('/');
  const loadBtn = page.getByTestId(`load-${pkg.id}`);
@@ -149,12 +177,19 @@ test('full core loop via UI: load → fly to destination → exact reward + rep
  await expect(flyBtn).toBeEnabled();
  await flyBtn.click();

-  let s = await getState(page);
  const planeId = 'plane-starter';
-  expect(s.planes.find((p) => p.id === planeId)!.status).toBe('flying');
-  expect(s.planes.find((p) => p.id === planeId)!.destIcao).toBe(nearest.icao);
+  // The click fires the fly POST asynchronously (runAction is fire-and-forget from the test's view),
+  // so a getState issued immediately can race ahead of it and still see 'available' — poll until the
+  // fly actually took effect on the server (the run #36/#41 flake).
+  await expect.poll(async () => {
+    const b = await getState(page);
+    const p = b.planes.find((x) => x.id === planeId)!;
+    return p.status === 'flying' && p.destIcao === nearest.icao;
+  }, { timeout: 15_000, message: 'waiting for the fly click to take effect (status "flying" + dest set)' }).toBe(true);

-  // Fast-forward to arrival (≤ ~10 min game time at 60× → seconds of real time).
+  let s = await getState(page);
+
+  // Fast-forward to arrival (a few seconds of real time at 1000×).
  await setScale(page, SCALE);
  await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === planeId)!.status), { timeout: 120_000 }).toBe('available');

@@ -174,8 +209,12 @@ test('full core loop via UI: load → fly to destination → exact reward + rep
  const repGain = Math.round((REP_BASE + REP_PER_KM * exactKm) * 100) / 100;
  expect(s.account.reputation).toBeCloseTo(Math.round((before.account.reputation + repGain) * 100) / 100, 9);

-  // Fuel burned exactly burnPerKm × km (analytic movement — no rounding drift).
-  expect(landed.fuel).toBeCloseTo(Math.max(0, before.planes.find((p) => p.id === planeId)!.fuel - BURN_PER_KM * exactKm), 6);
+  // Fuel burned per the v0.16.0 weight-proportional model (closed form — no rounding drift).
+  const entry = before.catalog.find((e) => e.model === 'atr72')!;
+  expect(landed.fuel).toBeCloseTo(
+    fuelAfter(before.planes.find((p) => p.id === planeId)!.fuel, entry.burnPerKm, entry.emptyWeightKg, entry.maxFuel, exactKm),
+    6,
+  );

  // Refuel via the API: cost = (maxFuel − fuel) × FUEL_PRICE_PER_L, deducted exactly.
  const refuelRes = await page.request.post(`/api/planes/${planeId}/refuel`);
@@ -186,7 +225,9 @@ test('full core loop via UI: load → fly to destination → exact reward + rep
  const refuelCost = Math.round((afterRefuel.maxFuel - landed.fuel) * FUEL_PRICE_PER_L * 100) / 100;
  expect(s.account.cash).toBeCloseTo(before.account.cash + pkg.reward - refuelCost, 6);

-  // Restore: fly home (repositioning — no package needed in the v0.12.0 model).
+  // Restore: fly home (repositioning — no package needed in the v0.12.0 model). ISS-011: the
+  // arrival above auto-slown the sim to 1×, so re-set SCALE for the return leg.
+  await setScale(page, SCALE);
  const homeRes = await page.request.post(`/api/planes/${planeId}/fly`, { data: { destIcao: HUB } });
  expect(homeRes.ok()).toBeTruthy();
  await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === planeId)!.locationIcao), { timeout: 120_000 }).toBe(HUB);
@@ -230,7 +271,7 @@ test('abandon while grounded deducts exactly the formula penalty', async ({ page
 });

 test('expired packages deliver and abandon with no reward and no penalty', async ({ page }) => {
-  test.setTimeout(480_000); // two ~3 min real-time legs at 60× (HUB↔LEMD) plus expiry wait
+  test.setTimeout(480_000); // two ~10 s real-time legs at 1000× (HUB↔LEMD) plus expiry wait
  await flyHomeViaApi(page);
  const before = await getState(page);

@@ -273,15 +314,17 @@ test('expired packages deliver and abandon with no reward and no penalty', async
  expect(s.packages.find((p) => p.id === pkgB.id)!.status).toBe('abandoned');
  expect(s.account.cash).toBe(cashBeforeAbandon); // free — expired abandons cost nothing

-  // Restore: refuel + fly home (scale is still SCALE from the expiry wait above).
+  // Restore: refuel + fly home. ISS-011: the LEMD arrival above auto-slown the sim to 1×, so
+  // re-set SCALE for the return leg (the expiry wait's scale no longer persists past a landing).
  await page.request.post('/api/planes/plane-starter/refuel');
+  await setScale(page, SCALE);
  const homeRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
  expect(homeRes.ok()).toBeTruthy();
  await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.locationIcao), { timeout: 240_000 }).toBe(HUB);
 });

 test('load and fly validation paths (404 / 409 / 400)', async ({ page }) => {
-  test.setTimeout(600_000); // the FAR round trip alone is ~7.5 min real time at 60×
+  test.setTimeout(600_000); // the FAR round trip alone is ~30 s real time at 1000×
  await flyHomeViaApi(page);

  // Load a package whose origin the plane is not at → 409.
@@ -312,17 +355,21 @@ test('load and fly validation paths (404 / 409 / 400)', async ({ page }) => {
  res = await page.request.post(`/api/packages/${pkg.id}/abandon`);
  expect(res.status()).toBe(409);

-  // Fly home from the hop so the fuel section starts at the hub.
+  // Fly home from the hop so the fuel section starts at the hub. ISS-011: the hop arrival above
+  // auto-slown the sim to 1×, so re-set SCALE for this leg.
+  await setScale(page, SCALE);
  res = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
  expect(res.ok()).toBeTruthy();
  await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.locationIcao), { timeout: 120_000 }).toBe(HUB);

-  // Insufficient fuel: a full-tank one-way burn of > half the tank makes the return leg unfuelable.
+  // Insufficient fuel (v0.16.0 weighted burn): a full tank covers the FAR round trip —
+  // the plane gets lighter as fuel burns off, so both legs fit — but landing back at the
+  // hub leaves too little for ANOTHER long leg: the second outbound must 409.
  const s0 = await getState(page);
  const starter = s0.planes.find((p) => p.id === 'plane-starter')!;
  expect(starter.locationIcao).toBe(HUB); // landed back at the hub from the hop above
  if (starter.fuel < starter.maxFuel) {
-    await page.request.post('/api/planes/plane-starter/refuel'); // ensure a full tank for the long leg
+    await page.request.post('/api/planes/plane-starter/refuel'); // ensure a full tank for the long legs
  }
  const farRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: FAR } });
  expect(farRes.ok()).toBeTruthy();
@@ -332,16 +379,20 @@ test('load and fly validation paths (404 / 409 / 400)', async ({ page }) => {
  const sFar = await getState(page);
  const atFar = sFar.planes.find((p) => p.id === 'plane-starter')!;
  expect(atFar.locationIcao).toBe(FAR);
-  // The return leg needs the same burn as the outbound — more than what's left.
+  // The return leg fits: the weighted burn over it is less than what's left in the tank.
+  // ISS-011: the FAR arrival above auto-slown the sim to 1×, so re-set SCALE for this leg.
+  await setScale(page, SCALE);
  const backRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
-  expect(backRes.status()).toBe(409);
-  expect(((await backRes.json()) as { error: string }).error).toMatch(/insufficient fuel/i);
-
-  // Restore: refuel + fly home.
-  await page.request.post('/api/planes/plane-starter/refuel');
-  const homeRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
-  expect(homeRes.ok()).toBeTruthy();
+  expect(backRes.ok()).toBeTruthy();
  await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.locationIcao), { timeout: 240_000 }).toBe(HUB);
+
+  // …but the tank is now too light for another FAR leg.
+  const againFar = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: FAR } });
+  expect(againFar.status()).toBe(409);
+  expect(((await againFar.json()) as { error: string }).error).toMatch(/insufficient fuel/i);
+
+  // Restore: refuel (the plane is already home).
+  await page.request.post('/api/planes/plane-starter/refuel');
 });

 // Great-circle distance in km — mirrors lib/geo.ts (same formula, same R).
@@ -0,0 +1,130 @@
+import type { Page } from '@playwright/test';
+import { expect, test } from '@playwright/test';
+
+// v0.19.0 — ISS-011: when the LAST plane lands (no plane remains in flight) the sim auto-slows
+// to 1×, server-side and persisted on the sim_state row so the UI slider reflects it on the next
+// snapshot. Arrival-triggered by design: a grounded fleet at high scale is left alone, there is no
+// auto-restore — the player speeds up manually again (asserted below).
+
+const SCALE = 1000; // fastest sim speed — top of the v0.14.0 ladder (same convention as e2e/sim.spec.ts)
+const HUB = 'EDDF'; // Frankfurt Main — the seeded starter plane's home base (lib/game/seed.ts)
+
+interface SimState {
+  clockMs: number;
+  timeScale: number;
+  paused: boolean;
+}
+
+interface StateBody {
+  simState: SimState;
+  planes: Array<{ id: string; status: string; locationIcao: string; destIcao: string | null }>;
+}
+
+async function getState(page: Page): Promise<StateBody> {
+  const res = await page.request.get('/api/state');
+  expect(res.ok()).toBeTruthy();
+  return (await res.json()) as StateBody;
+}
+
+async function postSim(page: Page, body: Record<string, unknown>): Promise<void> {
+  const res = await page.request.post('/api/sim', { data: body });
+  expect(res.status()).toBe(200);
+}
+
+// Set the time scale and VERIFY from the response that it stuck — if something external ever
+// resets the live instance's controls mid-test, fail loudly here instead of timing out later.
+async function setScale(page: Page, scale: number): Promise<void> {
+  const res = await page.request.post('/api/sim', { data: { timeScale: scale } });
+  expect(res.status()).toBe(200);
+  const body = (await res.json()) as SimState;
+  expect(body.timeScale, `timeScale should be ${scale} after POST /api/sim`).toBe(scale);
+}
+
+// Closest airport to the hub from /api/airports → shortest possible leg (fastest e2e flight).
+async function nearestToHub(page: Page): Promise<{ icao: string }> {
+  const res = await page.request.get('/api/airports');
+  expect(res.ok()).toBeTruthy();
+  const fc = (await res.json()) as { features: Array<{ properties: { icao: string; lat: number; lon: number } }> };
+  const hub = fc.features.find((f) => f.properties.icao === HUB)!.properties;
+  let nearest = fc.features.filter((f) => f.properties.icao !== HUB)[0].properties;
+  for (const f of fc.features) {
+    if (f.properties.icao === HUB) continue;
+    const d = Math.hypot(f.properties.lat - hub.lat, f.properties.lon - hub.lon);
+    const dn = Math.hypot(nearest.lat - hub.lat, nearest.lon - hub.lon);
+    if (d < dn) nearest = f.properties;
+  }
+  return { icao: nearest.icao };
+}
+
+// Self-heal helper (same pattern as e2e/relocation.spec.ts): let any in-flight leg finish and
+// reposition plane-starter home via the API so every test starts from the canonical state even
+// after an interrupted previous run.
+async function flyHomeViaApi(page: Page): Promise<void> {
+  let s = await getState(page);
+  let plane = s.planes.find((p) => p.id === 'plane-starter')!;
+  if (plane.status === 'flying' || plane.locationIcao !== HUB) {
+    // Fast-forward any leftover leg / repositioning flight (~20 s real time worst case at 1000×).
+    await setScale(page, SCALE);
+  }
+  if (plane.status === 'flying') {
+    // Let the in-flight leg finish before repositioning. While flying, locationIcao stays at the
+    // DEPARTURE airport — re-read state after landing before deciding whether a repositioning
+    // flight is needed.
+    await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.status), { timeout: 240_000 }).toBe('available');
+    s = await getState(page);
+    plane = s.planes.find((p) => p.id === 'plane-starter')!;
+  }
+  if (plane.locationIcao !== HUB) {
+    // ISS-011: the landing above auto-slown the sim to 1× — re-set SCALE so the return leg
+    // fast-forwards instead of taking real-time hours.
+    await setScale(page, SCALE);
+    const res = await page.request.post(`/api/planes/${plane.id}/fly`, { data: { destIcao: HUB } });
+    expect(res.ok()).toBeTruthy(); // repositioning needs no package (v0.12.0 manual flight)
+    await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.locationIcao), { timeout: 240_000 }).toBe(HUB);
+  }
+}
+
+// Self-heal in CLEANUP (afterEach): the test deliberately leaves plane-starter at the far end, so
+// fast-forward + reposition home here; then restore scale=1 / unpaused for later specs.
+test.afterEach(async ({ page }) => {
+  await flyHomeViaApi(page);
+  await postSim(page, { timeScale: 1, paused: false });
+});
+
+test.describe.configure({ mode: 'serial' }); // shared live DB — order matters within this file
+
+test('auto-slow to 1× when the last plane lands; manual speed-up still works (ISS-011)', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal (worst case ~20 s at 1000×) + one short leg
+  await flyHomeViaApi(page); // deterministic: the starter sits grounded at EDDF
+
+  const nearest = await nearestToHub(page);
+
+  // Set 1000× via the API and verify it stuck.
+  await setScale(page, SCALE);
+
+  // Dispatch plane-starter on the shortest leg from its hub (repositioning — no package needed).
+  const flyRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: nearest.icao } });
+  expect(flyRes.status()).toBe(200);
+
+  // Wait for the landing…
+  let landedBody: StateBody | undefined;
+  await expect
+    .poll(async () => {
+      const b = await getState(page);
+      const p = b.planes.find((x) => x.id === 'plane-starter')!;
+      if (p.status === 'available' && p.locationIcao === nearest.icao) landedBody = b;
+      return !!landedBody;
+    }, { timeout: 120_000, message: `waiting for plane-starter to land at ${nearest.icao}` })
+    .toBe(true);
+
+  // …and the server has auto-slown to 1× — persisted on sim_state, so this very snapshot shows it.
+  expect(landedBody!.simState.timeScale).toBe(1);
+
+  // Manual override still works: POST /api/sim {timeScale: 1000} → confirmed by the response…
+  const post = await page.request.post('/api/sim', { data: { timeScale: SCALE } });
+  expect(post.status()).toBe(200);
+  expect(((await post.json()) as SimState).timeScale).toBe(SCALE);
+  // …and by a fresh snapshot (no auto-restore of the previous scale — and no re-slow either,
+  // since nothing is in flight: the trigger is arrival-based, not idle-enforcement).
+  expect((await getState(page)).simState.timeScale).toBe(SCALE);
+});
@@ -0,0 +1,36 @@
+// CI-only connectivity diagnostics (globalSetup runs after the e2e stack is ready).
+// Evidence for the Chromium ERR_SSL_PROTOCOL_ERROR hunt: compares node-side resolution/HTTP
+// against Chromium's own navigation, hostname vs static IP. Never fails the run.
+import { promises as dnsPromises } from 'node:dns';
+import { chromium } from '@playwright/test';
+
+export default async function ciDiagnostics() {
+  if (process.env.PW_REMOTE_BROWSER !== '0') return; // local runs: no-op
+  const base = process.env.E2E_BASE_URL ?? '';
+  try {
+    console.log('[diag] node resolve4(app):', JSON.stringify(await dnsPromises.resolve4('app').catch((e) => `failed: ${e.code}`)));
+    try {
+      const r = await fetch(`${base}/api/version`);
+      console.log('[diag] node fetch', base, '->', r.status, JSON.stringify(await r.json().catch(() => null)));
+    } catch (e) {
+      console.log('[diag] node fetch failed:', String(e));
+    }
+    const browser = await chromium.launch();
+    try {
+      for (const url of ['http://app:3000/', base]) {
+        const page = await (await browser.newContext()).newPage();
+        try {
+          await page.goto(url, { timeout: 15_000 });
+          console.log('[diag] chromium goto', url, '-> OK, title:', await page.title().catch(() => '?'));
+        } catch (e) {
+          console.log('[diag] chromium goto', url, '-> FAILED:', String(e).split('\n')[0]);
+        }
+        await page.context().close();
+      }
+    } finally {
+      await browser.close();
+    }
+  } catch (e) {
+    console.log('[diag] diagnostics error (non-fatal):', String(e));
+  }
+}
@@ -0,0 +1,498 @@
+import { test, expect, type Page } from '@playwright/test';
+
+// v0.15.0 — ISS-002: hovering a plane or package in either side panel highlights it on the map.
+// Fleet rows + on-board blocks highlight the plane marker (and its route leg while flying);
+// open-package rows highlight both endpoint airports. The map exposes three top-most
+// highlight layers (planes-highlight / routes-highlight / airports-highlight), each filtered
+// to match nothing until a hover sets the filter — asserted here via window.__flightMap's
+// queryRenderedFeatures, same pattern as e2e/map.spec.ts and e2e/map-interactions.spec.ts.
+// ISS-022/025/027 (v0.22.0): any hover carrying two endpoints ALSO draws the full great-circle
+// trace between them in a fourth top-most layer (`hover-route`, dashed) — job-list rows, on-board
+// cargo rows and the Relocate section; the relocate preview rings only its TARGET airport, which
+// additionally gets a distinct green ring in `airports-target-highlight` (ISS-022).
+
+const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top) — keeps flights to seconds of real time
+const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts
+// Madrid–Barajas — same long leg as e2e/map-interactions.spec.ts: ~1420 km → ~10 s at scale 1000.
+const DEST = 'LEMD';
+
+interface PlaneState {
+  id: string;
+  model: string;
+  status: 'available' | 'flying';
+  fuel: number;
+  maxFuel: number;
+  locationIcao: string;
+  destIcao: string | null;
+}
+
+interface PackageState {
+  id: string;
+  originName: string;
+  destName: string;
+  reward: number;
+  status: 'open' | 'loaded' | 'delivered' | 'expired' | 'abandoned';
+  planeId: string | null;
+}
+
+interface StateBody {
+  account: { cash: number; reputation: number };
+  simState: { clockMs: number; timeScale: number; paused: boolean };
+  planes: PlaneState[];
+  packages: PackageState[];
+}
+
+async function getState(page: Page): Promise<StateBody> {
+  const res = await page.request.get('/api/state');
+  expect(res.status()).toBe(200);
+  return (await res.json()) as StateBody;
+}
+
+async function postSim(page: Page, body: unknown) {
+  return page.request.post('/api/sim', { data: body });
+}
+
+// Set the time scale and VERIFY from the response that it stuck — a silent reset would
+// otherwise surface as an unexplained landing-wait timeout.
+async function setScale(page: Page, scale: number): Promise<void> {
+  const res = await page.request.post('/api/sim', { data: { timeScale: scale } });
+  expect(res.status()).toBe(200);
+  const body = (await res.json()) as { timeScale: number };
+  expect(body.timeScale, `timeScale should be ${scale} after POST /api/sim`).toBe(scale);
+}
+
+// Leave the live instance in a sane state for the other specs (scale 1, running).
+test.afterEach(async ({ page }) => {
+  const res = await postSim(page, { timeScale: 1, paused: false });
+  expect(res.status()).toBe(200);
+});
+
+// Test hook (FLIGHT_TEST_HOOKS=1): create an open package on a known route.
+async function createPackage(page: Page, fromIcao: string, toIcao: string): Promise<PackageState> {
+  const created = await page.request.post('/api/test/create-package', {
+    data: { originIcao: fromIcao, destIcao: toIcao, deadlineOffsetMs: 24 * 3_600_000 },
+  });
+  expect(created.status()).toBe(201);
+  return (await created.json()) as PackageState;
+}
+
+// Self-heal: let any in-flight leg finish, then reposition plane-starter home via the API.
+async function flyHomeViaApi(page: Page): Promise<void> {
+  const s0 = await getState(page);
+  const starter = s0.planes.find((p) => p.id === 'plane-starter')!;
+  if (starter.status === 'flying' || starter.locationIcao !== HUB) {
+    // Fast-forward any leftover leg / repositioning flight (~20 s real time worst case at 1000×).
+    await setScale(page, SCALE);
+  }
+  if (starter.status === 'flying') {
+    await expect
+      .poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.status === 'available', {
+        timeout: 240_000,
+        message: 'waiting for an in-flight plane-starter to land',
+      })
+      .toBe(true);
+  }
+  if (starter.locationIcao !== HUB) {
+    // ISS-011: the landing above auto-slown the sim to 1× — re-set SCALE so the return leg
+    // fast-forwards instead of taking real-time hours.
+    await setScale(page, SCALE);
+    const res = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
+    expect(res.status()).toBe(200); // repositioning needs no package (v0.12.0 manual flight)
+    await expect
+      .poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.locationIcao === HUB, {
+        timeout: 240_000,
+        message: 'waiting for plane-starter to land back at the hub',
+      })
+      .toBe(true);
+  }
+}
+
+async function waitForAirportCount(page: Page): Promise<void> {
+  const countEl = page.getByTestId('airport-count');
+  await expect.poll(async () => {
+    const text = (await countEl.textContent()) ?? '';
+    const m = text.match(/(\d+)/);
+    return m ? parseInt(m[1], 10) : -1;
+  }).toBeGreaterThan(0);
+}
+
+// Rendered features of the given layers in the current viewport, [] until the map exists.
+function renderedFeatures(
+  page: Page,
+  layers: string[],
+): Promise<Array<{ type?: unknown; id?: unknown; properties?: unknown; geometry?: unknown }>> {
+  return page.evaluate((ls: string[]) => {
+    const m = (window as any).__flightMap;
+    if (!m) return [];
+    try {
+      // queryRenderedFeatures returns live GeoJSONFeature instances whose `geometry` is a lazy
+      // PROTOTYPE getter — Playwright's evaluate serialization copies only own enumerable props,
+      // so geometry silently vanishes across the page boundary (CI runs #69–#71: strict-equality
+      // timeouts → TypeError on f.geometry.coordinates → filter-found-nothing timeouts). Map to
+      // plain objects IN-PAGE so the getter is evaluated before serialization.
+      return (m.queryRenderedFeatures(undefined, { layers: ls }) as Array<{
+        type?: unknown;
+        id?: unknown;
+        properties?: unknown;
+        geometry?: unknown;
+      }>).map((f) => ({
+        type: f.type,
+        id: f.id,
+        properties: f.properties,
+        geometry: f.geometry,
+      }));
+    } catch {
+      return [];
+    }
+  }, layers);
+}
+
+// Move the pointer to a neutral element with no hover handler — leaves any hovered row/block.
+async function unhover(page: Page): Promise<void> {
+  await page.getByTestId('wallet-cash').hover();
+}
+
+// Fit the map so all given airports are in-viewport — queryRenderedFeatures only returns
+// features rendered inside the CURRENT viewport, and the default Frankfurt-centered view leaves
+// far endpoints (LEMD) off-screen even when they match a layer filter.
+async function fitToAirports(page: Page, icaos: string[]): Promise<void> {
+  const fc = (await (await page.request.get('/api/airports')).json()) as {
+    features: Array<{ properties: { icao: string; lat: number; lon: number } }>;
+  };
+  const points = icaos.map((icao) => {
+    const f = fc.features.find((x) => x.properties.icao === icao);
+    if (!f) throw new Error(`airport ${icao} not found in /api/airports`);
+    return [f.properties.lon, f.properties.lat] as [number, number];
+  });
+  await page.evaluate((pts: [number, number][]) => {
+    const m = (window as any).__flightMap;
+    if (!m) throw new Error('map not ready');
+    const lons = pts.map((p) => p[0]);
+    const lats = pts.map((p) => p[1]);
+    // duration 0 → instant camera jump, no animation to wait out.
+    m.fitBounds(
+      [
+        [Math.min(...lons), Math.min(...lats)],
+        [Math.max(...lons), Math.max(...lats)],
+      ],
+      { padding: 40, duration: 0 },
+    );
+  }, points);
+  // Give the renderer a beat after the camera jump before asserting on rendered features.
+  await page.waitForTimeout(300);
+}
+
+// [lon, lat] of an airport from the same /api/airports dataset the map draws its traces from.
+async function airportLonLat(page: Page, icao: string): Promise<[number, number]> {
+  const fc = (await (await page.request.get('/api/airports')).json()) as {
+    features: Array<{ properties: { icao: string; lat: number; lon: number } }>;
+  };
+  const f = fc.features.find((x) => x.properties.icao === icao);
+  if (!f) throw new Error(`airport ${icao} not found in /api/airports`);
+  return [f.properties.lon, f.properties.lat];
+}
+
+// ISS-022/025/027: the hover-route layer must hold the great-circle trace from origin to dest.
+// MapLibre stores GeoJSON geometry in per-tile INTEGER grids and clips long lines across tiles, so
+// queryRenderedFeatures returns ONE FEATURE PER TILE the line crosses (the 1420 km EDDF→LEMD leg is
+// 4 segments at z=4 / 5 at z=5) with coordinates quantized to the rendered zoom's grid — up to ~half
+// a grid step off (~0.001° observed at z≥4, ~0.02° worst case at z=0). A strict single-feature +
+// exact-coords comparison can therefore never match even when the line is drawn correctly (CI run #69:
+// all three hover-route timeouts while the trace was visibly rendered), so we accept any number of
+// segments and require some segment to START within EPS of `from` and some to END within EPS of `to`.
+// The true endpoints survive clipping verbatim in whichever tile contains them. (CI runs #69–#71:
+// features could arrive WITHOUT a usable geometry because Playwright's evaluate serialization drops
+// the lazy prototype getter — not MapLibre artifacts; renderedFeatures now maps to plain objects
+// in-page.) The helper still filters to real LineString segments and treats "none yet" as keep-polling
+// instead of throwing inside the poll callback. Call fitToAirports([from, to]) first — rendered
+// features are viewport-scoped.
+const HOVER_ROUTE_EPS_DEG = 0.05; // ~5 km: above worst-case quantization at any zoom, below the distance between any two EU airports
+
+async function expectHoverRoute(page: Page, fromIcao: string, toIcao: string): Promise<void> {
+  const [from, to] = await Promise.all([airportLonLat(page, fromIcao), airportLonLat(page, toIcao)]);
+  const near = (a: [number, number], b: [number, number]) =>
+    Math.abs(a[0] - b[0]) <= HOVER_ROUTE_EPS_DEG && Math.abs(a[1] - b[1]) <= HOVER_ROUTE_EPS_DEG;
+  await expect.poll(async () => {
+    const feats = (await renderedFeatures(page, ['hover-route'])) as Array<{ geometry?: { type: string; coordinates: [number, number][] } }>;
+    // Features are plain objects with in-page-evaluated geometry (see renderedFeatures). The filter
+    // guards against degenerate/zero-length clipped segments and keeps this poll callback total — a
+    // throw inside expect.poll fails the test instantly instead of retrying. "None yet" → keep polling.
+    const segs = feats.filter(
+      (f): f is { geometry: { type: 'LineString'; coordinates: [number, number][] } } =>
+        !!f.geometry && f.geometry.type === 'LineString' && Array.isArray(f.geometry.coordinates) && f.geometry.coordinates.length >= 2,
+    );
+    if (!segs.length) return false;
+    // The line may be clipped into several per-tile segments — check the endpoints across all of them.
+    const startsAtFrom = segs.some((f) => near(f.geometry.coordinates[0], from));
+    const endsAtTo = segs.some((f) => {
+      const c = f.geometry.coordinates;
+      return near(c[c.length - 1], to);
+    });
+    return startsAtFrom && endsAtTo;
+  }, { timeout: 15_000, message: `waiting for the hover-route line ${fromIcao} → ${toIcao}` }).toBe(true);
+}
+
+test('hovering a fleet row highlights the plane on the map', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal can take minutes after an interrupted run
+  await flyHomeViaApi(page); // deterministic: the starter sits at EDDF, inside the initial view
+
+  await page.goto('/');
+  await waitForAirportCount(page);
+
+  // Fleet rows are <li data-testid={`plane-${p.id}`}> and the server id already carries the "plane-"
+  // prefix (run #34: the real testid is plane-plane-starter) — derive it from /api/state, never hardcode.
+  const planes = (await getState(page)).planes;
+  const starterId = planes.find((p) => p.id.endsWith('starter'))?.id ?? (planes.length === 1 ? planes[0].id : undefined);
+  expect(starterId).toBeDefined();
+  const row = page.locator(`li[data-testid="plane-${starterId}"]`);
+  // The browser's /api/state polls can lag node-side requests right after a fresh page load
+  // (useGameState keeps loading=true until the first success → no fleet rows yet), so poll with
+  // diagnostics: on timeout the message compares what the NODE side sees vs what the BROWSER
+  // last polled, plus the fleet section's HTML — distinguishing server divergence from a render
+  // bug. (The value is returned, not thrown — expect.poll fails immediately on a callback throw
+  // instead of retrying.)
+  await expect
+    .poll(async () => {
+      if ((await row.count()) > 0 && (await row.isVisible())) return 'visible';
+      const body = await getState(page);
+      const browserSnap = await page.evaluate(() => (window as any).__flightLastSnapshot ?? null);
+      const fleetHtml = await page.evaluate(() => {
+        const el = document.querySelector('[data-testid="fleet-list"]');
+        if (el) return `fleet-list HTML: ${(el.outerHTML ?? '').slice(0, 300)}`;
+        const pane = document.querySelector<HTMLElement>('[data-testid="left-pane"]');
+        return `no fleet-list — left-pane text: ${(pane?.innerText ?? '').slice(0, 200)}`;
+      });
+      return (
+        `not visible — node /api/state planes=[${body.planes.map((p) => p.id).join(', ')}] cash=${body.account.cash}; ` +
+        `browser __flightLastSnapshot=${JSON.stringify(browserSnap)}; ${fleetHtml}`
+      );
+    }, { timeout: 30_000 })
+    .toBe('visible');
+
+  // No highlight before hovering (the layers start filtered to match nothing).
+  expect(await renderedFeatures(page, ['planes-highlight'])).toHaveLength(0);
+
+  await row.hover();
+  await expect.poll(async () => {
+    const feats = (await renderedFeatures(page, ['planes-highlight'])) as Array<{ properties: Record<string, unknown> }>;
+    return feats.length > 0 && feats[0].properties.id === starterId;
+  }, { timeout: 15_000, message: `waiting for the planes-highlight layer to show ${starterId}` }).toBe(true);
+
+  await unhover(page);
+  await expect.poll(async () => (await renderedFeatures(page, ['planes-highlight'])).length, {
+    timeout: 15_000,
+    message: 'waiting for the highlight to clear after mouseleave',
+  }).toBe(0);
+});
+
+test('hovering an open package highlights its endpoint airports', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal can take minutes after an interrupted run
+  await flyHomeViaApi(page);
+
+  const pkg = await createPackage(page, HUB, DEST);
+
+  await page.goto('/');
+  await waitForAirportCount(page);
+
+  const row = page.locator(`li[data-testid="open-package-${pkg.id}"]`);
+  await expect(row, 'the hook-created package appears in the list').toBeVisible({ timeout: 15_000 });
+
+  // Both endpoints must be in-viewport for queryRenderedFeatures to see them (LEMD is off-screen
+  // at the default Frankfurt-centered view).
+  await fitToAirports(page, [HUB, DEST]);
+
+  expect(await renderedFeatures(page, ['airports-highlight'])).toHaveLength(0);
+  expect(await renderedFeatures(page, ['airports-target-highlight'])).toHaveLength(0);
+
+  await row.hover();
+  await expect.poll(async () => {
+    const feats = (await renderedFeatures(page, ['airports-highlight'])) as Array<{ properties: Record<string, unknown> }>;
+    return JSON.stringify(feats.map((f) => f.properties.icao).sort());
+  }, { timeout: 15_000, message: 'waiting for the airports-highlight layer to show both endpoints' })
+    .toBe(JSON.stringify([HUB, DEST].sort()));
+
+  // ISS-022 (v0.22.0): the ENTIRE trace is drawn too — a great-circle line from origin to dest,
+  // not just the endpoint rings.
+  await expectHoverRoute(page, HUB, DEST);
+
+  // And the TARGET airport gets its own distinct-colored ring — only the destination, never the origin.
+  await expect.poll(async () => {
+    const feats = (await renderedFeatures(page, ['airports-target-highlight'])) as Array<{ properties: Record<string, unknown> }>;
+    return JSON.stringify(feats.map((f) => f.properties.icao).sort());
+  }, { timeout: 15_000, message: 'waiting for the airports-target-highlight layer to ring only the destination' })
+    .toBe(JSON.stringify([DEST]));
+
+  await unhover(page);
+  await expect.poll(async () => (await renderedFeatures(page, ['airports-highlight'])).length, {
+    timeout: 15_000,
+    message: 'waiting for the highlight to clear after mouseleave',
+  }).toBe(0);
+  await expect.poll(async () => (await renderedFeatures(page, ['hover-route'])).length, {
+    timeout: 15_000,
+    message: 'waiting for the hover route trace to clear after mouseleave',
+  }).toBe(0);
+  await expect.poll(async () => (await renderedFeatures(page, ['airports-target-highlight'])).length, {
+    timeout: 15_000,
+    message: 'waiting for the target ring to clear after mouseleave',
+  }).toBe(0);
+});
+
+test('hovering an on-board cargo row draws its trace and keeps the plane halo', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal can take minutes after an interrupted run
+  await flyHomeViaApi(page); // deterministic: the starter sits grounded at EDDF
+
+  // Load a package onto the grounded starter so it shows up in the On board section.
+  const pkg = await createPackage(page, HUB, DEST);
+  const load = await page.request.post(`/api/packages/${pkg.id}/load`, { data: { planeId: 'plane-starter' } });
+  expect(load.status()).toBe(200);
+
+  await page.goto('/');
+  await waitForAirportCount(page);
+
+  const row = page.locator(`[data-testid="onboard-package-${pkg.id}"]`);
+  await expect(row, 'the loaded package appears in the On board section').toBeVisible({ timeout: 15_000 });
+
+  // Both endpoints must be in-viewport for queryRenderedFeatures to see the trace.
+  await fitToAirports(page, [HUB, DEST]);
+
+  await row.hover();
+  // ISS-025 (v0.22.0): same full origin→dest trace as job-list rows…
+  await expectHoverRoute(page, HUB, DEST);
+  // …and the package's plane keeps its halo lit (the hover carries planeId).
+  await expect.poll(async () => {
+    const feats = (await renderedFeatures(page, ['planes-highlight'])) as Array<{ properties: Record<string, unknown> }>;
+    return feats.length > 0 && feats[0].properties.id === 'plane-starter';
+  }, { timeout: 15_000, message: 'waiting for the planes-highlight layer to show plane-starter' }).toBe(true);
+
+  await unhover(page);
+  await expect.poll(async () => (await renderedFeatures(page, ['hover-route'])).length, {
+    timeout: 15_000,
+    message: 'waiting for the hover route trace to clear after mouseleave',
+  }).toBe(0);
+  await expect.poll(async () => (await renderedFeatures(page, ['planes-highlight'])).length, {
+    timeout: 15_000,
+    message: 'waiting for the highlight to clear after mouseleave',
+  }).toBe(0);
+
+  // Leave the instance clean: abandon the loaded package so later specs start with an empty starter.
+  const res = await page.request.post(`/api/packages/${pkg.id}/abandon`);
+  expect(res.status()).toBe(200);
+});
+
+test('hovering the Relocate section previews the planned route and target airport', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal can take minutes after an interrupted run
+  await flyHomeViaApi(page); // deterministic: the starter sits grounded at EDDF
+
+  await page.goto('/');
+  await waitForAirportCount(page);
+
+  const section = page.getByTestId('relocate-section');
+  await expect(section, 'the Relocate section is visible').toBeVisible({ timeout: 15_000 });
+
+  // LeftPane fetches /api/airports on its own (separate from the map header count) — wait for
+  // the destination options to populate before selecting.
+  await expect(page.getByTestId('relocate-dest').locator(`option[value="${DEST}"]`)).toHaveCount(1, { timeout: 15_000 });
+
+  // Pick the starter + a known destination explicitly (the effective-selection defaults already do this).
+  await page.getByTestId('relocate-plane').selectOption('plane-starter');
+  await page.getByTestId('relocate-dest').selectOption(DEST);
+
+  // Both endpoints must be in-viewport for queryRenderedFeatures to see the trace.
+  await fitToAirports(page, [HUB, DEST]);
+
+  expect(await renderedFeatures(page, ['hover-route'])).toHaveLength(0);
+  expect(await renderedFeatures(page, ['airports-highlight'])).toHaveLength(0);
+  expect(await renderedFeatures(page, ['airports-target-highlight'])).toHaveLength(0);
+
+  // ISS-027 (v0.22.0): hovering the panel with a plane + destination selected previews the flight —
+  // dashed trace from the plane's airport to the destination…
+  await section.hover();
+  await expectHoverRoute(page, HUB, DEST);
+  // …and rings ONLY the target airport (the origin stays unmarked).
+  await expect.poll(async () => {
+    const feats = (await renderedFeatures(page, ['airports-highlight'])) as Array<{ properties: Record<string, unknown> }>;
+    return JSON.stringify(feats.map((f) => f.properties.icao).sort());
+  }, { timeout: 15_000, message: 'waiting for the airports-highlight layer to ring only the target' })
+    .toBe(JSON.stringify([DEST]));
+  // …plus the destination's own distinct-colored ring (ISS-022) — same single icao.
+  await expect.poll(async () => {
+    const feats = (await renderedFeatures(page, ['airports-target-highlight'])) as Array<{ properties: Record<string, unknown> }>;
+    return JSON.stringify(feats.map((f) => f.properties.icao).sort());
+  }, { timeout: 15_000, message: 'waiting for the airports-target-highlight layer to ring only the target' })
+    .toBe(JSON.stringify([DEST]));
+
+  await unhover(page);
+  await expect.poll(async () => (await renderedFeatures(page, ['hover-route'])).length, {
+    timeout: 15_000,
+    message: 'waiting for the hover route trace to clear after mouseleave',
+  }).toBe(0);
+  await expect.poll(async () => (await renderedFeatures(page, ['airports-highlight'])).length, {
+    timeout: 15_000,
+    message: 'waiting for the highlight to clear after mouseleave',
+  }).toBe(0);
+  await expect.poll(async () => (await renderedFeatures(page, ['airports-target-highlight'])).length, {
+    timeout: 15_000,
+    message: 'waiting for the target ring to clear after mouseleave',
+  }).toBe(0);
+});
+
+test('hovering an on-board block of a flying plane highlights its route', async ({ page }) => {
+  test.setTimeout(600_000); // self-heal + one flight at scale 1000 + fly-home cleanup
+  await flyHomeViaApi(page);
+
+  // Full tank before departure — the EDDF↔LEMD round trip burns ~4970 L of the 6300 L tank.
+  const refuel = await page.request.post('/api/planes/plane-starter/refuel');
+  expect(refuel.status()).toBe(200);
+
+  await page.goto('/');
+  await waitForAirportCount(page);
+
+  // Load + fly via the API (same pattern as e2e/map-interactions.spec.ts), then speed up.
+  const pkg = await createPackage(page, HUB, DEST);
+  const load = await page.request.post(`/api/packages/${pkg.id}/load`, { data: { planeId: 'plane-starter' } });
+  expect(load.status()).toBe(200);
+  const fly = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: DEST } });
+  expect(fly.status()).toBe(200);
+  await setScale(page, SCALE);
+
+  // The on-board block shows the plane in flight once a snapshot with status 'flying' lands.
+  const block = page.getByTestId('onboard-plane-starter');
+  await expect(block).toContainText(/in flight/i, { timeout: 15_000 });
+
+  // Freeze mid-flight so the ~10 s leg can't land under us while we assert (same pattern as
+  // e2e/map-interactions.spec.ts' marker click): the route line stays drawn while paused.
+  await postSim(page, { paused: true });
+
+  await block.hover();
+  await expect.poll(async () => {
+    const feats = (await renderedFeatures(page, ['routes-highlight'])) as Array<{ properties: Record<string, unknown> }>;
+    return feats.length > 0 && feats[0].properties.planeId === 'plane-starter';
+  }, { timeout: 15_000, message: 'waiting for the routes-highlight layer to show the plane-starter leg' }).toBe(true);
+
+  await unhover(page);
+  await expect.poll(async () => (await renderedFeatures(page, ['routes-highlight'])).length, {
+    timeout: 15_000,
+    message: 'waiting for the highlight to clear after mouseleave',
+  }).toBe(0);
+
+  // Resume and fast-forward to arrival, then fly home so the live instance stays in its
+  // onboarding state (starter grounded at EDDF) for the other specs.
+  await postSim(page, { timeScale: SCALE, paused: false });
+  await expect
+    .poll(async () => {
+      const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter');
+      return !!p && p.status === 'available' && p.locationIcao === DEST;
+    }, { timeout: 120_000, message: `waiting for plane-starter to land at ${DEST}` })
+    .toBe(true);
+
+  // ISS-011: the arrival above auto-slown the sim to 1×, so re-set SCALE for this leg.
+  await setScale(page, SCALE);
+  const home = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
+  expect(home.status()).toBe(200);
+  await expect
+    .poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.locationIcao === HUB, {
+      timeout: 120_000,
+      message: 'waiting for plane-starter to land back at the hub',
+    })
+    .toBe(true);
+});
@@ -5,14 +5,16 @@ import { test, expect, type Page } from '@playwright/test';
 // deterministic generated weather), plane markers whose positions come from the
 // /api/state polls, each FLYING plane's current leg as a route line (origin →
 // dest_icao; grounded planes draw nothing), and the plane status popup. Packages
-// are created on a known EDDF→EDDV route via POST /api/test/create-package
+// are created on a known EDDF→LEMD route via POST /api/test/create-package
 // (FLIGHT_TEST_HOOKS=1).

 const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts
-// Hannover — ~282 km from EDDF → ~33 min game time ≈ 33 s at scale 60, a comfortable
-// window for the click assertions below (the nearest airport would land too fast).
-const DEST = 'EDDV';
-const SCALE = 60;
+// Madrid–Barajas — ~1420 km from EDDF → ~2.8 h game time ≈ 10 s at scale 1000, a comfortable
+// window for the mid-flight click assertions below (at 1000× even Hannover's 33-min leg would
+// land in ~2 s — shorter than the map poll + click pipeline). Round-trip burn (~4970 L) fits
+// the 6300 L tank, so a full-tank departure always makes it home.
+const DEST = 'LEMD';
+const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top)

 interface PlaneState {
  id: string;
@@ -91,7 +93,7 @@ async function createPackage(page: Page, fromIcao: string, toIcao: string): Prom
 }

 // Load a package onto plane-starter and fly it from → to via the API, then poll at
-// scale 60 until the plane lands at `to`. Same pattern as e2e/actions.spec.ts.
+// scale 1000 until the plane lands at `to`. Same pattern as e2e/actions.spec.ts.
 async function loadAndFly(page: Page, fromIcao: string, toIcao: string): Promise<PackageState> {
  const pkg = await createPackage(page, fromIcao, toIcao);
  const load = await page.request.post(`/api/packages/${pkg.id}/load`, { data: { planeId: 'plane-starter' } });
@@ -170,8 +172,8 @@ test('airport popup shows name, ICAO, local time and generated weather', async (
  expect(wText).toMatch(/\d+ kt/); // wind speed in knots
 });

-test('plane markers move while flying, the current leg draws a route line, and the plane popup shows status + route', async ({ page }) => {
-  test.setTimeout(600_000); // self-heal from a far airport (~4 min worst case at 60×) + main flight + cleanup
+test('plane markers move while flying and the plane popup shows status + route', async ({ page }) => {
+  test.setTimeout(600_000); // self-heal from a far airport (~20 s worst case at 1000×) + main flight + cleanup

  await page.goto('/');
  await waitForAirportCount(page);
@@ -195,6 +197,11 @@ test('plane markers move while flying, the current leg draws a route line, and t
    await loadAndFly(page, starterLoc, HUB);
  }

+  // Full tank before departure — the EDDF↔LEMD round trip burns ~4970 L of the 6300 L tank,
+  // so a partially drained plane left by an earlier spec could not make it home.
+  const refuel = await page.request.post('/api/planes/plane-starter/refuel');
+  expect(refuel.status()).toBe(200);
+
  // 1) Load the hook-created package — a GROUNDED plane draws no route line yet.
  const pkg = await createPackage(page, HUB, DEST);
  const load = await page.request.post(`/api/packages/${pkg.id}/load`, { data: { planeId: 'plane-starter' } });
@@ -238,35 +245,56 @@ test('plane markers move while flying, the current leg draws a route line, and t
  const p2 = (await getState(page)).planes.find((p) => p.id === 'plane-starter')!;
  expect(haversineKm(p1.lat, p1.lon, p2.lat, p2.lon)).toBeGreaterThan(0);

-  // 4) The route line for this flight exists in the routes source (v0.12.0: one line
-  // per flying plane's current leg, keyed by planeId) and is a CURVED arc — >2
-  // coordinates along the great circle, not a straight two-point chord (v0.12.2).
+  // (No map-side assertion on the drawn leg here: MapLibre's querySourceFeatures returns
+  // tile-simplified geometry at low zoom, so coordinate counts from it are unreliable —
+  // the v0.12.2 curved-arc check failed in CI and live while the arc rendered correctly.
+  // The arc itself stays covered by unit tests: lib/mapData.test.ts.)
+
+  // 4) Click the flying plane → status popup with model, status, fuel and the leg.
+  // Freeze the sim so the click can't miss a fast-moving marker: at scale 1000 the rendered
+  // marker lags our fresh /api/state fetch by up to one map poll (~1 s) — tens of px of drift
+  // on this leg. Pausing makes the position static; we resume right after the popup checks.
+  await postSim(page, { paused: true });
+  let prevPos: { lat: number; lon: number } | null = null;
  await expect
    .poll(async () => {
-      const feats = (await sourceFeatures(page, 'routes')) as Array<{
-        properties: Record<string, unknown>;
-        geometry?: { type: string; coordinates: [number, number][] };
-      }>;
-      const f = feats.find((x) => x.properties.planeId === 'plane-starter');
-      return !!f && (f.geometry?.coordinates.length ?? 0) > 2;
-    }, { timeout: 15_000, message: 'waiting for the curved route line in the routes source' })
+      const p = (await getState(page)).planes.find((x) => x.id === 'plane-starter');
+      if (!p || p.status !== 'flying') return false;
+      if (prevPos && prevPos.lat === p.lat && prevPos.lon === p.lon) return true;
+      prevPos = { lat: p.lat, lon: p.lon };
+      return false;
+    }, { timeout: 15_000, message: 'waiting for the paused clock to freeze the plane position' })
    .toBe(true);

-  // 5) Click the flying plane → status popup with model, status, fuel and the leg.
-  // Fetch + project in one evaluate so the click lands on a fresh position (the
-  // marker drifts only ~1 px/s of screen space at scale 60).
+  // Click the RENDERED marker position, not a fresh /api/state fetch. With the sim paused
+  // above the server's analytic position is static — but the map renders from its own ~1 s
+  // poll, so right after the freeze confirmation the last rendered frame can still be up to
+  // one poll interval stale (tens of px at scale 1000 on this leg) and a click projected
+  // from a fresh fetch misses the small circle layer (CI run #37). Poll for the plane's
+  // rendered feature instead and project ITS coordinates — exactly what the map draws.
+  // Find + project in one evaluate so nothing can change between the two steps.
  const pt = await page.evaluate(async () => {
    const m = (window as any).__flightMap;
    if (!m) return null;
-    const res = await fetch('/api/state', { cache: 'no-store' });
-    const body = (await res.json()) as StateBody;
-    const p = body.planes.find((x) => x.id === 'plane-starter');
-    if (!p || p.status !== 'flying') return null;
-    const projected = m.project([p.lon, p.lat]);
-    const rect = m.getContainer().getBoundingClientRect();
-    return { x: rect.left + projected.x, y: rect.top + projected.y };
+    const deadline = Date.now() + 5_000;
+    for (;;) {
+      let feats: Array<{ properties?: Record<string, unknown>; geometry?: { coordinates: number[] } }> = [];
+      try {
+        feats = m.queryRenderedFeatures(undefined, { layers: ['planes-flying', 'planes-grounded'] });
+      } catch {
+        // map not ready yet — keep polling
+      }
+      const f = feats.find((x) => x.properties?.id === 'plane-starter');
+      if (f && f.geometry) {
+        const projected = m.project(f.geometry.coordinates);
+        const rect = m.getContainer().getBoundingClientRect();
+        return { x: rect.left + projected.x, y: rect.top + projected.y };
+      }
+      if (Date.now() >= deadline) return null;
+      await new Promise((r) => setTimeout(r, 100));
+    }
  });
-  expect(pt).not.toBeNull(); // the flight (~33 s at scale 60) is still in progress here
+  expect(pt, 'plane marker not rendered after pause').not.toBeNull();

  await page.mouse.click(pt!.x, pt!.y);
  const popup = page.getByTestId('plane-popup');
@@ -279,7 +307,10 @@ test('plane markers move while flying, the current leg draws a route line, and t
  // The popup's route line is the plane's own leg: origin name → destination name.
  await expect(page.getByTestId('plane-route')).toContainText(`${live.locationName} → ${live.destName}`);

-  // 6) Let the flight finish, then fly home so the live instance stays in its
+  // Resume before step 5 — the landing wait needs a running clock.
+  await postSim(page, { timeScale: SCALE, paused: false });
+
+  // 5) Let the flight finish, then fly home so the live instance stays in its
  // onboarding state (starter grounded at EDDF) for the other specs. The loaded
  // package is delivered on arrival (in-deadline).
  await expect
@@ -4,6 +4,8 @@ import { test, expect, type Page } from '@playwright/test';
 // The panes render from the shell's single /api/state poll (lib/useGameState.ts); time
 // controls POST to /api/sim and refetch immediately, so UI assertions settle within a tick.

+const SCALE = 1000; // fastest sim speed — top of the v0.14.0 ladder (same convention as e2e/sim.spec.ts)
+
 interface SimState {
  clockMs: number;
  timeScale: number;
@@ -67,9 +69,15 @@ test('left pane renders wallet, reputation and the starter fleet at Frankfurt',

  // Sim clock renders (UTC wall-clock of the game time).
  await expect(page.getByTestId('sim-clock')).toContainText(/UTC/);
+
+  // ISS-021 (v0.20.0): the On board section moved to the left pane (between Fleet and Time) —
+  // its heading renders here…
+  await expect(page.getByTestId('left-pane').getByRole('heading', { name: 'On board', exact: true })).toBeVisible();
+  // …and no longer in the right pane.
+  await expect(page.getByTestId('right-pane').getByRole('heading', { name: 'On board', exact: true })).toHaveCount(0);
 });

-test('time controls: pause freezes the sim and the power-of-two slider sets timeScale', async ({ page }) => {
+test('time controls: pause freezes the sim and the ladder slider sets timeScale', async ({ page }) => {
  await page.goto('/');
  const pauseBtn = page.getByTestId('pause-toggle');
  await expect(pauseBtn).toBeVisible({ timeout: 15_000 });
@@ -80,13 +88,13 @@ test('time controls: pause freezes the sim and the power-of-two slider sets time
  // …and in the pane itself (the refetch after POST flips the button to Resume).
  await expect(pauseBtn).toHaveText('Resume');

-  // Scale via the power-of-two slider. End jumps to max (t=1 → 64×): the label updates
+  // Scale via the ladder slider. End jumps to max (t=1 → 1000×): the label updates
  // optimistically on input, and release flushes the debounced POST immediately.
  const slider = page.getByTestId('time-scale-slider');
  await slider.focus();
  await page.keyboard.press('End');
-  await expect(page.getByTestId('time-scale-value')).toHaveText('64×', { timeout: 10_000 });
-  await expect.poll(async () => (await getState(page)).simState.timeScale, { timeout: 10_000 }).toBe(64);
+  await expect(page.getByTestId('time-scale-value')).toHaveText('1000×', { timeout: 10_000 });
+  await expect.poll(async () => (await getState(page)).simState.timeScale, { timeout: 10_000 }).toBe(1000);

  // Home jumps to min (t=0 → 1×).
  await page.keyboard.press('Home');
@@ -104,6 +112,40 @@ test('time controls: pause freezes the sim and the power-of-two slider sets time
  expect(after.simState.paused).toBe(false);
 });

+test('sim clock ticks smoothly between polls — seconds advance without waiting for a snapshot (ISS-007)', async ({ page }) => {
+  await page.goto('/');
+  const clock = page.getByTestId('sim-clock');
+  await expect(clock).toBeVisible({ timeout: 15_000 });
+
+  // Fastest scale so game seconds move visibly inside the sampling window.
+  const post = await page.request.post('/api/sim', { data: { timeScale: SCALE, paused: false } });
+  expect(post.status()).toBe(200);
+
+  // "YYYY-MM-DD HH:MM:SS UTC" → epoch ms (UTC). While running there is no "(paused)" suffix.
+  const sample = async () => {
+    const text = ((await clock.textContent()) ?? '').trim();
+    expect(text, `clock format: ${text}`).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} UTC$/);
+    return Date.parse(text.replace(' ', 'T').replace(' UTC', 'Z'));
+  };
+
+  // Three samples ~1.3 s apart real time: at scale 1000 each gap is ≈1300 game seconds, so the
+  // displayed clock must strictly advance between CONSECUTIVE samples — with the old poll-only
+  // rendering a sample pair could straddle zero snapshot updates and show no change at all.
+  const t0 = await sample();
+  await new Promise((r) => setTimeout(r, 1_300));
+  const t1 = await sample();
+  await new Promise((r) => setTimeout(r, 1_300));
+  const t2 = await sample();
+
+  expect(t1).toBeGreaterThan(t0);
+  expect(t2).toBeGreaterThan(t1);
+  // Sanity: ~2.6 s real × 1000 ≈ 2.6 M game ms — generous bounds keep slow CI boxes safe while
+  // still catching a frozen or wildly mis-scaled clock.
+  const total = t2 - t0;
+  expect(total).toBeGreaterThanOrEqual(1_000_000);
+  expect(total).toBeLessThanOrEqual(6_000_000);
+});
+
 test('slider commit keeps the chosen scale on screen until confirmed — no snap-back (ISS-001)', async ({ page }) => {
  test.setTimeout(60_000);
  await page.goto('/');
@@ -116,19 +158,19 @@ test('slider commit keeps the chosen scale on screen until confirmed — no snap

  // …and sample the displayed value rapidly across the whole commit→confirm window. With the
  // ISS-001 fix the optimistic value stays until a snapshot confirms it, so EVERY sample must
-  // be '64×' — never snapping back to the previous scale for one poll cycle (the old bug).
+  // be '1000×' — never snapping back to the previous scale for one poll cycle (the old bug).
  const seen: string[] = [];
  for (let i = 0; i < 30; i++) {
    seen.push(((await page.getByTestId('time-scale-value').textContent()) ?? '').trim());
    await new Promise((r) => setTimeout(r, 25));
  }
  expect(
-    seen.every((v) => v === '64×'),
-    `displayed scale must stay 64× during the commit window (saw: ${[...new Set(seen)].join(', ')})`,
+    seen.every((v) => v === '1000×'),
+    `displayed scale must stay 1000× during the commit window (saw: ${[...new Set(seen)].join(', ')})`,
  ).toBe(true);

  // …and the server confirms it.
-  await expect.poll(async () => (await getState(page)).simState.timeScale, { timeout: 10_000 }).toBe(64);
+  await expect.poll(async () => (await getState(page)).simState.timeScale, { timeout: 10_000 }).toBe(1000);

  // Restore to min for later tests (afterEach restores scale anyway).
  await page.keyboard.press('Home');
@@ -0,0 +1,189 @@
+import type { Page } from '@playwright/test';
+import { expect, test } from '@playwright/test';
+
+// v0.18.0 — ISS-010: relocating a GROUNDED (empty) plane to any airport against the live origin.
+// Two UI surfaces drive the EXISTING POST /api/planes/{id}/fly endpoint (pure repositioning has
+// been allowed since v0.12.0 — no API change): the left-pane Relocate section (ISS-023, v0.21.0)
+// (relocate-plane / relocate-dest / relocate-go) and the Relocate row inside the airport popup on
+// the map (airport-popup-plane / airport-popup-relocate). Marker-size regression is covered by
+// the existing e2e/map.spec.ts click tests, not here.
+
+const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top) — keeps cleanup flights to seconds of real time
+const HUB = 'EDDF'; // Frankfurt Main — the seeded starter plane's home base (lib/game/seed.ts)
+// LFRS Nantes Atlantique — same isolated marker as e2e/map.spec.ts: its nearest neighbour is ~78 px
+// away at the initial zoom, so a click on its projected center cannot hit another circle.
+const POPUP_AIRPORT = { icao: 'LFRS', lon: -1.61073, lat: 47.153198 };
+
+interface StateBody {
+  planes: Array<{ id: string; status: string; locationIcao: string; destIcao: string | null }>;
+}
+
+async function getState(page: Page): Promise<StateBody> {
+  const res = await page.request.get('/api/state');
+  expect(res.ok()).toBeTruthy();
+  return (await res.json()) as StateBody;
+}
+
+async function postSim(page: Page, body: Record<string, unknown>): Promise<void> {
+  const res = await page.request.post('/api/sim', { data: body });
+  expect(res.ok()).toBeTruthy();
+}
+
+// Set the time scale and VERIFY from the response that it stuck — if something external ever
+// resets the live instance's controls mid-test, fail loudly here instead of timing out later.
+async function setScale(page: Page, scale: number): Promise<void> {
+  const res = await page.request.post('/api/sim', { data: { timeScale: scale } });
+  expect(res.status()).toBe(200);
+  const body = (await res.json()) as { timeScale: number };
+  expect(body.timeScale, `timeScale should be ${scale} after POST /api/sim`).toBe(scale);
+}
+
+// Closest airport to the hub from /api/airports → shortest possible leg (fuel trivial).
+async function nearestToHub(page: Page): Promise<{ icao: string }> {
+  const res = await page.request.get('/api/airports');
+  expect(res.ok()).toBeTruthy();
+  const fc = (await res.json()) as { features: Array<{ properties: { icao: string; lat: number; lon: number } }> };
+  const hub = fc.features.find((f) => f.properties.icao === HUB)!.properties;
+  let nearest = fc.features.filter((f) => f.properties.icao !== HUB)[0].properties;
+  for (const f of fc.features) {
+    if (f.properties.icao === HUB) continue;
+    const d = Math.hypot(f.properties.lat - hub.lat, f.properties.lon - hub.lon);
+    const dn = Math.hypot(nearest.lat - hub.lat, nearest.lon - hub.lon);
+    if (d < dn) nearest = f.properties;
+  }
+  return { icao: nearest.icao };
+}
+
+// Self-heal helper (same pattern as e2e/actions.spec.ts): let any in-flight leg finish and
+// reposition plane-starter home via the API — repositioning needs no package (v0.12.0 manual
+// flight) — so every test starts from the canonical state even after an interrupted previous run.
+async function flyHomeViaApi(page: Page): Promise<void> {
+  let s = await getState(page);
+  let plane = s.planes.find((p) => p.id === 'plane-starter')!;
+  if (plane.status === 'flying' || plane.locationIcao !== HUB) {
+    // Fast-forward any leftover leg / repositioning flight (~20 s real time worst case at 1000×).
+    await setScale(page, SCALE);
+  }
+  if (plane.status === 'flying') {
+    // While flying, locationIcao stays at the DEPARTURE airport — re-read state after landing
+    // before deciding whether a repositioning flight is needed.
+    await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.status), { timeout: 240_000 }).toBe('available');
+    s = await getState(page);
+    plane = s.planes.find((p) => p.id === 'plane-starter')!;
+  }
+  if (plane.locationIcao !== HUB) {
+    // ISS-011: the landing above auto-slown the sim to 1× — re-set SCALE so the return leg
+    // fast-forwards instead of taking real-time hours.
+    await setScale(page, SCALE);
+    const res = await page.request.post(`/api/planes/${plane.id}/fly`, { data: { destIcao: HUB } });
+    expect(res.ok()).toBeTruthy(); // repositioning needs no package (v0.12.0 manual flight)
+    await expect.poll(async () => ((await getState(page)).planes.find((p) => p.id === 'plane-starter')!.locationIcao), { timeout: 240_000 }).toBe(HUB);
+  }
+}
+
+// Self-heal in CLEANUP (afterEach): the tests deliberately leave plane-starter mid-flight, so
+// fast-forward + reposition home here; then restore scale=1 / unpaused for later specs.
+test.afterEach(async ({ page }) => {
+  await flyHomeViaApi(page);
+  await postSim(page, { timeScale: 1, paused: false });
+});
+
+test.describe.configure({ mode: 'serial' }); // shared live DB — order matters within this file
+
+test('left pane Relocate section relocates a grounded plane', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal (worst case ~20 s at 1000×) + one short leg
+  await flyHomeViaApi(page);
+
+  // Full tank before departure — a partially drained plane left by an earlier spec could not
+  // afford the cleanup round trip.
+  const refuel = await page.request.post('/api/planes/plane-starter/refuel');
+  expect(refuel.ok()).toBeTruthy();
+
+  const nearest = await nearestToHub(page);
+
+  await page.goto('/');
+  const planeSel = page.getByTestId('relocate-plane');
+  await expect(planeSel).toBeVisible({ timeout: 15_000 }); // pane renders once the first snapshot lands
+  await planeSel.selectOption('plane-starter');
+
+  // Destination options come from the one-time /api/airports fetch (sorted by name) — selectOption
+  // waits until the matching option exists, so this doubles as the load wait.
+  const destSel = page.getByTestId('relocate-dest');
+  await destSel.selectOption(nearest.icao);
+
+  const goBtn = page.getByTestId('relocate-go');
+  await expect(goBtn).toBeEnabled();
+  await goBtn.click();
+
+  // The click fires the fly POST asynchronously (runAction is fire-and-forget from the test's view),
+  // so poll until it took effect on the server.
+  await expect.poll(async () => {
+    const b = await getState(page);
+    const p = b.planes.find((x) => x.id === 'plane-starter')!;
+    return p.status === 'flying' && p.destIcao === nearest.icao;
+  }, { timeout: 15_000, message: 'waiting for the relocate click to take effect (status "flying" + dest set)' }).toBe(true);
+});
+
+test('airport popup offers Relocate options for grounded planes', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal (worst case ~20 s at 1000×) + one leg to LFRS
+  await flyHomeViaApi(page);
+
+  const refuel = await page.request.post('/api/planes/plane-starter/refuel');
+  expect(refuel.ok()).toBeTruthy();
+
+  await page.goto('/');
+
+  // Wait until the airport count renders (airports loaded) and the map has a snapshot containing
+  // the plane — the popup's Relocate row is built from that same latest snapshot.
+  const countEl = page.getByTestId('airport-count');
+  await expect.poll(async () => {
+    const text = (await countEl.textContent()) ?? '';
+    const m = text.match(/(\d+)/);
+    return m ? parseInt(m[1], 10) : -1;
+  }, { timeout: 15_000 }).toBeGreaterThan(0);
+  await expect.poll(async () =>
+    page.evaluate(() => {
+      const m = (window as any).__flightMap;
+      if (!m || !m.getSource('planes')) return false;
+      try {
+        return m.querySourceFeatures('planes').some((f: { properties?: Record<string, unknown> }) => f.properties?.id === 'plane-starter');
+      } catch {
+        return false; // source not ready yet — keep polling
+      }
+    }),
+    { timeout: 15_000 },
+  ).toBe(true);
+
+  // Click the LFRS marker (projected center — same pattern as e2e/map.spec.ts). The constant is
+  // passed AS AN ARGUMENT: the evaluate callback runs in the browser, where Node-scope values don't exist.
+  const pt = await page.evaluate(({ lon, lat }) => {
+    const map = (window as any).__flightMap;
+    const p = map.project([lon, lat]);
+    const rect = map.getContainer().getBoundingClientRect();
+    return { x: rect.left + p.x, y: rect.top + p.y };
+  }, POPUP_AIRPORT);
+  await page.mouse.click(pt.x, pt.y);
+
+  const popup = page.getByTestId('airport-popup');
+  await expect(popup).toBeVisible();
+  await expect(popup).toContainText(POPUP_AIRPORT.icao);
+
+  // The Relocate row: a select of grounded planes + the button (disabled until one is picked).
+  const planeSel = page.getByTestId('airport-popup-plane');
+  await expect(planeSel).toBeVisible();
+  // Target THE PLANE OPTION specifically — locator('option') also matches the placeholder and
+  // trips strict mode (CI run #51).
+  await expect(planeSel.locator('option[value="plane-starter"]')).toHaveText(/ATR 72-600 — EDDF/);
+  const goBtn = page.getByTestId('airport-popup-relocate');
+  await expect(goBtn).toBeDisabled(); // placeholder selected
+
+  await planeSel.selectOption('plane-starter');
+  await expect(goBtn).toBeEnabled();
+  await goBtn.click();
+
+  await expect.poll(async () => {
+    const b = await getState(page);
+    const p = b.planes.find((x) => x.id === 'plane-starter')!;
+    return p.status === 'flying' && p.destIcao === POPUP_AIRPORT.icao;
+  }, { timeout: 15_000, message: 'waiting for the popup relocate click to take effect (status "flying" + dest set)' }).toBe(true);
+});
@@ -2,13 +2,14 @@ import type { Page } from '@playwright/test';
 import { expect, test } from '@playwright/test';

 // v0.12.0 — right Jobs & Market pane against the live origin: open packages render with
-// names/reward/deadline and Load (UI click) binds one to the starter; the on-board list shows
-// loaded packages with fly-to-destination + abandon buttons (penalty preview from the same
+// names/reward/deadline and Load (UI click) binds one to the starter; the on-board list
+// (moved to the left pane in v0.20.0, ISS-021) shows loaded packages with fly-to-destination +
+// abandon buttons (penalty preview from the same
 // formula as the server); flying planes show their current leg; market buy/sell/refuel previews
 // match the catalog + economy constants exposed in /api/state. Packages are created via
 // POST /api/test/create-package (FLIGHT_TEST_HOOKS=1), same pattern as e2e/actions.spec.ts.

-const SCALE = 60;
+const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top) — keeps flights to seconds of real time
 const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts

 interface PlaneState {
@@ -38,6 +39,7 @@ interface CatalogEntry {
  price: number;
  maxFuel: number;
  burnPerKm: number;
+  emptyWeightKg: number; // v0.16.0 weighted burn input
  speedKmh: number;
  capacity: number;
 }
@@ -98,7 +100,7 @@ function penaltyFor(reward: number, createdSimTime: number, deadlineSimTime: num
  return Math.round(reward * (0.15 + 0.45 * frac) * 100) / 100;
 }

-// Closest airport to EDDF from /api/airports → shortest possible arrival time at scale 60.
+// Closest airport to EDDF from /api/airports → shortest possible arrival time at scale 1000.
 async function nearestToHub(page: Page): Promise<{ icao: string; lat: number; lon: number }> {
  const fc = (await (await page.request.get('/api/airports')).json()) as {
    features: Array<{ properties: { icao: string; lat: number; lon: number } }>;
@@ -114,6 +116,39 @@ async function nearestToHub(page: Page): Promise<{ icao: string; lat: number; lo
  return nearest;
 }

+// Farthest airport from EDDF whose leg still FITS A FULL TANK — the longest flyable leg (v0.16.0
+// refuel-for-flight test). The dataset's absolute farthest can exceed the aircraft's range (UNNT is
+// ~4803 km out and needs ~6955 L > the 6300 L tank), so a full-tank fly there would rightly 409;
+// this test wants a long-but-flyable leg instead.
+async function farthestFlyableToHub(
+  page: Page,
+  entry: CatalogEntry,
+): Promise<{ icao: string; lat: number; lon: number; hubLat: number; hubLon: number }> {
+  const fc = (await (await page.request.get('/api/airports')).json()) as {
+    features: Array<{ properties: { icao: string; lat: number; lon: number } }>;
+  };
+  const hub = fc.features.find((f) => f.properties.icao === HUB)!.properties;
+  let farthest: { icao: string; lat: number; lon: number; d: number } | null = null;
+  for (const f of fc.features) {
+    if (f.properties.icao === HUB) continue;
+    const d = haversineKm(hub.lat, hub.lon, f.properties.lat, f.properties.lon);
+    if (requiredFuelFor(entry.burnPerKm, entry.emptyWeightKg, entry.maxFuel, d) > entry.maxFuel) continue; // beyond range
+    if (!farthest || d > farthest.d) {
+      farthest = { icao: f.properties.icao, lat: f.properties.lat, lon: f.properties.lon, d };
+    }
+  }
+  if (!farthest) throw new Error('no full-tank-flyable airport found in the dataset');
+  return { ...farthest, hubLat: hub.lat, hubLon: hub.lon };
+}
+
+// Mirrors lib/sim/movement.ts (v0.16.0): fuel required to cover distanceKm arriving empty —
+// closed form of the weight-proportional burn model, k calibrated so a full tank burns burnPerKm.
+const FUEL_DENSITY_KG_PER_L = 0.8; // must match FUEL_DENSITY_KG_PER_L in lib/sim/movement.ts
+function requiredFuelFor(burnPerKm: number, emptyWeightKg: number, maxFuel: number, distanceKm: number): number {
+  const k = burnPerKm / (emptyWeightKg + FUEL_DENSITY_KG_PER_L * maxFuel);
+  return (emptyWeightKg / FUEL_DENSITY_KG_PER_L) * (Math.exp(k * FUEL_DENSITY_KG_PER_L * distanceKm) - 1);
+}
+
 // Test hook (FLIGHT_TEST_HOOKS=1): create an open package on a known route.
 async function createPackage(page: Page, fromIcao: string, toIcao: string, deadlineOffsetMs?: number): Promise<PackageState> {
  const created = await page.request.post('/api/test/create-package', {
@@ -128,7 +163,7 @@ async function flyHomeViaApi(page: Page): Promise<void> {
  const s0 = await getState(page);
  const starter = s0.planes.find((p) => p.id === 'plane-starter')!;
  if (starter.status === 'flying' || starter.locationIcao !== HUB) {
-    // Fast-forward any leftover leg / repositioning flight (~3 min real time worst case at 60×).
+    // Fast-forward any leftover leg / repositioning flight (~20 s real time worst case at 1000×).
    await setScale(page, SCALE);
  }
  if (starter.status === 'flying') {
@@ -140,6 +175,9 @@ async function flyHomeViaApi(page: Page): Promise<void> {
      .toBe(true);
  }
  if (starter.locationIcao !== HUB) {
+    // ISS-011: the landing above auto-slown the sim to 1× — re-set SCALE so the return leg
+    // fast-forwards instead of taking real-time hours.
+    await setScale(page, SCALE);
    const res = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
    expect(res.status()).toBe(200); // repositioning needs no package (v0.12.0 manual flight)
    await expect
@@ -197,7 +235,7 @@ test('Load is disabled when no plane sits at the package origin', async ({ page
 });

 test('on-board list: fly-to-destination + abandon with penalty preview; flying planes show their leg', async ({ page }) => {
-  test.setTimeout(240_000); // one short flight at scale 60 plus UI steps — typical run well under three minutes
+  test.setTimeout(240_000); // one short flight at scale 1000 (seconds of real time) plus UI steps
  await flyHomeViaApi(page);

  const nearest = await nearestToHub(page);
@@ -241,7 +279,7 @@ test('on-board list: fly-to-destination + abandon with penalty preview; flying p
      const b = await getState(page);
      const p = b.planes.find((x) => x.id === 'plane-starter');
      return !!p && p.status === 'available' && p.locationIcao === nearest.icao;
-    }, { timeout: 120_000, message: `waiting for arrival at ${nearest.icao} (scale 60)` })
+    }, { timeout: 120_000, message: `waiting for arrival at ${nearest.icao} (scale 1000)` })
    .toBe(true);

  // The in-deadline package was delivered on arrival — it leaves the on-board list…
@@ -250,6 +288,8 @@ test('on-board list: fly-to-destination + abandon with penalty preview; flying p
  await expect(onboardRow).not.toBeVisible({ timeout: 15_000 });

  // Restore: fly home so the live instance stays in its onboarding state for the next run.
+  // ISS-011: the arrival above auto-slown the sim to 1×, so re-set SCALE for this leg.
+  await setScale(page, SCALE);
  const homeRes = await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } });
  expect(homeRes.status()).toBe(200);
  await expect
@@ -307,3 +347,76 @@ test('market buy/sell/refuel render with previews from the catalog in /api/state
    expect(after.planes.find((p) => p.id === 'plane-starter')!.fuel).toBe(starter.maxFuel);
  }
 });
+
+test('on-board row Refuel tops up just enough for the package leg; market button says "Refuel to full"', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal + one long flight each way at scale 1000
+  await flyHomeViaApi(page);
+
+  const body = await getState(page);
+  const entry = body.catalog.find((e) => e.model === 'atr72')!;
+
+  // Deterministic baseline: a full tank.
+  expect((await page.request.post('/api/planes/plane-starter/refuel')).status()).toBe(200);
+
+  // Longest FLYABLE leg from the hub (fits a full tank) — long enough that "just enough" for it
+  // exceeds what's left on arrival.
+  const farthest = await farthestFlyableToHub(page, entry);
+  const pkg1 = await createPackage(page, HUB, farthest.icao, 24 * 3_600_000);
+  expect((await page.request.post(`/api/packages/${pkg1.id}/load`, { data: { planeId: 'plane-starter' } })).status()).toBe(200);
+
+  // Fly there (delivers pkg1 on arrival) — the tank is now partial.
+  expect((await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: farthest.icao } })).status()).toBe(200);
+  await setScale(page, SCALE);
+  await expect
+    .poll(async () => {
+      const b = await getState(page);
+      const p = b.planes.find((x) => x.id === 'plane-starter');
+      return !!p && p.status === 'available' && p.locationIcao === farthest.icao;
+    }, { timeout: 240_000, message: `waiting for arrival at ${farthest.icao} (scale 1000)` })
+    .toBe(true);
+
+  // New work at the far end: a package back to the hub — its leg is exactly what we refuel for.
+  const pkg2 = await createPackage(page, farthest.icao, HUB, 24 * 3_600_000);
+  expect((await page.request.post(`/api/packages/${pkg2.id}/load`, { data: { planeId: 'plane-starter' } })).status()).toBe(200);
+
+  // Expected "just enough" from the snapshot constants (mirrors requiredFuelFor in lib/sim/movement.ts).
+  const pre = await getState(page);
+  const fuelBefore = pre.planes.find((p) => p.id === 'plane-starter')!.fuel;
+  const cashBefore = pre.account.cash;
+  const km = haversineKm(farthest.hubLat, farthest.hubLon, farthest.lat, farthest.lon); // symmetric: hub ↔ far end
+  const liters = Math.max(0, requiredFuelFor(entry.burnPerKm, entry.emptyWeightKg, entry.maxFuel, km) - fuelBefore);
+  expect(liters).toBeGreaterThan(0); // the long leg genuinely needs more than what's left
+  const expectedCost = Math.round(liters * pre.fuelPricePerL * 100) / 100;
+
+  await page.goto('/');
+  const refuelBtn = page.getByTestId(`refuel-for-${pkg2.id}`);
+  await expect(refuelBtn, 'row Refuel button appears for the loaded package').toBeVisible({ timeout: 15_000 });
+  // Capture the endpoint's OWN response — the full post-action snapshot at the action's clock.
+  const [res] = await Promise.all([
+    page.waitForResponse((r) => r.url().includes(`/api/planes/plane-starter/refuel`), { timeout: 15_000 }),
+    refuelBtn.click(),
+  ]);
+  expect(res.status()).toBe(200);
+  const post = (await res.json()) as StateBody;
+
+  // Cash dropped by exactly L × price and fuel rose by exactly L.
+  expect(post.account.cash).toBeCloseTo(cashBefore - expectedCost, 6);
+  expect(post.planes.find((p) => p.id === 'plane-starter')!.fuel).toBeCloseTo(fuelBefore + liters, 6);
+
+  // Market row: the fill-up button is labeled "Refuel to full" (testid unchanged).
+  await expect(page.getByTestId('market-refuel')).toHaveText('Refuel to full');
+
+  // Restore: fly home — pkg2's destination IS the hub, so it delivers on arrival. The tank holds
+  // exactly the leg requirement, so this also proves "just enough" is enough. ISS-011: the far-end
+  // arrival above auto-slown the sim to 1×, so re-set SCALE for this leg.
+  await setScale(page, SCALE);
+  expect((await page.request.post('/api/planes/plane-starter/fly', { data: { destIcao: HUB } })).status()).toBe(200);
+  await expect
+    .poll(async () => (await getState(page)).planes.find((p) => p.id === 'plane-starter')?.locationIcao === HUB, {
+      timeout: 240_000,
+      message: 'waiting for plane-starter to land back at the hub',
+    })
+    .toBe(true);
+  // Top the tank back up so later specs start with a full tank.
+  expect((await page.request.post('/api/planes/plane-starter/refuel')).status()).toBe(200);
+});
@@ -6,8 +6,8 @@ import { test, expect, type Page } from '@playwright/test';

 // Must match lib/sim/engine.ts — kept in sync manually (same pattern as MIN_ZOOM/MAX_ZOOM in map.spec.ts).
 const MAX_TICK_ELAPSED_MS = 2_000;
-const SCALE = 60;
-const MAX_DELTA_PER_TICK = MAX_TICK_ELAPSED_MS * SCALE; // 120_000 game ms per tick at scale 60
+const SCALE = 1000; // fastest sim speed — top of the v0.14.0 ladder
+const MAX_DELTA_PER_TICK = MAX_TICK_ELAPSED_MS * SCALE; // 2_000_000 game ms per tick at scale 1000
 // Must match MARKET_TARGET_OPEN_PACKAGES in lib/game/seed.ts.
 const MARKET_TARGET = 10;

@@ -42,7 +42,7 @@ test.afterEach(async ({ page }) => {
  expect(res.status()).toBe(200);
 });

-test('timeScale 60 advances the clock by roughly real-time × 60 between polls', async ({ page }) => {
+test('timeScale 1000 advances the clock by roughly real-time × 1000 between polls', async ({ page }) => {
  const post = await postSim(page, { timeScale: SCALE });
  expect(post.status()).toBe(200);
  const s1 = (await post.json()) as SimState;
@@ -51,11 +51,11 @@ test('timeScale 60 advances the clock by roughly real-time × 60 between polls',

  let prev = s1.clockMs;
  for (let i = 0; i < 3; i++) {
-    await sleep(1_000); // one real second ≈ 60 game seconds at scale 60 — well under the clamp
+    await sleep(1_000); // one real second ≈ 1000 game seconds at scale 1000 — well under the clamp
    const body = await getState(page);
    const now = body.simState.clockMs;
    expect(now).toBeGreaterThan(prev); // strictly advances while actively polled
-    expect(now - prev).toBeGreaterThanOrEqual(30_000); // ≥ ~500 ms real × 60
+    expect(now - prev).toBeGreaterThanOrEqual(500_000); // ≥ ~500 ms real × 1000
    expect(now - prev).toBeLessThanOrEqual(MAX_DELTA_PER_TICK + 60); // clamp bounds each tick
    prev = now;
  }
@@ -82,7 +82,7 @@ test('an open package past its short deadline expires and the market stays toppe
  expect(victim).toBeDefined(); // steady state always has open packages

  // Test-only hook (FLIGHT_TEST_HOOKS=1 in docker-compose): move an existing open
-  // package's deadline ~10 game-seconds out so expiry is observable at scale 60.
+  // package's deadline ~10 game-seconds out so expiry is observable at scale 1000.
  const hook = await page.request.post('/api/test/expire-package', { data: { packageId: victim!.id } });
  expect(hook.status()).toBe(200);
  const moved = (await hook.json()) as { id: string; deadlineSimTime: number };
@@ -132,9 +132,13 @@ test('the hook can also create a fresh short-deadline package, which then expire
 });

 test('POST /api/sim validates and clamps its input', async ({ page }) => {
-  const clampHigh = await postSim(page, { timeScale: 500 });
+  const clampHigh = await postSim(page, { timeScale: 2000 });
  expect(clampHigh.status()).toBe(200);
-  expect(((await clampHigh.json()) as SimState).timeScale).toBe(64); // top of the power-of-two ladder (v0.9.2)
+  expect(((await clampHigh.json()) as SimState).timeScale).toBe(1000); // top of the ladder (v0.14.0)
+
+  const inRange = await postSim(page, { timeScale: 500 });
+  expect(inRange.status()).toBe(200);
+  expect(((await inRange.json()) as SimState).timeScale).toBe(500); // ladder value passes through unclamped

  const clampLow = await postSim(page, { timeScale: 0.1 });
  expect(clampLow.status()).toBe(200);
@@ -3,8 +3,10 @@ import path from 'node:path';
 import { test, expect } from '@playwright/test';

 // Repo root — docker-compose.yml lives here; `docker compose restart` runs on
-// this host (the test runner), browsers stay remote.
+// this host (the test runner), browsers stay remote. CI points E2E_COMPOSE_ARGS at the
+// isolated stack file + project (-f docker-compose.ci.yml -p flight-ci) instead of the default one.
 const repoRoot = path.join(__dirname, '..');
+const composeArgs = process.env.E2E_COMPOSE_ARGS ?? '';

 interface StateBody {
  account: { cash: number; reputation: number };
@@ -46,7 +48,7 @@ test('state survives a container restart (sim clock + account persisted)', async
  expect(resBefore.status()).toBe(200);
  const before = (await resBefore.json()) as StateBody;

-  execSync('docker compose restart flight', { cwd: repoRoot, stdio: 'pipe' });
+  execSync(`docker compose ${composeArgs} restart flight`, { cwd: repoRoot, stdio: 'pipe' });

  // Wait for the app to come back, capturing the post-restart snapshot.
  let after: StateBody | undefined;
@@ -0,0 +1,76 @@
+import type { Page } from '@playwright/test';
+import { expect, test } from '@playwright/test';
+
+// v0.17.0 — ISS-008: action errors surface as bottom-right toasts (in addition to the inline
+// pane error) and game events appear as info toasts via snapshot diffing; the left-pane Time
+// section offers an explicit "Enable notifications" opt-in for browser notifications.
+
+interface CatalogEntry {
+  model: string;
+  label: string;
+  price: number;
+}
+
+interface StateBody {
+  account: { cash: number };
+  catalog: CatalogEntry[];
+}
+
+async function getState(page: Page): Promise<StateBody> {
+  const res = await page.request.get('/api/state');
+  expect(res.status()).toBe(200);
+  return (await res.json()) as StateBody;
+}
+
+test('failed actions toast bottom-right (inline error stays) and the Time section offers a notifications opt-in', async ({ page }) => {
+  await page.goto('/');
+  const buyModel = page.getByTestId('market-buy-model');
+  await expect(buyModel, 'the market section renders once the first snapshot lands').toBeVisible({ timeout: 15_000 });
+
+  // Part A — deterministic error path: the most expensive catalog model (ATR 72-600, €200k) is
+  // unaffordable with starting cash (€20k). On a long-lived local instance cash may have grown
+  // past it — then this part is skipped in place; CI's isolated stack always starts fresh.
+  const body = await getState(page);
+  const priciest = [...body.catalog].sort((a, b) => b.price - a.price)[0];
+  if (body.account.cash < priciest.price) {
+    await buyModel.selectOption(priciest.model);
+    await page.getByTestId('market-buy').click();
+
+    // The toast appears with the server's error message and the error variant class…
+    const toast = page.locator('[data-testid="toast"]').filter({ hasText: /insufficient funds/i });
+    await expect(toast, 'the error toast appears bottom-right').toBeVisible({ timeout: 10_000 });
+    await expect(toast).toHaveClass(/toast-error/);
+
+    // …and the inline pane error still shows (both surfaces by design). It auto-clears on the
+    // next poll (~1 s), so assert right after the toast — both are set in the same commit.
+    await expect(page.getByTestId('right-error')).toContainText(/insufficient funds/);
+  }
+
+  // Part B — notifications opt-in in the Time section.
+  const btn = page.getByTestId('enable-notifications');
+  await expect(btn, 'the notifications button renders in the Time section').toBeVisible({ timeout: 15_000 });
+
+  // Browsers without the Notification API: disabled with a tooltip-ish title.
+  const supported = await page.evaluate(() => 'Notification' in window);
+  if (!supported) {
+    await expect(btn).toBeDisabled();
+    await expect(btn).toHaveAttribute('title', /does not support/i);
+    return;
+  }
+
+  // Branch on the ACTUAL permission state — headless CI reports 'denied' (not 'default'), so a
+  // fresh context is not guaranteed to show the opt-in prompt (CI run #47).
+  const permission = await page.evaluate(() => Notification.permission);
+  if (permission === 'denied') {
+    // LeftPane renders the blocked-state label without any click.
+    await expect(btn, 'denied context shows the blocked-state label').toHaveText('Notifications blocked', { timeout: 10_000 });
+  } else if (permission === 'granted') {
+    await expect(btn, 'pre-granted context shows the enabled label').toHaveText('Notifications enabled', { timeout: 10_000 });
+  } else {
+    // 'default' — the opt-in prompt. Clicking requests it; headless may deny, so accept either
+    // outcome, but the label must CHANGE from the prompt to reflect the result.
+    await expect(btn, 'non-denied context shows the opt-in prompt').toHaveText('Enable notifications', { timeout: 10_000 });
+    await btn.click();
+    await expect(btn).not.toHaveText('Enable notifications', { timeout: 10_000 });
+  }
+});
@@ -0,0 +1,162 @@
+import { describe, expect, it } from 'vitest';
+import type { PackageState, PlaneState, StateSnapshot } from './game/state';
+import { diffSnapshots } from './deriveEvents';
+
+// ISS-008 (v0.17.0): snapshot-diffing event derivation — pure core of the toast/notification
+// feature, unit-tested in node like advanceSimClock/fetchState.
+
+const CATALOG = [
+  { model: 'atr72', label: 'ATR 72-600', price: 200_000, maxFuel: 6300, burnPerKm: 1.75, emptyWeightKg: 9300, speedKmh: 510, capacity: 6 },
+];
+
+const basePlane = (id: string): PlaneState => ({
+  id,
+  model: 'atr72',
+  status: 'available',
+  fuel: 6300,
+  maxFuel: 6300,
+  locationIcao: 'EDDF',
+  locationName: 'Frankfurt',
+  destIcao: null,
+  destName: null,
+  departureSimTime: null,
+  lat: 50.03,
+  lon: 8.56,
+});
+
+const basePackage = (id: string): PackageState => ({
+  id,
+  originIcao: 'EDDF',
+  originName: 'Frankfurt',
+  destIcao: 'LEMD',
+  destName: 'Madrid–Barajas',
+  reward: 1234.5,
+  cargoType: 'mail',
+  cargoCount: 2,
+  deadlineSimTime: 0,
+  status: 'open',
+  planeId: null,
+  createdSimTime: 0,
+});
+
+const snapshot = (over: Partial<StateSnapshot> = {}): StateSnapshot => ({
+  account: { cash: 20_000, reputation: 10 },
+  simState: { clockMs: 0, timeScale: 1, paused: false },
+  planes: [basePlane('plane-starter')],
+  packages: [],
+  catalog: CATALOG,
+  fuelPricePerL: 0.8,
+  sellFraction: 0.5,
+  ...over,
+});
+
+describe('diffSnapshots', () => {
+  it('returns [] for identical snapshots (only clock/cash drift)', () => {
+    const prev = snapshot();
+    const next = snapshot({ account: { cash: 21_000, reputation: 11 }, simState: { clockMs: 60_000, timeScale: 1, paused: false } });
+    expect(diffSnapshots(prev, next)).toEqual([]);
+  });
+
+  it('returns [] for the first snapshot (no baseline — no "new package" spam on page load)', () => {
+    const next = snapshot({ packages: [basePackage('pkg-1'), basePackage('pkg-2')] });
+    expect(diffSnapshots(null, next)).toEqual([]);
+  });
+
+  it('emits a landing event when a plane goes flying → available (new locationName is the arrival)', () => {
+    const prev = snapshot({
+      planes: [
+        {
+          ...basePlane('plane-starter'),
+          status: 'flying',
+          destIcao: 'LEMD',
+          destName: 'Madrid–Barajas',
+          departureSimTime: 0,
+        },
+      ],
+    });
+    const next = snapshot({
+      planes: [
+        { ...basePlane('plane-starter'), locationIcao: 'LEMD', locationName: 'Madrid–Barajas' },
+      ],
+    });
+    expect(diffSnapshots(prev, next)).toEqual([
+      { kind: 'info', message: 'ATR 72-600 landed at Madrid–Barajas' },
+    ]);
+  });
+
+  it('emits a delivery event with the reward when a loaded package is delivered on arrival', () => {
+    const prev = snapshot({ packages: [{ ...basePackage('pkg-1'), status: 'loaded', planeId: 'plane-starter' }] });
+    const next = snapshot({ packages: [{ ...basePackage('pkg-1'), status: 'delivered', planeId: 'plane-starter' }] });
+    expect(diffSnapshots(prev, next)).toEqual([
+      { kind: 'info', message: 'Package delivered: +€1,234.50' },
+    ]);
+  });
+
+  it('emits an expiry event for open → expired and loaded → expired', () => {
+    const fromOpen = diffSnapshots(
+      snapshot({ packages: [basePackage('pkg-1')] }),
+      snapshot({ packages: [{ ...basePackage('pkg-1'), status: 'expired' }] }),
+    );
+    expect(fromOpen).toEqual([{ kind: 'info', message: 'Package expired: Frankfurt → Madrid–Barajas' }]);
+
+    const fromLoaded = diffSnapshots(
+      snapshot({ packages: [{ ...basePackage('pkg-2'), status: 'loaded', planeId: 'plane-starter' }] }),
+      snapshot({ packages: [{ ...basePackage('pkg-2'), status: 'expired', planeId: 'plane-starter' }] }),
+    );
+    expect(fromLoaded).toEqual([{ kind: 'info', message: 'Package expired: Frankfurt → Madrid–Barajas' }]);
+  });
+
+  it('emits a new-package event for ids only in the next snapshot', () => {
+    const prev = snapshot({ packages: [basePackage('pkg-1')] });
+    const next = snapshot({ packages: [basePackage('pkg-1'), basePackage('pkg-2')] });
+    expect(diffSnapshots(prev, next)).toEqual([
+      { kind: 'info', message: 'New package available: Frankfurt → Madrid–Barajas' },
+    ]);
+  });
+
+  it('emits bought/sold events when the plane id set changes (with the model name)', () => {
+    const bought = diffSnapshots(
+      snapshot(),
+      snapshot({ planes: [basePlane('plane-starter'), basePlane('plane-2')] }),
+    );
+    expect(bought).toEqual([{ kind: 'info', message: 'Bought ATR 72-600' }]);
+
+    const sold = diffSnapshots(
+      snapshot({ planes: [basePlane('plane-starter'), basePlane('plane-2')] }),
+      snapshot(),
+    );
+    expect(sold).toEqual([{ kind: 'info', message: 'Sold ATR 72-600' }]);
+  });
+
+  it('reports every transition in one diff (planes first, then packages)', () => {
+    const prev = snapshot({
+      planes: [
+        { ...basePlane('plane-starter'), status: 'flying', destIcao: 'LEMD', destName: 'Madrid–Barajas' },
+        basePlane('plane-2'),
+      ],
+      packages: [{ ...basePackage('pkg-1'), status: 'loaded', planeId: 'plane-starter' }],
+    });
+    const next = snapshot({
+      planes: [
+        { ...basePlane('plane-starter'), locationIcao: 'LEMD', locationName: 'Madrid–Barajas' },
+        basePlane('plane-3'),
+      ],
+      packages: [{ ...basePackage('pkg-1'), status: 'delivered', planeId: 'plane-starter' }],
+    });
+    expect(diffSnapshots(prev, next)).toEqual([
+      { kind: 'info', message: 'ATR 72-600 landed at Madrid–Barajas' },
+      { kind: 'info', message: 'Bought ATR 72-600' },
+      { kind: 'info', message: 'Sold ATR 72-600' },
+      { kind: 'info', message: 'Package delivered: +€1,234.50' },
+    ]);
+  });
+
+  it('ignores transitions that are not events (open → loaded, available → flying)', () => {
+    const prev = snapshot({ packages: [basePackage('pkg-1')] });
+    const next = snapshot({
+      planes: [{ ...basePlane('plane-starter'), status: 'flying', destIcao: 'LEMD', destName: 'Madrid–Barajas' }],
+      packages: [{ ...basePackage('pkg-1'), status: 'loaded', planeId: 'plane-starter' }],
+    });
+    expect(diffSnapshots(prev, next)).toEqual([]);
+  });
+});
@@ -0,0 +1,61 @@
+import type { StateSnapshot } from './game/state';
+import { PLANE_TYPES } from './game/catalog';
+import { formatCash } from './format';
+
+// ISS-008 (v0.17.0): derive human-readable game events by diffing two consecutive /api/state
+// snapshots — there is no server event feed, so the client watches for transitions in the
+// fields it already receives. Pure and unit-tested; the shell calls it once per new snapshot
+// and turns each result into an info toast (plus a browser notification when hidden).
+
+export interface GameEvent {
+  kind: 'info';
+  message: string;
+}
+
+const planeName = (model: string): string => PLANE_TYPES[model]?.name ?? model;
+
+export function diffSnapshots(prev: StateSnapshot | null, next: StateSnapshot): GameEvent[] {
+  // No baseline yet (first snapshot after load) — nothing to compare against. Emitting a
+  // "new package" event for every existing row would spam the stack on page load.
+  if (prev === null) return [];
+
+  const events: GameEvent[] = [];
+
+  // Planes: landed (flying → available, new locationName is the arrival airport), bought or
+  // sold (id set changed — ids are stable for a plane's whole life).
+  const prevPlanes = new Map(prev.planes.map((p) => [p.id, p]));
+  for (const plane of next.planes) {
+    const before = prevPlanes.get(plane.id);
+    if (!before) {
+      events.push({ kind: 'info', message: `Bought ${planeName(plane.model)}` });
+      continue;
+    }
+    if (before.status === 'flying' && plane.status === 'available') {
+      events.push({ kind: 'info', message: `${planeName(plane.model)} landed at ${plane.locationName}` });
+    }
+  }
+  for (const [id, before] of prevPlanes) {
+    if (!next.planes.some((p) => p.id === id)) {
+      events.push({ kind: 'info', message: `Sold ${planeName(before.model)}` });
+    }
+  }
+
+  // Packages: delivered (loaded → delivered, reward paid out in the same tick), expired
+  // (open|loaded → expired), newly appeared (id only in next — terminal packages are never
+  // deleted, so an id appearing is always a genuinely new one).
+  const prevPackages = new Map(prev.packages.map((p) => [p.id, p]));
+  for (const pkg of next.packages) {
+    const before = prevPackages.get(pkg.id);
+    if (!before) {
+      events.push({ kind: 'info', message: `New package available: ${pkg.originName} → ${pkg.destName}` });
+      continue;
+    }
+    if (before.status === 'loaded' && pkg.status === 'delivered') {
+      events.push({ kind: 'info', message: `Package delivered: +${formatCash(pkg.reward)}` });
+    } else if ((before.status === 'open' || before.status === 'loaded') && pkg.status === 'expired') {
+      events.push({ kind: 'info', message: `Package expired: ${pkg.originName} → ${pkg.destName}` });
+    }
+  }
+
+  return events;
+}
@@ -6,6 +6,8 @@ import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
 import { openGameDb, type GameDb } from '@/lib/db/client';
 import * as schema from '@/lib/db/schema';
 import { loadAirportsGeoJson } from '@/lib/airports';
+import { haversineKm } from '@/lib/geo';
+import { requiredFuelFor } from '@/lib/sim/movement';
 import { FUEL_PRICE_PER_L, PLANE_TYPES, SELL_FRACTION } from './catalog';
 import { HUB_ICAO } from './seed';
 import {
@@ -412,4 +414,110 @@ describe('refuelPlane', () => {
    const inst = await freshDb('refuel-unknown.db');
    await expectActionError(refuelPlane(inst, 'ghost'), 404);
  });
+
+  // --- forFlight mode (v0.16.0) ---
+
+  it('forFlight adds exactly the liters needed for the package leg and deducts L × price', async () => {
+    const inst = await freshDb('refuel-forflight-ok.db');
+    await insertOpenPackage(inst, 'p-ff', { destIcao: 'LEMD' }); // EDDF → LEMD
+    await loadPackage(inst, 'p-ff', 'plane-starter');
+
+    const fc = await loadAirportsGeoJson();
+    const from = fc.features.find((f) => f.properties.icao === HUB_ICAO)!.properties;
+    const to = fc.features.find((f) => f.properties.icao === 'LEMD')!.properties;
+    const km = haversineKm(from.lat, from.lon, to.lat, to.lon);
+    const type = PLANE_TYPES.atr72;
+    const required = requiredFuelFor(type.burnPerKm, type.emptyWeightKg, type.maxFuel, km);
+
+    // Partial tank below the requirement so L > 0.
+    const startFuel = Math.round(required / 2);
+    await inst.db.update(schema.planes).set({ fuel: startFuel }).where(eq(schema.planes.id, 'plane-starter'));
+    const cashBefore = (await inst.db.select().from(schema.account))[0].cash;
+
+    const { cost } = await refuelPlane(inst, 'plane-starter', { mode: 'forFlight', packageId: 'p-ff' });
+
+    expect(cost).toBe(Math.round((required - startFuel) * FUEL_PRICE_PER_L * 100) / 100);
+    const plane = (await inst.db.select().from(schema.planes))[0];
+    expect(plane.fuel).toBeCloseTo(required, 6); // topped up to exactly the leg requirement
+    const account = (await inst.db.select().from(schema.account))[0];
+    expect(account.cash).toBeCloseTo(cashBefore - cost, 6);
+  });
+
+  it('forFlight leaves an exactly-feasible tank — flyPlane to the package dest succeeds right after', async () => {
+    const inst = await freshDb('refuel-ff-flyafter.db');
+    await insertOpenPackage(inst, 'p-fa', { destIcao: 'LEMD' }); // EDDF → LEMD
+    await loadPackage(inst, 'p-fa', 'plane-starter');
+
+    const fc = await loadAirportsGeoJson();
+    const from = fc.features.find((f) => f.properties.icao === HUB_ICAO)!.properties;
+    const to = fc.features.find((f) => f.properties.icao === 'LEMD')!.properties;
+    const km = haversineKm(from.lat, from.lon, to.lat, to.lon);
+    const type = PLANE_TYPES.atr72;
+    const required = requiredFuelFor(type.burnPerKm, type.emptyWeightKg, type.maxFuel, km);
+
+    // Empty-ish tank: well below the leg requirement.
+    await inst.db.update(schema.planes).set({ fuel: Math.round(required / 4) }).where(eq(schema.planes.id, 'plane-starter'));
+
+    await refuelPlane(inst, 'plane-starter', { mode: 'forFlight', packageId: 'p-fa' });
+
+    // The leg must now be flyable — no epsilon-short 409 (regression guard for the float-exact target).
+    await flyPlane(inst, 'plane-starter', 'LEMD');
+    const plane = (await inst.db.select().from(schema.planes))[0];
+    expect(plane.status).toBe('flying');
+    expect(plane.destIcao).toBe('LEMD');
+  });
+
+  it('forFlight is a free no-op when the tank already covers the leg', async () => {
+    const inst = await freshDb('refuel-forflight-enough.db'); // seeded starter is full at EDDF
+    await insertOpenPackage(inst, 'p-ff2', { destIcao: 'LEMD' });
+    await loadPackage(inst, 'p-ff2', 'plane-starter');
+    const cashBefore = (await inst.db.select().from(schema.account))[0].cash;
+
+    const { cost } = await refuelPlane(inst, 'plane-starter', { mode: 'forFlight', packageId: 'p-ff2' });
+
+    expect(cost).toBe(0);
+    const plane = (await inst.db.select().from(schema.planes))[0];
+    expect(plane.fuel).toBe(PLANE_TYPES.atr72.maxFuel); // untouched
+    expect((await inst.db.select().from(schema.account))[0].cash).toBe(cashBefore);
+  });
+
+  it('forFlight rejects a package that is not loaded on this plane with 409', async () => {
+    const inst = await freshDb('refuel-ff-open.db'); // open — never loaded
+    await insertOpenPackage(inst, 'p-x');
+    await expectActionError(refuelPlane(inst, 'plane-starter', { mode: 'forFlight', packageId: 'p-x' }), 409);
+
+    const inst2 = await freshDb('refuel-ff-other.db'); // loaded on ANOTHER plane
+    await insertOpenPackage(inst2, 'p-y', { status: 'loaded', planeId: 'plane-someone-else' });
+    await expectActionError(refuelPlane(inst2, 'plane-starter', { mode: 'forFlight', packageId: 'p-y' }), 409);
+  });
+
+  it('forFlight rejects an expired package with 409', async () => {
+    const inst = await freshDb('refuel-ff-expired.db');
+    await insertOpenPackage(inst, 'p-z', { status: 'expired', planeId: 'plane-starter' });
+    await expectActionError(refuelPlane(inst, 'plane-starter', { mode: 'forFlight', packageId: 'p-z' }), 409);
+  });
+
+  it('forFlight rejects an unknown package id with 404', async () => {
+    const inst = await freshDb('refuel-ff-unknown.db');
+    await expectActionError(refuelPlane(inst, 'plane-starter', { mode: 'forFlight', packageId: 'nope' }), 404);
+  });
+
+  it('forFlight rejects a missing packageId with 400', async () => {
+    const inst = await freshDb('refuel-ff-nopkg.db');
+    await expectActionError(refuelPlane(inst, 'plane-starter', { mode: 'forFlight' }), 400);
+  });
+
+  it('forFlight rejects a leg that does not fit even a full tank with 409', async () => {
+    const inst = await freshDb('refuel-ff-nofit.db');
+    // UNNT (Narsarsuaq, Greenland) ↔ LPPD are ~7670 km apart — far beyond the ATR's range.
+    await insertOpenPackage(inst, 'p-far', { destIcao: 'LPPD' });
+    await loadPackage(inst, 'p-far', 'plane-starter');
+    await inst.db.update(schema.planes).set({ locationIcao: 'UNNT' }).where(eq(schema.planes.id, 'plane-starter'));
+
+    await expectActionError(
+      refuelPlane(inst, 'plane-starter', { mode: 'forFlight', packageId: 'p-far' }),
+      409,
+      /does not fit/i,
+    );
+  });
 });
@@ -4,6 +4,7 @@ import * as schema from '@/lib/db/schema';
 import { persist, type GameDb } from '@/lib/db/client';
 import { loadAirportsGeoJson } from '@/lib/airports';
 import { haversineKm } from '@/lib/geo';
+import { requiredFuelFor } from '@/lib/sim/movement';
 import { runAction } from '@/lib/sim/engine';
 import { getStateSnapshot } from './state';
 import { FUEL_PRICE_PER_L, PLANE_TYPES, SELL_FRACTION } from './catalog';
@@ -105,9 +106,10 @@ export async function flyPlane(inst: GameDb, planeId: string, destIcao: string):
  const type = PLANE_TYPES[plane.model];
  if (!type) throw new Error(`unknown plane model ${plane.model}`); // → 500, cannot happen for seeded data
  const distanceKm = haversineKm(origin.lat, origin.lon, destFeature.properties.lat, destFeature.properties.lon);
-  const burnL = type.burnPerKm * distanceKm;
-  if (burnL > plane.fuel) {
-    throw new GameActionError(409, `insufficient fuel: the leg needs ${Math.round(burnL)} L but the plane has ${Math.round(plane.fuel)} L`);
+  // Weighted burn model (v0.16.0): the leg needs enough fuel to cover it arriving empty.
+  const requiredL = requiredFuelFor(type.burnPerKm, type.emptyWeightKg, type.maxFuel, distanceKm);
+  if (requiredL > plane.fuel) {
+    throw new GameActionError(409, `insufficient fuel: the leg needs ${Math.round(requiredL)} L but the plane has ${Math.round(plane.fuel)} L`);
  }

  // runAction() ticked first, so this is current game time.
@@ -225,8 +227,19 @@ export async function sellPlane(inst: GameDb, planeId: string): Promise<{ payout

 // --- Refuel (POST /api/planes/:planeId/refuel) ---

-// Fill a grounded plane to maxFuel at FUEL_PRICE_PER_L per missing liter.
-export async function refuelPlane(inst: GameDb, planeId: string): Promise<{ cost: number }> {
+// Refuel modes (v0.16.0): 'full' fills the tank to maxFuel; 'forFlight' adds just
+// enough fuel for one loaded package's destination leg — required liters per the
+// weighted burn model, independent of how much is already in the tank.
+export interface RefuelOptions {
+  mode?: 'full' | 'forFlight';
+  packageId?: string;
+}
+
+// Fill a grounded plane to maxFuel at FUEL_PRICE_PER_L per missing liter — or, with
+// {mode:'forFlight', packageId}, top it up just enough to fly the loaded package's
+// destination leg (409 if the package isn't loaded on this plane, is expired, or the
+// leg doesn't fit a full tank).
+export async function refuelPlane(inst: GameDb, planeId: string, opts: RefuelOptions = {}): Promise<{ cost: number }> {
  const rows = await inst.db.select().from(schema.planes).where(eq(schema.planes.id, planeId));
  const plane = rows[0];
  if (!plane) throw new GameActionError(404, `plane ${planeId} not found`);
@@ -234,14 +247,47 @@ export async function refuelPlane(inst: GameDb, planeId: string): Promise<{ cost
    throw new GameActionError(409, `plane is ${plane.status}, only grounded planes can be refueled`);
  }

-  const cost = Math.round((plane.maxFuel - plane.fuel) * FUEL_PRICE_PER_L * 100) / 100;
+  const mode = opts.mode ?? 'full';
+  let targetFuel: number; // tank level after the refuel
+  if (mode === 'forFlight') {
+    if (!opts.packageId) throw new GameActionError(400, 'packageId is required when mode is "forFlight"');
+
+    const pkgRows = await inst.db.select().from(schema.packages).where(eq(schema.packages.id, opts.packageId));
+    const pkg = pkgRows[0];
+    if (!pkg) throw new GameActionError(404, `package ${opts.packageId} not found`);
+    if (pkg.status !== 'loaded' || pkg.planeId !== plane.id) {
+      const where = pkg.planeId === plane.id ? '' : ', and it is bound to another plane';
+      throw new GameActionError(409, `only a package loaded on this plane can be refueled for (it is ${pkg.status}${where})`);
+    }
+
+    const type = PLANE_TYPES[plane.model];
+    if (!type) throw new Error(`unknown plane model ${plane.model}`); // → 500, cannot happen for seeded data
+    const origin = await airportByIcao(plane.locationIcao);
+    const dest = await airportByIcao(pkg.destIcao);
+    const distanceKm = haversineKm(origin.lat, origin.lon, dest.lat, dest.lon);
+    const requiredL = requiredFuelFor(type.burnPerKm, type.emptyWeightKg, type.maxFuel, distanceKm);
+    if (requiredL > plane.maxFuel) {
+      throw new GameActionError(409, `the leg to ${pkg.destIcao} needs ${Math.round(requiredL)} L even starting empty — it does not fit a full ${plane.maxFuel} L tank`);
+    }
+    // Land EXACTLY on the leg requirement when topping up: flyPlane re-computes this same value and
+    // compares with strict `>`, so fuel := requiredL guarantees the leg is feasible. The alternative
+    // (fuel + liters) can round a hair BELOW R in IEEE754 — f + fl(R − f) is not guaranteed ≥ R — and
+    // would 409 on an otherwise-feasible leg. Already enough → free no-op, tank untouched.
+    targetFuel = Math.max(plane.fuel, requiredL);
+  } else {
+    // Exactly maxFuel (as before v0.16.0) — clients/tests compare against it with strict equality.
+    targetFuel = plane.maxFuel;
+  }
+
+  const liters = Math.max(0, targetFuel - plane.fuel);
+  const cost = Math.round(liters * FUEL_PRICE_PER_L * 100) / 100;
  const account = (await inst.db.select().from(schema.account))[0];
  if (!account) throw new Error('account row missing');
  if (cost > 0 && account.cash < cost) {
    throw new GameActionError(409, `insufficient funds: refueling costs ${cost}, you have ${Math.round(account.cash)}`);
  }

-  await inst.db.update(schema.planes).set({ fuel: plane.maxFuel }).where(eq(schema.planes.id, planeId));
+  await inst.db.update(schema.planes).set({ fuel: targetFuel }).where(eq(schema.planes.id, planeId));
  if (cost > 0) {
    await inst.db.update(schema.account).set({ cash: Math.round((account.cash - cost) * 100) / 100 });
  }
@@ -6,8 +6,11 @@ export interface PlaneType {
  name: string;
  // Fuel capacity, liters.
  maxFuel: number;
-  // Fuel burn per km of flight, liters/km (cruise).
+  // Fuel burn per km of flight at a FULL tank, liters/km (cruise) — the weighted burn
+  // model (v0.16.0) calibrates its rate constant to this value at F = maxFuel.
  burnPerKm: number;
+  // Operating empty weight in kg (v0.16.0) — feeds the weight-proportional burn model.
+  emptyWeightKg: number;
  // Cruise speed, km/h — used by the sim tick to advance planes along routes.
  speedKmh: number;
  // Market price in € (v0.8.0): buying costs `price`, selling pays out
@@ -22,7 +25,8 @@ export const PLANE_TYPES: Record<string, PlaneType> = {
    id: 'atr72',
    name: 'ATR 72-600',
    maxFuel: 6300,
-    burnPerKm: 1.75, // ~900 kg/h at 510 km/h cruise (Jet-A1 ≈ 0.8 kg/L)
+    burnPerKm: 1.75, // full-tank rate: ~893 L/h ≈ 714 kg/h at 510 km/h cruise (Jet-A1 ≈ 0.8 kg/L); the weighted model burns less as fuel drops off
+    emptyWeightKg: 9_300, // ATR 72-600 operating empty weight
    speedKmh: 510,
    // €200k — with the starting cash of €20k and typical hop rewards (~€1–3k),
    // a second ATR takes sustained play to afford, as intended for the MVP sink.
@@ -49,6 +53,9 @@ export interface CatalogEntry {
  price: number;
  maxFuel: number;
  burnPerKm: number;
+  // Weighted burn model inputs (v0.16.0) — clients can mirror the closed forms in
+  // lib/sim/movement.ts with these + FUEL_DENSITY_KG_PER_L.
+  emptyWeightKg: number;
  speedKmh: number;
  capacity: number;
 }
@@ -62,6 +69,7 @@ export function catalogEntries(): CatalogEntry[] {
    price: t.price,
    maxFuel: t.maxFuel,
    burnPerKm: t.burnPerKm,
+    emptyWeightKg: t.emptyWeightKg,
    speedKmh: t.speedKmh,
    capacity: t.capacity,
  }));
@@ -3,7 +3,7 @@ import { haversineKm } from '@/lib/geo';
 import { getGameDb } from '@/lib/db/client';
 import * as schema from '@/lib/db/schema';
 import { catalogEntries, FUEL_PRICE_PER_L, PLANE_TYPES, SELL_FRACTION, type CatalogEntry } from './catalog';
-import { fuelAt, progressAt, positionAt } from '@/lib/sim/movement';
+import { fuelAtWeighted, progressAt, positionAt } from '@/lib/sim/movement';

 // Read-only game-state snapshot for client polling (GET /api/state).

@@ -84,7 +84,7 @@ export async function getStateSnapshot(): Promise<StateSnapshot> {
    const distanceKm = haversineKm(from.lat, from.lon, to.lat, to.lon);
    const progress = progressAt(p.departureSimTime, distanceKm, type.speedKmh, simRow.clockMs);
    const pos = positionAt(from.lat, from.lon, to.lat, to.lon, progress);
-    return { ...pos, fuel: fuelAt(p.fuel, type.burnPerKm, distanceKm, progress) };
+    return { ...pos, fuel: fuelAtWeighted(p.fuel, type.burnPerKm, type.emptyWeightKg, type.maxFuel, distanceKm, progress) };
  };

  return {
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import type { StateSnapshot } from './game/state';
-import { planesGeoJson, routesGeoJson, greatCircleArc, ROUTE_ARC_SEGMENTS, type AirportCoord } from './mapData';
+import { planesGeoJson, routesGeoJson, hoverRouteGeoJson, greatCircleArc, ROUTE_ARC_SEGMENTS, type AirportCoord } from './mapData';
 import { haversineKm } from './geo';

 const AIRPORTS = new Map<string, AirportCoord>([
@@ -17,7 +17,7 @@ function snapshot(overrides: Partial<StateSnapshot> = {}): StateSnapshot {
    planes: [],
    packages: [],
    catalog: [
-      { model: 'atr72', label: 'ATR 72-600', price: 200_000, maxFuel: 6300, burnPerKm: 1.75, speedKmh: 510, capacity: 6 },
+      { model: 'atr72', label: 'ATR 72-600', price: 200_000, maxFuel: 6300, burnPerKm: 1.75, emptyWeightKg: 9_300, speedKmh: 510, capacity: 6 },
    ],
    fuelPricePerL: 0.8,
    sellFraction: 0.5,
@@ -140,6 +140,42 @@ describe('routesGeoJson (v0.12.0 — one line per flying plane\'s current leg)',
  });
 });

+describe('hoverRouteGeoJson (ISS-022/025/027 v0.22.0 — hover route trace)', () => {
+  it('returns an empty collection for the no-hover "" sentinel', () => {
+    expect(hoverRouteGeoJson('', '', AIRPORTS)).toEqual({ type: 'FeatureCollection', features: [] });
+  });
+
+  it('draws one great-circle line between two known airports with exact endpoints', () => {
+    const fc = hoverRouteGeoJson('EDDF', 'EHAM', AIRPORTS);
+    expect(fc.features).toHaveLength(1);
+    expect(fc.features[0].properties).toEqual({ planeId: '' }); // pure overlay — no owning plane
+    const coords = fc.features[0].geometry.coordinates;
+    expect(coords.length).toBe(ROUTE_ARC_SEGMENTS + 1); // sampled arc, not a 2-point chord
+    expect(coords[0]).toEqual([8.56, 50.03]); // EDDF [lon, lat] — exact endpoint
+    expect(coords[coords.length - 1]).toEqual([4.76, 52.31]); // EHAM — exact endpoint
+  });
+
+  it('draws the same trace reversed (endpoints swapped, arc mirrored)', () => {
+    const ab = hoverRouteGeoJson('EDDF', 'EHAM', AIRPORTS).features[0].geometry.coordinates;
+    const ba = hoverRouteGeoJson('EHAM', 'EDDF', AIRPORTS).features[0].geometry.coordinates;
+    expect(ba.length).toBe(ab.length);
+    // The slerp is symmetric up to floating-point rounding (1 − t ≠ (N−t)/N bit-exactly), so
+    // compare with a tolerance: each reversed point sits on the forward arc within ~1e-9 degrees.
+    for (let i = 0; i < ab.length; i++) {
+      expect(Math.abs(ba[i][0] - ab[ab.length - 1 - i][0])).toBeLessThan(1e-9);
+      expect(Math.abs(ba[i][1] - ab[ab.length - 1 - i][1])).toBeLessThan(1e-9);
+    }
+  });
+
+  it('returns an empty collection when the from airport is missing from the dataset', () => {
+    expect(hoverRouteGeoJson('ZZZZ', 'EDDV', AIRPORTS)).toEqual({ type: 'FeatureCollection', features: [] });
+  });
+
+  it('returns an empty collection when the to airport is missing from the dataset', () => {
+    expect(hoverRouteGeoJson('EDDF', 'ZZZZ', AIRPORTS)).toEqual({ type: 'FeatureCollection', features: [] });
+  });
+});
+
 describe('greatCircleArc (v0.12.2 — curved route traces)', () => {
  it('samples >2 points with the endpoints exactly at the airport coords', () => {
    const arc = greatCircleArc(AIRPORTS.get('EDDF')!, AIRPORTS.get('EHAM')!);
@@ -85,6 +85,33 @@ export function greatCircleArc(from: AirportCoord, to: AirportCoord): [number, n
  return coords;
 }

+// ISS-022/025/027 (v0.22.0): the hover route trace — one great-circle LineString between two
+// airports, drawn top-most while a panel row hovers (job-list rows, on-board cargo rows, the
+// Relocate section). Empty collection when either endpoint is missing from the dataset — never
+// guessed; the '' sentinel (no hovered target) resolves to nothing and yields the same.
+export function hoverRouteGeoJson(
+  fromIcao: string,
+  toIcao: string,
+  airportsByIcao: ReadonlyMap<string, AirportCoord>,
+): FeatureCollection<MapLineFeature> {
+  const from = airportsByIcao.get(fromIcao);
+  const to = airportsByIcao.get(toIcao);
+  if (!from || !to) return EMPTY_LINES;
+  return {
+    type: 'FeatureCollection',
+    features: [
+      {
+        type: 'Feature',
+        geometry: {
+          type: 'LineString',
+          coordinates: greatCircleArc(from, to),
+        },
+        properties: { planeId: '' }, // no owning plane — a pure hover overlay
+      },
+    ],
+  };
+}
+
 // One LineString per FLYING plane — its current leg from locationIcao to dest_icao.
 // Grounded planes draw nothing; a flying plane missing either endpoint from the
 // dataset is skipped, never guessed. The line is sampled along the great circle
@@ -90,8 +90,17 @@ describe('OpenAPI spec', () => {
    expect(snap.sellFraction.type).toBe('number');

    const catalog = openApiSpec.components.schemas.CatalogEntry.properties;
-    expect(Object.keys(catalog).sort()).toEqual(['burnPerKm', 'capacity', 'label', 'maxFuel', 'model', 'price', 'speedKmh']);
-    for (const key of ['burnPerKm', 'maxFuel', 'price', 'speedKmh'] as const) {
+    expect(Object.keys(catalog).sort()).toEqual([
+      'burnPerKm',
+      'capacity',
+      'emptyWeightKg', // v0.16.0 weighted burn model input
+      'label',
+      'maxFuel',
+      'model',
+      'price',
+      'speedKmh',
+    ]);
+    for (const key of ['burnPerKm', 'emptyWeightKg', 'maxFuel', 'price', 'speedKmh'] as const) {
      expect(catalog[key].type, `CatalogEntry.${key}`).toBe('number');
    }
    expect(catalog.capacity.type).toBe('integer'); // v0.12.0 slot capacity
@@ -153,7 +162,7 @@ describe('OpenAPI spec', () => {
    expect(Object.keys(controls).sort()).toEqual(['paused', 'timeScale']);
    expect(controls.timeScale.type).toBe('number');
    expect(controls.timeScale.minimum).toBe(1);
-    expect(controls.timeScale.maximum).toBe(64);
+    expect(controls.timeScale.maximum).toBe(1000);
    expect(controls.paused.type).toBe('boolean');

    const error = openApiSpec.components.schemas.Error.properties;
@@ -165,7 +174,7 @@ describe('OpenAPI spec', () => {
    const post = (p: string) =>
      ((openApiSpec.paths as Record<string, { post?: unknown }>)[p]?.post ?? {}) as {
        responses: Record<string, unknown>;
-        requestBody?: { content: Record<string, { schema: { $ref: string } }> };
+        requestBody?: { required?: boolean; content: Record<string, { schema: { $ref: string } }> };
        parameters?: Array<{ name: string }>;
      };

@@ -189,9 +198,10 @@ describe('OpenAPI spec', () => {
    expect(errorCodes('/api/planes/{planeId}/fly')).toEqual(['400', '404', '409']);
    expect(errorCodes('/api/market/buy-plane')).toEqual(['400', '409']);
    expect(errorCodes('/api/market/sell-plane')).toEqual(['400', '404', '409']);
-    expect(errorCodes('/api/planes/{planeId}/refuel')).toEqual(['404', '409']);
+    expect(errorCodes('/api/planes/{planeId}/refuel')).toEqual(['400', '404', '409']); // v0.16.0 optional body

-    // Request bodies: load/fly/buy/sell take their dedicated schemas; abandon/refuel take none.
+    // Request bodies: load/fly/buy/sell take their dedicated schemas; abandon takes none;
+    // refuel's is OPTIONAL (v0.16.0) — no body still means "fill to full".
    expect(post('/api/packages/{id}/load').requestBody?.content['application/json'].schema.$ref).toBe(
      '#/components/schemas/LoadPackageRequest',
    );
@@ -205,7 +215,9 @@ describe('OpenAPI spec', () => {
      '#/components/schemas/SellPlaneRequest',
    );
    expect(post('/api/packages/{id}/abandon').requestBody).toBeUndefined();
-    expect(post('/api/planes/{planeId}/refuel').requestBody).toBeUndefined();
+    const refuelBody = post('/api/planes/{planeId}/refuel').requestBody;
+    expect(refuelBody?.content['application/json'].schema.$ref).toBe('#/components/schemas/RefuelRequest');
+    expect(refuelBody?.required).toBe(false); // optional — no body still means "fill to full"

    // Path parameters are declared on the parameterized routes.
    const paramNames = (p: string) => post(p).parameters?.map((x) => x.name);
@@ -227,5 +239,11 @@ describe('OpenAPI spec', () => {
    const sell = openApiSpec.components.schemas.SellPlaneRequest;
    expect(sell.required).toEqual(['planeId']);
    expect(sell.properties.planeId.type).toBe('string');
+
+    // RefuelRequest (v0.16.0): both fields optional — no body / {} means "full".
+    const refuel = openApiSpec.components.schemas.RefuelRequest;
+    expect((refuel as { required?: string[] }).required ?? []).toEqual([]);
+    expect(((refuel.properties.mode) as { enum: string[] }).enum.sort()).toEqual(['forFlight', 'full']);
+    expect(refuel.properties.packageId.type).toBe('string');
  });
 });
@@ -197,7 +197,8 @@ export const openApiSpec = {
            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
          },
          409: {
-            description: 'Plane not grounded, or insufficient fuel for the leg (burnPerKm × great-circle km)',
+            description:
+              'Plane not grounded, or insufficient fuel for the leg (v0.16.0 weight-proportional burn — the fuel required to cover the great-circle distance arriving empty)',
            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
          },
        },
@@ -271,22 +272,35 @@ export const openApiSpec = {
      post: {
        summary: 'Refuel a grounded plane',
        description:
-          'Fill a grounded plane to maxFuel (v0.8.0). Cost = (maxFuel − fuel) × fuel price per liter, deducted from cash; no body.',
+          'Refuel a grounded plane at the fuel price per added liter, deducted from cash (v0.8.0). The body is optional (v0.16.0): no body or mode "full" fills to maxFuel; mode "forFlight" with packageId adds just enough for that loaded package\'s destination leg — liters = required fuel for the great-circle distance (weight-proportional burn model) minus what is already in the tank.',
        operationId: 'refuelPlane',
        parameters: [
          { name: 'planeId', in: 'path', required: true, schema: { type: 'string' } },
        ],
+        requestBody: {
+          required: false,
+          content: {
+            'application/json': {
+              schema: { $ref: '#/components/schemas/RefuelRequest' },
+            },
+          },
+        },
        responses: {
          200: {
-            description: 'Refueled — full state snapshot (fuel at max, cash reduced by the cost)',
+            description: 'Refueled — full state snapshot (fuel raised by exactly the added liters, cash reduced by the cost)',
            content: { 'application/json': { schema: { $ref: '#/components/schemas/StateSnapshot' } } },
          },
+          400: {
+            description: 'Invalid body (not an object, unknown field, unknown mode, or forFlight without packageId)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
          404: {
-            description: 'Unknown plane id',
+            description: 'Unknown plane id (or unknown package id in forFlight mode)',
            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
          },
          409: {
-            description: 'Plane is flying, or cash is insufficient for the fill-up',
+            description:
+              'Plane is flying, the package is not loaded on this plane (or is expired), the leg does not fit a full tank, or cash is insufficient for the refuel',
            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
          },
        },
@@ -376,11 +390,12 @@ export const openApiSpec = {
          label: { type: 'string', description: 'Display name (e.g. "ATR 72-600").' },
          price: { type: 'number', description: 'Market price in € (buy cost; sell pays out sellFraction × this).' },
          maxFuel: { type: 'number', description: 'Fuel capacity, liters.' },
-          burnPerKm: { type: 'number', description: 'Cruise fuel burn, liters/km.' },
+          burnPerKm: { type: 'number', description: 'Cruise fuel burn at a full tank, liters/km (v0.16.0 weighted model calibrates to this).' },
+          emptyWeightKg: { type: 'number', description: 'Operating empty weight, kg — with burnPerKm and maxFuel it drives the v0.16.0 weight-proportional burn model.' },
          speedKmh: { type: 'number', description: 'Cruise speed, km/h.' },
          capacity: { type: 'integer', description: 'Cargo slot capacity — packages that can be loaded on one plane (v0.12.0).' },
        },
-        required: ['model', 'label', 'price', 'maxFuel', 'burnPerKm', 'speedKmh', 'capacity'],
+        required: ['model', 'label', 'price', 'maxFuel', 'burnPerKm', 'emptyWeightKg', 'speedKmh', 'capacity'],
      },
      AccountState: {
        type: 'object',
@@ -394,7 +409,7 @@ export const openApiSpec = {
        type: 'object',
        properties: {
          clockMs: { type: 'integer', description: 'Sim-clock epoch ms (game time)' },
-          timeScale: { type: 'number', minimum: 1, maximum: 64 },
+          timeScale: { type: 'number', minimum: 1, maximum: 1000 },
          paused: { type: 'boolean' },
        },
        required: ['clockMs', 'timeScale', 'paused'],
@@ -406,8 +421,8 @@ export const openApiSpec = {
          timeScale: {
            type: 'number',
            minimum: 1,
-            maximum: 64,
-            description: 'Game-time multiplier; values outside [1, 64] are clamped. The UI offers the power-of-two ladder 1/2/4/8/16/32/64.',
+            maximum: 1000,
+            description: 'Game-time multiplier; values outside [1, 1000] are clamped. The UI offers the ladder 1/2/5/10/25/50/100/250/500/1000.',
          },
          paused: { type: 'boolean' },
        },
@@ -440,6 +455,22 @@ export const openApiSpec = {
        },
        required: ['planeId'],
      },
+      RefuelRequest: {
+        type: 'object',
+        description:
+          'Optional refuel body (v0.16.0) — omit it entirely or send {} to fill the tank; both fields are optional.',
+        properties: {
+          mode: {
+            enum: ['full', 'forFlight'],
+            description:
+              '"full" (default) fills the tank to maxFuel; "forFlight" adds just enough fuel for one loaded package\'s destination leg.',
+          },
+          packageId: {
+            type: 'string',
+            description: 'Required with mode "forFlight": a package LOADED on this plane — its destIcao is the refuel target.',
+          },
+        },
+      },
      Error: {
        type: 'object',
        properties: {
@@ -9,11 +9,14 @@ import { loadAirportsGeoJson } from '@/lib/airports';
 import { haversineKm } from '@/lib/geo';
 import { PLANE_TYPES } from '@/lib/game/catalog';
 import { MARKET_TARGET_OPEN_PACKAGES, mulberry32 } from '@/lib/game/seed';
-import { arrivalTimeFor } from './movement';
+import { arrivalTimeFor, fuelAtWeighted } from './movement';
 import {
+  clampTimeScale,
  deliverPackages,
  expirePackages,
  MAX_TICK_ELAPSED_MS,
+  MAX_TIME_SCALE,
+  MIN_TIME_SCALE,
  reputationGainFor,
  spawnCoveragePackages,
  spawnOpenPackages,
@@ -179,7 +182,8 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
    expect(plane.locationIcao).toBe(TO);
    expect(plane.lat).toBe(to.lat);
    expect(plane.lon).toBe(to.lon);
-    expect(plane.fuel).toBeCloseTo(Math.max(0, type.maxFuel - type.burnPerKm * km), 6); // remaining fuel
+    // Remaining fuel per the v0.16.0 weight-proportional burn model (closed form).
+    expect(plane.fuel).toBeCloseTo(fuelAtWeighted(type.maxFuel, type.burnPerKm, type.emptyWeightKg, type.maxFuel, km, 1), 6);
    expect(plane.departureSimTime).toBeNull();
    expect(plane.destIcao).toBeNull(); // flight context cleared on landing

@@ -233,6 +237,80 @@ describe('deliverPackages (v0.12.0 arrival delivery)', () => {
  });
 });

+describe('auto-slow to 1× when the last plane lands (ISS-011)', () => {
+  const FROM = 'EDDF';
+  const TO = 'LEMD';
+
+  // Starter flying EDDF→LEMD with departureSimTime set so its arrival is EXACTLY T0 —
+  // any advancing tick past T0 finalizes it. timeScale is the value under test.
+  async function setupLanding(name: string, timeScale: number) {
+    const inst = await freshDb(name);
+    const fc = await loadAirportsGeoJson();
+    const from = fc.features.find((f) => f.properties.icao === FROM)!.properties;
+    const to = fc.features.find((f) => f.properties.icao === TO)!.properties;
+    const km = haversineKm(from.lat, from.lon, to.lat, to.lon);
+    const type = PLANE_TYPES.atr72;
+
+    await inst.db.update(schema.simState).set({ timeScale });
+    await inst.db.update(schema.planes)
+      .set({ status: 'flying', destIcao: TO, departureSimTime: T0 - travelMs(km, type.speedKmh), fuel: type.maxFuel })
+      .where(eq(schema.planes.id, 'plane-starter'));
+
+    return { inst, from, km, type };
+  }
+
+  it('last plane lands → stored timeScale becomes 1', async () => {
+    const { inst } = await setupLanding('autoslow-last.db', 1000);
+    vi.setSystemTime(T0 + 2_000); // one full clamped tick at scale 1000 → clock T0+2e6 ≥ arrival (T0)
+
+    const sim = await tickOnce(inst);
+
+    expect(sim.timeScale).toBe(1); // persisted on the sim_state row…
+    expect((await inst.db.select().from(schema.simState))[0].timeScale).toBe(1); // …and visible to the next snapshot
+    expect((await inst.db.select().from(schema.planes))[0].status).toBe('available'); // landing itself unchanged
+  });
+
+  it('a landing while another plane is still flying → no change', async () => {
+    const { inst, from, type } = await setupLanding('autoslow-other.db', 1000);
+    // A second plane on the same route departing at T0 — arrives far after this tick's clock.
+    await inst.db.insert(schema.planes).values({
+      id: 'p-b', model: 'atr72', status: 'flying', fuel: type.maxFuel, maxFuel: type.maxFuel,
+      locationIcao: FROM, destIcao: TO, lat: from.lat, lon: from.lon, departureSimTime: T0,
+    });
+
+    vi.setSystemTime(T0 + 2_000);
+    const sim = await tickOnce(inst);
+
+    expect(sim.timeScale).toBe(1000); // p-b still in flight — no auto-slow
+    const byId = new Map((await inst.db.select().from(schema.planes)).map((p) => [p.id, p.status]));
+    expect(byId.get('plane-starter')).toBe('available'); // the starter did land…
+    expect(byId.get('p-b')).toBe('flying'); // …but the fleet is not idle
+  });
+
+  it('already at 1× → stays 1', async () => {
+    const { inst } = await setupLanding('autoslow-one.db', 1);
+    vi.setSystemTime(T0 + 2_000); // one tick at scale 1 advances 2e3 game ms — past the T0 arrival
+
+    const sim = await tickOnce(inst);
+
+    expect(sim.timeScale).toBe(1);
+    expect((await inst.db.select().from(schema.planes))[0].status).toBe('available');
+  });
+
+  it('paused sim with all planes landed → no change', async () => {
+    const inst = await freshDb('autoslow-paused.db');
+    // The fleet is fully grounded (the seeded starter) — a paused tick must not touch the
+    // scale even though "no plane in flight" holds: the trigger requires a landing this tick.
+    await inst.db.update(schema.simState).set({ timeScale: 1000, paused: true });
+
+    vi.setSystemTime(T0 + 5_000);
+    const sim = await tickOnce(inst);
+
+    expect(sim.timeScale).toBe(1000); // no landing processed while paused → trigger never fires
+    expect((await inst.db.select().from(schema.planes))[0].status).toBe('available');
+  });
+});
+
 describe('spawnOpenPackages', () => {
  it('tops the market up to MARKET_TARGET_OPEN_PACKAGES using the shared seed builder', async () => {
    const inst = await freshDb('spawn.db');
@@ -374,6 +452,32 @@ describe('spawnCoveragePackages (v0.8.0 spawn coverage rule)', () => {
  });
 });

+describe('clampTimeScale — v0.14.0 ladder bounds [1, 1000]', () => {
+  it('clamps below-minimum values to MIN_TIME_SCALE', () => {
+    expect(clampTimeScale(0)).toBe(MIN_TIME_SCALE);
+    expect(clampTimeScale(-5)).toBe(MIN_TIME_SCALE);
+    expect(clampTimeScale(0.1)).toBe(MIN_TIME_SCALE);
+  });
+
+  it('clamps above-maximum values to MAX_TIME_SCALE', () => {
+    expect(clampTimeScale(1001)).toBe(MAX_TIME_SCALE);
+    expect(clampTimeScale(2000)).toBe(MAX_TIME_SCALE);
+    expect(clampTimeScale(Number.MAX_SAFE_INTEGER)).toBe(MAX_TIME_SCALE);
+  });
+
+  it('passes in-range values through unclamped — ladder and off-ladder alike', () => {
+    for (const s of [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000]) {
+      expect(clampTimeScale(s)).toBe(s); // the full v0.14.0 slider ladder
+    }
+    expect(clampTimeScale(37)).toBe(37); // off-ladder but in range (e.g. a legacy value)
+  });
+
+  it('keeps the endpoints exact', () => {
+    expect(clampTimeScale(MIN_TIME_SCALE)).toBe(MIN_TIME_SCALE);
+    expect(clampTimeScale(MAX_TIME_SCALE)).toBe(MAX_TIME_SCALE);
+  });
+});
+
 // Local helper mirroring lib/sim/movement.ts (kept private there on purpose — the
 // engine composes arrivalTimeFor; tests just need the duration for fixtures).
 function travelMs(km: number, speedKmh: number): number {
@@ -12,7 +12,7 @@ import {
  type Rng,
  type SeedAirport,
 } from '@/lib/game/seed';
-import { arrivalTimeFor, fuelAt } from './movement';
+import { arrivalTimeFor, fuelAtWeighted } from './movement';

 // Server-authoritative sim engine (v0.7.0) — tick-on-read: there is NO background
 // timer. Every read/action endpoint calls tickNow() first; the clock advances by
@@ -22,12 +22,12 @@ import { arrivalTimeFor, fuelAt } from './movement';
 // Clamp constant: max real-time gap counted by a single tick. Chosen at 2000 ms —
 // comfortably above a normal client poll interval (~1 s), so active play advances
 // ~real time × scale; small enough that one stale read after an absence moves game
-// time by at most 2 s × scale (≈ 2 min even at max scale 64). The sim therefore
+// time by at most 2 s × scale (≈ 33 min even at max scale 1000). The sim therefore
 // only meaningfully progresses while actively polled.
 export const MAX_TICK_ELAPSED_MS = 2_000;

 export const MIN_TIME_SCALE = 1;
-export const MAX_TIME_SCALE = 64; // top of the power-of-two ladder (v0.9.2)
+export const MAX_TIME_SCALE = 1000; // top of the slider ladder (v0.14.0)

 // Reputation gain per delivered package: BASE + PER_KM × great-circle km, rounded
 // to 2 decimals (reputation is REAL). A short hop (~300 km) earns ~1.15 rep, a
@@ -71,17 +71,33 @@ export async function tickOnce(inst: GameDb): Promise<schema.SimStateRow> {
  const advanceMs = sim.paused ? 0 : Math.min(elapsed, MAX_TICK_ELAPSED_MS) * sim.timeScale;
  const clockMs = Math.round(sim.clockMs + advanceMs);

+  let landedThisTick = 0;
  if (advanceMs > 0) {
    await expirePackages(inst, clockMs);
-    await deliverPackages(inst, clockMs);
+    // ISS-011: remember the landings so the tick can auto-slow to 1× when this was
+    // the last plane in flight.
+    landedThisTick = await deliverPackages(inst, clockMs);
    await spawnOpenPackages(inst, clockMs);
    // AFTER delivery on purpose: a plane that just landed gets work spawned
    // at its new location within the same tick.
    await spawnCoveragePackages(inst, clockMs);
  }

+  const sets: Partial<Pick<schema.SimStateRow, 'clockMs' | 'lastRealTickMs' | 'timeScale'>> = {
+    clockMs,
+    lastRealTickMs: nowMs,
+  };
+  // Auto-slow (ISS-011): when ≥1 plane landed this tick and NO plane remains in flight,
+  // drop the stored timeScale to 1× — persisted here so the UI slider reflects it on the
+  // next snapshot. Arrival-triggered by design: a grounded fleet at high scale is left
+  // alone (the player speeds up manually again; there is no auto-restore).
+  if (landedThisTick > 0 && !sim.paused) {
+    const flying = await inst.db.select().from(schema.planes).where(eq(schema.planes.status, 'flying'));
+    if (flying.length === 0) sets.timeScale = MIN_TIME_SCALE;
+  }
+
  // Persist lastRealTickMs even when nothing advanced — it is the tick anchor.
-  await inst.db.update(schema.simState).set({ clockMs, lastRealTickMs: nowMs });
+  await inst.db.update(schema.simState).set(sets);
  await persist(inst);
  const updated = (await inst.db.select().from(schema.simState))[0];
  if (!updated) throw new Error('sim_state row missing after tick');
@@ -131,14 +147,14 @@ export async function deliverPackages(inst: GameDb, clockMs: number): Promise<nu
    const distanceKm = haversineKm(from.lat, from.lon, to.lat, to.lon);
    if (clockMs < arrivalTimeFor(p.departureSimTime, distanceKm, type.speedKmh)) continue;

-    // Arrived: progress is exactly 1 here, so remaining fuel is the full-leg burn.
+    // Arrived: progress is exactly 1 here, so remaining fuel is the full-leg weighted burn.
    await inst.db.update(schema.planes)
      .set({
        status: 'available',
        locationIcao: to.icao,
        lat: to.lat,
        lon: to.lon,
-        fuel: fuelAt(p.fuel, type.burnPerKm, distanceKm, 1),
+        fuel: fuelAtWeighted(p.fuel, type.burnPerKm, type.emptyWeightKg, type.maxFuel, distanceKm, 1),
        departureSimTime: null,
        destIcao: null,
      })
@@ -264,7 +280,7 @@ export function runAction<T>(fn: (inst: GameDb) => Promise<T>): Promise<T> {
 }

 // Tick first so the returned state reflects current time, then apply the new
-// controls. timeScale is clamped to [1, 64]; validation of raw input happens in
+// controls. timeScale is clamped to [1, 1000]; validation of raw input happens in
 // the route handler (400 on non-number / non-boolean).
 export function applyTimeControls(input: SimControlsInput): Promise<schema.SimStateRow> {
  return withLock(async () => {
@@ -1,12 +1,23 @@
 import { describe, expect, it } from 'vitest';
 import { haversineKm } from '@/lib/geo';
-import { arrivalTimeFor, fuelAt, positionAt, progressAt, travelDurationMs } from './movement';
+import {
+  arrivalTimeFor,
+  burnRateConstant,
+  FUEL_DENSITY_KG_PER_L,
+  fuelAtWeighted,
+  positionAt,
+  progressAt,
+  requiredFuelFor,
+  travelDurationMs,
+} from './movement';

 // Synthetic in-flight fixtures — no DB needed: everything is a pure function of
 // the sim clock. ATR 72-600 numbers from lib/game/catalog.ts.
 const DEP = 1_750_000_000_000; // departure sim time (ms)
 const SPEED = 510; // km/h
-const BURN = 1.75; // L/km
+const BURN = 1.75; // L/km at a full tank
+const WE = 9_300; // kg, operating empty weight
+const TANK = 6_300; // liters, full tank

 // Frankfurt → Madrid, real coordinates from the CSV dataset.
 const FROM = { lat: 50.0333, lon: 8.5706 };
@@ -96,17 +107,53 @@ describe('positionAt (great-circle slerp)', () => {
  });
 });

-describe('fuelAt', () => {
-  it('burns fuel proportionally to distance flown', () => {
-    const start = 6_300; // full ATR tank
-    expect(fuelAt(start, BURN, KM, 0)).toBe(start);
-    expect(fuelAt(start, BURN, KM, 0.5)).toBeCloseTo(start - BURN * KM / 2, 9);
-    expect(fuelAt(start, BURN, KM, 1)).toBeCloseTo(start - BURN * KM, 9);
+describe('weighted burn model (v0.16.0)', () => {
+  it('calibrates so a full tank burns exactly the old constant rate', () => {
+    const k = burnRateConstant(BURN, WE, TANK);
+    expect(k * (WE + FUEL_DENSITY_KG_PER_L * TANK)).toBeCloseTo(BURN, 12);
+
+    // Over a short hop from full, weighted ≈ constant — divergence only grows as fuel drops off.
+    const d = 100;
+    const consumed = TANK - fuelAtWeighted(TANK, BURN, WE, TANK, d, 1);
+    expect(Math.abs(consumed - BURN * d)).toBeLessThan(1); // < 1 L over 100 km from full
+  });
+
+  it('consumption matches numeric integration of r(F) = k·(We + ρF)', () => {
+    const k = burnRateConstant(BURN, WE, TANK);
+    const rho = FUEL_DENSITY_KG_PER_L;
+    // Euler-integrate dF/dx = −k(We + ρF) from a full tank over the whole leg.
+    const steps = 200_000;
+    const h = KM / steps;
+    let f = TANK;
+    for (let i = 0; i < steps; i++) f -= k * (WE + rho * f) * h;
+    expect(Math.abs(fuelAtWeighted(TANK, BURN, WE, TANK, KM, 1) - f)).toBeLessThan(0.001); // Euler drift is sub-milliliter here
+  });
+
+  it('requiredFuelFor is zero for a zero leg and strictly increasing in distance', () => {
+    expect(requiredFuelFor(BURN, WE, TANK, 0)).toBe(0);
+    let prev = requiredFuelFor(BURN, WE, TANK, 100);
+    for (const d of [500, 1_000, 2_000, 3_000, 4_000]) {
+      const cur = requiredFuelFor(BURN, WE, TANK, d);
+      expect(cur).toBeGreaterThan(prev);
+      prev = cur;
+    }
+  });
+
+  it('a lighter start burns less over the same distance', () => {
+    const burnFromFull = TANK - fuelAtWeighted(TANK, BURN, WE, TANK, KM, 1);
+    const burnFromHalf = TANK / 2 - fuelAtWeighted(TANK / 2, BURN, WE, TANK, KM, 1);
+    expect(burnFromFull).toBeGreaterThan(burnFromHalf);
+  });
+
+  it('starting with exactly the required fuel arrives on empty', () => {
+    const req = requiredFuelFor(BURN, WE, TANK, KM);
+    expect(fuelAtWeighted(req, BURN, WE, TANK, KM, 1)).toBeCloseTo(0, 6);
  });

  it('clamps at zero instead of going negative', () => {
-    expect(fuelAt(100, BURN, 1_000, 1)).toBe(0); // needs 1750 L, has 100
-    expect(fuelAt(100, BURN, 1_000, 0.01)).toBeCloseTo(100 - 17.5, 9);
+    expect(fuelAtWeighted(100, BURN, WE, TANK, KM, 1)).toBe(0); // needs ~2800 L from full, has 100
+    expect(fuelAtWeighted(TANK, BURN, WE, TANK, KM, 0)).toBe(TANK);
+    expect(fuelAtWeighted(TANK, BURN, WE, TANK, 0, 1)).toBe(TANK);
  });

  it('composes with progressAt for a just-before-arrival snapshot', () => {
@@ -114,9 +161,6 @@ describe('fuelAt', () => {
    const clock = DEP + duration - 1; // one ms before arrival
    const p = positionAt(FROM.lat, FROM.lon, TO.lat, TO.lon, progressAt(DEP, KM, SPEED, clock));
    expect(haversineKm(p.lat, p.lon, TO.lat, TO.lon)).toBeGreaterThan(0); // not yet at the gate
-    expect(fuelAt(6_300, BURN, KM, progressAt(DEP, KM, SPEED, clock))).toBeCloseTo(
-      6_300 - BURN * KM * (1 - 1 / duration),
-      6,
-    );
+    expect(fuelAtWeighted(TANK, BURN, WE, TANK, KM, progressAt(DEP, KM, SPEED, clock))).toBeGreaterThan(0);
  });
 });
@@ -65,8 +65,56 @@ export function positionAt(
  };
 }

-// Fuel remaining after flying `progress` of a leg of distanceKm. Clamped at 0 —
-// range exhaustion is not modeled yet (fuel management/refueling comes later).
-export function fuelAt(startFuel: number, burnPerKm: number, distanceKm: number, progress: number): number {
-  return Math.max(0, startFuel - burnPerKm * distanceKm * progress);
+// --- Weight-proportional fuel burn (v0.16.0) ---
+//
+// The instantaneous burn rate is proportional to total weight: r(F) = k·(We + ρF) L/km,
+// where We is the empty weight in kg, ρ the fuel density and F the current load in
+// liters — a heavier plane burns more per km. k is calibrated so that a FULL tank
+// burns exactly the catalog's constant burnPerKm: k = burnPerKm / (We + ρ·maxFuel),
+// so full-tank legs match the old model at departure and only diverge as fuel (and
+// weight) drops off in flight. Closed forms of dF/dx = −k(We + ρF):
+//   fuel after distance D from F₀:        (F₀ + We/ρ)·e^{−kρD} − We/ρ
+//   consumption over D:                   (F₀ + We/ρ)·(1 − e^{−kρD})
+//   fuel required to cover D arriving with 0, independent of F₀: (We/ρ)(e^{kρD} − 1)
+
+// Jet-A1 density in kg/L — converts a liter load into its weight contribution.
+export const FUEL_DENSITY_KG_PER_L = 0.8;
+
+// Calibration constant k for one plane type (see the model note above).
+export function burnRateConstant(burnPerKm: number, emptyWeightKg: number, maxFuel: number): number {
+  return burnPerKm / (emptyWeightKg + FUEL_DENSITY_KG_PER_L * maxFuel);
+}
+
+// Fuel remaining after flying `progress` of a leg of distanceKm from startFuel under the
+// weighted model. Clamped at 0 — range exhaustion is not modeled (a plane that runs dry
+// limps to the gate on fumes, same as before).
+export function fuelAtWeighted(
+  startFuel: number,
+  burnPerKm: number,
+  emptyWeightKg: number,
+  maxFuel: number,
+  distanceKm: number,
+  progress: number,
+): number {
+  const d = distanceKm * progress;
+  if (d <= 0) return startFuel;
+  const k = burnRateConstant(burnPerKm, emptyWeightKg, maxFuel);
+  const rho = FUEL_DENSITY_KG_PER_L;
+  const f = (startFuel + emptyWeightKg / rho) * Math.exp(-k * rho * d) - emptyWeightKg / rho;
+  return Math.max(0, f);
+}
+
+// Total fuel required to cover distanceKm arriving with an empty tank — independent of the
+// starting load. A leg is flyable from a plane iff its current fuel covers this amount; it
+// fits in the aircraft at all iff this does not exceed the tank capacity.
+export function requiredFuelFor(
+  burnPerKm: number,
+  emptyWeightKg: number,
+  maxFuel: number,
+  distanceKm: number,
+): number {
+  if (distanceKm <= 0) return 0;
+  const k = burnRateConstant(burnPerKm, emptyWeightKg, maxFuel);
+  const rho = FUEL_DENSITY_KG_PER_L;
+  return (emptyWeightKg / rho) * (Math.exp(k * rho * distanceKm) - 1);
 }
@@ -1,16 +1,16 @@
 import { describe, expect, it } from 'vitest';
 import { MAX_SCALE, MIN_SCALE, TIME_SCALES, scaleToSlider, sliderToScale } from './timeScale';

-const STEPS = TIME_SCALES.length - 1; // 6 intervals across the 7 ladder positions
+const STEPS = TIME_SCALES.length - 1; // 9 intervals across the 10 ladder positions (v0.14.0)

 describe('sliderToScale', () => {
-  it('is exact at the endpoints (0 → 1×, 1 → 64×)', () => {
+  it('is exact at the endpoints (0 → 1×, 1 → 1000×)', () => {
    expect(sliderToScale(0)).toBe(MIN_SCALE);
    expect(sliderToScale(1)).toBe(MAX_SCALE);
  });

-  it('maps each of the 7 positions to the power-of-two ladder', () => {
-    const expected = [1, 2, 4, 8, 16, 32, 64];
+  it('maps each of the 10 positions to the ladder', () => {
+    const expected = [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000];
    for (let i = 0; i < TIME_SCALES.length; i++) {
      expect(sliderToScale(i / STEPS)).toBe(expected[i]);
    }
@@ -39,9 +39,9 @@ describe('sliderToScale', () => {
 });

 describe('scaleToSlider', () => {
-  it('is exact at the endpoints (1× → 0, 64× → 1)', () => {
+  it('is exact at the endpoints (1× → 0, 1000× → 1)', () => {
    expect(scaleToSlider(1)).toBe(0);
-    expect(scaleToSlider(64)).toBe(1);
+    expect(scaleToSlider(1000)).toBe(1);
  });

  it('places each ladder value on its own position', () => {
@@ -61,7 +61,7 @@ describe('scaleToSlider', () => {
  it('clamps out-of-range and non-finite input', () => {
    expect(scaleToSlider(0)).toBe(0);
    expect(scaleToSlider(-3)).toBe(0);
-    expect(scaleToSlider(65)).toBe(1);
+    expect(scaleToSlider(1001)).toBe(1); // above the ladder top → clamped to 1000× → t=1
    expect(scaleToSlider(NaN)).toBe(0);
  });
 });
@@ -73,8 +73,9 @@ describe('round-trip', () => {
    }
  });

-  it('maps off-ladder scales to the nearest power of two', () => {
-    expect(sliderToScale(scaleToSlider(3))).toBe(4); // log2(3) ≈ 1.58 → step 2 (4×)
-    expect(sliderToScale(scaleToSlider(60))).toBe(64); // legacy max from the v0.9.x era
+  it('maps off-ladder scales to the nearest ladder step by log distance', () => {
+    expect(sliderToScale(scaleToSlider(3))).toBe(2); // ln 3 ≈ 1.10 → closer to 2 (ln ≈ 0.69) than 5 (ln ≈ 1.61)
+    expect(sliderToScale(scaleToSlider(60))).toBe(50); // legacy max from the v0.9.x era sits between 50 and 100, nearer 50
+    expect(sliderToScale(scaleToSlider(200))).toBe(250); // ln 200 ≈ 5.30 → closer to 250 (ln ≈ 5.52) than 100 (ln ≈ 4.61)
  });
 });
@@ -1,24 +1,33 @@
-// Pure mapping helpers for the time-scale slider (v0.9.2) — no game logic, unit-testable
-// in node. The slider has 7 discrete positions on a power-of-two ladder:
-// 1× → 2× → 4× → 8× → 16× → 32× → 64×, so each step doubles the speed (matching
-// POST /api/sim's clamp range [1, 64]).
+// Pure mapping helpers for the time-scale slider (v0.9.2, values reworked in v0.14.0) — no
+// game logic, unit-testable in node. The slider has 10 discrete positions on a mixed
+// ×2/×2.5 ladder: 1× → 2× → 5× → 10× → 25× → 50× → 100× → 250× → 500× → 1000×, so each
+// step roughly doubles the speed (matching POST /api/sim's clamp range [1, 1000]).

-export const TIME_SCALES = [1, 2, 4, 8, 16, 32, 64] as const;
+export const TIME_SCALES = [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000] as const;
 export const MIN_SCALE: number = TIME_SCALES[0];
 export const MAX_SCALE: number = TIME_SCALES[TIME_SCALES.length - 1];

 const clamp = (v: number, lo: number, hi: number) => Math.min(hi, Math.max(lo, v));

 // t → scale: the position maps to the nearest ladder step. Exact at the endpoints:
-// sliderToScale(0) === 1, sliderToScale(1) === 64.
+// sliderToScale(0) === 1, sliderToScale(1) === 1000.
 export function sliderToScale(t: number): number {
  const tt = clamp(Number.isFinite(t) ? t : 0, 0, 1);
  return TIME_SCALES[clamp(Math.round(tt * (TIME_SCALES.length - 1)), 0, TIME_SCALES.length - 1)];
 }

-// scale → t: the nearest ladder position by log2 distance. Exact at the endpoints:
-// scaleToSlider(1) === 0, scaleToSlider(64) === 1; round-trips every value in TIME_SCALES.
+// scale → t: the nearest ladder position by log distance. Exact at the endpoints:
+// scaleToSlider(1) === 0, scaleToSlider(1000) === 1; round-trips every value in TIME_SCALES.
 export function scaleToSlider(scale: number): number {
  const s = clamp(Number.isFinite(scale) ? scale : MIN_SCALE, MIN_SCALE, MAX_SCALE);
-  return Math.log2(s) / Math.log2(MAX_SCALE);
+  let best = 0;
+  let bestDist = Infinity;
+  for (let i = 0; i < TIME_SCALES.length; i++) {
+    const d = Math.abs(Math.log(s) - Math.log(TIME_SCALES[i]));
+    if (d < bestDist) {
+      bestDist = d;
+      best = i;
+    }
+  }
+  return best / (TIME_SCALES.length - 1);
 }
@@ -0,0 +1,53 @@
+'use client';
+
+import { useCallback, useEffect, useState } from 'react';
+import type { StateSnapshot } from '@/lib/game/state';
+
+// ISS-021 (v0.20.0) — shared action runner for the side panes (extracted verbatim from
+// RightPane.runAction when the On board section moved to LeftPane). POSTs an action endpoint;
+// every success returns the FULL post-action snapshot (v0.8.0 convention), pushed into the
+// shared shell state immediately via applySnapshot so the UI updates without waiting for the
+// next poll tick. A non-2xx {error} body becomes the pane's inline error AND is mirrored to
+// the shell as a bottom-right toast via onError (ISS-008 — both surfaces by design). Buttons
+// are disabled while a request is in flight, so at most one action runs per pane at a time.
+export function useGameAction(
+  state: StateSnapshot | null,
+  applySnapshot: (snapshot: StateSnapshot) => void,
+  onError?: (message: string) => void,
+): { runAction: (path: string, body?: unknown) => Promise<void>; busy: boolean; actionError: string | null } {
+  const [busy, setBusy] = useState(false);
+  // Inline error from a failed action — auto-clears on the next successful poll (the shell's
+  // snapshot prop changes every tick) or the next successful action.
+  const [actionError, setActionError] = useState<string | null>(null);
+  useEffect(() => {
+    if (state !== null) setActionError(null);
+  }, [state]);
+
+  const runAction = useCallback(
+    async (path: string, body?: unknown) => {
+      if (busy) return;
+      setBusy(true);
+      try {
+        const res = await fetch(path, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: body === undefined ? undefined : JSON.stringify(body),
+          cache: 'no-store',
+        });
+        const data = (await res.json()) as StateSnapshot & { error?: string };
+        if (!res.ok) throw new Error(data.error ?? `HTTP ${res.status}`);
+        setActionError(null);
+        applySnapshot(data);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        setActionError(message); // inline pane error stays…
+        onError?.(message); // …and the shell mirrors it as a bottom-right toast (ISS-008)
+      } finally {
+        setBusy(false);
+      }
+    },
+    [applySnapshot, busy, onError],
+  );
+
+  return { runAction, busy, actionError };
+}
@@ -21,7 +21,18 @@ export interface GameStateResult {
 export async function fetchState(): Promise<StateSnapshot> {
  const res = await fetch('/api/state', { cache: 'no-store' });
  if (!res.ok) throw new Error(`GET /api/state → HTTP ${res.status}`);
-  return (await res.json()) as StateSnapshot;
+  const snapshot = (await res.json()) as StateSnapshot;
+  // Dev/e2e hook (v0.15.0): the last successfully polled snapshot, so tests can compare what
+  // the BROWSER received against a fresh node-side fetch. Client-only, harmless in prod.
+  if (typeof window !== 'undefined') {
+    (window as unknown as Record<string, unknown>).__flightLastSnapshot = {
+      planeIds: snapshot.planes.map((p) => p.id),
+      cash: snapshot.account.cash,
+      timeScale: snapshot.simState.timeScale,
+      at: Date.now(),
+    };
+  }
+  return snapshot;
 }

 // The shell's single polling source (v0.9.0): one GET /api/state loop for the whole page,
@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest';
+import { advanceSimClock, type SimClockAnchor } from './useSimClock';
+
+// ISS-007 (v0.16.1) — the pure extrapolation core of lib/useSimClock.ts. The hook itself is a
+// thin setInterval + re-sync wrapper covered by e2e (panes.spec.ts "ticks smoothly between polls");
+// this suite pins the math: game time advances real-time × timeScale, frozen while paused.
+
+const anchor = (over: Partial<SimClockAnchor> = {}): SimClockAnchor => ({
+  clockMs: 1_750_000_000_000,
+  at: 1_000_000,
+  timeScale: 1,
+  paused: false,
+  ...over,
+});
+
+describe('advanceSimClock', () => {
+  it('advances by exactly elapsed real-time × timeScale while running', () => {
+    expect(advanceSimClock(anchor(), 1_001_000)).toBe(1_750_000_000_000 + 1_000); // scale 1: 1 s real = 1 s game
+    expect(advanceSimClock(anchor({ timeScale: 25 }), 1_002_500)).toBe(1_750_000_000_000 + 62_500);
+    // The e2e scenario: scale 1000, 2.5 s real → 2 500 game seconds.
+    expect(advanceSimClock(anchor({ timeScale: 1000 }), 1_002_500)).toBe(1_750_000_000_000 + 2_500_000);
+  });
+
+  it('returns the anchor value exactly at zero elapsed', () => {
+    expect(advanceSimClock(anchor({ timeScale: 1000 }), 1_000_000)).toBe(1_750_000_000_000);
+  });
+
+  it('is frozen while paused regardless of elapsed or scale', () => {
+    const a = anchor({ timeScale: 1000, paused: true });
+    expect(advanceSimClock(a, 1_000_000)).toBe(1_750_000_000_000);
+    expect(advanceSimClock(a, 2_000_000)).toBe(1_750_000_000_000); // a full second later — still frozen
+  });
+
+  it('clamps to the anchor value when nowMs is before the anchor (clock skew), never backwards', () => {
+    expect(advanceSimClock(anchor({ timeScale: 1000 }), 999_999)).toBe(1_750_000_000_000);
+    expect(advanceSimClock(anchor({ paused: true }), 999_999)).toBe(1_750_000_000_000);
+  });
+
+  it('mirrors the server tick model (tickOnce): advance = elapsed × timeScale while actively polled', () => {
+    // lib/sim/engine.ts: clockMs += min(now − lastRealTickMs, MAX_TICK_ELAPSED_MS) × timeScale.
+    // For gaps under the 2 s clamp the client extrapolation is exactly the server's own formula.
+    const scale = 50;
+    for (const gap of [1, 250, 999, 1_999]) {
+      expect(advanceSimClock(anchor({ timeScale: scale }), 1_000_000 + gap)).toBe(
+        1_750_000_000_000 + gap * scale,
+      );
+    }
+  });
+});
@@ -0,0 +1,68 @@
+'use client';
+
+import { useEffect, useRef, useState } from 'react';
+import type { StateSnapshot } from './game/state';
+
+// ISS-007 (v0.16.1): the sim clock ticks smoothly on the CLIENT between polls instead of
+// jumping once per snapshot. The server's authoritative rate is exactly real-time × timeScale
+// (tickOnce in lib/sim/engine.ts: advance = min(elapsed, MAX_TICK_ELAPSED_MS) × timeScale), so
+// client-side extrapolation mirrors the server's own model. Every new snapshot re-anchors to
+// server truth, bounding any drift by network latency only.
+
+export interface SimClockAnchor {
+  // Server truth at anchor time — the snapshot's simState.clockMs.
+  clockMs: number;
+  // Date.now() when that snapshot was received.
+  at: number;
+  timeScale: number;
+  paused: boolean;
+}
+
+// Pure core of the extrapolation — mirrors tickOnce: while running, game time advances by
+// real-time × timeScale; while paused it is frozen (advance 0). nowMs before `at` clamps to
+// the anchor value instead of going backwards. Unit-testable in node.
+export function advanceSimClock(anchor: SimClockAnchor, nowMs: number): number {
+  if (anchor.paused) return anchor.clockMs;
+  return anchor.clockMs + Math.max(0, nowMs - anchor.at) * anchor.timeScale;
+}
+
+// ~10 fps display refresh — smooth for a seconds-precision wall clock without busy re-renders.
+const DISPLAY_TICK_MS = 100;
+
+export interface SimClockControls {
+  // EFFECTIVE controls (optimistic pending scale / current pause), not the snapshot's:
+  // UI changes take effect on click/drag without waiting for a confirming snapshot.
+  timeScale: number;
+  paused: boolean;
+}
+
+// Returns the display clockMs to render, or null until the first snapshot arrives.
+export function useSimClock(snapshot: StateSnapshot | null, controls: SimClockControls): number | null {
+  const anchorRef = useRef<SimClockAnchor | null>(null);
+  const [displayMs, setDisplayMs] = useState<number | null>(null);
+
+  // Re-sync on every snapshot AND effective-control change: snap to server truth. The snapshot
+  // object is fresh per poll (useGameState), so this runs once per poll cycle as well.
+  useEffect(() => {
+    if (!snapshot) return;
+    anchorRef.current = {
+      clockMs: snapshot.simState.clockMs,
+      at: Date.now(),
+      timeScale: controls.timeScale,
+      paused: controls.paused,
+    };
+    setDisplayMs(advanceSimClock(anchorRef.current, Date.now()));
+  }, [snapshot, controls.timeScale, controls.paused]);
+
+  useEffect(() => {
+    const id = setInterval(() => {
+      const anchor = anchorRef.current;
+      if (anchor) setDisplayMs(advanceSimClock(anchor, Date.now()));
+    }, DISPLAY_TICK_MS);
+    return () => clearInterval(id);
+  }, []);
+
+  // First paint after a snapshot arrives happens before the re-sync effect runs — show the
+  // snapshot value directly so the clock never blanks for a frame.
+  return displayMs ?? (snapshot ? snapshot.simState.clockMs : null);
+}
@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { MAX_TOASTS, pushToast, type Toast } from './useToasts';
+
+// ISS-008 (v0.17.0): the toast queue's pure core — append + cap at MAX_TOASTS dropping the
+// oldest. The hook itself is a thin useState wrapper around this (auto-dismiss timers are
+// plain setTimeout, covered by e2e via the visible toasts).
+
+const toast = (id: number, message: string): Toast => ({ id, kind: 'info', message });
+
+describe('pushToast', () => {
+  it('appends to an empty queue and preserves order', () => {
+    expect(pushToast([], toast(1, 'a'))).toEqual([toast(1, 'a')]);
+    expect(pushToast([toast(1, 'a')], toast(2, 'b'))).toEqual([toast(1, 'a'), toast(2, 'b')]);
+  });
+
+  it('keeps the newest MAX_TOASTS entries, dropping the oldest beyond the cap', () => {
+    let queue: Toast[] = [];
+    for (let id = 1; id <= MAX_TOASTS + 2; id++) queue = pushToast(queue, toast(id, `m${id}`));
+    expect(queue).toEqual([toast(MAX_TOASTS - 1, 'm3'), toast(MAX_TOASTS, 'm4'), toast(MAX_TOASTS + 1, 'm5'), toast(MAX_TOASTS + 2, 'm6')]);
+  });
+
+  it('does not mutate the input queue', () => {
+    const before = [toast(1, 'a')];
+    pushToast(before, toast(2, 'b'));
+    expect(before).toEqual([toast(1, 'a')]);
+  });
+});
@@ -0,0 +1,50 @@
+'use client';
+
+import { useCallback, useRef, useState } from 'react';
+
+// ISS-008 (v0.17.0): transient toast notifications — a bottom-right stack for action errors
+// and game events derived from snapshot diffs. Each toast auto-dismisses after TOAST_TTL_MS;
+// the queue is capped at MAX_TOASTS (oldest dropped) so an event burst can't fill the corner.
+
+export type ToastKind = 'error' | 'info';
+
+export interface Toast {
+  id: number;
+  kind: ToastKind;
+  message: string;
+}
+
+export const TOAST_TTL_MS = 5_000;
+export const MAX_TOASTS = 4;
+
+// Pure core (unit-tested): append a toast, dropping the oldest beyond the cap.
+export function pushToast(toasts: Toast[], toast: Toast): Toast[] {
+  return [...toasts, toast].slice(-MAX_TOASTS);
+}
+
+export interface UseToastsResult {
+  toasts: Toast[];
+  push: (kind: ToastKind, message: string) => void;
+  dismiss: (id: number) => void;
+}
+
+export function useToasts(): UseToastsResult {
+  const [toasts, setToasts] = useState<Toast[]>([]);
+  const nextIdRef = useRef(1);
+
+  // Functional update — a late timer for an already-dismissed/dropped id is a no-op.
+  const dismiss = useCallback((id: number) => {
+    setToasts((current) => current.filter((t) => t.id !== id));
+  }, []);
+
+  const push = useCallback(
+    (kind: ToastKind, message: string) => {
+      const toast: Toast = { id: nextIdRef.current++, kind, message };
+      setToasts((current) => pushToast(current, toast));
+      setTimeout(() => dismiss(toast.id), TOAST_TTL_MS);
+    },
+    [dismiss],
+  );
+
+  return { toasts, push, dismiss };
+}
@@ -1,6 +1,6 @@
 {
  "name": "flight-ops",
-  "version": "0.12.2",
+  "version": "0.22.2",
  "private": true,
  "scripts": {
    "dev": "next dev -p 3000",
@@ -19,6 +19,7 @@
    "sql.js": "^1.14.2"
  },
  "devDependencies": {
+    "@playwright/test": "1.63.0",
    "@types/node": "^22.20.3",
    "@types/react": "^19.3.0",
    "@types/react-dom": "^19.3.0",
@@ -1,28 +1,33 @@
 import { defineConfig } from '@playwright/test';

-const remoteRunner = true;
+// Browsers run on the shared remote Playwright server by default (AGENTS.md).
+// PW_REMOTE_BROWSER=0 → local browsers instead (CI, or boxes without LAN access to 192.168.1.4).
+const remoteBrowser = process.env.PW_REMOTE_BROWSER !== '0';

-if (!process.env.PW_TEST_CONNECT_WS_ENDPOINT) {
+if (!process.env.PW_TEST_CONNECT_WS_ENDPOINT && remoteBrowser) {
  process.env.PW_TEST_CONNECT_WS_ENDPOINT = 'ws://192.168.1.4:3000/';
 }

+// App under test. Default: the live compose instance behind Traefik, deployed manually
+// before running the suite (AGENTS.md). When E2E_DEPLOY_CMD is set it runs as a webServer
+// and the suite waits for baseURL to come up — CI uses this to target an isolated stack
+// inside dind instead of production. All vars optional; unset = current local behavior.
+const deployCmd = process.env.E2E_DEPLOY_CMD;
+const baseUrl = process.env.E2E_BASE_URL ?? 'https://flight.dev.kkhost.pl';
+
 export default defineConfig({
  testDir: './e2e',
+  globalSetup: './e2e/ci-diagnostics.ts',
  // Serial execution: e2e/state.spec.ts restarts the compose container mid-run,
  // which would break any map test running concurrently in another worker.
  workers: 1,
  timeout: 300_000,
  retries: 1,
  use: {
-    baseURL: process.env.E2E_BASE_URL ?? 'https://flight.dev.kkhost.pl',
+    baseURL: baseUrl,
    trace: 'on-first-retry',
  },
-  webServer: remoteRunner
-    ? undefined
-    : {
-        command: 'docker compose up -d --build',
-        url: 'https://flight.dev.kkhost.pl',
-        reuseExistingServer: true,
-        timeout: 600_000,
-      },
-});
+  webServer: deployCmd
+    ? { command: deployCmd, url: baseUrl, reuseExistingServer: true, timeout: 600_000 }
+    : undefined,
+});
Author	SHA1	Message	Date
kamilkrzywda	8eeef401ae	Merge pull request 'v0.22.2 — commit ORCHESTRATOR.md manual' (#38 ) from docs/orchestrator-md-v2 into master CI / build + unit + e2e (push) Successful in 6m9s Details	2026-09-20 09:57:56 +02:00
kamilkrzywda	f273d385c2	docs: make ORCHESTRATOR.md durable — drop specifics that rot (test counts, CI run numbers, paint values) CI / build + unit + e2e (pull_request) Successful in 6m29s Details	2026-09-20 07:50:11 +00:00
kamilkrzywda	3b02c7feac	docs: document GITEA_TOKEN in .env.example CI / build + unit + e2e (pull_request) Failing after 7m17s Details	2026-09-20 07:41:55 +00:00
kamilkrzywda	1ba70ebbf3	docs: commit ORCHESTRATOR.md manual (token via gitignored .env) CI / build + unit + e2e (pull_request) Successful in 6m32s Details	2026-09-20 07:34:04 +00:00
kamilkrzywda	08a819e44c	Merge pull request 'v0.22.1 — gitignore local-only ORCHESTRATOR.md' (#37 ) from fix/gitignore-local-docs into master CI / build + unit + e2e (push) Successful in 6m27s Details	2026-09-20 09:06:59 +02:00
kamilkrzywda	50a9147665	chore: gitignore local-only ORCHESTRATOR.md manual CI / build + unit + e2e (pull_request) Successful in 6m30s Details	2026-09-20 06:58:42 +00:00
kamilkrzywda	5391636979	Merge pull request 'v0.22.0 — ISS-022/025/027 hover route trace (job list, on-board rows, relocation panel)' (#34 ) from feat/hover-trace into master CI / build + unit + e2e (push) Failing after 7m10s Details	2026-09-20 03:58:03 +02:00
kamilkrzywda	ab79d9b17f	fix(e2e): renderedFeatures — evaluate maplibre geometry getter in-page before Playwright serialization drops it CI / build + unit + e2e (pull_request) Successful in 7m28s Details	2026-09-20 01:50:23 +00:00
kamilkrzywda	505a58b4fe	fix(e2e): expectHoverRoute — ignore queryRenderedFeatures artifacts without LineString geometry (CI run #70 ) CI / build + unit + e2e (pull_request) Failing after 7m49s Details	2026-09-20 01:22:23 +00:00
kamilkrzywda	2655ef81c8	fix: hover-route line not drawn in e2e — MapLibre clips queried lines across tiles and quantizes their coordinates (strict single-feature equality never matched) CI / build + unit + e2e (pull_request) Failing after 6m44s Details	2026-09-19 22:52:12 +00:00
kamilkrzywda	ac4e3fa316	feat: v0.22.0 — ISS-022 target airport distinct-color ring on job-list / relocation hover CI / build + unit + e2e (pull_request) Failing after 8m51s Details	2026-09-19 22:01:02 +00:00
kamilkrzywda	f2dbad5e03	feat: v0.22.0 — ISS-022/025/027 hover route trace on job list, on-board rows and relocation panel	2026-09-19 21:47:00 +00:00
kamilkrzywda	096a6bfe61	Merge pull request 'v0.21.0 — ISS-023 Relocate (empty flight) panel moves to left pane' (#33 ) from feat/relocate-left-pane into master CI / build + unit + e2e (push) Successful in 5m52s Details	2026-09-19 23:14:42 +02:00
kamilkrzywda	71ee63b38a	feat: v0.21.0 — ISS-023 Relocate panel moves to left pane CI / build + unit + e2e (pull_request) Successful in 5m54s Details	2026-09-19 21:02:55 +00:00
kamilkrzywda	a4f7947666	Merge pull request 'feat: v0.20.0 — ISS-021 move On board to left pane, widen left 360/280' (#31 ) from feat/onboard-left-pane into master CI / build + unit + e2e (push) Successful in 6m8s Details	2026-09-19 22:52:02 +02:00
kamilkrzywda	570ad52d47	feat: v0.20.0 part 2 — ISS-028 on-board rows two-line layout + airport name ellipsis CI / build + unit + e2e (pull_request) Successful in 7m1s Details	2026-09-19 20:41:33 +00:00
kamilkrzywda	59974d1b79	feat: v0.20.0 — ISS-021 move On board to left pane, widen left 360/280	2026-09-19 20:41:33 +00:00
kamilkrzywda	af5176354a	Merge pull request 'v0.19.2 — AGENTS.md: CI-only e2e workflow + connected-issues exception' (#32 ) from docs/agents-md-e2e-ci-only into master CI / build + unit + e2e (push) Successful in 6m23s Details	2026-09-19 22:34:34 +02:00
kamilkrzywda	f5468bb640	docs: v0.19.2 — AGENTS.md e2e section reflects CI-only runs; connected issues may be done together CI / build + unit + e2e (pull_request) Successful in 7m5s Details	2026-09-19 20:06:40 +00:00
kamilkrzywda	0970ee4710	docs: v0.19.1 — AGENTS.md documents enforced CI gate + auto-merge CI / build + unit + e2e (pull_request) Successful in 7m32s Details CI / build + unit + e2e (push) Successful in 6m43s Details	2026-09-19 18:49:52 +00:00
kamilkrzywda	6e1439391a	Merge pull request 'v0.19.0 — ISS-011 auto-slow to 1× when all planes have landed' (#24 ) from feat/auto-slow-on-idle into master CI / build + unit + e2e (push) Successful in 5m59s Details	2026-09-19 20:27:00 +02:00
kamilkrzywda	86379fc9c6	feat: v0.19.0 — ISS-011 auto-slow to 1x when all planes have landed CI / build + unit + e2e (pull_request) Successful in 6m14s Details	2026-09-19 18:07:42 +00:00
kamilkrzywda	f0602453ea	Merge pull request 'v0.18.0 — ISS-010 relocate empty planes + bigger airport markers + popup options' (#20 ) from feat/plane-relocation into master CI / build + unit + e2e (push) Successful in 6m4s Details	2026-09-19 18:44:56 +02:00
kamilkrzywda	337eda2743	test: target the plane option specifically in relocation popup e2e CI / build + unit + e2e (pull_request) Successful in 7m32s Details	2026-09-19 16:35:19 +00:00
kamilkrzywda	8852ae11f2	test: fix POPUP_AIRPORT scoping in relocation popup e2e CI / build + unit + e2e (pull_request) Failing after 6m49s Details	2026-09-19 16:23:03 +00:00
kamilkrzywda	008a77e456	feat: v0.18.0 part 3 — market row to relocate a grounded plane CI / build + unit + e2e (pull_request) Failing after 6m17s Details	2026-09-19 16:03:03 +00:00
kamilkrzywda	3e62d63418	feat: v0.18.0 part 2 — airport popup relocate options	2026-09-19 15:57:33 +00:00
kamilkrzywda	09c1d8bcd8	feat: v0.18.0 part 1 — ISS-010 bigger airport markers	2026-09-19 15:57:23 +00:00
kamilkrzywda	0467b54c70	Merge pull request 'v0.17.0 — ISS-008 toasts for errors/events + browser notifications' (#19 ) from feat/toasts-and-notifications into master CI / build + unit + e2e (push) Successful in 6m31s Details	2026-09-19 17:33:14 +02:00
kamilkrzywda	51d4f21d6b	fix: v0.17.0 — sim-control POST retries + permission-aware notifications e2e CI / build + unit + e2e (pull_request) Successful in 6m52s Details	2026-09-19 15:23:20 +00:00
kamilkrzywda	d8dc785757	feat: v0.17.0 — ISS-008 toasts for errors/events + browser notifications CI / build + unit + e2e (pull_request) Failing after 6m59s Details	2026-09-19 14:52:36 +00:00
kamilkrzywda	eb69359a38	Merge pull request 'v0.16.1 — ISS-007 smooth client-side sim clock with per-snapshot re-sync' (#18 ) from feat/smooth-sim-clock into master CI / build + unit + e2e (push) Successful in 6m34s Details	2026-09-19 16:27:21 +02:00
kamilkrzywda	3acf471295	test: fix ISS-007 clock parse — replace only fixed the first space CI / build + unit + e2e (pull_request) Successful in 6m4s Details	2026-09-19 14:20:34 +00:00
kamilkrzywda	7d2f8f07c8	feat: v0.16.1 — ISS-007 smooth client-side sim clock with per-snapshot re-sync CI / build + unit + e2e (pull_request) Failing after 6m42s Details	2026-09-19 14:00:47 +00:00
kamilkrzywda	05d956f71b	Merge pull request 'v0.16.0 — ISS-005 weighted fuel burn + "refuel just enough" per package' (#17 ) from feat/fuel-weight-refuel-for-flight into master CI / build + unit + e2e (push) Successful in 6m23s Details	2026-09-19 15:44:09 +02:00
kamilkrzywda	ae1cb93a4f	test: harden full-core-loop against Load/Fly precondition races CI / build + unit + e2e (pull_request) Successful in 6m32s Details	2026-09-19 13:36:27 +00:00
kamilkrzywda	687e4f2169	fix: forFlight refuel leaves an exactly-feasible tank (round up) — e2e 409 CI / build + unit + e2e (pull_request) Failing after 5m26s Details	2026-09-19 13:00:06 +00:00
kamilkrzywda	a801311fc5	feat: v0.16.0 — ISS-005 weight-proportional fuel burn + refuel just enough for the loaded package CI / build + unit + e2e (pull_request) Failing after 5m28s Details Part A: r(F) = k(We + rhoF) L/km, k calibrated so a full tank burns exactly the old constant; closed forms in lib/sim/movement.ts (fuelAtWeighted, requiredFuelFor, burnRateConstant, FUEL_DENSITY_KG_PER_L). Catalog gains emptyWeightKg (ATR72 OEW 9300 kg), exposed in the snapshot. All three burn call sites (engine landing, state live fuel, fly validation) moved to the weighted model; old constant-rate fuelAt removed. Part B: POST /api/planes/{planeId}/refuel takes an optional body {mode:'full'\|'forFlight', packageId} — no body keeps today's fill-to-full behavior exactly (fuel lands bit-exact on maxFuel); forFlight adds just enough for the loaded package's destination leg (409 not-loaded/expired/ doesn't-fit, 400 bad body). UI: per-cargo-row 'Refuel' button (refuel-for-{pkg.id}), market button renamed 'Refuel to full'. OpenAPI: RefuelRequest schema + optional requestBody + 400 on refuel, fly's 409 description updated, CatalogEntry.emptyWeightKg. Tests: new weighted-burn suite, forFlight action/route cases (incl. ~7670 km UNNT<->LPPD doesn't-fit), openapi guards; landing-fuel assertions in engine.test.ts + e2e/actions.spec.ts use the closed form; the e2e 'return leg unfuelable' scenario reworked — a full tank now covers the EDDF<->LEZL round trip, so the 409 moves to the second outbound. New e2e: row Refuel deducts exactly Lprice / raises fuel by exactly L via the endpoint's own response snapshot.	2026-09-19 12:24:34 +00:00
kamilkrzywda	1dc5beb0dd	Merge pull request 'v0.15.1 — ISS-004 right pane widened, On-board wrapping fixed' (#16 ) from fix/right-pane-width into master CI / build + unit + e2e (push) Successful in 5m4s Details	2026-09-19 13:38:52 +02:00
kamilkrzywda	b6bfcedaf6	test: click the rendered marker position while paused — closes render-lag race (CI run #37 ) CI / build + unit + e2e (pull_request) Successful in 5m0s Details	2026-09-19 11:32:19 +00:00
kamilkrzywda	4c99dbe550	fix: v0.15.1 — ISS-004 right pane widened to 360px, on-board wrap fixes CI / build + unit + e2e (pull_request) Failing after 6m15s Details	2026-09-19 11:05:02 +00:00
kamilkrzywda	e6d7e03934	Merge pull request 'v0.15.0 — ISS-002 hovering a plane or package in the side panels highlights it on the map' (#15 ) from feat/map-hover-highlight into master CI / build + unit + e2e (push) Failing after 4m21s Details	2026-09-19 12:57:45 +02:00
kamilkrzywda	08094a00e2	test: hover spec — fleet row testid is plane-${p.id} (double prefix), derive from state CI / build + unit + e2e (pull_request) Successful in 5m42s Details	2026-09-19 10:51:18 +00:00
kamilkrzywda	eff934a1cc	test: decisive hover diagnostics — browser snapshot vs node state + fleet HTML; CI fresh DB per run CI / build + unit + e2e (pull_request) Failing after 6m3s Details	2026-09-19 10:35:36 +00:00
kamilkrzywda	3209dea425	test: hover spec — robust fleet-row wait + fit map to both endpoints before asserting CI / build + unit + e2e (pull_request) Failing after 6m15s Details	2026-09-19 10:06:48 +00:00
kamilkrzywda	3b6506832f	feat: v0.15.0 — ISS-002 hovering a plane or package in the side panels highlights it on the map CI / build + unit + e2e (pull_request) Failing after 6m8s Details	2026-09-19 09:37:42 +00:00
kamilkrzywda	7db8fcc549	Merge pull request 'v0.14.0 — ISS-006 time-scale slider values up to 1000x; tests use fastest time' (#14 ) from feat/time-scale-slider-1000x into master CI / build + unit + e2e (push) Successful in 4m27s Details	2026-09-19 11:16:55 +02:00
kamilkrzywda	d65d4e45b9	test: pause sim around plane-popup marker click at 1000× (rendered marker lags fresh state by one poll) CI / build + unit + e2e (pull_request) Successful in 4m43s Details	2026-09-19 09:11:10 +00:00
kamilkrzywda	bd00b2b4c4	feat: v0.14.0 — ISS-006 time-scale slider values up to 1000x; tests use fastest time CI / build + unit + e2e (pull_request) Failing after 4m52s Details	2026-09-19 08:49:30 +00:00
kamilkrzywda	0c9279818a	ci: e2e list reporter — per-test progress in job log CI / build + unit + e2e (pull_request) Successful in 19m58s Details CI / build + unit + e2e (push) Successful in 18m20s Details	2026-09-19 08:09:32 +00:00
kamilkrzywda	eb2e7a7430	Merge pull request 'CI: Gitea Actions pipeline (build → unit → e2e) + pull-request workflow' (#9 ) from ci/pr-workflow into master CI / build + unit + e2e (push) Failing after 13m20s Details	2026-09-19 09:59:49 +02:00
kamilkrzywda	97f82dd464	ci: self-hosted map assets for e2e — download + cache pack, mount ./public CI / build + unit + e2e (pull_request) Successful in 18m27s Details	2026-09-19 07:55:29 +00:00
kamilkrzywda	aa5eabeb78	ci: bounded retries around playwright browser install — flaky CDN, progress accumulates	2026-09-19 07:53:22 +00:00
kamilkrzywda	35493f92f0	ci: cache playwright browsers across runs; drop no-op save step	2026-09-19 07:53:22 +00:00
kamilkrzywda	e694011302	ci: e2e — static in-network IP for the app (bypass DNS) + post-deploy chromium diagnostics	2026-09-19 07:53:22 +00:00
kamilkrzywda	0bfbd2a2e8	ci: e2e — bypass proxy for in-network app host + connectivity diagnostics	2026-09-19 07:53:22 +00:00
kamilkrzywda	b112339dd3	ci: keep e2e webServer alive — up -d returns immediately, playwright needs a long-running cmd	2026-09-19 07:53:22 +00:00
kamilkrzywda	f89f0407ae	ci: image build needs no outbound net — copy job-installed node_modules; base alpine→slim	2026-09-19 07:53:22 +00:00
kamilkrzywda	14aaf26900	ci: revert to run-12 workflow state — retries restored, diagnostics removed	2026-09-19 07:53:22 +00:00
kamilkrzywda	c30f5f650f	ci: v0.13.0 — DNS diagnostics daemon-side probe uses local node:22-alpine (no image pull)	2026-09-19 07:53:22 +00:00
kamilkrzywda	54c7a0c5f5	ci: v0.13.0 — drop retry wrappers; add non-fatal DNS diagnostics step	2026-09-19 07:53:22 +00:00
kamilkrzywda	d0149c6ab3	ci: v0.13.0 — retry wrappers for flaky runner network (bun install, dep install, e2e image build)	2026-09-19 07:53:22 +00:00
kamilkrzywda	579d425b64	ci: v0.13.0 — plain-progress image build, bun cache mounts + actions/cache around dep install	2026-09-19 07:53:22 +00:00
kamilkrzywda	543aad310c	ci: v0.13.0 — drop daemon probing; runner provides docker out of the box	2026-09-19 07:53:22 +00:00
kamilkrzywda	5ee0d89826	ci: v0.13.0 — e2e via shared docker network (flight-ci-e2e) instead of endpoint-derived URL	2026-09-19 07:53:22 +00:00
kamilkrzywda	47381f2011	ci: adapt to full-dind runner — drop dind service, resolve daemon endpoint	2026-09-19 07:53:22 +00:00
kamilkrzywda	775b0e479a	ci: allow manual workflow dispatch	2026-09-19 07:53:22 +00:00
kamilkrzywda	0c921556fb	chore: v0.13.0 — CI pipeline (build → unit → e2e) on PRs to master + push, dind-isolated e2e stack (docker-compose.ci.yml), playwright config env-var overrides (PW_REMOTE_BROWSER/E2E_DEPLOY_CMD/E2E_BASE_URL/E2E_COMPOSE_ARGS, backward-compatible), @playwright/test pinned as devDependency; AGENTS.md switched to pull-request workflow	2026-09-19 07:53:22 +00:00
kamilkrzywda	db998a9dfb	test: v0.12.3 — remove unreliable curved-route e2e assertion (querySourceFeatures returns tile-simplified geometry at low zoom, so coordinate counts are not a valid signal; arc stays unit-tested in lib/mapData.test.ts)	2026-09-19 07:39:28 +00:00