diff --git a/docs/BACKLOG.md b/docs/BACKLOG.md
index 43f05a5..875b0a5 100644
--- a/docs/BACKLOG.md
+++ b/docs/BACKLOG.md
@@ -2,18 +2,27 @@
 
 Curated from the 2026-06-09 full-codebase audit (12-agent sweep, 199 findings) plus live playtest.
 Wave 1+2 fixes covered the gameplay-killing bugs; these are the deliberate deferrals.
+Fog of war + war termination shipped in game-loop v2; the intel suite + combat-on-contacts
+shipped in v3 (docs/plans/intel-suite-v3.md) — v3 deferrals listed below.
+
+## Intel suite v3 deferrals (design doc §7 + build-wave notes)
+
+- Missions/doctrine cascade (patrol boxes, recon orbits, per-zone weapon release authority).
+- HVT person-tracking chains, underground facility model, WAMI rewind, Staff Summary panel.
+- Counter-OSINT levers: shutter control, disinfo plants, Iranian internet blackout.
+- Live-data upgrades: OpenSky via a small Vercel proxy, aisstream AIS relay, Windy webcams,
+  GIBS fires MVT layer, USGS seismic ticker as MASINT flavor.
+- STRIKE_LEAKED currently scoots the target + degrades the contact; the designed Iranian
+  point-defense readiness bump is not implemented.
+- FLASH salvo-warning intercept path (getNextSalvoEstimate) has no test (couples to AI phase).
+- ADS-B polling has no document-visibility pause; LiveFeeds drag is title-bar only.
+- Destroying Iranian ISR assets (Mohajer orbit, picket boats, Noor) has no kill path.
+- OSINT regime-mouthpiece nation detection is a name-regex heuristic; new Iranian names need
+  the patterns extended (osint-feed.ts IRAN_WEAPON_RE/IRAN_UNIT_RE).
 
 ## Big features (design needed before code)
 
-- **Fog of war.** The snapshot ships full enemy state to the UI; detection/espionage/satellite
-  systems compute results that gate nothing. Decide the visibility model (per-unit detected
-  state with decay?), filter the snapshot, and wire HUMINT reveals + SIGINT range multiplier +
-  `satelliteDetectedUnitIds` into it. Until then the whole intel layer is cosmetic
-  (IntelBudgetPanel is a placebo).
-- **Victory / end conditions.** Wars currently never end: no objectives evaluated, no
-  victory/defeat screen, CEASE_FIRE command handled by the engine but has no UI. The war just
-  goes silent. Define win conditions per scenario (e.g. Hormuz kept open N days, % enemy
-  strategic assets destroyed) and an end-of-war screen.
+- **Logistics depth** (see below), **aircraft/sortie system**, **more scenarios**.
 - **Logistics depth.** logistics-v2 (national stockpiles, shipments, production) was deleted as
   dead code in the cleanup; the live v1 ignores `SupplyLine.capacity`/`distance_km`. If supply
   is to matter strategically, re-design from the v1 base (git history has v2 for reference).
@@ -26,26 +35,39 @@ Wave 1+2 fixes covered the gameplay-killing bugs; these are the deliberate defer
 
 ## UX debt
 
-- Panels overlap each other (SITREP opens on top of the strike dialog) and have no
-  drag/z-order management; Escape does not close panels.
 - Mobile: LOG tab empty, IntelPanel X needs two taps, direct-fire flow yanks to UNIT panel.
-- Strike timing modes (staggered/sequential) run on wall-clock setTimeout (0.3s/3s) instead of
-  game time, and fire while paused. Honest fix = engine-side scheduled salvos.
 - Shipping lane name/throughput labels are built but never rendered; lanes/minefields have no
   hover/click interactivity.
-- Intel estimate markers are pickable but `moveEstimate`/`confirmEstimate` have no UI path.
-- "BAB EL_MANDEB" event copy; review event vocabulary for raw enum leakage generally.
-- No path back to the main menu from a running game.
-- StartScreen shows a hardcoded stale version/date banner; project naming is split between
-  REALPOLITIK (UI/package/IndexedDB) and Ashfall Command (repo/Vercel).
+- OFFER CEASEFIRE two-step confirm still uses silent blur-disarm — reuse TopBar's
+  useArmedCountdown for consistency with CONFIRM WAR.
+- exitToMainMenu() in TopBar duplicates DebriefScreen's handleMainMenu — extract a shared
+  helper; consider SET_SPEED 0 on exit (worker keeps ticking behind the start screen).
+- Package/IndexedDB internals still named realpolitik (package.json name, save-load DB_NAME,
+  map style ids) — cosmetic, renaming the DB key breaks saves.
+
+## Engine scale (from the Wave A stress guard, 2026-06-11)
+
+- Measured: ~60-unit shipped scenarios are comfortably real-time; at 500 units the
+  interceptor-saturation phase (~2100 live missiles) runs 80-190 ms/tick — missile
+  count dominates, units are cheap, terrain/LOS adds only ~9%. If bigger scenarios
+  ever become a target: spatial index / per-missile detection culling in
+  detection/visibility loops. NOT WASM-for-LOS. Guard: src/engine/__tests__/scale-stress.test.ts.
 
 ## Smaller deferred fixes
 
 - DIRECT FIRE cluster popup z-order vs strike panel (replaces it on screen).
-- DECLARE WAR confirm silently times out (by design?) — consider a visible countdown.
 - visualTimestamp interpolation assumes nominal worker speed; visual clock can snap back.
-- Multiple radars on one unit: max range paired with first radar's antenna/sector.
-- detectThreats runs twice per radar unit per tick (perf, harmless at current scale).
-- Sensor types sonar/irst/ew have no mechanics; `Sensor.detection_prob` unread.
+- Sensor types sonar/irst/ew have no mechanics; `Sensor.detection_prob` data-only (noted in code).
 - `GameTime.tickIntervalMs` set everywhere, read nowhere (visual interpolation hardcodes 100).
-- Cursor elevation readout tracks mousemove even with ELV overlay off.
+
+## Done 2026-06-11 (backlog wave 1)
+
+- Panels: drag by title bar, click-to-raise z-order, Escape closes topmost, per-title
+  position memory (Panel.tsx + ui-store panels slice).
+- Strike timing engine-side: LAUNCH_SALVO spacingTicks + state.scheduledLaunches queue —
+  pause-safe, save/load-safe, one leak roll per salvo. Staggered/sequential now space
+  rounds within the salvo (2 s/8 s); old 30 s/10 min between-tier delays removed.
+- MAIN MENU in the ··· menu (two-step confirm), CONFIRM WAR visible 5 s countdown,
+  lane/supply-line names prettified (Bab el-Mandeb).
+- Multi-radar pairing fixed (per-sensor range/antenna/sector evaluation), detectThreats
+  per-tick memo (3× → 1× per unit), ELV cursor listener gated on the toggle.
diff --git a/docs/plans/air-war-v5.md b/docs/plans/air-war-v5.md
new file mode 100644
index 0000000..2081ddb
--- /dev/null
+++ b/docs/plans/air-war-v5.md
@@ -0,0 +1,138 @@
+# Air war v5 — squadrons, flights, missions
+
+Binding design for Roadmap Wave C. Research basis: CMO/Falcon/DCS Liberation
+convergent design + real 2026 orbat (roadmap-v4.md Wave C). Core principle:
+squadrons are pools, flights are transient map tracks, orders exist ONLY at
+mission level. No per-airframe anything.
+
+## 1. Data model
+
+```ts
+// types/game.ts
+export interface SquadronState {
+  id: string                 // 'vfa14'
+  name: string               // 'VFA-14 Tophatters'
+  airframe: AirframeId       // 'fa18e' | 'f35c' | 'ea18g' | 'e2d' | 'f14' | 'mig29' | 'su24' | 'su35'
+  total: number              // airframes on the books
+  available: number          // ready now (total − airborne − turnaround − maintenance − lost)
+  readyAt: number[]          // ticks when turning-around airframes rejoin `available`
+}
+// Unit gains: airWing?: SquadronState[]   (carrier_group + airbase only)
+
+export interface AirframeSpec {
+  id: AirframeId
+  name: string
+  speed_kts: number          // cruise
+  combat_radius_km: number
+  sensors: Sensor[]          // radar per airframe (E-2D huge + datalink)
+  weapons: WeaponLoadout[]   // per-airframe loadout template by mission
+  datalink_range_km?: number // E-2D/E-3 are hubs
+  rcs_class: 'stealth' | 'fighter' | 'large'
+}
+
+export type AirMissionKind = 'cap' | 'strike' | 'aew'
+export interface AirMission {
+  id: string
+  kind: AirMissionKind
+  squadronId: string
+  fromUnitId: UnitId
+  flightSize: number          // 2-4
+  station?: Position          // cap/aew orbit point
+  targetId?: UnitId           // strike
+  escortSead?: boolean        // EA-18G pair attached (USA only)
+  extendedRange?: boolean     // tanker tax: +35% radius, −2 fa18e sorties
+  status: 'planning' | 'active' | 'complete' | 'aborted'
+  planningCompleteTick?: number
+  flightUnitId?: UnitId       // spawned Flight unit
+}
+// GameState gains: airMissions?: AirMission[]
+```
+
+Flights are real `Unit`s, category `'aircraft'`, id `flight_<n>`, name
+"2× F/A-18E (VFA-14)" — movement, visibility contacts, SAM engagement,
+war-support, datalink all work day one. Flight unit carries the airframe's
+sensors/weapons (scaled by flightSize) and `flightMeta` fields on Unit:
+`{ missionId, bingoTick, rtbTo: UnitId }` (optional, plain data).
+
+## 2. Sortie economy (CMO numbers)
+
+- CAP quick-turn 90 game-min; strike turnaround 6 h (surge) / 20 h (sustained).
+- Carrier ceiling ~100 sorties/day enforced implicitly by pools + turnarounds.
+- 30% of each squadron's `total` starts in maintenance (deduct from available
+  at init; returns at scenario start + 12-24 h via readyAt).
+- SURGE OPS: one global toggle (command). 96 h of halved ready times, then
+  ×1.5 sustained for the rest of the war. TopBar chip while active.
+- `extendedRange` deducts 2 extra fa18e sorties from the carrier (buddy
+  tanking; MQ-25 slipped to 2029).
+- Strike planning delay: 2-6 h (rng seeded by mission id) between order and
+  launch window — `status: 'planning'`. CAP/AEW launch next tick.
+
+## 3. Mission behavior (engine/systems/air-ops.ts)
+
+Per game-minute evaluation + per-tick movement (movement.ts already moves
+aircraft units; air-ops only sets waypoints/decisions):
+
+- **Launch**: pop `available`, spawn Flight at the host position, waypoints to
+  station/target. bingoTick = now + 2×(transit time) + on-station allowance
+  derived from combat_radius vs distance (never fuel liters).
+- **CAP**: orbit station (small 4-waypoint racetrack, re-issued when reached).
+  Auto-intercept: nearest enemy `aircraft` contact (tracked+, live) within
+  commit range 120 km → engage via AUTO_ENGAGEMENT path with A2A pK table
+  (new weapon type 'aam', simple pK per rcs_class; one engagement roll per
+  30 game-s within 40 km). Iranian flights symmetric.
+- **Strike**: transit to release range of targetId (per loadout weapon),
+  spawn EXISTING missiles via launchMissile (trackQuality from the nation
+  picture like friendly-ai), then RTB. SEAD escort: while within 80 km of the
+  flight, enemy SAM detection_prob×0.6 and pk×0.6 vs this flight's missiles
+  AND emitting SAMs within 150 km become 'detected' contacts (ELINT hook).
+- **AEW**: orbit station; the Flight has E-2D sensors + datalink_range_km →
+  the existing visibility + fire-control network does the rest.
+- **RTB**: at bingo or out of weapons → waypoints home, on arrival the Flight
+  unit is removed, squadron readyAt += turnaround, `available` restored minus
+  losses. Flight destroyed → airframes lost, pilot roll per airframe:
+  KIA (−2 war support) / rescued (+1) / POW (−4, OSINT event).
+- **Iran AI**: scramble-only — when a detected USA package/flight approaches a
+  defended box, spawn an interceptor CAP from the nearest airbase with
+  available fighters (ai.ts hook, max 2 concurrent). Su-35 squadron only
+  scrambles to defend Hamadan/Tehran. Parked airframes: each Iranian airbase
+  exposes `airWing` totals to BDA — airbase damage destroys parked airframes
+  proportionally (UNIT damage events → pool reduction; satellite pass caption
+  mentions counted airframes).
+
+## 4. Commands
+
+`LAUNCH_AIR_MISSION { kind, squadronId, fromUnitId, flightSize, station?, targetId?, escortSead?, extendedRange? }`,
+`CANCEL_AIR_MISSION { missionId }` (RTB immediately), `SET_SURGE_OPS { enabled }`.
+
+## 5. UI — Air Plan board
+
+- New AIR button in TopBar → AirOpsPanel (Panel, draggable like the rest):
+  per host (carrier/airbase): squadron rows (name, airframe, available/total,
+  next-ready countdown), active missions list (kind, flight, status, BINGO
+  countdown, CANCEL), mission composer: kind → squadron → flight size →
+  (station: click-map capture like satellite tasking / target: enemy contact
+  picker) → SEAD/extended-range checkboxes → LAUNCH. SURGE OPS toggle with
+  the 96 h consequence spelled out.
+- Map: Flight units render with existing aircraft icon; CAP/AEW stations get
+  a small racetrack glyph (IntelLayers-style); strike flights show a target
+  line when selected.
+- ViewState: `airMissions` slice (player nation only) + squadron pools on
+  ViewUnit (own units only, scrubbed for enemies — enemy pools NEVER leak;
+  BDA estimates come via imagery product captions only).
+
+## 6. Out of scope (→ BACKLOG)
+
+Individual airframes, fuel-liter modeling, tanker tracks, weather aborts,
+A2A missile entities (pK roll abstraction instead), runway cratering state
+(airbase health already gates), carrier deck cycles visualization.
+
+## 7. Build split
+
+Scaffold (orchestrator): types + commands + airframe/squadron data files +
+air-ops.ts skeleton + game-engine wiring + view slice.
+- C1: air-ops.ts full implementation + ai scramble hook + tests.
+- C2: AirOpsPanel + TopBar AIR + map glyphs + tests.
+- C3: data verification pass (CVW-9 + Iranian orbat numbers vs research),
+  BDA/pool wiring on airbase damage + imagery captions, pilot-fate events +
+  AlertFeed formatters + OSINT feed coverage, tests.
+- T: smoke extension (launch CAP, see flight on map, RTB).
diff --git a/docs/plans/intel-suite-v3.md b/docs/plans/intel-suite-v3.md
new file mode 100644
index 0000000..420496a
--- /dev/null
+++ b/docs/plans/intel-suite-v3.md
@@ -0,0 +1,336 @@
+# Intel Suite v3 — SIGINT, IMINT, HUMINT, OSINT, counterespionage
+
+Binding design for the v3 build wave. Builds on game-loop v2 fog of war
+(`docs/plans/game-loop-v2.md`) and the v3 combat-on-contacts commit (radar
+horizon, fire-control quality, auto-engagement). Research basis: 5-agent web
+research sweep 2026-06-10 (US ISR architecture, OSINT ecosystem, verified free
+data feeds, game design references, Iran counterintelligence).
+
+Design goals, in priority order:
+
+1. The USA player CAN reach near-total knowledge of Iran — but only by tasking
+   assets well (tip-and-cue: wide-area sensors tip, expensive collection confirms).
+2. Intel is load-bearing: TEL hunting, decoy discrimination and strike warning
+   are unsolvable without collection.
+3. Counterespionage cuts both ways: Iran hunts the player's sources and leaks
+   the player's operations; the player has OPSEC verbs to fight back.
+4. Presentation mirrors real intel products using REAL data where free and
+   verified: real satellite imagery of the real bases, a genuinely live
+   geostationary weather satellite, real air traffic, real cloud cover.
+5. No espionage minigames. Every intel action is 1–2 clicks, resolved by
+   readable odds. Products (imagery, intercepts, reports) are presentation
+   rewards that show exactly the knowledge earned — never knowledge the sensor
+   network does not have.
+
+## 0. Verified real-data stack (all keyless + CORS unless noted)
+
+Central config module `src/data/feeds.ts` — every URL lives there with a
+comment naming what was verified 2026-06-10. Degrade gracefully: every consumer
+must handle fetch failure by falling back to simulated/synthetic content.
+
+| Source | Use | Notes |
+|---|---|---|
+| Esri World Imagery XYZ `https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}` | High-res IMINT product backdrops + FMV feed scenery (z up to 16) | path order is z/y/x. Attribution required. Free app only. |
+| NASA Worldview Snapshot `https://wvs.earthdata.nasa.gov/api/v1/snapshot?REQUEST=GetSnapshot&LAYERS=VIIRS_SNPP_CorrectedReflectance_TrueColor&CRS=EPSG:4326&TIME={YYYY-MM-DD}&BBOX={s},{w},{n},{e}&WIDTH=768&HEIGHT=512&FORMAT=image/jpeg` | One-fetch date-stamped recon JPEG for "daily pass" products | Pin explicit date; default yesterday UTC, try today, 404 = "not downlinked yet" |
+| NASA GIBS WMTS `https://gibs.earthdata.nasa.gov/wmts/epsg3857/best/VIIRS_SNPP_CorrectedReflectance_TrueColor/default/{time}/GoogleMapsCompatible_Level9/{z}/{y}/{x}.jpg` | Optional map base-layer toggle "DAILY RECON MOSAIC" | maxzoom 9, time pinned yesterday UTC. Never TIME=default (resolves to tomorrow → 404). |
+| EUMETSAT EUMETView WMS `https://view.eumetsat.int/geoserver/wms?service=WMS&request=GetMap&version=1.3.0&layers=msg_iodc:{layer}&styles=&format=image/jpeg&crs=EPSG:4326&bbox={s},{w},{n},{e}&width=640&height=480` layers `rgb_naturalenhncd` (day) / `ir108` (night-capable) | "GEOSAT IODC LIVE" window — genuinely live Meteosat-9 over the Gulf, 15-min cadence | Refresh every 15 min of REAL time |
+| airplanes.live `https://api.airplanes.live/v2/point/{lat}/{lon}/{radius_nm}` | "LIVE ADS-B" map layer — real civilian/military aircraft over the Gulf | ~1 req/s limit → poll every 45 s, radius ≤ 250 nm |
+| Open-Meteo `https://api.open-meteo.com/v1/forecast?latitude={lat}&longitude={lon}&current=cloud_cover` | Real cloud cover gates optical satellite tasking | One fetch per tasking, UI-side; fallback = seeded rng |
+| YouTube live embed, video id `osUeQTR91Ig` (Reuters "Vessel traffic in Strait of Hormuz") | OSINT ambience cam in the LIVE FEEDS window | iframe embed verified via oEmbed; if unavailable show SIGNAL LOST card |
+| NOT in v3 | OpenSky (CORS-locked, needs proxy), live AIS (key+relay), Windy webcams (key+token), GIBS fires MVT, USGS quakes, RainViewer | BACKLOG.md |
+
+Compliance: game stays free/non-revenue. LIVE FEEDS window footer gets an
+"INTEL SOURCES" credits panel styled as an agency acknowledgment page: Esri ·
+Maxar, NASA GIBS, EUMETSAT 2026, airplanes.live, Open-Meteo, Reuters.
+
+Engine purity rule: the worker NEVER fetches. UI fetches real data and passes
+results into commands (e.g. cloud cover) or renders it presentation-side only.
+Engine outcomes must stay deterministic given commands + seed.
+
+## 1. Engine: intel assets + tasking (`src/engine/systems/intel.ts`)
+
+New module-level system, `resetIntelState()` + save/load like war-support.
+State lives in `state.intel` (new `IntelState` in types/game.ts):
+
+```ts
+interface IntelState {
+  assets: Record<string, IntelAsset>          // per-nation ISR assets
+  agents: Record<string, AgentSource>         // player HUMINT sources
+  products: IntelProduct[]                    // last 30 imagery/report products (metadata only)
+  taskings: SatTasking[]                      // queued satellite taskings
+  paranoia: number                            // 0-100 Iranian counterintel alert
+  encryptionUpgradedUntilTick?: number        // SIGINT blackout window
+  leakLevel: number                           // 0-100 how compromised the player's ops are
+  lastSweepTick?: number                      // player OPSEC sweep cooldown anchor
+}
+```
+
+### 1.1 ISR assets (fixed roster, data in `src/data/intel/assets.ts`)
+
+USA: `kh11` (LEO optical, revisit 4h base — existing satellite entries get
+names/types), `commercial` (revisit 90min, lower quality, products marked
+UNCLASSIFIED//COMMERCIAL), `rc135` (SIGINT standoff — drives intercept cadence
+while alive), `mq4c_triton` (wide-area maritime — coarse 'detected' refresh of
+ships in the Gulf box every 30 game-min), `sbirs` (always-on launch detection —
+already exists as launch-plume reveals; now also emits a FLASH intercept card).
+Iran: `noor` (coarse optical, revisit 8h), `mohajer10` (drone orbit over the
+strait — refreshes carrier contact), `fastboats` (IRGC shadowing — carrier
+coarse-tracked while inside the Hormuz approaches box).
+
+Assets are abstract (no map unit) except where a unit already exists. Each has
+`status: 'active' | 'lost'`, cooldowns, and for Iran assets a kill-path noted
+in BACKLOG (out of scope to destroy them in v3 except via events).
+
+### 1.2 Satellite tasking — the IMINT verb
+
+Command `TASK_SATELLITE_PASS { assetId: 'kh11' | 'commercial', target: Position, cloudPct?: number }`.
+UI flow: INTEL → ISR tab → TASK PASS → click map (or "TASK PASS" button on a
+contact). Queues a `SatTasking`; resolves at the asset's next pass window
+(kh11: next tick where `(tick - lastPassTick) >= revisit`, max 1 queued per asset).
+
+Resolution:
+- cloudPct ≥ 70 → pass FAILED (`SATELLITE_PASS_FAILED` event, asset cooldown
+  halved so retry is cheap). cloudPct comes from the command (UI fetched real
+  weather); if absent, seeded rng 0–100.
+- Success: all enemy units within `swathKm = 60` of target get contact refresh:
+  fixed sites + units already tracked → `identified`; others → `tracked`.
+  Decoys within swath: kh11 pass REVEALS them (NIIRS 7+); commercial does not.
+- Emits `SATELLITE_PASS_COMPLETE { assetId, target, found: number, revealedDecoys: number }`
+  and pushes an `IntelProduct { kind: 'imint', assetId, target, tick, niirs, caption, classification }`.
+  The UI renders the product with REAL imagery fetched at view time (engine
+  stores metadata only).
+- Each pass over Iranian soil: `paranoia += 4` (kh11) / `+2` (commercial).
+
+### 1.3 SIGINT intercepts
+
+While `rc135` active and not in an encryption-upgrade window: every
+`INTERCEPT_INTERVAL = 20 game-min ± jitter`, scaled by `sigint_pct` budget,
+emit `INTERCEPT_DECRYPTED { precedence, text, aboutUnitId?, leakKind }` choosing
+from true-state leaks (priority order):
+
+1. Pending Iran AI salvo in the next 30 game-min → `FLASH` warning naming the
+   target region ("FLASH: missile brigade ordered to combat readiness —
+   expect fires vs PRINCE SULTAN AB within the hour").
+2. A hidden (unseen/detected) Iranian `missile_battery` or `sam_site` →
+   reveal at `detected` + `IMMEDIATE` card with a location ellipse reference.
+3. War-support state ("PRIORITY: Tehran leadership cohesion failing") when
+   Iran support < 45.
+4. Filler chatter (`ROUTINE`, no game effect) otherwise.
+
+Every intercept: `paranoia += 2`. When `paranoia ≥ 70` and at war: Iran rolls
+encryption upgrade — `ENCRYPTION_UPGRADED` event, no intercepts for 6 game-h,
+paranoia resets to 40. SIGINT cards live in `IntelState.products` as
+`kind: 'sigint'`.
+
+### 1.4 HUMINT — named sources (the burn-the-source loop)
+
+Exactly 4 named sources in `src/data/intel/agents.ts`, USA-side only in v3:
+
+| id | codename | placement | product |
+|---|---|---|---|
+| `amber` | AMBER | Bandar Abbas port clerk | naval base activity; reveals ships in Bandar Abbas/Jask boxes at `tracked`; sortie warnings |
+| `opal` | OPAL | IRGC logistics officer | TEL hunt: reveals 1-2 hidden `missile_battery` at `identified` per tasking |
+| `saffron` | SAFFRON | Tehran ministry aide | political: Iran war-support exact value + ceasefire intent for 2 game-h |
+| `garnet` | GARNET | Strait observer w/ camera | enables the LIVE OBSERVER feed on the Hormuz box; passive +tracked refresh of ships transiting the strait every 30 game-min while active |
+
+`AgentSource { id, codename, placement, product, status: 'active'|'resting'|'exfiltrated'|'arrested', exposure: 0-100, lastTaskedTick }`.
+
+Verbs (commands): `TASK_AGENT { agentId }` (immediate report + effect,
+`exposure += 15 + paranoia/5`, 1 game-h cooldown), `REST_AGENT` (status
+resting: no products, exposure decays 1/game-h instead of rising),
+`EXFILTRATE_AGENT` (after 6 game-h delay → safely removed, product lane lost).
+
+Iranian spy sweeps: when `paranoia ≥ 50`, every 4 game-h Iran sweeps: each
+active/resting source rolls `chance(exposure/200 + paranoia/400)` → ARRESTED:
+`AGENT_ARRESTED` event, source lost, `leakLevel += 10` (interrogation), USA
+war-support −3, Iran war-support +2. Feed + INTEL panel show it loudly.
+
+### 1.5 Counterespionage — Iran spies on the player
+
+`leakLevel` 0–100 (starts 25): Iran's insight into player operations.
+- Rises: +1/game-h while carrier inside Hormuz approaches box (fast boats),
+  +5 per player strike launched (pattern analysis), +10 per arrested agent.
+- Effects: while `leakLevel ≥ 60`, player `LAUNCH_MISSILE`/`LAUNCH_SALVO`
+  commands have a `leakLevel/200` chance to emit `STRIKE_LEAKED` — Iran AI
+  gets +1 defensive readiness: targeted unit (if mobile, undamaged) relocates
+  ~15 km and its contact for USA degrades to `detected` (it moved), and Iran
+  point-defense readiness event fires. Player sees "STRIKE COMPROMISED —
+  target displaced before impact" only via OSINT/feed after the miss.
+- Iran's coarse carrier picture (asymmetry rule): every 30 game-min, if the
+  player carrier_group is within the Gulf/strait OSINT box, Iran's contact on
+  it refreshes at `detected` (at `tracked` while leakLevel ≥ 60 or mohajer10
+  active). EMCON does NOT hide the carrier from this (you can't hide a CSG
+  from port spotters) — it only denies ELINT/precision (see 1.6).
+
+Player verbs: `OPSEC_SWEEP` (cooldown 6 game-h: `leakLevel -= 25`, event
+`OPSEC_SWEEP_COMPLETE`), and EMCON (1.6).
+
+### 1.6 EMCON
+
+`SET_EMCON { unitId, emcon: boolean }` — unit radar stops radiating:
+- visibility.ts: unit excluded from `ownRadars` (no contributions to own picture)
+  and `radarSeesUnit` returns unseen for it (fire-control 'own' lost).
+- sensor-network ELINT: emcon units are NOT ELINT-detectable (both the per-tick
+  network and visibility's `isElintDetected`).
+- detection.ts missile defense: emcon unit cannot detect threats with own radar
+  (datalink network picture still applies — that's the CEC trade-off).
+- UnitInfoPanel gets an EMCON toggle next to ROE.
+
+### 1.7 Decoys
+
+At war start (or when Iran enters DEFENSIVE), spawn `DECOY_COUNT = 4` decoy
+units near real Iranian missile_battery clusters: real `Unit`s with
+`isDecoy: true`, category `missile_battery`, no weapons, health 40, name
+"Missile TEL group" — indistinguishable at detected/tracked. Revealed by:
+kh11 pass over them (1.2), HUMINT OPAL report, or destroying one (BDA shows
+no secondaries). Revealed → `DECOY_REVEALED` event; ViewUnit gets
+`decoyRevealed: true` → rendered desaturated with DECOY tag. Striking an
+unrevealed decoy: normal impact, but war-support loss for Iran is 0 and Iran
+gains +1 support (propaganda); the player wasted missiles — that's the lesson.
+war-support.ts: losses ignore `isDecoy` units. toViewUnit: `isDecoy` NEVER
+leaks for unrevealed decoys (snapshot scrubbing test required).
+
+### 1.8 Tick order
+
+`processIntel(state, rng, grid)` runs after `processVisibility` (consumes fresh
+contacts) and before `processWarSupport`. All reveals route through the same
+contact bookkeeping as visibility.ts (export small helpers there rather than
+duplicating decay logic).
+
+## 2. OSINT feed (UI-side, `src/intel/osint-feed.ts`)
+
+Pure consumer of the snapshot event stream — no engine state. Generator keyed
+on `(event, account)` with per-account delay/noise/false-rate; posts surface in
+the INTEL → OSINT tab and the 3 most recent as a collapsed ticker above the
+AlertFeed. Roster (`src/data/intel/osint-accounts.ts`), all fictional handles:
+
+| handle | archetype | delay | reliability |
+|---|---|---|---|
+| `@GulfPlaneWatch` | base plane-spotter | 1-3 min | high — launches/sorties near bases |
+| `@CENTCOM_Watch` | aggregator | 2-6 min | 85% — BREAKING style, occasionally wrong target names |
+| `@TankerTrackerz` | oil-flow analyst | 12-24 game-h | high — Hormuz status, oil price commentary |
+| `@OrbitalRecon` | imagery analyst | 6-12 game-h | high — BDA after strikes ("crater analysis suggests...") |
+| `@IRGC_Media` | regime mouthpiece | 5-15 min | inflated claims, true readiness chatter |
+| `@StraitSpotter` | webcam watcher | 2-8 min | ship transits, mine sightings |
+| `@SignalDesk` | leak channel | minutes BEFORE Iran salvos (when leakLevel < 40) | jittered warnings |
+| `@PizzaIndexGulf` | joke indicator | ~1 game-h before player-visible AI escalation | 60% |
+
+False posts: aggregator/mouthpiece occasionally emit posts about events that
+did not happen (recycled-footage flavor); cross-checking against sensors is the
+intended skill. Posts referencing player operations (carrier transit, big
+salvos) appear too — visible reminder that OSINT cuts both ways.
+
+## 3. UI — INTEL command center + product viewers
+
+### 3.1 `IntelCommandCenter.tsx` (replaces IntelPanel content; keep budget sliders in ISR tab footer)
+
+Tabs: **ISR · SIGINT · HUMINT · OSINT · OPSEC**
+
+- ISR: asset cards (status, next-pass countdown), TASK PASS flow (click-map
+  capture like the estimate-placement flow), product gallery (thumbnail grid,
+  click → IMINT viewer). Budget sliders move here.
+- SIGINT: intercept cards newest-first, precedence-tagged (FLASH red pulse,
+  IMMEDIATE amber, PRIORITY white, ROUTINE muted), encryption-upgrade banner
+  with countdown when active.
+- HUMINT: one card per source: codename, placement, product line, exposure bar
+  (green→red), TASK / REST / EXFILTRATE buttons with readable risk ("Tasking
+  raises exposure ~18%"). Arrested sources stay as tombstone cards.
+- OSINT: the feed (2), with account filter chips.
+- OPSEC: leakLevel gauge ("OPERATIONS SECURITY"), what's driving it (list),
+  OPSEC SWEEP button + cooldown, EMCON quick-toggles for radar ships, Iranian
+  paranoia estimate (fuzzy: LOW/ELEVATED/HIGH/SEVERE).
+
+### 3.2 IMINT product viewer (`ImintViewer.tsx`)
+
+Full-screen modal, classified-product dress: black frame,
+`TOP SECRET//TK//NOFORN` banner (or `UNCLASSIFIED//COMMERCIAL`), real Esri
+imagery crop centered on product.target (simple `<img>` tile mosaic 3×2 at the
+zoom where swath ≈ frame, no canvas), crosshair + AOI bracket overlays, NIIRS
+rating, sensor + acquisition Z-time stamps, auto-caption ("2× probable TEL
+group, 1× SA-15 type emitter"), grain/scanline CSS overlay. SAVE TO BOARD
+pins it to the product gallery.
+
+### 3.3 LIVE FEEDS window (`LiveFeeds.tsx`)
+
+Dockable window (toggle in TopBar: LIVE) with a 2×2 grid:
+1. **GEOSAT IODC LIVE** — EUMETSAT WMS img, refreshed every 15 real-min,
+   day layer by local day/night at the Gulf (rgb day / ir108 night), timestamp.
+2. **HORMUZ TRAFFIC CAM** — Reuters YouTube live iframe; SIGNAL LOST card on error.
+3. **ISR FMV** — synthetic drone soda-straw: Esri z15-16 imagery of a selected
+   contact/AOI, slow Ken-Burns drift, IR-style filter (invert+contrast) at
+   night, noise/scanline shader, REC dot, corner telemetry (coords, ALT, SLANT),
+   crosshair. Source select: any tracked+ contact (or GARNET's strait box).
+4. **ADS-B LIVE** — toggle that also enables the map layer; in-window list of
+   the 10 nearest real aircraft (callsign, alt, speed) from airplanes.live.
+Footer: INTEL SOURCES credits (compliance, styled as agency acknowledgments).
+
+### 3.4 Map layers (`IntelLayers.ts` + UnitLayer touches)
+
+- AOU ellipses: stale contacts get a growing dashed circle
+  `radius = min(60, 4 + minutesSinceSeen × speedFactor)` km.
+- Sensor rings: selected own unit shows radar ring capped at the horizon vs
+  surface targets (teaches the new physics); dim second ring = nominal range.
+- Satellite swath preview during TASK PASS placement + 60 km AOI circle on
+  queued taskings with next-pass countdown label.
+- Decoy styling: revealed decoys desaturated + DECOY tag.
+- ADS-B layer: real aircraft as small neutral-gray tracks w/ heading, callsign
+  on hover. Clearly non-interactive (flavor), toggle in MapToggle.
+- DAILY RECON MOSAIC: GIBS VIIRS raster source toggle (maxzoom 9, yesterday).
+
+### 3.5 Time slider (TopBar)
+
+Replace/augment the fixed speed buttons with a continuous slider (user
+request): log-scale drag 0 → 3600 (PAUSE · 1× · 8× · 60× · 10m/s · 1h/s
+detents with snap), current multiplier label ("×480"), keyboard +/- steps
+between detents, pause button stays separate. Engine already accepts any
+number via SET_SPEED; `GameLoop` bursts `round(speed)` ticks per 100 ms with
+an 80 ms budget, so the slider needs no engine change. Presets remain as
+click-targets under the slider. TopBar is owned by U2 in this wave (slider +
+LIVE toggle) to avoid file collisions.
+
+### 3.6 View-state additions (types/view.ts)
+
+`GameViewState` gains `intel: { assets, agents, products(latest 30), taskings, leakLevel, paranoiaBand, encryptionUpgradedUntilTick }`,
+`ViewUnit` gains `emcon?: boolean`, `decoyRevealed?: boolean`. Snapshot
+scrubbing: products/agents are player-nation only; decoy truth only when revealed.
+
+## 4. Events (types/game.ts)
+
+`SATELLITE_PASS_COMPLETE`, `SATELLITE_PASS_FAILED`, `INTERCEPT_DECRYPTED`,
+`AGENT_REPORT`, `AGENT_ARRESTED`, `AGENT_EXFILTRATED`, `SPY_SWEEP`,
+`ENCRYPTION_UPGRADED`, `DECOY_REVEALED`, `STRIKE_LEAKED`, `OPSEC_SWEEP_COMPLETE`.
+All get AlertFeed formatters + colors; FLASH intercepts and AGENT_ARRESTED join
+the auto-pause options.
+
+## 5. Commands (types/commands.ts)
+
+`TASK_SATELLITE_PASS`, `TASK_AGENT`, `REST_AGENT`, `EXFILTRATE_AGENT`,
+`OPSEC_SWEEP`, `SET_EMCON`.
+
+## 6. Build plan (parallel agents, disjoint files)
+
+Scaffold (me, first commit): types/game.ts + commands.ts + view.ts deltas,
+`intel.ts` skeleton (exported signatures + reset + save/load wiring),
+`feeds.ts`, data files (assets/agents/osint-accounts) with full content,
+game-engine wiring (tick order, command cases, snapshot slice), EMCON hooks in
+visibility/sensor-network/detection (small, central).
+
+- **E1**: intel.ts full implementation + war-support decoy exception + tests
+  (taskings, intercepts incl. encryption window, sweeps/exposure, leakLevel,
+  decoy spawn/reveal, EMCON visibility effects, save/load round-trip).
+- **U1**: IntelCommandCenter + ui-store + UnitInfoPanel EMCON toggle + panel tests.
+- **U2**: ImintViewer + LiveFeeds + credits + osint-feed.ts generator + ticker
+  + TopBar (time slider §3.5 + LIVE toggle).
+- **U3**: IntelLayers (AOU, sensor rings, swaths, ADS-B, GIBS toggle) + decoy
+  styling + MapToggle entries.
+- **T**: extend `scripts/e2e-smoke.mjs`: open INTEL, task a pass, verify a
+  product appears; check OSINT tab renders posts; toggle EMCON; verify LIVE
+  window opens with all four quadrants (network feeds may show fallback cards).
+
+## 7. Out of scope (→ BACKLOG.md)
+
+Missions/doctrine cascade, WAMI rewind, HVT person-tracking chains, underground
+facility model, shutter control, disinfo plants, internet blackout, OpenSky
+proxy, aisstream relay, Windy webcams, USGS seismic ticker, RainViewer, GIBS
+fires layer, Iranian asset destruction, Staff Summary panel, NIIRS-gated
+bunker-buster folders.
diff --git a/docs/plans/roadmap-v4.md b/docs/plans/roadmap-v4.md
new file mode 100644
index 0000000..bc4cb19
--- /dev/null
+++ b/docs/plans/roadmap-v4.md
@@ -0,0 +1,147 @@
+# Roadmap v4 — toward the best browser military sim
+
+Synthesized from a 5-agent research sweep 2026-06-11 (3D/terrain, air ops, TOT +
+elevation, presentation, longevity). Every external source named here was
+live-verified (curl) on 2026-06-11. Hard constraints unchanged: free/non-revenue,
+purely client-side, Vercel static hosting.
+
+Waves are ordered by recommendation. Effort is calendar-honest for this codebase.
+
+## Wave A — Feel (each item ~hours-to-2-days, all prerequisites already shipped)
+
+1. **Hillshade relief, always on.** Add a `raster-dem` source to both map styles —
+   verified keyless+CORS sources: AWS Terrain Tiles
+   `https://s3.amazonaws.com/elevation-tiles-prod/terrarium/{z}/{x}/{y}.png`
+   (encoding `terrarium`, tileSize 256, native detail to z12 = SRTM 30 m) and
+   `tiles.mapterhorn.com` (webp, far lighter, used by MapLibre's official 3D
+   example). Dark-tuned hillshade layer below `overlay-anchor`; retire the static
+   elevation overlay image. Attribution line: Mapzen/Tilezen + providers.
+2. **TOT strikes (time-on-target).** `launch_i = TOT − flightTime_i` on top of the
+   just-shipped `state.scheduledLaunches`. One master TOT control in the strike
+   panel (default "earliest feasible"), read-only derived launch schedule, never
+   per-launcher inputs (CMO/DCS pattern; CMO players used Excel before they got
+   this). Plan summary shows estimated leakers all-at-TOT vs spread (fire-channel
+   saturation math already exists) and a "first launch at T−Xh may be detected"
+   warning when slow weapons are in the package — April vs October 2024 Iran
+   strikes as emergent gameplay. Staggered/sequential become impact-window
+   spreads on the same queue.
+3. **Unit images in tooltips + pinned card.** 22-unit verified image list
+   (research doc): US units all public-domain DoD photos on Wikimedia Commons;
+   Iranian split PD-by-US-Navy + Tasnim/Fars CC BY 4.0 (credit line required).
+   Hotlinking rejected (Commons 400s non-standard widths, discouraged) → build
+   script downloads via `Special:FilePath?width=500`, re-encodes 250 px WebP into
+   `public/unit-images/` (~400 KB total) + generates `src/data/unit-images.ts`
+   with license metadata. Image shows only at `identified` level (intel reward).
+   Credits panel entry mandatory incl. DoD non-endorsement disclaimer.
+4. **Minimal sound kit.** 8 CC0 sounds (Kenney Interface Sounds + freesound CC0:
+   klaxon, sonar ping #493162, radio squelch, launch whoosh, distant impact, CIC
+   room tone, UI blips, error). AudioManager: master/sfx/ambient GainNodes,
+   `ctx.resume()` on first gesture (autoplay rule), localStorage mute/volume,
+   one pure event→sound table. DEFCON precedent: sound is the cheapest immersion
+   multiplier in the genre. No camera shake — ops rooms flash and sound, never shake.
+5. **Combat legibility:** DEFCON-style kill markers (expanding blot → persistent
+   faint X + tally), contact track trails via `TripsLayer` (~30-point ring buffer,
+   ~10 game-min trail, fadeTrail), 200-300 ms opacity transitions on range rings,
+   300 ms tooltip hover delay + click-to-pin.
+
+## Wave A addendum
+
+6. **Engine scale stress test.** Synthetic scenario (~500 units, missiles in
+   flight) driven 1000+ ticks in a vitest perf guard: assert average tick stays
+   inside budget, log p95. Answers "do we need a faster engine" with numbers
+   instead of vibes (decision 2026-06-11: stay TS, harden, WASM only if a
+   measured hot path ever demands it).
+
+## Wave B — TILT 3D — CUT (player decision 2026-06-11: no 3D)
+
+Kept for the record only. Hillshade (Wave A.1) is 2D shading and stays.
+Do not add pitch/terrain/sky features.
+
+Everything needed ships in installed maplibre-gl 4.7.1 (terrain + sky + hillshade;
+v5/globe explicitly unnecessary). Add `terrain {source, exaggeration ~1.1}` + `sky`
+as style-root properties in BOTH styles (survives MAP/SAT swaps), maxPitch 70,
+TILT toggle flies pitch 0 ↔ ~55. Default OFF (protect 30 fps baseline).
+- deck.gl interop truth: keep `interleaved: false` (interleaved+terrain is broken,
+  deck.gl#8091). Overlay mode = icons draw over ridges — correct for a command UI.
+  Naval z=0 IS sea level; land units get z from the main-thread elevation grid;
+  IconLayer billboards stay readable under pitch.
+- Missile arcs: carry altitude into `Missile.path` as [lng,lat,alt], PathLayer with
+  z + follow-cam at pitch ~60 for ballistic arcs — the visual payoff.
+- Optional: maplibre-contour (BSD-3, same terrarium tiles) contour toggle for the
+  tactical-chart look at pitch 0.
+- Do NOT: interleaved mode, deck.gl TerrainLayer basemap, maplibre v5 migration,
+  Cesium-style full 3D. Watch deck.gl#10173 (fractional browser zoom drift in
+  installed 9.2.11).
+
+## Wave C — Air war (the big gameplay feature, ~1-2 weeks)
+
+Convergent design from CMO/Falcon/DCS Liberation: squadrons as pools, flights as
+transient tracks, orders at mission level only. Slots into shipped systems
+(contacts, datalink hubs, SAM envelopes, war support, satellite BDA products).
+1. `airWing: SquadronState[]` on carrier + airbases. CVW-9 real 2026 composition
+   (3×12 F/A-18E/F, 10 F-35C, 6 EA-18G, 5 E-2D — Lincoln really is in CENTCOM);
+   Iran: F-14 Isfahan, MiG-29 Mehrabad/Tabriz, Su-24 Bushehr, Su-35 Hamadan.
+   25-33% maintenance unavailability at start.
+2. One Flight entity (2-4 airframes folded into one `aircraft`-category unit so
+   movement/visibility/SAM/war-support work day one) + three verbs: CAP station
+   (auto-intercept via combat-on-contacts), Strike package (transit → release →
+   spawn existing missiles → RTB), AEW station (E-2D/E-3 pattern, datalink hub).
+3. Sortie economy = CMO's published numbers: 90-min CAP quick-turn, 6 h surge /
+   20 h sustained strike ready times, ~90-120 sorties/day carrier ceiling, one
+   global SURGE OPS lever (96 h half ready-times, then ×1.5 sustained).
+4. SEAD as EA-18G escort modifier (×0.6 SAM detect/pk in radius + emitting SAMs
+   become ELINT contacts). Tanker tax not tanker tracks (+30-40% radius costs 2
+   Super Hornet sorties; MQ-25 slipped to 2029). Strike-package planning delay
+   2-6 h paces the war and rewards the intel workflow.
+5. Iran plays a different air game: scramble-only interceptors vs approaching
+   packages (ai.ts escalation hook), hoarded Su-35 HVT, parked airframes as
+   strikeable airbase sub-targets whose loss permanently drains pools (BDA via
+   the shipped imagery products — June 2025 ramp strikes). Pilot stakes: KIA /
+   rescued / POW rolls feed war support + OSINT.
+6. UI = Air Plan board (Task Force Admiral pattern): squadrons × launch-cycle
+   windows, drop missions into cycles, engine air boss resolves. Read
+   dcs-retribution's flight-plan builder for auto-escort suggestion logic.
+
+## Wave D — Elevation fidelity (~2-4 days)
+
+Two tiers (current grid ~5.5 km aliases whole Zagros ridges):
+1. Build-time: regenerate static grid at 0.01° (~1.1 km) for the Gulf core box
+   (lat 22-34, lng 44-64) as Int16 (~4.8 MB raw, ~2 MB brotli) from Copernicus
+   GLO-30 COGs (verified keyless, HTTP Range OK, NO CORS → build-time only).
+   Header gains a version field; ElevationGrid gains bilinear sampling.
+2. Runtime: z11 terrarium tile LRU (128-256 tiles, 17-34 MB) decoded in the
+   worker via createImageBitmap + OffscreenCanvas for hot paths (LOS viewsheds,
+   TEL hide checks, cruise terrain-following) — ~68 m/px = DTED Level 1, the
+   real military LOS standard. Coarse grid stays as fallback.
+
+## Wave E — Longevity (pick per appetite)
+
+1. **Command-log replay foundation** (FIRST — unlocks everything below): record
+   (tick, Command) in executeCommand, seed+appVersion+scenarioHash in the save
+   envelope, periodic syncHash. Watch-replay mode = re-simulate in a second
+   worker. Caveat: JS trig isn't cross-engine deterministic — same-browser safe,
+   pin versions (OpenRA sync-hash pattern).
+2. **Daily Flashpoint**: date-hashed seed + fixed objectives + score + Wordle-style
+   emoji share block with `#c=base64url(gzip())` challenge URL (CompressionStream,
+   zero backend).
+3. **Scenario import/export + URL loading**: .json export/drag-drop import; load
+   from raw.githubusercontent/gist (CORS verified `*`). The JSON IS the editor.
+4. **Community gallery**: ashfall-scenarios repo + index.json via jsDelivr —
+   Steam Workshop with zero infrastructure, PR-based curation.
+5. **Persistent theater week**: dawn-planning/dusk-debrief day cycle, persistent
+   losses/ammo, sortie fatigue, procurement, one IndexedDB campaign slot (DCS
+   Liberation loop compressed to 7 browser days). Do after Wave C.
+6. **Rival commander persona**: templated communiqués from GameEvents into the
+   OSINT feed, seeded-deterministic. WebLLM paraphrase = optional toggle only
+   (multi-GB download is hostile onboarding) — never a dependency.
+7. **ADVISOR onboarding**: interactive checklist completing by observing real
+   Commands + diegetic Watch Officer's Handbook (Highfleet charm, not CMO videos).
+8. **Async 1v1 PBEM** LAST: WEGO command-packet exchange reusing replay machinery.
+   Realtime PeerJS lockstep deferred until trig determinism is solved.
+
+## Recommended order
+
+A (feel, incl. TOT) → C (air war) → B (TILT 3D) → D (elevation) → E1-E4
+(replay/daily/sharing) → E5 (campaign) → rest. Wave A first because every minute
+of play gets better immediately; C is the biggest pure-gameplay hole; B and D are
+spectacle and fidelity on top of a game that by then deserves them.
diff --git a/public/unit-images/arleigh_burke.jpg b/public/unit-images/arleigh_burke.jpg
new file mode 100644
index 0000000..72b0aa3
Binary files /dev/null and b/public/unit-images/arleigh_burke.jpg differ
diff --git a/public/unit-images/bavar373.jpg b/public/unit-images/bavar373.jpg
new file mode 100644
index 0000000..c92fd4e
Binary files /dev/null and b/public/unit-images/bavar373.jpg differ
diff --git a/public/unit-images/e3_sentry.jpg b/public/unit-images/e3_sentry.jpg
new file mode 100644
index 0000000..17c9b04
Binary files /dev/null and b/public/unit-images/e3_sentry.jpg differ
diff --git a/public/unit-images/fateh110.jpg b/public/unit-images/fateh110.jpg
new file mode 100644
index 0000000..25f3873
Binary files /dev/null and b/public/unit-images/fateh110.jpg differ
diff --git a/public/unit-images/ghadir_sub.jpg b/public/unit-images/ghadir_sub.jpg
new file mode 100644
index 0000000..10589bd
Binary files /dev/null and b/public/unit-images/ghadir_sub.jpg differ
diff --git a/public/unit-images/iran_airbase.jpg b/public/unit-images/iran_airbase.jpg
new file mode 100644
index 0000000..c73748c
Binary files /dev/null and b/public/unit-images/iran_airbase.jpg differ
diff --git a/public/unit-images/irgc_fac.jpg b/public/unit-images/irgc_fac.jpg
new file mode 100644
index 0000000..31f9b27
Binary files /dev/null and b/public/unit-images/irgc_fac.jpg differ
diff --git a/public/unit-images/khordad3.jpg b/public/unit-images/khordad3.jpg
new file mode 100644
index 0000000..2fb114d
Binary files /dev/null and b/public/unit-images/khordad3.jpg differ
diff --git a/public/unit-images/nimitz_cvn.jpg b/public/unit-images/nimitz_cvn.jpg
new file mode 100644
index 0000000..dcbeaad
Binary files /dev/null and b/public/unit-images/nimitz_cvn.jpg differ
diff --git a/public/unit-images/noor_coastal.jpg b/public/unit-images/noor_coastal.jpg
new file mode 100644
index 0000000..a898c04
Binary files /dev/null and b/public/unit-images/noor_coastal.jpg differ
diff --git a/public/unit-images/nsa_bahrain.jpg b/public/unit-images/nsa_bahrain.jpg
new file mode 100644
index 0000000..67a5c82
Binary files /dev/null and b/public/unit-images/nsa_bahrain.jpg differ
diff --git a/public/unit-images/patriot.jpg b/public/unit-images/patriot.jpg
new file mode 100644
index 0000000..0f668f8
Binary files /dev/null and b/public/unit-images/patriot.jpg differ
diff --git a/public/unit-images/s300pmu2.jpg b/public/unit-images/s300pmu2.jpg
new file mode 100644
index 0000000..457090b
Binary files /dev/null and b/public/unit-images/s300pmu2.jpg differ
diff --git a/public/unit-images/sejjil2.jpg b/public/unit-images/sejjil2.jpg
new file mode 100644
index 0000000..449dff1
Binary files /dev/null and b/public/unit-images/sejjil2.jpg differ
diff --git a/public/unit-images/shahab3.jpg b/public/unit-images/shahab3.jpg
new file mode 100644
index 0000000..7507fac
Binary files /dev/null and b/public/unit-images/shahab3.jpg differ
diff --git a/public/unit-images/shahed136.jpg b/public/unit-images/shahed136.jpg
new file mode 100644
index 0000000..2c7a756
Binary files /dev/null and b/public/unit-images/shahed136.jpg differ
diff --git a/public/unit-images/soumar.jpg b/public/unit-images/soumar.jpg
new file mode 100644
index 0000000..036b62f
Binary files /dev/null and b/public/unit-images/soumar.jpg differ
diff --git a/public/unit-images/thaad.jpg b/public/unit-images/thaad.jpg
new file mode 100644
index 0000000..85b7e5c
Binary files /dev/null and b/public/unit-images/thaad.jpg differ
diff --git a/public/unit-images/tor_m1.jpg b/public/unit-images/tor_m1.jpg
new file mode 100644
index 0000000..6f1f490
Binary files /dev/null and b/public/unit-images/tor_m1.jpg differ
diff --git a/public/unit-images/us_airbase.jpg b/public/unit-images/us_airbase.jpg
new file mode 100644
index 0000000..cef6c29
Binary files /dev/null and b/public/unit-images/us_airbase.jpg differ
diff --git a/public/unit-images/virginia_ssn.jpg b/public/unit-images/virginia_ssn.jpg
new file mode 100644
index 0000000..ecd9227
Binary files /dev/null and b/public/unit-images/virginia_ssn.jpg differ
diff --git a/public/unit-images/zolfaghar.jpg b/public/unit-images/zolfaghar.jpg
new file mode 100644
index 0000000..1b6e6e9
Binary files /dev/null and b/public/unit-images/zolfaghar.jpg differ
diff --git a/scripts/e2e-smoke.mjs b/scripts/e2e-smoke.mjs
index 4d913be..89a8afa 100644
--- a/scripts/e2e-smoke.mjs
+++ b/scripts/e2e-smoke.mjs
@@ -49,14 +49,49 @@ await step('fog of war: SITREP shows contacts, not full enemy orbat', async () =
   await clickText('SITREP', { exact: true })
 })
 
+await step('intel command center: tabs, assets, agents, opsec', async () => {
+  await clickText('INTEL', { exact: true })
+  await page.getByText('KH-11 CRYSTAL').first().waitFor({ timeout: 8000 })
+  await page.getByText('TASK PASS').first().waitFor({ timeout: 4000 })
+  await clickText('HUMINT', { exact: true })
+  await page.getByText('AMBER').first().waitFor({ timeout: 4000 })
+  await page.getByText('OPAL').first().waitFor({ timeout: 2000 })
+  await clickText('OSINT', { exact: true })
+  await clickText('OPSEC', { exact: true })
+  await page.getByText(/OPSEC SWEEP/i).first().waitFor({ timeout: 4000 })
+  await clickText('SIGINT', { exact: true })
+  await clickText('INTEL', { exact: true })
+})
+
+await step('live feeds window opens with all four quadrants', async () => {
+  await clickText('LIVE', { exact: true })
+  await page.getByText('GEOSAT IODC LIVE').first().waitFor({ timeout: 8000 })
+  await page.getByText(/HORMUZ TRAFFIC CAM/i).first().waitFor({ timeout: 4000 })
+  await page.getByText(/ISR FMV/i).first().waitFor({ timeout: 4000 })
+  await page.getByText(/ADS-B/i).first().waitFor({ timeout: 4000 })
+  await page.getByText(/INTEL SOURCES/i).first().waitFor({ timeout: 4000 })
+  await clickText('LIVE', { exact: true })
+})
+
+await step('time slider present in top bar', async () => {
+  const slider = page.locator('input[type="range"]').first()
+  await slider.waitFor({ timeout: 4000 })
+})
+
 await step('declare war', async () => {
   await clickText('DECLARE WAR')
   await clickText('CONFIRM WAR')
   await page.getByText('WAR: IRAN').first().waitFor({ timeout: 8000 })
 })
 
-await step('run the war at speed', async () => {
-  await clickText('1h', { exact: true })
+await step('run the war at speed via the time slider', async () => {
+  await page.locator('input[type="range"]').first().evaluate(el => {
+    const setter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value').set
+    setter.call(el, el.max)
+    el.dispatchEvent(new Event('input', { bubbles: true }))
+    el.dispatchEvent(new Event('change', { bubbles: true }))
+  })
+  await page.getByText('1h/s').first().waitFor({ timeout: 4000 })
   await page.waitForTimeout(8000)
 })
 
diff --git a/scripts/fetch-unit-images.mjs b/scripts/fetch-unit-images.mjs
new file mode 100644
index 0000000..9c70627
--- /dev/null
+++ b/scripts/fetch-unit-images.mjs
@@ -0,0 +1,230 @@
+/**
+ * Downloads one Wikimedia Commons recognition photo per unit class into
+ * public/unit-images/ and generates src/data/unit-images.ts with license
+ * metadata. Re-runnable; classes that fail (license, HTTP, not-a-JPEG) are
+ * dropped from the generated map and reported.
+ *
+ *   node scripts/fetch-unit-images.mjs
+ *
+ * Hotlinking is rejected by design (Commons 400s non-standard widths and
+ * discourages it) — width 500/250 are allowed thumb widths.
+ */
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const outDir = path.join(root, 'public', 'unit-images')
+const tsOut = path.join(root, 'src', 'data', 'unit-images.ts')
+
+const UA = 'AshfallCommand/1.0 (browser wargame; one-time build script fetching unit recognition photos)'
+const MAX_BYTES = 80 * 1024
+const WIDTHS = [500, 250]
+
+/** classKey → Commons file title (verified to exist + acceptable license, 2026-06-11) */
+const MANIFEST = [
+  // — USA (public-domain DoD photography) —
+  ['nimitz_cvn', 'File:USS Abraham Lincoln (CVN-72) underway during sea trials on 11 May 2017.jpg'],
+  ['arleigh_burke', 'File:US Navy 050413-N-5526M-016 The Arleigh Burke-class guided missile destroyer USS Mustin (DDG 89) underway in the Northern Persian Gulf while conducting Maritime Security Operations.jpg'],
+  ['virginia_ssn', 'File:US Navy 110909-N-OV802-222 The Virginia-class submarine Pre-Commissioning Unit (PCU) California (SSN 781) gets underway from Naval Station Norfolk.jpg'],
+  ['patriot', 'File:MIM-104 Patriot surface-to-air missile system launcher.jpg'],
+  ['thaad', 'File:THAAD missile launch in 2005 -2.jpg'],
+  ['e3_sentry', 'File:Boeing E-3 Sentry 090512-F-7550B-902.jpg'],
+  ['us_airbase', 'File:Al Udeid Air Base.jpg'],
+  ['nsa_bahrain', 'File:Navy Day at Naval Support Activity Bahrain 140416-N-RJ323-385.jpg'],
+  // — Iran (Tasnim/Fars/Mehr press photography, CC BY 4.0 — credit required) —
+  ['s300pmu2', 'File:S-300 Tehran 2017.jpg'],
+  ['bavar373', 'File:Bavar-373 upgrade ceremony (23).jpg'],
+  ['khordad3', 'File:3rd Khordad TELAR w Taer-2 missiles.jpg'],
+  ['tor_m1', 'File:Tor M1.jpg'],
+  ['shahab3', 'File:Shahab missile launch photographed by Satyar Emami.jpg'],
+  ['sejjil2', 'File:Sejjil missile launch - November 2008 (09).jpg'],
+  ['fateh110', 'File:Firing Fateh-110 belong to AFAGIR.jpg'],
+  ['zolfaghar', 'File:Two IRGC AF Missiles.jpg'],
+  ['soumar', 'File:Unveiling ceremony of Soumar cruise missile and other missiles (13).jpg'],
+  ['ghadir_sub', 'File:2012 Bandar Abbas new equipment induction ceremony - Ghadir-class submarine (10).jpg'],
+  ['noor_coastal', 'File:شلیک موشک کروز نور توسط یگان ساحلی نداجا از سواحل مکران (1).jpg'],
+  ['irgc_fac', 'File:Commissioning ceremony of IRGC naval vessels in March 2023 (10).jpg'],
+  ['iran_airbase', 'File:F-14 Tomcat at Mehrabad preparing for Iranian Army Day 2013 (1).jpg'],
+  ['shahed136', 'File:Military equipment displayed for the 44th Iranian revolution anniversary rally - Shahed 136.jpg'],
+]
+
+// PD/CC0/CC BY/CC BY-SA only — Commons' bare "Attribution" license is deliberately excluded
+const LICENSE_OK = /^(public domain|pd[\s-]|pd$|cc0|cc[\s-]by(-sa)?(\s\d\.\d)?$)/i
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+
+async function fetchRetry(url, attempt = 0) {
+  const res = await fetch(url, { headers: { 'User-Agent': UA } })
+  if (res.status === 429 && attempt < 4) {
+    await sleep(8000 * (attempt + 1))
+    return fetchRetry(url, attempt + 1)
+  }
+  return res
+}
+
+const stripHtml = (s) =>
+  (s ?? '').replace(/<[^>]*>/g, '').replace(/\s+/g, ' ').trim()
+
+function shorten(s, max = 70) {
+  return s.length > max ? `${s.slice(0, max - 1).trimEnd()}…` : s
+}
+
+/** One batched imageinfo query for every title (cheap on the API rate limit) */
+async function fetchMetadata(titles) {
+  const url = 'https://commons.wikimedia.org/w/api.php?' + new URLSearchParams({
+    format: 'json',
+    action: 'query',
+    titles: titles.join('|'),
+    prop: 'imageinfo',
+    iiprop: 'url|mime|extmetadata',
+  })
+  const res = await fetchRetry(url)
+  if (!res.ok) throw new Error(`metadata query failed: HTTP ${res.status}`)
+  const json = await res.json()
+  const byTitle = new Map()
+  for (const page of Object.values(json.query?.pages ?? {})) {
+    if (page.imageinfo?.[0]) byTitle.set(page.title, page.imageinfo[0])
+  }
+  // map normalized titles back to requested ones
+  for (const { from, to } of json.query?.normalized ?? []) {
+    if (byTitle.has(to)) byTitle.set(from, byTitle.get(to))
+  }
+  return byTitle
+}
+
+async function downloadJpeg(title, width) {
+  const name = encodeURIComponent(title.replace(/^File:/, ''))
+  const url = `https://commons.wikimedia.org/wiki/Special:FilePath/${name}?width=${width}`
+  const res = await fetchRetry(url)
+  if (!res.ok) throw new Error(`HTTP ${res.status} at width ${width}`)
+  const buf = Buffer.from(await res.arrayBuffer())
+  if (buf.length < 4 || buf[0] !== 0xff || buf[1] !== 0xd8 || buf[2] !== 0xff) {
+    throw new Error(`not a JPEG (first bytes ${buf.subarray(0, 3).toString('hex')}) at width ${width}`)
+  }
+  return buf
+}
+
+const entries = {}
+const failures = []
+
+await fs.mkdir(outDir, { recursive: true })
+
+console.log('Fetching metadata for', MANIFEST.length, 'titles...')
+const meta = await fetchMetadata(MANIFEST.map(([, t]) => t))
+
+for (const [key, title] of MANIFEST) {
+  const info = meta.get(title)
+  if (!info) {
+    failures.push([key, 'no imageinfo (title missing on Commons?)'])
+    continue
+  }
+  const md = info.extmetadata ?? {}
+  const license = stripHtml(md.LicenseShortName?.value)
+  const author = shorten(stripHtml(md.Artist?.value) || 'Unknown')
+  if (!LICENSE_OK.test(license)) {
+    failures.push([key, `license not in allowlist: "${license}"`])
+    continue
+  }
+  if (info.mime !== 'image/jpeg') {
+    failures.push([key, `not a JPEG source: ${info.mime}`])
+    continue
+  }
+  try {
+    let buf = await downloadJpeg(title, WIDTHS[0])
+    if (buf.length > MAX_BYTES) {
+      await sleep(1500)
+      buf = await downloadJpeg(title, WIDTHS[1])
+    }
+    if (buf.length > MAX_BYTES) {
+      console.warn(`  WARN ${key}: still ${(buf.length / 1024).toFixed(0)} KB at width ${WIDTHS[1]}, keeping it`)
+    }
+    const file = `${key}.jpg`
+    await fs.writeFile(path.join(outDir, file), buf)
+    entries[key] = {
+      file,
+      title: title.replace(/^File:/, ''),
+      author,
+      license,
+      sourceUrl: info.descriptionurl ?? `https://commons.wikimedia.org/wiki/${encodeURIComponent(title)}`,
+    }
+    console.log(`  OK   ${key}  ${(buf.length / 1024).toFixed(0)} KB  [${license}] ${author}`)
+  } catch (e) {
+    failures.push([key, e.message])
+  }
+  await sleep(1500)
+}
+
+for (const [key, why] of failures) console.warn(`  DROP ${key}: ${why}`)
+
+const count = Object.keys(entries).length
+console.log(`\n${count}/${MANIFEST.length} classes downloaded.`)
+if (count < 12) {
+  console.error('Fewer than 12 classes succeeded — generated map is too thin, aborting without writing TS.')
+  process.exit(1)
+}
+
+const entryLines = Object.entries(entries)
+  .map(([key, e]) =>
+    `  ${key}: { file: ${JSON.stringify(e.file)}, title: ${JSON.stringify(e.title)}, author: ${JSON.stringify(e.author)}, license: ${JSON.stringify(e.license)}, sourceUrl: ${JSON.stringify(e.sourceUrl)} },`)
+  .join('\n')
+
+const ts = `/**
+ * GENERATED by scripts/fetch-unit-images.mjs — re-run the script instead of
+ * editing image entries by hand. Recognition photos live in public/unit-images/.
+ * Licenses: US imagery is public-domain DoD photography; Iranian imagery is
+ * CC BY press photography — author + license MUST be shown wherever an image
+ * renders (in-game credit caption + LIVE FEEDS credits panel).
+ */
+
+export interface UnitImageInfo {
+  /** filename under public/unit-images/ */
+  file: string
+  /** Commons file title (without the File: prefix) */
+  title: string
+  author: string
+  license: string
+  sourceUrl: string
+}
+
+export const UNIT_IMAGES: Record<string, UnitImageInfo> = {
+${entryLines}
+}
+
+const US_AIRBASE_HINTS = ['udeid', 'dhafra', 'prince sultan', 'al salem', 'incirlik', 'diego garcia']
+
+/**
+ * Best-effort class match from unit name/category. May return a key with no
+ * UNIT_IMAGES entry (download dropped) — callers must check the map.
+ */
+export function unitImageKey(unit: { name: string; category: string }): string | null {
+  const n = unit.name.toLowerCase()
+  if (unit.category === 'carrier_group' || n.includes('cvn')) return 'nimitz_cvn'
+  if (n.includes('ddg') || n.includes('arleigh')) return 'arleigh_burke'
+  if (n.includes('ssn')) return 'virginia_ssn'
+  if (n.includes('patriot')) return 'patriot'
+  if (n.includes('thaad')) return 'thaad'
+  if (n.includes('e-3') || n.includes('awacs')) return 'e3_sentry'
+  if (n.includes('nsa bahrain') || n.includes('5th fleet')) return 'nsa_bahrain'
+  if (n.includes('s-300')) return 's300pmu2'
+  if (n.includes('bavar')) return 'bavar373'
+  if (n.includes('khordad')) return 'khordad3'
+  if (n.includes('tor-m1')) return 'tor_m1'
+  if (n.includes('shahab')) return 'shahab3'
+  if (n.includes('sejjil')) return 'sejjil2'
+  if (n.includes('fateh')) return 'fateh110'
+  if (n.includes('zolfaghar')) return 'zolfaghar'
+  if (n.includes('soumar')) return 'soumar'
+  if (n.includes('ghadir')) return 'ghadir_sub'
+  if (n.includes('coastal') || n.includes('qeshm')) return 'noor_coastal'
+  if (/\\bfac\\b/.test(n)) return 'irgc_fac'
+  if (n.includes('shahed')) return 'shahed136'
+  if (unit.category === 'airbase') {
+    return US_AIRBASE_HINTS.some((h) => n.includes(h)) ? 'us_airbase' : 'iran_airbase'
+  }
+  return null
+}
+`
+
+await fs.writeFile(tsOut, ts, 'utf8')
+console.log('Wrote', tsOut)
diff --git a/src/App.tsx b/src/App.tsx
index 689da25..7a26758 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -9,6 +9,9 @@ import EconomyPanel from '@/components/panels/EconomyPanel'
 import OrbatPanel from '@/components/panels/OrbatPanel'
 import StatsPanel from '@/components/panels/StatsPanel'
 import IntelPanel from '@/components/panels/IntelPanel'
+import ImintViewer from '@/components/intel/ImintViewer'
+import LiveFeeds from '@/components/intel/LiveFeeds'
+import OsintTicker from '@/components/intel/OsintTicker'
 import StartScreen from '@/components/menu/StartScreen'
 import ScenarioSelect from '@/components/menu/ScenarioSelect'
 import FreeModeLobby from '@/components/menu/FreeModeLobby'
@@ -19,6 +22,7 @@ import { useMenuStore } from '@/store/menu-store'
 import { useDeploymentStore } from '@/store/deployment-store'
 import { useStrikeStore } from '@/store/strike-store'
 import { useIsMobile } from '@/hooks/useIsMobile'
+import { useSoundEffects } from '@/audio/useSoundEffects'
 import { initBridge, initFromData, sendCommand } from '@/store/bridge'
 import { getScenario } from '@/data/scenarios/index'
 
@@ -29,6 +33,8 @@ export default function App() {
   const [mobilePanel, setMobilePanel] = useState<MobilePanel>(null)
   const screen = useMenuStore(s => s.screen)
 
+  useSoundEffects()
+
   useEffect(() => {
     initBridge()
   }, [])
@@ -133,6 +139,8 @@ export default function App() {
           break
         }
         const ui = useUIStore.getState()
+        // Close the topmost registered panel first (ImintViewer capture-stops its own Escape before this runs)
+        if (ui.closeTopPanel()) break
         if (ui.leftPanel !== null || ui.showIntel || strike.open) {
           ui.setLeftPanel(null)
           useUIStore.setState({ showIntel: false })
@@ -168,6 +176,7 @@ export default function App() {
         {mobilePanel === 'econ' && <EconomyPanel />}
         {mobilePanel === 'events' && <AlertFeed />}
         {mobilePanel === 'intel' && <IntelPanel onClose={() => setMobilePanel(null)} />}
+        <ImintViewer />
         <MobileNav active={mobilePanel} onSelect={setMobilePanel} hasSelection={!!selectedUnitId} />
         {showDebrief && <DebriefScreen onDismiss={dismissDebrief} />}
       </div>
@@ -179,12 +188,15 @@ export default function App() {
       <GameMap />
       <TopBar />
       <AlertFeed />
+      <OsintTicker />
       <UnitInfoPanel units={units} />
       <StrikePanel />
       {showOrbat && <OrbatPanel />}
       {showStats && <StatsPanel />}
       {showEconomy && <EconomyPanel />}
       {showIntel && <IntelPanel />}
+      <LiveFeeds />
+      <ImintViewer />
       {showDebrief && <DebriefScreen onDismiss={dismissDebrief} />}
     </div>
   )
diff --git a/src/audio/__tests__/audio-manager.test.ts b/src/audio/__tests__/audio-manager.test.ts
new file mode 100644
index 0000000..42dc4cc
--- /dev/null
+++ b/src/audio/__tests__/audio-manager.test.ts
@@ -0,0 +1,255 @@
+import { describe, it, expect, vi } from 'vitest'
+import {
+  AudioManager,
+  AUDIO_STORAGE_KEYS,
+  DEFAULT_DEBOUNCE_MS,
+  DEFAULT_VOLUME,
+  SOUND_DEBOUNCE_MS,
+} from '../audio-manager'
+import type { AudioManagerDeps, SoundKit, SoundName } from '../audio-manager'
+
+const SOUND_NAMES: SoundName[] = [
+  'klaxon', 'sonar-ping', 'radio-squelch', 'launch-whoosh',
+  'distant-impact', 'ui-blip', 'ui-error', 'ambient-cic',
+]
+
+function makeFakeGain() {
+  return {
+    gain: { value: 1 },
+    connect: vi.fn(),
+    disconnect: vi.fn(),
+  }
+}
+
+function makeFakeSource() {
+  return {
+    buffer: null as unknown,
+    loop: false,
+    connect: vi.fn(),
+    disconnect: vi.fn(),
+    start: vi.fn(),
+    stop: vi.fn(),
+  }
+}
+
+function makeFakeContext() {
+  const gains: ReturnType<typeof makeFakeGain>[] = []
+  const sources: ReturnType<typeof makeFakeSource>[] = []
+  const ctx = {
+    state: 'suspended',
+    sampleRate: 44100,
+    destination: {},
+    resume: vi.fn(async () => { ctx.state = 'running' }),
+    createGain: vi.fn(() => {
+      const g = makeFakeGain()
+      gains.push(g)
+      return g
+    }),
+    createBufferSource: vi.fn(() => {
+      const s = makeFakeSource()
+      sources.push(s)
+      return s
+    }),
+  }
+  return { ctx, gains, sources }
+}
+
+function makeMapStorage() {
+  const map = new Map<string, string>()
+  return {
+    map,
+    getItem: (key: string) => map.get(key) ?? null,
+    setItem: (key: string, value: string) => { map.set(key, value) },
+  }
+}
+
+function makeKit(): SoundKit {
+  const kit: SoundKit = {}
+  for (const name of SOUND_NAMES) kit[name] = { soundName: name } as unknown as AudioBuffer
+  return kit
+}
+
+function makeManager(over: Partial<AudioManagerDeps> = {}) {
+  const fake = makeFakeContext()
+  const storage = makeMapStorage()
+  const clock = { nowMs: 0 }
+  const manager = new AudioManager({
+    createContext: () => fake.ctx as unknown as AudioContext,
+    loadKit: async () => makeKit(),
+    storage,
+    now: () => clock.nowMs,
+    ...over,
+  })
+  return { manager, fake, storage, clock }
+}
+
+describe('AudioManager init', () => {
+  it('resumes a suspended context and builds master/sfx/ambient buses', async () => {
+    const { manager, fake } = makeManager()
+    await manager.init()
+    expect(fake.ctx.resume).toHaveBeenCalledTimes(1)
+    expect(fake.ctx.createGain).toHaveBeenCalledTimes(3)
+    expect(manager.isInitialized()).toBe(true)
+  })
+
+  it('initializes once on the first gesture, then ignores further gestures', async () => {
+    const { manager, fake } = makeManager()
+    const target = new EventTarget()
+    manager.attachGestureListeners(target)
+    expect(manager.isInitialized()).toBe(false)
+
+    target.dispatchEvent(new Event('pointerdown'))
+    await manager.init()
+    expect(fake.ctx.resume).toHaveBeenCalledTimes(1)
+
+    target.dispatchEvent(new Event('keydown'))
+    target.dispatchEvent(new Event('pointerdown'))
+    await manager.init()
+    expect(fake.ctx.createGain).toHaveBeenCalledTimes(3)
+  })
+
+  it('degrades gracefully when no AudioContext is available', async () => {
+    const { manager } = makeManager({ createContext: () => null })
+    await manager.init()
+    expect(manager.isInitialized()).toBe(false)
+    expect(manager.play('ui-blip')).toBe(false)
+    expect(() => manager.startAmbient()).not.toThrow()
+    expect(() => manager.stopAmbient()).not.toThrow()
+  })
+})
+
+describe('AudioManager play + debounce', () => {
+  it('does not play before init, and the failed attempt does not burn the debounce window', async () => {
+    const { manager, fake } = makeManager()
+    expect(manager.play('ui-blip')).toBe(false)
+    expect(fake.sources.length).toBe(0)
+    await manager.init()
+    expect(manager.play('ui-blip')).toBe(true)
+    expect(fake.sources.length).toBe(1)
+    expect(fake.sources[0].start).toHaveBeenCalledTimes(1)
+  })
+
+  it('debounces repeats inside the default window and allows them after', async () => {
+    const { manager, clock } = makeManager()
+    await manager.init()
+    expect(manager.play('ui-blip')).toBe(true)
+    expect(manager.play('ui-blip')).toBe(false)
+    clock.nowMs = DEFAULT_DEBOUNCE_MS - 1
+    expect(manager.play('ui-blip')).toBe(false)
+    clock.nowMs = DEFAULT_DEBOUNCE_MS
+    expect(manager.play('ui-blip')).toBe(true)
+  })
+
+  it('debounces klaxon with its heavy per-sound window', async () => {
+    const { manager, clock } = makeManager()
+    await manager.init()
+    const gap = SOUND_DEBOUNCE_MS['klaxon']!
+    expect(manager.play('klaxon')).toBe(true)
+    clock.nowMs = gap - 1
+    expect(manager.play('klaxon')).toBe(false)
+    clock.nowMs = gap
+    expect(manager.play('klaxon')).toBe(true)
+  })
+
+  it('tracks debounce per sound name, not globally', async () => {
+    const { manager, fake } = makeManager()
+    await manager.init()
+    expect(manager.play('ui-blip')).toBe(true)
+    expect(manager.play('klaxon')).toBe(true)
+    expect(fake.sources.length).toBe(2)
+  })
+
+  it('applies per-play volume through an extra gain node', async () => {
+    const { manager, fake } = makeManager()
+    await manager.init()
+    expect(manager.play('ui-blip', { volume: 0.3 })).toBe(true)
+    const perPlayGain = fake.gains[3] // 0-2 are master/sfx/ambient
+    expect(perPlayGain.gain.value).toBe(0.3)
+    expect(fake.sources[0].connect).toHaveBeenCalledWith(perPlayGain)
+  })
+
+  it('returns false for sounds missing from the kit', async () => {
+    const { manager } = makeManager({ loadKit: async () => ({}) })
+    await manager.init()
+    expect(manager.play('ui-blip')).toBe(false)
+  })
+})
+
+describe('AudioManager mute/volume persistence', () => {
+  it('defaults to unmuted at default volume', () => {
+    const { manager } = makeManager()
+    expect(manager.isMuted()).toBe(false)
+    expect(manager.getVolume()).toBe(DEFAULT_VOLUME)
+  })
+
+  it('drives the master gain: volume when unmuted, 0 when muted', async () => {
+    const { manager, fake } = makeManager()
+    await manager.init()
+    const master = fake.gains[0]
+    expect(master.gain.value).toBe(DEFAULT_VOLUME)
+
+    manager.setMuted(true)
+    expect(master.gain.value).toBe(0)
+
+    manager.setVolume(0.8)
+    expect(master.gain.value).toBe(0)
+
+    manager.setMuted(false)
+    expect(master.gain.value).toBe(0.8)
+  })
+
+  it('persists prefs and restores them in a fresh manager', () => {
+    const { manager, storage } = makeManager()
+    manager.setMuted(true)
+    manager.setVolume(0.8)
+    expect(storage.map.get(AUDIO_STORAGE_KEYS.muted)).toBe('1')
+    expect(storage.map.get(AUDIO_STORAGE_KEYS.volume)).toBe('0.8')
+
+    const { manager: restored } = makeManager({ storage })
+    expect(restored.isMuted()).toBe(true)
+    expect(restored.getVolume()).toBe(0.8)
+  })
+
+  it('clamps volume to 0..1', () => {
+    const { manager } = makeManager()
+    manager.setVolume(1.7)
+    expect(manager.getVolume()).toBe(1)
+    manager.setVolume(-2)
+    expect(manager.getVolume()).toBe(0)
+  })
+
+  it('works without storage', () => {
+    const { manager } = makeManager({ storage: null })
+    expect(() => manager.setMuted(true)).not.toThrow()
+    expect(manager.isMuted()).toBe(true)
+  })
+})
+
+describe('AudioManager ambient loop', () => {
+  it('starts the loop after init even when requested before, and stops cleanly', async () => {
+    const { manager, fake } = makeManager()
+    manager.startAmbient()
+    expect(fake.sources.length).toBe(0)
+
+    await manager.init()
+    expect(fake.sources.length).toBe(1)
+    expect(fake.sources[0].loop).toBe(true)
+    expect(fake.sources[0].start).toHaveBeenCalledTimes(1)
+
+    manager.startAmbient()
+    expect(fake.sources.length).toBe(1)
+
+    manager.stopAmbient()
+    expect(fake.sources[0].stop).toHaveBeenCalledTimes(1)
+
+    manager.startAmbient()
+    expect(fake.sources.length).toBe(2)
+  })
+
+  it('does not start ambient when the kit lacks the loop buffer', async () => {
+    const { manager, fake } = makeManager({ loadKit: async () => ({}) })
+    await manager.init()
+    manager.startAmbient()
+    expect(fake.sources.length).toBe(0)
+  })
+})
diff --git a/src/audio/__tests__/event-sounds.test.ts b/src/audio/__tests__/event-sounds.test.ts
new file mode 100644
index 0000000..75a4188
--- /dev/null
+++ b/src/audio/__tests__/event-sounds.test.ts
@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest'
+import { soundForEvent } from '../event-sounds'
+import type { SoundName } from '../audio-manager'
+import type { GameEvent } from '@/types/game'
+
+const tick = 42
+const pos = { lng: 52, lat: 27 }
+
+const cases: [GameEvent, SoundName | null][] = [
+  [{ type: 'WAR_DECLARED', attacker: 'usa', defender: 'iran', tick }, 'klaxon'],
+  [{ type: 'MISSILE_LAUNCHED', missileId: 'm1', launcherId: 'u1', targetId: 'u2', weaponName: 'Tomahawk', tick }, 'launch-whoosh'],
+  [{ type: 'MISSILE_IMPACT', missileId: 'm1', targetId: 'u2', damage: 40, tick }, 'distant-impact'],
+  [{ type: 'UNIT_DESTROYED', unitId: 'u2', tick }, 'distant-impact'],
+  [{ type: 'MISSILE_INTERCEPTED', missileId: 'm1', interceptorId: 'u3', position: pos, tick }, 'ui-blip'],
+  [{ type: 'POINT_DEFENSE_KILL', unitId: 'u3', missileId: 'm1', specId: 'ciws', tick }, 'ui-blip'],
+  [{ type: 'AGENT_ARRESTED', agentId: 'a1', codename: 'CYRUS', tick }, 'ui-error'],
+  [{ type: 'STRIKE_LEAKED', targetId: 'u2', tick }, 'ui-error'],
+  [{ type: 'INTERCEPT_DECRYPTED', precedence: 'FLASH', text: 'launch order intercepted', tick }, 'radio-squelch'],
+  [{ type: 'SATELLITE_PASS_COMPLETE', assetId: 's1', target: pos, found: 2, revealedDecoys: 0, tick }, 'sonar-ping'],
+  [{ type: 'CEASEFIRE_OFFERED', by: 'iran', tick }, 'radio-squelch'],
+  [{ type: 'WAR_ENDED', outcome: 'ceasefire', tick }, 'radio-squelch'],
+]
+
+const silentCases: GameEvent[] = [
+  { type: 'INTERCEPT_DECRYPTED', precedence: 'ROUTINE', text: 'routine traffic', tick },
+  { type: 'INTERCEPT_DECRYPTED', precedence: 'IMMEDIATE', text: 'immediate traffic', tick },
+  { type: 'RESUPPLIED', unitId: 'u1', weaponId: 'w1', count: 4, fromBaseId: 'b1', tick },
+  { type: 'OIL_PRICE_CHANGE', newPrice: 95, oldPrice: 80, tick },
+  { type: 'AGENT_REPORT', agentId: 'a1', codename: 'CYRUS', text: 'report', tick },
+  { type: 'SATELLITE_PASS_FAILED', assetId: 's1', target: pos, cloudPct: 80, tick },
+  { type: 'ORDER_REJECTED', unitId: 'u1', reason: 'no fuel', tick },
+]
+
+describe('soundForEvent', () => {
+  it.each(cases.map(([e, expected]) => [e.type, e, expected] as const))(
+    'maps %s',
+    (_type, e, expected) => {
+      expect(soundForEvent(e)).toBe(expected)
+    },
+  )
+
+  it.each(silentCases.map((e) => [e.type, e] as const))(
+    'stays silent for %s',
+    (_type, e) => {
+      expect(soundForEvent(e)).toBeNull()
+    },
+  )
+
+  it('only FLASH intercepts squelch', () => {
+    const flash: GameEvent = { type: 'INTERCEPT_DECRYPTED', precedence: 'FLASH', text: 'x', tick }
+    const priority: GameEvent = { type: 'INTERCEPT_DECRYPTED', precedence: 'PRIORITY', text: 'x', tick }
+    expect(soundForEvent(flash)).toBe('radio-squelch')
+    expect(soundForEvent(priority)).toBeNull()
+  })
+})
diff --git a/src/audio/audio-manager.ts b/src/audio/audio-manager.ts
new file mode 100644
index 0000000..13ad693
--- /dev/null
+++ b/src/audio/audio-manager.ts
@@ -0,0 +1,271 @@
+import { synthesizeKit } from './synth'
+
+export type SoundName =
+  | 'klaxon'
+  | 'sonar-ping'
+  | 'radio-squelch'
+  | 'launch-whoosh'
+  | 'distant-impact'
+  | 'ui-blip'
+  | 'ui-error'
+  | 'ambient-cic'
+
+export type BusName = 'sfx' | 'ambient'
+
+export interface PlayOptions {
+  bus?: BusName
+  volume?: number
+}
+
+export const AUDIO_STORAGE_KEYS = {
+  muted: 'ashfall.audio.muted',
+  volume: 'ashfall.audio.volume',
+} as const
+
+export const DEFAULT_VOLUME = 0.5
+/** Ambient bus sits well under sfx — CIC room tone, not a soundtrack */
+const AMBIENT_BUS_LEVEL = 0.4
+
+export const DEFAULT_DEBOUNCE_MS = 80
+/** Long sounds get long debounces so a 30-missile salvo doesn't stack 30 klaxons */
+export const SOUND_DEBOUNCE_MS: Partial<Record<SoundName, number>> = {
+  'klaxon': 2500,
+  'launch-whoosh': 1500,
+  'distant-impact': 300,
+  'sonar-ping': 500,
+  'radio-squelch': 400,
+  'ui-error': 200,
+}
+
+export type SoundKit = Partial<Record<SoundName, AudioBuffer>>
+
+export interface AudioManagerDeps {
+  createContext?: () => AudioContext | null
+  loadKit?: (ctx: AudioContext) => Promise<SoundKit>
+  /** null = no persistence (e.g. storage blocked) */
+  storage?: Pick<Storage, 'getItem' | 'setItem'> | null
+  now?: () => number
+}
+
+function clamp01(v: number): number {
+  return Math.max(0, Math.min(1, v))
+}
+
+function defaultCreateContext(): AudioContext | null {
+  try {
+    const Ctor = typeof AudioContext !== 'undefined'
+      ? AudioContext
+      : (globalThis as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext
+    return Ctor ? new Ctor() : null
+  } catch {
+    return null
+  }
+}
+
+function defaultStorage(): Pick<Storage, 'getItem' | 'setItem'> | null {
+  try {
+    return typeof localStorage !== 'undefined' ? localStorage : null
+  } catch {
+    return null
+  }
+}
+
+export class AudioManager {
+  private createContext: () => AudioContext | null
+  private loadKit: (ctx: AudioContext) => Promise<SoundKit>
+  private storage: Pick<Storage, 'getItem' | 'setItem'> | null
+  private now: () => number
+
+  private ctx: AudioContext | null = null
+  private master: GainNode | null = null
+  private buses: Record<BusName, GainNode> | null = null
+  private buffers: SoundKit = {}
+  private lastPlayedMs = new Map<SoundName, number>()
+  private ambientSource: AudioBufferSourceNode | null = null
+  private ambientWanted = false
+  private muted: boolean
+  private volume: number
+  private initPromise: Promise<void> | null = null
+  private detachGesture: (() => void) | null = null
+
+  constructor(deps: AudioManagerDeps = {}) {
+    this.createContext = deps.createContext ?? defaultCreateContext
+    this.loadKit = deps.loadKit ?? ((ctx) => synthesizeKit(ctx.sampleRate))
+    this.storage = deps.storage === undefined ? defaultStorage() : deps.storage
+    this.now = deps.now
+      ?? (() => (typeof performance !== 'undefined' ? performance.now() : Date.now()))
+
+    this.muted = this.readStored(AUDIO_STORAGE_KEYS.muted) === '1'
+    const storedVolume = this.readStored(AUDIO_STORAGE_KEYS.volume)
+    const parsed = storedVolume === null ? NaN : Number(storedVolume)
+    this.volume = Number.isFinite(parsed) ? clamp01(parsed) : DEFAULT_VOLUME
+  }
+
+  /** Browsers block AudioContext until a user gesture — init on the first one, then detach */
+  attachGestureListeners(target: EventTarget): void {
+    if (this.detachGesture) return
+    const onGesture = () => {
+      this.detachGesture?.()
+      void this.init()
+    }
+    target.addEventListener('pointerdown', onGesture, { once: true })
+    target.addEventListener('keydown', onGesture, { once: true })
+    this.detachGesture = () => {
+      target.removeEventListener('pointerdown', onGesture)
+      target.removeEventListener('keydown', onGesture)
+      this.detachGesture = null
+    }
+  }
+
+  detachGestureListeners(): void {
+    this.detachGesture?.()
+  }
+
+  /** Idempotent; a failed init leaves the manager permanently (and silently) inert */
+  init(): Promise<void> {
+    if (!this.initPromise) {
+      this.initPromise = this.doInit().catch(() => undefined)
+    }
+    return this.initPromise
+  }
+
+  isInitialized(): boolean {
+    return this.ctx !== null
+  }
+
+  private async doInit(): Promise<void> {
+    const ctx = this.createContext()
+    if (!ctx) return
+    this.ctx = ctx
+    if (ctx.state === 'suspended') {
+      try {
+        await ctx.resume()
+      } catch {
+        // stays suspended — play() calls are harmless no-audio ops
+      }
+    }
+
+    const master = ctx.createGain()
+    master.connect(ctx.destination)
+    const sfx = ctx.createGain()
+    sfx.connect(master)
+    const ambient = ctx.createGain()
+    ambient.gain.value = AMBIENT_BUS_LEVEL
+    ambient.connect(master)
+    this.master = master
+    this.buses = { sfx, ambient }
+    this.applyMasterGain()
+
+    try {
+      this.buffers = await this.loadKit(ctx)
+    } catch {
+      this.buffers = {}
+    }
+    if (this.ambientWanted) this.startAmbientSource()
+  }
+
+  /** Returns true only when a source actually started */
+  play(name: SoundName, opts: PlayOptions = {}): boolean {
+    const minGapMs = SOUND_DEBOUNCE_MS[name] ?? DEFAULT_DEBOUNCE_MS
+    const t = this.now()
+    const last = this.lastPlayedMs.get(name)
+    if (last !== undefined && t - last < minGapMs) return false
+
+    const ctx = this.ctx
+    const buses = this.buses
+    const buffer = this.buffers[name]
+    if (!ctx || !buses || !buffer) return false
+
+    this.lastPlayedMs.set(name, t)
+    const source = ctx.createBufferSource()
+    source.buffer = buffer
+    const bus = buses[opts.bus ?? 'sfx']
+    if (opts.volume !== undefined) {
+      const gain = ctx.createGain()
+      gain.gain.value = clamp01(opts.volume)
+      source.connect(gain)
+      gain.connect(bus)
+    } else {
+      source.connect(bus)
+    }
+    source.start()
+    return true
+  }
+
+  startAmbient(): void {
+    this.ambientWanted = true
+    this.startAmbientSource()
+  }
+
+  stopAmbient(): void {
+    this.ambientWanted = false
+    if (!this.ambientSource) return
+    try {
+      this.ambientSource.stop()
+    } catch {
+      // already stopped
+    }
+    try {
+      this.ambientSource.disconnect()
+    } catch {
+      // already disconnected
+    }
+    this.ambientSource = null
+  }
+
+  private startAmbientSource(): void {
+    if (!this.ambientWanted || this.ambientSource) return
+    const ctx = this.ctx
+    const buses = this.buses
+    const buffer = this.buffers['ambient-cic']
+    if (!ctx || !buses || !buffer) return
+    const source = ctx.createBufferSource()
+    source.buffer = buffer
+    source.loop = true
+    source.connect(buses.ambient)
+    source.start()
+    this.ambientSource = source
+  }
+
+  isMuted(): boolean {
+    return this.muted
+  }
+
+  getVolume(): number {
+    return this.volume
+  }
+
+  setMuted(muted: boolean): void {
+    this.muted = muted
+    this.writeStored(AUDIO_STORAGE_KEYS.muted, muted ? '1' : '0')
+    this.applyMasterGain()
+  }
+
+  setVolume(volume: number): void {
+    this.volume = clamp01(volume)
+    this.writeStored(AUDIO_STORAGE_KEYS.volume, String(this.volume))
+    this.applyMasterGain()
+  }
+
+  private applyMasterGain(): void {
+    if (this.master) this.master.gain.value = this.muted ? 0 : this.volume
+  }
+
+  private readStored(key: string): string | null {
+    try {
+      return this.storage?.getItem(key) ?? null
+    } catch {
+      return null
+    }
+  }
+
+  private writeStored(key: string, value: string): void {
+    try {
+      this.storage?.setItem(key, value)
+    } catch {
+      // persistence unavailable — session-only prefs
+    }
+  }
+}
+
+export const audioManager = new AudioManager()
diff --git a/src/audio/event-sounds.ts b/src/audio/event-sounds.ts
new file mode 100644
index 0000000..bb8dfa4
--- /dev/null
+++ b/src/audio/event-sounds.ts
@@ -0,0 +1,33 @@
+import type { GameEvent } from '@/types/game'
+import type { SoundName } from './audio-manager'
+
+/**
+ * Pure event→sound table. The own-unit-destroyed klaxon overlay lives in
+ * useSoundEffects — it needs viewState to resolve the unit's nation.
+ */
+export function soundForEvent(e: GameEvent): SoundName | null {
+  switch (e.type) {
+    case 'WAR_DECLARED':
+      return 'klaxon'
+    case 'MISSILE_LAUNCHED':
+      return 'launch-whoosh'
+    case 'MISSILE_IMPACT':
+    case 'UNIT_DESTROYED':
+      return 'distant-impact'
+    case 'MISSILE_INTERCEPTED':
+    case 'POINT_DEFENSE_KILL':
+      return 'ui-blip'
+    case 'AGENT_ARRESTED':
+    case 'STRIKE_LEAKED':
+      return 'ui-error'
+    case 'INTERCEPT_DECRYPTED':
+      return e.precedence === 'FLASH' ? 'radio-squelch' : null
+    case 'SATELLITE_PASS_COMPLETE':
+      return 'sonar-ping'
+    case 'CEASEFIRE_OFFERED':
+    case 'WAR_ENDED':
+      return 'radio-squelch'
+    default:
+      return null
+  }
+}
diff --git a/src/audio/synth.ts b/src/audio/synth.ts
new file mode 100644
index 0000000..9e7968a
--- /dev/null
+++ b/src/audio/synth.ts
@@ -0,0 +1,290 @@
+import type { SoundKit } from './audio-manager'
+
+// Procedural DEFCON-style ops-room kit — no audio assets shipped, every sound is
+// rendered once at init via OfflineAudioContext and cached as an AudioBuffer.
+
+const DEFAULT_SAMPLE_RATE = 44100
+
+type OfflineCtor = new (numberOfChannels: number, length: number, sampleRate: number) => OfflineAudioContext
+
+function getOfflineCtor(): OfflineCtor | null {
+  if (typeof OfflineAudioContext !== 'undefined') return OfflineAudioContext
+  const webkit = (globalThis as { webkitOfflineAudioContext?: OfflineCtor }).webkitOfflineAudioContext
+  return webkit ?? null
+}
+
+function whiteNoiseBuffer(ctx: OfflineAudioContext, seconds: number): AudioBuffer {
+  const n = Math.ceil(seconds * ctx.sampleRate)
+  const buffer = ctx.createBuffer(1, n, ctx.sampleRate)
+  const data = buffer.getChannelData(0)
+  for (let i = 0; i < n; i++) data[i] = Math.random() * 2 - 1
+  return buffer
+}
+
+function noiseSource(ctx: OfflineAudioContext, seconds: number): AudioBufferSourceNode {
+  const source = ctx.createBufferSource()
+  source.buffer = whiteNoiseBuffer(ctx, seconds)
+  return source
+}
+
+type Builder = (ctx: OfflineAudioContext, master: GainNode) => void
+
+async function render(Offline: OfflineCtor, sampleRate: number, seconds: number, build: Builder): Promise<AudioBuffer> {
+  const ctx = new Offline(1, Math.ceil(seconds * sampleRate), sampleRate)
+  const master = ctx.createGain()
+  master.connect(ctx.destination)
+  build(ctx, master)
+  return ctx.startRendering()
+}
+
+/** Short scope blip — track updates, intercepts, PD kills */
+function buildUiBlip(ctx: OfflineAudioContext, master: GainNode): void {
+  const osc = ctx.createOscillator()
+  osc.type = 'triangle'
+  osc.frequency.value = 1240
+  const gain = ctx.createGain()
+  gain.gain.setValueAtTime(0, 0)
+  gain.gain.linearRampToValueAtTime(0.5, 0.005)
+  gain.gain.exponentialRampToValueAtTime(0.001, 0.08)
+  osc.connect(gain)
+  gain.connect(master)
+  osc.start(0)
+  osc.stop(0.09)
+}
+
+/** Two falling buzzer notes — denied / source lost */
+function buildUiError(ctx: OfflineAudioContext, master: GainNode): void {
+  const lp = ctx.createBiquadFilter()
+  lp.type = 'lowpass'
+  lp.frequency.value = 1200
+  lp.connect(master)
+  const note = (freq: number, start: number, dur: number) => {
+    const osc = ctx.createOscillator()
+    osc.type = 'square'
+    osc.frequency.value = freq
+    const gain = ctx.createGain()
+    gain.gain.setValueAtTime(0, start)
+    gain.gain.linearRampToValueAtTime(0.3, start + 0.008)
+    gain.gain.setValueAtTime(0.3, start + dur - 0.02)
+    gain.gain.exponentialRampToValueAtTime(0.001, start + dur)
+    osc.connect(gain)
+    gain.connect(lp)
+    osc.start(start)
+    osc.stop(start + dur)
+  }
+  note(440, 0, 0.1)
+  note(294, 0.11, 0.13)
+}
+
+/** Two-tone alternating klaxon — war declared, own unit lost */
+function buildKlaxon(ctx: OfflineAudioContext, master: GainNode): void {
+  const osc = ctx.createOscillator()
+  osc.type = 'sawtooth'
+  const lp = ctx.createBiquadFilter()
+  lp.type = 'lowpass'
+  lp.frequency.value = 1500
+  const gain = ctx.createGain()
+  for (let i = 0; i < 6; i++) {
+    osc.frequency.setValueAtTime(i % 2 === 0 ? 620 : 466, i * 0.3)
+  }
+  gain.gain.setValueAtTime(0, 0)
+  gain.gain.linearRampToValueAtTime(0.4, 0.015)
+  gain.gain.setValueAtTime(0.4, 1.5)
+  gain.gain.exponentialRampToValueAtTime(0.001, 1.78)
+  osc.connect(lp)
+  lp.connect(gain)
+  gain.connect(master)
+  osc.start(0)
+  osc.stop(1.8)
+}
+
+/** Sine ping with long decay and one faint echo — satellite pass complete */
+function buildSonarPing(ctx: OfflineAudioContext, master: GainNode): void {
+  const ping = (start: number, level: number) => {
+    const osc = ctx.createOscillator()
+    osc.type = 'sine'
+    osc.frequency.setValueAtTime(1050, start)
+    osc.frequency.exponentialRampToValueAtTime(980, start + 0.9)
+    const gain = ctx.createGain()
+    gain.gain.setValueAtTime(0, start)
+    gain.gain.linearRampToValueAtTime(level, start + 0.006)
+    gain.gain.exponentialRampToValueAtTime(0.0005, start + 1.0)
+    osc.connect(gain)
+    gain.connect(master)
+    osc.start(start)
+    osc.stop(start + 1.0)
+  }
+  ping(0, 0.55)
+  ping(0.35, 0.16)
+}
+
+/** Bandpassed static burst ending in a click — comms traffic */
+function buildRadioSquelch(ctx: OfflineAudioContext, master: GainNode): void {
+  const bp = ctx.createBiquadFilter()
+  bp.type = 'bandpass'
+  bp.frequency.value = 1800
+  bp.Q.value = 0.8
+  bp.connect(master)
+  const burst = (start: number, dur: number, level: number) => {
+    const src = noiseSource(ctx, dur)
+    const gain = ctx.createGain()
+    gain.gain.setValueAtTime(0, start)
+    gain.gain.linearRampToValueAtTime(level, start + 0.01)
+    gain.gain.setValueAtTime(level, start + dur - 0.015)
+    gain.gain.linearRampToValueAtTime(0, start + dur)
+    src.connect(gain)
+    gain.connect(bp)
+    src.start(start)
+    src.stop(start + dur)
+  }
+  burst(0, 0.18, 0.4)
+  burst(0.22, 0.06, 0.25)
+}
+
+/** Filtered-noise sweep with a sub-bass rumble — missile away */
+function buildLaunchWhoosh(ctx: OfflineAudioContext, master: GainNode): void {
+  const src = noiseSource(ctx, 1.6)
+  const lp = ctx.createBiquadFilter()
+  lp.type = 'lowpass'
+  lp.frequency.setValueAtTime(150, 0)
+  lp.frequency.exponentialRampToValueAtTime(2800, 0.5)
+  lp.frequency.exponentialRampToValueAtTime(500, 1.55)
+  const gain = ctx.createGain()
+  gain.gain.setValueAtTime(0, 0)
+  gain.gain.linearRampToValueAtTime(0.5, 0.4)
+  gain.gain.exponentialRampToValueAtTime(0.002, 1.55)
+  src.connect(lp)
+  lp.connect(gain)
+  gain.connect(master)
+  src.start(0)
+  src.stop(1.6)
+
+  const sub = ctx.createOscillator()
+  sub.type = 'sawtooth'
+  sub.frequency.setValueAtTime(60, 0)
+  sub.frequency.exponentialRampToValueAtTime(28, 1.4)
+  const subGain = ctx.createGain()
+  subGain.gain.setValueAtTime(0, 0)
+  subGain.gain.linearRampToValueAtTime(0.15, 0.3)
+  subGain.gain.exponentialRampToValueAtTime(0.001, 1.5)
+  sub.connect(subGain)
+  subGain.connect(master)
+  sub.start(0)
+  sub.stop(1.6)
+}
+
+/** Muffled low thud — impacts and unit losses heard from the CIC, not the front line */
+function buildDistantImpact(ctx: OfflineAudioContext, master: GainNode): void {
+  const thump = ctx.createOscillator()
+  thump.type = 'sine'
+  thump.frequency.setValueAtTime(90, 0)
+  thump.frequency.exponentialRampToValueAtTime(38, 0.5)
+  const thumpGain = ctx.createGain()
+  thumpGain.gain.setValueAtTime(0, 0)
+  thumpGain.gain.linearRampToValueAtTime(0.7, 0.012)
+  thumpGain.gain.exponentialRampToValueAtTime(0.001, 1.0)
+  thump.connect(thumpGain)
+  thumpGain.connect(master)
+  thump.start(0)
+  thump.stop(1.05)
+
+  const debris = noiseSource(ctx, 0.35)
+  const lp = ctx.createBiquadFilter()
+  lp.type = 'lowpass'
+  lp.frequency.value = 400
+  const debrisGain = ctx.createGain()
+  debrisGain.gain.setValueAtTime(0, 0)
+  debrisGain.gain.linearRampToValueAtTime(0.35, 0.01)
+  debrisGain.gain.exponentialRampToValueAtTime(0.001, 0.32)
+  debris.connect(lp)
+  lp.connect(debrisGain)
+  debrisGain.connect(master)
+  debris.start(0)
+  debris.stop(0.35)
+}
+
+const AMBIENT_LOOP_S = 8
+const AMBIENT_FADE_S = 0.4
+
+/** Very quiet CIC room tone: mains hum + air handling, rendered loop-seamless */
+async function renderAmbient(Offline: OfflineCtor, sampleRate: number): Promise<AudioBuffer> {
+  const totalS = AMBIENT_LOOP_S + AMBIENT_FADE_S
+  const ctx = new Offline(1, Math.ceil(totalS * sampleRate), sampleRate)
+  const master = ctx.createGain()
+  master.connect(ctx.destination)
+
+  const hum = (freq: number, level: number) => {
+    const osc = ctx.createOscillator()
+    osc.type = 'sine'
+    osc.frequency.value = freq
+    const gain = ctx.createGain()
+    gain.gain.value = level
+    osc.connect(gain)
+    gain.connect(master)
+    osc.start(0)
+    osc.stop(totalS)
+  }
+  hum(60, 0.05)
+  hum(120, 0.028)
+
+  const air = noiseSource(ctx, totalS)
+  const lp = ctx.createBiquadFilter()
+  lp.type = 'lowpass'
+  lp.frequency.value = 450
+  const airGain = ctx.createGain()
+  airGain.gain.value = 0.06
+  air.connect(lp)
+  lp.connect(airGain)
+  airGain.connect(master)
+  air.start(0)
+  air.stop(totalS)
+
+  const rendered = await ctx.startRendering()
+
+  // Crossfade the extra tail into the head, then trim — plain loop=true plays seamlessly
+  const loopN = Math.floor(AMBIENT_LOOP_S * sampleRate)
+  const fadeN = Math.floor(AMBIENT_FADE_S * sampleRate)
+  const src = rendered.getChannelData(0)
+  const out = ctx.createBuffer(1, loopN, sampleRate)
+  const dst = out.getChannelData(0)
+  dst.set(src.subarray(0, loopN))
+  for (let i = 0; i < fadeN; i++) {
+    const w = i / fadeN
+    dst[i] = dst[i] * w + src[loopN + i] * (1 - w)
+  }
+  return out
+}
+
+export async function synthesizeKit(sampleRate?: number): Promise<SoundKit> {
+  const Offline = getOfflineCtor()
+  if (!Offline) return {}
+  const sr = sampleRate !== undefined && Number.isFinite(sampleRate) && sampleRate >= 8000
+    ? sampleRate
+    : DEFAULT_SAMPLE_RATE
+
+  try {
+    const [klaxon, sonarPing, radioSquelch, launchWhoosh, distantImpact, uiBlip, uiError, ambientCic]
+      = await Promise.all([
+        render(Offline, sr, 1.8, buildKlaxon),
+        render(Offline, sr, 1.4, buildSonarPing),
+        render(Offline, sr, 0.32, buildRadioSquelch),
+        render(Offline, sr, 1.6, buildLaunchWhoosh),
+        render(Offline, sr, 1.1, buildDistantImpact),
+        render(Offline, sr, 0.09, buildUiBlip),
+        render(Offline, sr, 0.26, buildUiError),
+        renderAmbient(Offline, sr),
+      ])
+    return {
+      'klaxon': klaxon,
+      'sonar-ping': sonarPing,
+      'radio-squelch': radioSquelch,
+      'launch-whoosh': launchWhoosh,
+      'distant-impact': distantImpact,
+      'ui-blip': uiBlip,
+      'ui-error': uiError,
+      'ambient-cic': ambientCic,
+    }
+  } catch {
+    return {}
+  }
+}
diff --git a/src/audio/useSoundEffects.ts b/src/audio/useSoundEffects.ts
new file mode 100644
index 0000000..afa4737
--- /dev/null
+++ b/src/audio/useSoundEffects.ts
@@ -0,0 +1,41 @@
+import { useEffect, useRef } from 'react'
+import { useGameStore } from '@/store/game-store'
+import { useMenuStore } from '@/store/menu-store'
+import { audioManager } from './audio-manager'
+import { soundForEvent } from './event-sounds'
+import type { GameEvent } from '@/types/game'
+
+export function useSoundEffects(): void {
+  useEffect(() => {
+    audioManager.attachGestureListeners(window)
+    return () => audioManager.detachGestureListeners()
+  }, [])
+
+  const events = useGameStore((s) => s.viewState.events)
+  // Events are one-shot batches from the worker — reference-guarded like
+  // AlertFeed so StrictMode/unrelated re-renders don't replay a batch
+  const lastBatchRef = useRef<GameEvent[] | null>(null)
+  useEffect(() => {
+    if (events.length === 0 || lastBatchRef.current === events) return
+    lastBatchRef.current = events
+
+    const { viewState } = useGameStore.getState()
+    for (const e of events) {
+      const name = soundForEvent(e)
+      if (name) audioManager.play(name)
+      if (e.type === 'UNIT_DESTROYED'
+        && viewState.units.find((u) => u.id === e.unitId)?.nation === viewState.playerNation) {
+        audioManager.play('klaxon')
+      }
+    }
+  }, [events])
+
+  const screen = useMenuStore((s) => s.screen)
+  const initialized = useGameStore((s) => s.viewState.initialized)
+  useEffect(() => {
+    if (screen === 'playing' && initialized) audioManager.startAmbient()
+    else audioManager.stopAmbient()
+  }, [screen, initialized])
+
+  useEffect(() => () => audioManager.stopAmbient(), [])
+}
diff --git a/src/components/common/Panel.tsx b/src/components/common/Panel.tsx
index c1b9776..066659b 100644
--- a/src/components/common/Panel.tsx
+++ b/src/components/common/Panel.tsx
@@ -1,5 +1,10 @@
-import { useRef, useState, useCallback, type CSSProperties, type ReactNode, type PointerEvent } from 'react'
+import { useRef, useState, useEffect, useCallback, type CSSProperties, type ReactNode, type PointerEvent as ReactPointerEvent } from 'react'
 import { useIsMobile } from '@/hooks/useIsMobile'
+import { useUIStore } from '@/store/ui-store'
+
+const Z_BASE = 20
+/** Min px of the title bar that must remain inside the viewport after a drag */
+const EDGE_MARGIN = 40
 
 interface PanelProps {
   title: string
@@ -19,42 +24,81 @@ function stripPosition(s: CSSProperties | undefined): CSSProperties {
 export default function Panel({ title, children, style, onClose, defaultMinimized = false }: PanelProps) {
   const isMobile = useIsMobile()
   const panelRef = useRef<HTMLDivElement>(null)
-  const [offset, setOffset] = useState<{ x: number; y: number } | null>(null)
   const [minimized, setMinimized] = useState(defaultMinimized)
-  const dragState = useRef<{ startX: number; startY: number; origLeft: number; origTop: number } | null>(null)
+  const [dragging, setDragging] = useState(false)
+
+  const offset = useUIStore((s) => s.panelOffsets[title])
+  const focusPanel = useUIStore((s) => s.focusPanel)
+  const zIndex = useUIStore((s) => {
+    const reg = s.panelRegistry[title]
+    if (!reg) return Z_BASE
+    let below = 0
+    for (const other of Object.values(s.panelRegistry)) {
+      if (other.lastFocus < reg.lastFocus) below++
+    }
+    return Z_BASE + below
+  })
+
+  // Live ref so consumer re-renders can swap onClose without re-registering (which would reset focus order)
+  const onCloseRef = useRef(onClose)
+  useEffect(() => {
+    onCloseRef.current = onClose
+  }, [onClose])
+
+  useEffect(() => {
+    useUIStore.getState().registerPanel(title, onCloseRef)
+    return () => useUIStore.getState().unregisterPanel(title)
+  }, [title])
+
+  // Detach window drag listeners if unmounted mid-drag
+  const dragCleanupRef = useRef<(() => void) | null>(null)
+  useEffect(() => () => dragCleanupRef.current?.(), [])
 
-  const onPointerDown = useCallback((e: PointerEvent<HTMLDivElement>) => {
-    if (isMobile) return // no drag on mobile
+  const onTitlePointerDown = useCallback((e: ReactPointerEvent<HTMLDivElement>) => {
+    if (isMobile || e.button !== 0) return
+    if ((e.target as HTMLElement).closest('button, a')) return
     const panel = panelRef.current
     if (!panel) return
     e.preventDefault()
-    ;(e.target as HTMLElement).setPointerCapture(e.pointerId)
 
-    const rect = panel.getBoundingClientRect()
-    dragState.current = {
-      startX: e.clientX,
-      startY: e.clientY,
-      origLeft: rect.left,
-      origTop: rect.top,
-    }
-  }, [isMobile])
-
-  const onPointerMove = useCallback((e: PointerEvent<HTMLDivElement>) => {
-    if (!dragState.current) return
-    const dx = e.clientX - dragState.current.startX
-    const dy = e.clientY - dragState.current.startY
-    setOffset({
-      x: dragState.current.origLeft + dx,
-      y: dragState.current.origTop + dy,
-    })
-  }, [])
+    const start = useUIStore.getState().panelOffsets[title] ?? { dx: 0, dy: 0 }
+    const startX = e.clientX
+    const startY = e.clientY
+    setDragging(true)
 
-  const onPointerUp = useCallback(() => {
-    dragState.current = null
-  }, [])
+    const onMove = (ev: PointerEvent) => {
+      useUIStore.getState().setPanelOffset(title, {
+        dx: start.dx + ev.clientX - startX,
+        dy: start.dy + ev.clientY - startY,
+      })
+    }
+    const cleanup = () => {
+      window.removeEventListener('pointermove', onMove)
+      window.removeEventListener('pointerup', onUp)
+      dragCleanupRef.current = null
+      setDragging(false)
+    }
+    const onUp = () => {
+      cleanup()
+      const rect = panel.getBoundingClientRect()
+      const cur = useUIStore.getState().panelOffsets[title] ?? { dx: 0, dy: 0 }
+      let { dx, dy } = cur
+      if (rect.left > window.innerWidth - EDGE_MARGIN) dx -= rect.left - (window.innerWidth - EDGE_MARGIN)
+      if (rect.right < EDGE_MARGIN) dx += EDGE_MARGIN - rect.right
+      if (rect.top < 0) dy -= rect.top
+      if (rect.top > window.innerHeight - EDGE_MARGIN) dy -= rect.top - (window.innerHeight - EDGE_MARGIN)
+      if (dx !== cur.dx || dy !== cur.dy) useUIStore.getState().setPanelOffset(title, { dx, dy })
+    }
+    dragCleanupRef.current = cleanup
+    window.addEventListener('pointermove', onMove)
+    window.addEventListener('pointerup', onUp)
+  }, [isMobile, title])
 
-  const positionStyle: CSSProperties = (!isMobile && offset)
-    ? { position: 'fixed', left: offset.x, top: offset.y, right: 'auto', bottom: 'auto' }
+  const dx = offset?.dx ?? 0
+  const dy = offset?.dy ?? 0
+  // Drag offset rides on top of the consumer's own transform (e.g. translateX(-50%) centering)
+  const dragStyle: CSSProperties = (!isMobile && (dx !== 0 || dy !== 0))
+    ? { transform: `${typeof style?.transform === 'string' ? `${style.transform} ` : ''}translate(${dx}px, ${dy}px)` }
     : {}
 
   const mobileStyle: CSSProperties = isMobile ? {
@@ -75,6 +119,7 @@ export default function Panel({ title, children, style, onClose, defaultMinimize
   return (
     <div
       ref={panelRef}
+      onPointerDownCapture={() => focusPanel(title)}
       style={{
         background: 'var(--bg-panel)',
         border: '1px solid var(--border-default)',
@@ -86,15 +131,13 @@ export default function Panel({ title, children, style, onClose, defaultMinimize
         minWidth: minimized ? 120 : 260,
         maxHeight: minimized ? 'auto' : '80vh',
         overflowY: minimized ? 'hidden' : 'auto',
-        zIndex: 10,
+        zIndex,
         ...(isMobile ? stripPosition(style) : style),
-        ...(isMobile ? mobileStyle : positionStyle),
+        ...(isMobile ? mobileStyle : dragStyle),
       }}
     >
       <div
-        onPointerDown={onPointerDown}
-        onPointerMove={onPointerMove}
-        onPointerUp={onPointerUp}
+        onPointerDown={onTitlePointerDown}
         style={{
           display: 'flex',
           justifyContent: 'space-between',
@@ -102,7 +145,7 @@ export default function Panel({ title, children, style, onClose, defaultMinimize
           marginBottom: minimized ? 0 : 8,
           paddingBottom: minimized ? 0 : 6,
           borderBottom: minimized ? 'none' : '1px solid var(--border-default)',
-          cursor: isMobile ? 'default' : 'grab',
+          cursor: isMobile ? 'default' : dragging ? 'grabbing' : 'grab',
           userSelect: 'none',
           gap: 8,
         }}
diff --git a/src/components/common/__tests__/Panel.test.tsx b/src/components/common/__tests__/Panel.test.tsx
new file mode 100644
index 0000000..bf3aef6
--- /dev/null
+++ b/src/components/common/__tests__/Panel.test.tsx
@@ -0,0 +1,153 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { render, screen, fireEvent } from '@testing-library/react'
+import Panel from '../Panel'
+import { useUIStore } from '@/store/ui-store'
+
+const ABS = { position: 'absolute', top: 44, left: 12 } as const
+
+// jsdom rects are all zeros, which the drag-end clamp would misread as off-screen
+function stubRect(el: HTMLElement, rect: Partial<DOMRect> = {}) {
+  el.getBoundingClientRect = () => ({
+    x: 100, y: 100, top: 100, left: 100, right: 400, bottom: 300, width: 300, height: 200,
+    toJSON: () => ({}),
+    ...rect,
+  }) as DOMRect
+}
+
+function titleBar(title: string): HTMLElement {
+  return screen.getByText(title).parentElement!
+}
+
+function panelEl(title: string): HTMLElement {
+  return titleBar(title).parentElement!
+}
+
+beforeEach(() => {
+  useUIStore.setState({ panelOffsets: {}, panelRegistry: {}, panelFocusCounter: 0 })
+})
+
+describe('Panel dragging', () => {
+  it('drags via the title bar, applies a translate, and persists the offset across remount', () => {
+    const first = render(<Panel title="TEST PANEL" style={ABS}>body</Panel>)
+    stubRect(first.container.firstChild as HTMLElement)
+
+    expect(titleBar('TEST PANEL').style.cursor).toBe('grab')
+    fireEvent.pointerDown(titleBar('TEST PANEL'), { clientX: 200, clientY: 100 })
+    expect(titleBar('TEST PANEL').style.cursor).toBe('grabbing')
+
+    fireEvent.pointerMove(window, { clientX: 250, clientY: 130 })
+    expect((first.container.firstChild as HTMLElement).style.transform).toBe('translate(50px, 30px)')
+
+    fireEvent.pointerUp(window, { clientX: 250, clientY: 130 })
+    expect(titleBar('TEST PANEL').style.cursor).toBe('grab')
+    expect(useUIStore.getState().panelOffsets['TEST PANEL']).toEqual({ dx: 50, dy: 30 })
+
+    first.unmount()
+    const second = render(<Panel title="TEST PANEL" style={ABS}>body</Panel>)
+    expect((second.container.firstChild as HTMLElement).style.transform).toBe('translate(50px, 30px)')
+  })
+
+  it('composes the drag translate with the consumer transform', () => {
+    const { container } = render(
+      <Panel title="CENTERED" style={{ position: 'absolute', top: 50, left: '50%', transform: 'translateX(-50%)' }}>body</Panel>,
+    )
+    stubRect(container.firstChild as HTMLElement)
+
+    fireEvent.pointerDown(titleBar('CENTERED'), { clientX: 0, clientY: 0 })
+    fireEvent.pointerMove(window, { clientX: 10, clientY: 5 })
+    fireEvent.pointerUp(window)
+
+    expect((container.firstChild as HTMLElement).style.transform).toBe('translateX(-50%) translate(10px, 5px)')
+  })
+
+  it('ignores drags starting on title-bar buttons', () => {
+    const onClose = vi.fn()
+    render(<Panel title="BTN PANEL" style={ABS} onClose={onClose}>body</Panel>)
+
+    fireEvent.pointerDown(screen.getByText('x'), { clientX: 0, clientY: 0 })
+    fireEvent.pointerMove(window, { clientX: 80, clientY: 80 })
+    fireEvent.pointerUp(window)
+
+    expect(useUIStore.getState().panelOffsets['BTN PANEL']).toBeUndefined()
+  })
+
+  it('clamps the offset on drag end so the title bar stays reachable', () => {
+    const { container } = render(<Panel title="CLAMP" style={ABS}>body</Panel>)
+    const el = container.firstChild as HTMLElement
+
+    fireEvent.pointerDown(titleBar('CLAMP'), { clientX: 0, clientY: 0 })
+    fireEvent.pointerMove(window, { clientX: 1100, clientY: 0 })
+    // panel now hangs past the right viewport edge (jsdom viewport is 1024px wide)
+    stubRect(el, { left: 1100, right: 1400 })
+    fireEvent.pointerUp(window)
+
+    expect(useUIStore.getState().panelOffsets['CLAMP']).toEqual({ dx: 1024 - 40, dy: 0 })
+  })
+})
+
+describe('Panel z-order', () => {
+  it('raises the clicked panel above siblings', () => {
+    render(
+      <>
+        <Panel title="ALPHA" style={ABS}>alpha body</Panel>
+        <Panel title="BRAVO" style={ABS}>bravo body</Panel>
+      </>,
+    )
+    const z = (t: string) => Number(panelEl(t).style.zIndex)
+
+    // last mounted starts on top
+    expect(z('BRAVO')).toBeGreaterThan(z('ALPHA'))
+
+    fireEvent.pointerDown(screen.getByText('alpha body'))
+    expect(z('ALPHA')).toBeGreaterThan(z('BRAVO'))
+
+    fireEvent.pointerDown(screen.getByText('bravo body'))
+    expect(z('BRAVO')).toBeGreaterThan(z('ALPHA'))
+  })
+})
+
+describe('Escape close ordering (closeTopPanel)', () => {
+  it('closes only the topmost panel with an onClose', () => {
+    const closeA = vi.fn()
+    const closeB = vi.fn()
+    render(
+      <>
+        <Panel title="ALPHA" style={ABS} onClose={closeA}>alpha body</Panel>
+        <Panel title="BRAVO" style={ABS} onClose={closeB}>bravo body</Panel>
+      </>,
+    )
+    fireEvent.pointerDown(screen.getByText('alpha body'))
+
+    expect(useUIStore.getState().closeTopPanel()).toBe(true)
+    expect(closeA).toHaveBeenCalledTimes(1)
+    expect(closeB).not.toHaveBeenCalled()
+  })
+
+  it('skips panels without an onClose', () => {
+    const closeB = vi.fn()
+    render(
+      <>
+        <Panel title="PLAIN" style={ABS}>plain body</Panel>
+        <Panel title="BRAVO" style={ABS} onClose={closeB}>bravo body</Panel>
+      </>,
+    )
+    fireEvent.pointerDown(screen.getByText('plain body'))
+
+    expect(useUIStore.getState().closeTopPanel()).toBe(true)
+    expect(closeB).toHaveBeenCalledTimes(1)
+  })
+
+  it('returns false when no closable panel is registered', () => {
+    render(<Panel title="PLAIN" style={ABS}>plain body</Panel>)
+    expect(useUIStore.getState().closeTopPanel()).toBe(false)
+  })
+
+  it('unregisters on unmount so closed panels cannot be re-closed', () => {
+    const closeA = vi.fn()
+    const { unmount } = render(<Panel title="ALPHA" style={ABS} onClose={closeA}>alpha body</Panel>)
+    unmount()
+
+    expect(useUIStore.getState().closeTopPanel()).toBe(false)
+    expect(closeA).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/components/hud/AlertFeed.tsx b/src/components/hud/AlertFeed.tsx
index b4a67ce..5a39f0c 100644
--- a/src/components/hud/AlertFeed.tsx
+++ b/src/components/hud/AlertFeed.tsx
@@ -436,6 +436,29 @@ function eventColor(e: GameEvent): string {
     case 'CEASEFIRE_OFFERED': return 'var(--status-ready)'
     case 'CEASEFIRE_REJECTED': return 'var(--text-muted)'
     case 'WAR_ENDED': return 'var(--status-ready)'
+    case 'AIR_MISSION_LAUNCHED': return 'var(--status-moving)'
+    case 'FLIGHT_ON_STATION': return 'var(--status-ready)'
+    case 'FLIGHT_RTB': return 'var(--text-secondary)'
+    case 'FLIGHT_LOST': return 'var(--status-damaged)'
+    case 'AIR_INTERCEPT': return 'var(--status-engaged)'
+    case 'AUTO_ENGAGEMENT': return 'var(--status-engaged)'
+    case 'MISSILE_MISSED': return 'var(--text-muted)'
+    case 'MISSILE_CRASHED': return 'var(--text-muted)'
+    case 'ORDER_REJECTED': return 'var(--text-muted)'
+    case 'SATELLITE_PASS_COMPLETE': return 'var(--status-ready)'
+    case 'SATELLITE_PASS_FAILED': return 'var(--text-muted)'
+    case 'INTERCEPT_DECRYPTED':
+      return e.precedence === 'FLASH' ? '#ff4444'
+        : e.precedence === 'IMMEDIATE' ? 'var(--status-engaged)'
+          : 'var(--text-secondary)'
+    case 'AGENT_REPORT': return 'var(--status-ready)'
+    case 'AGENT_ARRESTED': return 'var(--status-damaged)'
+    case 'AGENT_EXFILTRATED': return 'var(--status-moving)'
+    case 'SPY_SWEEP': return 'var(--status-engaged)'
+    case 'ENCRYPTION_UPGRADED': return 'var(--status-engaged)'
+    case 'DECOY_REVEALED': return 'var(--status-moving)'
+    case 'STRIKE_LEAKED': return 'var(--status-damaged)'
+    case 'OPSEC_SWEEP_COMPLETE': return 'var(--status-ready)'
     default: return 'var(--text-secondary)'
   }
 }
@@ -448,12 +471,24 @@ function weaponName(id: string): string {
   return weaponSpecs[id]?.name ?? id
 }
 
+const NAME_PARTICLES = new Set(['of', 'the', 'el', 'al'])
+
+// 'bab_el_mandeb' → 'Bab el-Mandeb', 'strait_of_hormuz' → 'Strait of Hormuz'
 function lineName(id: string): string {
-  return id.toUpperCase().replace(/_/g, ' ')
+  return id
+    .split('_')
+    .filter(Boolean)
+    .map((word, i) => {
+      const lower = word.toLowerCase()
+      if (i > 0 && NAME_PARTICLES.has(lower)) return lower
+      return lower.charAt(0).toUpperCase() + lower.slice(1)
+    })
+    .join(' ')
+    .replace(/ (el|al) /g, ' $1-')
 }
 
 function laneName(id: string, lanes: Map<string, string>): string {
-  return (lanes.get(id) ?? lineName(id)).toUpperCase()
+  return lanes.get(id) ?? lineName(id)
 }
 
 function eventPosition(
@@ -475,6 +510,21 @@ function eventPosition(
     case 'UNIT_REPAIRED':
     case 'POINT_DEFENSE_KILL':
     case 'RESUPPLIED':
+    case 'ORDER_REJECTED':
+      return unitPositions.get(e.unitId) ?? null
+    case 'AUTO_ENGAGEMENT':
+      return unitPositions.get(e.targetId) ?? unitPositions.get(e.unitId) ?? null
+    case 'MISSILE_MISSED':
+    case 'STRIKE_LEAKED':
+      return unitPositions.get(e.targetId) ?? null
+    case 'SATELLITE_PASS_COMPLETE':
+    case 'SATELLITE_PASS_FAILED':
+      return e.target
+    case 'MISSILE_CRASHED':
+      return e.position ?? null
+    case 'INTERCEPT_DECRYPTED':
+      return e.aboutUnitId ? (unitPositions.get(e.aboutUnitId) ?? null) : null
+    case 'DECOY_REVEALED':
       return unitPositions.get(e.unitId) ?? null
     case 'SUPPLY_LINE_INTERDICTED':
       return unitPositions.get(e.threatUnitId) ?? null
@@ -525,6 +575,46 @@ function formatEvent(e: GameEvent, names: Map<string, string>, lanes: Map<string
       return e.outcome === 'capitulation'
         ? `T+${e.tick} WAR ENDED: ${(e.loser ?? '').toUpperCase()} CAPITULATED`
         : `T+${e.tick} WAR ENDED: CEASEFIRE`
+    case 'AIR_MISSION_LAUNCHED':
+      return `T+${e.tick} ${e.kind.toUpperCase()} AIRBORNE: ${e.flightName}`
+    case 'FLIGHT_ON_STATION':
+      return `T+${e.tick} ON STATION: ${e.flightName}`
+    case 'FLIGHT_RTB':
+      return `T+${e.tick} RTB: ${e.flightName} (${e.reason})`
+    case 'FLIGHT_LOST':
+      return `T+${e.tick} FLIGHT LOST: ${e.flightName} — ${e.airframesLost} airframe(s), pilot ${e.pilotFate.toUpperCase()}`
+    case 'AIR_INTERCEPT':
+      return `T+${e.tick} AIR ENGAGEMENT: ${e.attackerName} vs ${e.defenderName}${e.kills > 0 ? ` — ${e.kills} kill(s)` : ' — no kill'}`
+    case 'AUTO_ENGAGEMENT':
+      return `T+${e.tick} ENGAGING ${unitName(e.targetId, names)}: ${e.weaponName} x${e.count}${e.quality === 'datalink' ? ' [LINK]' : ''}`
+    case 'MISSILE_MISSED':
+      return `T+${e.tick} MISS: ${unitName(e.targetId, names)} evaded (stale track)`
+    case 'MISSILE_CRASHED':
+      return `T+${e.tick} MISSILE DOWN: fuel exhausted en route`
+    case 'ORDER_REJECTED':
+      return `T+${e.tick} ORDER REJECTED: ${unitName(e.unitId, names)} — ${e.reason}`
+    case 'SATELLITE_PASS_COMPLETE':
+      return `T+${e.tick} IMINT: pass complete — ${e.found} object(s) imaged${e.revealedDecoys > 0 ? `, ${e.revealedDecoys} DECOY` : ''}`
+    case 'SATELLITE_PASS_FAILED':
+      return `T+${e.tick} IMINT: pass failed — cloud cover ${e.cloudPct}%`
+    case 'INTERCEPT_DECRYPTED':
+      return `T+${e.tick} ${e.precedence} SIGINT: ${e.text}`
+    case 'AGENT_REPORT':
+      return `T+${e.tick} HUMINT ${e.codename}: ${e.text}`
+    case 'AGENT_ARRESTED':
+      return `T+${e.tick} SOURCE LOST: ${e.codename} arrested by counterintelligence`
+    case 'AGENT_EXFILTRATED':
+      return `T+${e.tick} ${e.codename} exfiltrated safely`
+    case 'SPY_SWEEP':
+      return `T+${e.tick} IRANIAN SPY SWEEP${e.arrests > 0 ? ` — ${e.arrests} source(s) lost` : ' — network intact'}`
+    case 'ENCRYPTION_UPGRADED':
+      return `T+${e.tick} SIGINT BLACKOUT: enemy upgraded encryption`
+    case 'DECOY_REVEALED':
+      return `T+${e.tick} DECOY IDENTIFIED: ${unitName(e.unitId, names)} is a dummy`
+    case 'STRIKE_LEAKED':
+      return `T+${e.tick} STRIKE COMPROMISED: enemy had foreknowledge`
+    case 'OPSEC_SWEEP_COMPLETE':
+      return `T+${e.tick} OPSEC SWEEP COMPLETE: leak level ${e.newLeakLevel}%`
     default:
       return `T+${(e as GameEvent & { tick: number }).tick} ${(e as GameEvent & { type: string }).type}`
   }
diff --git a/src/components/hud/MapToggle.tsx b/src/components/hud/MapToggle.tsx
index 8f9a292..7d25507 100644
--- a/src/components/hud/MapToggle.tsx
+++ b/src/components/hud/MapToggle.tsx
@@ -1,5 +1,6 @@
 import { useState } from 'react'
 import { useUIStore } from '@/store/ui-store'
+import { useMapIntelStore } from '@/store/map-intel-store'
 import { useIsMobile } from '@/hooks/useIsMobile'
 import type { CSSProperties } from 'react'
 
@@ -74,6 +75,12 @@ export default function MapToggle() {
   const cycleMapMode = useUIStore(s => s.cycleMapMode)
   const toggleElevation = useUIStore(s => s.toggleElevation)
   const toggleIntelCoverage = useUIStore(s => s.toggleIntelCoverage)
+  const reconMosaic = useMapIntelStore(s => s.reconMosaic)
+  const adsbLive = useMapIntelStore(s => s.adsbLive)
+  const intelOverlays = useMapIntelStore(s => s.intelOverlays)
+  const toggleReconMosaic = useMapIntelStore(s => s.toggleReconMosaic)
+  const toggleAdsbLive = useMapIntelStore(s => s.toggleAdsbLive)
+  const toggleIntelOverlays = useMapIntelStore(s => s.toggleIntelOverlays)
 
   const [openSub, setOpenSub] = useState<OpenSub>(null)
 
@@ -98,7 +105,7 @@ export default function MapToggle() {
         <button onClick={cycleMapMode} style={{ ...btnFirst, ...(isSat ? active : {}) }} title="Toggle map style">
           {isSat ? 'SAT' : 'MAP'}
         </button>
-        <button onClick={toggleElevation} style={{ ...btn, ...(showElevation ? active : {}) }} title="Elevation overlay">
+        <button onClick={toggleElevation} style={{ ...btn, ...(showElevation ? active : {}) }} title="Terrain relief — hillshade + cursor elevation (on by default)">
           ELV
         </button>
         <button onClick={() => toggleSub('rng')} style={{ ...btn, ...(rngOn ? active : {}), ...(openSub === 'rng' ? { background: 'var(--bg-hover)' } : {}) }} title="Range circles">
@@ -110,6 +117,15 @@ export default function MapToggle() {
         <button onClick={() => toggleSub('int')} style={{ ...btn, ...(showIntelCoverage ? { ...active, color: '#ffaa33' } : {}), ...(openSub === 'int' ? { background: 'var(--bg-hover)' } : {}) }} title="Intel coverage">
           INT
         </button>
+        <button onClick={toggleReconMosaic} style={{ ...btn, ...(reconMosaic ? active : {}) }} title="Recon mosaic — yesterday's VIIRS satellite pass (NASA GIBS)">
+          RCN
+        </button>
+        <button onClick={toggleAdsbLive} style={{ ...btn, ...(adsbLive ? active : {}) }} title="ADS-B live — real air traffic (airplanes.live)">
+          ADS-B
+        </button>
+        <button onClick={toggleIntelOverlays} style={{ ...btn, ...(intelOverlays ? active : {}) }} title="Intel overlays — AOU rings, sensor rings, tasking swaths">
+          OVL
+        </button>
       </div>
 
       {/* Sub-menu panels */}
diff --git a/src/components/hud/TopBar.tsx b/src/components/hud/TopBar.tsx
index b2400da..8c5e6db 100644
--- a/src/components/hud/TopBar.tsx
+++ b/src/components/hud/TopBar.tsx
@@ -1,8 +1,9 @@
-import { useState, useCallback, useMemo } from 'react'
+import { useState, useCallback, useEffect, useMemo, useRef } from 'react'
 import { useUIStore } from '@/store/ui-store'
 import { useGameStore } from '@/store/game-store'
 import { useStrikeStore } from '@/store/strike-store'
 import { useIntelStore } from '@/store/intel-store'
+import { useMenuStore } from '@/store/menu-store'
 import { sendCommand, getFullState, loadState } from '@/store/bridge'
 import { saveToSlot, loadFromSlot } from '@/store/save-load'
 import { useIsMobile } from '@/hooks/useIsMobile'
@@ -32,15 +33,70 @@ const INLINE_LABELS: Record<number, string> = {
   360: '1h',
 }
 
-const ALL_SPEEDS = [0, 0.1, 1, 6, 60, 360, 3600] as const
-const ALL_SPEED_LABELS: Record<number, string> = {
-  0: '||',
-  0.1: '1s/s',
-  1: '10s/s',
-  6: '1m/s',
-  60: '10m/s',
-  360: '1h/s',
-  3600: '10h/s',
+// Time slider works in game-time multipliers (game-seconds per real second);
+// engine speed (ticks per 100ms) = multiplier / 10
+const SLIDER_MAX_MULT = 3600
+const SLIDER_STEPS = 1000
+const SNAP_PCT = 0.08
+const DETENTS: { mult: number; label: string }[] = [
+  { mult: 0, label: 'PAUSED' },
+  { mult: 1, label: '1×' },
+  { mult: 8, label: '8×' },
+  { mult: 60, label: '60×' },
+  { mult: 600, label: '10m/s' },
+  { mult: 3600, label: '1h/s' },
+]
+
+function multToPos(mult: number): number {
+  if (mult <= 0) return 0
+  return Math.max(1, Math.min(SLIDER_STEPS, Math.round(1 + ((SLIDER_STEPS - 1) * Math.log(mult)) / Math.log(SLIDER_MAX_MULT))))
+}
+
+function posToMult(pos: number): number {
+  if (pos <= 0) return 0
+  const raw = Math.pow(SLIDER_MAX_MULT, (pos - 1) / (SLIDER_STEPS - 1))
+  for (const d of DETENTS) {
+    if (d.mult > 0 && Math.abs(raw - d.mult) <= d.mult * SNAP_PCT) return d.mult
+  }
+  return Math.round(raw)
+}
+
+function multLabel(mult: number): string {
+  const detent = DETENTS.find((d) => Math.abs(d.mult - mult) < 0.001)
+  if (detent) return detent.label
+  return mult >= 1 ? `×${Math.round(mult)}` : `×${mult.toFixed(1)}`
+}
+
+const WAR_CONFIRM_MS = 5_000
+const EXIT_CONFIRM_MS = 4_000
+
+// Two-step confirm state with a wall-clock auto-disarm (UI-side only, never engine time)
+function useArmedCountdown(durationMs: number) {
+  const [remainingMs, setRemainingMs] = useState<number | null>(null)
+  const deadlineRef = useRef(0)
+  const armed = remainingMs !== null
+
+  useEffect(() => {
+    if (!armed) return
+    const id = setInterval(() => {
+      const left = deadlineRef.current - Date.now()
+      setRemainingMs(left > 0 ? left : null)
+    }, 100)
+    return () => clearInterval(id)
+  }, [armed])
+
+  const arm = useCallback(() => {
+    deadlineRef.current = Date.now() + durationMs
+    setRemainingMs(durationMs)
+  }, [durationMs])
+  const disarm = useCallback(() => setRemainingMs(null), [])
+
+  return {
+    armed,
+    secondsLeft: remainingMs === null ? 0 : Math.ceil(remainingMs / 1000),
+    arm,
+    disarm,
+  }
 }
 
 export default function TopBar() {
@@ -55,6 +111,8 @@ export default function TopBar() {
   const showEconomy = useUIStore((s) => s.showEconomy)
   const showIntel = useUIStore((s) => s.showIntel)
   const toggleIntel = useUIStore((s) => s.toggleIntel)
+  const liveFeedsOpen = useUIStore((s) => s.liveFeedsOpen)
+  const toggleLiveFeeds = useUIStore((s) => s.toggleLiveFeeds)
   const placingCatalogId = useIntelStore((s) => s.placingCatalogId)
 
   const units = useGameStore((s) => s.viewState.units)
@@ -76,10 +134,9 @@ export default function TopBar() {
   const hasUnits = units.length > 0
 
   const [showHelp, setShowHelp] = useState(false)
-  const [warClickPending, setWarClickPending] = useState(false)
+  const warConfirm = useArmedCountdown(WAR_CONFIRM_MS)
   const [offerClickPending, setOfferClickPending] = useState(false)
   const [roeOpen, setRoeOpen] = useState(false)
-  const [speedDropdownOpen, setSpeedDropdownOpen] = useState(false)
   const [overflowOpen, setOverflowOpen] = useState(false)
   const [objectivesOpen, setObjectivesOpen] = useState(false)
 
@@ -123,12 +180,12 @@ export default function TopBar() {
 
   const handleDeclareWar = () => {
     if (!primaryEnemyNation) return
-    if (!warClickPending) {
-      setWarClickPending(true)
+    if (!warConfirm.armed) {
+      warConfirm.arm()
       return
     }
+    warConfirm.disarm()
     sendCommand({ type: 'DECLARE_WAR', target: primaryEnemyNation.id })
-    setWarClickPending(false)
   }
 
   const handleOfferCeasefire = () => {
@@ -224,7 +281,7 @@ export default function TopBar() {
               }}>
                 WAR
               </span>
-            ) : !warClickPending ? (
+            ) : !warConfirm.armed ? (
               <button
                 onClick={handleDeclareWar}
                 style={{
@@ -245,7 +302,7 @@ export default function TopBar() {
             ) : (
               <button
                 onClick={handleDeclareWar}
-                onBlur={() => setWarClickPending(false)}
+                onBlur={warConfirm.disarm}
                 style={{
                   background: 'var(--status-damaged)',
                   border: '2px solid var(--status-damaged)',
@@ -259,7 +316,7 @@ export default function TopBar() {
                   whiteSpace: 'nowrap',
                 }}
               >
-                CONFIRM
+                {`CONFIRM ${warConfirm.secondsLeft}`}
               </button>
             )}
 
@@ -373,114 +430,7 @@ export default function TopBar() {
 
         <Sep />
 
-        {INLINE_SPEEDS.map((s) => (
-          <button
-            key={s}
-            onClick={() => sendCommand({ type: 'SET_SPEED', speed: s })}
-            style={{
-              background: time.speed === s ? 'var(--border-accent)' : 'none',
-              border: `1px solid ${time.speed === s ? 'var(--border-accent)' : 'transparent'}`,
-              borderRadius: 3,
-              color: time.speed === s ? 'var(--text-primary)' : 'var(--text-muted)',
-              cursor: 'pointer',
-              fontFamily: 'var(--font-mono)',
-              fontSize: 'var(--font-size-xs)',
-              padding: '2px 4px',
-              fontWeight: 600,
-              whiteSpace: 'nowrap',
-              opacity: time.speed === s ? 1 : 0.55,
-            }}
-          >
-            {INLINE_LABELS[s]}
-          </button>
-        ))}
-
-        {/* Speed chevron dropdown */}
-        <div style={{ position: 'relative' }}>
-          <button
-            onClick={() => setSpeedDropdownOpen(!speedDropdownOpen)}
-            style={{
-              background: 'none',
-              border: '1px solid transparent',
-              borderRadius: 3,
-              color: 'var(--text-muted)',
-              cursor: 'pointer',
-              fontFamily: 'var(--font-mono)',
-              fontSize: 'var(--font-size-xs)',
-              padding: '2px 3px',
-              fontWeight: 600,
-              opacity: 0.55,
-            }}
-          >
-            {'\u203A'}
-          </button>
-
-          {speedDropdownOpen && (
-            <div style={{
-              position: 'absolute',
-              top: '100%',
-              left: 0,
-              marginTop: 4,
-              background: 'var(--bg-panel)',
-              border: '1px solid var(--border-default)',
-              borderRadius: 'var(--panel-radius)',
-              padding: 4,
-              zIndex: 30,
-              display: 'flex',
-              flexDirection: 'column',
-              gap: 2,
-              minWidth: 80,
-            }}>
-
-              {/* Fine speed slider */}
-              <div style={{ padding: '4px 8px', display: 'flex', alignItems: 'center', gap: 4 }}>
-                <input
-                  type="range"
-                  min={0}
-                  max={100}
-                  value={time.speed <= 0 ? 0 : Math.round(1 + 99 * Math.log(time.speed / 0.1) / Math.log(36000))}
-                  onChange={(e) => {
-                    const val = Number(e.target.value)
-                    const speed = val === 0 ? 0 : 0.1 * Math.pow(36000, (val - 1) / 99)
-                    sendCommand({ type: 'SET_SPEED', speed })
-                  }}
-                  style={{ flex: 1, height: 4, cursor: 'pointer', accentColor: 'var(--text-accent)' }}
-                />
-                <span style={{ fontSize: '0.55rem', color: 'var(--text-secondary)', minWidth: 35, textAlign: 'right', fontFamily: 'var(--font-mono)' }}>
-                  {time.speed <= 0 ? '||' : time.speed < 6 ? `${Math.round(time.speed * 10)}s/s` : time.speed < 300 ? `${Math.round(time.speed / 6)}m/s` : `${(time.speed / 360).toFixed(1)}h/s`}
-                </span>
-              </div>
-              <div style={{ height: 1, background: 'var(--border-default)', margin: '2px 0' }} />
-
-              {ALL_SPEEDS.map((s) => (
-                <button
-                  key={s}
-                  onClick={() => {
-                    sendCommand({ type: 'SET_SPEED', speed: s })
-                    setSpeedDropdownOpen(false)
-                  }}
-                  style={{
-                    background: time.speed === s ? 'var(--border-accent)' : 'var(--bg-hover)',
-                    border: time.speed === s
-                      ? '1px solid var(--border-accent)'
-                      : '1px solid var(--border-default)',
-                    borderRadius: 3,
-                    color: time.speed === s ? 'var(--text-primary)' : 'var(--text-secondary)',
-                    cursor: 'pointer',
-                    fontFamily: 'var(--font-mono)',
-                    fontSize: 'var(--font-size-xs)',
-                    padding: '4px 8px',
-                    fontWeight: time.speed === s ? 700 : 400,
-                    textAlign: 'left',
-                    whiteSpace: 'nowrap',
-                  }}
-                >
-                  {ALL_SPEED_LABELS[s]}
-                </button>
-              ))}
-            </div>
-          )}
-        </div>
+        <TimeSlider speed={time.speed} />
 
         <Sep />
 
@@ -507,6 +457,12 @@ export default function TopBar() {
         {/* Intel panel toggle */}
         <IntelBtn active={showIntel || !!placingCatalogId} onClick={toggleIntel} compact={false} />
 
+        {/* Live feeds window toggle */}
+        <LiveBtn active={liveFeedsOpen} onClick={toggleLiveFeeds} />
+
+        {/* Sound mute toggle */}
+        <MuteBtn />
+
         <Sep />
 
         {/* Hormuz status badge */}
@@ -715,10 +671,10 @@ export default function TopBar() {
           {!atWarWithPrimaryEnemy && primaryEnemyNation && (
             <button
               onClick={handleDeclareWar}
-              onBlur={() => setWarClickPending(false)}
+              onBlur={warConfirm.disarm}
               style={{
-                background: warClickPending ? 'var(--status-damaged)' : 'var(--iran-secondary)',
-                border: warClickPending
+                background: warConfirm.armed ? 'var(--status-damaged)' : 'var(--iran-secondary)',
+                border: warConfirm.armed
                   ? '2px solid var(--status-damaged)'
                   : '1px solid var(--iran-primary)',
                 borderRadius: 3,
@@ -731,7 +687,7 @@ export default function TopBar() {
                 whiteSpace: 'nowrap',
               }}
             >
-              {warClickPending ? 'CONFIRM WAR' : 'DECLARE WAR'}
+              {warConfirm.armed ? `CONFIRM WAR ${warConfirm.secondsLeft}` : 'DECLARE WAR'}
             </button>
           )}
         </div>
@@ -794,6 +750,7 @@ export default function TopBar() {
                   {atWarWithPrimaryEnemy && (
                     <OverflowResign onDone={() => setOverflowOpen(false)} />
                   )}
+                  <OverflowMainMenu onDone={() => setOverflowOpen(false)} />
                 </div>
               )}
             </div>
@@ -802,9 +759,9 @@ export default function TopBar() {
       </div>
 
       {/* Close dropdowns on outside click */}
-      {(roeOpen || speedDropdownOpen || overflowOpen || objectivesOpen) && (
+      {(roeOpen || overflowOpen || objectivesOpen) && (
         <div
-          onClick={() => { setRoeOpen(false); setSpeedDropdownOpen(false); setOverflowOpen(false); setObjectivesOpen(false) }}
+          onClick={() => { setRoeOpen(false); setOverflowOpen(false); setObjectivesOpen(false) }}
           style={{
             position: 'fixed',
             inset: 0,
@@ -860,6 +817,8 @@ export default function TopBar() {
           <div style={{ color: 'var(--text-accent)', fontWeight: 600, marginBottom: 4, marginTop: 4, textTransform: 'uppercase' }}>
             Top Bar
           </div>
+          <HelpRow keys="TIME SLIDER" desc="Any speed; snaps to 1×/8×/60×/10m/1h" />
+          <HelpRow keys="LIVE" desc="Real-data live feeds window" />
           <HelpRow keys="ROE dropdown" desc="Theater-wide ROE" />
           <HelpRow keys="DECLARE WAR" desc="Initiate hostilities (click twice)" />
           <HelpRow keys="OFFER CEASEFIRE" desc="Propose ending the war (click twice)" />
@@ -1004,6 +963,51 @@ function OverflowResign({ onDone }: { onDone: () => void }) {
   )
 }
 
+// Same return-to-menu flow as DebriefScreen's MAIN MENU button
+function exitToMainMenu() {
+  useStrikeStore.getState().reset()
+  useIntelStore.getState().reset()
+  const ui = useUIStore.getState()
+  ui.clearSelection()
+  ui.setLeftPanel(null)
+  useUIStore.setState({ showIntel: false })
+  useMenuStore.getState().setScreen('start')
+}
+
+function OverflowMainMenu({ onDone }: { onDone: () => void }) {
+  const confirm = useArmedCountdown(EXIT_CONFIRM_MS)
+  return (
+    <button
+      onClick={() => {
+        if (!confirm.armed) {
+          confirm.arm()
+          return
+        }
+        confirm.disarm()
+        onDone()
+        exitToMainMenu()
+      }}
+      style={{
+        background: confirm.armed ? 'var(--status-engaged)' : 'var(--bg-hover)',
+        border: confirm.armed
+          ? '1px solid var(--status-engaged)'
+          : '1px solid var(--border-default)',
+        borderRadius: 3,
+        color: confirm.armed ? 'var(--bg-primary)' : 'var(--text-secondary)',
+        cursor: 'pointer',
+        fontFamily: 'var(--font-mono)',
+        fontSize: 'var(--font-size-xs)',
+        padding: '4px 8px',
+        fontWeight: confirm.armed ? 700 : 400,
+        textAlign: 'left',
+        whiteSpace: 'nowrap',
+      }}
+    >
+      {confirm.armed ? 'CONFIRM EXIT?' : 'MAIN MENU'}
+    </button>
+  )
+}
+
 function OverflowSaveLoad({ onDone }: { onDone: () => void }) {
   const [feedback, setFeedback] = useState<string | null>(null)
 
@@ -1079,6 +1083,164 @@ function IntelBtn({ active, onClick, compact }: { active: boolean; onClick: () =
   )
 }
 
+function TimeSlider({ speed }: { speed: number }) {
+  const [dragMult, setDragMult] = useState<number | null>(null)
+  const lastSentRef = useRef(0)
+  const pendingRef = useRef<number | null>(null)
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const lastNonzeroRef = useRef(0.1)
+
+  useEffect(() => {
+    if (speed > 0) lastNonzeroRef.current = speed
+  }, [speed])
+
+  useEffect(() => () => {
+    if (timerRef.current) clearTimeout(timerRef.current)
+  }, [])
+
+  // ~10 sends/s max while dragging; trailing send keeps the final position
+  const sendSpeed = useCallback((s: number) => {
+    const since = performance.now() - lastSentRef.current
+    if (since >= 100) {
+      lastSentRef.current = performance.now()
+      sendCommand({ type: 'SET_SPEED', speed: s })
+    } else {
+      pendingRef.current = s
+      if (!timerRef.current) {
+        timerRef.current = setTimeout(() => {
+          timerRef.current = null
+          lastSentRef.current = performance.now()
+          if (pendingRef.current !== null) {
+            sendCommand({ type: 'SET_SPEED', speed: pendingRef.current })
+            pendingRef.current = null
+          }
+        }, 100 - since)
+      }
+    }
+  }, [])
+
+  const mult = dragMult ?? speed * 10
+  const paused = mult <= 0
+
+  return (
+    <div style={{ display: 'flex', alignItems: 'center', gap: 5, padding: '0 2px' }}>
+      <button
+        onClick={() => sendCommand({ type: 'SET_SPEED', speed: speed === 0 ? lastNonzeroRef.current : 0 })}
+        title={paused ? 'Resume' : 'Pause'}
+        aria-label={paused ? 'Resume' : 'Pause'}
+        style={{
+          background: paused ? 'var(--bg-hover)' : 'none',
+          border: `1px solid ${paused ? 'var(--status-engaged)' : 'transparent'}`,
+          borderRadius: 3,
+          color: paused ? 'var(--status-engaged)' : 'var(--text-secondary)',
+          cursor: 'pointer',
+          fontFamily: 'var(--font-mono)',
+          fontSize: 'var(--font-size-xs)',
+          padding: '2px 5px',
+          fontWeight: 700,
+          lineHeight: 1.2,
+        }}
+      >
+        {paused ? '▶' : '||'}
+      </button>
+      <input
+        type="range"
+        min={0}
+        max={SLIDER_STEPS}
+        step={1}
+        value={multToPos(mult)}
+        aria-label="Game speed"
+        title="Game speed (snaps to 1× / 8× / 60× / 10m/s / 1h/s)"
+        onChange={(e) => {
+          const m = posToMult(Number(e.target.value))
+          setDragMult(m)
+          sendSpeed(m / 10)
+        }}
+        onPointerUp={() => setDragMult(null)}
+        onKeyUp={() => setDragMult(null)}
+        onBlur={() => setDragMult(null)}
+        style={{ width: 92, height: 4, cursor: 'pointer', accentColor: 'var(--text-accent)' }}
+      />
+      <span style={{
+        fontSize: 'var(--font-size-xs)',
+        color: paused ? 'var(--status-engaged)' : 'var(--text-secondary)',
+        minWidth: 46,
+        fontWeight: 600,
+        whiteSpace: 'nowrap',
+      }}>
+        {multLabel(mult)}
+      </span>
+    </div>
+  )
+}
+
+function LiveBtn({ active, onClick }: { active: boolean; onClick: () => void }) {
+  return (
+    <button
+      onClick={onClick}
+      style={{
+        background: active ? 'var(--bg-hover)' : 'none',
+        border: `1px solid ${active ? 'var(--border-accent)' : 'transparent'}`,
+        borderRadius: 3,
+        color: active ? 'var(--text-accent)' : 'var(--text-muted)',
+        cursor: 'pointer',
+        fontFamily: 'var(--font-mono)',
+        fontSize: 'var(--font-size-xs)',
+        padding: '2px 4px',
+        textTransform: 'uppercase',
+        fontWeight: 600,
+        letterSpacing: '0.03em',
+        whiteSpace: 'nowrap',
+        opacity: active ? 1 : 0.55,
+        display: 'inline-flex',
+        alignItems: 'center',
+        gap: 4,
+      }}
+    >
+      {active && (
+        <>
+          <style>{'@keyframes live-pulse{0%,100%{opacity:1}50%{opacity:0.25}}'}</style>
+          <span style={{ width: 5, height: 5, borderRadius: '50%', background: '#e84545', animation: 'live-pulse 1.4s ease-in-out infinite', flexShrink: 0 }} />
+        </>
+      )}
+      LIVE
+    </button>
+  )
+}
+
+function MuteBtn() {
+  const muted = useUIStore((s) => s.audioMuted)
+  const toggleAudioMuted = useUIStore((s) => s.toggleAudioMuted)
+  return (
+    <button
+      onClick={toggleAudioMuted}
+      title="Sound on/off"
+      aria-label="Sound on/off"
+      style={{
+        background: 'none',
+        border: '1px solid transparent',
+        borderRadius: 3,
+        color: muted ? 'var(--status-engaged)' : 'var(--text-muted)',
+        cursor: 'pointer',
+        padding: '2px 4px',
+        opacity: muted ? 1 : 0.55,
+        display: 'inline-flex',
+        alignItems: 'center',
+        lineHeight: 1,
+      }}
+    >
+      <svg width="12" height="12" viewBox="0 0 16 16" aria-hidden="true">
+        <path d="M2 6h3l4-3.5v11L5 10H2z" fill="currentColor" />
+        {muted ? (
+          <path d="M11 6l4 4M15 6l-4 4" stroke="currentColor" strokeWidth="1.4" strokeLinecap="round" fill="none" />
+        ) : (
+          <path d="M11.5 5.5a3.4 3.4 0 0 1 0 5M13 4a5.6 5.6 0 0 1 0 8" stroke="currentColor" strokeWidth="1.2" strokeLinecap="round" fill="none" />
+        )}
+      </svg>
+    </button>
+  )
+}
+
 function StrikeBtn({ compact }: { compact: boolean }) {
   const { open, openStrike, closeStrike } = useStrikeStore()
   return (
diff --git a/src/components/hud/__tests__/AlertFeed.test.tsx b/src/components/hud/__tests__/AlertFeed.test.tsx
index 2498b85..a340ad5 100644
--- a/src/components/hud/__tests__/AlertFeed.test.tsx
+++ b/src/components/hud/__tests__/AlertFeed.test.tsx
@@ -6,7 +6,7 @@ import { useUIStore } from '@/store/ui-store'
 import { sendCommand } from '@/store/bridge'
 import { shippingLanes } from '@/data/shipping/shipping-lanes'
 import type { GameViewState, ViewUnit } from '@/types/view'
-import type { GameEvent } from '@/types/game'
+import type { GameEvent, ShippingLane } from '@/types/game'
 
 vi.mock('@/store/bridge', () => ({
   sendCommand: vi.fn(),
@@ -50,6 +50,7 @@ const jamaran: ViewUnit = {
 interface ViewOpts {
   speed?: number
   units?: ViewUnit[]
+  lanes?: ShippingLane[]
 }
 
 function makeViewState(events: GameEvent[], opts: ViewOpts = {}): GameViewState {
@@ -61,13 +62,14 @@ function makeViewState(events: GameEvent[], opts: ViewOpts = {}): GameViewState
     units: opts.units ?? [lincoln, jamaran],
     missiles: [],
     supplyLines: [],
-    shippingLanes,
+    shippingLanes: opts.lanes ?? shippingLanes,
     events,
     pendingEventCount: 0,
     satelliteDetectedUnitIds: [],
     warSupport: {},
     gameOver: null,
     objectives: [],
+    intel: { assets: [], agents: [], products: [], taskings: [], leakLevel: 0, paranoiaBand: 'LOW' as const, encryptionUpgradedUntilTick: null },
   }
 }
 
@@ -150,7 +152,7 @@ describe('AlertFeed', () => {
     const cut: GameEvent = { type: 'SUPPLY_LINE_CUT', lineId: 'bandar_supply', tick: 7 }
     setStore([cut])
     render(<AlertFeed />)
-    expect(screen.getByText(/SUPPLY CUT: BANDAR SUPPLY/)).toBeTruthy()
+    expect(screen.getByText(/SUPPLY CUT: Bandar Supply/)).toBeTruthy()
   })
 
   it('renders lane events with the lane display name, not the underscored id', () => {
@@ -160,8 +162,18 @@ describe('AlertFeed', () => {
     }
     setStore([laneEvent])
     render(<AlertFeed />)
-    expect(screen.getByText(/BAB EL-MANDEB: REDUCED/)).toBeTruthy()
-    expect(screen.queryByText(/EL_MANDEB/)).toBeNull()
+    expect(screen.getByText(/Bab el-Mandeb: REDUCED/)).toBeTruthy()
+    expect(screen.queryByText(/EL_MANDEB/i)).toBeNull()
+  })
+
+  it('prettifies lane ids missing from view state instead of leaking the raw enum', () => {
+    const laneEvent: GameEvent = {
+      type: 'SHIPPING_LANE_STATUS_CHANGE', laneId: 'bab_el_mandeb',
+      newStatus: 'blocked', suppressionFactor: 1, tick: 9,
+    }
+    setStore([laneEvent], [], { lanes: [] })
+    render(<AlertFeed />)
+    expect(screen.getByText(/Bab el-Mandeb: BLOCKED/)).toBeTruthy()
   })
 })
 
@@ -193,7 +205,7 @@ describe('AlertFeed click-to-zoom', () => {
     render(<AlertFeed />)
     expandFeed()
 
-    fireEvent.click(screen.getByText(/STRAIT OF HORMUZ: BLOCKED/))
+    fireEvent.click(screen.getByText(/Strait of Hormuz: BLOCKED/))
     expect(useUIStore.getState().mapFocus).toMatchObject({ lng: 56.3, lat: 26.5 })
   })
 
diff --git a/src/components/hud/__tests__/DebriefScreen.test.tsx b/src/components/hud/__tests__/DebriefScreen.test.tsx
index e676e46..d762074 100644
--- a/src/components/hud/__tests__/DebriefScreen.test.tsx
+++ b/src/components/hud/__tests__/DebriefScreen.test.tsx
@@ -75,6 +75,7 @@ function makeViewState(over: Partial<GameViewState>): GameViewState {
     warSupport: { usa: 64, iran: 0 },
     gameOver: victoryReport,
     objectives,
+    intel: { assets: [], agents: [], products: [], taskings: [], leakLevel: 0, paranoiaBand: 'LOW' as const, encryptionUpgradedUntilTick: null },
     ...over,
   }
 }
diff --git a/src/components/hud/__tests__/MapToggle.test.tsx b/src/components/hud/__tests__/MapToggle.test.tsx
index 0f3c8a7..81c2510 100644
--- a/src/components/hud/__tests__/MapToggle.test.tsx
+++ b/src/components/hud/__tests__/MapToggle.test.tsx
@@ -1,5 +1,7 @@
-import { describe, it, expect, beforeEach } from 'vitest'
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
 import { useUIStore } from '@/store/ui-store'
+import { useMapIntelStore } from '@/store/map-intel-store'
+import type { ViewUnit } from '@/types/view'
 
 /**
  * Tests for map toggle behavior — written BEFORE implementation (TDD).
@@ -31,3 +33,149 @@ describe('MapToggle sub-menu behavior', () => {
     expect(useUIStore.getState().losFilter).toBe('off')
   })
 })
+
+function mkUnit(id: string, nation: string, stale: boolean, status = 'ready'): ViewUnit {
+  return { id, nation, stale, status } as unknown as ViewUnit
+}
+
+describe('map-intel-store toggles', () => {
+  beforeEach(() => {
+    useMapIntelStore.getState().setAdsbLive(false)
+    useMapIntelStore.setState({ intelOverlays: false, reconMosaic: false, staleSince: {}, adsbAircraft: [] })
+  })
+
+  afterEach(() => {
+    useMapIntelStore.getState().setAdsbLive(false)
+    vi.unstubAllGlobals()
+  })
+
+  it('defaults: all layers off', () => {
+    const s = useMapIntelStore.getState()
+    expect(s.intelOverlays).toBe(false)
+    expect(s.reconMosaic).toBe(false)
+    expect(s.adsbLive).toBe(false)
+    expect(s.adsbAircraft).toEqual([])
+  })
+
+  it('intel overlays and recon mosaic toggle independently', () => {
+    useMapIntelStore.getState().toggleIntelOverlays()
+    expect(useMapIntelStore.getState().intelOverlays).toBe(true)
+    expect(useMapIntelStore.getState().reconMosaic).toBe(false)
+
+    useMapIntelStore.getState().toggleReconMosaic()
+    expect(useMapIntelStore.getState().reconMosaic).toBe(true)
+
+    useMapIntelStore.getState().toggleIntelOverlays()
+    expect(useMapIntelStore.getState().intelOverlays).toBe(false)
+    expect(useMapIntelStore.getState().reconMosaic).toBe(true)
+  })
+
+  it('ADS-B on: fetches aircraft, caps at 80, trims callsigns', async () => {
+    const ac = Array.from({ length: 100 }, (_, i) => ({
+      hex: `hex${i}`,
+      flight: `GULF${i}  `,
+      lat: 26 + i * 0.01,
+      lon: 54,
+      track: 90,
+    }))
+    vi.stubGlobal('fetch', vi.fn(async () => ({
+      ok: true,
+      json: async () => ({ ac }),
+    })))
+
+    useMapIntelStore.getState().setAdsbLive(true)
+    await vi.waitFor(() => {
+      expect(useMapIntelStore.getState().adsbAircraft.length).toBe(80)
+    })
+    expect(useMapIntelStore.getState().adsbAircraft[0]).toEqual({
+      id: 'hex0',
+      callsign: 'GULF0',
+      lat: 26,
+      lon: 54,
+      track: 90,
+    })
+  })
+
+  it('ADS-B skips aircraft without a usable position', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => ({
+      ok: true,
+      json: async () => ({
+        ac: [
+          { hex: 'nopos', flight: 'GHOST1' },
+          { hex: 'good', flight: 'REAL1', lat: 26.5, lon: 54.2 },
+          { hex: 'lastpos', lastPosition: { lat: 27.1, lon: 53.9 } },
+        ],
+      }),
+    })))
+
+    useMapIntelStore.getState().setAdsbLive(true)
+    await vi.waitFor(() => {
+      expect(useMapIntelStore.getState().adsbAircraft.length).toBe(2)
+    })
+    const ids = useMapIntelStore.getState().adsbAircraft.map(a => a.id)
+    expect(ids).toEqual(['good', 'lastpos'])
+    expect(useMapIntelStore.getState().adsbAircraft[1].track).toBeNull()
+  })
+
+  it('ADS-B fetch failure is silent and leaves no aircraft', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => { throw new Error('network down') }))
+    useMapIntelStore.getState().setAdsbLive(true)
+    await new Promise(r => setTimeout(r, 10))
+    expect(useMapIntelStore.getState().adsbLive).toBe(true)
+    expect(useMapIntelStore.getState().adsbAircraft).toEqual([])
+  })
+
+  it('ADS-B off clears aircraft', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => ({
+      ok: true,
+      json: async () => ({ ac: [{ hex: 'a1', flight: 'X', lat: 26, lon: 54, track: 10 }] }),
+    })))
+    useMapIntelStore.getState().setAdsbLive(true)
+    await vi.waitFor(() => {
+      expect(useMapIntelStore.getState().adsbAircraft.length).toBe(1)
+    })
+    useMapIntelStore.getState().setAdsbLive(false)
+    expect(useMapIntelStore.getState().adsbAircraft).toEqual([])
+    expect(useMapIntelStore.getState().adsbLive).toBe(false)
+  })
+})
+
+describe('map-intel-store stale-since bookkeeping', () => {
+  beforeEach(() => {
+    useMapIntelStore.setState({ staleSince: {} })
+  })
+
+  it('anchors a stale enemy contact at the tick it first went stale', () => {
+    const sync = useMapIntelStore.getState().syncStaleContacts
+    sync([mkUnit('e1', 'iran', true)], 100, 'usa')
+    expect(useMapIntelStore.getState().staleSince).toEqual({ e1: 100 })
+
+    // Still stale later → anchor preserved, not re-stamped
+    sync([mkUnit('e1', 'iran', true)], 500, 'usa')
+    expect(useMapIntelStore.getState().staleSince).toEqual({ e1: 100 })
+  })
+
+  it('clears the anchor when the contact refreshes or disappears', () => {
+    const sync = useMapIntelStore.getState().syncStaleContacts
+    sync([mkUnit('e1', 'iran', true), mkUnit('e2', 'iran', true)], 100, 'usa')
+    expect(Object.keys(useMapIntelStore.getState().staleSince)).toHaveLength(2)
+
+    // e1 refreshes (stale=false), e2 disappears entirely
+    sync([mkUnit('e1', 'iran', false)], 200, 'usa')
+    expect(useMapIntelStore.getState().staleSince).toEqual({})
+
+    // Going stale again re-anchors at the new tick
+    sync([mkUnit('e1', 'iran', true)], 300, 'usa')
+    expect(useMapIntelStore.getState().staleSince).toEqual({ e1: 300 })
+  })
+
+  it('ignores own-nation and destroyed units', () => {
+    const sync = useMapIntelStore.getState().syncStaleContacts
+    sync([
+      mkUnit('own1', 'usa', true),
+      mkUnit('dead1', 'iran', true, 'destroyed'),
+      mkUnit('e1', 'iran', true),
+    ], 50, 'usa')
+    expect(useMapIntelStore.getState().staleSince).toEqual({ e1: 50 })
+  })
+})
diff --git a/src/components/hud/__tests__/TopBar.test.tsx b/src/components/hud/__tests__/TopBar.test.tsx
index a53f286..86d133d 100644
--- a/src/components/hud/__tests__/TopBar.test.tsx
+++ b/src/components/hud/__tests__/TopBar.test.tsx
@@ -1,8 +1,11 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest'
-import { render, screen, fireEvent } from '@testing-library/react'
+import { render, screen, fireEvent, act } from '@testing-library/react'
 import TopBar from '../TopBar'
 import { useGameStore } from '@/store/game-store'
+import { useUIStore } from '@/store/ui-store'
+import { useMenuStore } from '@/store/menu-store'
 import { sendCommand } from '@/store/bridge'
+import { audioManager, AUDIO_STORAGE_KEYS } from '@/audio/audio-manager'
 import type { GameViewState } from '@/types/view'
 import type { GameEvent, Nation } from '@/types/game'
 
@@ -50,6 +53,15 @@ function makeViewState(over: Partial<GameViewState> & { atWar?: boolean }): Game
     warSupport: { usa: 72, iran: 41 },
     gameOver: null,
     objectives: [],
+    intel: {
+      assets: [],
+      agents: [],
+      products: [],
+      taskings: [],
+      leakLevel: 0,
+      paranoiaBand: 'LOW',
+      encryptionUpgradedUntilTick: null,
+    },
     ...rest,
   }
 }
@@ -86,6 +98,34 @@ describe('TopBar war controls', () => {
     expect(screen.getByText('41%')).toBeTruthy()
   })
 
+  it('sends DECLARE_WAR when confirmed inside the countdown window', () => {
+    render(<TopBar />)
+
+    fireEvent.click(screen.getByText('DECLARE WAR'))
+    expect(sendCommand).not.toHaveBeenCalled()
+
+    fireEvent.click(screen.getByText(/CONFIRM WAR/))
+    expect(sendCommand).toHaveBeenCalledWith({ type: 'DECLARE_WAR', target: 'iran' })
+  })
+
+  it('shows a live countdown on CONFIRM WAR and disarms when it expires', () => {
+    vi.useFakeTimers()
+    try {
+      render(<TopBar />)
+      fireEvent.click(screen.getByText('DECLARE WAR'))
+      expect(screen.getByText('CONFIRM WAR 5')).toBeTruthy()
+
+      act(() => { vi.advanceTimersByTime(1100) })
+      expect(screen.getByText('CONFIRM WAR 4')).toBeTruthy()
+
+      act(() => { vi.advanceTimersByTime(4000) })
+      expect(screen.getByText('DECLARE WAR')).toBeTruthy()
+      expect(sendCommand).not.toHaveBeenCalled()
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
   it('sends OFFER_CEASEFIRE only after the two-step confirm', () => {
     setStore(makeViewState({ atWar: true }))
     render(<TopBar />)
@@ -168,3 +208,116 @@ describe('TopBar war controls', () => {
     expect(screen.queryByText('RESIGN')).toBeNull()
   })
 })
+
+describe('TopBar main menu exit', () => {
+  beforeEach(() => {
+    useMenuStore.getState().setScreen('playing')
+  })
+
+  it('returns to the main menu only after the two-step confirm', () => {
+    useUIStore.setState({ showIntel: true })
+    render(<TopBar />)
+
+    fireEvent.click(screen.getByText('···'))
+    fireEvent.click(screen.getByText('MAIN MENU'))
+    expect(useMenuStore.getState().screen).toBe('playing')
+
+    fireEvent.click(screen.getByText('CONFIRM EXIT?'))
+    expect(useMenuStore.getState().screen).toBe('start')
+    expect(useUIStore.getState().showIntel).toBe(false)
+  })
+
+  it('disarms CONFIRM EXIT? after 4 seconds without confirming', () => {
+    vi.useFakeTimers()
+    try {
+      render(<TopBar />)
+      fireEvent.click(screen.getByText('···'))
+      fireEvent.click(screen.getByText('MAIN MENU'))
+      expect(screen.getByText('CONFIRM EXIT?')).toBeTruthy()
+
+      act(() => { vi.advanceTimersByTime(4100) })
+      expect(screen.getByText('MAIN MENU')).toBeTruthy()
+      expect(useMenuStore.getState().screen).toBe('playing')
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})
+
+describe('TopBar sound toggle', () => {
+  beforeEach(() => {
+    audioManager.setMuted(false)
+    useUIStore.setState({ audioMuted: false })
+  })
+
+  it('toggles mute in the ui-store and persists it', () => {
+    render(<TopBar />)
+    const btn = screen.getByLabelText('Sound on/off')
+    expect(btn.getAttribute('title')).toBe('Sound on/off')
+
+    fireEvent.click(btn)
+    expect(useUIStore.getState().audioMuted).toBe(true)
+    expect(localStorage.getItem(AUDIO_STORAGE_KEYS.muted)).toBe('1')
+    expect(audioManager.isMuted()).toBe(true)
+
+    fireEvent.click(btn)
+    expect(useUIStore.getState().audioMuted).toBe(false)
+    expect(localStorage.getItem(AUDIO_STORAGE_KEYS.muted)).toBe('0')
+  })
+})
+
+describe('TopBar time controls', () => {
+  function setSpeed(speed: number) {
+    setStore(makeViewState({ time: { tick: 100, timestamp: 1_000_000, speed, tickIntervalMs: 100 } }))
+  }
+
+  it('slider at max sends 1h/s (engine speed 360)', () => {
+    render(<TopBar />)
+    fireEvent.change(screen.getByRole('slider'), { target: { value: '1000' } })
+    expect(sendCommand).toHaveBeenCalledWith({ type: 'SET_SPEED', speed: 360 })
+  })
+
+  it('slider snaps near-detent positions to the detent', () => {
+    render(<TopBar />)
+    // pos 500 ≈ multiplier 59.8 → snaps to the 60× detent → engine speed 6
+    fireEvent.change(screen.getByRole('slider'), { target: { value: '500' } })
+    expect(sendCommand).toHaveBeenCalledWith({ type: 'SET_SPEED', speed: 6 })
+  })
+
+  it('slider at zero pauses', () => {
+    render(<TopBar />)
+    fireEvent.change(screen.getByRole('slider'), { target: { value: '0' } })
+    expect(sendCommand).toHaveBeenCalledWith({ type: 'SET_SPEED', speed: 0 })
+  })
+
+  it('shows PAUSED when speed is 0 and ×N otherwise', () => {
+    setSpeed(0)
+    const { unmount } = render(<TopBar />)
+    expect(screen.getByText('PAUSED')).toBeTruthy()
+    unmount()
+
+    setSpeed(1) // multiplier 10
+    render(<TopBar />)
+    expect(screen.getByText('×10')).toBeTruthy()
+  })
+
+  it('pause button stops the clock and resumes to the last nonzero speed', () => {
+    setSpeed(1)
+    const { unmount } = render(<TopBar />)
+    fireEvent.click(screen.getByLabelText('Pause'))
+    expect(sendCommand).toHaveBeenCalledWith({ type: 'SET_SPEED', speed: 0 })
+    unmount()
+
+    setSpeed(0)
+    render(<TopBar />)
+    fireEvent.click(screen.getByLabelText('Resume'))
+    expect(sendCommand).toHaveBeenCalledWith({ type: 'SET_SPEED', speed: 0.1 })
+  })
+
+  it('toggles the LIVE feeds window', () => {
+    useUIStore.setState({ liveFeedsOpen: false })
+    render(<TopBar />)
+    fireEvent.click(screen.getByText('LIVE'))
+    expect(useUIStore.getState().liveFeedsOpen).toBe(true)
+  })
+})
diff --git a/src/components/intel/ImintViewer.tsx b/src/components/intel/ImintViewer.tsx
new file mode 100644
index 0000000..e81be30
--- /dev/null
+++ b/src/components/intel/ImintViewer.tsx
@@ -0,0 +1,258 @@
+import { useEffect, useRef, useState } from 'react'
+import { useGameStore } from '@/store/game-store'
+import { useUIStore } from '@/store/ui-store'
+import { esriImageryTileUrl } from '@/data/feeds'
+import { formatDtg, tileGrid, NOISE_BG, SCANLINE_OVERLAY } from './imagery'
+import type { GameEvent, IntelProduct } from '@/types/game'
+
+const TOAST_MS = 10_000
+
+export default function ImintViewer() {
+  const viewedProductId = useUIStore((s) => s.viewedProductId)
+  const setViewedProduct = useUIStore((s) => s.setViewedProduct)
+  const intel = useGameStore((s) => s.viewState.intel)
+  const events = useGameStore((s) => s.viewState.events)
+  const products = intel?.products ?? []
+
+  // Toast on fresh imagery — event batches are one-shot, guard by reference
+  const [toastUntil, setToastUntil] = useState(0)
+  const toastBatchRef = useRef<GameEvent[] | null>(null)
+  useEffect(() => {
+    if (events.length === 0 || toastBatchRef.current === events) return
+    toastBatchRef.current = events
+    if (events.some((e) => e.type === 'SATELLITE_PASS_COMPLETE')) {
+      setToastUntil(Date.now() + TOAST_MS)
+    }
+  }, [events])
+  useEffect(() => {
+    if (toastUntil <= Date.now()) return
+    const t = setTimeout(() => setToastUntil(0), toastUntil - Date.now())
+    return () => clearTimeout(t)
+  }, [toastUntil])
+
+  const product = viewedProductId
+    ? products.find((p) => p.id === viewedProductId && p.kind === 'imint') ?? null
+    : null
+
+  // Esc closes the viewer; capture+stop so App's global Escape doesn't also fire
+  useEffect(() => {
+    if (!product) return
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') {
+        e.stopPropagation()
+        setViewedProduct(null)
+      }
+    }
+    window.addEventListener('keydown', onKey, true)
+    return () => window.removeEventListener('keydown', onKey, true)
+  }, [product, setViewedProduct])
+
+  const openNewest = () => {
+    const newest = [...products].filter((p) => p.kind === 'imint').sort((a, b) => b.tick - a.tick)[0]
+    if (newest) setViewedProduct(newest.id)
+    setToastUntil(0)
+  }
+
+  const sensorName = product?.assetId
+    ? intel?.assets.find((a) => a.id === product.assetId)?.name ?? product.assetId.toUpperCase()
+    : 'UNKNOWN SENSOR'
+
+  return (
+    <>
+      {toastUntil > Date.now() && !product && (
+        <button
+          onClick={openNewest}
+          style={{
+            position: 'absolute',
+            bottom: 16,
+            left: '50%',
+            transform: 'translateX(-50%)',
+            zIndex: 60,
+            background: 'var(--bg-panel)',
+            border: '1px solid var(--border-accent)',
+            borderRadius: 'var(--panel-radius)',
+            color: 'var(--text-accent)',
+            cursor: 'pointer',
+            fontFamily: 'var(--font-mono)',
+            fontSize: 'var(--font-size-xs)',
+            fontWeight: 700,
+            letterSpacing: '0.06em',
+            padding: '6px 14px',
+            whiteSpace: 'nowrap',
+          }}
+        >
+          NEW IMINT PRODUCT — VIEW
+        </button>
+      )}
+
+      {product && (
+        <div
+          onClick={() => setViewedProduct(null)}
+          style={{
+            position: 'fixed',
+            inset: 0,
+            zIndex: 100,
+            background: 'rgba(0, 0, 0, 0.85)',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            fontFamily: 'var(--font-mono)',
+          }}
+        >
+          <ProductFrame
+            key={product.id}
+            product={product}
+            sensorName={sensorName}
+            onClose={() => setViewedProduct(null)}
+          />
+        </div>
+      )}
+    </>
+  )
+}
+
+function ProductFrame({ product, sensorName, onClose }: { product: IntelProduct; sensorName: string; onClose: () => void }) {
+  const topSecret = product.classification.toUpperCase().includes('TOP SECRET')
+  const zoom = product.assetId === 'commercial' ? 14 : 15
+  const target = product.target ?? { lng: 56.27, lat: 27.18 }
+  const { xs, ys } = tileGrid(target.lng, target.lat, zoom, 3, 2)
+  const [failed, setFailed] = useState<Record<string, boolean>>({})
+
+  return (
+    <div
+      onClick={(e) => e.stopPropagation()}
+      style={{
+        background: '#000',
+        border: '1px solid #2a2f36',
+        width: 'min(780px, 94vw)',
+        boxShadow: '0 0 60px rgba(0,0,0,0.9)',
+      }}
+    >
+      <ClassificationBanner text={product.classification} topSecret={topSecret} />
+
+      {/* Image area */}
+      <div style={{ position: 'relative', margin: '6px 10px' }}>
+        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: 0, background: '#05070a' }}>
+          {ys.map((ty) =>
+            xs.map((tx) => {
+              const k = `${tx}/${ty}`
+              return failed[k] ? (
+                <div
+                  key={k}
+                  style={{
+                    ...NOISE_BG,
+                    aspectRatio: '1',
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    color: 'var(--text-muted)',
+                    fontSize: '0.5rem',
+                    letterSpacing: '0.08em',
+                    textAlign: 'center',
+                    padding: 6,
+                  }}
+                >
+                  COLLECTION ARTIFACT — IMAGE DATA UNAVAILABLE
+                </div>
+              ) : (
+                <img
+                  key={k}
+                  src={esriImageryTileUrl(zoom, tx, ty)}
+                  alt=""
+                  onError={() => setFailed((f) => ({ ...f, [k]: true }))}
+                  style={{ width: '100%', aspectRatio: '1', display: 'block', objectFit: 'cover' }}
+                  draggable={false}
+                />
+              )
+            }),
+          )}
+        </div>
+
+        {/* Crosshair */}
+        <div style={{ position: 'absolute', inset: 0, pointerEvents: 'none' }}>
+          <div style={{ position: 'absolute', left: '50%', top: '50%', width: 1, height: 46, background: 'rgba(255,255,255,0.65)', transform: 'translate(-50%, -50%)' }} />
+          <div style={{ position: 'absolute', left: '50%', top: '50%', width: 46, height: 1, background: 'rgba(255,255,255,0.65)', transform: 'translate(-50%, -50%)' }} />
+          <div style={{ position: 'absolute', left: '50%', top: '50%', width: 70, height: 70, border: '1px solid rgba(255,255,255,0.35)', borderRadius: '50%', transform: 'translate(-50%, -50%)' }} />
+        </div>
+
+        {/* Corner brackets */}
+        {([
+          { left: 6, top: 6, borderLeft: '2px solid', borderTop: '2px solid' },
+          { right: 6, top: 6, borderRight: '2px solid', borderTop: '2px solid' },
+          { left: 6, bottom: 6, borderLeft: '2px solid', borderBottom: '2px solid' },
+          { right: 6, bottom: 6, borderRight: '2px solid', borderBottom: '2px solid' },
+        ] as const).map((pos, i) => (
+          <div key={i} style={{ position: 'absolute', width: 22, height: 22, color: 'rgba(255,255,255,0.5)', pointerEvents: 'none', ...pos }} />
+        ))}
+
+        {/* Burn-ins */}
+        <div style={{ position: 'absolute', top: 8, left: 34, color: '#e6e6e6', fontSize: '0.6rem', letterSpacing: '0.1em', textShadow: '0 0 3px #000' }}>
+          {sensorName.toUpperCase()}
+        </div>
+        <div style={{ position: 'absolute', top: 8, right: 34, display: 'flex', gap: 6, alignItems: 'center' }}>
+          {product.niirs !== undefined && (
+            <span style={{ border: '1px solid rgba(255,255,255,0.5)', color: '#e6e6e6', fontSize: '0.55rem', padding: '1px 5px', letterSpacing: '0.08em', textShadow: '0 0 3px #000' }}>
+              NIIRS {product.niirs}
+            </span>
+          )}
+        </div>
+        <div style={{ position: 'absolute', bottom: 8, left: 34, color: '#e6e6e6', fontSize: '0.6rem', letterSpacing: '0.1em', textShadow: '0 0 3px #000' }}>
+          {formatDtg(product.tick)}
+        </div>
+        <div style={{ position: 'absolute', bottom: 8, right: 34, color: '#e6e6e6', fontSize: '0.6rem', letterSpacing: '0.1em', textShadow: '0 0 3px #000' }}>
+          {`${Math.abs(target.lat).toFixed(4)}${target.lat >= 0 ? 'N' : 'S'} ${Math.abs(target.lng).toFixed(4)}${target.lng >= 0 ? 'E' : 'W'}`}
+        </div>
+
+        <div style={SCANLINE_OVERLAY} />
+      </div>
+
+      {/* Caption bar */}
+      <div style={{
+        display: 'flex',
+        justifyContent: 'space-between',
+        alignItems: 'center',
+        gap: 12,
+        padding: '4px 10px 8px',
+        color: 'var(--text-secondary)',
+        fontSize: 'var(--font-size-xs)',
+      }}>
+        <span style={{ overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>{product.caption}</span>
+        <button
+          onClick={onClose}
+          style={{
+            background: 'none',
+            border: '1px solid var(--border-default)',
+            borderRadius: 3,
+            color: 'var(--text-muted)',
+            cursor: 'pointer',
+            fontFamily: 'var(--font-mono)',
+            fontSize: 'var(--font-size-xs)',
+            padding: '2px 8px',
+            flexShrink: 0,
+          }}
+        >
+          CLOSE [ESC]
+        </button>
+      </div>
+
+      <ClassificationBanner text={product.classification} topSecret={topSecret} />
+    </div>
+  )
+}
+
+function ClassificationBanner({ text, topSecret }: { text: string; topSecret: boolean }) {
+  return (
+    <div style={{
+      background: topSecret ? '#8c1f1f' : '#1f6e2e',
+      color: '#fff',
+      textAlign: 'center',
+      fontSize: '0.6rem',
+      fontWeight: 700,
+      letterSpacing: '0.25em',
+      padding: '3px 0',
+      textTransform: 'uppercase',
+    }}>
+      {text}
+    </div>
+  )
+}
diff --git a/src/components/intel/LiveFeeds.tsx b/src/components/intel/LiveFeeds.tsx
new file mode 100644
index 0000000..19db596
--- /dev/null
+++ b/src/components/intel/LiveFeeds.tsx
@@ -0,0 +1,381 @@
+import { useCallback, useEffect, useRef, useState, type CSSProperties, type PointerEvent, type ReactNode } from 'react'
+import { useGameStore } from '@/store/game-store'
+import { useUIStore } from '@/store/ui-store'
+import {
+  ADSB_POLL_INTERVAL_MS,
+  GULF_BBOX,
+  HORMUZ_LIVE_YOUTUBE_ID,
+  INTEL_SOURCES,
+  adsbLiveUrl,
+  esriImageryTileUrl,
+  eumetsatLiveUrl,
+  youtubeEmbedUrl,
+} from '@/data/feeds'
+import { formatDtg, isGulfDaylight, tileGrid, NOISE_BG, SCANLINE_OVERLAY } from './imagery'
+
+const GEOSAT_REFRESH_MS = 15 * 60 * 1000
+const ADSB_CENTER = { lat: 26.5, lon: 54.0, radiusNm: 220 }
+
+export default function LiveFeeds() {
+  const open = useUIStore((s) => s.liveFeedsOpen)
+  const toggleLiveFeeds = useUIStore((s) => s.toggleLiveFeeds)
+  const [pos, setPos] = useState<{ x: number; y: number } | null>(null)
+  const panelRef = useRef<HTMLDivElement>(null)
+  const dragRef = useRef<{ startX: number; startY: number; origLeft: number; origTop: number } | null>(null)
+
+  const onPointerDown = useCallback((e: PointerEvent<HTMLDivElement>) => {
+    const panel = panelRef.current
+    if (!panel) return
+    e.preventDefault()
+    ;(e.target as HTMLElement).setPointerCapture(e.pointerId)
+    const rect = panel.getBoundingClientRect()
+    dragRef.current = { startX: e.clientX, startY: e.clientY, origLeft: rect.left, origTop: rect.top }
+  }, [])
+  const onPointerMove = useCallback((e: PointerEvent<HTMLDivElement>) => {
+    if (!dragRef.current) return
+    setPos({
+      x: dragRef.current.origLeft + e.clientX - dragRef.current.startX,
+      y: dragRef.current.origTop + e.clientY - dragRef.current.startY,
+    })
+  }, [])
+  const onPointerUp = useCallback(() => { dragRef.current = null }, [])
+
+  if (!open) return null
+
+  return (
+    <div
+      ref={panelRef}
+      style={{
+        position: 'absolute',
+        ...(pos ? { left: pos.x, top: pos.y } : { top: 48, right: 12 }),
+        zIndex: 25,
+        width: 'min(640px, 94vw)',
+        background: 'var(--bg-panel)',
+        border: '1px solid var(--border-default)',
+        borderRadius: 'var(--panel-radius)',
+        fontFamily: 'var(--font-mono)',
+        boxShadow: '0 8px 40px rgba(0,0,0,0.6)',
+        overflow: 'hidden',
+      }}
+    >
+      <style>{'@keyframes lf-rec{0%,100%{opacity:1}50%{opacity:0.25}} @keyframes lf-drift{0%{transform:scale(1.35) translate(-2.5%,-1.5%)}100%{transform:scale(1.35) translate(2.5%,1.8%)}}'}</style>
+
+      {/* Title bar */}
+      <div
+        onPointerDown={onPointerDown}
+        onPointerMove={onPointerMove}
+        onPointerUp={onPointerUp}
+        style={{
+          display: 'flex',
+          justifyContent: 'space-between',
+          alignItems: 'center',
+          padding: '5px 10px',
+          borderBottom: '1px solid var(--border-default)',
+          cursor: 'grab',
+          userSelect: 'none',
+        }}
+      >
+        <span style={{ color: 'var(--text-accent)', fontSize: 'var(--font-size-xs)', fontWeight: 600, letterSpacing: '0.08em', textTransform: 'uppercase' }}>
+          LIVE FEEDS — THEATER ISR
+        </span>
+        <button
+          onClick={toggleLiveFeeds}
+          onPointerDown={(e) => e.stopPropagation()}
+          style={{ background: 'none', border: 'none', color: 'var(--text-muted)', cursor: 'pointer', fontFamily: 'var(--font-mono)', fontSize: 'var(--font-size-sm)', padding: '0 3px', lineHeight: 1 }}
+        >
+          x
+        </button>
+      </div>
+
+      {/* 2x2 grid */}
+      <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 6, padding: 6 }}>
+        <GeosatCell />
+        <HormuzCamCell />
+        <FmvCell />
+        <AdsbCell />
+      </div>
+
+      {/* Credits — required by source terms */}
+      <div style={{ borderTop: '1px solid var(--border-default)', padding: '4px 10px 6px' }}>
+        <div style={{ color: 'var(--text-muted)', fontSize: '0.5rem', letterSpacing: '0.12em', marginBottom: 2 }}>
+          INTEL SOURCES
+        </div>
+        <div style={{ display: 'flex', flexWrap: 'wrap', gap: '1px 10px' }}>
+          {INTEL_SOURCES.map((s) => (
+            <span key={s.name} style={{ color: 'var(--text-muted)', fontSize: '0.5rem', opacity: 0.8 }}>
+              {s.name} · {s.role}
+            </span>
+          ))}
+        </div>
+      </div>
+    </div>
+  )
+}
+
+function FeedCell({ title, live = true, caption, children }: { title: string; live?: boolean; caption?: ReactNode; children: ReactNode }) {
+  return (
+    <div style={{ border: '1px solid var(--border-default)', borderRadius: 3, overflow: 'hidden', background: '#05070a' }}>
+      <div style={{ display: 'flex', alignItems: 'center', gap: 6, padding: '3px 6px', borderBottom: '1px solid var(--border-default)' }}>
+        {live && (
+          <span style={{ width: 6, height: 6, borderRadius: '50%', background: '#e84545', animation: 'lf-rec 1.4s ease-in-out infinite', flexShrink: 0 }} />
+        )}
+        <span style={{ color: 'var(--text-secondary)', fontSize: '0.55rem', fontWeight: 600, letterSpacing: '0.1em', textTransform: 'uppercase', whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis' }}>
+          {title}
+        </span>
+      </div>
+      <div style={{ position: 'relative', aspectRatio: '16 / 10' }}>{children}</div>
+      {caption !== undefined && (
+        <div style={{ padding: '2px 6px', color: 'var(--text-muted)', fontSize: '0.5rem', letterSpacing: '0.06em', whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis' }}>
+          {caption}
+        </div>
+      )}
+    </div>
+  )
+}
+
+function OfflineCard({ label }: { label: string }) {
+  return (
+    <div style={{ ...NOISE_BG, position: 'absolute', inset: 0, display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
+      <span style={{ color: 'var(--text-muted)', fontSize: '0.55rem', letterSpacing: '0.15em', fontWeight: 600 }}>{label}</span>
+    </div>
+  )
+}
+
+// ── 1. EUMETSAT Meteosat-9 IODC, genuinely live, 15-min cadence ─────────────
+
+function GeosatCell() {
+  const [refreshedAt, setRefreshedAt] = useState(() => Date.now())
+  const [failed, setFailed] = useState(false)
+
+  useEffect(() => {
+    const iv = setInterval(() => {
+      setFailed(false)
+      setRefreshedAt(Date.now())
+    }, GEOSAT_REFRESH_MS)
+    return () => clearInterval(iv)
+  }, [])
+
+  const layer = isGulfDaylight(refreshedAt) ? 'rgb_naturalenhncd' : 'ir108'
+  const src = `${eumetsatLiveUrl({ layer, ...GULF_BBOX, width: 640, height: 360 })}&_cb=${refreshedAt}`
+  const iso = new Date(refreshedAt).toISOString()
+
+  return (
+    <FeedCell title="GEOSAT IODC LIVE" caption={`MSG-9 IODC ${layer === 'ir108' ? 'IR 10.8µm' : 'NAT COLOR'} · ${iso.slice(0, 10)} ${iso.slice(11, 16)}Z`}>
+      {failed ? (
+        <OfflineCard label="SIGNAL LOST" />
+      ) : (
+        <img
+          src={src}
+          alt=""
+          onError={() => setFailed(true)}
+          style={{ position: 'absolute', inset: 0, width: '100%', height: '100%', objectFit: 'cover', display: 'block' }}
+          draggable={false}
+        />
+      )}
+    </FeedCell>
+  )
+}
+
+// ── 2. Reuters Hormuz vessel-traffic live stream ────────────────────────────
+
+function HormuzCamCell() {
+  return (
+    <FeedCell title="HORMUZ TRAFFIC CAM" caption="LIVE — courtesy Reuters">
+      <iframe
+        src={youtubeEmbedUrl(HORMUZ_LIVE_YOUTUBE_ID)}
+        title="Strait of Hormuz live"
+        allow="autoplay; encrypted-media"
+        style={{ position: 'absolute', inset: 0, width: '100%', height: '100%', border: 'none' }}
+      />
+    </FeedCell>
+  )
+}
+
+// ── 3. Synthetic drone soda-straw over a tracked contact ────────────────────
+
+function FmvCell() {
+  const units = useGameStore((s) => s.viewState.units)
+  const playerNation = useGameStore((s) => s.viewState.playerNation)
+  const gameTimestamp = useGameStore((s) => s.viewState.time.timestamp)
+  const tick = useGameStore((s) => s.viewState.time.tick)
+  const fmvTargetId = useUIStore((s) => s.fmvTargetId)
+  const setFmvTarget = useUIStore((s) => s.setFmvTarget)
+  const [failedTiles, setFailedTiles] = useState<Record<string, boolean>>({})
+
+  const contacts = units.filter(
+    (u) => u.nation !== playerNation
+      && u.status !== 'destroyed'
+      && (u.visibility === 'tracked' || u.visibility === 'identified'),
+  )
+  const target = contacts.find((u) => u.id === fmvTargetId) ?? null
+  const night = !isGulfDaylight(gameTimestamp)
+
+  const select = (
+    <select
+      value={target?.id ?? ''}
+      onChange={(e) => setFmvTarget(e.target.value === '' ? null : e.target.value)}
+      style={{
+        background: 'var(--bg-panel)',
+        border: '1px solid var(--border-default)',
+        borderRadius: 2,
+        color: 'var(--text-secondary)',
+        fontFamily: 'var(--font-mono)',
+        fontSize: '0.5rem',
+        maxWidth: '100%',
+        padding: '1px 2px',
+      }}
+    >
+      <option value="">— SELECT TARGET —</option>
+      {contacts.map((u) => (
+        <option key={u.id} value={u.id}>{u.name}</option>
+      ))}
+    </select>
+  )
+
+  if (!target) {
+    return (
+      <FeedCell title="ISR FMV" caption={select}>
+        <OfflineCard label="NO DOWNLINK — SELECT TARGET" />
+      </FeedCell>
+    )
+  }
+
+  const { xs, ys } = tileGrid(target.position.lng, target.position.lat, 15, 2, 2)
+
+  return (
+    <FeedCell title={`ISR FMV — ${target.name}`} caption={select}>
+      <div style={{ position: 'absolute', inset: 0, overflow: 'hidden' }}>
+        <div style={{
+          position: 'absolute',
+          inset: 0,
+          display: 'grid',
+          gridTemplateColumns: '1fr 1fr',
+          animation: 'lf-drift 38s linear infinite alternate',
+          filter: night ? 'invert(1) grayscale(1) contrast(1.4)' : 'saturate(0.8) contrast(1.05)',
+        }}>
+          {ys.map((ty) =>
+            xs.map((tx) => {
+              const k = `${tx}/${ty}`
+              return failedTiles[k] ? (
+                <div key={k} style={{ ...NOISE_BG, width: '100%', height: '100%' }} />
+              ) : (
+                <img
+                  key={k}
+                  src={esriImageryTileUrl(15, tx, ty)}
+                  alt=""
+                  onError={() => setFailedTiles((f) => ({ ...f, [k]: true }))}
+                  style={{ width: '100%', height: '100%', objectFit: 'cover', display: 'block' }}
+                  draggable={false}
+                />
+              )
+            }),
+          )}
+        </div>
+
+        {/* Crosshair */}
+        <div style={{ position: 'absolute', inset: 0, pointerEvents: 'none' }}>
+          <div style={{ position: 'absolute', left: '50%', top: '50%', width: 1, height: 30, background: 'rgba(255,255,255,0.7)', transform: 'translate(-50%, -50%)' }} />
+          <div style={{ position: 'absolute', left: '50%', top: '50%', width: 30, height: 1, background: 'rgba(255,255,255,0.7)', transform: 'translate(-50%, -50%)' }} />
+          <div style={{ position: 'absolute', left: '50%', top: '50%', width: 44, height: 44, border: '1px solid rgba(255,255,255,0.3)', transform: 'translate(-50%, -50%)' }} />
+        </div>
+
+        {/* Telemetry burn-ins */}
+        <Burn style={{ top: 4, left: 5 }}>
+          {`${Math.abs(target.position.lat).toFixed(4)}${target.position.lat >= 0 ? 'N' : 'S'} ${Math.abs(target.position.lng).toFixed(4)}${target.position.lng >= 0 ? 'E' : 'W'}`}
+        </Burn>
+        <Burn style={{ top: 4, right: 5, display: 'flex', alignItems: 'center', gap: 4 }}>
+          <span style={{ width: 5, height: 5, borderRadius: '50%', background: '#e84545', animation: 'lf-rec 1.4s ease-in-out infinite' }} />
+          REC
+        </Burn>
+        <Burn style={{ bottom: 4, left: 5 }}>ALT 18500FT · SLANT 12.4KM{night ? ' · IR' : ' · EO'}</Burn>
+        <Burn style={{ bottom: 4, right: 5 }}>{formatDtg(tick)}</Burn>
+
+        <div style={SCANLINE_OVERLAY} />
+      </div>
+    </FeedCell>
+  )
+}
+
+function Burn({ style, children }: { style: CSSProperties; children: ReactNode }) {
+  return (
+    <div style={{ position: 'absolute', color: '#e6e6e6', fontSize: '0.5rem', letterSpacing: '0.08em', textShadow: '0 0 3px #000', pointerEvents: 'none', ...style }}>
+      {children}
+    </div>
+  )
+}
+
+// ── 4. airplanes.live — real ADS-B over the Gulf ────────────────────────────
+
+interface AdsbTrack {
+  callsign: string
+  alt: string
+  gs: string
+}
+
+function AdsbCell() {
+  const [tracks, setTracks] = useState<AdsbTrack[] | null>(null)
+  const [total, setTotal] = useState(0)
+  const [failed, setFailed] = useState(false)
+
+  useEffect(() => {
+    let alive = true
+    const poll = async () => {
+      try {
+        const res = await fetch(adsbLiveUrl(ADSB_CENTER.lat, ADSB_CENTER.lon, ADSB_CENTER.radiusNm))
+        if (!res.ok) throw new Error(`adsb ${res.status}`)
+        const data = await res.json() as { ac?: Record<string, unknown>[] }
+        if (!alive) return
+        const ac = Array.isArray(data.ac) ? data.ac : []
+        const withDist = ac
+          .filter((a) => typeof a.lat === 'number' && typeof a.lon === 'number')
+          .map((a) => ({
+            a,
+            d: ((a.lat as number) - ADSB_CENTER.lat) ** 2 + ((a.lon as number) - ADSB_CENTER.lon) ** 2,
+          }))
+          .sort((x, y) => x.d - y.d)
+          .slice(0, 10)
+        setTotal(ac.length)
+        setTracks(withDist.map(({ a }) => ({
+          callsign: (typeof a.flight === 'string' && a.flight.trim()) || (typeof a.hex === 'string' ? a.hex.toUpperCase() : '—'),
+          alt: a.alt_baro === 'ground' ? 'GND' : typeof a.alt_baro === 'number' ? `${a.alt_baro}` : '—',
+          gs: typeof a.gs === 'number' ? `${Math.round(a.gs)}` : '—',
+        })))
+        setFailed(false)
+      } catch {
+        if (alive) setFailed(true)
+      }
+    }
+    poll()
+    const iv = setInterval(poll, ADSB_POLL_INTERVAL_MS)
+    return () => { alive = false; clearInterval(iv) }
+  }, [])
+
+  return (
+    <FeedCell
+      title="ADS-B LIVE"
+      caption={failed ? 'FEED OFFLINE' : `${total} REAL TRACKS — LIVE ADS-B`}
+    >
+      {failed ? (
+        <OfflineCard label="FEED OFFLINE" />
+      ) : tracks === null ? (
+        <OfflineCard label="ACQUIRING…" />
+      ) : (
+        <div style={{ position: 'absolute', inset: 0, overflowY: 'auto', padding: '3px 6px', fontSize: '0.5rem', color: 'var(--text-secondary)' }}>
+          <div style={{ display: 'grid', gridTemplateColumns: '1fr 60px 48px', gap: 2, color: 'var(--text-muted)', letterSpacing: '0.1em', marginBottom: 1 }}>
+            <span>CALLSIGN</span><span style={{ textAlign: 'right' }}>ALT FT</span><span style={{ textAlign: 'right' }}>GS KT</span>
+          </div>
+          {tracks.length === 0 && (
+            <div style={{ color: 'var(--text-muted)', padding: '8px 0', textAlign: 'center' }}>NO TRAFFIC IN BOX</div>
+          )}
+          {tracks.map((t, i) => (
+            <div key={`${t.callsign}-${i}`} style={{ display: 'grid', gridTemplateColumns: '1fr 60px 48px', gap: 2, padding: '0.5px 0' }}>
+              <span style={{ color: 'var(--text-primary)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>{t.callsign}</span>
+              <span style={{ textAlign: 'right' }}>{t.alt}</span>
+              <span style={{ textAlign: 'right' }}>{t.gs}</span>
+            </div>
+          ))}
+        </div>
+      )}
+    </FeedCell>
+  )
+}
diff --git a/src/components/intel/OsintTicker.tsx b/src/components/intel/OsintTicker.tsx
new file mode 100644
index 0000000..7696bb0
--- /dev/null
+++ b/src/components/intel/OsintTicker.tsx
@@ -0,0 +1,60 @@
+import { useEffect, useState } from 'react'
+import { useOsintFeed } from '@/intel/osint-feed'
+import { useUIStore } from '@/store/ui-store'
+
+const CYCLE_MS = 6_000
+
+/** One-line OSINT crawl just above the AlertFeed; click opens the INTEL panel */
+export default function OsintTicker() {
+  const posts = useOsintFeed()
+  const toggleIntel = useUIStore((s) => s.toggleIntel)
+  const [cursor, setCursor] = useState(0)
+
+  const latest = posts.slice(0, 3)
+
+  useEffect(() => {
+    if (latest.length < 2) return
+    const iv = setInterval(() => setCursor((c) => c + 1), CYCLE_MS)
+    return () => clearInterval(iv)
+  }, [latest.length])
+
+  if (latest.length === 0) return null
+  const post = latest[cursor % latest.length]
+
+  return (
+    <div
+      onClick={toggleIntel}
+      title="Open INTEL panel"
+      style={{
+        position: 'absolute',
+        bottom: 40,
+        left: 12,
+        width: 240,
+        background: 'rgba(13, 17, 23, 0.7)',
+        border: '1px solid var(--border-default)',
+        borderRadius: 'var(--panel-radius)',
+        padding: '3px 8px',
+        fontFamily: 'var(--font-mono)',
+        fontSize: '0.55rem',
+        // Below the AlertFeed so its expanded log covers the ticker, not vice versa
+        zIndex: 9,
+        cursor: 'pointer',
+        display: 'flex',
+        alignItems: 'center',
+        gap: 6,
+        backdropFilter: 'blur(4px)',
+        opacity: 0.85,
+      }}
+    >
+      <span style={{ color: 'var(--text-muted)', textTransform: 'uppercase', fontWeight: 600, flexShrink: 0, letterSpacing: '0.08em' }}>
+        OSINT
+      </span>
+      <span style={{ color: post.color, fontWeight: 600, flexShrink: 0 }}>
+        {post.handle}
+      </span>
+      <span style={{ color: 'var(--text-secondary)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', flex: 1 }}>
+        {post.text}
+      </span>
+    </div>
+  )
+}
diff --git a/src/components/intel/imagery.ts b/src/components/intel/imagery.ts
new file mode 100644
index 0000000..beaf7ed
--- /dev/null
+++ b/src/components/intel/imagery.ts
@@ -0,0 +1,59 @@
+import type { CSSProperties } from 'react'
+import { lonLatToTile } from '@/data/feeds'
+
+export const SCENARIO_START_UTC_MS = Date.UTC(2026, 5, 15, 6, 0, 0)
+
+const MONTHS = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']
+
+/** Military date-time group from a game tick (1 tick = 1 game second): DDHHMMZ MMM YY */
+export function formatDtg(tick: number): string {
+  const d = new Date(SCENARIO_START_UTC_MS + tick * 1000)
+  const p = (n: number) => String(n).padStart(2, '0')
+  return `${p(d.getUTCDate())}${p(d.getUTCHours())}${p(d.getUTCMinutes())}Z ${MONTHS[d.getUTCMonth()]} ${String(d.getUTCFullYear()).slice(2)}`
+}
+
+/** Gulf local hour (UTC+3.5) for a UTC epoch ms — gates day/night imagery looks */
+export function gulfLocalHour(utcMs: number): number {
+  return (new Date(utcMs).getUTCHours() + new Date(utcMs).getUTCMinutes() / 60 + 3.5) % 24
+}
+
+export function isGulfDaylight(utcMs: number): boolean {
+  const h = gulfLocalHour(utcMs)
+  return h >= 6 && h < 17
+}
+
+/**
+ * Tile rows/cols centered on a point. Even-sized axes pick the half of the
+ * target tile the point falls in (via z+1) so it lands near the grid middle —
+ * uses only lonLatToTile, no fractional math.
+ */
+export function tileGrid(lon: number, lat: number, z: number, cols: number, rows: number): { xs: number[]; ys: number[] } {
+  const { x, y } = lonLatToTile(lon, lat, z)
+  const half = lonLatToTile(lon, lat, z + 1)
+  const start = (c: number, count: number, inFirstHalf: boolean) =>
+    count % 2 === 0 ? (inFirstHalf ? c - count / 2 : c - count / 2 + 1) : c - Math.floor(count / 2)
+  const xLeft = start(x, cols, half.x === 2 * x)
+  const yTop = start(y, rows, half.y === 2 * y)
+  return {
+    xs: Array.from({ length: cols }, (_, i) => xLeft + i),
+    ys: Array.from({ length: rows }, (_, i) => yTop + i),
+  }
+}
+
+/** TV-static backdrop for failed feeds / missing tiles */
+export const NOISE_BG: CSSProperties = {
+  background:
+    'repeating-linear-gradient(0deg, #0a0c10 0px, #161a20 1px, #0a0c10 2px, #1c2026 3px), ' +
+    'repeating-linear-gradient(90deg, rgba(255,255,255,0.03) 0px, rgba(0,0,0,0.06) 2px)',
+}
+
+/** Film-grain/scanline overlay for imagery dressing — pointer-events none */
+export const SCANLINE_OVERLAY: CSSProperties = {
+  position: 'absolute',
+  inset: 0,
+  pointerEvents: 'none',
+  background:
+    'repeating-linear-gradient(0deg, rgba(0,0,0,0.12) 0px, transparent 1px, transparent 3px), ' +
+    'repeating-linear-gradient(90deg, rgba(255,255,255,0.015) 0px, transparent 2px, transparent 5px)',
+  mixBlendMode: 'overlay',
+}
diff --git a/src/components/map/DeckOverlay.tsx b/src/components/map/DeckOverlay.tsx
index 61d4bd1..27be577 100644
--- a/src/components/map/DeckOverlay.tsx
+++ b/src/components/map/DeckOverlay.tsx
@@ -1,16 +1,120 @@
-import { useEffect } from 'react'
-import { useControl } from 'react-map-gl/maplibre'
+import { useEffect, useMemo, useState } from 'react'
+import { useControl, useMap } from 'react-map-gl/maplibre'
 import { MapboxOverlay } from '@deck.gl/mapbox'
 import type { MapboxOverlayProps } from '@deck.gl/mapbox'
+import { createIntelMapLayers } from './layers/IntelLayers'
+import { createEffectsLayers, KILL_ANIM_MS } from './layers/EffectsLayers'
+import { useGameStore } from '@/store/game-store'
+import { useUIStore } from '@/store/ui-store'
+import { useMapIntelStore } from '@/store/map-intel-store'
+
+const CALLSIGN_MIN_ZOOM = 6.5
 
 export default function DeckOverlay(props: MapboxOverlayProps) {
+  const units = useGameStore((s) => s.viewState.units)
+  const tick = useGameStore((s) => s.viewState.time.tick)
+  const playerNation = useGameStore((s) => s.viewState.playerNation)
+  const intel = useGameStore((s) => s.viewState.intel)
+  const eventLog = useGameStore((s) => s.eventLog)
+  const selectedUnitId = useUIStore((s) => s.selectedUnitId)
+  const intelOverlays = useMapIntelStore((s) => s.intelOverlays)
+  const adsbLive = useMapIntelStore((s) => s.adsbLive)
+  const adsbAircraft = useMapIntelStore((s) => s.adsbAircraft)
+  const staleSince = useMapIntelStore((s) => s.staleSince)
+  const syncStaleContacts = useMapIntelStore((s) => s.syncStaleContacts)
+  const killMarkers = useMapIntelStore((s) => s.killMarkers)
+  const trackHistory = useMapIntelStore((s) => s.trackHistory)
+  const ingestKillEvents = useMapIntelStore((s) => s.ingestKillEvents)
+  const sampleTrackHistory = useMapIntelStore((s) => s.sampleTrackHistory)
+
+  useEffect(() => {
+    syncStaleContacts(units, tick, playerNation)
+  }, [units, tick, playerNation, syncStaleContacts])
+
+  useEffect(() => {
+    ingestKillEvents(eventLog, units)
+  }, [eventLog, units, ingestKillEvents])
+
+  useEffect(() => {
+    sampleTrackHistory(units, tick, playerNation)
+  }, [units, tick, playerNation, sampleTrackHistory])
+
+  // Real-time clock for the kill animations — runs only while a marker is in its
+  // ~10 s window, so an idle map costs nothing
+  const [effectsNowMs, setEffectsNowMs] = useState(() => performance.now())
+  useEffect(() => {
+    if (killMarkers.length === 0) return
+    const newestMs = killMarkers[killMarkers.length - 1].addedAtMs
+    if (performance.now() - newestMs >= KILL_ANIM_MS) return
+    let raf = 0
+    let lastSet = 0
+    const loop = (t: number) => {
+      if (t - lastSet >= 33) {
+        lastSet = t
+        setEffectsNowMs(performance.now())
+      }
+      if (performance.now() - newestMs < KILL_ANIM_MS) {
+        raf = requestAnimationFrame(loop)
+      } else {
+        setEffectsNowMs(performance.now()) // settle on the fully-faded end state
+      }
+    }
+    raf = requestAnimationFrame(loop)
+    return () => cancelAnimationFrame(raf)
+  }, [killMarkers])
+
+  // Quantized zoom read (boolean) so map panning doesn't churn re-renders
+  const { current: mapRef } = useMap()
+  const [showCallsigns, setShowCallsigns] = useState(false)
+  useEffect(() => {
+    const map = mapRef?.getMap()
+    if (!map) return
+    const onMove = () => setShowCallsigns(map.getZoom() > CALLSIGN_MIN_ZOOM)
+    onMove()
+    map.on('move', onMove)
+    return () => { map.off('move', onMove) }
+  }, [mapRef])
+
+  const selectedUnit = useMemo(
+    () => units.find((u) => u.id === selectedUnitId && u.nation === playerNation),
+    [units, selectedUnitId, playerNation],
+  )
+
+  const intelLayers = useMemo(
+    () => createIntelMapLayers({
+      intelOverlaysOn: intelOverlays,
+      adsbOn: adsbLive,
+      units,
+      playerNation,
+      tick,
+      staleSince,
+      selectedUnit,
+      taskings: intel?.taskings ?? [],
+      aircraft: adsbAircraft,
+      showCallsigns,
+    }),
+    [intelOverlays, adsbLive, units, playerNation, tick, staleSince, selectedUnit, intel, adsbAircraft, showCallsigns],
+  )
+
+  const effectsLayers = useMemo(
+    () => createEffectsLayers({ killMarkers, trackHistory, units, playerNation, nowMs: effectsNowMs }),
+    [killMarkers, trackHistory, units, playerNation, effectsNowMs],
+  )
+
+  // Intel layers prepend (draw beneath) the game layers passed by GameMap;
+  // effects sit between — above rings/overlays, below unit icons
+  const mergedProps = useMemo<MapboxOverlayProps>(
+    () => ({ ...props, layers: [...intelLayers, ...effectsLayers, ...(props.layers ?? [])] }),
+    [props, intelLayers, effectsLayers],
+  )
+
   const overlay = useControl<MapboxOverlay>(
     () => new MapboxOverlay({
-      ...props,
+      ...mergedProps,
       interleaved: false, // overlay mode — reliable picking
     }),
   )
-  overlay.setProps(props)
+  overlay.setProps(mergedProps)
 
   // The overlay canvas's first frame can composite as opaque black, hiding the
   // basemap; any later redraw clears correctly. The game starts paused, so without
diff --git a/src/components/map/GameMap.tsx b/src/components/map/GameMap.tsx
index da96afc..d2b4bff 100644
--- a/src/components/map/GameMap.tsx
+++ b/src/components/map/GameMap.tsx
@@ -19,7 +19,6 @@ import { createSupplyLineGeoJSON } from './layers/SupplyLineLayer'
 import { createShippingLaneGeoJSON } from './layers/ShippingLaneLayer'
 import { createMinefieldGeoJSON } from './layers/MinefieldLayer'
 import { ensureMainThreadGrid, getMainThreadGrid, getLOSPolygon } from './layers/LOSLayer'
-import { generateElevationOverlay } from './layers/ElevationOverlay'
 import InfoTooltip from './InfoTooltip'
 import MissileTracker from './MissileTracker'
 import { useUIStore } from '@/store/ui-store'
@@ -27,7 +26,9 @@ import { useGameStore } from '@/store/game-store'
 import { useStrikeStore } from '@/store/strike-store'
 import { useIntelStore } from '@/store/intel-store'
 import { useMenuStore } from '@/store/menu-store'
-import { getMapStyle } from '@/styles/map-providers'
+import { useMapIntelStore } from '@/store/map-intel-store'
+import { getMapStyle, HILLSHADE_LAYER_ID } from '@/styles/map-providers'
+import { gibsDailyTrueColorTiles, safeGibsDate } from '@/data/feeds'
 import { weaponSpecs } from '@/data/weapons/missiles'
 import { iranCatalog } from '@/data/catalog/iran-catalog'
 import { usaCatalog } from '@/data/catalog/usa-catalog'
@@ -40,6 +41,9 @@ const DEFAULT_VIEW = {
   bearing: 0,
 }
 
+const GIBS_SOURCE_ID = 'gibs-recon-mosaic'
+const GIBS_LAYER_ID = 'gibs-recon-mosaic-layer'
+
 interface CtxMenu {
   x: number
   y: number
@@ -124,13 +128,11 @@ export default function GameMap() {
     ensureMainThreadGrid().then(() => setGridReady(true)).catch(() => {})
   }, [])
 
-  // Generate elevation overlay image (static, computed once when grid is ready)
-  const elevationOverlay = useMemo(() => {
-    if (!gridReady || !showElevation) return null
-    const grid = getMainThreadGrid()
-    if (!grid) return null
-    return generateElevationOverlay(grid)
-  }, [gridReady, showElevation])
+  // Hillshade relief is on by default ("always on", roadmap A.1) — the map owns
+  // that default, not the store; ELV stays the off switch
+  useEffect(() => {
+    useUIStore.setState({ showElevation: true })
+  }, [])
 
   const showIntelCoverage = useUIStore((s) => s.showIntelCoverage)
 
@@ -208,11 +210,100 @@ export default function GameMap() {
       .filter(Boolean) as { poly: NonNullable<ReturnType<typeof getLOSPolygon>>; isEnemy: boolean }[]
   }, [losFilter, gridReady, units])
 
+  const [mapReady, setMapReady] = useState(false)
   const onLoad = useCallback(() => {
     const map = mapRef.current?.getMap()
     map?.resize()
+    setMapReady(true)
   }, [])
 
+  // DAILY RECON MOSAIC — GIBS VIIRS raster, toggled via map-intel-store.
+  // Imperative add/remove: style switches (SAT/MAP) wipe custom sources, so the
+  // styledata handler re-adds and re-anchors it below overlay-anchor.
+  const reconMosaic = useMapIntelStore((s) => s.reconMosaic)
+  useEffect(() => {
+    if (!reconMosaic || !mapReady) return
+    const map = mapRef.current?.getMap()
+    if (!map) return
+
+    const ensureMosaic = () => {
+      try {
+        if (!map.getSource(GIBS_SOURCE_ID)) {
+          const cfg = gibsDailyTrueColorTiles(safeGibsDate())
+          map.addSource(GIBS_SOURCE_ID, {
+            type: 'raster',
+            tiles: cfg.tiles,
+            tileSize: 256,
+            maxzoom: cfg.maxzoom,
+            attribution: cfg.attribution,
+          })
+        }
+        const anchor = map.getLayer('overlay-anchor') ? 'overlay-anchor' : undefined
+        if (!map.getLayer(GIBS_LAYER_ID)) {
+          map.addLayer({
+            id: GIBS_LAYER_ID,
+            type: 'raster',
+            source: GIBS_SOURCE_ID,
+            paint: {
+              'raster-opacity': 0.9,
+              'raster-fade-duration': 0,
+              'raster-saturation': -0.2,
+              'raster-brightness-max': 0.85,
+            },
+          }, anchor)
+        } else if (anchor) {
+          // Layers added later with beforeId=overlay-anchor (country fills) can land
+          // above the mosaic; re-anchor — the position check prevents styledata loops
+          const order = map.getStyle().layers?.map((l) => l.id) ?? []
+          const gibsIdx = order.indexOf(GIBS_LAYER_ID)
+          const anchorIdx = order.indexOf('overlay-anchor')
+          if (gibsIdx !== -1 && anchorIdx !== -1 && gibsIdx !== anchorIdx - 1) {
+            map.moveLayer(GIBS_LAYER_ID, 'overlay-anchor')
+          }
+        }
+      } catch {
+        // style mid-swap — the next styledata event retries
+      }
+    }
+
+    ensureMosaic()
+    map.on('styledata', ensureMosaic)
+    return () => {
+      map.off('styledata', ensureMosaic)
+      try {
+        if (map.getLayer(GIBS_LAYER_ID)) map.removeLayer(GIBS_LAYER_ID)
+        if (map.getSource(GIBS_SOURCE_ID)) map.removeSource(GIBS_SOURCE_ID)
+      } catch {
+        // map already torn down
+      }
+    }
+  }, [reconMosaic, mapReady])
+
+  // HILLSHADE RELIEF — the layer lives in both styles (default visible); the ELV
+  // toggle drives visibility. Style switches (SAT/MAP) reset layout props to the
+  // style default, so the styledata handler re-applies the user's choice.
+  useEffect(() => {
+    if (!mapReady) return
+    const map = mapRef.current?.getMap()
+    if (!map) return
+
+    const applyHillshade = () => {
+      try {
+        if (map.getLayer(HILLSHADE_LAYER_ID)) {
+          map.setLayoutProperty(HILLSHADE_LAYER_ID, 'visibility', showElevation ? 'visible' : 'none')
+        }
+      } catch {
+        // style mid-swap — the next styledata event retries
+      }
+    }
+
+    applyHillshade()
+    map.on('styledata', applyHillshade)
+    return () => {
+      map.off('styledata', applyHillshade)
+    }
+  }, [showElevation, mapReady])
+
   const onContextMenu = useCallback((e: MapLayerMouseEvent) => {
     e.preventDefault()
     if (selectedUnitId) {
@@ -449,7 +540,7 @@ export default function GameMap() {
         mapStyle={mapStyle}
         onLoad={onLoad}
         onMove={onMove}
-        onMouseMove={onMouseMove}
+        onMouseMove={showElevation ? onMouseMove : undefined}
         onContextMenu={onContextMenu}
         onClick={onMapClick}
         attributionControl={false}
@@ -468,29 +559,6 @@ export default function GameMap() {
           paint={{ 'background-color': 'rgba(0, 0, 0, 0)' }}
         />
 
-        {elevationOverlay && (
-          <Source
-            id="elevation-overlay"
-            type="image"
-            url={elevationOverlay.dataUrl}
-            coordinates={[
-              [elevationOverlay.bounds[0], elevationOverlay.bounds[3]], // top-left [west, north]
-              [elevationOverlay.bounds[2], elevationOverlay.bounds[3]], // top-right [east, north]
-              [elevationOverlay.bounds[2], elevationOverlay.bounds[1]], // bottom-right [east, south]
-              [elevationOverlay.bounds[0], elevationOverlay.bounds[1]], // bottom-left [west, south]
-            ]}
-          >
-            <Layer
-              id="elevation-raster"
-              type="raster"
-              paint={{
-                'raster-opacity': 0.6,
-                'raster-fade-duration': 0,
-              }}
-            />
-          </Source>
-        )}
-
         {supplyLines.length > 0 && (
           <Source id="supply-lines" type="geojson" data={supplyLineData}>
             <Layer
@@ -660,10 +728,12 @@ export default function GameMap() {
 
         {geoData && (
           <Source id="countries" type="geojson" data={geoData}>
+            {/* Fills anchor below the hillshade (opaque tint would bury the relief);
+                border/glow lines stay above it via overlay-anchor */}
             <Layer
               id="country-fill"
               type="fill"
-              beforeId="overlay-anchor"
+              beforeId={HILLSHADE_LAYER_ID}
               paint={{
                 'fill-color': ['match', ['get', 'iso_a3'],
                   'IRN', '#1a1520',
diff --git a/src/components/map/InfoTooltip.tsx b/src/components/map/InfoTooltip.tsx
index b6abb5c..8b5dde6 100644
--- a/src/components/map/InfoTooltip.tsx
+++ b/src/components/map/InfoTooltip.tsx
@@ -1,9 +1,13 @@
+import { useEffect, useState } from 'react'
 import { useUIStore } from '@/store/ui-store'
 import { useGameStore } from '@/store/game-store'
 import { weaponSpecs } from '@/data/weapons/missiles'
+import { UNIT_IMAGES, unitImageKey } from '@/data/unit-images'
 import type { ViewUnit } from '@/types/view'
 import type { Missile } from '@/types/game'
 
+const HOVER_DELAY_MS = 300
+
 interface InfoTooltipProps {
   x: number
   y: number
@@ -11,16 +15,28 @@ interface InfoTooltipProps {
 
 export default function InfoTooltip({ x, y }: InfoTooltipProps) {
   const hoveredId = useUIStore((s) => s.hoveredUnitId)
+  if (!hoveredId) return null
+  // key remounts on target change so the hover delay restarts per target
+  return <DelayedTooltip key={hoveredId} hoveredId={hoveredId} x={x} y={y} />
+}
+
+function DelayedTooltip({ hoveredId, x, y }: { hoveredId: string; x: number; y: number }) {
   const units = useGameStore((s) => s.viewState.units)
   const missiles = useGameStore((s) => s.viewState.missiles)
+  const [visible, setVisible] = useState(false)
 
-  if (hoveredId) {
-    const unit = units.find(u => u.id === hoveredId)
-    if (unit) return <UnitTooltip unit={unit} x={x} y={y} />
+  useEffect(() => {
+    const t = window.setTimeout(() => setVisible(true), HOVER_DELAY_MS)
+    return () => window.clearTimeout(t)
+  }, [])
 
-    const missile = missiles.find(m => m.id === hoveredId)
-    if (missile) return <MissileTooltipView missile={missile} x={x} y={y} />
-  }
+  if (!visible) return null
+
+  const unit = units.find(u => u.id === hoveredId)
+  if (unit) return <UnitTooltip unit={unit} x={x} y={y} />
+
+  const missile = missiles.find(m => m.id === hoveredId)
+  if (missile) return <MissileTooltipView missile={missile} x={x} y={y} />
 
   return null
 }
@@ -56,8 +72,24 @@ function MissileTooltipView({ missile, x, y }: { missile: Missile; x: number; y:
 function UnitTooltip({ unit, x, y }: { unit: ViewUnit; x: number; y: number }) {
   const detected = unit.visibility === 'detected'
   const identified = unit.visibility === 'identified'
+  const imageKey = identified ? unitImageKey(unit) : null
+  const image = imageKey ? UNIT_IMAGES[imageKey] : undefined
   return (
     <div style={tooltipStyle(x, y)}>
+      {image && (
+        <img
+          src={`/unit-images/${image.file}`}
+          alt={unit.name}
+          style={{
+            display: 'block',
+            width: '100%',
+            height: 80,
+            objectFit: 'cover',
+            borderRadius: 2,
+            marginBottom: 5,
+          }}
+        />
+      )}
       <div style={headerStyle}>{unit.name}</div>
       {unit.stale && <div style={staleBannerStyle}>TRACK LOST — LAST KNOWN POSITION</div>}
       <Row label="Nation" value={unit.nation.toUpperCase()} />
diff --git a/src/components/map/__tests__/ContextMenu.test.tsx b/src/components/map/__tests__/ContextMenu.test.tsx
index 7f7d017..ea855c5 100644
--- a/src/components/map/__tests__/ContextMenu.test.tsx
+++ b/src/components/map/__tests__/ContextMenu.test.tsx
@@ -45,6 +45,7 @@ function makeViewState(units: ViewUnit[]): GameViewState {
     warSupport: {},
     gameOver: null,
     objectives: [],
+    intel: { assets: [], agents: [], products: [], taskings: [], leakLevel: 0, paranoiaBand: 'LOW' as const, encryptionUpgradedUntilTick: null },
   }
 }
 
diff --git a/src/components/map/__tests__/InfoTooltip.test.tsx b/src/components/map/__tests__/InfoTooltip.test.tsx
index 5090f0b..d8bb4a2 100644
--- a/src/components/map/__tests__/InfoTooltip.test.tsx
+++ b/src/components/map/__tests__/InfoTooltip.test.tsx
@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest'
-import { render, screen } from '@testing-library/react'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { render, screen, act } from '@testing-library/react'
 import InfoTooltip from '../InfoTooltip'
 import { useGameStore } from '@/store/game-store'
 import { useUIStore } from '@/store/ui-store'
@@ -46,15 +46,47 @@ function setup(unit: ViewUnit) {
     warSupport: {},
     gameOver: null,
     objectives: [],
+    intel: { assets: [], agents: [], products: [], taskings: [], leakLevel: 0, paranoiaBand: 'LOW' as const, encryptionUpgradedUntilTick: null },
   } as GameViewState
   useGameStore.setState({ viewState })
   useUIStore.setState({ hoveredUnitId: unit.id })
   return render(<InfoTooltip x={100} y={100} />)
 }
 
+/** Hover-delay elapse — tooltip only appears 300ms after hover */
+function elapseHoverDelay() {
+  act(() => {
+    vi.advanceTimersByTime(300)
+  })
+}
+
+beforeEach(() => {
+  vi.useFakeTimers()
+})
+
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+describe('InfoTooltip hover delay', () => {
+  it('shows nothing until 300ms have elapsed', () => {
+    setup(makeUnit({ id: 'c0', name: 'Surface contact' }))
+    expect(screen.queryByText('Surface contact')).toBeNull()
+    act(() => {
+      vi.advanceTimersByTime(299)
+    })
+    expect(screen.queryByText('Surface contact')).toBeNull()
+    act(() => {
+      vi.advanceTimersByTime(1)
+    })
+    expect(screen.getByText('Surface contact')).toBeTruthy()
+  })
+})
+
 describe('InfoTooltip fog of war', () => {
   it('shows only identity and staleness for stale detected contacts', () => {
     setup(makeUnit({ id: 'c1', name: 'Surface contact', visibility: 'detected', stale: true }))
+    elapseHoverDelay()
     expect(screen.getByText('Surface contact')).toBeTruthy()
     expect(screen.getByText(/TRACK LOST/)).toBeTruthy()
     expect(screen.getByText('Type')).toBeTruthy()
@@ -65,6 +97,7 @@ describe('InfoTooltip fog of war', () => {
 
   it('shows condition but NO LOADOUT DATA and no ROE for tracked contacts', () => {
     setup(makeUnit({ id: 'c2', name: 'IRIS Sahand', visibility: 'tracked', health: 70, status: 'damaged' }))
+    elapseHoverDelay()
     expect(screen.getByText('Health')).toBeTruthy()
     expect(screen.getByText('70%')).toBeTruthy()
     expect(screen.getByText('NO LOADOUT DATA')).toBeTruthy()
@@ -78,9 +111,33 @@ describe('InfoTooltip fog of war', () => {
       name: 'IRIS Jamaran',
       weapons: [{ weaponId: 'mystery_missile', count: 4, maxCount: 8, reloadTimeSec: 60 }],
     }))
+    elapseHoverDelay()
     expect(screen.getByText('ROE')).toBeTruthy()
     expect(screen.getByText('mystery_missile')).toBeTruthy()
     expect(screen.getByText('4/8')).toBeTruthy()
     expect(screen.queryByText('NO LOADOUT DATA')).toBeNull()
   })
 })
+
+describe('InfoTooltip recognition photo', () => {
+  it('shows the class photo for identified units', () => {
+    setup(makeUnit({ id: 'c4', name: 'Bavar-373 (Tehran)', category: 'sam_site' }))
+    elapseHoverDelay()
+    const img = screen.getByAltText('Bavar-373 (Tehran)')
+    expect(img.getAttribute('src')).toBe('/unit-images/bavar373.jpg')
+  })
+
+  it('hides the photo below identified', () => {
+    setup(makeUnit({ id: 'c5', name: 'Bavar-373 (Tehran)', category: 'sam_site', visibility: 'tracked' }))
+    elapseHoverDelay()
+    expect(screen.getByText('Bavar-373 (Tehran)')).toBeTruthy()
+    expect(screen.queryByRole('img')).toBeNull()
+  })
+
+  it('renders no photo for units without imagery', () => {
+    setup(makeUnit({ id: 'c6', name: 'IRIS Jamaran' }))
+    elapseHoverDelay()
+    expect(screen.getByText('IRIS Jamaran')).toBeTruthy()
+    expect(screen.queryByRole('img')).toBeNull()
+  })
+})
diff --git a/src/components/map/layers/EffectsLayers.ts b/src/components/map/layers/EffectsLayers.ts
new file mode 100644
index 0000000..598847c
--- /dev/null
+++ b/src/components/map/layers/EffectsLayers.ts
@@ -0,0 +1,164 @@
+import { PathLayer, ScatterplotLayer, TextLayer } from '@deck.gl/layers'
+import type { Layer } from '@deck.gl/core'
+import type { ViewUnit } from '@/types/view'
+import type { KillMarker, TrackPoint } from '@/store/map-intel-store'
+
+/** Real-time length of the expanding-ring/blot phase; the faint X persists after */
+export const KILL_ANIM_MS = 10_000
+
+const MONO_FONT = 'JetBrains Mono, Fira Code, monospace'
+
+const TRAIL_MAX_RENDERED = 80
+const TRAIL_SEGMENTS = 4
+/** Per-segment alpha, newest → oldest */
+const TRAIL_SEGMENT_ALPHAS = [165, 115, 70, 35]
+const TRAIL_WIDTH_PX = 1.2
+
+const MUTED_NATION_COLORS: Record<string, [number, number, number]> = {
+  usa: [104, 128, 151],
+  iran: [142, 95, 95],
+}
+const MUTED_FALLBACK: [number, number, number] = [120, 124, 128]
+
+const KILL_RING_COLOR: [number, number, number] = [255, 235, 210]
+const KILL_BLOT_COLOR: [number, number, number] = [255, 244, 230]
+const KILL_X_COLOR: [number, number, number, number] = [170, 175, 180, 140]
+
+type Rgba = [number, number, number, number]
+
+function killProgress(m: KillMarker, nowMs: number): number {
+  return Math.min(1, Math.max(0, (nowMs - m.addedAtMs) / KILL_ANIM_MS))
+}
+
+/** DEFCON-style death sites: expanding ring + fading blot for ~10 s, persistent faint X */
+function createKillMarkerLayers(markers: KillMarker[], nowMs: number): Layer[] {
+  if (markers.length === 0) return []
+  const layers: Layer[] = [
+    new TextLayer<KillMarker>({
+      id: 'fx-kill-x',
+      data: markers,
+      getPosition: (d) => d.position,
+      getText: () => 'x',
+      getSize: 11,
+      getColor: KILL_X_COLOR,
+      fontFamily: MONO_FONT,
+      fontWeight: 700,
+      sizeUnits: 'pixels',
+      billboard: true,
+      pickable: false,
+    }),
+  ]
+
+  const animating = markers.filter((m) => nowMs - m.addedAtMs < KILL_ANIM_MS)
+  if (animating.length > 0) {
+    const animKey = Math.floor(nowMs)
+    layers.push(
+      new ScatterplotLayer<KillMarker>({
+        id: 'fx-kill-blots',
+        data: animating,
+        getPosition: (d) => d.position,
+        getRadius: (d) => 10 - killProgress(d, nowMs) * 4,
+        radiusUnits: 'pixels',
+        filled: true,
+        stroked: false,
+        getFillColor: (d) => [...KILL_BLOT_COLOR, Math.round((1 - killProgress(d, nowMs)) * 185)] as Rgba,
+        pickable: false,
+        updateTriggers: { getRadius: animKey, getFillColor: animKey },
+      }),
+      new ScatterplotLayer<KillMarker>({
+        id: 'fx-kill-rings',
+        data: animating,
+        getPosition: (d) => d.position,
+        getRadius: (d) => 6 + killProgress(d, nowMs) * 26,
+        radiusUnits: 'pixels',
+        filled: false,
+        stroked: true,
+        getLineColor: (d) => [...KILL_RING_COLOR, Math.round((1 - killProgress(d, nowMs)) * 200)] as Rgba,
+        lineWidthUnits: 'pixels',
+        getLineWidth: 1.5,
+        lineWidthMinPixels: 1,
+        pickable: false,
+        updateTriggers: { getRadius: animKey, getLineColor: animKey },
+      }),
+    )
+  }
+  return layers
+}
+
+interface TrailSegment {
+  path: [number, number][]
+  color: Rgba
+}
+
+/** Track-history trails for live enemy contacts, brightest at the newest end */
+function createTrailLayers(
+  trackHistory: Record<string, TrackPoint[]>,
+  units: ViewUnit[],
+  playerNation: string,
+): Layer[] {
+  const ids = Object.keys(trackHistory)
+  if (ids.length === 0) return []
+
+  const unitById = new Map(units.map((u) => [u.id, u]))
+  const segments: TrailSegment[] = []
+  let rendered = 0
+  for (const id of ids) {
+    if (rendered >= TRAIL_MAX_RENDERED) break
+    const unit = unitById.get(id)
+    if (!unit || unit.nation === playerNation || unit.status === 'destroyed') continue
+    if (unit.visibility !== 'tracked' && unit.visibility !== 'identified') continue
+    const buf = trackHistory[id]
+    if (!buf || buf.length === 0) continue
+
+    const points = buf.map((p) => p.position)
+    // Live head so the trail meets the moving icon between samples
+    if (!unit.stale) points.push([unit.position.lng, unit.position.lat])
+    const n = points.length
+    if (n < 2) continue
+    rendered++
+
+    const base = MUTED_NATION_COLORS[unit.nation] ?? MUTED_FALLBACK
+    const chunk = Math.max(1, Math.ceil((n - 1) / TRAIL_SEGMENTS))
+    let end = n - 1
+    let segIdx = 0
+    while (end > 0 && segIdx < TRAIL_SEGMENTS) {
+      const start = Math.max(0, end - chunk)
+      segments.push({
+        path: points.slice(start, end + 1),
+        color: [...base, TRAIL_SEGMENT_ALPHAS[segIdx]] as Rgba,
+      })
+      end = start
+      segIdx++
+    }
+  }
+  if (segments.length === 0) return []
+
+  return [
+    new PathLayer<TrailSegment>({
+      id: 'fx-track-trails',
+      data: segments,
+      getPath: (d) => d.path,
+      getColor: (d) => d.color,
+      widthUnits: 'pixels',
+      getWidth: TRAIL_WIDTH_PX,
+      widthMinPixels: 1,
+      pickable: false,
+    }),
+  ]
+}
+
+export interface EffectsLayerInputs {
+  killMarkers: KillMarker[]
+  trackHistory: Record<string, TrackPoint[]>
+  units: ViewUnit[]
+  playerNation: string
+  /** Real-time clock (performance.now) driving the kill animations */
+  nowMs: number
+}
+
+export function createEffectsLayers(opts: EffectsLayerInputs): Layer[] {
+  return [
+    ...createTrailLayers(opts.trackHistory, opts.units, opts.playerNation),
+    ...createKillMarkerLayers(opts.killMarkers, opts.nowMs),
+  ]
+}
diff --git a/src/components/map/layers/ElevationOverlay.ts b/src/components/map/layers/ElevationOverlay.ts
deleted file mode 100644
index 3642fca..0000000
--- a/src/components/map/layers/ElevationOverlay.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-import { ElevationGrid } from '@/engine/systems/elevation'
-
-/**
- * ElevationOverlay — generates a semi-transparent canvas image from the
- * elevation grid, suitable for use as a MapLibre raster image source.
- *
- * The canvas paints each grid cell as a single pixel, colored by elevation:
- *   - Sea/water (<=0): transparent
- *   - Low (0-500m): dark green → yellow-green
- *   - Medium (500-1500m): yellow → orange
- *   - High (1500-3000m): orange → red-brown
- *   - Very high (3000m+): red-brown → white
- *
- * Returns a data URL and the geographic bounds for the raster source.
- */
-
-interface ElevationOverlayResult {
-  dataUrl: string
-  bounds: [number, number, number, number] // [west, south, east, north]
-}
-
-/** Map an elevation value (meters) to an RGBA color. */
-function elevationToColor(elev: number): [number, number, number, number] {
-  if (elev <= 0) return [0, 0, 0, 0] // transparent for water/sea
-
-  // Normalize to color bands
-  if (elev <= 200) {
-    // Low terrain: dark olive-green
-    const t = elev / 200
-    return [
-      Math.round(20 + t * 40),  // 20→60
-      Math.round(40 + t * 50),  // 40→90
-      Math.round(15 + t * 15),  // 15→30
-      140,
-    ]
-  }
-  if (elev <= 600) {
-    // Low-medium: olive → tan
-    const t = (elev - 200) / 400
-    return [
-      Math.round(60 + t * 80),   // 60→140
-      Math.round(90 + t * 30),   // 90→120
-      Math.round(30 + t * 30),   // 30→60
-      150,
-    ]
-  }
-  if (elev <= 1500) {
-    // Medium: tan → brown
-    const t = (elev - 600) / 900
-    return [
-      Math.round(140 + t * 20),  // 140→160
-      Math.round(120 - t * 40),  // 120→80
-      Math.round(60 - t * 20),   // 60→40
-      160,
-    ]
-  }
-  if (elev <= 3000) {
-    // High: brown → reddish-brown
-    const t = (elev - 1500) / 1500
-    return [
-      Math.round(160 + t * 40),  // 160→200
-      Math.round(80 - t * 30),   // 80→50
-      Math.round(40 + t * 20),   // 40→60
-      170,
-    ]
-  }
-  // Very high (>3000m): reddish → light gray/white peaks
-  const t = Math.min(1, (elev - 3000) / 2500)
-  return [
-    Math.round(200 + t * 55),  // 200→255
-    Math.round(50 + t * 180),  // 50→230
-    Math.round(60 + t * 170),  // 60→230
-    180,
-  ]
-}
-
-let cachedResult: ElevationOverlayResult | null = null
-
-/**
- * Generate the elevation overlay canvas image.
- * Caches the result since the grid is static.
- */
-export function generateElevationOverlay(grid: ElevationGrid): ElevationOverlayResult {
-  if (cachedResult) return cachedResult
-
-  const rows = grid.numRows
-  const cols = grid.numCols
-  const data = grid.data
-  const bounds = grid.bounds
-
-  const canvas = document.createElement('canvas')
-  canvas.width = cols
-  canvas.height = rows
-
-  const ctx = canvas.getContext('2d')!
-  const imageData = ctx.createImageData(cols, rows)
-  const pixels = imageData.data
-
-  // The grid is stored south-to-north (row 0 = southernmost),
-  // but canvas Y=0 is the top. So we flip vertically.
-  for (let row = 0; row < rows; row++) {
-    const canvasY = rows - 1 - row // flip: grid row 0 (south) → canvas bottom
-    for (let col = 0; col < cols; col++) {
-      const elev = data[row * cols + col]
-      const [r, g, b, a] = elevationToColor(elev)
-      const idx = (canvasY * cols + col) * 4
-      pixels[idx] = r
-      pixels[idx + 1] = g
-      pixels[idx + 2] = b
-      pixels[idx + 3] = a
-    }
-  }
-
-  ctx.putImageData(imageData, 0, 0)
-
-  cachedResult = {
-    dataUrl: canvas.toDataURL(),
-    bounds: [bounds.lngMin, bounds.latMin, bounds.lngMax, bounds.latMax],
-  }
-
-  return cachedResult
-}
diff --git a/src/components/map/layers/IntelLayers.ts b/src/components/map/layers/IntelLayers.ts
new file mode 100644
index 0000000..2c78d56
--- /dev/null
+++ b/src/components/map/layers/IntelLayers.ts
@@ -0,0 +1,280 @@
+import { LineLayer, PathLayer, ScatterplotLayer, TextLayer } from '@deck.gl/layers'
+import type { Layer } from '@deck.gl/core'
+import type { ViewUnit } from '@/types/view'
+import type { SatTasking } from '@/types/game'
+import type { AdsbAircraft } from '@/store/map-intel-store'
+
+const MONO_FONT = 'JetBrains Mono, Fira Code, monospace'
+const TEXT_OUTLINE: [number, number, number, number] = [13, 17, 23, 220]
+
+const TICKS_PER_GAME_MINUTE = 60
+const AOU_MAX_RADIUS_KM = 60
+const TASKING_SWATH_KM = 60
+const ADSB_HEADING_TICK_KM = 3.5
+
+const AOU_AMBER: [number, number, number, number] = [212, 168, 84, 128]
+const SENSOR_CYAN: [number, number, number, number] = [64, 224, 240, 200]
+const SENSOR_CYAN_DIM: [number, number, number, number] = [64, 224, 240, 90]
+const SWATH_WHITE: [number, number, number, number] = [235, 235, 235, 130]
+const ADSB_GRAY: [number, number, number, number] = [168, 174, 180, 153]
+
+const RING_FADE_MS = 250
+/** Entering ring vertices start fully transparent → 250 ms fade-in */
+const fadeInEnter = (to: number[]) => [to[0], to[1], to[2], 0]
+
+type LngLat = [number, number]
+
+const KM_PER_DEG_LAT = 110.574
+const KM_PER_DEG_LON_EQ = 111.32
+
+function offsetKm(lng: number, lat: number, eastKm: number, northKm: number): LngLat {
+  const dLat = northKm / KM_PER_DEG_LAT
+  const dLng = eastKm / (KM_PER_DEG_LON_EQ * Math.cos((lat * Math.PI) / 180))
+  return [lng + dLng, lat + dLat]
+}
+
+function circlePath(lng: number, lat: number, radiusKm: number, segments = 72): LngLat[] {
+  const pts: LngLat[] = []
+  for (let i = 0; i <= segments; i++) {
+    const a = (i / segments) * Math.PI * 2
+    pts.push(offsetKm(lng, lat, Math.sin(a) * radiusKm, Math.cos(a) * radiusKm))
+  }
+  return pts
+}
+
+// Dashed ring as separate short arcs — PathStyleExtension is not a dependency
+function dashedCirclePaths(lng: number, lat: number, radiusKm: number, dashes = 40): LngLat[][] {
+  const paths: LngLat[][] = []
+  const slot = (Math.PI * 2) / dashes
+  for (let i = 0; i < dashes; i++) {
+    const start = i * slot
+    const arc: LngLat[] = []
+    for (let j = 0; j <= 3; j++) {
+      const a = start + (j / 3) * slot * 0.55
+      arc.push(offsetKm(lng, lat, Math.sin(a) * radiusKm, Math.cos(a) * radiusKm))
+    }
+    paths.push(arc)
+  }
+  return paths
+}
+
+export function aouRadiusKm(minutesStale: number): number {
+  return Math.min(AOU_MAX_RADIUS_KM, 4 + minutesStale * 0.5)
+}
+
+/** Mirrors the engine's elevationRangeBonus: +50% radar range at 10 km of antenna height */
+export function effectiveRadarRangeKm(rangeKm: number, antennaHeightM: number): number {
+  return rangeKm * (1 + 0.5 * Math.min(1, Math.max(0, antennaHeightM) / 10000))
+}
+
+interface AouDatum {
+  id: string
+  position: LngLat
+  radiusM: number
+}
+
+/** Area-of-uncertainty rings: stale enemy contacts grow until refreshed */
+export function createAouLayers(
+  units: ViewUnit[],
+  staleSince: Record<string, number>,
+  tick: number,
+  playerNation: string,
+): Layer[] {
+  const data: AouDatum[] = []
+  for (const u of units) {
+    if (u.nation === playerNation || !u.stale || u.status === 'destroyed') continue
+    const since = staleSince[u.id]
+    const minutesStale = since === undefined ? 0 : Math.max(0, (tick - since) / TICKS_PER_GAME_MINUTE)
+    data.push({
+      id: u.id,
+      position: [u.position.lng, u.position.lat],
+      radiusM: aouRadiusKm(minutesStale) * 1000,
+    })
+  }
+  // Layer persists with empty data so new rings transition in instead of popping
+  return [
+    new ScatterplotLayer<AouDatum>({
+      id: 'intel-aou-rings',
+      data,
+      getPosition: (d) => d.position,
+      getRadius: (d) => d.radiusM,
+      radiusUnits: 'meters',
+      filled: false,
+      stroked: true,
+      // function accessor: constant-valued attributes don't repack on data change,
+      // which would skip the enter transition for new rings
+      getLineColor: () => AOU_AMBER,
+      lineWidthUnits: 'pixels',
+      getLineWidth: 1,
+      lineWidthMinPixels: 1,
+      pickable: false,
+      transitions: {
+        getLineColor: { duration: RING_FADE_MS, enter: fadeInEnter },
+        getRadius: RING_FADE_MS,
+      },
+    }),
+  ]
+}
+
+/** Radar rings for the selected own unit: solid at effective range, dashed at nominal when boosted.
+ *  Both layers persist with empty data so a new selection's rings fade in instead of popping. */
+export function createSensorRingLayers(selected: ViewUnit | undefined): Layer[] {
+  const solid: { path: LngLat[] }[] = []
+  const dashed: { path: LngLat[] }[] = []
+  if (selected && selected.emcon !== true && selected.status !== 'destroyed') {
+    const { lng, lat } = selected.position
+    for (const radar of (selected.sensors ?? []).filter((s) => s.type === 'radar')) {
+      const effective = effectiveRadarRangeKm(radar.range_km, radar.antenna_height_m ?? 15)
+      solid.push({ path: circlePath(lng, lat, effective) })
+      // High-sited radars overshoot their nominal radius — show the baseline dashed
+      if (effective > radar.range_km * 1.02) {
+        for (const path of dashedCirclePaths(lng, lat, radar.range_km, 48)) dashed.push({ path })
+      }
+    }
+  }
+
+  return [
+    new PathLayer<{ path: LngLat[] }>({
+      id: 'intel-sensor-ring-horizon',
+      data: solid,
+      getPath: (d) => d.path,
+      getColor: () => SENSOR_CYAN,
+      widthUnits: 'pixels',
+      getWidth: 1,
+      widthMinPixels: 1,
+      pickable: false,
+      transitions: { getColor: { duration: RING_FADE_MS, enter: fadeInEnter } },
+    }),
+    new PathLayer<{ path: LngLat[] }>({
+      id: 'intel-sensor-ring-nominal',
+      data: dashed,
+      getPath: (d) => d.path,
+      getColor: () => SENSOR_CYAN_DIM,
+      widthUnits: 'pixels',
+      getWidth: 1,
+      widthMinPixels: 1,
+      pickable: false,
+      transitions: { getColor: { duration: RING_FADE_MS, enter: fadeInEnter } },
+    }),
+  ]
+}
+
+/** Queued satellite taskings: 60 km dashed AOI ring + PASS QUEUED tag */
+export function createTaskingSwathLayers(taskings: SatTasking[]): Layer[] {
+  if (taskings.length === 0) return []
+  const ringPaths = taskings.flatMap((t) =>
+    dashedCirclePaths(t.target.lng, t.target.lat, TASKING_SWATH_KM, 48).map((path) => ({ path })),
+  )
+  return [
+    new PathLayer<{ path: LngLat[] }>({
+      id: 'intel-tasking-swaths',
+      data: ringPaths,
+      getPath: (d) => d.path,
+      getColor: SWATH_WHITE,
+      widthUnits: 'pixels',
+      getWidth: 1,
+      widthMinPixels: 1,
+      pickable: false,
+    }),
+    new TextLayer<SatTasking>({
+      id: 'intel-tasking-labels',
+      data: taskings,
+      getPosition: (t) => [t.target.lng, t.target.lat],
+      getText: () => 'PASS QUEUED',
+      getSize: 10,
+      getColor: [235, 235, 235, 190],
+      getPixelOffset: [0, -12],
+      fontFamily: MONO_FONT,
+      fontWeight: 700,
+      outlineWidth: 2,
+      outlineColor: TEXT_OUTLINE,
+      sizeUnits: 'pixels',
+      billboard: true,
+      pickable: false,
+    }),
+  ]
+}
+
+/** Live ADS-B traffic: ambient gray dots + heading ticks, callsigns when zoomed in */
+export function createAdsbLayers(aircraft: AdsbAircraft[], showCallsigns: boolean): Layer[] {
+  if (aircraft.length === 0) return []
+  const layers: Layer[] = [
+    new ScatterplotLayer<AdsbAircraft>({
+      id: 'intel-adsb-aircraft',
+      data: aircraft,
+      getPosition: (d) => [d.lon, d.lat],
+      getRadius: 2.5,
+      radiusUnits: 'pixels',
+      getFillColor: ADSB_GRAY,
+      stroked: false,
+      pickable: false,
+    }),
+  ]
+
+  const withTrack = aircraft.filter((a) => a.track !== null)
+  if (withTrack.length > 0) {
+    layers.push(
+      new LineLayer<AdsbAircraft>({
+        id: 'intel-adsb-heading-ticks',
+        data: withTrack,
+        getSourcePosition: (d) => [d.lon, d.lat],
+        getTargetPosition: (d) => {
+          const rad = ((d.track ?? 0) * Math.PI) / 180
+          return offsetKm(d.lon, d.lat, Math.sin(rad) * ADSB_HEADING_TICK_KM, Math.cos(rad) * ADSB_HEADING_TICK_KM)
+        },
+        getColor: [168, 174, 180, 140],
+        getWidth: 1,
+        widthUnits: 'pixels',
+        pickable: false,
+      }),
+    )
+  }
+
+  if (showCallsigns) {
+    layers.push(
+      new TextLayer<AdsbAircraft>({
+        id: 'intel-adsb-callsigns',
+        data: aircraft.filter((a) => a.callsign !== ''),
+        getPosition: (d) => [d.lon, d.lat],
+        getText: (d) => d.callsign,
+        getSize: 9,
+        getColor: [168, 174, 180, 150],
+        getPixelOffset: [0, -10],
+        fontFamily: MONO_FONT,
+        fontWeight: 600,
+        outlineWidth: 2,
+        outlineColor: TEXT_OUTLINE,
+        sizeUnits: 'pixels',
+        billboard: true,
+        pickable: false,
+      }),
+    )
+  }
+  return layers
+}
+
+export interface IntelMapLayerInputs {
+  intelOverlaysOn: boolean
+  adsbOn: boolean
+  units: ViewUnit[]
+  playerNation: string
+  tick: number
+  staleSince: Record<string, number>
+  selectedUnit: ViewUnit | undefined
+  taskings: SatTasking[]
+  aircraft: AdsbAircraft[]
+  showCallsigns: boolean
+}
+
+export function createIntelMapLayers(opts: IntelMapLayerInputs): Layer[] {
+  const layers: Layer[] = []
+  if (opts.adsbOn) {
+    layers.push(...createAdsbLayers(opts.aircraft, opts.showCallsigns))
+  }
+  if (opts.intelOverlaysOn) {
+    layers.push(...createAouLayers(opts.units, opts.staleSince, opts.tick, opts.playerNation))
+    layers.push(...createTaskingSwathLayers(opts.taskings))
+    layers.push(...createSensorRingLayers(opts.selectedUnit))
+  }
+  return layers
+}
diff --git a/src/components/map/layers/LOSLayer.ts b/src/components/map/layers/LOSLayer.ts
index 90d26ef..98060bf 100644
--- a/src/components/map/layers/LOSLayer.ts
+++ b/src/components/map/layers/LOSLayer.ts
@@ -58,19 +58,42 @@ const NUM_RAYS = 360
 /** Step size along each ray in km */
 const STEP_KM = 2
 
+/** Coverage is shown against an air target this far above ground — high enough
+ *  that desert dunes and coastal berms don't shadow rays, only real mountains */
+const TARGET_AGL_M = 500
+
+/** Median window (± rays) — kills single-ray needles from elevation-grid aliasing */
+const SMOOTH_WINDOW = 2
+
+function medianOf(values: number[]): number {
+  const s = [...values].sort((a, b) => a - b)
+  return s[Math.floor(s.length / 2)]
+}
+
+/** Median-smooth ray distances; circular wrap for full rings, clamped for sectors */
+function smoothDistances(dists: number[], circular: boolean): number[] {
+  const n = dists.length
+  if (n < SMOOTH_WINDOW * 2 + 1) return dists
+  const out = new Array<number>(n)
+  for (let i = 0; i < n; i++) {
+    const window: number[] = []
+    for (let o = -SMOOTH_WINDOW; o <= SMOOTH_WINDOW; o++) {
+      const j = circular ? (i + o + n) % n : Math.min(n - 1, Math.max(0, i + o))
+      window.push(dists[j])
+    }
+    out[i] = medianOf(window)
+  }
+  return out
+}
+
 /**
- * Compute visible-area polygon by raycasting from a radar position.
- *
- * Algorithm:
- * 1. Cast 360 rays (1 per degree) from the radar position
- * 2. March outward in ~2km steps up to radarRange_km
- * 3. At each step, compute LOS line height accounting for earth curvature
- *    and compare against terrain elevation
- * 4. If terrain > LOS height, the ray is blocked at this distance
- * 5. Build a polygon from the 360 endpoint coordinates
+ * Compute the radar coverage polygon by raycasting from the radar position.
  *
- * Curvature drop at distance d: drop = d^2 / (2 * R * k)
- * where R = 6371km, k = 4/3 (atmospheric refraction)
+ * Matches the engine model (2026-06-11): coverage is the effective radius
+ * (nominal range × elevation bonus — height pays, no horizon cap), trimmed
+ * only where terrain physically shadows a low-flying air target (100 m AGL).
+ * Over open water this renders as a clean radius/sector arc; real mountain
+ * ranges still carve shadows.
  */
 export function computeLOSPolygon(input: LOSInput): Feature<Polygon> {
   const { position, radarRange_km, antennaHeight_m, elevationGrid, heading, sectorDeg } = input
@@ -79,7 +102,10 @@ export function computeLOSPolygon(input: LOSInput): Feature<Polygon> {
   const radarGroundElev = elevationGrid.getElevation(position.lat, position.lng)
   const radarAlt = radarGroundElev + antennaHeight_m
 
-  const numSteps = Math.max(1, Math.ceil(radarRange_km / STEP_KM))
+  // Mirrors detection.ts elevationRangeBonus: +50% range at 10 km of site+antenna height
+  const effectiveRange_km = radarRange_km * (1 + 0.5 * Math.min(1, Math.max(0, radarAlt) / 10000))
+
+  const numSteps = Math.max(1, Math.ceil(effectiveRange_km / STEP_KM))
 
   // Equirectangular stepping instead of turf destination() — this runs
   // ~rays x steps times per polygon and geodesic precision is irrelevant
@@ -87,12 +113,11 @@ export function computeLOSPolygon(input: LOSInput): Feature<Polygon> {
   const latPerKm = 1 / 110.574
   const lngPerKm = 1 / (111.32 * Math.cos((position.lat * Math.PI) / 180))
 
-  /** Raycast a single bearing and return the farthest visible point.
-   *  Shows terrain masking only — if a mountain peak between the radar
-   *  and a distant point is higher than the radar antenna, the ray is blocked.
-   *  Horizon/curvature is NOT applied here (it's target-altitude-dependent
-   *  and handled by the detection engine). */
-  const castRay = (bearing: number): [number, number] => {
+  /** Raycast a single bearing: farthest distance (km) where a TARGET_AGL_M
+   *  target is still visible over all terrain passed so far. Bare-ground
+   *  visibility was the old criterion — it let every 30 m coastal berm shadow
+   *  the whole ray and drew spiky fans instead of coverage arcs. */
+  const castRayDistance = (bearing: number): number => {
     const rad = (bearing * Math.PI) / 180
     const northPerKm = Math.cos(rad)
     const eastPerKm = Math.sin(rad)
@@ -101,47 +126,45 @@ export function computeLOSPolygon(input: LOSInput): Feature<Polygon> {
     let maxObstacleAngle = -Infinity // highest "look angle" to any terrain seen so far
 
     for (let step = 1; step <= numSteps; step++) {
-      const dist_km = (step / numSteps) * radarRange_km
+      const dist_km = (step / numSteps) * effectiveRange_km
 
       const lat = position.lat + dist_km * northPerKm * latPerKm
       const lng = position.lng + dist_km * eastPerKm * lngPerKm
       const terrainElev = elevationGrid.getElevation(lat, lng)
 
-      // Compute the angle from the radar to this terrain point
-      // angle = atan2(terrainElev - radarAlt, dist_km * 1000)
-      const elevDiff = terrainElev - radarAlt
-      const angle = Math.atan2(elevDiff, dist_km * 1000)
-
-      if (angle > maxObstacleAngle) {
-        // This point is visible (higher angle than any previous obstacle)
-        maxObstacleAngle = angle
+      // A target flying TARGET_AGL_M above this ground is visible if its look
+      // angle clears every terrain obstacle between it and the radar
+      const targetAngle = Math.atan2(terrainElev + TARGET_AGL_M - radarAlt, dist_km * 1000)
+      if (targetAngle >= maxObstacleAngle) {
         maxVisibleDist_km = dist_km
       }
-      // If angle <= maxObstacleAngle, a previous terrain peak blocks this point
-      // But we keep going — there might be higher terrain further out that IS visible
-      // For simplicity, break when blocked (conservative)
-      else if (elevDiff > 0 && angle <= maxObstacleAngle) {
-        break
+
+      // The bare terrain here shadows whatever sits behind it
+      const obstacleAngle = Math.atan2(terrainElev - radarAlt, dist_km * 1000)
+      if (obstacleAngle > maxObstacleAngle) {
+        maxObstacleAngle = obstacleAngle
       }
     }
 
-    if (maxVisibleDist_km <= 0) {
-      return origin
-    }
+    return maxVisibleDist_km
+  }
+
+  const pointAt = (bearing: number, dist_km: number): [number, number] => {
+    if (dist_km <= 0) return origin
+    const rad = (bearing * Math.PI) / 180
     return [
-      position.lng + maxVisibleDist_km * eastPerKm * lngPerKm,
-      position.lat + maxVisibleDist_km * northPerKm * latPerKm,
+      position.lng + dist_km * Math.sin(rad) * lngPerKm,
+      position.lat + dist_km * Math.cos(rad) * latPerKm,
     ]
   }
 
   const ring: [number, number][] = []
 
   if (sectorDeg >= 360) {
-    // Full circle — existing 360° behavior
-    for (let ray = 0; ray < NUM_RAYS; ray++) {
-      const bearing = (ray * 360) / NUM_RAYS
-      ring.push(castRay(bearing))
-    }
+    // Full circle
+    const bearings = Array.from({ length: NUM_RAYS }, (_, ray) => (ray * 360) / NUM_RAYS)
+    const dists = smoothDistances(bearings.map(castRayDistance), true)
+    for (let i = 0; i < bearings.length; i++) ring.push(pointAt(bearings[i], dists[i]))
     // Close the polygon ring
     ring.push(ring[0])
   } else {
@@ -150,14 +173,12 @@ export function computeLOSPolygon(input: LOSInput): Feature<Polygon> {
     const endAngle = heading + sectorDeg / 2
     const numRays = Math.max(3, Math.round(sectorDeg)) // ~1 ray per degree within sector
 
+    const bearings = Array.from({ length: numRays + 1 }, (_, i) => startAngle + (i / numRays) * (endAngle - startAngle))
+    const dists = smoothDistances(bearings.map(castRayDistance), false)
+
     // Start at radar position (center of wedge)
     ring.push(origin)
-
-    for (let i = 0; i <= numRays; i++) {
-      const azimuth = startAngle + (i / numRays) * (endAngle - startAngle)
-      ring.push(castRay(azimuth))
-    }
-
+    for (let i = 0; i < bearings.length; i++) ring.push(pointAt(bearings[i], dists[i]))
     // Close back to radar position
     ring.push(origin)
   }
diff --git a/src/components/map/layers/UnitLayer.ts b/src/components/map/layers/UnitLayer.ts
index 83fb8fd..d88a286 100644
--- a/src/components/map/layers/UnitLayer.ts
+++ b/src/components/map/layers/UnitLayer.ts
@@ -36,6 +36,8 @@ const TRACKED_ALPHA_FACTOR = 0.8
 const DETECTED_ALPHA_FACTOR = 0.75
 const DETECTED_STALE_ALPHA_FACTOR = 0.55
 const DESATURATION = 0.65
+const DECOY_DESATURATION = 0.85
+const DECOY_TAG_COLOR: [number, number, number, number] = [201, 178, 88, 220]
 
 /** Flattened render item — either a solo unit or a cluster rendered as its primary */
 interface RenderUnit {
@@ -51,6 +53,7 @@ interface RenderUnit {
   heading: number
   visibility: string
   stale: boolean
+  decoyRevealed: boolean
 }
 
 function toRenderUnit(item: ViewUnit | UnitCluster): RenderUnit {
@@ -75,6 +78,8 @@ function toRenderUnit(item: ViewUnit | UnitCluster): RenderUnit {
       heading: item.primary.heading,
       visibility,
       stale,
+      // Only tag a cluster DECOY when every member is a confirmed decoy
+      decoyRevealed: item.units.every(u => u.decoyRevealed === true),
     }
   }
   return {
@@ -90,20 +95,22 @@ function toRenderUnit(item: ViewUnit | UnitCluster): RenderUnit {
     heading: item.heading,
     visibility: item.visibility,
     stale: item.stale,
+    decoyRevealed: item.decoyRevealed === true,
   }
 }
 
-function desaturate([r, g, b]: [number, number, number]): [number, number, number] {
+function desaturate([r, g, b]: [number, number, number], amount = DESATURATION): [number, number, number] {
   const gray = 0.3 * r + 0.59 * g + 0.11 * b
   return [
-    Math.round(r + (gray - r) * DESATURATION),
-    Math.round(g + (gray - g) * DESATURATION),
-    Math.round(b + (gray - b) * DESATURATION),
+    Math.round(r + (gray - r) * amount),
+    Math.round(g + (gray - g) * amount),
+    Math.round(b + (gray - b) * amount),
   ]
 }
 
 function fogColor(d: RenderUnit): [number, number, number, number] {
-  const base = NATION_COLORS[d.nation] ?? [200, 200, 200]
+  const nationBase = NATION_COLORS[d.nation] ?? [200, 200, 200]
+  const base = d.decoyRevealed ? desaturate(nationBase, DECOY_DESATURATION) : nationBase
   const alpha = STATUS_ALPHA[d.status] ?? 255
   if (d.visibility === 'tracked') {
     return [...base, Math.round(alpha * TRACKED_ALPHA_FACTOR)] as [number, number, number, number]
@@ -192,7 +199,7 @@ export function createUnitLayer(
     },
     updateTriggers: {
       getSize: [selectedId, hoveredId, targetId],
-      getColor: [targetingMode, targetId, units.map(u => `${u.id}:${u.status}:${u.visibility}:${u.stale}`).join(',')],
+      getColor: [targetingMode, targetId, units.map(u => `${u.id}:${u.status}:${u.visibility}:${u.stale}:${u.decoyRevealed ? 'D' : ''}`).join(',')],
       getAngle: [units.map(u => `${u.id}:${u.heading}`).join(',')],
     },
   })
@@ -287,6 +294,25 @@ export function createUnitLayer(
     backgroundPadding: [4, 1],
   })
 
+  // Confirmed decoys: tag above the (desaturated) icon
+  const decoyItems = renderItems.filter(d => d.decoyRevealed)
+  const decoyTagLayer = new TextLayer<RenderUnit>({
+    id: 'decoy-tags',
+    data: decoyItems,
+    getPosition: (d) => [d.position.lng, d.position.lat],
+    getText: () => 'DECOY',
+    getSize: 9,
+    getColor: DECOY_TAG_COLOR,
+    getPixelOffset: [0, -26],
+    fontFamily: 'JetBrains Mono, Fira Code, monospace',
+    fontWeight: 700,
+    outlineWidth: 2,
+    outlineColor: [13, 17, 23, 220],
+    sizeUnits: 'pixels',
+    billboard: true,
+    pickable: false,
+  })
+
   // Invisible pick layer — much larger hit area (24px radius) for easy clicking
   const pickLayer = new ScatterplotLayer<RenderUnit>({
     id: 'unit-pick-layer',
@@ -313,10 +339,10 @@ export function createUnitLayer(
   })
 
   if (typeof window !== 'undefined' && window.innerWidth < 768) {
-    return [pickLayer, contactRingLayer, iconLayer, badgeLayer, contactBadgeLayer]
+    return [pickLayer, contactRingLayer, iconLayer, badgeLayer, contactBadgeLayer, decoyTagLayer]
   }
 
-  return [pickLayer, contactRingLayer, iconLayer, labelLayer, badgeLayer, contactBadgeLayer]
+  return [pickLayer, contactRingLayer, iconLayer, labelLayer, badgeLayer, contactBadgeLayer, decoyTagLayer]
 }
 
 /** Highlight ring around units recently spotted by satellite passes */
diff --git a/src/components/panels/IntelPanel.tsx b/src/components/panels/IntelPanel.tsx
index bf15817..fe8631b 100644
--- a/src/components/panels/IntelPanel.tsx
+++ b/src/components/panels/IntelPanel.tsx
@@ -1,268 +1,166 @@
-import { useState } from 'react'
+import { useState, type CSSProperties } from 'react'
 import Panel from '@/components/common/Panel'
 import IntelBudgetPanel from '@/components/panels/IntelBudgetPanel'
-import { useIntelStore } from '@/store/intel-store'
+import { useIntelStore, type IntelTab } from '@/store/intel-store'
 import { useUIStore } from '@/store/ui-store'
 import { useGameStore } from '@/store/game-store'
-import { iranCatalog } from '@/data/catalog/iran-catalog'
-import { usaCatalog } from '@/data/catalog/usa-catalog'
-import type { UnitCatalogEntry } from '@/types/scenario'
-import type { UnitCategory } from '@/types/game'
-
-const CATEGORY_LABELS: Record<UnitCategory, string> = {
-  airbase: 'Airbases',
-  naval_base: 'Naval Bases',
-  sam_site: 'Air Defense',
-  missile_battery: 'Missiles & Launchers',
-  aircraft: 'Aircraft',
-  ship: 'Ships',
-  submarine: 'Submarines',
-  carrier_group: 'Carrier Groups',
-  minefield: 'Minefields',
+import { sendCommand } from '@/store/bridge'
+import { cloudCoverUrl } from '@/data/feeds'
+import { useOsintFeed } from '@/intel/osint-feed'
+import type {
+  AgentSource,
+  IntelAsset,
+  IntelAssetKind,
+  IntelProduct,
+  InterceptPrecedence,
+  Position,
+} from '@/types/game'
+import type { IntelViewState, ViewUnit } from '@/types/view'
+
+const HOUR = 3600
+const AGENT_TASK_COOLDOWN_TICKS = HOUR
+
+const TABS: { id: IntelTab; label: string }[] = [
+  { id: 'isr', label: 'ISR' },
+  { id: 'sigint', label: 'SIGINT' },
+  { id: 'humint', label: 'HUMINT' },
+  { id: 'osint', label: 'OSINT' },
+  { id: 'opsec', label: 'OPSEC' },
+]
+
+const KIND_LABELS: Record<IntelAssetKind, string> = {
+  optical_sat: 'OPTICAL RECON SAT',
+  commercial_sat: 'COMMERCIAL EO LAYER',
+  sigint_air: 'SIGINT AIRCRAFT',
+  maritime_patrol: 'MARITIME PATROL UAS',
+  launch_detection: 'OPIR LAUNCH DETECTION',
+  recon_drone: 'RECON DRONE',
+  fast_boats: 'PICKET BOATS',
 }
 
-function getEnemyCatalog(playerNation: string): UnitCatalogEntry[] {
-  if (playerNation === 'usa') return iranCatalog
-  if (playerNation === 'iran') return usaCatalog
-  return []
+const TASKABLE_KINDS: IntelAssetKind[] = ['optical_sat', 'commercial_sat']
+
+const PRECEDENCE_COLORS: Record<InterceptPrecedence, string> = {
+  FLASH: '#ff4444',
+  IMMEDIATE: 'var(--status-engaged)',
+  PRIORITY: 'var(--text-primary)',
+  ROUTINE: 'var(--text-muted)',
 }
 
-function CatalogCategory({
-  label,
-  entries,
-  placingCatalogId,
-  onPlace,
-}: {
-  label: string
-  entries: UnitCatalogEntry[]
-  placingCatalogId: string | null
-  onPlace: (id: string) => void
-}) {
-  const [collapsed, setCollapsed] = useState(false)
+const PARANOIA_COLORS: Record<IntelViewState['paranoiaBand'], string> = {
+  LOW: 'var(--text-muted)',
+  ELEVATED: 'var(--text-primary)',
+  HIGH: 'var(--status-engaged)',
+  SEVERE: 'var(--status-damaged)',
+}
 
-  return (
-    <div style={{ marginBottom: 4 }}>
-      <div
-        style={{
-          display: 'flex',
-          alignItems: 'center',
-          gap: 4,
-          padding: '2px 4px',
-          userSelect: 'none',
-        }}
-      >
-        <span
-          onClick={() => setCollapsed((c) => !c)}
-          style={{ fontSize: 8, cursor: 'pointer', color: 'var(--text-muted)' }}
-        >
-          {collapsed ? '\u25B6' : '\u25BC'}
-        </span>
-        <span
-          onClick={() => setCollapsed((c) => !c)}
-          style={{
-            textTransform: 'uppercase',
-            letterSpacing: '0.04em',
-            color: 'var(--text-secondary)',
-            fontSize: 'var(--font-size-xs)',
-            cursor: 'pointer',
-            flex: 1,
-          }}
-        >
-          {label}
-        </span>
-        <span style={{ color: 'var(--text-muted)', fontSize: 'var(--font-size-xs)' }}>
-          {entries.length}
-        </span>
-      </div>
-      {!collapsed &&
-        entries.map((entry) => (
-          <CatalogRow
-            key={entry.id}
-            entry={entry}
-            isPlacing={placingCatalogId === entry.id}
-            onPlace={() => onPlace(entry.id)}
-          />
-        ))}
-    </div>
-  )
+const AGENT_STATUS_COLORS: Record<AgentSource['status'], string> = {
+  active: 'var(--status-ready)',
+  resting: 'var(--text-accent)',
+  exfiltrating: 'var(--status-engaged)',
+  exfiltrated: 'var(--text-muted)',
+  arrested: 'var(--status-damaged)',
 }
 
-function CatalogRow({
-  entry,
-  isPlacing,
-  onPlace,
-}: {
-  entry: UnitCatalogEntry
-  isPlacing: boolean
-  onPlace: () => void
-}) {
-  return (
-    <div
-      style={{
-        display: 'flex',
-        alignItems: 'center',
-        gap: 6,
-        padding: '3px 6px',
-        marginLeft: 16,
-        borderRadius: 3,
-        background: isPlacing ? 'var(--bg-hover)' : 'transparent',
-        borderLeft: isPlacing
-          ? '2px solid var(--border-accent)'
-          : '2px solid transparent',
-      }}
-    >
-      <div style={{ flex: 1, minWidth: 0 }}>
-        <div
-          style={{
-            color: 'var(--text-primary)',
-            fontSize: 'var(--font-size-xs)',
-            overflow: 'hidden',
-            textOverflow: 'ellipsis',
-            whiteSpace: 'nowrap',
-          }}
-        >
-          {entry.name}
-        </div>
-        <div
-          style={{
-            color: 'var(--text-muted)',
-            fontSize: '0.55rem',
-            lineHeight: 1.3,
-            overflow: 'hidden',
-            textOverflow: 'ellipsis',
-            display: '-webkit-box',
-            WebkitLineClamp: 2,
-            WebkitBoxOrient: 'vertical',
-          }}
-        >
-          {entry.description}
-        </div>
-      </div>
-      <button
-        onClick={onPlace}
-        style={{
-          background: isPlacing ? 'var(--border-accent)' : 'var(--bg-hover)',
-          border: isPlacing
-            ? '1px solid var(--border-accent)'
-            : '1px solid var(--border-default)',
-          borderRadius: 3,
-          color: isPlacing ? '#fff' : 'var(--text-secondary)',
-          cursor: 'pointer',
-          fontFamily: 'var(--font-mono)',
-          fontSize: '0.5rem',
-          padding: '2px 6px',
-          fontWeight: 600,
-          whiteSpace: 'nowrap',
-          flexShrink: 0,
-        }}
-      >
-        {isPlacing ? 'CANCEL' : 'PLACE'}
-      </button>
-    </div>
-  )
+const CARD: CSSProperties = {
+  border: '1px solid var(--border-default)',
+  borderRadius: 4,
+  padding: '6px 8px',
+  marginBottom: 6,
+  background: 'var(--bar-bg)',
 }
 
-function EstimateRow({
-  estimate,
-  onRemove,
-}: {
-  estimate: { id: string; name: string; position: { lat: number; lng: number }; confirmed: boolean }
-  onRemove: () => void
-}) {
-  return (
-    <div
-      style={{
-        display: 'flex',
-        alignItems: 'center',
-        gap: 6,
-        padding: '2px 6px',
-        borderRadius: 3,
-      }}
-    >
-      {estimate.confirmed ? (
-        <span style={{ color: 'var(--status-ready)', fontSize: 10, flexShrink: 0 }}>
-          {'\u2713'}
-        </span>
-      ) : (
-        <span
-          style={{
-            display: 'inline-block',
-            width: 6,
-            height: 6,
-            borderRadius: '50%',
-            border: '1px solid var(--text-muted)',
-            flexShrink: 0,
-            marginTop: 1,
-          }}
-        />
-      )}
-      <span
-        style={{
-          flex: 1,
-          color: estimate.confirmed ? 'var(--status-ready)' : 'var(--text-primary)',
-          fontSize: 'var(--font-size-xs)',
-          overflow: 'hidden',
-          textOverflow: 'ellipsis',
-          whiteSpace: 'nowrap',
-        }}
-      >
-        {estimate.name}
-      </span>
-      <span
-        style={{
-          color: 'var(--text-muted)',
-          fontSize: '0.5rem',
-          flexShrink: 0,
-        }}
-      >
-        {estimate.position.lat.toFixed(1)},{estimate.position.lng.toFixed(1)}
-      </span>
-      <button
-        onClick={onRemove}
-        style={{
-          background: 'none',
-          border: '1px solid var(--border-default)',
-          borderRadius: 3,
-          color: 'var(--status-damaged)',
-          cursor: 'pointer',
-          fontFamily: 'var(--font-mono)',
-          fontSize: '0.5rem',
-          padding: '1px 4px',
-          fontWeight: 600,
-          flexShrink: 0,
-          lineHeight: 1,
-        }}
-      >
-        X
-      </button>
-    </div>
-  )
+const SECTION_HEADER: CSSProperties = {
+  color: 'var(--text-accent)',
+  fontWeight: 700,
+  fontSize: 'var(--font-size-xs)',
+  letterSpacing: '0.06em',
+  textTransform: 'uppercase',
+  padding: '4px 0',
+  borderBottom: '1px solid var(--border-default)',
+  marginBottom: 6,
+  userSelect: 'none',
 }
 
-export default function IntelPanel({ onClose }: { onClose?: () => void }) {
-  const estimatedUnits = useIntelStore((s) => s.estimatedUnits)
-  const placingCatalogId = useIntelStore((s) => s.placingCatalogId)
-  const setPlacing = useIntelStore((s) => s.setPlacing)
-  const removeEstimate = useIntelStore((s) => s.removeEstimate)
-  const toggleIntel = useUIStore((s) => s.toggleIntel)
-  const playerNation = useGameStore((s) => s.viewState.playerNation)
+const BTN: CSSProperties = {
+  background: 'var(--bg-hover)',
+  border: '1px solid var(--border-default)',
+  borderRadius: 3,
+  color: 'var(--text-secondary)',
+  cursor: 'pointer',
+  fontFamily: 'var(--font-mono)',
+  fontSize: '0.55rem',
+  padding: '3px 8px',
+  fontWeight: 600,
+  textTransform: 'uppercase',
+  letterSpacing: '0.04em',
+  whiteSpace: 'nowrap',
+}
 
-  const catalog = getEnemyCatalog(playerNation)
+const BTN_DISABLED: CSSProperties = { ...BTN, opacity: 0.4, cursor: 'default' }
 
-  // Group catalog entries by category
-  const byCategory = new Map<UnitCategory, UnitCatalogEntry[]>()
-  for (const entry of catalog) {
-    if (!byCategory.has(entry.category)) byCategory.set(entry.category, [])
-    byCategory.get(entry.category)!.push(entry)
-  }
+const MUTED_XS: CSSProperties = {
+  color: 'var(--text-muted)',
+  fontSize: '0.55rem',
+  lineHeight: 1.4,
+}
 
-  const handlePlace = (catalogId: string) => {
-    if (placingCatalogId === catalogId) {
-      setPlacing(null)
-    } else {
-      setPlacing(catalogId)
+const HINT: CSSProperties = { ...MUTED_XS, fontStyle: 'italic', padding: '2px 0' }
+
+function fmtTicks(ticks: number): string {
+  const t = Math.max(0, Math.round(ticks))
+  const h = Math.floor(t / 3600)
+  const m = Math.floor((t % 3600) / 60)
+  const s = t % 60
+  if (h > 0) return `${h}h ${String(m).padStart(2, '0')}m`
+  if (m > 0) return `${m}m ${String(s).padStart(2, '0')}s`
+  return `${s}s`
+}
+
+function tPlus(tick: number): string {
+  const h = Math.floor(tick / 3600)
+  const m = Math.floor((tick % 3600) / 60)
+  return `T+${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`
+}
+
+function fmtPos(p: Position): string {
+  return `${p.lat.toFixed(2)}N ${p.lng.toFixed(2)}E`
+}
+
+function nextPassLabel(asset: IntelAsset, tick: number): string {
+  if (asset.status !== 'active') return 'OFFLINE'
+  if (asset.revisit_min === 0) return 'CONTINUOUS'
+  const remaining = asset.lastCollectionTick + asset.revisit_min * 60 - tick
+  return remaining <= 0 ? 'READY' : fmtTicks(remaining)
+}
+
+/** Real cloud cover for the AOI — 3s budget, any failure means "omit and let the engine roll" */
+async function fetchCloudPct(target: Position): Promise<number | undefined> {
+  try {
+    const ctrl = new AbortController()
+    const timer = setTimeout(() => ctrl.abort(), 3000)
+    try {
+      const res = await fetch(cloudCoverUrl(target.lat, target.lng), { signal: ctrl.signal })
+      if (!res.ok) return undefined
+      const data = await res.json()
+      const cc = data?.current?.cloud_cover
+      return typeof cc === 'number' && Number.isFinite(cc) ? cc : undefined
+    } finally {
+      clearTimeout(timer)
     }
+  } catch {
+    return undefined
   }
+}
+
+export default function IntelPanel({ onClose }: { onClose?: () => void }) {
+  const toggleIntel = useUIStore((s) => s.toggleIntel)
+  const activeTab = useIntelStore((s) => s.activeTab)
+  const setActiveTab = useIntelStore((s) => s.setActiveTab)
+  const intel = useGameStore((s) => s.viewState.intel)
+  const tick = useGameStore((s) => s.viewState.time.tick)
+  const units = useGameStore((s) => s.viewState.units)
+  const playerNation = useGameStore((s) => s.viewState.playerNation)
 
   return (
     <Panel
@@ -273,124 +171,532 @@ export default function IntelPanel({ onClose }: { onClose?: () => void }) {
         top: 44,
         right: 12,
         maxHeight: '70vh',
-        minWidth: 280,
+        width: 340,
         overflowY: 'auto',
       }}
     >
-      {/* Section 0: Budget Allocation */}
-      <IntelBudgetPanel />
-
-      {/* Section A: Enemy Catalog Browser */}
-      {catalog.length > 0 && <div style={{ marginBottom: 8 }}>
-        <div
-          style={{
-            display: 'flex',
-            alignItems: 'center',
-            gap: 6,
-            padding: '4px 4px',
-            borderBottom: '1px solid color-mix(in srgb, var(--status-damaged) 27%, transparent)',
-            marginBottom: 4,
-            userSelect: 'none',
-          }}
-        >
-          <span
+      <div style={{ display: 'flex', gap: 3, marginBottom: 8 }}>
+        {TABS.map((t) => (
+          <button
+            key={t.id}
+            onClick={() => setActiveTab(t.id)}
             style={{
-              color: 'var(--status-damaged)',
+              flex: 1,
+              background: activeTab === t.id ? 'var(--bg-hover)' : 'none',
+              border: '1px solid',
+              borderColor: activeTab === t.id ? 'var(--border-accent)' : 'var(--border-default)',
+              borderRadius: 3,
+              color: activeTab === t.id ? 'var(--text-accent)' : 'var(--text-muted)',
+              cursor: 'pointer',
+              fontFamily: 'var(--font-mono)',
+              fontSize: '0.55rem',
               fontWeight: 700,
-              fontSize: 'var(--font-size-sm)',
-              letterSpacing: '0.06em',
+              letterSpacing: '0.05em',
+              padding: '4px 0',
               textTransform: 'uppercase',
-              flex: 1,
             }}
           >
-            ENEMY CATALOG
-          </span>
-          <span
-            style={{ color: 'var(--text-muted)', fontSize: 'var(--font-size-xs)' }}
-          >
-            {catalog.length} types
-          </span>
+            {t.label}
+          </button>
+        ))}
+      </div>
+
+      {!intel ? (
+        <div style={HINT}>INTEL FEED OFFLINE</div>
+      ) : (
+        <>
+          {activeTab === 'isr' && (
+            <IsrTab intel={intel} tick={tick} units={units} playerNation={playerNation} />
+          )}
+          {activeTab === 'sigint' && (
+            <SigintTab
+              products={intel.products}
+              tick={tick}
+              blackoutUntil={intel.encryptionUpgradedUntilTick}
+            />
+          )}
+          {activeTab === 'humint' && <HumintTab agents={intel.agents} tick={tick} />}
+          {activeTab === 'osint' && <OsintTab />}
+          {activeTab === 'opsec' && (
+            <OpsecTab intel={intel} units={units} playerNation={playerNation} />
+          )}
+        </>
+      )}
+    </Panel>
+  )
+}
+
+// ── ISR ─────────────────────────────────────────────────────────────────────
+
+interface AoiOption {
+  key: string
+  label: string
+  sub: string
+  position: Position
+}
+
+function IsrTab({
+  intel,
+  tick,
+  units,
+  playerNation,
+}: {
+  intel: IntelViewState
+  tick: number
+  units: ViewUnit[]
+  playerNation: string
+}) {
+  const estimates = useIntelStore((s) => s.estimatedUnits)
+  const [pickerAssetId, setPickerAssetId] = useState<string | null>(null)
+  const [wxCheckAssetId, setWxCheckAssetId] = useState<string | null>(null)
+
+  const aoiOptions: AoiOption[] = [
+    ...units
+      .filter((u) => u.nation !== playerNation && u.status !== 'destroyed')
+      .map((u) => ({
+        key: u.id,
+        label: u.name,
+        sub: `${fmtPos(u.position)} · ${u.visibility.toUpperCase()}`,
+        position: u.position,
+      })),
+    ...estimates.map((e) => ({
+      key: e.id,
+      label: e.name,
+      sub: `${fmtPos(e.position)} · ESTIMATE`,
+      position: e.position,
+    })),
+  ]
+
+  const taskPass = async (assetId: string, target: Position) => {
+    setPickerAssetId(null)
+    setWxCheckAssetId(assetId)
+    const cloudPct = await fetchCloudPct(target)
+    setWxCheckAssetId(null)
+    if (cloudPct === undefined) {
+      sendCommand({ type: 'TASK_SATELLITE_PASS', assetId, target })
+    } else {
+      sendCommand({ type: 'TASK_SATELLITE_PASS', assetId, target, cloudPct })
+    }
+  }
+
+  return (
+    <div>
+      <div style={SECTION_HEADER}>Collection Assets</div>
+      {intel.assets.map((asset) => {
+        const taskable = TASKABLE_KINDS.includes(asset.kind) && asset.status === 'active'
+        const pickerOpen = pickerAssetId === asset.id
+        const wxBusy = wxCheckAssetId === asset.id
+        return (
+          <div key={asset.id} style={CARD}>
+            <div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
+              <span style={{ flex: 1, fontWeight: 700, fontSize: 'var(--font-size-xs)', color: 'var(--text-primary)' }}>
+                {asset.name}
+              </span>
+              <span style={{
+                fontSize: '0.5rem',
+                fontWeight: 700,
+                letterSpacing: '0.05em',
+                color: asset.status === 'active' ? 'var(--status-ready)' : 'var(--status-damaged)',
+              }}>
+                {asset.status.toUpperCase()}
+              </span>
+            </div>
+            <div style={{ display: 'flex', alignItems: 'center', gap: 6, marginTop: 2 }}>
+              <span style={{ ...MUTED_XS, flex: 1 }}>{KIND_LABELS[asset.kind]}</span>
+              <span style={{ ...MUTED_XS, color: 'var(--text-secondary)' }}>
+                NEXT PASS {nextPassLabel(asset, tick)}
+              </span>
+            </div>
+            {taskable && (
+              <div style={{ marginTop: 4 }}>
+                <button
+                  onClick={() => setPickerAssetId(pickerOpen ? null : asset.id)}
+                  disabled={wxBusy}
+                  style={pickerOpen ? { ...BTN, borderColor: 'var(--border-accent)', color: 'var(--text-accent)' } : wxBusy ? BTN_DISABLED : BTN}
+                >
+                  {wxBusy ? 'WX CHECK…' : pickerOpen ? 'CANCEL' : 'TASK PASS'}
+                </button>
+              </div>
+            )}
+            {pickerOpen && (
+              <div style={{ marginTop: 4, borderTop: '1px solid var(--border-default)', paddingTop: 4 }}>
+                <div style={{ ...MUTED_XS, textTransform: 'uppercase', letterSpacing: '0.04em', marginBottom: 2 }}>
+                  Select AOI
+                </div>
+                {aoiOptions.length === 0 && (
+                  <div style={HINT}>No enemy contacts or estimates to target.</div>
+                )}
+                {aoiOptions.map((opt) => (
+                  <div
+                    key={opt.key}
+                    onClick={() => { void taskPass(asset.id, opt.position) }}
+                    style={{
+                      display: 'flex',
+                      alignItems: 'baseline',
+                      gap: 6,
+                      padding: '2px 4px',
+                      borderRadius: 3,
+                      cursor: 'pointer',
+                    }}
+                    onMouseEnter={(e) => { e.currentTarget.style.background = 'var(--bg-hover)' }}
+                    onMouseLeave={(e) => { e.currentTarget.style.background = 'transparent' }}
+                  >
+                    <span style={{
+                      flex: 1,
+                      color: 'var(--text-primary)',
+                      fontSize: 'var(--font-size-xs)',
+                      overflow: 'hidden',
+                      textOverflow: 'ellipsis',
+                      whiteSpace: 'nowrap',
+                    }}>
+                      {opt.label}
+                    </span>
+                    <span style={{ ...MUTED_XS, flexShrink: 0 }}>{opt.sub}</span>
+                  </div>
+                ))}
+              </div>
+            )}
+          </div>
+        )
+      })}
+
+      {intel.taskings.length > 0 && (
+        <>
+          <div style={SECTION_HEADER}>Queued Taskings</div>
+          {intel.taskings.map((t) => {
+            const asset = intel.assets.find((a) => a.id === t.assetId)
+            return (
+              <div key={t.id} style={{ display: 'flex', alignItems: 'baseline', gap: 6, padding: '2px 4px' }}>
+                <span style={{ color: 'var(--text-primary)', fontSize: 'var(--font-size-xs)', flex: 1 }}>
+                  {asset?.name ?? t.assetId}
+                </span>
+                <span style={MUTED_XS}>{fmtPos(t.target)}</span>
+                <span style={{ ...MUTED_XS, color: 'var(--status-engaged)' }}>
+                  {asset ? (nextPassLabel(asset, tick) === 'READY' ? 'RESOLVING…' : nextPassLabel(asset, tick)) : '—'}
+                </span>
+              </div>
+            )
+          })}
+        </>
+      )}
+
+      <div style={{ marginTop: 8 }}>
+        <IntelBudgetPanel />
+      </div>
+    </div>
+  )
+}
+
+// ── SIGINT ──────────────────────────────────────────────────────────────────
+
+function SigintTab({
+  products,
+  tick,
+  blackoutUntil,
+}: {
+  products: IntelProduct[]
+  tick: number
+  blackoutUntil: number | null
+}) {
+  const intercepts = products.filter((p) => p.kind === 'sigint')
+  const dark = blackoutUntil !== null && blackoutUntil > tick
+
+  return (
+    <div>
+      {dark && (
+        <div style={{
+          border: '1px solid var(--status-damaged)',
+          borderRadius: 4,
+          padding: '6px 8px',
+          marginBottom: 8,
+          color: 'var(--status-damaged)',
+          fontSize: 'var(--font-size-xs)',
+          fontWeight: 700,
+          letterSpacing: '0.04em',
+        }}>
+          ENCRYPTION UPGRADED — COLLECTION DARK
+          <div style={{ ...MUTED_XS, color: 'var(--text-secondary)', fontWeight: 400, marginTop: 2 }}>
+            Adversary rotated crypto. Intercepts resume in {fmtTicks((blackoutUntil ?? 0) - tick)}.
+          </div>
         </div>
+      )}
 
-        {placingCatalogId && (
-          <div
-            style={{
-              color: 'var(--text-accent)',
-              fontSize: '0.55rem',
-              fontStyle: 'italic',
-              padding: '2px 4px',
-              marginBottom: 4,
-            }}
-          >
-            Click on the map to place estimated position...
+      <div style={SECTION_HEADER}>Intercepts</div>
+      {intercepts.length === 0 && <div style={HINT}>No intercepts collected.</div>}
+      {intercepts.map((p) => (
+        <div key={p.id} style={CARD}>
+          <div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
+            <span style={{
+              border: `1px solid ${PRECEDENCE_COLORS[p.precedence ?? 'ROUTINE']}`,
+              borderRadius: 2,
+              color: PRECEDENCE_COLORS[p.precedence ?? 'ROUTINE'],
+              fontSize: '0.5rem',
+              fontWeight: 700,
+              letterSpacing: '0.06em',
+              padding: '0 4px',
+            }}>
+              {p.precedence ?? 'ROUTINE'}
+            </span>
+            <span style={{ ...MUTED_XS, flex: 1 }}>{p.classification}</span>
+            <span style={MUTED_XS}>{tPlus(p.tick)}</span>
           </div>
-        )}
-
-        {Array.from(byCategory.entries()).map(([cat, entries]) => (
-          <CatalogCategory
-            key={cat}
-            label={CATEGORY_LABELS[cat] ?? cat}
-            entries={entries}
-            placingCatalogId={placingCatalogId}
-            onPlace={handlePlace}
-          />
-        ))}
-      </div>}
+          <div style={{ color: 'var(--text-secondary)', fontSize: 'var(--font-size-xs)', marginTop: 3, lineHeight: 1.4 }}>
+            {p.caption}
+          </div>
+        </div>
+      ))}
+    </div>
+  )
+}
+
+// ── HUMINT ──────────────────────────────────────────────────────────────────
+
+function HumintTab({ agents, tick }: { agents: AgentSource[]; tick: number }) {
+  const live = agents.filter(
+    (a) => a.status === 'active' || a.status === 'resting' || a.status === 'exfiltrating',
+  )
+  const gone = agents.filter((a) => a.status === 'arrested' || a.status === 'exfiltrated')
 
-      {/* Section B: Placed Estimates */}
-      <div>
+  return (
+    <div>
+      <div style={SECTION_HEADER}>Source Network</div>
+      <div style={HINT}>Tasking raises exposure ~15-25%</div>
+      {agents.length === 0 && <div style={HINT}>No sources in country.</div>}
+      {live.map((a) => <AgentCard key={a.id} agent={a} tick={tick} />)}
+      {gone.map((a) => (
         <div
+          key={a.id}
           style={{
             display: 'flex',
             alignItems: 'center',
             gap: 6,
-            padding: '4px 4px',
-            borderBottom: '1px solid var(--border-default)',
+            padding: '3px 8px',
             marginBottom: 4,
-            userSelect: 'none',
+            borderLeft: `2px solid ${a.status === 'arrested' ? 'var(--status-damaged)' : 'var(--border-default)'}`,
+            opacity: 0.55,
           }}
         >
-          <span
-            style={{
-              color: 'var(--text-accent)',
-              fontWeight: 700,
-              fontSize: 'var(--font-size-sm)',
-              letterSpacing: '0.06em',
-              textTransform: 'uppercase',
-              flex: 1,
-            }}
-          >
-            ESTIMATES
+          <span style={{ flex: 1, fontWeight: 700, fontSize: 'var(--font-size-xs)', color: 'var(--text-muted)' }}>
+            {a.codename}
           </span>
-          <span
-            style={{ color: 'var(--text-muted)', fontSize: 'var(--font-size-xs)' }}
-          >
-            {estimatedUnits.length}
+          <span style={{ fontSize: '0.5rem', fontWeight: 700, letterSpacing: '0.05em', color: AGENT_STATUS_COLORS[a.status] }}>
+            {a.status.toUpperCase()}
           </span>
         </div>
+      ))}
+    </div>
+  )
+}
 
-        {estimatedUnits.length === 0 && (
-          <div
-            style={{
-              color: 'var(--text-muted)',
-              fontSize: '0.55rem',
-              fontStyle: 'italic',
-              padding: '2px 4px',
-            }}
+function AgentCard({ agent, tick }: { agent: AgentSource; tick: number }) {
+  const cooldownLeft = AGENT_TASK_COOLDOWN_TICKS - (tick - agent.lastTaskedTick)
+  const onCooldown = cooldownLeft > 0
+  const exposure = Math.round(agent.exposure)
+
+  return (
+    <div style={CARD}>
+      <div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
+        <span style={{ flex: 1, fontWeight: 700, fontSize: 'var(--font-size-sm)', color: 'var(--text-primary)', letterSpacing: '0.05em' }}>
+          {agent.codename}
+        </span>
+        <span style={{ fontSize: '0.5rem', fontWeight: 700, letterSpacing: '0.05em', color: AGENT_STATUS_COLORS[agent.status] }}>
+          {agent.status.toUpperCase()}
+        </span>
+      </div>
+      <div style={{ ...MUTED_XS, color: 'var(--text-secondary)' }}>{agent.placement}</div>
+      <div style={MUTED_XS}>{agent.product}</div>
+
+      <div style={{ display: 'flex', alignItems: 'center', gap: 6, marginTop: 4 }}>
+        <span style={{ ...MUTED_XS, textTransform: 'uppercase', letterSpacing: '0.04em', flexShrink: 0 }}>
+          Exposure
+        </span>
+        <div style={{ flex: 1, height: 5, background: 'var(--bar-bg)', border: '1px solid var(--bar-border)', borderRadius: 2, overflow: 'hidden' }}>
+          <div style={{
+            width: `${exposure}%`,
+            height: '100%',
+            backgroundImage: 'linear-gradient(90deg, var(--status-ready), var(--status-engaged), var(--status-damaged))',
+            backgroundSize: exposure > 0 ? `${10000 / exposure}% 100%` : '100% 100%',
+          }} />
+        </div>
+        <span style={{ ...MUTED_XS, color: 'var(--text-secondary)', flexShrink: 0 }}>{exposure}%</span>
+      </div>
+
+      {agent.status === 'exfiltrating' ? (
+        <div style={{ ...MUTED_XS, color: 'var(--status-engaged)', marginTop: 4, fontWeight: 600 }}>
+          EXFIL IN PROGRESS — {fmtTicks((agent.exfilCompleteTick ?? tick) - tick)}
+        </div>
+      ) : (
+        <>
+          <div style={{ display: 'flex', gap: 4, marginTop: 5 }}>
+            <button
+              onClick={() => sendCommand({ type: 'TASK_AGENT', agentId: agent.id })}
+              disabled={onCooldown}
+              style={onCooldown ? BTN_DISABLED : BTN}
+            >
+              TASK
+            </button>
+            <button
+              onClick={() => sendCommand({ type: 'REST_AGENT', agentId: agent.id })}
+              disabled={agent.status === 'resting'}
+              style={agent.status === 'resting' ? BTN_DISABLED : BTN}
+            >
+              REST
+            </button>
+            <button
+              onClick={() => sendCommand({ type: 'EXFILTRATE_AGENT', agentId: agent.id })}
+              style={BTN}
+            >
+              EXFILTRATE
+            </button>
+          </div>
+          <div style={HINT}>
+            {onCooldown ? `Comms window in ${fmtTicks(cooldownLeft)} · ` : ''}Exfiltrate: 6h to extract
+          </div>
+        </>
+      )}
+    </div>
+  )
+}
+
+// ── OSINT ───────────────────────────────────────────────────────────────────
+
+function OsintTab() {
+  const posts = useOsintFeed()
+  const [filter, setFilter] = useState<string | null>(null)
+
+  const handles = Array.from(new Set(posts.map((p) => p.handle)))
+  const sorted = [...posts].sort((a, b) => b.tick - a.tick)
+  const shown = filter ? sorted.filter((p) => p.handle === filter) : sorted
+
+  return (
+    <div>
+      <div style={SECTION_HEADER}>Open Sources</div>
+      {handles.length > 1 && (
+        <div style={{ display: 'flex', flexWrap: 'wrap', gap: 3, marginBottom: 6 }}>
+          <button
+            onClick={() => setFilter(null)}
+            style={filter === null ? { ...BTN, borderColor: 'var(--border-accent)', color: 'var(--text-accent)' } : BTN}
           >
-            No estimates placed. Use the catalog above to mark suspected enemy
-            positions.
+            ALL
+          </button>
+          {handles.map((h) => (
+            <button
+              key={h}
+              onClick={() => setFilter(filter === h ? null : h)}
+              style={filter === h ? { ...BTN, borderColor: 'var(--border-accent)', color: 'var(--text-accent)' } : BTN}
+            >
+              {h.replace('@', '')}
+            </button>
+          ))}
+        </div>
+      )}
+      {shown.length === 0 && <div style={HINT}>Monitoring open sources&hellip;</div>}
+      {shown.map((p) => (
+        <div key={p.id} style={{ padding: '4px 2px', borderBottom: '1px solid var(--bar-border)' }}>
+          <div style={{ display: 'flex', alignItems: 'baseline', gap: 6 }}>
+            <span style={{ color: p.color, fontSize: 'var(--font-size-xs)', fontWeight: 700, flex: 1 }}>
+              {p.handle}
+            </span>
+            <span style={MUTED_XS}>{tPlus(p.tick)}</span>
           </div>
-        )}
-
-        {estimatedUnits.map((est) => (
-          <EstimateRow
-            key={est.id}
-            estimate={est}
-            onRemove={() => removeEstimate(est.id)}
-          />
-        ))}
+          <div style={{ color: 'var(--text-secondary)', fontSize: 'var(--font-size-xs)', lineHeight: 1.4, marginTop: 1 }}>
+            {p.text}
+          </div>
+        </div>
+      ))}
+    </div>
+  )
+}
+
+// ── OPSEC ───────────────────────────────────────────────────────────────────
+
+function OpsecTab({
+  intel,
+  units,
+  playerNation,
+}: {
+  intel: IntelViewState
+  units: ViewUnit[]
+  playerNation: string
+}) {
+  const leak = Math.round(intel.leakLevel)
+  const leakColor = leak > 60
+    ? 'var(--status-damaged)'
+    : leak >= 40
+      ? 'var(--status-engaged)'
+      : 'var(--status-ready)'
+
+  const radarUnits = units.filter(
+    (u) => u.nation === playerNation && u.sensors.some((s) => s.type === 'radar'),
+  )
+
+  return (
+    <div>
+      <div style={SECTION_HEADER}>Operations Security</div>
+      <div style={{ display: 'flex', alignItems: 'center', gap: 6, marginBottom: 2 }}>
+        <span style={{ ...MUTED_XS, textTransform: 'uppercase', letterSpacing: '0.04em', flexShrink: 0 }}>
+          Leak level
+        </span>
+        <div style={{ flex: 1, height: 6, background: 'var(--bar-bg)', border: '1px solid var(--bar-border)', borderRadius: 2, overflow: 'hidden' }}>
+          <div style={{ width: `${leak}%`, height: '100%', background: leakColor }} />
+        </div>
+        <span style={{ color: leakColor, fontSize: 'var(--font-size-xs)', fontWeight: 700, flexShrink: 0 }}>
+          {leak}%
+        </span>
       </div>
-    </Panel>
+      <div style={MUTED_XS}>+ carrier operating inside the strait</div>
+      <div style={MUTED_XS}>+ each strike launched (pattern analysis)</div>
+      <div style={MUTED_XS}>+ agents lost to counterintelligence</div>
+
+      <div style={{ marginTop: 8 }}>
+        <button
+          onClick={() => sendCommand({ type: 'OPSEC_SWEEP' })}
+          style={{ ...BTN, width: '100%', padding: '5px 8px', fontSize: '0.6rem' }}
+        >
+          OPSEC SWEEP
+        </button>
+        <div style={HINT}>Purge comms patterns, rotate callsigns. Once per 6h.</div>
+      </div>
+
+      <div style={{ ...SECTION_HEADER, marginTop: 8 }}>Counterintel Threat</div>
+      <div style={{ display: 'flex', alignItems: 'center', gap: 6, padding: '2px 0' }}>
+        <span style={{ ...MUTED_XS, textTransform: 'uppercase', letterSpacing: '0.04em', flex: 1 }}>
+          Iranian counterintel posture
+        </span>
+        <span style={{ color: PARANOIA_COLORS[intel.paranoiaBand], fontSize: 'var(--font-size-xs)', fontWeight: 700, letterSpacing: '0.05em' }}>
+          {intel.paranoiaBand}
+        </span>
+      </div>
+
+      <div style={{ ...SECTION_HEADER, marginTop: 8 }}>EMCON — Radar Emitters</div>
+      {radarUnits.length === 0 && <div style={HINT}>No radar-equipped units.</div>}
+      {radarUnits.map((u) => (
+        <div key={u.id} style={{ display: 'flex', alignItems: 'center', gap: 6, padding: '2px 0' }}>
+          <span style={{
+            flex: 1,
+            color: 'var(--text-primary)',
+            fontSize: 'var(--font-size-xs)',
+            overflow: 'hidden',
+            textOverflow: 'ellipsis',
+            whiteSpace: 'nowrap',
+          }}>
+            {u.name}
+          </span>
+          <button
+            onClick={() => sendCommand({ type: 'SET_EMCON', unitId: u.id, emcon: !u.emcon })}
+            style={{
+              ...BTN,
+              color: u.emcon ? 'var(--status-engaged)' : 'var(--status-ready)',
+              borderColor: u.emcon ? 'var(--status-engaged)' : 'var(--border-default)',
+            }}
+          >
+            {u.emcon ? 'SILENT' : 'RADIATING'}
+          </button>
+        </div>
+      ))}
+      {radarUnits.length > 0 && (
+        <div style={HINT}>Radar silent: invisible to ELINT, blind without datalink</div>
+      )}
+    </div>
   )
 }
diff --git a/src/components/panels/StatsPanel.tsx b/src/components/panels/StatsPanel.tsx
index c106595..2fb4430 100644
--- a/src/components/panels/StatsPanel.tsx
+++ b/src/components/panels/StatsPanel.tsx
@@ -1,3 +1,4 @@
+import type { CSSProperties } from 'react'
 import Panel from '@/components/common/Panel'
 import StatBar from '@/components/common/StatBar'
 import { useGameStore } from '@/store/game-store'
@@ -82,6 +83,137 @@ export function computeNationStats(
   }
 }
 
+export interface ArsenalRow {
+  weaponId: string
+  name: string
+  deployed: number
+  deployedMax: number
+  reserve: number
+  prodPerHour: number
+}
+
+/** Per-weapon national arsenal: loaded on units + reserve at bases + industry rate */
+export function computeArsenal(units: ViewUnit[], nationId: NationId): ArsenalRow[] {
+  const rows = new Map<string, ArsenalRow>()
+  const row = (weaponId: string): ArsenalRow => {
+    let r = rows.get(weaponId)
+    if (!r) {
+      r = {
+        weaponId,
+        name: weaponSpecs[weaponId]?.name ?? weaponId,
+        deployed: 0,
+        deployedMax: 0,
+        reserve: 0,
+        prodPerHour: 0,
+      }
+      rows.set(weaponId, r)
+    }
+    return r
+  }
+
+  for (const unit of units) {
+    if (unit.nation !== nationId || unit.status === 'destroyed') continue
+    for (const w of unit.weapons) {
+      const r = row(w.weaponId)
+      r.deployed += w.count
+      r.deployedMax += w.maxCount
+    }
+    for (const s of unit.supplyStocks) {
+      const r = row(s.weaponId)
+      r.reserve += s.count
+      r.prodPerHour += s.productionRate
+    }
+  }
+
+  return Array.from(rows.values()).sort(
+    (a, b) => (b.deployed + b.reserve) - (a.deployed + a.reserve),
+  )
+}
+
+function ArsenalTable({ units, nationId }: { units: ViewUnit[]; nationId: NationId }) {
+  const rows = computeArsenal(units, nationId)
+  if (rows.length === 0) return null
+  const totalProd = rows.reduce((sum, r) => sum + r.prodPerHour, 0)
+
+  const cell: CSSProperties = {
+    fontSize: 'var(--font-size-xs)',
+    fontFamily: 'var(--font-mono)',
+    padding: '1px 4px',
+    textAlign: 'right',
+    whiteSpace: 'nowrap',
+  }
+
+  return (
+    <div style={{ marginTop: 8 }}>
+      <div style={{
+        display: 'flex',
+        alignItems: 'baseline',
+        gap: 6,
+        borderBottom: '1px solid var(--border-default)',
+        marginBottom: 2,
+        paddingBottom: 2,
+      }}>
+        <span style={{
+          color: 'var(--text-secondary)',
+          fontWeight: 700,
+          fontSize: 'var(--font-size-xs)',
+          letterSpacing: '0.06em',
+        }}>
+          ARSENAL
+        </span>
+        <span style={{ flex: 1 }} />
+        <span style={{ color: totalProd > 0 ? 'var(--status-ready)' : 'var(--text-muted)', fontSize: 'var(--font-size-xs)' }}>
+          INDUSTRY {totalProd > 0 ? `+${formatRate(totalProd)}/h` : 'IDLE'}
+        </span>
+      </div>
+      <table style={{ width: '100%', borderCollapse: 'collapse' }}>
+        <thead>
+          <tr>
+            <th style={{ ...cell, textAlign: 'left', color: 'var(--text-muted)', fontWeight: 400 }}>TYPE</th>
+            <th style={{ ...cell, color: 'var(--text-muted)', fontWeight: 400 }}>LOADED</th>
+            <th style={{ ...cell, color: 'var(--text-muted)', fontWeight: 400 }}>RESERVE</th>
+            <th style={{ ...cell, color: 'var(--text-muted)', fontWeight: 400 }}>IND.</th>
+          </tr>
+        </thead>
+        <tbody>
+          {rows.map(r => (
+            <tr key={r.weaponId}>
+              <td style={{
+                ...cell,
+                textAlign: 'left',
+                color: 'var(--text-primary)',
+                maxWidth: 110,
+                overflow: 'hidden',
+                textOverflow: 'ellipsis',
+              }}>
+                {r.name}
+              </td>
+              <td style={{
+                ...cell,
+                color: r.deployed === 0 ? 'var(--status-damaged)'
+                  : r.deployed < r.deployedMax * 0.25 ? 'var(--status-engaged)'
+                    : 'var(--text-primary)',
+              }}>
+                {r.deployed}/{r.deployedMax}
+              </td>
+              <td style={{ ...cell, color: r.reserve > 0 ? 'var(--text-secondary)' : 'var(--text-muted)' }}>
+                {r.reserve}
+              </td>
+              <td style={{ ...cell, color: r.prodPerHour > 0 ? 'var(--status-ready)' : 'var(--text-muted)' }}>
+                {r.prodPerHour > 0 ? `+${formatRate(r.prodPerHour)}` : '—'}
+              </td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  )
+}
+
+function formatRate(rate: number): string {
+  return Number.isInteger(rate) ? String(rate) : rate.toFixed(1)
+}
+
 function ModernNationBlock({ nationId, nationLabel, units, events, isPlayer }: { nationId: NationId; nationLabel: string; units: ViewUnit[]; events: GameEvent[]; isPlayer: boolean }) {
   const stats = computeNationStats(units, events, nationId)
   const activeUnits = stats.total - stats.destroyed
@@ -126,6 +258,7 @@ function ModernNationBlock({ nationId, nationLabel, units, events, isPlayer }: {
               color="var(--status-ready)"
             />
           )}
+          <ArsenalTable units={units} nationId={nationId} />
         </>
       ) : (
         // Enemy inventories are not knowable under fog — known contacts only
diff --git a/src/components/panels/StrikePanel.tsx b/src/components/panels/StrikePanel.tsx
index ab1ec50..015b6f9 100644
--- a/src/components/panels/StrikePanel.tsx
+++ b/src/components/panels/StrikePanel.tsx
@@ -6,12 +6,20 @@ import { useGameStore } from '@/store/game-store'
 import { useIntelStore } from '@/store/intel-store'
 import { sendCommand } from '@/store/bridge'
 import { weaponSpecs } from '@/data/weapons/missiles'
-import { computeAttackPlan } from '@/engine/attack-planner'
+import {
+  computeAttackPlan,
+  computeTotSchedule,
+  estimateLeakers,
+  TOT_RIPPLE_TICKS,
+  TOT_DETECTION_WARNING_TICKS,
+  type TotSchedule,
+} from '@/engine/attack-planner'
 import { computeRouteDistance } from '@/components/map/layers/RouteLayer'
 import { getMainThreadGrid } from '@/components/map/layers/LOSLayer'
 import { findAutoRoute } from '@/engine/systems/route-planner'
 import { haversine } from '@/engine/utils/geo'
 import type { UnitCategory } from '@/types/game'
+import type { ViewUnit } from '@/types/view'
 import type { AttackPriority, Severity, TimingMode, PlannedStrike, AttackPlan } from '@/types/attack-plan'
 
 // ════════════════════════════════════════════════════════════════
@@ -26,10 +34,27 @@ const SEVERITY_OPTIONS: { value: Severity; label: string; desc: string }[] = [
 
 const TIMING_OPTIONS: { value: TimingMode; label: string; desc: string }[] = [
   { value: 'simultaneous', label: 'SIMULTANEOUS', desc: 'All at T+0' },
-  { value: 'staggered', label: 'STAGGERED', desc: '30s between tiers' },
-  { value: 'sequential', label: 'SEQUENTIAL', desc: '10min between tiers' },
+  { value: 'staggered', label: 'STAGGERED', desc: '2s between launches' },
+  { value: 'sequential', label: 'SEQUENTIAL', desc: '8s between launches' },
 ]
 
+/** Format game-ticks (1 tick = 1 game-sec) as m:ss or h:mm:ss */
+function fmtTicks(ticks: number): string {
+  const s = Math.max(0, Math.round(ticks))
+  const h = Math.floor(s / 3600)
+  const m = Math.floor((s % 3600) / 60)
+  const sec = s % 60
+  const pad = (v: number) => String(v).padStart(2, '0')
+  return h > 0 ? `${h}:${pad(m)}:${pad(sec)}` : `${m}:${pad(sec)}`
+}
+
+// Game-seconds between rounds of each salvo — scheduled engine-side, so it respects pause
+const TIMING_SPACING_TICKS: Record<TimingMode, number> = {
+  simultaneous: 0,
+  staggered: 2,
+  sequential: 8,
+}
+
 const TARGET_CATEGORIES: { value: UnitCategory; label: string }[] = [
   { value: 'sam_site', label: 'SAM Sites' },
   { value: 'missile_battery', label: 'Missile Batteries' },
@@ -790,6 +815,11 @@ function PlanAttackTab() {
   const closeStrike = useStrikeStore((s) => s.closeStrike)
   const units = useGameStore((s) => s.viewState.units)
   const playerNation = useGameStore((s) => s.viewState.playerNation)
+  const nowTick = useGameStore((s) => s.viewState.time.tick)
+
+  // TOT lives UI-side on top of the store's TimingMode — one master control,
+  // the launch schedule below is derived and read-only
+  const [totMode, setTotMode] = useState(false)
 
   const friendlyUnits = useMemo(
     () => units.filter((u) => u.nation === playerNation && u.status !== 'destroyed'),
@@ -800,6 +830,11 @@ function PlanAttackTab() {
     [units, playerNation],
   )
 
+  const totSchedule = useMemo(
+    () => (totMode && computedPlan ? computeTotSchedule(computedPlan, nowTick) : null),
+    [totMode, computedPlan, nowTick],
+  )
+
   // Recompute plan whenever draft changes
   useEffect(() => {
     if (planPriorities.length === 0) {
@@ -825,42 +860,56 @@ function PlanAttackTab() {
     if (!computedPlan || executing) return
     startExecution()
 
-    const strikes = computedPlan.strikes.filter((s) => s.inRange)
-    const tierGroups = new Map<number, PlannedStrike[]>()
-    for (const s of strikes) {
-      const group = tierGroups.get(s.priorityTier) ?? []
-      group.push(s)
-      tierGroups.set(s.priorityTier, group)
-    }
+    if (totMode) {
+      // Recompute against the tick at authorization so delays are exact
+      const execTick = useGameStore.getState().viewState.time.tick
+      const schedule = computeTotSchedule(computedPlan, execTick)
 
-    const tiers = Array.from(tierGroups.entries()).sort(([a], [b]) => a - b)
-    let fired = 0
-    const total = strikes.reduce((s, st) => s + st.count, 0)
+      let fired = 0
+      const total = schedule.entries.reduce((s, e) => s + e.count, 0)
 
-    for (let ti = 0; ti < tiers.length; ti++) {
-      const [, tierStrikes] = tiers[ti]
-      if (ti > 0) {
-        const delayMs = planTiming === 'staggered' ? 30_000 :
-                        planTiming === 'sequential' ? 600_000 : 0
-        if (delayMs > 0) {
-          await new Promise((r) => setTimeout(r, Math.min(delayMs / 100, 3000)))
-        }
-      }
-      for (const stk of tierStrikes) {
+      for (const e of schedule.entries) {
         await sendCommand({
           type: 'LAUNCH_SALVO',
-          launcherId: stk.launcherId,
-          weaponId: stk.weaponId,
-          targetId: stk.targetId,
-          count: stk.count,
+          launcherId: e.launcherId,
+          weaponId: e.weaponId,
+          targetId: e.targetId,
+          count: e.count,
+          spacingTicks: TOT_RIPPLE_TICKS,
+          delayTicks: e.dueTick - execTick,
         })
-        fired += stk.count
-        updateProgress(fired / total)
+        fired += e.count
+        updateProgress(total > 0 ? fired / total : 1)
       }
+
+      finishExecution()
+      return
+    }
+
+    // One burst of commands in tier order — spacing happens engine-side in game time
+    const strikes = computedPlan.strikes
+      .filter((s) => s.inRange)
+      .sort((a, b) => a.priorityTier - b.priorityTier)
+    const spacingTicks = TIMING_SPACING_TICKS[planTiming]
+
+    let fired = 0
+    const total = strikes.reduce((s, st) => s + st.count, 0)
+
+    for (const stk of strikes) {
+      await sendCommand({
+        type: 'LAUNCH_SALVO',
+        launcherId: stk.launcherId,
+        weaponId: stk.weaponId,
+        targetId: stk.targetId,
+        count: stk.count,
+        spacingTicks,
+      })
+      fired += stk.count
+      updateProgress(fired / total)
     }
 
     finishExecution()
-  }, [computedPlan, executing, planTiming, startExecution, updateProgress, finishExecution])
+  }, [computedPlan, executing, totMode, planTiming, startExecution, updateProgress, finishExecution])
 
   const availableCategories = TARGET_CATEGORIES.filter(
     (tc) => !planPriorities.some((p) => p.targetCategory === tc.value),
@@ -914,24 +963,42 @@ function PlanAttackTab() {
       {/* Timing */}
       <Section title="TIMING">
         <div style={{ display: 'flex', gap: 4 }}>
-          {TIMING_OPTIONS.map((t) => (
-            <button
-              key={t.value}
-              onClick={() => setPlanTiming(t.value)}
-              style={{
-                flex: 1, padding: '4px 6px',
-                background: planTiming === t.value ? 'var(--bg-hover)' : 'transparent',
-                border: `1px solid ${planTiming === t.value ? 'var(--border-accent)' : 'var(--border-default)'}`,
-                borderRadius: 4,
-                color: planTiming === t.value ? 'var(--text-accent)' : 'var(--text-muted)',
-                cursor: 'pointer', fontFamily: 'var(--font-mono)',
-                fontSize: '0.6rem', fontWeight: 600, textAlign: 'center',
-              }}
-            >
-              <div>{t.label}</div>
-              <div style={{ fontSize: '0.5rem', fontWeight: 400 }}>{t.desc}</div>
-            </button>
-          ))}
+          {TIMING_OPTIONS.map((t) => {
+            const selected = !totMode && planTiming === t.value
+            return (
+              <button
+                key={t.value}
+                onClick={() => { setTotMode(false); setPlanTiming(t.value) }}
+                style={{
+                  flex: 1, padding: '4px 6px',
+                  background: selected ? 'var(--bg-hover)' : 'transparent',
+                  border: `1px solid ${selected ? 'var(--border-accent)' : 'var(--border-default)'}`,
+                  borderRadius: 4,
+                  color: selected ? 'var(--text-accent)' : 'var(--text-muted)',
+                  cursor: 'pointer', fontFamily: 'var(--font-mono)',
+                  fontSize: '0.6rem', fontWeight: 600, textAlign: 'center',
+                }}
+              >
+                <div>{t.label}</div>
+                <div style={{ fontSize: '0.5rem', fontWeight: 400 }}>{t.desc}</div>
+              </button>
+            )
+          })}
+          <button
+            onClick={() => setTotMode(true)}
+            style={{
+              flex: 1, padding: '4px 6px',
+              background: totMode ? 'var(--bg-hover)' : 'transparent',
+              border: `1px solid ${totMode ? 'var(--border-accent)' : 'var(--border-default)'}`,
+              borderRadius: 4,
+              color: totMode ? 'var(--text-accent)' : 'var(--text-muted)',
+              cursor: 'pointer', fontFamily: 'var(--font-mono)',
+              fontSize: '0.6rem', fontWeight: 600, textAlign: 'center',
+            }}
+          >
+            <div>TOT</div>
+            <div style={{ fontSize: '0.5rem', fontWeight: 400 }}>Simultaneous impact</div>
+          </button>
         </div>
       </Section>
 
@@ -941,6 +1008,11 @@ function PlanAttackTab() {
           <Section title="STRIKE PLAN PREVIEW">
             <PlanPreview plan={computedPlan} />
           </Section>
+          {totMode && totSchedule && (
+            <Section title="TOT LAUNCH SCHEDULE">
+              <TotScheduleView plan={computedPlan} schedule={totSchedule} enemyUnits={enemyUnits} nowTick={nowTick} />
+            </Section>
+          )}
           <Section title="SUMMARY">
             <PlanSummary plan={computedPlan} />
           </Section>
@@ -1222,6 +1294,89 @@ function PlanSummary({ plan }: { plan: AttackPlan }) {
   )
 }
 
+function TotScheduleView({ plan, schedule, enemyUnits, nowTick }: {
+  plan: AttackPlan
+  schedule: TotSchedule
+  enemyUnits: ViewUnit[]
+  nowTick: number
+}) {
+  const rows = plan.strikes.filter((s) => s.inRange)
+  const totalMissiles = rows.reduce((sum, s) => sum + s.count, 0)
+
+  if (schedule.entries.length === 0 || totalMissiles === 0) {
+    return (
+      <div style={{ color: 'var(--text-muted)', fontStyle: 'italic', fontSize: 'var(--font-size-xs)' }}>
+        No in-range strikes to schedule.
+      </div>
+    )
+  }
+
+  // Impact-window comparison: TOT compresses arrivals into the launch ripple;
+  // launching everything at T+0 spreads them across the flight-time delta
+  const flightTimes = rows.map((s) => s.flightTimeSec)
+  const spreadSec = Math.max(...flightTimes) - Math.min(...flightTimes)
+  const totWindowSec = (Math.max(...rows.map((s) => s.count)) - 1) * TOT_RIPPLE_TICKS
+  const totLeakers = estimateLeakers(rows, enemyUnits, totWindowSec)
+  const spreadLeakers = estimateLeakers(rows, enemyUnits, spreadSec)
+  const spreadMin = Math.max(1, Math.round(spreadSec / 60))
+
+  const leadTicks = schedule.totTick - schedule.earliestLaunchTick
+  const showDetectionWarning = leadTicks > TOT_DETECTION_WARNING_TICKS
+
+  return (
+    <div style={{ fontSize: '0.6rem' }}>
+      <div style={{ display: 'flex', justifyContent: 'space-between', marginBottom: 4 }}>
+        <span style={{ color: 'var(--text-muted)' }}>ALL IMPACTS AT</span>
+        <span style={{ color: 'var(--text-accent)', fontWeight: 700 }}>
+          TOT — T+{fmtTicks(schedule.totTick - nowTick)}
+        </span>
+      </div>
+
+      {/* Derived launch schedule — read-only, one master TOT, no per-launcher inputs */}
+      <div style={{ maxHeight: 120, overflowY: 'auto', marginBottom: 6 }}>
+        {schedule.entries.map((e, i) => (
+          <div key={i} style={{
+            display: 'flex', justifyContent: 'space-between', alignItems: 'baseline',
+            padding: '1px 4px', borderBottom: '1px solid var(--border-default)',
+          }}>
+            <span style={{
+              color: 'var(--text-accent)', fontFamily: 'var(--font-mono)',
+              fontWeight: 600, flexShrink: 0, minWidth: 64,
+            }}>
+              T−{fmtTicks(schedule.totTick - e.dueTick)}
+            </span>
+            <span style={{
+              color: 'var(--text-primary)', flex: 1, marginLeft: 6,
+              overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',
+            }}>
+              {e.launcherName.split(' ').slice(0, 3).join(' ')}
+            </span>
+            <span style={{ color: 'var(--text-muted)', flexShrink: 0, marginLeft: 6 }}>
+              {e.count}x {e.weaponName.split(' ')[0]} → {e.targetName.split(' ').slice(0, 2).join(' ')}
+            </span>
+          </div>
+        ))}
+      </div>
+
+      {/* Saturation comparison — closed-form capacity estimate, hence EST */}
+      <div style={{ color: 'var(--text-muted)' }}>
+        EST leakers through AD — all-at-TOT:{' '}
+        <b style={{ color: 'var(--status-ready)' }}>{totLeakers}/{totalMissiles}</b>
+        {' '}vs spread over {spreadMin} min:{' '}
+        <b style={{ color: spreadLeakers < totLeakers ? 'var(--status-damaged)' : 'var(--text-accent)' }}>
+          {spreadLeakers}/{totalMissiles}
+        </b>
+      </div>
+
+      {showDetectionWarning && (
+        <div style={{ color: 'var(--status-engaged)', fontSize: '0.55rem', marginTop: 4 }}>
+          ! FIRST LAUNCH AT T−{fmtTicks(leadTicks)} — may be detected before impact
+        </div>
+      )}
+    </div>
+  )
+}
+
 // ════════════════════════════════════════════════════════════════
 //  Shared styles
 // ════════════════════════════════════════════════════════════════
diff --git a/src/components/panels/UnitInfoPanel.tsx b/src/components/panels/UnitInfoPanel.tsx
index f4f64b9..7b3fa08 100644
--- a/src/components/panels/UnitInfoPanel.tsx
+++ b/src/components/panels/UnitInfoPanel.tsx
@@ -7,6 +7,7 @@ import { sendCommand } from '@/store/bridge'
 import type { ViewUnit } from '@/types/view'
 import type { ROE } from '@/types/game'
 import { weaponSpecs } from '@/data/weapons/missiles'
+import { UNIT_IMAGES, unitImageKey } from '@/data/unit-images'
 
 interface UnitInfoPanelProps {
   units: ViewUnit[]
@@ -46,9 +47,13 @@ export default function UnitInfoPanel({ units }: UnitInfoPanelProps) {
   const isFriendly = unit.nation === playerNation
   const detected = unit.visibility === 'detected'
   const identified = unit.visibility === 'identified'
+  const hasRadar = unit.sensors.some((s) => s.type === 'radar')
   // Same gate shipping.ts uses for drone interdiction
   const isDroneCapable = unit.weapons.some((w) => w.weaponId.includes('shahed'))
   const droneMission: DroneMission = unit.droneMission ?? 'military'
+  // Recognition photo: own units always, enemy contacts only once identified
+  const imageKey = isFriendly || identified ? unitImageKey(unit) : null
+  const image = imageKey ? UNIT_IMAGES[imageKey] : undefined
 
   return (
     <Panel
@@ -56,6 +61,31 @@ export default function UnitInfoPanel({ units }: UnitInfoPanelProps) {
       onClose={() => selectUnit(null)}
       style={{ position: 'absolute', top: 60, right: 12 }}
     >
+      {image && (
+        <div style={{ marginBottom: 8 }}>
+          <img
+            src={`/unit-images/${image.file}`}
+            alt={unit.name}
+            style={{
+              display: 'block',
+              width: '100%',
+              height: 120,
+              objectFit: 'cover',
+              borderRadius: 3,
+            }}
+          />
+          <div style={{
+            color: 'var(--text-muted)',
+            fontSize: 'var(--font-size-xs)',
+            marginTop: 3,
+            whiteSpace: 'nowrap',
+            overflow: 'hidden',
+            textOverflow: 'ellipsis',
+          }}>
+            {image.author} · {image.license}
+          </div>
+        </div>
+      )}
       {/* Status + Health — scrubbed to placeholders below 'tracked', so don't show them */}
       <div style={{ marginBottom: 8 }}>
         <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
@@ -220,6 +250,64 @@ export default function UnitInfoPanel({ units }: UnitInfoPanelProps) {
                 ))}
               </div>
 
+              {hasRadar && (
+                <>
+                  <div style={{
+                    color: 'var(--text-muted)',
+                    fontSize: 'var(--font-size-xs)',
+                    margin: '8px 0 4px',
+                    textTransform: 'uppercase',
+                    letterSpacing: '0.05em',
+                  }}>
+                    Emissions Control
+                  </div>
+                  <div style={{ display: 'flex', gap: 4 }}>
+                    {([
+                      { emcon: false, label: 'EMCON OFF', color: 'var(--status-ready)' },
+                      { emcon: true, label: 'EMCON ON', color: 'var(--status-engaged)' },
+                    ] as const).map((opt) => {
+                      const active = (unit.emcon ?? false) === opt.emcon
+                      return (
+                        <button
+                          key={opt.label}
+                          onClick={() => sendCommand({
+                            type: 'SET_EMCON',
+                            unitId: unit.id,
+                            emcon: opt.emcon,
+                          })}
+                          style={{
+                            flex: 1,
+                            padding: '5px 4px',
+                            background: active ? opt.color : 'var(--bg-hover)',
+                            border: active
+                              ? `1px solid ${opt.color}`
+                              : '1px solid var(--border-default)',
+                            borderRadius: 4,
+                            color: active ? 'var(--bg-primary)' : 'var(--text-secondary)',
+                            cursor: 'pointer',
+                            fontFamily: 'var(--font-mono)',
+                            fontSize: 'var(--font-size-xs)',
+                            fontWeight: active ? 700 : 400,
+                            whiteSpace: 'nowrap',
+                          }}
+                        >
+                          {opt.label}
+                        </button>
+                      )
+                    })}
+                  </div>
+                  <div style={{
+                    color: 'var(--text-muted)',
+                    fontSize: '0.55rem',
+                    fontStyle: 'italic',
+                    marginTop: 3,
+                    lineHeight: 1.4,
+                  }}>
+                    Radar silent: invisible to ELINT, blind without datalink
+                  </div>
+                </>
+              )}
+
               {isDroneCapable && (
                 <>
                   <div style={{
diff --git a/src/components/panels/__tests__/IntelPanel.test.tsx b/src/components/panels/__tests__/IntelPanel.test.tsx
new file mode 100644
index 0000000..1889ab9
--- /dev/null
+++ b/src/components/panels/__tests__/IntelPanel.test.tsx
@@ -0,0 +1,303 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { render, screen, fireEvent, waitFor } from '@testing-library/react'
+import IntelPanel from '../IntelPanel'
+import { useGameStore } from '@/store/game-store'
+import { useIntelStore } from '@/store/intel-store'
+import { sendCommand } from '@/store/bridge'
+import type { GameViewState, IntelViewState, ViewUnit } from '@/types/view'
+
+vi.mock('@/store/bridge', () => ({
+  sendCommand: vi.fn(),
+  getFullState: vi.fn(),
+  loadState: vi.fn(),
+}))
+
+vi.mock('@/intel/osint-feed', () => ({
+  useOsintFeed: () => [
+    {
+      id: 'post_1',
+      handle: '@GulfPlaneWatch',
+      displayName: 'Gulf Plane Watch',
+      color: '#7fb3d5',
+      tick: 600,
+      text: 'Heavy tanker activity out of Al Udeid this morning.',
+    },
+  ],
+}))
+
+const TICK = 7200
+
+function makeUnit(id: string, nation: string, overrides: Partial<ViewUnit> = {}): ViewUnit {
+  return {
+    id,
+    name: id,
+    nation,
+    category: 'ship',
+    position: { lat: 26.2, lng: 56.3 },
+    heading: 0,
+    speed_kts: 0,
+    status: 'ready',
+    health: 100,
+    maxHealth: 100,
+    logistics: 100,
+    supplyStocks: [],
+    weapons: [],
+    pointDefense: [],
+    sensors: [],
+    roe: 'weapons_free',
+    waypoints: [],
+    subordinateIds: [],
+    visibility: 'identified',
+    stale: false,
+    ...overrides,
+  } as ViewUnit
+}
+
+function makeIntel(over: Partial<IntelViewState> = {}): IntelViewState {
+  return {
+    assets: [
+      {
+        id: 'kh11',
+        nation: 'usa',
+        name: 'KH-11 CRYSTAL',
+        kind: 'optical_sat',
+        status: 'active',
+        revisit_min: 240,
+        lastCollectionTick: 0,
+        niirs: 8,
+      },
+      {
+        id: 'rc135',
+        nation: 'usa',
+        name: 'RC-135 RIVET JOINT',
+        kind: 'sigint_air',
+        status: 'active',
+        revisit_min: 0,
+        lastCollectionTick: 0,
+      },
+    ],
+    agents: [
+      {
+        id: 'amber',
+        codename: 'AMBER',
+        placement: 'Port logistics clerk, Bandar Abbas',
+        product: 'Naval activity in the Bandar Abbas-Jask complex',
+        status: 'active',
+        exposure: 25,
+        lastTaskedTick: -999_999,
+      },
+    ],
+    products: [
+      {
+        id: 'prod_1',
+        kind: 'sigint',
+        tick: 1200,
+        classification: 'TOP SECRET//SI',
+        caption: 'Air-defense net: calibration chatter, sectors quiet.',
+        precedence: 'ROUTINE',
+      },
+    ],
+    taskings: [],
+    leakLevel: 25,
+    paranoiaBand: 'LOW',
+    encryptionUpgradedUntilTick: null,
+    ...over,
+  }
+}
+
+function setStore(intel: IntelViewState, units: ViewUnit[]) {
+  const viewState: GameViewState = {
+    playerNation: 'usa',
+    initialized: true,
+    time: { tick: TICK, timestamp: 0, speed: 0, tickIntervalMs: 100 },
+    nations: [],
+    units,
+    missiles: [],
+    supplyLines: [],
+    shippingLanes: [],
+    events: [],
+    pendingEventCount: 0,
+    satelliteDetectedUnitIds: [],
+    warSupport: {},
+    gameOver: null,
+    objectives: [],
+    intel,
+  }
+  useGameStore.setState({ viewState, eventLog: [] })
+}
+
+const defaultUnits = () => [
+  makeUnit('usa_ddg', 'usa', {
+    name: 'USS Gravely',
+    sensors: [{ type: 'radar', range_km: 300, detection_prob: 0.9 }],
+  }),
+  makeUnit('iran_ffg', 'iran', { name: 'IRIS Jamaran', visibility: 'tracked' }),
+]
+
+beforeEach(() => {
+  vi.mocked(sendCommand).mockClear()
+  useIntelStore.setState({ activeTab: 'isr', estimatedUnits: [], placingCatalogId: null })
+  vi.stubGlobal('fetch', vi.fn(() => Promise.reject(new Error('offline'))))
+  setStore(makeIntel(), defaultUnits())
+})
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('IntelPanel tabs', () => {
+  it('switches between the five tabs', () => {
+    render(<IntelPanel />)
+
+    // ISR is the default tab
+    expect(screen.getByText('KH-11 CRYSTAL')).toBeTruthy()
+
+    fireEvent.click(screen.getByRole('button', { name: 'SIGINT' }))
+    expect(screen.getByText(/calibration chatter/)).toBeTruthy()
+
+    fireEvent.click(screen.getByRole('button', { name: 'HUMINT' }))
+    expect(screen.getByText('AMBER')).toBeTruthy()
+
+    fireEvent.click(screen.getByRole('button', { name: 'OSINT' }))
+    expect(screen.getByText('@GulfPlaneWatch')).toBeTruthy()
+
+    fireEvent.click(screen.getByRole('button', { name: 'OPSEC' }))
+    expect(screen.getByText('OPSEC SWEEP')).toBeTruthy()
+  })
+})
+
+describe('ISR tab', () => {
+  it('shows a TASK PASS button on taskable assets only', () => {
+    render(<IntelPanel />)
+    expect(screen.getAllByText('TASK PASS')).toHaveLength(1) // kh11 yes, rc135 no
+  })
+
+  it('shows next-pass countdown from lastCollectionTick + revisit', () => {
+    render(<IntelPanel />)
+    // kh11: 240min revisit, last pass tick 0, now 7200 → 7200s left = 2h
+    expect(screen.getByText(/NEXT PASS 2h 00m/)).toBeTruthy()
+    // rc135: revisit 0 → continuous
+    expect(screen.getByText(/NEXT PASS CONTINUOUS/)).toBeTruthy()
+  })
+
+  it('queues a pass without cloudPct when the weather fetch fails', async () => {
+    render(<IntelPanel />)
+    fireEvent.click(screen.getByText('TASK PASS'))
+    fireEvent.click(screen.getByText('IRIS Jamaran'))
+
+    await waitFor(() => {
+      expect(sendCommand).toHaveBeenCalledWith({
+        type: 'TASK_SATELLITE_PASS',
+        assetId: 'kh11',
+        target: { lat: 26.2, lng: 56.3 },
+      })
+    })
+  })
+
+  it('passes real cloud cover as cloudPct when the fetch succeeds', async () => {
+    vi.stubGlobal('fetch', vi.fn(() => Promise.resolve({
+      ok: true,
+      json: () => Promise.resolve({ current: { cloud_cover: 42 } }),
+    })))
+    render(<IntelPanel />)
+    fireEvent.click(screen.getByText('TASK PASS'))
+    fireEvent.click(screen.getByText('IRIS Jamaran'))
+
+    await waitFor(() => {
+      expect(sendCommand).toHaveBeenCalledWith({
+        type: 'TASK_SATELLITE_PASS',
+        assetId: 'kh11',
+        target: { lat: 26.2, lng: 56.3 },
+        cloudPct: 42,
+      })
+    })
+  })
+
+  it('lists queued taskings', () => {
+    setStore(
+      makeIntel({
+        taskings: [{ id: 'task_1', assetId: 'kh11', target: { lat: 27.1, lng: 56.0 }, queuedTick: 7000 }],
+      }),
+      defaultUnits(),
+    )
+    render(<IntelPanel />)
+    expect(screen.getByText('Queued Taskings')).toBeTruthy()
+    expect(screen.getByText('27.10N 56.00E')).toBeTruthy()
+  })
+})
+
+describe('SIGINT tab', () => {
+  it('shows the encryption blackout banner with countdown when upgraded', () => {
+    setStore(makeIntel({ encryptionUpgradedUntilTick: TICK + 3600 }), defaultUnits())
+    render(<IntelPanel />)
+    fireEvent.click(screen.getByRole('button', { name: 'SIGINT' }))
+    expect(screen.getByText(/COLLECTION DARK/)).toBeTruthy()
+    expect(screen.getByText(/resume in 1h 00m/)).toBeTruthy()
+  })
+
+  it('hides the banner when the blackout has expired', () => {
+    setStore(makeIntel({ encryptionUpgradedUntilTick: TICK - 1 }), defaultUnits())
+    render(<IntelPanel />)
+    fireEvent.click(screen.getByRole('button', { name: 'SIGINT' }))
+    expect(screen.queryByText(/COLLECTION DARK/)).toBeNull()
+  })
+})
+
+describe('HUMINT tab', () => {
+  it('TASK dispatches TASK_AGENT', () => {
+    render(<IntelPanel />)
+    fireEvent.click(screen.getByRole('button', { name: 'HUMINT' }))
+    fireEvent.click(screen.getByText('TASK'))
+    expect(sendCommand).toHaveBeenCalledWith({ type: 'TASK_AGENT', agentId: 'amber' })
+  })
+
+  it('disables TASK during the 1h cooldown', () => {
+    const intel = makeIntel()
+    intel.agents[0].lastTaskedTick = TICK - 600 // tasked 10min ago
+    setStore(intel, defaultUnits())
+    render(<IntelPanel />)
+    fireEvent.click(screen.getByRole('button', { name: 'HUMINT' }))
+
+    const task = screen.getByText('TASK') as HTMLButtonElement
+    expect(task.disabled).toBe(true)
+    fireEvent.click(task)
+    expect(sendCommand).not.toHaveBeenCalled()
+  })
+
+  it('renders arrested agents as tombstones without action buttons', () => {
+    const intel = makeIntel()
+    intel.agents[0].status = 'arrested'
+    setStore(intel, defaultUnits())
+    render(<IntelPanel />)
+    fireEvent.click(screen.getByRole('button', { name: 'HUMINT' }))
+
+    expect(screen.getByText('ARRESTED')).toBeTruthy()
+    expect(screen.queryByText('TASK')).toBeNull()
+    expect(screen.queryByText('EXFILTRATE')).toBeNull()
+  })
+})
+
+describe('OPSEC tab', () => {
+  it('OPSEC SWEEP dispatches OPSEC_SWEEP', () => {
+    render(<IntelPanel />)
+    fireEvent.click(screen.getByRole('button', { name: 'OPSEC' }))
+    fireEvent.click(screen.getByText('OPSEC SWEEP'))
+    expect(sendCommand).toHaveBeenCalledWith({ type: 'OPSEC_SWEEP' })
+  })
+
+  it('toggles EMCON on own radar units', () => {
+    render(<IntelPanel />)
+    fireEvent.click(screen.getByRole('button', { name: 'OPSEC' }))
+
+    expect(screen.getByText('USS Gravely')).toBeTruthy()
+    fireEvent.click(screen.getByText('RADIATING'))
+    expect(sendCommand).toHaveBeenCalledWith({ type: 'SET_EMCON', unitId: 'usa_ddg', emcon: true })
+  })
+
+  it('shows the Iranian counterintel posture band', () => {
+    setStore(makeIntel({ paranoiaBand: 'SEVERE' }), defaultUnits())
+    render(<IntelPanel />)
+    fireEvent.click(screen.getByRole('button', { name: 'OPSEC' }))
+    expect(screen.getByText('SEVERE')).toBeTruthy()
+  })
+})
diff --git a/src/components/panels/__tests__/StatsPanel.test.tsx b/src/components/panels/__tests__/StatsPanel.test.tsx
index 9df6817..b71ea95 100644
--- a/src/components/panels/__tests__/StatsPanel.test.tsx
+++ b/src/components/panels/__tests__/StatsPanel.test.tsx
@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import { render, screen } from '@testing-library/react'
-import StatsPanel, { computeNationStats } from '../StatsPanel'
+import StatsPanel, { computeNationStats, computeArsenal } from '../StatsPanel'
 import { useGameStore } from '@/store/game-store'
 import type { GameEvent, Nation } from '@/types/game'
 import type { GameViewState, ViewUnit } from '@/types/view'
@@ -75,6 +75,57 @@ describe('computeNationStats interception rate', () => {
   })
 })
 
+describe('computeArsenal', () => {
+  it('sums loaded weapons, base reserves and industry rate per weapon type', () => {
+    const ship = makeUnit('usa_ship', 'usa', {
+      weapons: [
+        { weaponId: 'tomahawk', count: 40, maxCount: 60, reloadTimeSec: 0 },
+        { weaponId: 'sm6', count: 80, maxCount: 96, reloadTimeSec: 0 },
+      ],
+    })
+    const base = makeUnit('usa_base', 'usa', {
+      category: 'airbase',
+      supplyStocks: [
+        { weaponId: 'tomahawk', count: 96, maxCount: 96, productionRate: 1 },
+        { weaponId: 'jassm_er', count: 32, maxCount: 32, productionRate: 0.5 },
+      ],
+    })
+    const destroyedBase = makeUnit('usa_dead', 'usa', {
+      status: 'destroyed',
+      supplyStocks: [{ weaponId: 'tomahawk', count: 50, maxCount: 50, productionRate: 5 }],
+    })
+    const enemy = makeUnit('iran_tel', 'iran', {
+      weapons: [{ weaponId: 'fateh110', count: 12, maxCount: 12, reloadTimeSec: 0 }],
+    })
+
+    const rows = computeArsenal([ship, base, destroyedBase, enemy], 'usa')
+
+    const tomahawk = rows.find(r => r.weaponId === 'tomahawk')
+    expect(tomahawk).toMatchObject({ deployed: 40, deployedMax: 60, reserve: 96, prodPerHour: 1 })
+    const jassm = rows.find(r => r.weaponId === 'jassm_er')
+    expect(jassm).toMatchObject({ deployed: 0, reserve: 32, prodPerHour: 0.5 })
+    // Destroyed bases produce nothing; enemy weapons never appear
+    expect(rows.find(r => r.weaponId === 'fateh110')).toBeUndefined()
+    // Sorted by total stock descending
+    expect(rows[0].weaponId).toBe('tomahawk')
+  })
+
+  it('renders the arsenal table with industry total for the player nation', () => {
+    setStore([
+      makeUnit('usa_base', 'usa', {
+        category: 'airbase',
+        weapons: [{ weaponId: 'tomahawk', count: 10, maxCount: 20, reloadTimeSec: 0 }],
+        supplyStocks: [{ weaponId: 'tomahawk', count: 96, maxCount: 96, productionRate: 1 }],
+      }),
+    ])
+    render(<StatsPanel />)
+    expect(screen.getByText('ARSENAL')).toBeTruthy()
+    expect(screen.getByText('INDUSTRY +1/h')).toBeTruthy()
+    expect(screen.getAllByText('10/20').length).toBeGreaterThanOrEqual(1)
+    expect(screen.getByText('96')).toBeTruthy()
+  })
+})
+
 function setStore(units: ViewUnit[], eventLog: GameEvent[] = []) {
   const viewState: GameViewState = {
     playerNation: 'usa',
@@ -94,6 +145,7 @@ function setStore(units: ViewUnit[], eventLog: GameEvent[] = []) {
     warSupport: {},
     gameOver: null,
     objectives: [],
+    intel: { assets: [], agents: [], products: [], taskings: [], leakLevel: 0, paranoiaBand: 'LOW' as const, encryptionUpgradedUntilTick: null },
   }
   useGameStore.setState({ viewState, eventLog, visualTimestamp: 0, lastUpdateRealMs: 0, visualRate: 0 })
 }
diff --git a/src/components/panels/__tests__/UnitInfoPanel.test.tsx b/src/components/panels/__tests__/UnitInfoPanel.test.tsx
index 322f838..0e13998 100644
--- a/src/components/panels/__tests__/UnitInfoPanel.test.tsx
+++ b/src/components/panels/__tests__/UnitInfoPanel.test.tsx
@@ -3,6 +3,7 @@ import { render, screen } from '@testing-library/react'
 import UnitInfoPanel from '../UnitInfoPanel'
 import { useGameStore } from '@/store/game-store'
 import { useUIStore } from '@/store/ui-store'
+import { UNIT_IMAGES } from '@/data/unit-images'
 import type { GameViewState, ViewUnit } from '@/types/view'
 
 function makeUnit(overrides: Partial<ViewUnit> & Pick<ViewUnit, 'id'>): ViewUnit {
@@ -46,6 +47,7 @@ function setup(unit: ViewUnit) {
     warSupport: {},
     gameOver: null,
     objectives: [],
+    intel: { assets: [], agents: [], products: [], taskings: [], leakLevel: 0, paranoiaBand: 'LOW' as const, encryptionUpgradedUntilTick: null },
   } as GameViewState
   useGameStore.setState({ viewState })
   useUIStore.setState({ selectedUnitId: unit.id, selectedUnitIds: new Set([unit.id]) })
@@ -90,3 +92,27 @@ describe('UnitInfoPanel fog of war', () => {
     expect(screen.queryByText('NO LOADOUT DATA')).toBeNull()
   })
 })
+
+describe('UnitInfoPanel recognition photo', () => {
+  it('shows photo with author · license credit for identified enemy units', () => {
+    setup(makeUnit({ id: 'c4', name: 'Ghadir-class Sub (Jask)', category: 'submarine' }))
+    const img = screen.getByAltText('Ghadir-class Sub (Jask)')
+    expect(img.getAttribute('src')).toBe('/unit-images/ghadir_sub.jpg')
+    const meta = UNIT_IMAGES.ghadir_sub
+    expect(screen.getByText(`${meta.author} · ${meta.license}`)).toBeTruthy()
+  })
+
+  it('hides photo and credit for tracked enemy units', () => {
+    setup(makeUnit({ id: 'c5', name: 'Ghadir-class Sub (Jask)', category: 'submarine', visibility: 'tracked' }))
+    expect(screen.queryByAltText('Ghadir-class Sub (Jask)')).toBeNull()
+    expect(screen.queryByText(/CC BY/)).toBeNull()
+  })
+
+  it('always shows photo for own units', () => {
+    setup(makeUnit({ id: 'c6', name: 'DDG-89 USS Mustin', nation: 'usa' }))
+    const img = screen.getByAltText('DDG-89 USS Mustin')
+    expect(img.getAttribute('src')).toBe('/unit-images/arleigh_burke.jpg')
+    const meta = UNIT_IMAGES.arleigh_burke
+    expect(screen.getByText(`${meta.author} · ${meta.license}`)).toBeTruthy()
+  })
+})
diff --git a/src/data/__tests__/unit-images.test.ts b/src/data/__tests__/unit-images.test.ts
new file mode 100644
index 0000000..1aee3ac
--- /dev/null
+++ b/src/data/__tests__/unit-images.test.ts
@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest'
+import { UNIT_IMAGES, unitImageKey } from '../unit-images'
+import { usaUnits } from '../units/usa-orbat'
+import { iranUnits } from '../units/iran-orbat'
+
+describe('unitImageKey', () => {
+  it('maps US naval classes', () => {
+    expect(unitImageKey({ name: 'CVN-72 Abraham Lincoln CSG', category: 'carrier_group' })).toBe('nimitz_cvn')
+    expect(unitImageKey({ name: 'DDG-89 USS Mustin', category: 'ship' })).toBe('arleigh_burke')
+    expect(unitImageKey({ name: 'SSN-789 USS Indiana', category: 'submarine' })).toBe('virginia_ssn')
+    expect(unitImageKey({ name: 'NSA Bahrain (5th Fleet HQ)', category: 'naval_base' })).toBe('nsa_bahrain')
+  })
+
+  it('maps US air defense and aircraft', () => {
+    expect(unitImageKey({ name: 'Patriot Battery (Qatar)', category: 'sam_site' })).toBe('patriot')
+    expect(unitImageKey({ name: 'THAAD Battery (UAE)', category: 'sam_site' })).toBe('thaad')
+    expect(unitImageKey({ name: 'E-3 Sentry AWACS', category: 'aircraft' })).toBe('e3_sentry')
+  })
+
+  it('splits airbases between US and Iran by name', () => {
+    expect(unitImageKey({ name: 'Al Udeid Air Base', category: 'airbase' })).toBe('us_airbase')
+    expect(unitImageKey({ name: 'Diego Garcia', category: 'airbase' })).toBe('us_airbase')
+    expect(unitImageKey({ name: 'Mehrabad Air Base (Tehran)', category: 'airbase' })).toBe('iran_airbase')
+    expect(unitImageKey({ name: 'Tabriz Air Base (2nd TFB)', category: 'airbase' })).toBe('iran_airbase')
+  })
+
+  it('maps Iranian SAM, missile, and naval classes', () => {
+    expect(unitImageKey({ name: 'S-300PMU-2 (Isfahan)', category: 'sam_site' })).toBe('s300pmu2')
+    expect(unitImageKey({ name: 'Bavar-373 (Tehran)', category: 'sam_site' })).toBe('bavar373')
+    expect(unitImageKey({ name: '3rd Khordad (Bandar Abbas)', category: 'sam_site' })).toBe('khordad3')
+    expect(unitImageKey({ name: 'Tor-M1 (Isfahan)', category: 'sam_site' })).toBe('tor_m1')
+    expect(unitImageKey({ name: 'Shahab-3 TEL (Tabriz)', category: 'missile_battery' })).toBe('shahab3')
+    expect(unitImageKey({ name: 'Sejjil-2 TEL (Semnan)', category: 'missile_battery' })).toBe('sejjil2')
+    expect(unitImageKey({ name: 'Fateh-110 Battery (Dezful)', category: 'missile_battery' })).toBe('fateh110')
+    expect(unitImageKey({ name: 'Zolfaghar Battery (Kermanshah)', category: 'missile_battery' })).toBe('zolfaghar')
+    expect(unitImageKey({ name: 'Soumar GLCM Battery', category: 'missile_battery' })).toBe('soumar')
+    expect(unitImageKey({ name: 'Shahed-136 Battery (Kermanshah)', category: 'missile_battery' })).toBe('shahed136')
+    expect(unitImageKey({ name: 'Ghadir-class Sub (Jask)', category: 'submarine' })).toBe('ghadir_sub')
+    expect(unitImageKey({ name: 'Hormuz Coastal Battery', category: 'missile_battery' })).toBe('noor_coastal')
+    expect(unitImageKey({ name: 'Qeshm Island Battery', category: 'missile_battery' })).toBe('noor_coastal')
+    expect(unitImageKey({ name: 'IRGC FAC Group (Hormuz)', category: 'ship' })).toBe('irgc_fac')
+  })
+
+  it('returns null for units without recognition imagery', () => {
+    expect(unitImageKey({ name: 'IRGC Minefield — North Hormuz', category: 'minefield' })).toBeNull()
+    expect(unitImageKey({ name: 'Mobile Command Post', category: 'missile_battery' })).toBeNull()
+    expect(unitImageKey({ name: 'Bandar Abbas Naval Base (IRIN 1st District)', category: 'naval_base' })).toBeNull()
+    expect(unitImageKey({ name: 'Nebo SVU EW Radar', category: 'sam_site' })).toBeNull()
+  })
+})
+
+describe('UNIT_IMAGES', () => {
+  it('every entry carries file, author, license, and source for the credit line', () => {
+    const allowed = /^(Public domain|CC0|CC BY(-SA)?( \d\.\d)?|Attribution)$/i
+    for (const [key, e] of Object.entries(UNIT_IMAGES)) {
+      expect(e.file, key).toBe(`${key}.jpg`)
+      expect(e.author.length, key).toBeGreaterThan(0)
+      expect(e.license, key).toMatch(allowed)
+      expect(e.sourceUrl, key).toMatch(/^https:\/\/commons\.wikimedia\.org\//)
+    }
+  })
+
+  it('covers at least 12 ORBAT units with downloaded images', () => {
+    const covered = [...usaUnits, ...iranUnits].filter((u) => {
+      const key = unitImageKey(u)
+      return key !== null && UNIT_IMAGES[key] !== undefined
+    })
+    expect(covered.length).toBeGreaterThanOrEqual(12)
+  })
+})
diff --git a/src/data/air/airframes.ts b/src/data/air/airframes.ts
new file mode 100644
index 0000000..712f9df
--- /dev/null
+++ b/src/data/air/airframes.ts
@@ -0,0 +1,134 @@
+import type { AirframeId, Sensor } from '@/types/game'
+
+/**
+ * Airframe performance table — design: docs/plans/air-war-v5.md §1.
+ * A2A combat is a pK-roll abstraction (no missile entities): one engagement
+ * roll per 30 game-s inside 40 km, shots = per-airframe magazine.
+ */
+export interface AirframeSpec {
+  id: AirframeId
+  name: string
+  /** Cruise speed for transit (kts) */
+  speed_kts: number
+  combat_radius_km: number
+  /** Sensors mounted per flight (antenna_height_m carries the airborne range bonus) */
+  sensors: Sensor[]
+  /** Strike loadout per airframe: weaponId × countPerAirframe (empty = no strike role) */
+  strikeWeapons: { weaponId: string; countPerAirframe: number }[]
+  /** A2A magazine + kill probabilities per target class */
+  a2a: { shots: number; pkFighter: number; pkLarge: number } | null
+  /** AEW hubs relay fire-control tracks */
+  datalink_range_km?: number
+  rcsClass: 'stealth' | 'fighter' | 'large'
+}
+
+const radar = (range_km: number, antenna_height_m: number): Sensor => ({
+  type: 'radar',
+  range_km,
+  detection_prob: 0.9,
+  antenna_height_m,
+})
+
+export const AIRFRAMES: Record<AirframeId, AirframeSpec> = {
+  fa18e: {
+    id: 'fa18e',
+    name: 'F/A-18E Super Hornet',
+    speed_kts: 480,
+    combat_radius_km: 740,
+    sensors: [radar(150, 9000)],
+    strikeWeapons: [{ weaponId: 'jassm_er', countPerAirframe: 2 }],
+    a2a: { shots: 6, pkFighter: 0.65, pkLarge: 0.85 },
+    rcsClass: 'fighter',
+  },
+  f35c: {
+    id: 'f35c',
+    name: 'F-35C Lightning II',
+    speed_kts: 500,
+    combat_radius_km: 1100,
+    sensors: [radar(170, 9000)],
+    strikeWeapons: [{ weaponId: 'jassm_er', countPerAirframe: 2 }],
+    a2a: { shots: 4, pkFighter: 0.75, pkLarge: 0.9 },
+    rcsClass: 'stealth',
+  },
+  ea18g: {
+    id: 'ea18g',
+    name: 'EA-18G Growler',
+    speed_kts: 480,
+    combat_radius_km: 700,
+    sensors: [radar(120, 9000)],
+    strikeWeapons: [],
+    a2a: { shots: 2, pkFighter: 0.4, pkLarge: 0.6 },
+    rcsClass: 'fighter',
+  },
+  e2d: {
+    id: 'e2d',
+    name: 'E-2D Advanced Hawkeye',
+    speed_kts: 330,
+    combat_radius_km: 600,
+    sensors: [radar(450, 9000)],
+    strikeWeapons: [],
+    a2a: null,
+    datalink_range_km: 600,
+    rcsClass: 'large',
+  },
+  f14: {
+    id: 'f14',
+    name: 'F-14AM Tomcat',
+    speed_kts: 480,
+    combat_radius_km: 700,
+    sensors: [radar(160, 9000)],
+    strikeWeapons: [],
+    a2a: { shots: 4, pkFighter: 0.5, pkLarge: 0.75 },
+    rcsClass: 'fighter',
+  },
+  mig29: {
+    id: 'mig29',
+    name: 'MiG-29A Fulcrum',
+    speed_kts: 470,
+    combat_radius_km: 550,
+    sensors: [radar(100, 9000)],
+    strikeWeapons: [],
+    a2a: { shots: 4, pkFighter: 0.45, pkLarge: 0.7 },
+    rcsClass: 'fighter',
+  },
+  su24: {
+    id: 'su24',
+    name: 'Su-24MK Fencer',
+    speed_kts: 470,
+    combat_radius_km: 600,
+    sensors: [radar(90, 9000)],
+    strikeWeapons: [{ weaponId: 'noor', countPerAirframe: 2 }],
+    a2a: null,
+    rcsClass: 'large',
+  },
+  su35: {
+    id: 'su35',
+    name: 'Su-35SE Flanker-E',
+    speed_kts: 500,
+    combat_radius_km: 900,
+    sensors: [radar(180, 9000)],
+    strikeWeapons: [],
+    a2a: { shots: 6, pkFighter: 0.6, pkLarge: 0.85 },
+    rcsClass: 'fighter',
+  },
+}
+
+// Sortie economy (CMO published numbers — roadmap Wave C)
+export const CAP_TURNAROUND_TICKS = 90 * 60
+export const STRIKE_TURNAROUND_SURGE_TICKS = 6 * 3600
+export const STRIKE_TURNAROUND_SUSTAINED_TICKS = 20 * 3600
+export const SURGE_OPS_DURATION_TICKS = 96 * 3600
+/** Fraction of each squadron down for maintenance at scenario start */
+export const MAINTENANCE_FRACTION = 0.3
+/** Strike planning delay window (game-seconds) */
+export const STRIKE_PLANNING_MIN_TICKS = 2 * 3600
+export const STRIKE_PLANNING_MAX_TICKS = 6 * 3600
+/** A2A engagement model */
+export const A2A_COMMIT_RANGE_KM = 120
+export const A2A_ENGAGE_RANGE_KM = 40
+export const A2A_ROLL_INTERVAL_TICKS = 30
+/** SEAD escort effect radius + multiplier */
+export const SEAD_RADIUS_KM = 80
+export const SEAD_MULTIPLIER = 0.6
+export const EXTENDED_RANGE_BONUS = 1.35
+export const EXTENDED_RANGE_SORTIE_COST = 2
diff --git a/src/data/air/airwings.ts b/src/data/air/airwings.ts
new file mode 100644
index 0000000..3afef81
--- /dev/null
+++ b/src/data/air/airwings.ts
@@ -0,0 +1,49 @@
+import type { SquadronState, UnitId } from '@/types/game'
+
+/**
+ * Air wings per host unit — design: docs/plans/air-war-v5.md §1.
+ * CVW-9 composition matches the real 2026 Lincoln deployment; Iranian numbers
+ * reflect the June-2025 reality (low readiness, parked airframes).
+ * `available` is set at init time (total minus maintenance) by initAirWings.
+ */
+const sq = (id: string, name: string, airframe: SquadronState['airframe'], total: number): SquadronState => ({
+  id,
+  name,
+  airframe,
+  total,
+  available: total,
+  readyAt: [],
+})
+
+export const AIR_WINGS: Record<UnitId, SquadronState[]> = {
+  // ── USA: CVW-9 aboard CVN-72 Abraham Lincoln ──
+  cvn72_lincoln: [
+    sq('vfa14', 'VFA-14 Tophatters', 'fa18e', 12),
+    sq('vfa41', 'VFA-41 Black Aces', 'fa18e', 12),
+    sq('vfa97', 'VFA-97 Warhawks', 'f35c', 10),
+    sq('vaq133', 'VAQ-133 Wizards', 'ea18g', 6),
+    sq('vaw116', 'VAW-116 Sun Kings', 'e2d', 5),
+  ],
+  // Land-based USAF detachments
+  al_udeid: [
+    sq('efs_udeid', '94th EFS (F-15E det.)', 'fa18e', 8),
+  ],
+  al_dhafra: [
+    sq('efs_dhafra', '380th AEW (F-35A det.)', 'f35c', 6),
+  ],
+
+  // ── Iran: IRIAF (scramble-only readiness) ──
+  isfahan_ab: [
+    sq('tfb8_f14', '81st TFS Tomcats', 'f14', 12),
+  ],
+  mehrabad: [
+    sq('tfb1_su35', 'Su-35SE Group', 'su35', 8),
+    sq('tfb1_mig29', '11th TFS Fulcrums', 'mig29', 10),
+  ],
+  tabriz_ab: [
+    sq('tfb2_mig29', '23rd TFS Fulcrums', 'mig29', 8),
+  ],
+  bushehr_ab: [
+    sq('tfb6_su24', '72nd TFS Fencers', 'su24', 10),
+  ],
+}
diff --git a/src/data/feeds.ts b/src/data/feeds.ts
new file mode 100644
index 0000000..1775c06
--- /dev/null
+++ b/src/data/feeds.ts
@@ -0,0 +1,119 @@
+/**
+ * Central config for every REAL external data source the game uses.
+ * All endpoints verified keyless + CORS-enabled 2026-06-10 (research sweep).
+ * Every consumer MUST degrade gracefully on fetch failure — these are
+ * community/agency services and they drift.
+ *
+ * Compliance: the game must stay free/non-revenue (Esri free-use, EOX CC-BY-NC-SA).
+ * Attribution lives in the LIVE FEEDS window credits panel (INTEL_SOURCES below).
+ */
+
+/** Slippy-map tile coordinates from lat/lon (verified against Bandar Abbas fixtures) */
+export function lonLatToTile(lon: number, lat: number, z: number): { x: number; y: number } {
+  const x = Math.floor(((lon + 180) / 360) * 2 ** z)
+  const latRad = (lat * Math.PI) / 180
+  const y = Math.floor(((1 - Math.log(Math.tan(latRad) + 1 / Math.cos(latRad)) / Math.PI) / 2) * 2 ** z)
+  return { x, y }
+}
+
+/** Esri World Imagery — high-res IMINT backdrops + FMV scenery. NOTE: path is z/y/x. */
+export function esriImageryTileUrl(z: number, x: number, y: number): string {
+  return `https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/${z}/${y}/${x}`
+}
+
+/** Yesterday UTC as YYYY-MM-DD — the safe GIBS/Worldview date (today may not be downlinked) */
+export function safeGibsDate(now: Date = new Date()): string {
+  const d = new Date(now.getTime() - 24 * 3600 * 1000)
+  return d.toISOString().slice(0, 10)
+}
+
+/**
+ * NASA Worldview Snapshot — one keyless fetch returns a date-stamped recon JPEG
+ * of any bbox. The IMINT product generator. 404 on a date = "pass not downlinked yet".
+ */
+export function worldviewSnapshotUrl(opts: {
+  date: string
+  south: number
+  west: number
+  north: number
+  east: number
+  width?: number
+  height?: number
+}): string {
+  const { date, south, west, north, east, width = 768, height = 512 } = opts
+  return (
+    'https://wvs.earthdata.nasa.gov/api/v1/snapshot?REQUEST=GetSnapshot' +
+    '&LAYERS=VIIRS_SNPP_CorrectedReflectance_TrueColor&CRS=EPSG:4326' +
+    `&TIME=${date}&BBOX=${south},${west},${north},${east}` +
+    `&WIDTH=${width}&HEIGHT=${height}&FORMAT=image/jpeg`
+  )
+}
+
+/**
+ * NASA GIBS WMTS — daily VIIRS true color as a maplibre raster source.
+ * maxzoom 9. NEVER use TIME=default (resolves to tomorrow UTC → 404).
+ */
+export function gibsDailyTrueColorTiles(date: string): { tiles: string[]; maxzoom: number; attribution: string } {
+  return {
+    tiles: [
+      `https://gibs.earthdata.nasa.gov/wmts/epsg3857/best/VIIRS_SNPP_CorrectedReflectance_TrueColor/default/${date}/GoogleMapsCompatible_Level9/{z}/{y}/{x}.jpg`,
+    ],
+    maxzoom: 9,
+    attribution: 'NASA GIBS',
+  }
+}
+
+/**
+ * EUMETSAT EUMETView WMS — Meteosat-9 IODC, 15-minute cadence over the Gulf.
+ * The one genuinely LIVE satellite source. ir108 works at night.
+ */
+export function eumetsatLiveUrl(opts: {
+  layer: 'rgb_naturalenhncd' | 'ir108'
+  south: number
+  west: number
+  north: number
+  east: number
+  width?: number
+  height?: number
+}): string {
+  const { layer, south, west, north, east, width = 640, height = 480 } = opts
+  return (
+    'https://view.eumetsat.int/geoserver/wms?service=WMS&request=GetMap&version=1.3.0' +
+    `&layers=msg_iodc:${layer}&styles=&format=image/jpeg&crs=EPSG:4326` +
+    `&bbox=${south},${west},${north},${east}&width=${width}&height=${height}`
+  )
+}
+
+/** airplanes.live — real live ADS-B over the Gulf. ~1 req/s limit: poll every 45 s, radius ≤ 250 nm. */
+export function adsbLiveUrl(lat: number, lon: number, radiusNm: number): string {
+  return `https://api.airplanes.live/v2/point/${lat.toFixed(3)}/${lon.toFixed(3)}/${Math.min(250, radiusNm)}`
+}
+
+export const ADSB_POLL_INTERVAL_MS = 45_000
+
+/** Open-Meteo — real current cloud cover, gates optical satellite tasking */
+export function cloudCoverUrl(lat: number, lon: number): string {
+  return `https://api.open-meteo.com/v1/forecast?latitude=${lat.toFixed(3)}&longitude=${lon.toFixed(3)}&current=cloud_cover`
+}
+
+/** Reuters "Vessel traffic in Strait of Hormuz" live stream (verified embeddable via oEmbed) */
+export const HORMUZ_LIVE_YOUTUBE_ID = 'osUeQTR91Ig'
+
+export function youtubeEmbedUrl(videoId: string): string {
+  return `https://www.youtube-nocookie.com/embed/${videoId}?autoplay=1&mute=1`
+}
+
+/** EUMETSAT live window default bbox — the Gulf theater */
+export const GULF_BBOX = { south: 22, west: 44, north: 32, east: 62 }
+
+/** Attribution for the LIVE FEEDS credits panel — required by source terms */
+export const INTEL_SOURCES: { name: string; role: string }[] = [
+  { name: 'Esri · Maxar · Earthstar Geographics', role: 'World Imagery basemap & IMINT products' },
+  { name: 'NASA Global Imagery Browse Services (GIBS)', role: 'Daily VIIRS reconnaissance mosaics' },
+  { name: 'EUMETSAT © 2026', role: 'Meteosat-9 IODC live geostationary imagery' },
+  { name: 'airplanes.live', role: 'Live ADS-B air traffic' },
+  { name: 'Open-Meteo', role: 'Real-time weather (collection gating)' },
+  { name: 'Reuters', role: 'Strait of Hormuz live vessel traffic' },
+  { name: 'Unit imagery: U.S. DoD (public domain) · Wikimedia Commons contributors (CC)', role: 'Recognition photos — no DoD endorsement implied' },
+  { name: 'Mapterhorn · Mapzen/Tilezen · NASA SRTM', role: 'Terrain relief (hillshade DEM tiles)' },
+]
diff --git a/src/data/intel/agents.ts b/src/data/intel/agents.ts
new file mode 100644
index 0000000..265a490
--- /dev/null
+++ b/src/data/intel/agents.ts
@@ -0,0 +1,60 @@
+import type { AgentSource } from '@/types/game'
+import type { Position } from '@/types/game'
+
+/**
+ * Named HUMINT sources — design: docs/plans/intel-suite-v3.md §1.4.
+ * Few sources, each a character with a distinct product. Never interchangeable.
+ */
+export function buildAgentRoster(): Record<string, AgentSource> {
+  const agents: AgentSource[] = [
+    {
+      id: 'amber',
+      codename: 'AMBER',
+      placement: 'Port logistics clerk, Bandar Abbas',
+      product: 'Naval activity: reveals ships near Bandar Abbas & Jask, sortie warnings',
+      status: 'active',
+      exposure: 10,
+      lastTaskedTick: -999_999,
+    },
+    {
+      id: 'opal',
+      codename: 'OPAL',
+      placement: 'IRGC missile-force logistics officer',
+      product: 'TEL hunt: pinpoints hidden missile batteries (identified-level)',
+      status: 'active',
+      exposure: 20,
+      lastTaskedTick: -999_999,
+    },
+    {
+      id: 'saffron',
+      codename: 'SAFFRON',
+      placement: 'Ministry aide, Tehran',
+      product: 'Political: exact war support + ceasefire intent readout',
+      status: 'active',
+      exposure: 15,
+      lastTaskedTick: -999_999,
+    },
+    {
+      id: 'garnet',
+      codename: 'GARNET',
+      placement: 'Coastal observer with camera, Strait of Hormuz',
+      product: 'Live observer feed: tracks ships transiting the strait while active',
+      status: 'active',
+      exposure: 5,
+      lastTaskedTick: -999_999,
+    },
+  ]
+  return Object.fromEntries(agents.map(a => [a.id, { ...a }]))
+}
+
+/** Coverage boxes per agent (lat/lng bounds) */
+export const AGENT_COVERAGE: Record<string, { south: number; west: number; north: number; east: number }> = {
+  amber: { south: 25.5, west: 55.0, north: 27.8, east: 58.2 }, // Bandar Abbas + Jask
+  garnet: { south: 25.8, west: 55.5, north: 27.2, east: 57.5 }, // Strait of Hormuz
+}
+
+/** AMBER/GARNET refresh cadence while active (game-minutes) */
+export const AGENT_PASSIVE_INTERVAL_MIN = 30
+
+/** Where arrested-agent fallout is centered for feed click-to-zoom flavor */
+export const TEHRAN: Position = { lat: 35.69, lng: 51.39 }
diff --git a/src/data/intel/assets.ts b/src/data/intel/assets.ts
new file mode 100644
index 0000000..0b9d955
--- /dev/null
+++ b/src/data/intel/assets.ts
@@ -0,0 +1,94 @@
+import type { IntelAsset } from '@/types/game'
+
+/**
+ * Fixed ISR asset roster — design: docs/plans/intel-suite-v3.md §1.1.
+ * revisit_min is in GAME minutes. niirs >= 7 reveals decoys on a pass.
+ */
+export function buildIntelAssets(): Record<string, IntelAsset> {
+  const assets: IntelAsset[] = [
+    // ── USA ──
+    {
+      id: 'kh11',
+      nation: 'usa',
+      name: 'KH-11 CRYSTAL',
+      kind: 'optical_sat',
+      status: 'active',
+      revisit_min: 240,
+      lastCollectionTick: 0,
+      niirs: 8,
+    },
+    {
+      id: 'commercial',
+      nation: 'usa',
+      name: 'Commercial EO layer',
+      kind: 'commercial_sat',
+      status: 'active',
+      revisit_min: 90,
+      lastCollectionTick: 0,
+      niirs: 5,
+    },
+    {
+      id: 'rc135',
+      nation: 'usa',
+      name: 'RC-135 RIVET JOINT',
+      kind: 'sigint_air',
+      status: 'active',
+      revisit_min: 0,
+      lastCollectionTick: 0,
+    },
+    {
+      id: 'mq4c',
+      nation: 'usa',
+      name: 'MQ-4C TRITON',
+      kind: 'maritime_patrol',
+      status: 'active',
+      revisit_min: 30,
+      lastCollectionTick: 0,
+    },
+    {
+      id: 'sbirs',
+      nation: 'usa',
+      name: 'SBIRS OPIR',
+      kind: 'launch_detection',
+      status: 'active',
+      revisit_min: 0,
+      lastCollectionTick: 0,
+    },
+    // ── Iran ──
+    {
+      id: 'noor',
+      nation: 'iran',
+      name: 'Noor-3',
+      kind: 'optical_sat',
+      status: 'active',
+      revisit_min: 480,
+      lastCollectionTick: 0,
+      niirs: 2,
+    },
+    {
+      id: 'mohajer10',
+      nation: 'iran',
+      name: 'Mohajer-10 orbit',
+      kind: 'recon_drone',
+      status: 'active',
+      revisit_min: 60,
+      lastCollectionTick: 0,
+    },
+    {
+      id: 'fastboats',
+      nation: 'iran',
+      name: 'IRGCN picket boats',
+      kind: 'fast_boats',
+      status: 'active',
+      revisit_min: 30,
+      lastCollectionTick: 0,
+    },
+  ]
+  return Object.fromEntries(assets.map(a => [a.id, { ...a }]))
+}
+
+/** Hormuz approaches box — IRGC picket/OSINT coverage of the carrier (design §1.5) */
+export const HORMUZ_OSINT_BOX = { south: 24.5, west: 53.5, north: 27.8, east: 58.5 }
+
+/** Satellite pass footprint half-width (km) */
+export const PASS_SWATH_KM = 60
diff --git a/src/data/intel/osint-accounts.ts b/src/data/intel/osint-accounts.ts
new file mode 100644
index 0000000..6507d13
--- /dev/null
+++ b/src/data/intel/osint-accounts.ts
@@ -0,0 +1,93 @@
+/**
+ * Diegetic OSINT account roster — design: docs/plans/intel-suite-v3.md §2.
+ * The feed generator (src/intel/osint-feed.ts) is a pure consumer of snapshot
+ * events; each account transforms events it "covers" with its own delay,
+ * precision and error rate. All handles fictional.
+ */
+
+export interface OsintAccount {
+  handle: string
+  displayName: string
+  archetype:
+    | 'plane_spotter'
+    | 'aggregator'
+    | 'oil_analyst'
+    | 'imagery_analyst'
+    | 'regime_mouthpiece'
+    | 'webcam_watcher'
+    | 'leak_channel'
+    | 'joke_indicator'
+  /** Game-seconds delay range from true event to post */
+  delayRangeSec: [number, number]
+  /** 0-1 chance a given post is wrong/garbled (wrong name, inflated claim) */
+  errorRate: number
+  /** Feed accent color */
+  color: string
+}
+
+export const OSINT_ACCOUNTS: OsintAccount[] = [
+  {
+    handle: '@GulfPlaneWatch',
+    displayName: 'Gulf Plane Watch',
+    archetype: 'plane_spotter',
+    delayRangeSec: [60, 180],
+    errorRate: 0.02,
+    color: '#7fb3d5',
+  },
+  {
+    handle: '@CENTCOM_Watch',
+    displayName: 'CENTCOM Watch',
+    archetype: 'aggregator',
+    delayRangeSec: [120, 360],
+    errorRate: 0.15,
+    color: '#e8d27a',
+  },
+  {
+    handle: '@TankerTrackerz',
+    displayName: 'Tanker Trackerz',
+    archetype: 'oil_analyst',
+    delayRangeSec: [43_200, 86_400],
+    errorRate: 0.05,
+    color: '#8fbf8f',
+  },
+  {
+    handle: '@OrbitalRecon',
+    displayName: 'Orbital Recon',
+    archetype: 'imagery_analyst',
+    delayRangeSec: [21_600, 43_200],
+    errorRate: 0.05,
+    color: '#b39ddb',
+  },
+  {
+    handle: '@IRGC_Media',
+    displayName: 'IRGC Media Desk',
+    archetype: 'regime_mouthpiece',
+    delayRangeSec: [300, 900],
+    errorRate: 0.5,
+    color: '#d98880',
+  },
+  {
+    handle: '@StraitSpotter',
+    displayName: 'Strait Spotter',
+    archetype: 'webcam_watcher',
+    delayRangeSec: [120, 480],
+    errorRate: 0.08,
+    color: '#76c7c0',
+  },
+  {
+    handle: '@SignalDesk',
+    displayName: 'Signal Desk',
+    archetype: 'leak_channel',
+    delayRangeSec: [0, 0], // posts BEFORE the event when it fires (warning channel)
+    errorRate: 0.2,
+    color: '#f0a35e',
+  },
+  {
+    handle: '@PizzaIndexGulf',
+    displayName: 'Gulf Pizza Index',
+    archetype: 'joke_indicator',
+    delayRangeSec: [0, 0],
+    errorRate: 0.4,
+    color: '#c8a2c8',
+  },
+]
diff --git a/src/data/unit-images.ts b/src/data/unit-images.ts
new file mode 100644
index 0000000..adc6b23
--- /dev/null
+++ b/src/data/unit-images.ts
@@ -0,0 +1,76 @@
+/**
+ * GENERATED by scripts/fetch-unit-images.mjs — re-run the script instead of
+ * editing image entries by hand. Recognition photos live in public/unit-images/.
+ * Licenses: US imagery is public-domain DoD photography; Iranian imagery is
+ * CC BY press photography — author + license MUST be shown wherever an image
+ * renders (in-game credit caption + LIVE FEEDS credits panel).
+ */
+
+export interface UnitImageInfo {
+  /** filename under public/unit-images/ */
+  file: string
+  /** Commons file title (without the File: prefix) */
+  title: string
+  author: string
+  license: string
+  sourceUrl: string
+}
+
+export const UNIT_IMAGES: Record<string, UnitImageInfo> = {
+  nimitz_cvn: { file: "nimitz_cvn.jpg", title: "USS Abraham Lincoln (CVN-72) underway during sea trials on 11 May 2017.jpg", author: "U.S. Navy photo by Mass Communication Specialist 3nd Class Juan A. Cu…", license: "Public domain", sourceUrl: "https://commons.wikimedia.org/wiki/File:USS_Abraham_Lincoln_(CVN-72)_underway_during_sea_trials_on_11_May_2017.jpg" },
+  arleigh_burke: { file: "arleigh_burke.jpg", title: "US Navy 050413-N-5526M-016 The Arleigh Burke-class guided missile destroyer USS Mustin (DDG 89) underway in the Northern Persian Gulf while conducting Maritime Security Operations.jpg", author: "U.S. Navy photo by Photographer's Mate 1st Class Robert McRill", license: "Public domain", sourceUrl: "https://commons.wikimedia.org/wiki/File:US_Navy_050413-N-5526M-016_The_Arleigh_Burke-class_guided_missile_destroyer_USS_Mustin_(DDG_89)_underway_in_the_Northern_Persian_Gulf_while_conducting_Maritime_Security_Operations.jpg" },
+  virginia_ssn: { file: "virginia_ssn.jpg", title: "US Navy 110909-N-OV802-222 The Virginia-class submarine Pre-Commissioning Unit (PCU) California (SSN 781) gets underway from Naval Station Norfolk.jpg", author: "U.S. Navy photo by Mass Communication Specialist 2nd Class William Ja…", license: "Public domain", sourceUrl: "https://commons.wikimedia.org/wiki/File:US_Navy_110909-N-OV802-222_The_Virginia-class_submarine_Pre-Commissioning_Unit_(PCU)_California_(SSN_781)_gets_underway_from_Naval_Station_Norfolk.jpg" },
+  patriot: { file: "patriot.jpg", title: "MIM-104 Patriot surface-to-air missile system launcher.jpg", author: "Robert Barney, U.S. Air Force", license: "Public domain", sourceUrl: "https://commons.wikimedia.org/wiki/File:MIM-104_Patriot_surface-to-air_missile_system_launcher.jpg" },
+  thaad: { file: "thaad.jpg", title: "THAAD missile launch in 2005 -2.jpg", author: "National Missile Defense image", license: "Public domain", sourceUrl: "https://commons.wikimedia.org/wiki/File:THAAD_missile_launch_in_2005_-2.jpg" },
+  e3_sentry: { file: "e3_sentry.jpg", title: "Boeing E-3 Sentry 090512-F-7550B-902.jpg", author: "U.S. Air Force photo by 1st. Lt. Kinder Blacke", license: "Public domain", sourceUrl: "https://commons.wikimedia.org/wiki/File:Boeing_E-3_Sentry_090512-F-7550B-902.jpg" },
+  us_airbase: { file: "us_airbase.jpg", title: "Al Udeid Air Base.jpg", author: "US gov", license: "Public domain", sourceUrl: "https://commons.wikimedia.org/wiki/File:Al_Udeid_Air_Base.jpg" },
+  nsa_bahrain: { file: "nsa_bahrain.jpg", title: "Navy Day at Naval Support Activity Bahrain 140416-N-RJ323-385.jpg", author: "Mass Communication Specialist Petty Officer 1st Class Stephen Murphy…", license: "Public domain", sourceUrl: "https://commons.wikimedia.org/wiki/File:Navy_Day_at_Naval_Support_Activity_Bahrain_140416-N-RJ323-385.jpg" },
+  s300pmu2: { file: "s300pmu2.jpg", title: "S-300 Tehran 2017.jpg", author: "Tasnim News Agency", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:S-300_Tehran_2017.jpg" },
+  bavar373: { file: "bavar373.jpg", title: "Bavar-373 upgrade ceremony (23).jpg", author: "M. Hasan Zarifmanesh", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:Bavar-373_upgrade_ceremony_(23).jpg" },
+  khordad3: { file: "khordad3.jpg", title: "3rd Khordad TELAR w Taer-2 missiles.jpg", author: "Meghdad Madadi", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:3rd_Khordad_TELAR_w_Taer-2_missiles.jpg" },
+  tor_m1: { file: "tor_m1.jpg", title: "Tor M1.jpg", author: "Meghdad Madadi", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:Tor_M1.jpg" },
+  shahab3: { file: "shahab3.jpg", title: "Shahab missile launch photographed by Satyar Emami.jpg", author: "Satyar Emami", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:Shahab_missile_launch_photographed_by_Satyar_Emami.jpg" },
+  sejjil2: { file: "sejjil2.jpg", title: "Sejjil missile launch - November 2008 (09).jpg", author: "Vahid Reza Alaei", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:Sejjil_missile_launch_-_November_2008_(09).jpg" },
+  fateh110: { file: "fateh110.jpg", title: "Firing Fateh-110 belong to AFAGIR.jpg", author: "Hosein Velayati", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:Firing_Fateh-110_belong_to_AFAGIR.jpg" },
+  zolfaghar: { file: "zolfaghar.jpg", title: "Two IRGC AF Missiles.jpg", author: "M. Sadegh Nikgostar", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:Two_IRGC_AF_Missiles.jpg" },
+  soumar: { file: "soumar.jpg", title: "Unveiling ceremony of Soumar cruise missile and other missiles (13).jpg", author: "Mohammad Agah", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:Unveiling_ceremony_of_Soumar_cruise_missile_and_other_missiles_(13).jpg" },
+  ghadir_sub: { file: "ghadir_sub.jpg", title: "2012 Bandar Abbas new equipment induction ceremony - Ghadir-class submarine (10).jpg", author: "Ebrahim Noroozi", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:2012_Bandar_Abbas_new_equipment_induction_ceremony_-_Ghadir-class_submarine_(10).jpg" },
+  noor_coastal: { file: "noor_coastal.jpg", title: "شلیک موشک کروز نور توسط یگان ساحلی نداجا از سواحل مکران (1).jpg", author: "عرفان کوچاری (Erfan Kouchari)", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:%D8%B4%D9%84%DB%8C%DA%A9_%D9%85%D9%88%D8%B4%DA%A9_%DA%A9%D8%B1%D9%88%D8%B2_%D9%86%D9%88%D8%B1_%D8%AA%D9%88%D8%B3%D8%B7_%DB%8C%DA%AF%D8%A7%D9%86_%D8%B3%D8%A7%D8%AD%D9%84%DB%8C_%D9%86%D8%AF%D8%A7%D8%AC%D8%A7_%D8%A7%D8%B2_%D8%B3%D9%88%D8%A7%D8%AD%D9%84_%D9%85%DA%A9%D8%B1%D8%A7%D9%86_(1).jpg" },
+  irgc_fac: { file: "irgc_fac.jpg", title: "Commissioning ceremony of IRGC naval vessels in March 2023 (10).jpg", author: "Hossein Ghanbari", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:Commissioning_ceremony_of_IRGC_naval_vessels_in_March_2023_(10).jpg" },
+  iran_airbase: { file: "iran_airbase.jpg", title: "F-14 Tomcat at Mehrabad preparing for Iranian Army Day 2013 (1).jpg", author: "Mohammad Shaltouki", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:F-14_Tomcat_at_Mehrabad_preparing_for_Iranian_Army_Day_2013_(1).jpg" },
+  shahed136: { file: "shahed136.jpg", title: "Military equipment displayed for the 44th Iranian revolution anniversary rally - Shahed 136.jpg", author: "Meghdad Madadi", license: "CC BY 4.0", sourceUrl: "https://commons.wikimedia.org/wiki/File:Military_equipment_displayed_for_the_44th_Iranian_revolution_anniversary_rally_-_Shahed_136.jpg" },
+}
+
+const US_AIRBASE_HINTS = ['udeid', 'dhafra', 'prince sultan', 'al salem', 'incirlik', 'diego garcia']
+
+/**
+ * Best-effort class match from unit name/category. May return a key with no
+ * UNIT_IMAGES entry (download dropped) — callers must check the map.
+ */
+export function unitImageKey(unit: { name: string; category: string }): string | null {
+  const n = unit.name.toLowerCase()
+  if (unit.category === 'carrier_group' || n.includes('cvn')) return 'nimitz_cvn'
+  if (n.includes('ddg') || n.includes('arleigh')) return 'arleigh_burke'
+  if (n.includes('ssn')) return 'virginia_ssn'
+  if (n.includes('patriot')) return 'patriot'
+  if (n.includes('thaad')) return 'thaad'
+  if (n.includes('e-3') || n.includes('awacs')) return 'e3_sentry'
+  if (n.includes('nsa bahrain') || n.includes('5th fleet')) return 'nsa_bahrain'
+  if (n.includes('s-300')) return 's300pmu2'
+  if (n.includes('bavar')) return 'bavar373'
+  if (n.includes('khordad')) return 'khordad3'
+  if (n.includes('tor-m1')) return 'tor_m1'
+  if (n.includes('shahab')) return 'shahab3'
+  if (n.includes('sejjil')) return 'sejjil2'
+  if (n.includes('fateh')) return 'fateh110'
+  if (n.includes('zolfaghar')) return 'zolfaghar'
+  if (n.includes('soumar')) return 'soumar'
+  if (n.includes('ghadir')) return 'ghadir_sub'
+  if (n.includes('coastal') || n.includes('qeshm')) return 'noor_coastal'
+  if (/\bfac\b/.test(n)) return 'irgc_fac'
+  if (n.includes('shahed')) return 'shahed136'
+  if (unit.category === 'airbase') {
+    return US_AIRBASE_HINTS.some((h) => n.includes(h)) ? 'us_airbase' : 'iran_airbase'
+  }
+  return null
+}
diff --git a/src/engine/__tests__/attack-planner.test.ts b/src/engine/__tests__/attack-planner.test.ts
index c808d39..022c429 100644
--- a/src/engine/__tests__/attack-planner.test.ts
+++ b/src/engine/__tests__/attack-planner.test.ts
@@ -1,10 +1,17 @@
 import { describe, it, expect } from 'vitest'
-import { computeAttackPlan } from '../attack-planner'
+import {
+  computeAttackPlan,
+  computeTotSchedule,
+  estimateLeakers,
+  TOT_PAD_TICKS,
+  TOT_RIPPLE_TICKS,
+  AD_ENGAGEMENT_CYCLE_SEC,
+} from '../attack-planner'
 import { usaUnits } from '@/data/units/usa-orbat'
 import { iranUnits } from '@/data/units/iran-orbat'
 import type { Unit } from '@/types/game'
 import type { ViewUnit } from '@/types/view'
-import type { AttackPriority } from '@/types/attack-plan'
+import type { AttackPriority, AttackPlan, PlannedStrike } from '@/types/attack-plan'
 
 // Mirrors game-engine.ts toViewUnit — the planner consumes worker snapshots
 function toViewUnit(u: Unit): ViewUnit {
@@ -114,3 +121,169 @@ describe('computeAttackPlan on the real USA/Iran scenario', () => {
     expect(seadWarnings.every(w => w.includes('out of range'))).toBe(true)
   })
 })
+
+// ════════════════════════════════════════════════════════════════
+//  TOT scheduling + leaker estimate
+// ════════════════════════════════════════════════════════════════
+
+function plannedStrike(over: Partial<PlannedStrike> & { flightTimeSec: number }): PlannedStrike {
+  return {
+    launcherId: 'l1',
+    launcherName: 'Launcher 1',
+    weaponId: 'tomahawk',
+    weaponName: 'BGM-109 Tomahawk',
+    targetId: 't1',
+    targetName: 'Target 1',
+    targetCategory: 'airbase',
+    count: 1,
+    inRange: true,
+    distanceKm: 100,
+    priorityTier: 0,
+    ...over,
+  }
+}
+
+function planOf(strikes: PlannedStrike[]): AttackPlan {
+  return {
+    name: 'TOT Test',
+    priorities: [],
+    timing: 'simultaneous',
+    strikes,
+    summary: {
+      totalMissiles: strikes.reduce((s, st) => s + st.count, 0),
+      totalTargets: new Set(strikes.map(s => s.targetId)).size,
+      weaponBudget: {},
+      targetCoverage: {},
+      estimatedPenetration: 1,
+      estimatedKills: 0,
+      warnings: [],
+    },
+  }
+}
+
+function vu(over: Partial<ViewUnit> & { id: string; category: ViewUnit['category'] }): ViewUnit {
+  return {
+    name: over.id,
+    nation: 'iran',
+    position: { lat: 27, lng: 52 },
+    heading: 0,
+    speed_kts: 0,
+    status: 'ready',
+    health: 100,
+    maxHealth: 100,
+    logistics: 100,
+    supplyStocks: [],
+    weapons: [],
+    pointDefense: [],
+    sensors: [],
+    roe: 'weapons_tight',
+    waypoints: [],
+    subordinateIds: [],
+    visibility: 'identified',
+    stale: false,
+    ...over,
+  } as ViewUnit
+}
+
+describe('computeTotSchedule', () => {
+  it('schedules different flight times to impact within ±2 ticks of one TOT', () => {
+    const now = 1000
+    const strikes = [
+      plannedStrike({ launcherId: 'cruise', flightTimeSec: 2333.4 }),
+      plannedStrike({ launcherId: 'ballistic', flightTimeSec: 250 }),
+      plannedStrike({ launcherId: 'fast', flightTimeSec: 66.6 }),
+    ]
+    const schedule = computeTotSchedule(planOf(strikes), now)
+
+    expect(schedule.totTick).toBe(now + Math.ceil(2333.4) + TOT_PAD_TICKS)
+
+    for (const e of schedule.entries) {
+      const impactTick = e.dueTick + (e.count - 1) * TOT_RIPPLE_TICKS + Math.ceil(e.flightTimeSec)
+      expect(Math.abs(impactTick - schedule.totTick)).toBeLessThanOrEqual(2)
+    }
+
+    // Longest flight launches first; the derived schedule is sorted by dueTick
+    expect(schedule.entries[0].launcherId).toBe('cruise')
+    expect(schedule.earliestLaunchTick).toBe(schedule.entries[0].dueTick)
+    expect(schedule.earliestLaunchTick).toBe(now + TOT_PAD_TICKS)
+  })
+
+  it('ripples multi-round rows 1 tick per round so the last round lands on TOT', () => {
+    const now = 0
+    const schedule = computeTotSchedule(planOf([
+      plannedStrike({ flightTimeSec: 300, count: 4 }),
+    ]), now)
+
+    const e = schedule.entries[0]
+    expect(e.dueTick).toBe(schedule.totTick - 300 - 3 * TOT_RIPPLE_TICKS)
+    // Round j launches at dueTick + j and impacts at totTick - 3 + j
+    for (let j = 0; j < e.count; j++) {
+      const impact = e.dueTick + j * TOT_RIPPLE_TICKS + Math.ceil(e.flightTimeSec)
+      expect(impact).toBeGreaterThanOrEqual(schedule.totTick - 3)
+      expect(impact).toBeLessThanOrEqual(schedule.totTick)
+    }
+  })
+
+  it('never schedules a launch at or before nowTick', () => {
+    const now = 50
+    const schedule = computeTotSchedule(planOf([
+      plannedStrike({ flightTimeSec: 10, count: 100 }), // ripple longer than pad
+    ]), now)
+    expect(schedule.entries[0].dueTick).toBeGreaterThan(now)
+  })
+
+  it('skips out-of-range and unreachable (Infinity flight time) strikes', () => {
+    const schedule = computeTotSchedule(planOf([
+      plannedStrike({ launcherId: 'ok', flightTimeSec: 100 }),
+      plannedStrike({ launcherId: 'far', flightTimeSec: 500, inRange: false }),
+      plannedStrike({ launcherId: 'dead', flightTimeSec: Infinity }),
+    ]), 0)
+
+    expect(schedule.entries.map(e => e.launcherId)).toEqual(['ok'])
+    expect(schedule.totTick).toBe(100 + TOT_PAD_TICKS)
+  })
+
+  it('returns an empty schedule for a plan with no executable strikes', () => {
+    const schedule = computeTotSchedule(planOf([]), 10)
+    expect(schedule.entries).toEqual([])
+    expect(schedule.totTick).toBe(10 + TOT_PAD_TICKS)
+    expect(schedule.earliestLaunchTick).toBe(schedule.totTick)
+  })
+})
+
+describe('estimateLeakers', () => {
+  // 3rd Khordad battery: 4 fire channels (air-defense.ts), interceptor khordad15_int
+  const samSite = vu({
+    id: 'sam1',
+    category: 'sam_site',
+    weapons: [{ weaponId: 'khordad15_int', count: 8, maxCount: 16, reloadTimeSec: 480 }],
+  })
+  const airbase = vu({ id: 'ab1', category: 'airbase' })
+  const tenAtAirbase = [plannedStrike({ targetId: 'ab1', count: 10, flightTimeSec: 300 })]
+
+  it('compressed TOT window gives AD one engagement cycle: channels × 1 intercepts', () => {
+    const leakers = estimateLeakers(tenAtAirbase, [samSite, airbase], 0)
+    expect(leakers).toBe(10 - 4)
+  })
+
+  it('a spread impact window multiplies engagement cycles and kills the raid', () => {
+    const windowSec = 20 * AD_ENGAGEMENT_CYCLE_SEC // 21 cycles × 4 channels = 84 ≥ 10
+    expect(estimateLeakers(tenAtAirbase, [samSite, airbase], windowSec)).toBe(0)
+  })
+
+  it('undefended target leaks everything; out-of-range strikes are ignored', () => {
+    expect(estimateLeakers(tenAtAirbase, [airbase], 0)).toBe(10)
+    const oor = [plannedStrike({ targetId: 'ab1', count: 10, inRange: false, flightTimeSec: 300 })]
+    expect(estimateLeakers(oor, [samSite, airbase], 0)).toBe(0)
+  })
+
+  it('SAM sites farther than 200 km contribute no fire channels', () => {
+    const farSam = vu({
+      id: 'sam_far',
+      category: 'sam_site',
+      position: { lat: 27, lng: 55 }, // ~297 km from the airbase at lng 52
+      weapons: [{ weaponId: 'khordad15_int', count: 8, maxCount: 16, reloadTimeSec: 480 }],
+    })
+    expect(estimateLeakers(tenAtAirbase, [farSam, airbase], 0)).toBe(10)
+  })
+})
diff --git a/src/engine/__tests__/scale-stress.test.ts b/src/engine/__tests__/scale-stress.test.ts
new file mode 100644
index 0000000..0d5276a
--- /dev/null
+++ b/src/engine/__tests__/scale-stress.test.ts
@@ -0,0 +1,429 @@
+import { describe, it, expect } from 'vitest'
+import { GameEngine } from '../game-engine'
+import { ElevationGrid } from '../systems/elevation'
+import { SeededRNG } from '../utils/rng'
+import { haversine } from '../utils/geo'
+import { weaponSpecs } from '@/data/weapons/missiles'
+import type { Nation, NationId, Unit, UnitId } from '@/types/game'
+
+// ════════════════════════════════════════════════════════════════
+//  Scale stress guard (roadmap v4, Wave A.6)
+//
+//  Answers "do we need a faster engine" with numbers: ~500 units
+//  (realistic loadouts, both nations at war), ~60 missiles launched
+//  at t=0, driven twice — without an elevation grid, then with a
+//  synthetic flat grid so the LOS sampling cost is visible.
+//
+//  Measured 2026-06-11 (dev box, vitest/jsdom, 100 ticks per run):
+//    no grid    avg 176 ms  p50 176 ms  p95 216 ms  max 244 ms
+//    flat grid  avg 193 ms  p50 196 ms  p95 249 ms  max 284 ms
+//    (+9% avg with grid: LOS sampling is NOT the hot path)
+//  Cost driver: the missile population explodes from 57 seeded
+//  launches to ~2100 live missiles (SAM interceptor swarms), and
+//  detection/visibility scale with units x missiles. A 600-tick run
+//  averaged 81 ms/tick — late ticks get cheap once ammo runs dry —
+//  so the short run deliberately measures the saturation phase.
+//
+//  The roadmap assumed ~12 ms ticks and 600 ticks per run; at the
+//  measured ~176 ms/tick two 600-tick runs would take ~3.5 min, so
+//  the guard runs 100 ticks per run to stay inside the <60 s suite
+//  budget — still deep into the interceptor-swarm phase.
+//
+//  Budgets are ~3x the dev-box measurement so CI noise never flakes
+//  this; they exist to catch order-of-magnitude regressions, not to
+//  benchmark.
+// ════════════════════════════════════════════════════════════════
+
+const TICKS = 100
+const BUDGET_AVG_MS = 500
+const BUDGET_P95_MS = 650
+
+// ── Scenario construction ───────────────────────────────────────
+
+function makeNation(id: NationId, name: string, atWarWith: NationId): Nation {
+  return {
+    id,
+    name,
+    economy: { gdp_billions: 1000, military_budget_billions: 100, military_budget_pct_gdp: 3, oil_revenue_billions: 50, sanctions_impact: 0, war_cost_per_day_millions: 100, reserves_billions: 100 },
+    relations: { usa: 0, iran: 0 },
+    atWar: [atWarWith],
+  }
+}
+
+type UnitSeed = Partial<Unit> & { id: string; nation: NationId; category: Unit['category']; position: Unit['position'] }
+
+function makeUnit(overrides: UnitSeed): Unit {
+  return {
+    name: overrides.id,
+    heading: 0,
+    speed_kts: 0,
+    maxSpeed_kts: 0,
+    health: 100,
+    maxHealth: 100,
+    hardness: 100,
+    logistics: 0,
+    supplyStocks: [],
+    weapons: [],
+    pointDefense: [],
+    sensors: [],
+    roe: 'weapons_tight' as const,
+    status: 'ready' as const,
+    waypoints: [],
+    subordinateIds: [],
+    ...overrides,
+  } as Unit
+}
+
+interface Box { latMin: number; latMax: number; lngMin: number; lngMax: number }
+
+const US_LAND: Box = { latMin: 23.8, latMax: 26.6, lngMin: 46.8, lngMax: 56.5 } // Arabian peninsula coast
+const US_WATER: Box = { latMin: 24.2, latMax: 27.2, lngMin: 50.2, lngMax: 56.8 } // central/southern Gulf
+const IRAN_LAND: Box = { latMin: 27.4, latMax: 34.5, lngMin: 47.6, lngMax: 57.5 }
+const IRAN_WATER: Box = { latMin: 26.3, latMax: 27.2, lngMin: 51.0, lngMax: 56.8 } // northern Gulf waters
+
+function scatter(rng: SeededRNG, box: Box) {
+  return {
+    lat: box.latMin + rng.next() * (box.latMax - box.latMin),
+    lng: box.lngMin + rng.next() * (box.lngMax - box.lngMin),
+  }
+}
+
+/**
+ * ~500 units split USA/Iran with realistic loadouts mirroring the shipped
+ * orbats (real weapon ids, sector-limited SAM radars, datalink hubs),
+ * positions spread over the Gulf bbox. Fully deterministic (seeded placement).
+ */
+function buildStressScenario(): { nations: Record<string, Nation>; units: Unit[] } {
+  const rng = new SeededRNG(1234)
+  const units: Unit[] = []
+  const series = (count: number, build: (i: number) => UnitSeed) => {
+    for (let i = 0; i < count; i++) units.push(makeUnit(build(i)))
+  }
+
+  // ── USA (250) ──
+  series(10, i => ({
+    id: `us_ab_${i}`, nation: 'usa', category: 'airbase', position: scatter(rng, US_LAND),
+    hardness: 200, logistics: 80,
+    weapons: [{ weaponId: 'jassm_er', count: 48, maxCount: 48, reloadTimeSec: 0 }],
+    pointDefense: [{ specId: 'cram_centurion', active: true, ammo: 2000, maxAmmo: 2000 }],
+    sensors: [{ type: 'radar', range_km: 400, detection_prob: 0.95, antenna_height_m: 25 }],
+    datalink_range_km: 150,
+  }))
+  series(2, i => ({
+    id: `us_nb_${i}`, nation: 'usa', category: 'naval_base', position: scatter(rng, US_LAND),
+    hardness: 200, logistics: 80,
+    pointDefense: [{ specId: 'cram_centurion', active: true, ammo: 2000, maxAmmo: 2000 }],
+    sensors: [{ type: 'radar', range_km: 250, detection_prob: 0.9, antenna_height_m: 20 }],
+    datalink_range_km: 150,
+  }))
+  series(2, i => ({
+    id: `us_cvn_${i}`, nation: 'usa', category: 'carrier_group',
+    position: i === 0 ? { lat: 23.8, lng: 58.8 } : { lat: 26.4, lng: 52.6 },
+    heading: rng.int(0, 359), speed_kts: 18, maxSpeed_kts: 30, hardness: 250,
+    weapons: [
+      { weaponId: 'tomahawk', count: 60, maxCount: 60, reloadTimeSec: 0 },
+      { weaponId: 'sm6', count: 120, maxCount: 120, reloadTimeSec: 0 },
+      { weaponId: 'sm3_iia', count: 24, maxCount: 24, reloadTimeSec: 0 },
+      { weaponId: 'harpoon', count: 16, maxCount: 16, reloadTimeSec: 0 },
+    ],
+    pointDefense: [
+      { specId: 'phalanx_ciws', active: true, ammo: 1550, maxAmmo: 1550 },
+      { specId: 'rim116_ram', active: true, ammo: 21, maxAmmo: 21 },
+    ],
+    sensors: [
+      { type: 'radar', range_km: 500, detection_prob: 0.98, antenna_height_m: 50 },
+      { type: 'sonar', range_km: 50, detection_prob: 0.7 },
+    ],
+    datalink_range_km: 300,
+  }))
+  series(80, i => {
+    const pos = scatter(rng, US_WATER)
+    const moving = i % 2 === 0
+    return {
+      id: `us_ddg_${i}`, nation: 'usa', category: 'ship', position: pos,
+      heading: rng.int(0, 359), speed_kts: 12, maxSpeed_kts: 30, hardness: 150,
+      status: moving ? 'moving' as const : 'ready' as const,
+      waypoints: moving ? [scatter(rng, US_WATER), scatter(rng, US_WATER)] : [],
+      weapons: [
+        { weaponId: 'tomahawk', count: 20, maxCount: 20, reloadTimeSec: 0 },
+        { weaponId: 'sm6', count: 52, maxCount: 52, reloadTimeSec: 0 },
+        { weaponId: 'sm2_iiia', count: 24, maxCount: 24, reloadTimeSec: 0 },
+        { weaponId: 'harpoon', count: 8, maxCount: 8, reloadTimeSec: 0 },
+      ],
+      pointDefense: [
+        { specId: 'phalanx_ciws', active: true, ammo: 1550, maxAmmo: 1550 },
+        { specId: 'rim116_ram', active: true, ammo: 21, maxAmmo: 21 },
+      ],
+      sensors: [{ type: 'radar' as const, range_km: 500, detection_prob: 0.96, antenna_height_m: 30 }],
+      datalink_range_km: 300,
+    }
+  })
+  series(24, i => ({
+    id: `us_ffg_${i}`, nation: 'usa', category: 'ship', position: scatter(rng, US_WATER),
+    heading: rng.int(0, 359), speed_kts: 10, maxSpeed_kts: 28, hardness: 130,
+    weapons: [
+      { weaponId: 'sm2_iiia', count: 24, maxCount: 24, reloadTimeSec: 0 },
+      { weaponId: 'harpoon', count: 8, maxCount: 8, reloadTimeSec: 0 },
+    ],
+    pointDefense: [{ specId: 'phalanx_ciws', active: true, ammo: 1550, maxAmmo: 1550 }],
+    sensors: [{ type: 'radar', range_km: 350, detection_prob: 0.92, antenna_height_m: 25 }],
+  }))
+  series(40, i => ({
+    id: `us_pc_${i}`, nation: 'usa', category: 'ship', position: scatter(rng, US_WATER),
+    heading: rng.int(0, 359), speed_kts: 14, maxSpeed_kts: 35, hardness: 80,
+    weapons: [{ weaponId: 'harpoon', count: 4, maxCount: 4, reloadTimeSec: 0 }],
+    sensors: [{ type: 'radar', range_km: 120, detection_prob: 0.85, antenna_height_m: 12 }],
+  }))
+  series(16, i => ({
+    id: `us_ssn_${i}`, nation: 'usa', category: 'submarine', position: scatter(rng, US_WATER),
+    heading: rng.int(0, 359), speed_kts: 5, maxSpeed_kts: 25, hardness: 120,
+    weapons: [
+      { weaponId: 'tomahawk', count: 12, maxCount: 12, reloadTimeSec: 0 },
+      { weaponId: 'harpoon', count: 4, maxCount: 4, reloadTimeSec: 0 },
+    ],
+    sensors: [{ type: 'sonar', range_km: 80, detection_prob: 0.85 }],
+  }))
+  series(60, i => ({
+    id: `us_pat_${i}`, nation: 'usa', category: 'sam_site', position: scatter(rng, US_LAND),
+    heading: rng.int(0, 359), maxSpeed_kts: 25,
+    weapons: [{ weaponId: 'pac3_mse', count: 16, maxCount: 16, reloadTimeSec: 600 }],
+    sensors: [{ type: 'radar', range_km: 180, detection_prob: 0.95, antenna_height_m: 8, sector_deg: 120 }],
+    roe: 'weapons_free' as const,
+    readiness: 'deployed' as const, deploy_time_sec: 1800, pack_time_sec: 900,
+  }))
+  series(8, i => ({
+    id: `us_thaad_${i}`, nation: 'usa', category: 'sam_site', position: scatter(rng, US_LAND),
+    heading: rng.int(0, 359), maxSpeed_kts: 25,
+    weapons: [{ weaponId: 'thaad_int', count: 48, maxCount: 48, reloadTimeSec: 900 }],
+    sensors: [{ type: 'radar', range_km: 1000, detection_prob: 0.98, antenna_height_m: 10, sector_deg: 120 }],
+    roe: 'weapons_free' as const,
+    readiness: 'deployed' as const, deploy_time_sec: 1200, pack_time_sec: 600,
+  }))
+  series(8, i => ({
+    id: `us_awacs_${i}`, nation: 'usa', category: 'aircraft', position: scatter(rng, US_WATER),
+    heading: rng.int(0, 359), speed_kts: 300, maxSpeed_kts: 350, hardness: 30,
+    sensors: [{ type: 'radar', range_km: 400, detection_prob: 0.95, antenna_height_m: 10000, sector_deg: 360 }],
+    roe: 'weapons_free' as const,
+    datalink_range_km: 600,
+  }))
+
+  // ── Iran (250) ──
+  series(8, i => ({
+    id: `ir_ab_${i}`, nation: 'iran', category: 'airbase', position: scatter(rng, IRAN_LAND),
+    hardness: 200, logistics: 60,
+    sensors: [{ type: 'radar', range_km: 300, detection_prob: 0.85, antenna_height_m: 20 }],
+    datalink_range_km: 150,
+  }))
+  series(2, i => ({
+    id: `ir_nb_${i}`, nation: 'iran', category: 'naval_base', position: scatter(rng, IRAN_LAND),
+    hardness: 200, logistics: 60,
+    sensors: [{ type: 'radar', range_km: 200, detection_prob: 0.8, antenna_height_m: 15 }],
+    datalink_range_km: 150,
+  }))
+  const samSite = (id: string, weaponId: string, count: number, radarKm: number, sector: number | undefined): UnitSeed => ({
+    id, nation: 'iran', category: 'sam_site', position: scatter(rng, IRAN_LAND),
+    heading: rng.int(0, 359), maxSpeed_kts: 25,
+    weapons: [{ weaponId, count, maxCount: count, reloadTimeSec: 600 }],
+    sensors: [{ type: 'radar', range_km: radarKm, detection_prob: 0.9, antenna_height_m: 12, ...(sector ? { sector_deg: sector } : {}) }],
+    roe: 'weapons_free' as const,
+    readiness: 'deployed' as const, deploy_time_sec: 300, pack_time_sec: 300,
+  })
+  series(16, i => samSite(`ir_s300_${i}`, 's300_48n6e2', 32, 300, 90))
+  series(10, i => samSite(`ir_bavar_${i}`, 'bavar373_int', 24, 350, 90))
+  series(16, i => samSite(`ir_khordad_${i}`, 'khordad15_int', 12, 150, 90))
+  series(20, i => samSite(`ir_tor_${i}`, 'tor_m1_int', 8, 25, undefined))
+  const tel = (id: string, weaponId: string, count: number): UnitSeed => ({
+    id, nation: 'iran', category: 'missile_battery', position: scatter(rng, IRAN_LAND),
+    heading: rng.int(0, 359), maxSpeed_kts: 40, hardness: 80,
+    weapons: [{ weaponId, count, maxCount: count, reloadTimeSec: 3600 }],
+    readiness: 'deployed' as const, deploy_time_sec: 600, pack_time_sec: 300,
+  })
+  series(16, i => tel(`ir_shahab_${i}`, 'shahab3', 6))
+  series(8, i => tel(`ir_sejjil_${i}`, 'sejjil2', 4))
+  series(20, i => tel(`ir_zolf_${i}`, 'zolfaghar', 8))
+  series(30, i => tel(`ir_fateh_${i}`, 'fateh110', 12))
+  series(20, i => ({
+    id: `ir_coastal_${i}`, nation: 'iran', category: 'missile_battery',
+    position: { lat: 26.6 + rng.next() * 1.2, lng: 50.8 + rng.next() * 6.0 }, // coastal strip
+    heading: 180, hardness: 100,
+    weapons: [
+      { weaponId: 'noor', count: 12, maxCount: 12, reloadTimeSec: 1200 },
+      { weaponId: 'khalij_fars', count: 4, maxCount: 4, reloadTimeSec: 2400 },
+    ],
+    sensors: [{ type: 'radar', range_km: 100, detection_prob: 0.8, antenna_height_m: 10 }],
+  }))
+  series(16, i => ({
+    id: `ir_shahed_${i}`, nation: 'iran', category: 'missile_battery', position: scatter(rng, IRAN_LAND),
+    heading: rng.int(0, 359), maxSpeed_kts: 40, hardness: 60,
+    weapons: [{ weaponId: 'shahed_136', count: 50, maxCount: 50, reloadTimeSec: 0 }],
+    readiness: 'deployed' as const, deploy_time_sec: 600, pack_time_sec: 300,
+  }))
+  series(50, i => {
+    const moving = i % 2 === 0
+    return {
+      id: `ir_fac_${i}`, nation: 'iran', category: 'ship', position: scatter(rng, IRAN_WATER),
+      heading: rng.int(0, 359), speed_kts: 8, maxSpeed_kts: 45, hardness: 60,
+      status: moving ? 'moving' as const : 'ready' as const,
+      waypoints: moving ? [scatter(rng, IRAN_WATER)] : [],
+      weapons: [{ weaponId: 'noor', count: 4, maxCount: 4, reloadTimeSec: 0 }],
+      sensors: [{ type: 'radar' as const, range_km: 40, detection_prob: 0.7, antenna_height_m: 8 }],
+    }
+  })
+  series(14, i => ({
+    id: `ir_sub_${i}`, nation: 'iran', category: 'submarine', position: scatter(rng, IRAN_WATER),
+    heading: rng.int(0, 359), speed_kts: 3, maxSpeed_kts: 11, hardness: 80,
+    sensors: [{ type: 'sonar', range_km: 15, detection_prob: 0.6 }],
+  }))
+  series(4, i => ({
+    id: `ir_ew_${i}`, nation: 'iran', category: 'sam_site', position: scatter(rng, IRAN_LAND),
+    heading: rng.int(0, 359), hardness: 80,
+    sensors: [{ type: 'radar', range_km: 400, detection_prob: 0.9, antenna_height_m: 30, sector_deg: 360 }],
+    roe: 'weapons_free' as const,
+    datalink_range_km: 300,
+  }))
+
+  const nations = {
+    usa: makeNation('usa', 'USA', 'iran'),
+    iran: makeNation('iran', 'Iran', 'usa'),
+  }
+  return { nations, units }
+}
+
+/**
+ * Flat sea-level grid over the real theater bbox (lat 12-43, lng 32-70 at
+ * 0.05 deg = 620x760 cells). Float32Array zero-fill IS the flat grid — the
+ * run measures LOS/terrain sampling cost, not terrain shape. Sea level (not
+ * land) so moving ships never trigger per-tick naval re-routing, which would
+ * be a pathological cost no real scenario has.
+ */
+function makeFlatGrid(): ElevationGrid {
+  const latMin = 12, latMax = 43, lngMin = 32, lngMax = 70, resolution = 0.05
+  const rows = Math.round((latMax - latMin) / resolution)
+  const cols = Math.round((lngMax - lngMin) / resolution)
+  const buffer = new ArrayBuffer(20 + rows * cols * 4)
+  const header = new Float32Array(buffer, 0, 5)
+  header[0] = latMin
+  header[1] = latMax
+  header[2] = lngMin
+  header[3] = lngMax
+  header[4] = resolution
+  return new ElevationGrid(buffer)
+}
+
+// ── Driving + measurement ───────────────────────────────────────
+
+function setUpEngine(withGrid: boolean): GameEngine {
+  const { nations, units } = buildStressScenario()
+  const engine = new GameEngine()
+  if (withGrid) engine.setElevationGrid(makeFlatGrid())
+  engine.initFromData('usa', nations, units, [], {})
+  launchOpeningSalvos(engine)
+  return engine
+}
+
+/** ~60 missiles in flight at t=0 via the public command path, all range-verified */
+function launchOpeningSalvos(engine: GameEngine): void {
+  const all = [...engine.state.units.values()]
+  const usTargets = all.filter(u => u.nation === 'usa' && (u.category === 'airbase' || u.category === 'sam_site' || u.category === 'naval_base'))
+  const iranTargets = all.filter(u => u.nation === 'iran' && (u.category === 'sam_site' || u.category === 'airbase' || u.category === 'missile_battery'))
+
+  const fire = (launcherId: UnitId, weaponId: string, targets: Unit[], cursor: number): boolean => {
+    const launcher = engine.state.units.get(launcherId)!
+    const range = weaponSpecs[weaponId].range_km
+    for (let i = 0; i < targets.length; i++) {
+      const target = targets[(cursor + i) % targets.length]
+      if (haversine(launcher.position, target.position) <= range) {
+        engine.executeCommand({ type: 'LAUNCH_MISSILE', launcherId, weaponId, targetId: target.id })
+        return true
+      }
+    }
+    return false
+  }
+
+  // 30 Tomahawks from DDGs at Iranian air defense / TELs
+  for (let i = 0; i < 30; i++) fire(`us_ddg_${i}`, 'tomahawk', iranTargets, i * 7)
+  // 30 Iranian ballistic rounds at US bases and Patriot sites
+  for (let i = 0; i < 16; i++) fire(`ir_shahab_${i}`, 'shahab3', usTargets, i * 5)
+  for (let i = 0; i < 8; i++) fire(`ir_sejjil_${i}`, 'sejjil2', usTargets, i * 11)
+  for (let i = 0; i < 6; i++) fire(`ir_zolf_${i}`, 'zolfaghar', usTargets, i * 3)
+}
+
+interface TickStats { avg: number; p50: number; p95: number; max: number; total: number }
+
+function measure(engine: GameEngine, ticks: number): { stats: TickStats; errors: string[] } {
+  const samples = new Float64Array(ticks)
+  const errors: string[] = []
+  for (let i = 0; i < ticks; i++) {
+    const t0 = performance.now()
+    try {
+      engine.tick()
+    } catch (e) {
+      if (errors.length < 5) errors.push(`tick ${i + 1}: ${e instanceof Error ? e.stack ?? e.message : String(e)}`)
+    }
+    samples[i] = performance.now() - t0
+  }
+  const sorted = [...samples].sort((a, b) => a - b)
+  const total = sorted.reduce((s, v) => s + v, 0)
+  const at = (q: number) => sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))]
+  return {
+    stats: { avg: total / ticks, p50: at(0.5), p95: at(0.95), max: sorted[sorted.length - 1], total },
+    errors,
+  }
+}
+
+function row(label: string, s: TickStats): string {
+  const ms = (v: number) => `${v.toFixed(2)} ms`.padStart(12)
+  return `  ${label.padEnd(12)}${ms(s.avg)}${ms(s.p50)}${ms(s.p95)}${ms(s.max)}${`${s.total.toFixed(0)} ms`.padStart(12)}`
+}
+
+// ── Test ────────────────────────────────────────────────────────
+
+describe('scale stress', () => {
+  it(`500 units + 60 missiles stay inside tick budget over ${TICKS} ticks (with and without elevation grid)`, () => {
+    // Unmeasured warmup so JIT compilation doesn't bias run 1 vs run 2
+    const warmup = setUpEngine(false)
+    for (let i = 0; i < 15; i++) warmup.tick()
+
+    const noGrid = setUpEngine(false)
+    const unitCount = noGrid.state.units.size
+    const missilesInFlight = noGrid.state.missiles.size
+    const noGridRun = measure(noGrid, TICKS)
+
+    const withGrid = setUpEngine(true)
+    const gridRun = measure(withGrid, TICKS)
+
+    const losOverheadPct = ((gridRun.stats.avg / noGridRun.stats.avg) - 1) * 100
+    const inRunEvents = noGrid.state.events.filter(e => e.tick > 0).length
+    console.log([
+      `SCALE STRESS — ${unitCount} units, ${missilesInFlight} missiles in flight at t=0, ${TICKS} ticks per run`,
+      `  ${'run'.padEnd(12)}${'avg'.padStart(12)}${'p50'.padStart(12)}${'p95'.padStart(12)}${'max'.padStart(12)}${'total'.padStart(12)}`,
+      row('no grid', noGridRun.stats),
+      row('flat grid', gridRun.stats),
+      `  LOS overhead (flat grid vs none): ${losOverheadPct >= 0 ? '+' : ''}${losOverheadPct.toFixed(0)}% avg`,
+      `  end of no-grid run: ${noGrid.state.missiles.size} missiles live, ${inRunEvents} in-run events`,
+      `  budgets: avg < ${BUDGET_AVG_MS} ms, p95 < ${BUDGET_P95_MS} ms (~3x dev-box measurement, see header)`,
+    ].join('\n'))
+
+    // Scenario actually has the advertised scale
+    expect(unitCount).toBe(500)
+    expect(missilesInFlight).toBeGreaterThanOrEqual(55)
+
+    // Zero thrown errors across both runs
+    expect(noGridRun.errors).toEqual([])
+    expect(gridRun.errors).toEqual([])
+
+    // The sim actually ran: ticks advanced and events kept flowing DURING the run
+    expect(noGrid.state.time.tick).toBe(TICKS)
+    expect(withGrid.state.time.tick).toBe(TICKS)
+    expect(noGrid.state.events.some(e => e.type === 'MISSILE_LAUNCHED')).toBe(true)
+    expect(inRunEvents).toBeGreaterThan(0)
+    expect(withGrid.state.events.some(e => e.tick > 0)).toBe(true)
+
+    // Perf guard, not a benchmark: generous CI-safe ceilings on BOTH runs
+    expect(noGridRun.stats.avg).toBeLessThan(BUDGET_AVG_MS)
+    expect(noGridRun.stats.p95).toBeLessThan(BUDGET_P95_MS)
+    expect(gridRun.stats.avg).toBeLessThan(BUDGET_AVG_MS)
+    expect(gridRun.stats.p95).toBeLessThan(BUDGET_P95_MS)
+    // ~30 s on the dev box; 90 s timeout absorbs slower CI runners
+  }, 90_000)
+})
diff --git a/src/engine/attack-planner.ts b/src/engine/attack-planner.ts
index 02790e0..279897b 100644
--- a/src/engine/attack-planner.ts
+++ b/src/engine/attack-planner.ts
@@ -44,13 +44,8 @@ function adSystemForInterceptor(interceptorId: WeaponId) {
   return Object.values(adSystems).find((s) => s.interceptorId === interceptorId)
 }
 
-/**
- * AD multiplier: how many missiles we need per target given nearby SAM coverage.
- *
- * Looks at all alive enemy SAM sites within 200 km of the target, sums their
- * fire channels, and returns a saturation factor capped at 4.
- */
-function adMultiplier(target: ViewUnit, enemyUnits: ViewUnit[]): number {
+/** Total SAM fire channels from alive enemy SAM sites within 200 km of the target */
+function fireChannelsCovering(target: ViewUnit, enemyUnits: ViewUnit[]): number {
   let totalFireChannels = 0
 
   for (const eu of enemyUnits) {
@@ -69,6 +64,15 @@ function adMultiplier(target: ViewUnit, enemyUnits: ViewUnit[]): number {
     }
   }
 
+  return totalFireChannels
+}
+
+/**
+ * AD multiplier: how many missiles we need per target given nearby SAM coverage.
+ * Returns a saturation factor capped at 4.
+ */
+function adMultiplier(target: ViewUnit, enemyUnits: ViewUnit[]): number {
+  const totalFireChannels = fireChannelsCovering(target, enemyUnits)
   if (totalFireChannels === 0) return 1.0
   const saturationFactor = 1.0 + totalFireChannels * 0.15
   return Math.min(4.0, saturationFactor)
@@ -464,3 +468,104 @@ function buildSummary(
     warnings,
   }
 }
+
+// ────────────────────────────────────────────────
+//  TOT (time-on-target) scheduling
+// ────────────────────────────────────────────────
+
+/** Scheduling slack so even the longest-flight weapon launches in the future */
+export const TOT_PAD_TICKS = 60
+/** Per-round launch ripple within one launcher/weapon row (1 tick = 1 game-sec) */
+export const TOT_RIPPLE_TICKS = 1
+/** Warn when the earliest launch precedes impact by more than 15 game-min */
+export const TOT_DETECTION_WARNING_TICKS = 900
+/** One intercept attempt per fire channel per this many seconds of impact window */
+export const AD_ENGAGEMENT_CYCLE_SEC = 30
+
+export interface TotScheduleEntry {
+  launcherId: string
+  launcherName: string
+  weaponId: WeaponId
+  weaponName: string
+  targetId: string
+  targetName: string
+  count: number
+  /** First round's launch tick; rounds 1..count-1 follow at +TOT_RIPPLE_TICKS each */
+  dueTick: number
+  flightTimeSec: number
+}
+
+export interface TotSchedule {
+  /** Tick every row's last round impacts on (earlier rounds ripple in just before) */
+  totTick: number
+  /** Sorted by dueTick ascending — longest flight launches first */
+  entries: TotScheduleEntry[]
+  earliestLaunchTick: number
+}
+
+/**
+ * Derive per-row launch ticks so every in-range strike impacts together:
+ * totTick = nowTick + max(flightTime) + TOT_PAD_TICKS, and each row launches at
+ * totTick − ceil(flightTime) − (count−1)·ripple. Sent as LAUNCH_SALVO with
+ * spacingTicks = TOT_RIPPLE_TICKS and delayTicks = dueTick − nowTick.
+ */
+export function computeTotSchedule(plan: AttackPlan, nowTick: number): TotSchedule {
+  const rows = plan.strikes.filter((s) => s.inRange && Number.isFinite(s.flightTimeSec))
+  if (rows.length === 0) {
+    const totTick = nowTick + TOT_PAD_TICKS
+    return { totTick, entries: [], earliestLaunchTick: totTick }
+  }
+
+  const maxFlight = Math.max(...rows.map((s) => Math.ceil(s.flightTimeSec)))
+  const totTick = nowTick + maxFlight + TOT_PAD_TICKS
+
+  const entries: TotScheduleEntry[] = rows.map((s) => ({
+    launcherId: s.launcherId,
+    launcherName: s.launcherName,
+    weaponId: s.weaponId,
+    weaponName: s.weaponName,
+    targetId: s.targetId,
+    targetName: s.targetName,
+    count: s.count,
+    dueTick: Math.max(
+      nowTick + 1,
+      totTick - Math.ceil(s.flightTimeSec) - (s.count - 1) * TOT_RIPPLE_TICKS,
+    ),
+    flightTimeSec: s.flightTimeSec,
+  }))
+
+  entries.sort((a, b) => a.dueTick - b.dueTick)
+  return { totTick, entries, earliestLaunchTick: entries[0].dueTick }
+}
+
+/**
+ * Closed-form leaker estimate (EST): each covering SAM fire channel kills one
+ * inbound missile per AD_ENGAGEMENT_CYCLE_SEC of impact window. A compressed
+ * window means fewer engagement cycles, so more missiles leak through.
+ * Returns the number of missiles expected to penetrate across all targets.
+ */
+export function estimateLeakers(
+  strikes: PlannedStrike[],
+  enemyUnits: ViewUnit[],
+  impactWindowSec: number,
+): number {
+  const cycles = 1 + Math.floor(Math.max(0, impactWindowSec) / AD_ENGAGEMENT_CYCLE_SEC)
+
+  const missilesByTarget = new Map<string, number>()
+  for (const s of strikes) {
+    if (!s.inRange) continue
+    missilesByTarget.set(s.targetId, (missilesByTarget.get(s.targetId) ?? 0) + s.count)
+  }
+
+  let leakers = 0
+  for (const [targetId, missiles] of missilesByTarget) {
+    const target = enemyUnits.find((eu) => eu.id === targetId)
+    if (!target) {
+      leakers += missiles
+      continue
+    }
+    const channels = fireChannelsCovering(target, enemyUnits)
+    leakers += Math.max(0, missiles - channels * cycles)
+  }
+  return leakers
+}
diff --git a/src/engine/game-engine.ts b/src/engine/game-engine.ts
index 119e8b6..4fcfbd4 100644
--- a/src/engine/game-engine.ts
+++ b/src/engine/game-engine.ts
@@ -1,9 +1,11 @@
-import type { GameState, GameEvent, NationId, Unit, UnitId } from '@/types/game'
+import type { GameState, GameEvent, NationId, ScheduledLaunch, Unit, UnitId } from '@/types/game'
 import type { GameViewState, ViewUnit } from '@/types/view'
 import type { Command } from '@/types/commands'
 import { SeededRNG } from './utils/rng'
 import { processMovement } from './systems/movement'
+import { resetDetectionCache } from './systems/detection'
 import { processCombat, launchMissile, launchSAM, resetCombatState, setCombatCounters } from './systems/combat'
+import { processScheduledLaunches, scheduleSalvo } from './systems/strike-scheduler'
 import { processAI, resetAIState, orientSAMRadars } from './systems/ai'
 import { processEconomy } from './systems/economy'
 import { processOrders, resetOrdersState } from './systems/orders'
@@ -24,8 +26,11 @@ import { findNavalRoute } from './systems/route-planner'
 import type { SatellitePass } from '@/types/game'
 import { processShipping, resetShippingState } from './systems/shipping'
 import { shippingLanes as defaultShippingLanes } from '@/data/shipping/shipping-lanes'
-import { processVisibility, resetVisibilityState, getViewVisibility, contactDisplayName, type ViewVisibility } from './systems/visibility'
+import { processVisibility, resetVisibilityState, seedInitialVisibility, getViewVisibility, contactDisplayName, type ViewVisibility } from './systems/visibility'
 import { processWarSupport, resetWarSupportState, offerCeasefire, acceptCeasefire, resign, getWarSupport, getObjectives } from './systems/war-support'
+import { processIntel, initIntelState, resetIntelState, taskSatellitePass, taskAgent, restAgent, exfiltrateAgent, opsecSweep, maybeLeakStrike, paranoiaBand } from './systems/intel'
+import { processAirOps, initAirWings, resetAirOpsState, setAirMissionCounter, launchAirMission, cancelAirMission, setSurgeOps, surgeActive, getAirMissionsView } from './systems/air-ops'
+import type { IntelViewState } from '@/types/view'
 
 const TICK_MS = 1_000 // 1 tick = 1 game second (real-time at 1x)
 const SCENARIO_START = new Date('2026-06-15T06:00:00Z').getTime()
@@ -129,6 +134,15 @@ export class GameEngine {
     // Orient sector-limited SAMs toward enemy before first tick
     orientSAMRadars(this.state)
 
+    // Fixed installations are public knowledge — both sides start with them on the map
+    seedInitialVisibility(this.state)
+
+    // Intel suite: ISR assets, HUMINT roster, counterintel meters
+    initIntelState(this.state)
+
+    // Air war: squadron pools on carriers/airbases
+    initAirWings(this.state)
+
     // Initialize satellite constellations (only for modern scenarios with USA/Iran)
     if (this.state.nations.usa && this.state.nations.iran) {
       this.initSatellites()
@@ -151,6 +165,9 @@ export class GameEngine {
     // ROE enforcement before combat
     processOrders(state, this.elevationGrid)
 
+    // Engine-side salvo spacing — runs before combat so due rounds join this tick's air picture
+    processScheduledLaunches(state, (entry) => this.fireScheduledLaunch(entry))
+
     processCombat(state, this.rng, this.elevationGrid, this.sensorNetwork)
     processPointDefense(state, this.rng)
     processShipping(state, this.rng)
@@ -158,10 +175,10 @@ export class GameEngine {
     processLogistics(state)
     processRepair(state)
 
-    // Autonomous offensive fire for weapons_free units (any nation)
-    const friendlyCmds = processFriendlyAI(state, this.rng)
+    // Autonomous engagement of tracked contacts (any nation, ROE-gated)
+    const friendlyCmds = processFriendlyAI(state, this.rng, this.elevationGrid)
     // Enemy AI generates commands
-    const aiCommands = processAI(state, this.rng)
+    const aiCommands = processAI(state, this.rng, this.elevationGrid)
     for (const cmd of [...friendlyCmds, ...aiCommands]) {
       this.executeCommand(cmd)
     }
@@ -175,6 +192,12 @@ export class GameEngine {
     // Fog of war: fold radar/satellite/HUMINT/ELINT pictures into per-nation contacts
     processVisibility(state, this.sensorNetwork, this.lastEspionageResult, this.elevationGrid)
 
+    // Intel suite: satellite taskings, SIGINT intercepts, HUMINT, counterintel
+    processIntel(state, this.rng, this.elevationGrid)
+
+    // Air operations: mission lifecycle, CAP intercepts, strikes, RTB
+    processAirOps(state, this.rng, this.elevationGrid)
+
     // Political will: war-support drains, ceasefire logic, capitulation, objectives
     processWarSupport(state)
 
@@ -203,6 +226,18 @@ export class GameEngine {
       case 'MOVE_UNIT': {
         const unit = state.units.get(cmd.unitId)
         if (unit) {
+          // Land units can't be ordered into the sea — reject up front with feedback
+          const isLandMover = unit.category === 'missile_battery' || unit.category === 'sam_site'
+          const dest = cmd.waypoints[cmd.waypoints.length - 1]
+          if (isLandMover && dest && this.elevationGrid?.isWater(dest.lat, dest.lng)) {
+            this.emitEvent({
+              type: 'ORDER_REJECTED',
+              unitId: unit.id,
+              reason: 'destination is open water',
+              tick: state.time.tick,
+            })
+            break
+          }
           if (unit.deploy_time_sec != null) {
             // Unit has readiness lifecycle (mobile SAMs, TELs)
             if (unit.readiness === 'deployed') {
@@ -220,14 +255,16 @@ export class GameEngine {
             // No readiness lifecycle (ships, aircraft, etc.) — move immediately
             const isNaval = unit.category === 'ship' || unit.category === 'submarine' || unit.category === 'carrier_group'
             if (isNaval && this.elevationGrid && cmd.waypoints.length > 0) {
-              // Auto-route naval units around land
-              const finalDest = cmd.waypoints[cmd.waypoints.length - 1]
-              const route = findNavalRoute(unit.position, finalDest, this.elevationGrid)
-              if (route) {
-                unit.waypoints = [...route, finalDest]
-              } else {
-                unit.waypoints = cmd.waypoints // fallback to direct if no route
+              // Auto-route naval units around land, honoring every player waypoint as a leg
+              const routed: typeof cmd.waypoints = []
+              let from = unit.position
+              for (const wp of cmd.waypoints) {
+                const leg = findNavalRoute(from, wp, this.elevationGrid)
+                if (leg) routed.push(...leg)
+                routed.push(wp)
+                from = wp
               }
+              unit.waypoints = routed
             } else {
               unit.waypoints = cmd.waypoints
             }
@@ -237,7 +274,8 @@ export class GameEngine {
         break
       }
       case 'LAUNCH_MISSILE': {
-        const event = launchMissile(state, cmd.launcherId, cmd.weaponId, cmd.targetId, cmd.waypoints)
+        const compromised = this.applyStrikeLeak(cmd.launcherId, cmd.targetId, cmd.trackQuality)
+        const event = launchMissile(state, cmd.launcherId, cmd.weaponId, cmd.targetId, cmd.waypoints, cmd.trackQuality, compromised)
         if (event) {
           const launcher = state.units.get(cmd.launcherId)
           const target = state.units.get(cmd.targetId)
@@ -252,9 +290,45 @@ export class GameEngine {
       case 'LAUNCH_SALVO': {
         if (cmd.count <= 0) break
 
+        const compromised = this.applyStrikeLeak(cmd.launcherId, cmd.targetId, undefined)
+
+        // TOT path: a delayed first round can't fire "now" — queue the whole salvo
+        if ((cmd.delayTicks ?? 0) > 0) {
+          scheduleSalvo(state, cmd, compromised)
+          break
+        }
+
+        const spacing = cmd.spacingTicks ?? 0
+        if (spacing > 0) {
+          // First round fires now (war declaration + the salvo's single leak roll just
+          // happened); the rest are scheduled on GameState and reuse the same roll.
+          const fired = this.fireScheduledLaunch({
+            dueTick: state.time.tick,
+            launcherId: cmd.launcherId,
+            weaponId: cmd.weaponId,
+            targetId: cmd.targetId,
+            waypoints: cmd.waypoints,
+            compromised,
+          })
+          if (!fired) break // whole salvo would have failed today — don't queue duds
+
+          state.scheduledLaunches ??= []
+          for (let i = 1; i < cmd.count; i++) {
+            state.scheduledLaunches.push({
+              dueTick: state.time.tick + i * spacing,
+              launcherId: cmd.launcherId,
+              weaponId: cmd.weaponId,
+              targetId: cmd.targetId,
+              waypoints: cmd.waypoints,
+              compromised,
+            })
+          }
+          break
+        }
+
         let declaredWar = false
         for (let i = 0; i < cmd.count; i++) {
-          const event = launchMissile(state, cmd.launcherId, cmd.weaponId, cmd.targetId, cmd.waypoints)
+          const event = launchMissile(state, cmd.launcherId, cmd.weaponId, cmd.targetId, cmd.waypoints, undefined, compromised)
           if (!event) break
 
           if (!declaredWar) {
@@ -302,9 +376,84 @@ export class GameEngine {
         if (unit) unit.droneMission = cmd.mission
         break
       }
+      case 'TASK_SATELLITE_PASS': {
+        taskSatellitePass(state, cmd.assetId, cmd.target, cmd.cloudPct)
+        break
+      }
+      case 'TASK_AGENT': {
+        taskAgent(state, this.rng, cmd.agentId)
+        break
+      }
+      case 'REST_AGENT': {
+        restAgent(state, cmd.agentId)
+        break
+      }
+      case 'EXFILTRATE_AGENT': {
+        exfiltrateAgent(state, cmd.agentId)
+        break
+      }
+      case 'OPSEC_SWEEP': {
+        opsecSweep(state)
+        break
+      }
+      case 'SET_EMCON': {
+        const unit = state.units.get(cmd.unitId)
+        if (unit) unit.emcon = cmd.emcon
+        break
+      }
+      case 'LAUNCH_AIR_MISSION': {
+        launchAirMission(state, this.rng, cmd)
+        break
+      }
+      case 'CANCEL_AIR_MISSION': {
+        cancelAirMission(state, cmd.missionId)
+        break
+      }
+      case 'SET_SURGE_OPS': {
+        setSurgeOps(state, cmd.enabled)
+        break
+      }
     }
   }
 
+  /**
+   * Deliberate player strikes (strike panel, no auto-fire trackQuality) feed Iranian
+   * pattern analysis: bump the leak level and possibly compromise this launch.
+   */
+  private applyStrikeLeak(launcherId: UnitId, targetId: UnitId, trackQuality?: import('@/types/game').TrackQuality): boolean {
+    const { state } = this
+    if (trackQuality) return false // reactive auto-engagement, not a planned strike
+    const intel = state.intel
+    const launcher = state.units.get(launcherId)
+    const target = state.units.get(targetId)
+    if (!intel || !launcher || !target) return false
+    if (launcher.nation !== state.playerNation || target.nation === state.playerNation) return false
+    intel.leakLevel = Math.min(100, intel.leakLevel + 5)
+    return maybeLeakStrike(state, this.rng, targetId)
+  }
+
+  /**
+   * Same side effects as the LAUNCH_MISSILE command minus the leak roll — that
+   * happened once when the salvo was commanded and the entry carries the result.
+   */
+  private fireScheduledLaunch(entry: ScheduledLaunch): boolean {
+    const { state } = this
+    // launchMissile doesn't check status — destroyed units keep their loadout
+    const launcher = state.units.get(entry.launcherId)
+    const target = state.units.get(entry.targetId)
+    if (!launcher || launcher.status === 'destroyed') return false
+    if (!target || target.status === 'destroyed') return false
+
+    const event = launchMissile(state, entry.launcherId, entry.weaponId, entry.targetId, entry.waypoints, entry.trackQuality, entry.compromised)
+    if (!event) return false
+
+    if (launcher.nation !== target.nation) {
+      this.declareWar(launcher.nation, target.nation)
+    }
+    this.emitEvent(event)
+    return true
+  }
+
   /** Get serializable snapshot for the main thread */
   getViewState(): GameViewState {
     const { state } = this
@@ -314,7 +463,7 @@ export class GameEngine {
     const units: ViewUnit[] = []
     for (const u of state.units.values()) {
       const vis = getViewVisibility(state, state.playerNation, u)
-      if (vis) units.push(toViewUnit(u, vis))
+      if (vis) units.push(toViewUnit(u, vis, state.playerNation))
     }
 
     return {
@@ -332,6 +481,29 @@ export class GameEngine {
       warSupport: getWarSupport(state),
       gameOver: state.gameOver ?? null,
       objectives: getObjectives(state),
+      intel: this.getIntelViewState(),
+      airMissions: getAirMissionsView(state, state.playerNation),
+      surgeOps: surgeActive(state),
+    }
+  }
+
+  /** Player-nation slice of the intel suite — exact paranoia stays engine-side */
+  private getIntelViewState(): IntelViewState {
+    const intel = this.state.intel
+    if (!intel) {
+      return { assets: [], agents: [], products: [], taskings: [], leakLevel: 0, paranoiaBand: 'LOW', encryptionUpgradedUntilTick: null }
+    }
+    const player = this.state.playerNation
+    return {
+      assets: Object.values(intel.assets).filter(a => a.nation === player).map(a => ({ ...a })),
+      agents: player === 'usa' ? Object.values(intel.agents).map(a => ({ ...a })) : [],
+      products: player === 'usa' ? intel.products.map(p => ({ ...p })) : [],
+      taskings: intel.taskings
+        .filter(t => intel.assets[t.assetId]?.nation === player)
+        .map(t => ({ ...t, target: { ...t.target } })),
+      leakLevel: intel.leakLevel,
+      paranoiaBand: paranoiaBand(intel.paranoia),
+      encryptionUpgradedUntilTick: intel.encryptionUpgradedUntilTick ?? null,
     }
   }
 
@@ -347,6 +519,10 @@ export class GameEngine {
       visibility: s.visibility ?? {},
       warStatus: s.warStatus ?? {},
       gameOver: s.gameOver ?? null,
+      intel: s.intel ?? null,
+      scheduledLaunches: s.scheduledLaunches ?? [],
+      airMissions: s.airMissions ?? [],
+      surgeOps: s.surgeOps ?? null,
       units: Array.from(s.units.entries()),
       missiles: Array.from(s.missiles.entries()),
       supplyLines: Array.from(s.supplyLines.entries()),
@@ -389,7 +565,16 @@ export class GameEngine {
       visibility: raw.visibility ?? {},
       warStatus: raw.warStatus ?? {},
       gameOver: raw.gameOver ?? undefined,
+      intel: raw.intel ?? undefined,
+      scheduledLaunches: raw.scheduledLaunches ?? undefined,
+      airMissions: raw.airMissions ?? undefined,
+      surgeOps: raw.surgeOps ?? undefined,
     }
+    // Saves from before the intel suite get a fresh roster
+    if (!this.state.intel) initIntelState(this.state)
+    // Saves from before the air war get wings stood up fresh
+    if (!this.state.airMissions) initAirWings(this.state)
+    setAirMissionCounter(this.state)
     // Backfill shipping lanes for old saves that didn't have them
     if (!raw.shippingLanes || raw.shippingLanes.length === 0) {
       for (const lane of defaultShippingLanes) {
@@ -435,6 +620,9 @@ export class GameEngine {
     resetShippingState()
     resetVisibilityState()
     resetWarSupportState()
+    resetIntelState()
+    resetDetectionCache()
+    resetAirOpsState()
   }
 
   /** Set up satellite constellations for each nation */
@@ -531,11 +719,12 @@ export class GameEngine {
   }
 }
 
-function toViewUnit(u: Unit, vis: ViewVisibility): ViewUnit {
+function toViewUnit(u: Unit, vis: ViewVisibility, playerNation: NationId): ViewUnit {
   // Scrub by contact quality: 'detected' hides everything but the contact itself,
   // 'tracked' shows identity and condition but not loadout. Own units are 'identified'.
   const identified = vis.level === 'identified'
   const trackedPlus = identified || vis.level === 'tracked'
+  const isOwn = u.nation === playerNation
   return {
     id: u.id,
     name: trackedPlus ? u.name : contactDisplayName(u.category),
@@ -563,5 +752,10 @@ function toViewUnit(u: Unit, vis: ViewVisibility): ViewUnit {
     droneMission: identified ? u.droneMission : undefined,
     visibility: vis.level,
     stale: vis.stale,
+    emcon: isOwn ? u.emcon : undefined,
+    // isDecoy itself NEVER leaks — only the revealed verdict (own decoys are always known)
+    decoyRevealed: (isOwn ? u.isDecoy : u.decoyRevealed) || undefined,
+    // Squadron pools are own-side knowledge; enemy strength estimates come from BDA only
+    airWing: isOwn && u.airWing ? u.airWing.map(s => ({ ...s, readyAt: [...s.readyAt] })) : undefined,
   }
 }
diff --git a/src/engine/systems/__tests__/detection-integration.test.ts b/src/engine/systems/__tests__/detection-integration.test.ts
index 2c04ef8..3c2ab69 100644
--- a/src/engine/systems/__tests__/detection-integration.test.ts
+++ b/src/engine/systems/__tests__/detection-integration.test.ts
@@ -230,12 +230,8 @@ describe('orientSAMRadars', () => {
   })
 })
 
-describe('radar horizon', () => {
-  it('radar horizon caps effectiveRange, does not skip detection (bug #4 regression)', () => {
-    // Regression: the old code did `if (horizonKm < dist) continue` which completely
-    // skipped detection. The fix: cap effectiveRange to horizonKm, then check dist <= effectiveRange.
-    // A low-altitude missile close to the radar should still be detected.
-
+describe('low-altitude clutter', () => {
+  it('detects a sea-skimmer close to the radar', () => {
     // Flat grid at sea level
     const elevations = Array.from({ length: 5 }, () => Array(5).fill(0))
     const grid = makeGrid(24, 29, 50, 55, 1.0, elevations)
@@ -247,9 +243,7 @@ describe('radar horizon', () => {
       sensors: [{ type: 'radar', range_km: 180, detection_prob: 0.95, antenna_height_m: 15 }],
     })
 
-    // Low-altitude missile (30m) very close to the radar (~7km away)
-    // Radar horizon at 15m antenna + 30m target = 4.12*(sqrt(15)+sqrt(30)) = 4.12*(3.87+5.48) = ~38.5km
-    // Distance ~7km < 38.5km -> should detect
+    // Low flyer (30m) very close (~7km): well inside the clutter-reduced envelope
     const missile = makeMissile({
       id: 'low_cruise',
       nation: 'iran',
@@ -264,8 +258,7 @@ describe('radar horizon', () => {
     expect(threats[0].missile.id).toBe('low_cruise')
   })
 
-  it('radar horizon blocks detection of distant low-altitude targets', () => {
-    // Low-altitude missile far away should not be detected due to horizon
+  it('surface clutter shrinks the envelope against distant sea-skimmers', () => {
     const elevations = Array.from({ length: 10 }, () => Array(10).fill(0))
     const grid = makeGrid(20, 30, 45, 55, 1.0, elevations)
 
@@ -276,9 +269,8 @@ describe('radar horizon', () => {
       sensors: [{ type: 'radar', range_km: 180, detection_prob: 0.95, antenna_height_m: 15 }],
     })
 
-    // Low-altitude missile 100km away
-    // Radar horizon at 15m + 30m = 4.12*(3.87+5.48) = ~38.5km
-    // Distance ~100km > 38.5km -> should NOT detect
+    // Sea-skimmer profile (<500 ft) flies in clutter: 180 km radar sees it at
+    // 180 × 0.4 = 72 km, so at ~100 km it is still invisible
     const missile = makeMissile({
       id: 'distant_low',
       nation: 'iran',
@@ -293,6 +285,40 @@ describe('radar horizon', () => {
   })
 })
 
+describe('multi-radar elevation pairing', () => {
+  it('long-range radar uses its OWN antenna height for the elevation bonus (max+first pairing regression)', () => {
+    const elevations = Array.from({ length: 10 }, () => Array(10).fill(0))
+    const grid = makeGrid(20, 30, 45, 55, 1.0, elevations)
+
+    const sam = makeUnit({
+      id: 'dual_radar',
+      nation: 'usa',
+      position: { lat: 25, lng: 51 },
+      sensors: [
+        { type: 'radar', range_km: 60, detection_prob: 0.95, antenna_height_m: 0 },     // first: short, ground-level
+        { type: 'radar', range_km: 100, detection_prob: 0.9, antenna_height_m: 10000 }, // second: long, elevated
+      ],
+    })
+
+    // ~120km north: beyond the long radar's 100km nominal range, inside
+    // 100 × 1.5 = 150km once ITS 10km antenna earns the full elevation bonus.
+    // Old pairing applied the FIRST radar's 0m antenna (no bonus) → missed.
+    const missile = makeMissile({
+      id: 'edge_runner',
+      nation: 'iran',
+      weaponId: 'test_no_spec', // no weaponSpec → no RCS/clutter modifiers
+      altitude_m: 8000,
+      path: [[51, 26.08], [51, 26.09]],
+      timestamps: [1000, 2000],
+    })
+
+    const state = makeState([sam], [missile])
+    const threats = detectThreats(state, sam, grid)
+    expect(threats).toHaveLength(1)
+    expect(threats[0].missile.id).toBe('edge_runner')
+  })
+})
+
 describe('networked detection', () => {
   it('SAM connected to AWACS can see AWACS-detected threats', () => {
     // AWACS detects a missile far away. SAM within datalink range of AWACS
diff --git a/src/engine/systems/__tests__/detection.test.ts b/src/engine/systems/__tests__/detection.test.ts
index ed87605..bdd5af0 100644
--- a/src/engine/systems/__tests__/detection.test.ts
+++ b/src/engine/systems/__tests__/detection.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { detectThreats } from '../detection'
+import { detectThreats, resetDetectionCache } from '../detection'
 import type { GameState, Unit, Missile, NationId } from '@/types/game'
 
 // ── Helpers ─────────────────────────────────────────────────────
@@ -268,3 +268,133 @@ describe('detectThreats', () => {
     expect(threats.length).toBeGreaterThanOrEqual(1)
   })
 })
+
+describe('multi-radar units', () => {
+  it('a second omni radar is not constrained by the first radar sector (max+first pairing regression)', () => {
+    // Old code took max(range) across radars but the FIRST radar's sector:
+    // 500km range paired with the short radar's north-facing 90° arc missed this.
+    const sam = makeUnit({
+      id: 'dual_radar',
+      nation: 'usa',
+      position: { lat: 25, lng: 51 },
+      heading: 0, // sectored radar faces north
+      sensors: [
+        { type: 'radar', range_km: 30, detection_prob: 0.95, sector_deg: 90 }, // short, north arc
+        { type: 'radar', range_km: 500, detection_prob: 0.9 },                 // long, omni
+      ],
+    })
+    // ~111km due south: outside the first radar's arc AND beyond its range,
+    // but well inside the second (omni) radar's range
+    const missile = makeMissile({
+      id: 'south_runner',
+      nation: 'iran',
+      path: [[51, 24], [51, 24.1]],
+      timestamps: [1000, 2000],
+    })
+    const state = makeState([sam], [missile])
+    const threats = detectThreats(state, sam)
+    expect(threats).toHaveLength(1)
+    expect(threats[0].missile.id).toBe('south_runner')
+  })
+
+  it('each radar contributes independently (short omni close-in, long sectored at range)', () => {
+    const sam = makeUnit({
+      id: 'dual_radar',
+      nation: 'usa',
+      position: { lat: 25, lng: 51 },
+      heading: 0,
+      sensors: [
+        { type: 'radar', range_km: 30, detection_prob: 0.95 },                 // short, omni
+        { type: 'radar', range_km: 500, detection_prob: 0.9, sector_deg: 90 }, // long, north arc
+      ],
+    })
+    // ~22km south — only the short omni radar covers it (long one looks north)
+    const closeSouth = makeMissile({
+      id: 'close_south',
+      nation: 'iran',
+      path: [[51, 24.8], [51, 24.81]],
+      timestamps: [1000, 2000],
+    })
+    // ~111km north — only the long sectored radar reaches it
+    const farNorth = makeMissile({
+      id: 'far_north',
+      nation: 'iran',
+      path: [[51, 26], [51, 26.1]],
+      timestamps: [1000, 2000],
+      eta: 3000,
+    })
+    const state = makeState([sam], [closeSouth, farNorth])
+    const threats = detectThreats(state, sam)
+    expect(threats.map(t => t.missile.id).sort()).toEqual(['close_south', 'far_north'])
+  })
+})
+
+describe('per-tick memoization', () => {
+  function dualSetup() {
+    const sam = makeUnit({
+      id: 'patriot',
+      nation: 'usa',
+      position: { lat: 25, lng: 51 },
+      sensors: [{ type: 'radar', range_km: 500, detection_prob: 0.95 }],
+    })
+    const missile = makeMissile({
+      id: 'm1',
+      nation: 'iran',
+      path: [[51, 25.2], [51, 25.3]],
+      timestamps: [1000, 2000],
+    })
+    const state = makeState([sam], [missile])
+    return { sam, state }
+  }
+
+  it('returns the identical result within a tick and recomputes next tick', () => {
+    const { sam, state } = dualSetup()
+
+    const first = detectThreats(state, sam)
+    expect(first).toHaveLength(1)
+    // Same tick → same array instance (memoized)
+    expect(detectThreats(state, sam)).toBe(first)
+
+    // A missile added mid-tick is invisible to the memoized snapshot
+    state.missiles.set('m2', makeMissile({
+      id: 'm2',
+      nation: 'iran',
+      path: [[51, 25.2], [51, 25.3]],
+      timestamps: [1000, 2000],
+    }))
+    expect(detectThreats(state, sam)).toBe(first)
+
+    // Next tick recomputes and sees both missiles
+    state.time.tick++
+    const next = detectThreats(state, sam)
+    expect(next).not.toBe(first)
+    expect(next).toHaveLength(2)
+  })
+
+  it('resetDetectionCache forces recomputation within the same tick', () => {
+    const { sam, state } = dualSetup()
+
+    expect(detectThreats(state, sam)).toHaveLength(1)
+    state.missiles.set('m2', makeMissile({
+      id: 'm2',
+      nation: 'iran',
+      path: [[51, 25.2], [51, 25.3]],
+      timestamps: [1000, 2000],
+    }))
+    resetDetectionCache()
+    expect(detectThreats(state, sam)).toHaveLength(2)
+  })
+
+  it('honors a mid-tick EMCON flip despite the memo', () => {
+    const { sam, state } = dualSetup()
+
+    const first = detectThreats(state, sam)
+    expect(first).toHaveLength(1)
+
+    sam.emcon = true
+    expect(detectThreats(state, sam)).toHaveLength(0)
+
+    sam.emcon = false
+    expect(detectThreats(state, sam)).toBe(first)
+  })
+})
diff --git a/src/engine/systems/__tests__/friendly-ai.test.ts b/src/engine/systems/__tests__/friendly-ai.test.ts
index aded62d..d6a7712 100644
--- a/src/engine/systems/__tests__/friendly-ai.test.ts
+++ b/src/engine/systems/__tests__/friendly-ai.test.ts
@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach } from 'vitest'
 import { processFriendlyAI, resetFriendlyAIState } from '../friendly-ai'
 import { SeededRNG } from '../../utils/rng'
-import type { GameState, Unit, NationId, WeaponLoadout } from '@/types/game'
+import type { GameState, Sensor, Unit, NationId, WeaponLoadout } from '@/types/game'
 
 // ── Helpers ─────────────────────────────────────────────────────
 
@@ -33,6 +33,11 @@ function loadout(weaponId: string, count: number): WeaponLoadout {
   return { weaponId, count, maxCount: count, reloadTimeSec: 0 }
 }
 
+// Tall mast keeps the radar horizon out of these doctrine tests
+function radar(range_km: number): Sensor {
+  return { type: 'radar', range_km, detection_prob: 0.9, antenna_height_m: 2000 }
+}
+
 function makeState(units: Unit[]): GameState {
   return {
     playerNation: 'usa',
@@ -60,7 +65,18 @@ function makeState(units: Unit[]): GameState {
   }
 }
 
-// Iranian ship ~55km away — inside harpoon (130km) and tomahawk (1600km) range
+/** Seed a live nation-level contact so datalink engagement is possible */
+function seedContact(state: GameState, observer: NationId, target: Unit): void {
+  state.visibility ??= {}
+  const contacts = (state.visibility[observer as string] ??= {})
+  contacts[target.id] = {
+    level: 'tracked',
+    lastSeenTick: state.time.tick,
+    lastKnownPosition: { ...target.position },
+  }
+}
+
+// Iranian ship ~55km away — inside harpoon (130km) range
 const enemyShip = () => makeUnit({ id: 'ir_ship', nation: 'iran', position: { lat: 26.5, lng: 52 } })
 
 // ── Tests ───────────────────────────────────────────────────────
@@ -74,6 +90,7 @@ describe('processFriendlyAI', () => {
     const ship = makeUnit({
       id: 'us_ship',
       nation: 'usa',
+      sensors: [radar(200)],
       weapons: [loadout('tomahawk', 30), loadout('sm6', 12), loadout('harpoon', 8)],
     })
     const state = makeState([ship, enemyShip()])
@@ -99,6 +116,7 @@ describe('processFriendlyAI', () => {
       nation: 'iran',
       category: 'missile_battery',
       position: { lat: 26.5, lng: 52 },
+      sensors: [radar(200)],
       weapons: [loadout('fateh110', 30), loadout('shahed_136', 40)],
     })
     const usTarget = makeUnit({ id: 'us_ship', nation: 'usa', position: { lat: 26, lng: 52 } })
@@ -115,6 +133,7 @@ describe('processFriendlyAI', () => {
       readiness: 'packing',
       readinessTimer: 300,
       deploy_time_sec: 600,
+      sensors: [radar(200)],
       weapons: [loadout('harpoon', 8)],
     })
     const state = makeState([battery, enemyShip()])
@@ -128,4 +147,91 @@ describe('processFriendlyAI', () => {
     const cmds = processFriendlyAI(state, new SeededRNG(42))
     expect(cmds.length).toBeGreaterThanOrEqual(1)
   })
+
+  it('holds fire with no track: blind ships cannot engage targets in weapon range', () => {
+    const ship = makeUnit({
+      id: 'us_ship',
+      nation: 'usa',
+      weapons: [loadout('harpoon', 8)],
+    })
+    const state = makeState([ship, enemyShip()])
+
+    expect(processFriendlyAI(state, new SeededRNG(42))).toHaveLength(0)
+  })
+
+  it('engages on own radar with own quality and emits AUTO_ENGAGEMENT', () => {
+    const ship = makeUnit({
+      id: 'us_ship',
+      nation: 'usa',
+      sensors: [radar(200)],
+      weapons: [loadout('harpoon', 8)],
+    })
+    const state = makeState([ship, enemyShip()])
+
+    const cmds = processFriendlyAI(state, new SeededRNG(42))
+    expect(cmds.length).toBeGreaterThanOrEqual(1)
+    expect(cmds.every(c => c.type === 'LAUNCH_MISSILE' && c.trackQuality === 'own')).toBe(true)
+
+    const engagement = state.events.find(e => e.type === 'AUTO_ENGAGEMENT')
+    expect(engagement).toBeDefined()
+    if (engagement?.type === 'AUTO_ENGAGEMENT') {
+      expect(engagement.targetId).toBe('ir_ship')
+      expect(engagement.quality).toBe('own')
+    }
+  })
+
+  it('engages on a datalink track when the nation holds a live contact', () => {
+    const ship = makeUnit({
+      id: 'us_ship',
+      nation: 'usa',
+      datalink_range_km: 150, // hub itself → on the network
+      weapons: [loadout('harpoon', 8)],
+    })
+    const target = enemyShip()
+    const state = makeState([ship, target])
+    seedContact(state, 'usa', target)
+
+    const cmds = processFriendlyAI(state, new SeededRNG(42))
+    expect(cmds.length).toBeGreaterThanOrEqual(1)
+    expect(cmds.every(c => c.type === 'LAUNCH_MISSILE' && c.trackQuality === 'datalink')).toBe(true)
+  })
+
+  it('weapons_tight only engages inside the self-defense bubble', () => {
+    const tightShip = makeUnit({
+      id: 'us_tight',
+      nation: 'usa',
+      roe: 'weapons_tight',
+      sensors: [radar(200)],
+      weapons: [loadout('harpoon', 8)],
+    })
+    // ~111km away: in harpoon range, outside the 75km self-defense bubble
+    const farTarget = makeUnit({ id: 'ir_far', nation: 'iran', position: { lat: 27, lng: 52 } })
+    const state = makeState([tightShip, farTarget])
+
+    expect(processFriendlyAI(state, new SeededRNG(42))).toHaveLength(0)
+
+    // Same geometry under weapons_free fires
+    tightShip.roe = 'weapons_free'
+    resetFriendlyAIState()
+    expect(processFriendlyAI(state, new SeededRNG(42)).length).toBeGreaterThanOrEqual(1)
+  })
+
+  it('does not pile a second salvo onto a freshly engaged target', () => {
+    const a = makeUnit({
+      id: 'us_a', nation: 'usa', sensors: [radar(200)], weapons: [loadout('harpoon', 8)],
+    })
+    const b = makeUnit({
+      id: 'us_b', nation: 'usa', position: { lat: 26.1, lng: 52 }, sensors: [radar(200)], weapons: [loadout('harpoon', 8)],
+    })
+    const state = makeState([a, b, enemyShip()])
+
+    const cmds = processFriendlyAI(state, new SeededRNG(42))
+    const shooters = new Set(cmds.map(c => c.type === 'LAUNCH_MISSILE' ? c.launcherId : ''))
+    expect(shooters.size).toBe(1)
+
+    // After the re-engage window the second ship may add its own salvo
+    state.time.tick += 200
+    const later = processFriendlyAI(state, new SeededRNG(43))
+    expect(later.length).toBeGreaterThanOrEqual(1)
+  })
 })
diff --git a/src/engine/systems/__tests__/intel.test.ts b/src/engine/systems/__tests__/intel.test.ts
new file mode 100644
index 0000000..360195d
--- /dev/null
+++ b/src/engine/systems/__tests__/intel.test.ts
@@ -0,0 +1,870 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import {
+  processIntel,
+  initIntelState,
+  resetIntelState,
+  taskSatellitePass,
+  taskAgent,
+  restAgent,
+  exfiltrateAgent,
+  opsecSweep,
+  maybeLeakStrike,
+  paranoiaBand,
+} from '../intel'
+import { processVisibility, resetVisibilityState, revealContact, radarSeesUnit } from '../visibility'
+import { detectThreats } from '../detection'
+import { processWarSupport, resetWarSupportState, getWarSupport } from '../war-support'
+import { resetAIState } from '../ai'
+import { resetSatelliteState } from '../satellites'
+import { GameEngine } from '../../game-engine'
+import { SeededRNG } from '../../utils/rng'
+import { haversine } from '../../utils/geo'
+import type { EspionageResult } from '../espionage'
+import type { GameEvent, GameState, Missile, Nation, NationId, Position, Sensor, Unit, UnitId } from '@/types/game'
+
+// ── Helpers ─────────────────────────────────────────────────────
+
+function makeUnit(overrides: Partial<Unit> & { id: string; nation: NationId }): Unit {
+  return {
+    name: overrides.id,
+    category: 'ship',
+    position: { lat: 27, lng: 52 },
+    heading: 0,
+    speed_kts: 0,
+    maxSpeed_kts: 0,
+    health: 100,
+    maxHealth: 100,
+    hardness: 100,
+    logistics: 0,
+    supplyStocks: [],
+    weapons: [],
+    pointDefense: [],
+    sensors: [],
+    roe: 'weapons_tight' as const,
+    status: 'ready' as const,
+    waypoints: [],
+    subordinateIds: [],
+    ...overrides,
+  } as Unit
+}
+
+function radar(range_km: number, antenna_height_m = 2000): Sensor {
+  return { type: 'radar', range_km, detection_prob: 0.9, antenna_height_m }
+}
+
+function makeState(units: Unit[], opts: { atWar?: boolean; tick?: number } = {}): GameState {
+  const atWar = opts.atWar ?? true
+  const state: GameState = {
+    playerNation: 'usa',
+    initialized: true,
+    time: { tick: opts.tick ?? 0, timestamp: 1_000_000, speed: 1, tickIntervalMs: 100 },
+    nations: {
+      usa: {
+        id: 'usa', name: 'USA',
+        economy: { gdp_billions: 28000, military_budget_billions: 886, military_budget_pct_gdp: 3.2, oil_revenue_billions: 0, sanctions_impact: 0, war_cost_per_day_millions: 300, reserves_billions: 800, oilPrice_per_barrel: 80 },
+        relations: { usa: 100, iran: -60 }, atWar: atWar ? ['iran'] : [],
+        // sigint_pct 50 → intercept interval exactly 20 game-min (1200 ticks)
+        intelBudget: { total_pct: 10, humint_pct: 25, sigint_pct: 50, satellite_pct: 25 },
+      },
+      iran: {
+        id: 'iran', name: 'Iran',
+        economy: { gdp_billions: 400, military_budget_billions: 25, military_budget_pct_gdp: 6.3, oil_revenue_billions: 50, sanctions_impact: 0.3, war_cost_per_day_millions: 50, reserves_billions: 120, oilPrice_per_barrel: 80 },
+        relations: { usa: -60, iran: 100 }, atWar: atWar ? ['usa'] : [],
+      },
+    },
+    units: new Map(units.map(u => [u.id, u])),
+    missiles: new Map(),
+    supplyLines: new Map(),
+    shippingLanes: new Map(),
+    events: [],
+    pendingEvents: [],
+  }
+  initIntelState(state)
+  return state
+}
+
+/** Silence the always-on collectors so a test only exercises the system under test */
+function isolateIntel(state: GameState, opts: { sigint?: boolean; triton?: boolean; decoys?: boolean } = {}): void {
+  const intel = state.intel!
+  if (!opts.sigint) intel.assets.rc135.status = 'lost'
+  if (!opts.triton) intel.assets.mq4c.status = 'lost'
+  if (!opts.decoys) intel.decoysSpawned = true
+}
+
+function runIntel(state: GameState, rng: SeededRNG, tick: number): void {
+  state.time.tick = tick
+  processIntel(state, rng, null)
+}
+
+function eventsOf<T extends GameEvent['type']>(state: GameState, type: T): Extract<GameEvent, { type: T }>[] {
+  return state.events.filter((e): e is Extract<GameEvent, { type: T }> => e.type === type)
+}
+
+function contact(state: GameState, observer: string, unitId: UnitId) {
+  return state.visibility?.[observer]?.[unitId]
+}
+
+const TARGET: Position = { lat: 27, lng: 52 }
+
+beforeEach(() => {
+  resetIntelState()
+  resetVisibilityState()
+  resetWarSupportState()
+  resetAIState()
+  resetSatelliteState()
+})
+
+// At lat 27, 1 degree of longitude ≈ 99 km
+
+// ── Satellite tasking (design §1.2) ─────────────────────────────
+
+describe('satellite tasking', () => {
+  it('queues one tasking per asset and re-tasking replaces it', () => {
+    const state = makeState([])
+    taskSatellitePass(state, 'kh11', { lat: 27, lng: 52 })
+    taskSatellitePass(state, 'kh11', { lat: 29, lng: 54 })
+    taskSatellitePass(state, 'commercial', { lat: 26, lng: 55 })
+
+    const taskings = state.intel!.taskings
+    expect(taskings).toHaveLength(2)
+    const kh11 = taskings.filter(t => t.assetId === 'kh11')
+    expect(kh11).toHaveLength(1)
+    expect(kh11[0].target).toEqual({ lat: 29, lng: 54 })
+  })
+
+  it('rejects non-imaging and unknown assets', () => {
+    const state = makeState([])
+    taskSatellitePass(state, 'rc135', TARGET)
+    taskSatellitePass(state, 'nope', TARGET)
+    expect(state.intel!.taskings).toHaveLength(0)
+  })
+
+  it('resolves at the asset pass window, not before', () => {
+    const state = makeState([makeUnit({ id: 'ir_ship', nation: 'iran' })])
+    isolateIntel(state)
+    const rng = new SeededRNG(1)
+    taskSatellitePass(state, 'kh11', TARGET, 10) // kh11 revisit 240 min = 14400 ticks
+
+    runIntel(state, rng, 60)
+    runIntel(state, rng, 14340)
+    expect(eventsOf(state, 'SATELLITE_PASS_COMPLETE')).toHaveLength(0)
+    expect(state.intel!.taskings).toHaveLength(1)
+
+    runIntel(state, rng, 14400)
+    expect(eventsOf(state, 'SATELLITE_PASS_COMPLETE')).toHaveLength(1)
+    expect(state.intel!.taskings).toHaveLength(0)
+  })
+
+  it('refreshes the 60 km swath: fixed sites and tracked contacts → identified, new → tracked', () => {
+    const airbase = makeUnit({ id: 'ir_base', nation: 'iran', category: 'airbase', position: { lat: 27, lng: 52.3 } })   // ~30 km
+    const trackedShip = makeUnit({ id: 'ir_ship', nation: 'iran', position: { lat: 27, lng: 52.2 } })                     // ~20 km
+    const newTel = makeUnit({ id: 'ir_tel', nation: 'iran', category: 'missile_battery', position: { lat: 27, lng: 52.4 } }) // ~40 km
+    const farShip = makeUnit({ id: 'ir_far', nation: 'iran', position: { lat: 27, lng: 53 } })                            // ~99 km
+    const state = makeState([airbase, trackedShip, newTel, farShip])
+    isolateIntel(state)
+    revealContact(state, 'usa', trackedShip, 'tracked')
+
+    state.intel!.assets.kh11.lastCollectionTick = -14400
+    taskSatellitePass(state, 'kh11', TARGET, 10)
+    const rng = new SeededRNG(1)
+    runIntel(state, rng, 60)
+
+    expect(contact(state, 'usa', 'ir_base')?.level).toBe('identified')
+    expect(contact(state, 'usa', 'ir_ship')?.level).toBe('identified')
+    expect(contact(state, 'usa', 'ir_tel')?.level).toBe('tracked')
+    expect(contact(state, 'usa', 'ir_far')).toBeUndefined()
+
+    const done = eventsOf(state, 'SATELLITE_PASS_COMPLETE')
+    expect(done).toHaveLength(1)
+    expect(done[0]).toMatchObject({ assetId: 'kh11', found: 3, revealedDecoys: 0 })
+
+    const product = state.intel!.products[0]
+    expect(product).toMatchObject({ kind: 'imint', assetId: 'kh11', niirs: 8, classification: 'TOP SECRET//TK//NOFORN' })
+    expect(product.target).toEqual(TARGET)
+    expect(product.caption).toContain('probable TEL group')
+
+    expect(state.intel!.paranoia).toBe(14) // 10 + 4 for a kh11 pass
+  })
+
+  it('cloud >= 70 fails the pass with no product and a half-revisit retry', () => {
+    const state = makeState([makeUnit({ id: 'ir_ship', nation: 'iran', position: { lat: 27, lng: 52.2 } })])
+    isolateIntel(state)
+    state.intel!.assets.kh11.lastCollectionTick = -14400
+    taskSatellitePass(state, 'kh11', TARGET, 70)
+    const rng = new SeededRNG(1)
+    runIntel(state, rng, 60)
+
+    const failed = eventsOf(state, 'SATELLITE_PASS_FAILED')
+    expect(failed).toHaveLength(1)
+    expect(failed[0]).toMatchObject({ assetId: 'kh11', cloudPct: 70 })
+    expect(eventsOf(state, 'SATELLITE_PASS_COMPLETE')).toHaveLength(0)
+    expect(state.intel!.products).toHaveLength(0)
+    expect(contact(state, 'usa', 'ir_ship')).toBeUndefined()
+    expect(state.intel!.assets.kh11.lastCollectionTick).toBe(60 - 7200) // clock set back by half the revisit
+    expect(state.intel!.taskings).toHaveLength(0)
+
+    // Retry resolves a half-revisit later instead of a full one
+    taskSatellitePass(state, 'kh11', TARGET, 5)
+    runIntel(state, rng, 7200)
+    expect(eventsOf(state, 'SATELLITE_PASS_COMPLETE')).toHaveLength(0)
+    runIntel(state, rng, 7260)
+    expect(eventsOf(state, 'SATELLITE_PASS_COMPLETE')).toHaveLength(1)
+  })
+
+  it('kh11 (NIIRS 8) reveals decoys in the swath; commercial (NIIRS 5) does not', () => {
+    const build = () => [
+      makeUnit({ id: 'ir_tel', nation: 'iran', category: 'missile_battery', position: { lat: 27, lng: 52 } }),
+      makeUnit({ id: 'ir_decoy', nation: 'iran', category: 'missile_battery', position: { lat: 27, lng: 52.1 }, isDecoy: true }),
+    ]
+
+    const khState = makeState(build())
+    isolateIntel(khState)
+    khState.intel!.assets.kh11.lastCollectionTick = -14400
+    taskSatellitePass(khState, 'kh11', TARGET, 10)
+    runIntel(khState, new SeededRNG(1), 60)
+
+    expect(khState.units.get('ir_decoy')!.decoyRevealed).toBe(true)
+    expect(eventsOf(khState, 'DECOY_REVEALED')).toHaveLength(1)
+    expect(eventsOf(khState, 'SATELLITE_PASS_COMPLETE')[0].revealedDecoys).toBe(1)
+    expect(khState.intel!.products[0].caption).toContain('assessed DECOY')
+
+    const comState = makeState(build())
+    isolateIntel(comState)
+    comState.intel!.assets.commercial.lastCollectionTick = -5400
+    taskSatellitePass(comState, 'commercial', TARGET, 10)
+    runIntel(comState, new SeededRNG(1), 60)
+
+    expect(comState.units.get('ir_decoy')!.decoyRevealed).toBeFalsy()
+    expect(eventsOf(comState, 'DECOY_REVEALED')).toHaveLength(0)
+    expect(eventsOf(comState, 'SATELLITE_PASS_COMPLETE')[0].revealedDecoys).toBe(0)
+    // The decoy still shows up as a normal contact — indistinguishable at this quality
+    expect(contact(comState, 'usa', 'ir_decoy')?.level).toBe('tracked')
+    expect(comState.intel!.products[0].classification).toBe('UNCLASSIFIED//COMMERCIAL')
+  })
+})
+
+// ── SIGINT (design §1.3) ────────────────────────────────────────
+
+describe('SIGINT intercepts', () => {
+  it('rc135 produces intercepts on cadence and each raises paranoia by 2', () => {
+    const state = makeState([])
+    isolateIntel(state, { sigint: true })
+    const rng = new SeededRNG(7)
+
+    runIntel(state, rng, 60)
+    expect(eventsOf(state, 'INTERCEPT_DECRYPTED')).toHaveLength(1)
+    expect(eventsOf(state, 'INTERCEPT_DECRYPTED')[0].precedence).toBe('ROUTINE')
+    expect(state.intel!.paranoia).toBe(12)
+    expect(state.intel!.products[0]).toMatchObject({ kind: 'sigint', classification: 'TOP SECRET//SI' })
+
+    runIntel(state, rng, 120)
+    runIntel(state, rng, 1200) // 1140 ticks since last — interval is 1200 at sigint_pct 50
+    expect(eventsOf(state, 'INTERCEPT_DECRYPTED')).toHaveLength(1)
+
+    runIntel(state, rng, 1260)
+    expect(eventsOf(state, 'INTERCEPT_DECRYPTED')).toHaveLength(2)
+    expect(state.intel!.paranoia).toBe(14)
+  })
+
+  it('produces no intercepts when rc135 is lost', () => {
+    const state = makeState([])
+    isolateIntel(state)
+    runIntel(state, new SeededRNG(7), 60)
+    expect(eventsOf(state, 'INTERCEPT_DECRYPTED')).toHaveLength(0)
+  })
+
+  it('reveals a hidden emitter at detected with an IMMEDIATE intercept', () => {
+    const tel = makeUnit({ id: 'ir_tel', nation: 'iran', category: 'missile_battery', position: { lat: 29, lng: 53.2 } })
+    const state = makeState([tel])
+    isolateIntel(state, { sigint: true })
+    runIntel(state, new SeededRNG(7), 60)
+
+    const intercepts = eventsOf(state, 'INTERCEPT_DECRYPTED')
+    expect(intercepts).toHaveLength(1)
+    expect(intercepts[0].precedence).toBe('IMMEDIATE')
+    expect(intercepts[0].aboutUnitId).toBe('ir_tel')
+    expect(intercepts[0].text).toContain('missile unit')
+    expect(contact(state, 'usa', 'ir_tel')?.level).toBe('detected')
+  })
+
+  it('reports failing Iranian war support at PRIORITY when below 45', () => {
+    const state = makeState([makeUnit({ id: 'ir_ship', nation: 'iran' })]) // no hidden emitters
+    isolateIntel(state, { sigint: true })
+    state.warStatus = { usa: { warSupport: 90 }, iran: { warSupport: 40 } }
+    runIntel(state, new SeededRNG(7), 60)
+
+    const intercepts = eventsOf(state, 'INTERCEPT_DECRYPTED')
+    expect(intercepts[0].precedence).toBe('PRIORITY')
+    expect(intercepts[0].text).toContain('cohesion failing')
+  })
+
+  it('paranoia >= 70 at war triggers an encryption upgrade that silences intercepts for 6h', () => {
+    const state = makeState([])
+    isolateIntel(state, { sigint: true })
+    state.intel!.paranoia = 70
+    for (const a of Object.values(state.intel!.agents)) a.status = 'exfiltrated' // keep sweeps out of this test
+    const rng = new SeededRNG(3)
+
+    runIntel(state, rng, 60)
+    const upgrades = eventsOf(state, 'ENCRYPTION_UPGRADED')
+    expect(upgrades).toHaveLength(1)
+    expect(upgrades[0].untilTick).toBe(60 + 6 * 3600)
+    expect(state.intel!.paranoia).toBe(40)
+    expect(eventsOf(state, 'INTERCEPT_DECRYPTED')).toHaveLength(1) // the one that tipped it over
+
+    // Blackout: cadence elapses with nothing heard
+    runIntel(state, rng, 1260)
+    runIntel(state, rng, 12000)
+    expect(eventsOf(state, 'INTERCEPT_DECRYPTED')).toHaveLength(1)
+
+    // Window expires → collection resumes
+    runIntel(state, rng, 21660)
+    expect(eventsOf(state, 'INTERCEPT_DECRYPTED')).toHaveLength(2)
+    expect(eventsOf(state, 'ENCRYPTION_UPGRADED')).toHaveLength(1) // paranoia reset to 40 — no re-roll
+  })
+
+  it('does not upgrade encryption at peace, no matter the paranoia', () => {
+    const state = makeState([], { atWar: false })
+    isolateIntel(state, { sigint: true })
+    state.intel!.paranoia = 90
+    for (const a of Object.values(state.intel!.agents)) a.status = 'exfiltrated'
+    runIntel(state, new SeededRNG(3), 60)
+    expect(eventsOf(state, 'ENCRYPTION_UPGRADED')).toHaveLength(0)
+    expect(eventsOf(state, 'INTERCEPT_DECRYPTED')).toHaveLength(1)
+  })
+
+  it('SBIRS pushes a FLASH OPIR card for Iranian launches on the launch tick', () => {
+    const tel = makeUnit({ id: 'ir_tel', nation: 'iran', category: 'missile_battery', position: { lat: 29, lng: 53 } })
+    const state = makeState([tel])
+    isolateIntel(state)
+    state.time.tick = 61
+    state.events.push({ type: 'MISSILE_LAUNCHED', missileId: 'm_1', launcherId: 'ir_tel', targetId: 'us_x', weaponName: 'Fateh-110', tick: 61 })
+    processIntel(state, new SeededRNG(1), null) // non-minute tick — OPIR rides every tick
+
+    expect(state.intel!.products).toHaveLength(1)
+    expect(state.intel!.products[0]).toMatchObject({ kind: 'sigint', precedence: 'FLASH' })
+    expect(state.intel!.products[0].caption).toContain('OPIR LAUNCH DETECTION')
+    expect(state.intel!.products[0].caption).toContain('Fateh-110')
+
+    state.time.tick = 62 // stale event — no duplicate card
+    processIntel(state, new SeededRNG(1), null)
+    expect(state.intel!.products).toHaveLength(1)
+  })
+})
+
+// ── HUMINT (design §1.4) ────────────────────────────────────────
+
+describe('HUMINT', () => {
+  it('taskAgent reports, raises exposure, and respects the 1h cooldown', () => {
+    const state = makeState([])
+    isolateIntel(state)
+    const rng = new SeededRNG(1)
+    const saffron = state.intel!.agents.saffron
+
+    state.time.tick = 60
+    taskAgent(state, rng, 'saffron')
+    expect(eventsOf(state, 'AGENT_REPORT')).toHaveLength(1)
+    expect(eventsOf(state, 'AGENT_REPORT')[0].codename).toBe('SAFFRON')
+    expect(saffron.exposure).toBe(32) // 15 + 15 + paranoia(10)/5
+    expect(state.intel!.paranoia).toBe(11)
+    expect(state.intel!.products[0]).toMatchObject({ kind: 'humint', agentId: 'saffron', classification: 'SECRET//HCS' })
+
+    state.time.tick = 120
+    taskAgent(state, rng, 'saffron') // inside the 1 game-hour cooldown
+    expect(eventsOf(state, 'AGENT_REPORT')).toHaveLength(1)
+    expect(saffron.exposure).toBe(32)
+
+    state.time.tick = 60 + 3600
+    taskAgent(state, rng, 'saffron')
+    expect(eventsOf(state, 'AGENT_REPORT')).toHaveLength(2)
+  })
+
+  it('opal identifies up to 2 hidden missile batteries and flags decoys', () => {
+    const decoy = makeUnit({ id: 'ir_decoy', nation: 'iran', category: 'missile_battery', position: { lat: 29, lng: 53 }, isDecoy: true })
+    const tracked = makeUnit({ id: 'ir_known', nation: 'iran', category: 'missile_battery', position: { lat: 29.2, lng: 53 } })
+    const hidden1 = makeUnit({ id: 'ir_h1', nation: 'iran', category: 'missile_battery', position: { lat: 29.4, lng: 53 } })
+    const hidden2 = makeUnit({ id: 'ir_h2', nation: 'iran', category: 'missile_battery', position: { lat: 29.6, lng: 53 } })
+    const hidden3 = makeUnit({ id: 'ir_h3', nation: 'iran', category: 'missile_battery', position: { lat: 29.8, lng: 53 } })
+    const state = makeState([decoy, tracked, hidden1, hidden2, hidden3])
+    isolateIntel(state)
+    revealContact(state, 'usa', tracked, 'tracked')
+
+    taskAgent(state, new SeededRNG(1), 'opal')
+
+    expect(contact(state, 'usa', 'ir_h1')?.level).toBe('identified')
+    expect(contact(state, 'usa', 'ir_h2')?.level).toBe('identified')
+    expect(contact(state, 'usa', 'ir_h3')).toBeUndefined() // capped at 2 per tasking
+    expect(contact(state, 'usa', 'ir_known')?.level).toBe('tracked') // already held — skipped
+
+    expect(state.units.get('ir_decoy')!.decoyRevealed).toBe(true)
+    expect(eventsOf(state, 'DECOY_REVEALED')).toHaveLength(1)
+    const report = eventsOf(state, 'AGENT_REPORT')[0]
+    expect(report.text).toContain('2 launcher group(s)')
+    expect(report.text).toContain('Flags 1 site(s) as inflatable decoys')
+  })
+
+  it('saffron reads out the exact Iranian war support', () => {
+    const state = makeState([])
+    isolateIntel(state)
+    state.warStatus = { usa: { warSupport: 90 }, iran: { warSupport: 62 } }
+    taskAgent(state, new SeededRNG(1), 'saffron')
+    expect(eventsOf(state, 'AGENT_REPORT')[0].text).toContain('war support at 62%')
+  })
+
+  it('amber reveals ships in the Bandar Abbas–Jask box at tracked', () => {
+    const inBox = makeUnit({ id: 'ir_port', nation: 'iran', position: { lat: 26.5, lng: 56.2 } })
+    const outside = makeUnit({ id: 'ir_west', nation: 'iran', position: { lat: 27, lng: 52 } })
+    const state = makeState([inBox, outside])
+    isolateIntel(state)
+    taskAgent(state, new SeededRNG(1), 'amber')
+
+    expect(contact(state, 'usa', 'ir_port')?.level).toBe('tracked')
+    expect(contact(state, 'usa', 'ir_west')).toBeUndefined()
+    expect(eventsOf(state, 'AGENT_REPORT')[0].text).toContain('hulls active')
+  })
+
+  it('active coastal sources passively refresh their box every 30 game-min', () => {
+    const transiting = makeUnit({ id: 'ir_dhow', nation: 'iran', position: { lat: 26.5, lng: 56.5 } })
+    const state = makeState([transiting])
+    isolateIntel(state)
+    const rng = new SeededRNG(1)
+
+    runIntel(state, rng, 60)
+    expect(contact(state, 'usa', 'ir_dhow')).toBeUndefined()
+    runIntel(state, rng, 1800)
+    expect(contact(state, 'usa', 'ir_dhow')?.level).toBe('detected')
+  })
+
+  it('restAgent decays exposure by 1 per game-hour', () => {
+    const state = makeState([])
+    isolateIntel(state)
+    const rng = new SeededRNG(1)
+    const amber = state.intel!.agents.amber
+    amber.exposure = 40
+
+    restAgent(state, 'amber')
+    expect(amber.status).toBe('resting')
+
+    runIntel(state, rng, 60) // not an hour boundary
+    expect(amber.exposure).toBe(40)
+    runIntel(state, rng, 3600)
+    expect(amber.exposure).toBe(39)
+    runIntel(state, rng, 7200)
+    expect(amber.exposure).toBe(38)
+  })
+
+  it('exfiltrateAgent completes after 6 game-hours and removes the agent from play', () => {
+    const state = makeState([])
+    isolateIntel(state)
+    const rng = new SeededRNG(1)
+    const garnet = state.intel!.agents.garnet
+
+    state.time.tick = 60
+    exfiltrateAgent(state, 'garnet')
+    expect(garnet.status).toBe('exfiltrating')
+    expect(garnet.exfilCompleteTick).toBe(60 + 6 * 3600)
+
+    taskAgent(state, rng, 'garnet') // en route — no products
+    expect(eventsOf(state, 'AGENT_REPORT')).toHaveLength(0)
+
+    runIntel(state, rng, 21600)
+    expect(garnet.status).toBe('exfiltrating')
+    runIntel(state, rng, 21660)
+    expect(garnet.status).toBe('exfiltrated')
+    expect(eventsOf(state, 'AGENT_EXFILTRATED')).toHaveLength(1)
+    expect(eventsOf(state, 'AGENT_EXFILTRATED')[0].codename).toBe('GARNET')
+
+    taskAgent(state, rng, 'garnet') // gone for good
+    expect(eventsOf(state, 'AGENT_REPORT')).toHaveLength(0)
+  })
+})
+
+// ── Spy sweeps (design §1.4/§1.5) ───────────────────────────────
+
+describe('spy sweeps', () => {
+  function sweepScenario(seed: number) {
+    const state = makeState([], { atWar: false })
+    isolateIntel(state)
+    state.intel!.paranoia = 60
+    state.warStatus = { usa: { warSupport: 80 }, iran: { warSupport: 80 } }
+    for (const a of Object.values(state.intel!.agents)) a.exposure = 90
+    const rng = new SeededRNG(seed)
+    runIntel(state, rng, 60)
+    return { state, rng }
+  }
+
+  it('arrests exposed agents at paranoia >= 50, raising leakLevel and shifting war support', () => {
+    let hit: { state: GameState; rng: SeededRNG } | null = null
+    for (let seed = 1; seed <= 30 && !hit; seed++) {
+      const run = sweepScenario(seed)
+      if (run.state.events.some(e => e.type === 'AGENT_ARRESTED')) hit = run
+    }
+    expect(hit).not.toBeNull()
+    const { state } = hit!
+
+    const arrests = eventsOf(state, 'AGENT_ARRESTED')
+    expect(eventsOf(state, 'SPY_SWEEP')[0].arrests).toBe(arrests.length)
+    for (const e of arrests) {
+      expect(state.intel!.agents[e.agentId].status).toBe('arrested')
+    }
+    expect(state.intel!.leakLevel).toBe(25 + 10 * arrests.length)
+    expect(state.warStatus!.usa.warSupport).toBe(80 - 3 * arrests.length)
+    expect(state.warStatus!.iran.warSupport).toBe(80 + 2 * arrests.length)
+  })
+
+  it('arrested agents never report again and are not swept twice', () => {
+    let hit: { state: GameState; rng: SeededRNG } | null = null
+    for (let seed = 1; seed <= 30 && !hit; seed++) {
+      const run = sweepScenario(seed)
+      if (run.state.events.some(e => e.type === 'AGENT_ARRESTED')) hit = run
+    }
+    const { state, rng } = hit!
+    const arrestedId = eventsOf(state, 'AGENT_ARRESTED')[0].agentId
+
+    state.time.tick = 120
+    taskAgent(state, rng, arrestedId)
+    expect(eventsOf(state, 'AGENT_REPORT')).toHaveLength(0)
+    expect(state.intel!.agents[arrestedId].status).toBe('arrested')
+
+    runIntel(state, rng, 60 + 4 * 3600) // next sweep cycle
+    expect(eventsOf(state, 'SPY_SWEEP')).toHaveLength(2)
+    expect(eventsOf(state, 'AGENT_ARRESTED').filter(e => e.agentId === arrestedId)).toHaveLength(1)
+  })
+
+  it('does not sweep below the paranoia threshold', () => {
+    const state = makeState([], { atWar: false })
+    isolateIntel(state)
+    state.intel!.paranoia = 49
+    for (const a of Object.values(state.intel!.agents)) a.exposure = 100
+    runIntel(state, new SeededRNG(1), 60)
+    expect(eventsOf(state, 'SPY_SWEEP')).toHaveLength(0)
+    expect(eventsOf(state, 'AGENT_ARRESTED')).toHaveLength(0)
+  })
+})
+
+// ── Counterespionage (design §1.5) ──────────────────────────────
+
+describe('counterespionage', () => {
+  function leakScenario(seed: number, leakLevel: number) {
+    const tel = makeUnit({
+      id: 'ir_tel', nation: 'iran', category: 'missile_battery',
+      position: { lat: 29, lng: 53 }, maxSpeed_kts: 30,
+    })
+    const state = makeState([tel])
+    state.intel!.leakLevel = leakLevel
+    revealContact(state, 'usa', tel, 'identified')
+    const before = { ...tel.position }
+    const leaked = maybeLeakStrike(state, new SeededRNG(seed), 'ir_tel')
+    return { state, tel, before, leaked }
+  }
+
+  it('never leaks below leakLevel 60', () => {
+    for (let seed = 1; seed <= 20; seed++) {
+      const { state, leaked, tel, before } = leakScenario(seed, 59)
+      expect(leaked).toBe(false)
+      expect(eventsOf(state, 'STRIKE_LEAKED')).toHaveLength(0)
+      expect(tel.position).toEqual(before)
+    }
+  })
+
+  it('at high leak a compromised strike scoots the mobile target ~15 km and degrades the contact', () => {
+    let hit: ReturnType<typeof leakScenario> | null = null
+    for (let seed = 1; seed <= 40 && !hit; seed++) {
+      const run = leakScenario(seed, 90)
+      if (run.leaked) hit = run
+    }
+    expect(hit).not.toBeNull()
+    const { state, tel, before } = hit!
+
+    expect(eventsOf(state, 'STRIKE_LEAKED')).toHaveLength(1)
+    expect(eventsOf(state, 'STRIKE_LEAKED')[0].targetId).toBe('ir_tel')
+    expect(haversine(before, tel.position)).toBeGreaterThan(14)
+    expect(haversine(before, tel.position)).toBeLessThan(16)
+    expect(contact(state, 'usa', 'ir_tel')?.level).toBe('detected')
+    expect(state.intel!.paranoia).toBe(12)
+  })
+
+  it('leakLevel drifts up while the carrier sits in the Hormuz approaches', () => {
+    const carrier = makeUnit({ id: 'cvn', nation: 'usa', category: 'carrier_group', position: { lat: 26, lng: 56 } })
+    const state = makeState([carrier])
+    isolateIntel(state)
+    const rng = new SeededRNG(1)
+
+    runIntel(state, rng, 3600)
+    expect(state.intel!.leakLevel).toBe(26)
+
+    carrier.position = { lat: 26, lng: 50 } // out of the box — slow decay every 2h
+    runIntel(state, rng, 7200)
+    expect(state.intel!.leakLevel).toBe(25)
+  })
+
+  it('opsecSweep cuts leakLevel by 25 (floor 10) on a 6h cooldown', () => {
+    const state = makeState([])
+    state.intel!.leakLevel = 60
+
+    state.time.tick = 60
+    opsecSweep(state)
+    expect(state.intel!.leakLevel).toBe(35)
+    expect(eventsOf(state, 'OPSEC_SWEEP_COMPLETE')[0].newLeakLevel).toBe(35)
+
+    state.time.tick = 120
+    opsecSweep(state) // on cooldown
+    expect(state.intel!.leakLevel).toBe(35)
+    expect(eventsOf(state, 'OPSEC_SWEEP_COMPLETE')).toHaveLength(1)
+
+    state.time.tick = 60 + 6 * 3600
+    opsecSweep(state)
+    expect(state.intel!.leakLevel).toBe(10) // 35 - 25, clamped at the floor
+    expect(eventsOf(state, 'OPSEC_SWEEP_COMPLETE')).toHaveLength(2)
+  })
+
+  it("Iran's coarse carrier picture: detected from picket boats, tracked with Mohajer-10, EMCON does not hide it", () => {
+    const build = () => makeUnit({ id: 'cvn', nation: 'usa', category: 'carrier_group', position: { lat: 26, lng: 56 }, emcon: true })
+
+    const picketState = makeState([build()])
+    isolateIntel(picketState)
+    picketState.intel!.assets.mohajer10.status = 'lost'
+    runIntel(picketState, new SeededRNG(1), 1800)
+    expect(contact(picketState, 'iran', 'cvn')?.level).toBe('detected') // EMCON irrelevant to port spotters
+
+    const droneState = makeState([build()])
+    isolateIntel(droneState)
+    runIntel(droneState, new SeededRNG(1), 1800)
+    expect(contact(droneState, 'iran', 'cvn')?.level).toBe('tracked')
+  })
+})
+
+// ── Wide-area sensors (design §1.1) ─────────────────────────────
+
+describe('wide-area sensors', () => {
+  it('Triton refreshes maritime contacts in the Gulf box at detected, ignoring land units', () => {
+    const ship = makeUnit({ id: 'ir_ship', nation: 'iran', position: { lat: 27, lng: 52 } })
+    const tel = makeUnit({ id: 'ir_tel', nation: 'iran', category: 'missile_battery', position: { lat: 27, lng: 52 } })
+    const state = makeState([ship, tel])
+    isolateIntel(state, { triton: true })
+    const rng = new SeededRNG(1)
+
+    runIntel(state, rng, 60)
+    expect(contact(state, 'usa', 'ir_ship')).toBeUndefined() // 30-min revisit not yet elapsed
+
+    runIntel(state, rng, 1800)
+    expect(contact(state, 'usa', 'ir_ship')?.level).toBe('detected')
+    expect(contact(state, 'usa', 'ir_tel')).toBeUndefined()
+  })
+})
+
+// ── Decoys (design §1.7) ────────────────────────────────────────
+
+describe('decoys', () => {
+  const decoyUnits = (state: GameState) => Array.from(state.units.values()).filter(u => u.isDecoy)
+
+  it('spawns 4 decoys near real batteries when Iran is at war, exactly once', () => {
+    const batteries = [
+      makeUnit({ id: 'tel1', nation: 'iran', category: 'missile_battery', position: { lat: 29, lng: 53 } }),
+      makeUnit({ id: 'tel2', nation: 'iran', category: 'missile_battery', position: { lat: 30, lng: 54 } }),
+      makeUnit({ id: 'tel3', nation: 'iran', category: 'missile_battery', position: { lat: 28.5, lng: 52.5 } }),
+    ]
+    const state = makeState([...batteries, makeUnit({ id: 'us1', nation: 'usa' })])
+    isolateIntel(state, { decoys: true })
+    const rng = new SeededRNG(11)
+
+    runIntel(state, rng, 60)
+    const decoys = decoyUnits(state)
+    expect(decoys).toHaveLength(4)
+    expect(state.intel!.decoysSpawned).toBe(true)
+    for (const d of decoys) {
+      expect(d.category).toBe('missile_battery')
+      expect(d.name).toBe('Missile TEL group')
+      expect(d.health).toBe(40)
+      expect(d.weapons).toHaveLength(0)
+      const nearest = Math.min(...batteries.map(b => haversine(b.position, d.position)))
+      expect(nearest).toBeLessThanOrEqual(15.1)
+    }
+
+    runIntel(state, rng, 120)
+    expect(decoyUnits(state)).toHaveLength(4)
+
+    for (const d of decoyUnits(state)) d.status = 'destroyed'
+    runIntel(state, rng, 180)
+    expect(decoyUnits(state)).toHaveLength(4) // dead inflatables are not replaced
+  })
+
+  it('does not spawn at peace, then spawns when the war starts', () => {
+    const state = makeState(
+      [makeUnit({ id: 'tel1', nation: 'iran', category: 'missile_battery', position: { lat: 29, lng: 53 } })],
+      { atWar: false },
+    )
+    isolateIntel(state, { decoys: true })
+    const rng = new SeededRNG(11)
+
+    runIntel(state, rng, 60)
+    expect(decoyUnits(state)).toHaveLength(0)
+    expect(state.intel!.decoysSpawned).toBeFalsy()
+
+    state.nations.iran.atWar = ['usa']
+    runIntel(state, rng, 120)
+    expect(decoyUnits(state)).toHaveLength(4)
+  })
+})
+
+// ── EMCON (design §1.6) ─────────────────────────────────────────
+
+describe('EMCON', () => {
+  it('an EMCON unit contributes no radar contacts to its own picture', () => {
+    const usShip = makeUnit({ id: 'us_ship', nation: 'usa', sensors: [radar(100)], emcon: true })
+    const irShip = makeUnit({ id: 'ir_ship', nation: 'iran', position: { lat: 27, lng: 52.5 } }) // ~50 km
+    const state = makeState([usShip, irShip], { tick: 60 })
+
+    processVisibility(state, null, null, null)
+    expect(contact(state, 'usa', 'ir_ship')).toBeUndefined()
+
+    usShip.emcon = false
+    state.time.tick = 120
+    processVisibility(state, null, null, null)
+    expect(contact(state, 'usa', 'ir_ship')?.level).toBe('identified')
+  })
+
+  it('an EMCON emitter is not ELINT-detectable', () => {
+    const espionage: EspionageResult = {
+      humintRevealed: new Map(),
+      sigintMultiplier: new Map([['usa', 2.0], ['iran', 1.5]]),
+    }
+    const build = (emcon: boolean) => [
+      makeUnit({ id: 'us_ew', nation: 'usa', sensors: [radar(50)] }),
+      makeUnit({ id: 'ir_sam', nation: 'iran', category: 'sam_site', position: { lat: 27, lng: 53.75 }, sensors: [radar(100)], emcon }), // ~173 km
+    ]
+
+    const radiating = makeState(build(false), { tick: 60 })
+    processVisibility(radiating, null, espionage, null)
+    expect(contact(radiating, 'usa', 'ir_sam')?.level).toBe('detected') // 100 × 2.0 = 200 km >= 173
+
+    const silent = makeState(build(true), { tick: 60 })
+    processVisibility(silent, null, espionage, null)
+    expect(contact(silent, 'usa', 'ir_sam')).toBeUndefined()
+  })
+
+  it('radarSeesUnit returns unseen for an EMCON radar (fire-control own-track lost)', () => {
+    const usShip = makeUnit({ id: 'us_ship', nation: 'usa', sensors: [radar(100)], emcon: true })
+    const irShip = makeUnit({ id: 'ir_ship', nation: 'iran', position: { lat: 27, lng: 52.2 } }) // ~20 km
+    expect(radarSeesUnit(usShip, irShip, null)).toBe('unseen')
+    usShip.emcon = false
+    expect(radarSeesUnit(usShip, irShip, null)).toBe('identified')
+  })
+
+  it('detectThreats returns no threats for an EMCON air-defense unit', () => {
+    const adUnit = makeUnit({ id: 'us_ad', nation: 'usa', sensors: [radar(100)] })
+    const state = makeState([adUnit])
+    const missile: Missile = {
+      id: 'm_t', weaponId: 'test_wpn', launcherId: 'ir_x', targetId: 'us_ad', nation: 'iran',
+      path: [[52.1, 27], [52.3, 27]], timestamps: [900_000, 1_100_000], status: 'inflight',
+      launchTime: 900_000, eta: 1_100_000, altitude_m: 50, phase: 'cruise',
+      speed_current_mach: 0.8, fuel_remaining_sec: 600, is_interceptor: false,
+    }
+    state.missiles.set(missile.id, missile)
+
+    expect(detectThreats(state, adUnit, null)).toHaveLength(1)
+    adUnit.emcon = true
+    expect(detectThreats(state, adUnit, null)).toHaveLength(0)
+  })
+})
+
+// ── War-support decoy exception (design §1.7) ───────────────────
+
+describe('war-support decoy exception', () => {
+  function destroyUnit(state: GameState, unitId: string): void {
+    const unit = state.units.get(unitId)!
+    unit.status = 'destroyed'
+    const event: GameEvent = { type: 'UNIT_DESTROYED', unitId, tick: state.time.tick }
+    state.events.push(event)
+    state.pendingEvents.push(event)
+  }
+
+  function evalAt(state: GameState, tick: number): void {
+    state.time.tick = tick
+    processWarSupport(state)
+  }
+
+  it('destroying a decoy does not drain Iran and instead hands it +1 support', () => {
+    const state = makeState([
+      makeUnit({ id: 'us1', nation: 'usa' }),
+      makeUnit({ id: 'decoy', nation: 'iran', category: 'missile_battery', isDecoy: true }),
+      makeUnit({ id: 'real_tel', nation: 'iran', category: 'missile_battery' }),
+    ])
+    evalAt(state, 0)
+    state.warStatus!.iran.warSupport = 80
+    state.warStatus!.usa.warSupport = 90
+
+    destroyUnit(state, 'decoy')
+    evalAt(state, 60)
+    let support = getWarSupport(state)
+    expect(support.iran).toBeCloseTo(81, 1) // +1 propaganda bump, no 1.5 battery drain
+    expect(support.usa).toBeLessThan(90.05) // no kill gain for shooting an inflatable
+
+    destroyUnit(state, 'real_tel')
+    evalAt(state, 120)
+    support = getWarSupport(state)
+    expect(support.iran).toBeLessThan(79.6) // the real battery drains normally
+    expect(support.usa).toBeGreaterThan(90.4) // and pays out the kill gain
+  })
+})
+
+// ── Save/load round-trip ────────────────────────────────────────
+
+describe('save/load', () => {
+  function makeNation(id: NationId, name: string): Nation {
+    return {
+      id,
+      name,
+      economy: { gdp_billions: 1000, military_budget_billions: 100, military_budget_pct_gdp: 3, oil_revenue_billions: 0, sanctions_impact: 0, war_cost_per_day_millions: 0, reserves_billions: 100 },
+      relations: { usa: 0, iran: 0 },
+      atWar: [],
+    }
+  }
+
+  it('state.intel survives a JSON round-trip with taskings, agents and meters intact', () => {
+    const engine = new GameEngine()
+    engine.initFromData(
+      'usa',
+      { usa: makeNation('usa', 'USA'), iran: makeNation('iran', 'Iran') },
+      [
+        makeUnit({ id: 'us_ship', nation: 'usa' }),
+        makeUnit({ id: 'ir_base', nation: 'iran', category: 'airbase', position: { lat: 27.6, lng: 52.3 } }),
+      ],
+      [],
+      {},
+    )
+    engine.executeCommand({ type: 'TASK_SATELLITE_PASS', assetId: 'kh11', target: { lat: 27.5, lng: 52.5 }, cloudPct: 12 })
+    engine.executeCommand({ type: 'TASK_AGENT', agentId: 'saffron' })
+    engine.executeCommand({ type: 'SET_EMCON', unitId: 'us_ship', emcon: true })
+    const intel = engine.state.intel!
+    intel.paranoia = 57
+    intel.leakLevel = 64
+    intel.agents.amber.status = 'arrested'
+    intel.encryptionUpgradedUntilTick = 4242
+
+    const loaded = new GameEngine()
+    loaded.loadState(engine.getFullStateJson())
+
+    expect(loaded.state.intel).toEqual(engine.state.intel)
+    expect(loaded.state.intel!.taskings).toHaveLength(1)
+    expect(loaded.state.intel!.taskings[0]).toMatchObject({ assetId: 'kh11', cloudPct: 12 })
+    expect(loaded.state.intel!.agents.amber.status).toBe('arrested')
+    expect(loaded.state.intel!.products.length).toBeGreaterThan(0)
+    expect(loaded.state.units.get('us_ship')!.emcon).toBe(true)
+  })
+})
+
+// ── Snapshot helper ─────────────────────────────────────────────
+
+describe('paranoiaBand', () => {
+  it('maps paranoia to the fuzzy display bands', () => {
+    expect(paranoiaBand(0)).toBe('LOW')
+    expect(paranoiaBand(29)).toBe('LOW')
+    expect(paranoiaBand(30)).toBe('ELEVATED')
+    expect(paranoiaBand(54)).toBe('ELEVATED')
+    expect(paranoiaBand(55)).toBe('HIGH')
+    expect(paranoiaBand(74)).toBe('HIGH')
+    expect(paranoiaBand(75)).toBe('SEVERE')
+    expect(paranoiaBand(100)).toBe('SEVERE')
+  })
+})
diff --git a/src/engine/systems/__tests__/missile-terrain.test.ts b/src/engine/systems/__tests__/missile-terrain.test.ts
new file mode 100644
index 0000000..97685f7
--- /dev/null
+++ b/src/engine/systems/__tests__/missile-terrain.test.ts
@@ -0,0 +1,239 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { processMovement } from '../movement'
+import { processCombat, launchMissile, resetCombatState } from '../combat'
+import { ElevationGrid } from '../elevation'
+import { SeededRNG } from '../../utils/rng'
+import { weaponSpecs } from '@/data/weapons/missiles'
+import type { GameState, Unit, Missile, NationId } from '@/types/game'
+
+/**
+ * Regression suite for "missiles crash into elevation" (player report 2026-06-11).
+ * Three real defects in the class:
+ *  1. Ballistic altitude profile dipped to ~0 at the boost/midcourse and
+ *     midcourse/terminal seams (parabola didn't match its endpoints) — rendered
+ *     as the missile smashing into the ground mid-flight and resurrecting.
+ *  2. Terminal dives ended at sea level, putting the last seconds underground
+ *     for targets on high plateaus.
+ *  3. Cruise terrain-following sampled only the current cell, so steep ridge
+ *     faces caused a multi-thousand-meter altitude teleport on arrival; and a
+ *     fuel-starved missile vanished with no feed event.
+ */
+
+function makeUnit(overrides: Partial<Unit> & { id: string; nation: NationId }): Unit {
+  return {
+    name: overrides.id,
+    category: 'airbase',
+    position: { lat: 25, lng: 51 },
+    heading: 0,
+    speed_kts: 0,
+    maxSpeed_kts: 0,
+    health: 100,
+    maxHealth: 100,
+    hardness: 200,
+    logistics: 0,
+    supplyStocks: [],
+    weapons: [],
+    pointDefense: [],
+    sensors: [],
+    roe: 'hold_fire',
+    status: 'ready',
+    waypoints: [],
+    subordinateIds: [],
+    ...overrides,
+  } as Unit
+}
+
+function makeState(units: Unit[], missiles: Missile[] = []): GameState {
+  return {
+    playerNation: 'usa',
+    initialized: true,
+    time: { tick: 1, timestamp: 1000, speed: 1, tickIntervalMs: 100 },
+    nations: {
+      usa: { id: 'usa', name: 'USA', economy: { gdp_billions: 28000, military_budget_billions: 886, military_budget_pct_gdp: 3.2, oil_revenue_billions: 0, sanctions_impact: 0, war_cost_per_day_millions: 0, reserves_billions: 800 }, relations: { usa: 100, iran: -60 }, atWar: ['iran'] },
+      iran: { id: 'iran', name: 'Iran', economy: { gdp_billions: 400, military_budget_billions: 25, military_budget_pct_gdp: 6.3, oil_revenue_billions: 50, sanctions_impact: 0.3, war_cost_per_day_millions: 0, reserves_billions: 120 }, relations: { usa: -60, iran: 100 }, atWar: ['usa'] },
+    },
+    units: new Map(units.map(u => [u.id, u])),
+    missiles: new Map(missiles.map(m => [m.id, m])),
+    supplyLines: new Map(),
+    shippingLanes: new Map(),
+    events: [],
+    pendingEvents: [],
+  }
+}
+
+function makeGrid(
+  latMin: number, latMax: number, lngMin: number, lngMax: number,
+  resolution: number, elevations: number[][],
+): ElevationGrid {
+  const rows = elevations.length
+  const cols = elevations[0].length
+  const buffer = new ArrayBuffer(20 + rows * cols * 4)
+  const header = new Float32Array(buffer, 0, 5)
+  header[0] = latMin
+  header[1] = latMax
+  header[2] = lngMin
+  header[3] = lngMax
+  header[4] = resolution
+  const data = new Float32Array(buffer, 20, rows * cols)
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) data[r * cols + c] = elevations[r][c]
+  }
+  return new ElevationGrid(buffer)
+}
+
+function tickWorld(state: GameState, grid: ElevationGrid | null, rng: SeededRNG): void {
+  state.time.tick++
+  state.time.timestamp += 1000
+  processMovement(state, grid)
+  processCombat(state, rng, grid, null)
+}
+
+beforeEach(() => {
+  resetCombatState()
+})
+
+describe('ballistic altitude profile', () => {
+  it('stays airborne through the whole arc — no ground dips at phase seams', () => {
+    const launcher = makeUnit({
+      id: 'ir_tel', nation: 'iran', category: 'missile_battery',
+      position: { lat: 28, lng: 52 },
+      weapons: [{ weaponId: 'fateh110', count: 2, maxCount: 2, reloadTimeSec: 0 }],
+    })
+    const target = makeUnit({ id: 'us_base', nation: 'usa', position: { lat: 26, lng: 52 } })
+    const state = makeState([launcher, target])
+    const rng = new SeededRNG(7)
+
+    launchMissile(state, 'ir_tel', 'fateh110', 'us_base')
+    const missile = Array.from(state.missiles.values())[0]
+    expect(missile).toBeDefined()
+
+    const flightMs = missile.eta - missile.launchTime
+    const totalTicks = Math.ceil(flightMs / 1000)
+    // Steepest legitimate segment is the boost ramp (0.5×peak over 15% of flight);
+    // the seam bug snapped 0.5×peak in a single tick
+    const expectedPeak = weaponSpecs['fateh110'].flight_altitude_ft * 0.3048
+    const maxTickDelta = (0.5 * expectedPeak) / (0.15 * totalTicks) * 2
+
+    let peakSeen = 0
+    let prevAlt = missile.altitude_m
+
+    for (let i = 0; i < totalTicks + 5; i++) {
+      tickWorld(state, null, rng)
+      const m = state.missiles.get(missile.id)
+      if (!m || m.status !== 'inflight') break
+
+      peakSeen = Math.max(peakSeen, m.altitude_m)
+      const progress = (state.time.timestamp - m.launchTime) / flightMs
+
+      // Mid-flight the missile must be high, never scraping the ground
+      if (progress > 0.2 && progress < 0.85) {
+        expect(m.altitude_m).toBeGreaterThan(expectedPeak * 0.2)
+      }
+      // No teleports: altitude moves smoothly between ticks
+      expect(Math.abs(m.altitude_m - prevAlt)).toBeLessThan(maxTickDelta)
+      prevAlt = m.altitude_m
+    }
+
+    expect(peakSeen).toBeGreaterThan(expectedPeak * 0.9)
+  })
+
+  it('terminal dive ends at the target plateau elevation, not sea level', () => {
+    // Target sits on an 1800 m plateau
+    const elevations = Array.from({ length: 8 }, () => Array(8).fill(1800))
+    const grid = makeGrid(22, 30, 48, 56, 1.0, elevations)
+
+    const launcher = makeUnit({
+      id: 'ir_tel', nation: 'iran', category: 'missile_battery',
+      position: { lat: 28, lng: 52 },
+      weapons: [{ weaponId: 'fateh110', count: 2, maxCount: 2, reloadTimeSec: 0 }],
+    })
+    const target = makeUnit({ id: 'us_base', nation: 'usa', position: { lat: 26, lng: 52 } })
+    const state = makeState([launcher, target])
+    const rng = new SeededRNG(7)
+
+    launchMissile(state, 'ir_tel', 'fateh110', 'us_base')
+    const missile = Array.from(state.missiles.values())[0]
+    const flightMs = missile.eta - missile.launchTime
+
+    for (let i = 0; i < Math.ceil(flightMs / 1000) + 5; i++) {
+      tickWorld(state, grid, rng)
+      const m = state.missiles.get(missile.id)
+      if (!m || m.status !== 'inflight') break
+
+      const progress = (state.time.timestamp - m.launchTime) / flightMs
+      // Late terminal: must stay at/above the plateau the target sits on
+      if (m.phase === 'terminal' && progress > 0.9) {
+        expect(m.altitude_m).toBeGreaterThanOrEqual(1700)
+      }
+    }
+  })
+})
+
+describe('cruise terrain following over steep ridges', () => {
+  it('climbs ahead of a 2500 m wall — no multi-km altitude teleport', () => {
+    // Sea level everywhere except a 2500 m ridge band ~28-50 km east of launch
+    const cols = 40
+    const elevations = Array.from({ length: 20 }, () =>
+      Array.from({ length: cols }, (_, c) => (c >= 14 && c <= 16 ? 2500 : 0)),
+    )
+    // 0.05° cells ≈ 5 km: ridge at lng 51.4-51.55
+    const grid = makeGrid(24, 25, 50.7, 52.7, 0.05, elevations)
+
+    const launcher = makeUnit({
+      id: 'us_ship', nation: 'usa', category: 'ship',
+      position: { lat: 24.5, lng: 50.75 },
+      weapons: [{ weaponId: 'tomahawk', count: 2, maxCount: 2, reloadTimeSec: 0 }],
+    })
+    const target = makeUnit({ id: 'ir_base', nation: 'iran', position: { lat: 24.5, lng: 52.6 } })
+    const state = makeState([launcher, target])
+    const rng = new SeededRNG(7)
+
+    launchMissile(state, 'us_ship', 'tomahawk', 'ir_base')
+    const missile = Array.from(state.missiles.values())[0]
+
+    let prevAlt = missile.altitude_m
+    let crossedRidge = false
+    for (let i = 0; i < 1200; i++) {
+      tickWorld(state, grid, rng)
+      const m = state.missiles.get(missile.id)
+      if (!m || m.status !== 'inflight') break
+
+      // Climb rate is capped at 150 m/s — anything bigger is the teleport bug
+      expect(m.altitude_m - prevAlt).toBeLessThanOrEqual(160)
+      prevAlt = m.altitude_m
+
+      const pos = m.path[m.path.length - 1]
+      const terrain = grid.getElevation(pos[1], pos[0])
+      if (terrain > 2000) {
+        crossedRidge = true
+        // Over the ridge the missile must actually clear it
+        expect(m.altitude_m).toBeGreaterThanOrEqual(terrain)
+      }
+    }
+
+    expect(crossedRidge).toBe(true)
+  })
+
+  it('a fuel-starved missile crashes loudly, not silently', () => {
+    const launcher = makeUnit({
+      id: 'us_ship', nation: 'usa', category: 'ship',
+      position: { lat: 24.5, lng: 51 },
+      weapons: [{ weaponId: 'tomahawk', count: 2, maxCount: 2, reloadTimeSec: 0 }],
+    })
+    const target = makeUnit({ id: 'ir_base', nation: 'iran', position: { lat: 24.5, lng: 60 } })
+    const state = makeState([launcher, target])
+    const rng = new SeededRNG(7)
+
+    launchMissile(state, 'us_ship', 'tomahawk', 'ir_base')
+    const missile = Array.from(state.missiles.values())[0]
+    missile.fuel_remaining_sec = 3 // starve it
+
+    for (let i = 0; i < 60 && state.missiles.has(missile.id); i++) {
+      tickWorld(state, null, rng)
+    }
+
+    expect(state.missiles.has(missile.id)).toBe(false)
+    const crash = state.events.find(e => e.type === 'MISSILE_CRASHED')
+    expect(crash).toBeDefined()
+  })
+})
diff --git a/src/engine/systems/__tests__/sensor-network.test.ts b/src/engine/systems/__tests__/sensor-network.test.ts
index 9afdd17..a72250c 100644
--- a/src/engine/systems/__tests__/sensor-network.test.ts
+++ b/src/engine/systems/__tests__/sensor-network.test.ts
@@ -229,6 +229,71 @@ describe('detectThreatsNetworked', () => {
   })
 })
 
+describe('localDetections stash', () => {
+  function makeDetectorState() {
+    const detector = makeUnit({
+      id: 'detector',
+      nation: 'usa',
+      position: { lat: 25, lng: 51 },
+      sensors: [{ type: 'radar', range_km: 100, detection_prob: 0.95 }],
+    })
+    const hub = makeUnit({
+      id: 'hub',
+      nation: 'usa',
+      position: { lat: 25, lng: 51.2 },
+      sensors: [{ type: 'radar', range_km: 1, detection_prob: 0.95 }],
+      datalink_range_km: 100,
+    })
+    const missile = makeMissile({ id: 'inbound' })
+    const state = makeState([detector, hub], [missile])
+    state.time.timestamp = 30_000 // mid-flight on the missile's [0, 60000] timestamps
+    return { state, detector, missile }
+  }
+
+  it('buildSensorNetwork stashes per-unit local detections; non-detecting units absent', () => {
+    const { state } = makeDetectorState()
+    const blind = makeUnit({
+      id: 'blind',
+      nation: 'usa',
+      position: { lat: 25, lng: 52 },
+      sensors: [{ type: 'radar', range_km: 1, detection_prob: 0.95 }],
+    })
+    state.units.set('blind', blind)
+
+    const network = buildSensorNetwork(state)
+
+    expect(network.localDetections.get('detector')).toHaveLength(1)
+    expect(network.localDetections.get('detector')![0].missile.id).toBe('inbound')
+    expect(network.localDetections.has('blind')).toBe(false)
+  })
+
+  it('detectThreatsNetworked consumes the stash and falls back to a fresh call when absent', () => {
+    const { state, detector } = makeDetectorState()
+    const network = buildSensorNetwork(state)
+
+    // Stashed own detection wins
+    expect(detectThreatsNetworked(state, detector, network)[0].networkQuality).toBe('own')
+
+    // Present-but-empty stash entry is trusted → only the hub-relayed track remains
+    network.localDetections.set('detector', [])
+    expect(detectThreatsNetworked(state, detector, network)[0].networkQuality).toBe('tracked')
+
+    // Absent entry → fresh detectThreats call restores the own-quality track
+    network.localDetections.delete('detector')
+    expect(detectThreatsNetworked(state, detector, network)[0].networkQuality).toBe('own')
+  })
+
+  it('drops stashed own detections whose missile resolved mid-tick', () => {
+    const { state, detector, missile } = makeDetectorState()
+    state.units.delete('hub') // no network paths — own detections only
+    const network = buildSensorNetwork(state)
+    expect(network.localDetections.get('detector')).toHaveLength(1)
+
+    missile.status = 'intercepted'
+    expect(detectThreatsNetworked(state, detector, network)).toHaveLength(0)
+  })
+})
+
 describe('ELINT detection', () => {
   it('detects enemy radar within 1.5x range', () => {
     // USA unit at 25,51 — Iran radar at 25.5,51.5 with 300km range
diff --git a/src/engine/systems/__tests__/strike-scheduler.test.ts b/src/engine/systems/__tests__/strike-scheduler.test.ts
new file mode 100644
index 0000000..fdb9d64
--- /dev/null
+++ b/src/engine/systems/__tests__/strike-scheduler.test.ts
@@ -0,0 +1,423 @@
+import { describe, it, expect, vi } from 'vitest'
+import { GameEngine } from '../../game-engine'
+import { GameLoop } from '../../game-loop'
+import { processScheduledLaunches, scheduleSalvo } from '../strike-scheduler'
+import { computeTotSchedule, TOT_RIPPLE_TICKS } from '../../attack-planner'
+import { haversine } from '../../utils/geo'
+import { weaponSpecs } from '@/data/weapons/missiles'
+import type { Nation, NationId, ScheduledLaunch, Unit } from '@/types/game'
+import type { PlannedStrike } from '@/types/attack-plan'
+
+// ── Scenario helpers ────────────────────────────────────────────
+
+function makeNation(id: NationId, name: string): Nation {
+  return {
+    id,
+    name,
+    economy: { gdp_billions: 1000, military_budget_billions: 100, military_budget_pct_gdp: 3, oil_revenue_billions: 0, sanctions_impact: 0, war_cost_per_day_millions: 0, reserves_billions: 100 },
+    relations: { usa: 0, iran: 0 },
+    atWar: [],
+  }
+}
+
+function makeUnit(overrides: Partial<Unit> & { id: string; nation: NationId; category: Unit['category'] }): Unit {
+  return {
+    name: overrides.id,
+    position: { lat: 26, lng: 52 },
+    heading: 0,
+    speed_kts: 0,
+    maxSpeed_kts: 0,
+    health: 100,
+    maxHealth: 100,
+    hardness: 200,
+    logistics: 0,
+    supplyStocks: [],
+    weapons: [],
+    pointDefense: [],
+    sensors: [],
+    roe: 'weapons_tight' as const,
+    status: 'ready' as const,
+    waypoints: [],
+    subordinateIds: [],
+    ...overrides,
+  } as Unit
+}
+
+function makeScenarioUnits(): Unit[] {
+  return [
+    makeUnit({
+      id: 'us_tlam', nation: 'usa', category: 'missile_battery',
+      weapons: [{ weaponId: 'tomahawk', count: 20, maxCount: 20, reloadTimeSec: 0 }],
+    }),
+    makeUnit({ id: 'ir_base', nation: 'iran', category: 'airbase', position: { lat: 27.6, lng: 52.3 } }),
+  ]
+}
+
+function initEngine(): GameEngine {
+  const engine = new GameEngine()
+  const nations = { usa: makeNation('usa', 'USA'), iran: makeNation('iran', 'Iran') }
+  engine.initFromData('usa', nations, makeScenarioUnits(), [], {})
+  return engine
+}
+
+function salvo(count: number, spacingTicks?: number) {
+  return { type: 'LAUNCH_SALVO', launcherId: 'us_tlam', weaponId: 'tomahawk', targetId: 'ir_base', count, spacingTicks } as const
+}
+
+function ammo(engine: GameEngine): number {
+  return engine.state.units.get('us_tlam')!.weapons[0].count
+}
+
+// ── Tests ───────────────────────────────────────────────────────
+
+describe('processScheduledLaunches', () => {
+  it('fires entries whose dueTick has arrived, keeps future ones, preserves order', () => {
+    const engine = initEngine()
+    const entry = (dueTick: number): ScheduledLaunch =>
+      ({ dueTick, launcherId: 'us_tlam', weaponId: 'tomahawk', targetId: 'ir_base' })
+    engine.state.time.tick = 5
+    engine.state.scheduledLaunches = [entry(3), entry(7), entry(5)]
+
+    const fired: number[] = []
+    processScheduledLaunches(engine.state, (e) => fired.push(e.dueTick))
+
+    expect(fired).toEqual([3, 5])
+    expect(engine.state.scheduledLaunches).toEqual([entry(7)])
+  })
+
+  it('no-ops when the queue is empty or absent', () => {
+    const engine = initEngine()
+    const launchFn = vi.fn()
+    processScheduledLaunches(engine.state, launchFn)
+    engine.state.scheduledLaunches = []
+    processScheduledLaunches(engine.state, launchFn)
+    expect(launchFn).not.toHaveBeenCalled()
+  })
+})
+
+describe('LAUNCH_SALVO spacingTicks', () => {
+  it('fires the first round immediately and schedules the rest at i*spacing', () => {
+    const engine = initEngine()
+    engine.executeCommand(salvo(3, 2))
+
+    expect(engine.state.missiles.size).toBe(1)
+    expect(engine.state.scheduledLaunches?.map((e) => e.dueTick)).toEqual([2, 4])
+    expect(ammo(engine)).toBe(19)
+
+    engine.tick() // tick 1 — nothing due
+    expect(engine.state.missiles.size).toBe(1)
+    engine.tick() // tick 2 — second round
+    expect(engine.state.missiles.size).toBe(2)
+    engine.tick() // tick 3
+    expect(engine.state.missiles.size).toBe(2)
+    engine.tick() // tick 4 — third round
+    expect(engine.state.missiles.size).toBe(3)
+    expect(engine.state.scheduledLaunches).toEqual([])
+    expect(ammo(engine)).toBe(17)
+  })
+
+  it('spacing 0 or undefined launches the whole salvo immediately (previous behavior)', () => {
+    const engine = initEngine()
+    engine.executeCommand(salvo(4))
+    expect(engine.state.missiles.size).toBe(4)
+    expect(engine.state.scheduledLaunches ?? []).toEqual([])
+
+    engine.executeCommand(salvo(2, 0))
+    expect(engine.state.missiles.size).toBe(6)
+    expect(engine.state.scheduledLaunches ?? []).toEqual([])
+  })
+
+  it('declares war once on the immediate round, not per scheduled round', () => {
+    const engine = initEngine()
+    engine.executeCommand(salvo(3, 2))
+    expect(engine.state.nations.usa.atWar).toContain('iran')
+    expect(engine.state.events.filter((e) => e.type === 'WAR_DECLARED').length).toBe(1)
+
+    for (let i = 0; i < 5; i++) engine.tick()
+    expect(engine.state.missiles.size).toBe(3)
+    expect(engine.state.events.filter((e) => e.type === 'WAR_DECLARED').length).toBe(1)
+  })
+
+  it('scheduled rounds never fire while paused — only ticks advance the schedule', () => {
+    vi.useFakeTimers()
+    try {
+      const engine = initEngine()
+      const loop = new GameLoop(engine)
+      loop.start()
+
+      engine.executeCommand(salvo(2, 2))
+      expect(engine.state.missiles.size).toBe(1)
+
+      engine.state.time.speed = 0
+      vi.advanceTimersByTime(60_000) // a wall-clock minute while paused
+      expect(engine.state.missiles.size).toBe(1)
+      expect(engine.state.scheduledLaunches?.length).toBe(1)
+
+      engine.state.time.speed = 1
+      vi.advanceTimersByTime(300) // 3 loop steps = 3 ticks ≥ dueTick 2
+      expect(engine.state.missiles.size).toBe(2)
+      expect(engine.state.scheduledLaunches).toEqual([])
+
+      loop.stop()
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('save/load round-trips pending scheduled rounds and they still fire', () => {
+    const engine = initEngine()
+    engine.executeCommand(salvo(3, 5)) // remaining rounds due at ticks 5 and 10
+    engine.tick()
+
+    const loaded = new GameEngine()
+    loaded.loadState(engine.getFullStateJson())
+    expect(loaded.state.scheduledLaunches?.map((e) => e.dueTick)).toEqual([5, 10])
+    expect(loaded.state.missiles.size).toBe(1)
+
+    for (let i = 0; i < 9; i++) loaded.tick() // ticks 2..10
+    expect(loaded.state.missiles.size).toBe(3)
+    expect(loaded.state.scheduledLaunches).toEqual([])
+  })
+
+  it('rolls the leak once per salvo and carries compromised onto scheduled rounds', () => {
+    const engine = initEngine()
+    engine.state.intel!.leakLevel = 100
+    const chance = vi.spyOn(engine.rng, 'chance').mockReturnValue(true)
+    engine.executeCommand(salvo(3, 2))
+    expect(chance).toHaveBeenCalledTimes(1)
+    chance.mockRestore()
+
+    expect(engine.state.scheduledLaunches?.every((e) => e.compromised === true)).toBe(true)
+
+    for (let i = 0; i < 4; i++) engine.tick()
+    const missiles = [...engine.state.missiles.values()]
+    expect(missiles.length).toBe(3)
+    expect(missiles.every((m) => m.compromised === true)).toBe(true)
+  })
+
+  it('entries whose launcher is destroyed drain as no-ops without spending ammo', () => {
+    const engine = initEngine()
+    engine.executeCommand(salvo(3, 2))
+    engine.state.units.get('us_tlam')!.status = 'destroyed'
+
+    for (let i = 0; i < 5; i++) engine.tick()
+    expect(engine.state.missiles.size).toBe(1)
+    expect(engine.state.scheduledLaunches).toEqual([])
+    expect(ammo(engine)).toBe(19)
+  })
+
+  it('entries whose launcher ran out of ammo drain as no-ops', () => {
+    const engine = initEngine()
+    engine.executeCommand(salvo(3, 2))
+    engine.state.units.get('us_tlam')!.weapons[0].count = 0
+
+    for (let i = 0; i < 5; i++) engine.tick()
+    expect(engine.state.missiles.size).toBe(1)
+    expect(engine.state.scheduledLaunches).toEqual([])
+  })
+
+  it('starting a new scenario clears stale scheduled rounds', () => {
+    const engine = initEngine()
+    engine.executeCommand(salvo(3, 1000))
+    expect(engine.state.scheduledLaunches?.length).toBe(2)
+
+    const nations = { usa: makeNation('usa', 'USA'), iran: makeNation('iran', 'Iran') }
+    engine.initFromData('usa', nations, makeScenarioUnits(), [], {})
+    expect(engine.state.scheduledLaunches ?? []).toEqual([])
+    engine.tick()
+    expect(engine.state.missiles.size).toBe(0)
+  })
+})
+
+// ── scheduleSalvo (delayTicks — the TOT path) ───────────────────
+
+function delayedSalvoCmd(count: number, delayTicks: number, spacingTicks = 1) {
+  return {
+    type: 'LAUNCH_SALVO',
+    launcherId: 'us_tlam',
+    weaponId: 'tomahawk',
+    targetId: 'ir_base',
+    count,
+    spacingTicks,
+    delayTicks,
+  } as const
+}
+
+describe('scheduleSalvo', () => {
+  it('queues every round in the future — nothing fires and no ammo spends at command time', () => {
+    const engine = initEngine()
+    scheduleSalvo(engine.state, delayedSalvoCmd(3, 5), false)
+
+    expect(engine.state.missiles.size).toBe(0)
+    expect(ammo(engine)).toBe(20)
+    expect(engine.state.scheduledLaunches?.map((e) => e.dueTick)).toEqual([5, 6, 7])
+
+    for (let i = 0; i < 4; i++) engine.tick() // ticks 1..4
+    expect(engine.state.missiles.size).toBe(0)
+    engine.tick() // tick 5
+    expect(engine.state.missiles.size).toBe(1)
+    engine.tick() // tick 6
+    expect(engine.state.missiles.size).toBe(2)
+    engine.tick() // tick 7
+    expect(engine.state.missiles.size).toBe(3)
+    expect(engine.state.scheduledLaunches).toEqual([])
+    expect(ammo(engine)).toBe(17)
+  })
+
+  it('declares war when the first scheduled round fires, not at command time', () => {
+    const engine = initEngine()
+    scheduleSalvo(engine.state, delayedSalvoCmd(2, 3), false)
+
+    expect(engine.state.nations.usa.atWar).toEqual([])
+    expect(engine.state.events.filter((e) => e.type === 'WAR_DECLARED')).toEqual([])
+
+    for (let i = 0; i < 6; i++) engine.tick()
+    expect(engine.state.nations.usa.atWar).toContain('iran')
+    const declarations = engine.state.events.filter((e) => e.type === 'WAR_DECLARED')
+    expect(declarations.length).toBe(1)
+    expect(declarations[0].tick).toBe(3)
+  })
+
+  it('carries the salvo leak result onto every scheduled round', () => {
+    const engine = initEngine()
+    scheduleSalvo(engine.state, delayedSalvoCmd(3, 2), true)
+    expect(engine.state.scheduledLaunches?.every((e) => e.compromised === true)).toBe(true)
+  })
+})
+
+// ── TOT integration: scheduled entries → near-simultaneous impacts ──
+
+function totStrike(over: Partial<PlannedStrike> & { launcherId: string; weaponId: string; flightTimeSec: number }): PlannedStrike {
+  return {
+    launcherName: over.launcherId,
+    weaponName: over.weaponId,
+    targetId: 'ir_base',
+    targetName: 'ir_base',
+    targetCategory: 'airbase',
+    count: 1,
+    inRange: true,
+    distanceKm: 0,
+    priorityTier: 0,
+    ...over,
+  } as PlannedStrike
+}
+
+describe('TOT schedule driven through the engine', () => {
+  it('mixed cruise/ballistic package impacts within ±2 ticks of totTick', () => {
+    const engine = new GameEngine()
+    const nations = { usa: makeNation('usa', 'USA'), iran: makeNation('iran', 'Iran') }
+    const launcherPos = { lat: 26, lng: 52 }
+    const targetPos = { lat: 27.6, lng: 52.3 }
+    engine.initFromData('usa', nations, [
+      makeUnit({
+        id: 'us_tlam', nation: 'usa', category: 'missile_battery', position: { ...launcherPos },
+        weapons: [{ weaponId: 'tomahawk', count: 20, maxCount: 20, reloadTimeSec: 0 }],
+      }),
+      makeUnit({
+        id: 'us_bm', nation: 'usa', category: 'missile_battery', position: { ...launcherPos },
+        weapons: [{ weaponId: 'fateh110', count: 10, maxCount: 10, reloadTimeSec: 0 }],
+      }),
+      // Tough enough that the first impact can't destroy it before the second lands
+      makeUnit({
+        id: 'ir_base', nation: 'iran', category: 'airbase', position: { ...targetPos },
+        health: 100000, maxHealth: 100000, hardness: 5000,
+      }),
+    ], [], {})
+
+    // Same flight-time math the attack planner uses (mach × 1235 km/h)
+    const dist = haversine(launcherPos, targetPos)
+    const ftCruise = dist / (0.75 * 1235 / 3600) // tomahawk
+    const ftBallistic = dist / (3.5 * 1235 / 3600) // fateh110
+
+    const schedule = computeTotSchedule({
+      name: 'tot', priorities: [], timing: 'simultaneous',
+      strikes: [
+        totStrike({ launcherId: 'us_tlam', weaponId: 'tomahawk', flightTimeSec: ftCruise }),
+        totStrike({ launcherId: 'us_bm', weaponId: 'fateh110', flightTimeSec: ftBallistic }),
+      ],
+      summary: {
+        totalMissiles: 2, totalTargets: 1, weaponBudget: {}, targetCoverage: {},
+        estimatedPenetration: 1, estimatedKills: 0, warnings: [],
+      },
+    }, engine.state.time.tick)
+
+    const nowTick = engine.state.time.tick
+    for (const e of schedule.entries) {
+      scheduleSalvo(engine.state, {
+        type: 'LAUNCH_SALVO',
+        launcherId: e.launcherId,
+        weaponId: e.weaponId,
+        targetId: e.targetId,
+        count: e.count,
+        spacingTicks: TOT_RIPPLE_TICKS,
+        delayTicks: e.dueTick - nowTick,
+      }, false)
+    }
+
+    // Cruise leg launches first (longest flight); nothing flies before its dueTick
+    while (engine.state.time.tick < schedule.earliestLaunchTick - 1) engine.tick()
+    expect(engine.state.missiles.size).toBe(0)
+
+    while (engine.state.time.tick < schedule.totTick + 5) engine.tick()
+
+    const launches = engine.state.events.filter((e) => e.type === 'MISSILE_LAUNCHED')
+    expect(launches.map((l) => l.tick).sort((a, b) => a - b))
+      .toEqual(schedule.entries.map((e) => e.dueTick).sort((a, b) => a - b))
+
+    const impacts = engine.state.events.filter((e) => e.type === 'MISSILE_IMPACT')
+    expect(impacts.length).toBe(2)
+    for (const impact of impacts) {
+      expect(Math.abs(impact.tick - schedule.totTick)).toBeLessThanOrEqual(2)
+    }
+  })
+})
+
+// ── Iran AI ATTRITION saturation builds a TOT package ───────────
+
+describe('AI saturation TOT package', () => {
+  it('schedules a TOT-compressed ballistic package on the densest-AD target instead of dumping at T0', () => {
+    const engine = new GameEngine()
+    const nations = { usa: makeNation('usa', 'USA'), iran: makeNation('iran', 'Iran') }
+    const basePos = { lat: 26, lng: 52 }
+    engine.initFromData('usa', nations, [
+      makeUnit({ id: 'us_base', nation: 'usa', category: 'airbase', position: { ...basePos } }),
+      // Patriot umbrella over the airbase makes it the densest-AD target
+      makeUnit({
+        id: 'us_patriot', nation: 'usa', category: 'sam_site', position: { lat: 26.1, lng: 52.1 },
+        weapons: [{ weaponId: 'pac3_mse', count: 16, maxCount: 16, reloadTimeSec: 600 }],
+      }),
+      makeUnit({ id: 'us_ship', nation: 'usa', category: 'ship', position: { lat: 22, lng: 60 } }),
+      makeUnit({
+        id: 'ir_fateh', nation: 'iran', category: 'missile_battery', position: { lat: 27.8, lng: 52 },
+        weapons: [{ weaponId: 'fateh110', count: 4, maxCount: 4, reloadTimeSec: 0 }],
+      }),
+      makeUnit({
+        id: 'ir_shahab', nation: 'iran', category: 'missile_battery', position: { lat: 26, lng: 58 },
+        weapons: [{ weaponId: 'shahab3', count: 4, maxCount: 4, reloadTimeSec: 0 }],
+      }),
+    ], [], {})
+
+    // At war with ≤20 offensive rounds → ATTRITION on the first AI pass;
+    // -999 lastRetaliationTick watermark makes the saturation salvo due now
+    engine.state.nations.iran.atWar = ['usa']
+    engine.state.nations.usa.atWar = ['iran']
+    engine.state.time.tick = 2700
+    engine.tick()
+
+    const entries = engine.state.scheduledLaunches ?? []
+    expect(entries.length).toBeGreaterThan(0)
+    expect(engine.state.missiles.size).toBe(0)
+    expect(entries.every((e) => e.targetId === 'us_base')).toBe(true)
+    expect(entries.every((e) => e.trackQuality === 'datalink')).toBe(true)
+    expect(entries.every((e) => e.dueTick > engine.state.time.tick)).toBe(true)
+
+    // Every round's implied impact lands inside one tight window (count ripple ≤ 2)
+    const impliedImpacts = entries.map((e) => {
+      const launcher = engine.state.units.get(e.launcherId)!
+      const spec = weaponSpecs[e.weaponId]
+      const flightSec = haversine(launcher.position, basePos) / (spec.speed_mach * 1235 / 3600)
+      return e.dueTick + Math.ceil(flightSec)
+    })
+    expect(Math.max(...impliedImpacts) - Math.min(...impliedImpacts)).toBeLessThanOrEqual(2)
+  })
+})
diff --git a/src/engine/systems/__tests__/visibility.test.ts b/src/engine/systems/__tests__/visibility.test.ts
index 3cf89a2..4a5145f 100644
--- a/src/engine/systems/__tests__/visibility.test.ts
+++ b/src/engine/systems/__tests__/visibility.test.ts
@@ -31,8 +31,10 @@ function makeUnit(overrides: Partial<Unit> & { id: string; nation: NationId }):
   } as Unit
 }
 
-function radar(range_km: number, antenna_height_m = 15): Sensor {
-  return { type: 'radar', range_km, detection_prob: 0.9, antenna_height_m }
+// Default test radar sits on a tall mast so the radar horizon never caps these
+// scenarios — acquisition/decay tests probe contact logic, not curvature physics.
+function radar(range_km: number, antenna_height_m = 2000, sector_deg?: number): Sensor {
+  return { type: 'radar', range_km, detection_prob: 0.9, antenna_height_m, sector_deg }
 }
 
 function makeState(units: Unit[], tick = 60): GameState {
@@ -150,6 +152,59 @@ describe('radar acquisition', () => {
     expect(contact(state, 'iran', 'ir_ship')).toBeUndefined()
   })
 
+  it('radar range is its nominal radius — no horizon cap on surface targets', () => {
+    const usShip = makeUnit({ id: 'us_ship', nation: 'usa', sensors: [radar(400, 25)] })
+    const irFar = makeUnit({ id: 'ir_far', nation: 'iran', position: { lat: 27, lng: 53 } })   // ~99 km
+    const irOut = makeUnit({ id: 'ir_out', nation: 'iran', position: { lat: 27, lng: 57.5 } }) // ~545 km
+    const state = makeState([usShip, irFar, irOut])
+
+    runEval(state, 60)
+
+    expect(contact(state, 'usa', 'ir_far')?.level).toBe('identified') // within 60% of 400 km
+    expect(contact(state, 'usa', 'ir_out')).toBeUndefined()
+  })
+
+  it('height pays: a high-mounted radar outranges its sea-level twin', () => {
+    // Same nominal range, target at ~107 km: 100 km radius alone misses it,
+    // a 4000 m antenna (+20%) reaches it
+    const lowRadar = makeUnit({ id: 'us_low', nation: 'usa', sensors: [radar(100, 15)] })
+    const target1 = makeUnit({ id: 'ir_t1', nation: 'iran', position: { lat: 27, lng: 53.08 } })
+    const s1 = makeState([lowRadar, target1])
+    runEval(s1, 60)
+    expect(contact(s1, 'usa', 'ir_t1')).toBeUndefined()
+
+    resetVisibilityState()
+    const highRadar = makeUnit({ id: 'us_high', nation: 'usa', sensors: [radar(100, 4000)] })
+    const target2 = makeUnit({ id: 'ir_t2', nation: 'iran', position: { lat: 27, lng: 53.08 } })
+    const s2 = makeState([highRadar, target2])
+    runEval(s2, 60)
+    expect(contact(s2, 'usa', 'ir_t2')?.level).toBe('tracked')
+  })
+
+  it('high targets stand out: aircraft are spotted beyond nominal range, ships are not', () => {
+    const usRadar = makeUnit({ id: 'us_radar', nation: 'usa', sensors: [radar(100, 15)] })
+    const irJet = makeUnit({ id: 'ir_jet', nation: 'iran', category: 'aircraft', position: { lat: 27, lng: 53.16 } })  // ~115 km
+    const irShip = makeUnit({ id: 'ir_ship', nation: 'iran', position: { lat: 27.2, lng: 53.16 } })                    // ~115 km
+    const state = makeState([usRadar, irJet, irShip])
+
+    runEval(state, 60)
+
+    expect(contact(state, 'usa', 'ir_jet')?.level).toBe('tracked') // prominence: +30% vs high targets
+    expect(contact(state, 'usa', 'ir_ship')).toBeUndefined()
+  })
+
+  it('sector-limited radar only acquires inside its arc', () => {
+    const usSam = makeUnit({ id: 'us_sam', nation: 'usa', heading: 90, sensors: [radar(100, 2000, 120)] })
+    const irEast = makeUnit({ id: 'ir_east', nation: 'iran', position: { lat: 27, lng: 52.5 } })  // bearing ~90°, ~50 km
+    const irWest = makeUnit({ id: 'ir_west', nation: 'iran', position: { lat: 27, lng: 51.3 } })  // bearing ~270°
+    const state = makeState([usSam, irEast, irWest])
+
+    runEval(state, 60)
+
+    expect(contact(state, 'usa', 'ir_east')?.level).toBe('identified')
+    expect(contact(state, 'usa', 'ir_west')).toBeUndefined()
+  })
+
   it('terrain blocks line of sight', () => {
     // 3000 m ridge at lng 52.4-52.6, flat elsewhere
     const elevations = Array.from({ length: 20 }, () =>
diff --git a/src/engine/systems/ai.ts b/src/engine/systems/ai.ts
index c37be3f..736fb59 100644
--- a/src/engine/systems/ai.ts
+++ b/src/engine/systems/ai.ts
@@ -1,10 +1,15 @@
-import type { GameState, NationId, Position, Unit } from '@/types/game'
+import type { GameState, NationId, Position, TrackQuality, Unit } from '@/types/game'
 import type { Command } from '@/types/commands'
+import type { ElevationGrid } from './elevation'
 import type { SeededRNG } from '../utils/rng'
 import { weaponSpecs } from '@/data/weapons/missiles'
+import { adSystems } from '@/data/weapons/air-defense'
 import { haversine, bearing } from '../utils/geo'
 import { processDroneSwarm, getDroneAmmo } from './drone-ai'
 import { WAR_SUPPORT_CRITICAL_THRESHOLD } from './war-support'
+import { getFireControlQuality } from './visibility'
+import { scheduleSalvo } from './strike-scheduler'
+import { TOT_PAD_TICKS, TOT_RIPPLE_TICKS } from '../attack-planner'
 
 type AIPhase = 'PEACETIME' | 'ALERT' | 'DEFENSIVE' | 'OFFENSIVE' | 'ATTRITION'
 
@@ -55,6 +60,25 @@ function getAIState(nation: NationId, state: GameState): AIState {
   return s
 }
 
+/**
+ * SIGINT hook: best estimate of the nation's next salvo tick, or null when no
+ * salvo is on the clock. Reads the same AI state the salvo logic uses.
+ */
+export function getNextSalvoEstimate(nation: NationId): number | null {
+  const ai = aiStates.get(nation)
+  if (!ai) return null
+  switch (ai.phase) {
+    case 'DEFENSIVE':
+      return ai.attacksReceived > 0 ? ai.lastRetaliationTick + 300 : null
+    case 'OFFENSIVE':
+      return ai.lastRetaliationTick + 900
+    case 'ATTRITION':
+      return ai.lastRetaliationTick + 3600
+    default:
+      return null
+  }
+}
+
 /** Orient sector-limited SAM radars toward the nearest enemy concentration */
 export function orientSAMRadars(state: GameState, excludeNation?: NationId): void {
   for (const unit of state.units.values()) {
@@ -83,7 +107,7 @@ export function orientSAMRadars(state: GameState, excludeNation?: NationId): voi
 }
 
 /** Process AI for all non-player nations. Returns commands to execute. */
-export function processAI(state: GameState, rng: SeededRNG): Command[] {
+export function processAI(state: GameState, rng: SeededRNG, grid?: ElevationGrid | null): Command[] {
   const commands: Command[] = []
 
   // Re-orient enemy SAMs periodically (initial orient done in game-engine init)
@@ -160,7 +184,7 @@ export function processAI(state: GameState, rng: SeededRNG): Command[] {
       case 'DEFENSIVE':
         // Retaliate within 5 minutes of being attacked
         if (ai.attacksReceived > 0 && state.time.tick - ai.lastRetaliationTick > 300) {
-          const salvoCommands = generateRetaliatorySalvo(state, nation.id, enemyNation, rng, 'defensive')
+          const salvoCommands = generateRetaliatorySalvo(state, nation.id, enemyNation, rng, 'defensive', grid)
           commands.push(...salvoCommands)
           // Accompany with drone swarm for saturation effect
           if (getDroneAmmo(state, nation.id) > 10) {
@@ -177,7 +201,7 @@ export function processAI(state: GameState, rng: SeededRNG): Command[] {
       case 'OFFENSIVE':
         // Launch salvos every 15 minutes
         if (state.time.tick - ai.lastRetaliationTick > 900) {
-          const salvoCommands = generateRetaliatorySalvo(state, nation.id, enemyNation, rng, 'offensive')
+          const salvoCommands = generateRetaliatorySalvo(state, nation.id, enemyNation, rng, 'offensive', grid)
           commands.push(...salvoCommands)
           ai.lastRetaliationTick = state.time.tick
           ai.salvosLaunched++
@@ -192,8 +216,13 @@ export function processAI(state: GameState, rng: SeededRNG): Command[] {
       case 'ATTRITION':
         // Conserve ballistic ammo — launch only for saturation
         if (state.time.tick - ai.lastRetaliationTick > 3600) {
-          const salvoCommands = generateRetaliatorySalvo(state, nation.id, enemyNation, rng, 'saturation')
-          commands.push(...salvoCommands)
+          // TOT-compress the package against the densest enemy AD: simultaneous
+          // arrival beats fire channels that would defeat the same rounds at T0
+          const scheduled = scheduleSaturationTot(state, nation.id, enemyNation, rng, grid ?? null)
+          if (!scheduled) {
+            const salvoCommands = generateRetaliatorySalvo(state, nation.id, enemyNation, rng, 'saturation', grid)
+            commands.push(...salvoCommands)
+          }
           ai.lastRetaliationTick = state.time.tick
         }
         // Rely heavily on drones in attrition phase — cheap and plentiful
@@ -246,6 +275,7 @@ function generateRetaliatorySalvo(
   enemyNation: NationId,
   rng: SeededRNG,
   mode: 'defensive' | 'offensive' | 'saturation',
+  grid?: ElevationGrid | null,
 ): Command[] {
   const commands: Command[] = []
 
@@ -259,7 +289,8 @@ function generateRetaliatorySalvo(
     }),
   )
 
-  // Find enemy targets, prioritized
+  // Find enemy targets, prioritized — the AI fights on its own intel picture,
+  // so it can only target units it holds a fire-quality track on
   const targets = Array.from(state.units.values())
     .filter(u => u.nation === enemyNation && u.status !== 'destroyed')
     .sort((a, b) => targetPriority(b) - targetPriority(a))
@@ -284,13 +315,16 @@ function generateRetaliatorySalvo(
       const spec = weaponSpecs[loadout.weaponId]
       if (!spec || spec.type === 'sam' || loadout.count <= 0) continue
 
-      // Pick a target in range
+      // Pick a target in range that this launcher has fire-control quality on
+      let quality: TrackQuality | null = null
       const target = targets.find(t => {
         const dist = haversine(launcher.position, t.position)
-        return dist <= spec.range_km
+        if (dist > spec.range_km) return false
+        quality = getFireControlQuality(state, launcher, t, grid ?? null)
+        return quality !== null
       })
 
-      if (!target) continue
+      if (!target || !quality) continue
 
       // Launch 1-3 missiles at this target
       const count = Math.min(loadout.count, rng.int(1, 3), maxLaunches - launched)
@@ -300,6 +334,7 @@ function generateRetaliatorySalvo(
           launcherId: launcher.id,
           weaponId: loadout.weaponId,
           targetId: target.id,
+          trackQuality: quality,
         })
         launched++
       }
@@ -323,6 +358,108 @@ function targetPriority(unit: { category: string }): number {
   }
 }
 
+const SATURATION_MAX_LAUNCHES = 20
+
+/** Sum enemy SAM fire channels covering a unit (same 200 km scan the attack planner uses) */
+function coveringFireChannels(target: Unit, state: GameState, defenderNation: NationId): number {
+  let channels = 0
+  for (const sam of state.units.values()) {
+    if (sam.nation !== defenderNation || sam.category !== 'sam_site' || sam.status === 'destroyed') continue
+    if (haversine(sam.position, target.position) > 200) continue
+    for (const wl of sam.weapons) {
+      if (wl.count === 0) continue
+      const ad = Object.values(adSystems).find((s) => s.interceptorId === wl.weaponId)
+      if (ad) channels += ad.fire_channels
+    }
+  }
+  return channels
+}
+
+/**
+ * ATTRITION saturation: schedule a TOT-compressed ballistic package against the
+ * enemy unit under the densest AD umbrella, via the same scheduledLaunches queue
+ * player TOT strikes use. Returns false when no defended target or no usable
+ * ballistic launcher exists — caller falls back to the legacy spread salvo.
+ */
+function scheduleSaturationTot(
+  state: GameState,
+  nationId: NationId,
+  enemyNation: NationId,
+  rng: SeededRNG,
+  grid: ElevationGrid | null,
+): boolean {
+  let target: Unit | null = null
+  let targetChannels = 0
+  for (const candidate of state.units.values()) {
+    if (candidate.nation !== enemyNation || candidate.status === 'destroyed') continue
+    const channels = coveringFireChannels(candidate, state, enemyNation)
+    if (channels > targetChannels ||
+        (channels === targetChannels && channels > 0 && target !== null &&
+          targetPriority(candidate) > targetPriority(target))) {
+      target = candidate
+      targetChannels = channels
+    }
+  }
+  if (!target || targetChannels === 0) return false
+
+  interface PackageRow {
+    launcherId: string
+    weaponId: string
+    count: number
+    flightTimeSec: number
+    quality: TrackQuality
+  }
+  const rows: PackageRow[] = []
+  let total = 0
+  for (const launcher of state.units.values()) {
+    if (total >= SATURATION_MAX_LAUNCHES) break
+    if (launcher.nation !== nationId || launcher.status === 'destroyed') continue
+    if (launcher.readiness && launcher.readiness !== 'deployed') continue
+
+    for (const loadout of launcher.weapons) {
+      if (total >= SATURATION_MAX_LAUNCHES) break
+      const spec = weaponSpecs[loadout.weaponId]
+      if (!spec || spec.type !== 'ballistic_missile' || loadout.count <= 0) continue
+
+      const dist = haversine(launcher.position, target.position)
+      if (dist > spec.range_km) continue
+      const quality = getFireControlQuality(state, launcher, target, grid)
+      if (!quality) continue
+
+      const count = Math.min(loadout.count, rng.int(1, 3), SATURATION_MAX_LAUNCHES - total)
+      if (count <= 0) continue
+      rows.push({
+        launcherId: launcher.id,
+        weaponId: loadout.weaponId,
+        count,
+        flightTimeSec: dist / (spec.speed_mach * 1235 / 3600),
+        quality,
+      })
+      total += count
+    }
+  }
+  if (rows.length === 0) return false
+
+  const maxFlight = Math.max(...rows.map((r) => Math.ceil(r.flightTimeSec)))
+  const totTick = state.time.tick + maxFlight + TOT_PAD_TICKS
+  for (const r of rows) {
+    const dueTick = Math.max(
+      state.time.tick + 1,
+      totTick - Math.ceil(r.flightTimeSec) - (r.count - 1) * TOT_RIPPLE_TICKS,
+    )
+    scheduleSalvo(state, {
+      type: 'LAUNCH_SALVO',
+      launcherId: r.launcherId,
+      weaponId: r.weaponId,
+      targetId: target.id,
+      count: r.count,
+      spacingTicks: TOT_RIPPLE_TICKS,
+      delayTicks: dueTick - state.time.tick,
+    }, false, r.quality)
+  }
+  return true
+}
+
 function getTotalOffensiveAmmo(state: GameState, nationId: NationId): number {
   let total = 0
   for (const unit of state.units.values()) {
diff --git a/src/engine/systems/air-ops.ts b/src/engine/systems/air-ops.ts
new file mode 100644
index 0000000..ed924a0
--- /dev/null
+++ b/src/engine/systems/air-ops.ts
@@ -0,0 +1,167 @@
+import type {
+  AirMission,
+  GameEvent,
+  GameState,
+  NationId,
+  SquadronState,
+  Unit,
+} from '@/types/game'
+import type { Command } from '@/types/commands'
+import type { ElevationGrid } from './elevation'
+import type { SeededRNG } from '../utils/rng'
+import { AIR_WINGS } from '@/data/air/airwings'
+import {
+  AIRFRAMES,
+  MAINTENANCE_FRACTION,
+  STRIKE_PLANNING_MIN_TICKS,
+  STRIKE_PLANNING_MAX_TICKS,
+  SURGE_OPS_DURATION_TICKS,
+} from '@/data/air/airframes'
+
+/**
+ * Air operations — squadrons as pools, flights as transient units, orders at
+ * mission level only. Design: docs/plans/air-war-v5.md. All state lives on
+ * GameState (airMissions, surgeOps, Unit.airWing, Unit.flightMeta) so
+ * save/load is free.
+ */
+
+export function resetAirOpsState(): void {
+  resetAirMissionCounter()
+}
+
+/** Scenario init: attach air wings to hosts and stand down the maintenance fraction */
+export function initAirWings(state: GameState): void {
+  state.airMissions = []
+  state.surgeOps = { enabled: false }
+  for (const [unitId, squadrons] of Object.entries(AIR_WINGS)) {
+    const host = state.units.get(unitId)
+    if (!host) continue
+    host.airWing = squadrons.map(s => {
+      const down = Math.floor(s.total * MAINTENANCE_FRACTION)
+      return {
+        ...s,
+        available: s.total - down,
+        // Maintenance birds trickle back over the first 12-24 game-hours
+        readyAt: Array.from({ length: down }, (_, i) => 12 * 3600 + i * Math.floor((12 * 3600) / Math.max(1, down))),
+      }
+    })
+  }
+}
+
+export function findSquadron(state: GameState, squadronId: string): { host: Unit; squadron: SquadronState } | null {
+  for (const unit of state.units.values()) {
+    const squadron = unit.airWing?.find(s => s.id === squadronId)
+    if (squadron) return { host: unit, squadron }
+  }
+  return null
+}
+
+let missionCounter = 0
+
+/** Validate + record a mission. Lifecycle (spawn/orbit/strike/RTB) runs in processAirOps. */
+export function launchAirMission(
+  state: GameState,
+  rng: SeededRNG,
+  cmd: Extract<Command, { type: 'LAUNCH_AIR_MISSION' }>,
+): void {
+  const found = findSquadron(state, cmd.squadronId)
+  if (!found || found.host.id !== cmd.fromUnitId || found.host.status === 'destroyed') return
+  const spec = AIRFRAMES[found.squadron.airframe]
+  if (!spec) return
+
+  const flightSize = Math.max(2, Math.min(4, cmd.flightSize))
+  if (found.squadron.available < flightSize) return
+  if (cmd.kind === 'strike' && !cmd.targetId) return
+  if ((cmd.kind === 'cap' || cmd.kind === 'aew') && !cmd.station) return
+  if (cmd.kind === 'strike' && spec.strikeWeapons.length === 0) return
+  if (cmd.kind === 'aew' && !spec.datalink_range_km) return
+
+  const tick = state.time.tick
+  const mission: AirMission = {
+    id: `am_${++missionCounter}_${tick}`,
+    kind: cmd.kind,
+    nation: found.host.nation,
+    squadronId: cmd.squadronId,
+    fromUnitId: cmd.fromUnitId,
+    flightSize,
+    station: cmd.station ? { ...cmd.station } : undefined,
+    targetId: cmd.targetId,
+    escortSead: cmd.escortSead,
+    extendedRange: cmd.extendedRange,
+    status: cmd.kind === 'strike' ? 'planning' : 'active',
+    createdTick: tick,
+    planningCompleteTick:
+      cmd.kind === 'strike'
+        ? tick + STRIKE_PLANNING_MIN_TICKS + rng.int(0, STRIKE_PLANNING_MAX_TICKS - STRIKE_PLANNING_MIN_TICKS)
+        : undefined,
+  }
+  ;(state.airMissions ??= []).push(mission)
+}
+
+export function cancelAirMission(state: GameState, missionId: string): void {
+  const mission = state.airMissions?.find(m => m.id === missionId)
+  if (!mission || mission.status === 'complete' || mission.status === 'aborted') return
+  // Lifecycle in processAirOps sees 'aborted' and RTBs any airborne flight
+  mission.status = 'aborted'
+}
+
+export function setSurgeOps(state: GameState, enabled: boolean): void {
+  state.surgeOps ??= { enabled: false }
+  if (enabled && !state.surgeOps.enabled) {
+    state.surgeOps = { enabled: true, activatedTick: state.time.tick }
+  } else if (!enabled) {
+    state.surgeOps = { enabled: false, activatedTick: state.surgeOps.activatedTick }
+  }
+}
+
+/** Surge window still open? (96 h from activation) */
+export function surgeActive(state: GameState): boolean {
+  const s = state.surgeOps
+  if (!s?.enabled || s.activatedTick === undefined) return false
+  return state.time.tick - s.activatedTick < SURGE_OPS_DURATION_TICKS
+}
+
+/**
+ * Per-tick mission lifecycle — implemented per docs/plans/air-war-v5.md §3:
+ * launch due missions (spawn Flight units), CAP orbit + auto-intercept with the
+ * A2A pK model, strike transit/release via launchMissile, AEW station-keeping,
+ * SEAD escort effects, bingo/RTB, recovery + turnaround bookkeeping, losses
+ * with pilot-fate rolls, and the Iranian scramble AI hook.
+ */
+export function processAirOps(
+  state: GameState,
+  rng: SeededRNG,
+  grid: ElevationGrid | null,
+): void {
+  // C1 implements — contracts above are frozen.
+  void state
+  void rng
+  void grid
+}
+
+/** Player-nation mission slice for the snapshot */
+export function getAirMissionsView(state: GameState, nation: NationId): AirMission[] {
+  return (state.airMissions ?? [])
+    .filter(m => m.nation === nation)
+    .map(m => ({ ...m, station: m.station ? { ...m.station } : undefined }))
+}
+
+export function emitAirEvent(state: GameState, event: GameEvent): void {
+  state.events.push(event)
+  if (state.events.length > 2000) state.events.splice(0, state.events.length - 2000)
+  state.pendingEvents.push(event)
+}
+
+/** Restore the mission id counter after load so new ids never collide */
+export function setAirMissionCounter(state: GameState): void {
+  let max = 0
+  for (const m of state.airMissions ?? []) {
+    const n = /^am_(\d+)_/.exec(m.id)
+    if (n) max = Math.max(max, Number(n[1]))
+  }
+  missionCounter = max
+}
+
+export function resetAirMissionCounter(): void {
+  missionCounter = 0
+}
diff --git a/src/engine/systems/combat.ts b/src/engine/systems/combat.ts
index f571757..a4830b7 100644
--- a/src/engine/systems/combat.ts
+++ b/src/engine/systems/combat.ts
@@ -1,4 +1,4 @@
-import type { GameState, GameEvent, Missile, NationId, Unit, WeaponSpec, ADSystemSpec, Position } from '@/types/game'
+import type { GameState, GameEvent, Missile, NationId, TrackQuality, Unit, WeaponSpec, ADSystemSpec, Position } from '@/types/game'
 import type { ElevationGrid } from './elevation'
 import type { SeededRNG } from '../utils/rng'
 import { weaponSpecs } from '@/data/weapons/missiles'
@@ -131,7 +131,7 @@ export function processCombat(state: GameState, rng: SeededRNG, elevationGrid?:
   updateMissilePositions(state)
   runADEngagement(state, rng, elevationGrid, sensorNetwork)
   updateInterceptors(state, rng)
-  resolveImpacts(state)
+  resolveImpacts(state, rng)
   updateReloads(state)
 }
 
@@ -141,6 +141,7 @@ export function processCombat(state: GameState, rng: SeededRNG, elevationGrid?:
 
 function updateMissileFuel(state: GameState): void {
   const toRemove: string[] = []
+  const events: GameEvent[] = []
 
   for (const missile of state.missiles.values()) {
     if (missile.status !== 'inflight') continue
@@ -161,9 +162,16 @@ function updateMissileFuel(state: GameState): void {
         toRemove.push(missile.id)
       } else if (spec.type === 'cruise_missile' || spec.type === 'ashm' || spec.type === 'loitering_munition') {
         // Cruise missiles: speed decays and altitude drops (handled in speed/altitude updates)
-        // If altitude has reached 0 or below, crash
+        // If altitude has reached 0 or below, crash — loudly, a vanished missile reads as a bug
         if (missile.altitude_m <= 0) {
           toRemove.push(missile.id)
+          const pos = getCurrentMissilePosition(missile, state.time.timestamp)
+          events.push({
+            type: 'MISSILE_CRASHED',
+            missileId: missile.id,
+            position: pos ? { lng: pos[0], lat: pos[1] } : undefined,
+            tick: state.time.tick,
+          })
         }
       }
       // Ballistic missiles: fuel only matters in boost phase, midcourse/terminal are unpowered
@@ -173,6 +181,8 @@ function updateMissileFuel(state: GameState): void {
   for (const id of toRemove) {
     state.missiles.delete(id)
   }
+
+  emitEvents(state, events)
 }
 
 // ===============================================
@@ -296,13 +306,22 @@ function updateMissileAltitudes(state: GameState, elevationGrid?: ElevationGrid
         missile.altitude_m = (progress / 0.15) * peakAltM * 0.5
       } else if (progress < 0.7) {
         missile.phase = 'midcourse'
-        // Parabolic arc peaking at midpoint
+        // Arc from boost burnout (0.5×peak) through apogee and back — must match the
+        // boost/terminal endpoints, or altitude snaps to ground level at the phase
+        // seams (rendered as the missile crashing into terrain mid-flight)
         const midProgress = (progress - 0.15) / 0.55
-        missile.altitude_m = peakAltM * (1 - 4 * (midProgress - 0.5) ** 2)
+        missile.altitude_m = peakAltM * (0.5 + 0.5 * (1 - 4 * (midProgress - 0.5) ** 2))
       } else {
         missile.phase = 'terminal'
         const termProgress = (progress - 0.7) / 0.3
-        missile.altitude_m = peakAltM * (1 - termProgress) * 0.5
+        // The dive ends at the TARGET's ground elevation, not sea level — targets on
+        // high plateaus had the last seconds of the dive underground
+        let groundM = 0
+        if (elevationGrid) {
+          const tgt = state.units.get(missile.targetId)
+          if (tgt) groundM = Math.max(0, elevationGrid.getElevation(tgt.position.lat, tgt.position.lng))
+        }
+        missile.altitude_m = groundM + Math.max(0, peakAltM * 0.5 - groundM) * (1 - termProgress)
       }
     } else {
       // Cruise missiles fly at constant low altitude while fueled
@@ -840,6 +859,8 @@ export function launchMissile(
   weaponId: string,
   targetId: string,
   waypoints?: Position[],
+  trackQuality?: TrackQuality,
+  compromised?: boolean,
 ): GameEvent | null {
   const launcher = state.units.get(launcherId)
   const target = state.units.get(targetId)
@@ -919,9 +940,10 @@ export function launchMissile(
     timestamps = generateTimestamps(state.time.timestamp, flightTimeMs, numSegments)
   }
 
-  // Fuel duration: range_km / (speed_kmh / 3600) = seconds of burn
+  // Fuel duration: range_km / (speed_kmh / 3600) = seconds of burn, with a 15%
+  // reserve so terrain detours and waypoint legs don't starve max-range shots
   const speedKmPerSec = machToKmh(spec.speed_mach) / 3600
-  const fuelSec = spec.range_km / speedKmPerSec
+  const fuelSec = (spec.range_km / speedKmPerSec) * 1.15
 
   const id = `m_${++missileCounter}`
   const missile: Missile = {
@@ -940,6 +962,8 @@ export function launchMissile(
     speed_current_mach: spec.type === 'ballistic_missile' ? 0 : spec.speed_mach,
     fuel_remaining_sec: fuelSec,
     is_interceptor: false,
+    networkQuality: trackQuality === 'datalink' ? 'tracked' : 'own',
+    compromised: compromised || undefined,
   }
 
   state.missiles.set(id, missile)
@@ -1105,7 +1129,13 @@ function isAlreadyEngagedByUnit(unitId: string, missileId: string): boolean {
 //  IMPACT RESOLUTION
 // ===============================================
 
-function resolveImpacts(state: GameState): void {
+/** Categories that can move between launch and impact — datalink shots may miss them */
+const MOBILE_TARGET_CATEGORIES = new Set(['ship', 'carrier_group', 'submarine', 'aircraft'])
+const DATALINK_MISS_CHANCE = 0.12
+/** Strike leaked before launch — target was warned and displaced/hardened */
+const COMPROMISED_MISS_CHANCE = 0.35
+
+function resolveImpacts(state: GameState, rng: SeededRNG): void {
   const events: GameEvent[] = []
 
   for (const missile of state.missiles.values()) {
@@ -1120,6 +1150,30 @@ function resolveImpacts(state: GameState): void {
     const target = state.units.get(missile.targetId)
     const spec = weaponSpecs[missile.weaponId]
 
+    if (target && spec && missile.compromised && rng.chance(COMPROMISED_MISS_CHANCE)) {
+      events.push({
+        type: 'MISSILE_MISSED',
+        missileId: missile.id,
+        targetId: missile.targetId,
+        tick: state.time.tick,
+      })
+      state.missiles.delete(missile.id)
+      continue
+    }
+
+    // Shots on relayed tracks lack terminal-quality data — moving targets can evade
+    if (target && spec && missile.networkQuality === 'tracked' &&
+        MOBILE_TARGET_CATEGORIES.has(target.category) && rng.chance(DATALINK_MISS_CHANCE)) {
+      events.push({
+        type: 'MISSILE_MISSED',
+        missileId: missile.id,
+        targetId: missile.targetId,
+        tick: state.time.tick,
+      })
+      state.missiles.delete(missile.id)
+      continue
+    }
+
     if (target && target.status !== 'destroyed' && spec) {
       const damage = computeDamage(spec, target.hardness)
       const healthBefore = target.health
diff --git a/src/engine/systems/detection.ts b/src/engine/systems/detection.ts
index 889a97c..5646969 100644
--- a/src/engine/systems/detection.ts
+++ b/src/engine/systems/detection.ts
@@ -1,4 +1,4 @@
-import type { GameState, Missile, Unit, Position } from '@/types/game'
+import type { GameState, Missile, Unit, UnitId, Position } from '@/types/game'
 import type { ElevationGrid } from './elevation'
 import { haversine, bearing } from '../utils/geo'
 import { weaponSpecs } from '@/data/weapons/missiles'
@@ -9,9 +9,35 @@ export interface DetectedThreat {
   timeToImpactMs: number
 }
 
-/** Radar horizon distance in km using 4/3 earth refraction model */
-function radarHorizon(antennaHeightM: number, targetHeightM: number): number {
-  return 4.12 * (Math.sqrt(Math.max(0, antennaHeightM)) + Math.sqrt(Math.max(0, targetHeightM)))
+const DEFAULT_ANTENNA_HEIGHT_M = 15
+
+interface TickMemo {
+  tick: number
+  results: Map<UnitId, DetectedThreat[]>
+}
+
+// detectThreats runs for the same unit up to 3× per tick (sensor network, ROE
+// enforcement, combat); within a tick the inputs are identical, so memoize per
+// (state, tick, unit). Keyed by state object so parallel states (tests) never collide.
+let detectionMemo = new WeakMap<GameState, TickMemo>()
+
+/** Reset module-level state — must be called on save/load (game-engine resetAllSystems) */
+export function resetDetectionCache(): void {
+  detectionMemo = new WeakMap()
+}
+
+/**
+ * Height pays: a radar sited high (terrain + antenna/airframe) reaches further.
+ * +50% range at 10 km of total height. Replaces the old hard radar-horizon cap —
+ * radar coverage is otherwise its nominal radius (design decision 2026-06-11).
+ */
+export function elevationRangeBonus(heightM: number): number {
+  return 1 + 0.5 * Math.min(1, Math.max(0, heightM) / 10000)
+}
+
+/** High targets stand out against the sky: spotted at up to +30% range at 8 km height */
+export function targetProminenceBonus(heightM: number): number {
+  return 1 + 0.3 * Math.min(1, Math.max(0, heightM) / 8000)
 }
 
 /** Check line-of-sight between two points using elevation grid */
@@ -35,15 +61,31 @@ export function hasLineOfSight(
 
 /** For each AD unit, find incoming missiles within detection range */
 export function detectThreats(state: GameState, adUnit: Unit, grid?: ElevationGrid | null): DetectedThreat[] {
-  const threats: DetectedThreat[] = []
+  if (adUnit.sensors.length === 0) return []
+  // EMCON checked before the memo so a mid-tick flip never serves a stale picture
+  if (adUnit.emcon) return []
+
+  let memo = detectionMemo.get(state)
+  if (!memo || memo.tick !== state.time.tick) {
+    memo = { tick: state.time.tick, results: new Map() }
+    detectionMemo.set(state, memo)
+  }
+  const cached = memo.results.get(adUnit.id)
+  if (cached) return cached
 
-  if (adUnit.sensors.length === 0) return threats
+  const threats = computeThreats(state, adUnit, grid)
+  memo.results.set(adUnit.id, threats)
+  return threats
+}
 
-  const radarRange = Math.max(...adUnit.sensors
-    .filter(s => s.type === 'radar')
-    .map(s => s.range_km))
+function computeThreats(state: GameState, adUnit: Unit, grid?: ElevationGrid | null): DetectedThreat[] {
+  const threats: DetectedThreat[] = []
 
-  if (radarRange <= 0) return threats
+  // Sensor.detection_prob is data-only today — no probability roll (see BACKLOG)
+  const radars = adUnit.sensors.filter(s => s.type === 'radar' && s.range_km > 0)
+  if (radars.length === 0) return threats
+
+  const siteElevM = grid ? grid.getElevation(adUnit.position.lat, adUnit.position.lng) : 0
 
   for (const missile of state.missiles.values()) {
     if (missile.status !== 'inflight') continue
@@ -53,50 +95,54 @@ export function detectThreats(state: GameState, adUnit: Unit, grid?: ElevationGr
     const currentPos = interpolateMissilePosition(missile, state.time.timestamp)
     if (!currentPos) continue
 
-    const dist = haversine(adUnit.position, { lat: currentPos[1], lng: currentPos[0] })
+    const targetPos = { lat: currentPos[1], lng: currentPos[0] }
+    const dist = haversine(adUnit.position, targetPos)
 
-    // Detection range modified by missile profile
+    // Per-missile range modifiers, shared by every sensor
     const spec = weaponSpecs[missile.weaponId]
-    let effectiveRange = radarRange
-
+    let profileModifier = 1.0
     if (spec) {
       // RCS factor: small targets (drones ~0.1 m²) are harder to detect
       const rcs = spec.rcs_m2 ?? 1.0
-      if (rcs < 1.0) effectiveRange *= Math.min(1.0, Math.sqrt(rcs))
+      if (rcs < 1.0) profileModifier *= Math.min(1.0, Math.sqrt(rcs))
+
+      // Low flyers hide in surface clutter — harder to pick up, but no hard horizon cap
+      if (spec.flight_altitude_ft < 500) profileModifier *= 0.4
+      else if (spec.flight_altitude_ft < 5000) profileModifier *= 0.7
     }
 
-    // Radar horizon caps detection range for low-altitude targets
-    // (replaces the old flat altitude modifier — horizon is physics-based)
-    if (grid) {
-      const radarElevation = grid.getElevation(adUnit.position.lat, adUnit.position.lng)
-      const antennaHeight = adUnit.sensors.find(s => s.type === 'radar')?.antenna_height_m ?? 15
-      const radarAltM = radarElevation + antennaHeight
-      const targetAltM = missile.altitude_m ?? 50
+    const targetAltM = missile.altitude_m ?? 50
+
+    // The missile is detected if ANY radar sees it — each sensor evaluated with its
+    // own range, antenna height and sector arc (mirrors visibility.ts radarSeesUnit)
+    let seen = false
+    for (const sensor of radars) {
+      let effectiveRange = sensor.range_km * profileModifier
+      const radarAltM = siteElevM + (sensor.antenna_height_m ?? DEFAULT_ANTENNA_HEIGHT_M)
+
+      // High-sited radars reach further
+      if (grid) effectiveRange *= elevationRangeBonus(radarAltM)
 
-      const horizonKm = radarHorizon(radarAltM, targetAltM)
-      // Horizon caps effective range — not a hard cutoff on distance
-      effectiveRange = Math.min(effectiveRange, horizonKm)
+      if (dist > effectiveRange) continue
+
+      // Sector check — skip targets outside this radar's coverage arc
+      const sectorDeg = sensor.sector_deg ?? 360
+      if (sectorDeg < 360) {
+        const bearingToTarget = bearing(adUnit.position, targetPos)
+        // Normalize difference to [-180, 180]
+        const headingDiff = ((bearingToTarget - adUnit.heading) % 360 + 540) % 360 - 180
+        if (Math.abs(headingDiff) > sectorDeg / 2) continue
+      }
 
       // Terrain masking is a hard check — mountains physically block radar
-      if (dist <= effectiveRange &&
+      if (grid &&
           !hasLineOfSight(adUnit.position, radarAltM, currentPos[1], currentPos[0], targetAltM, grid)) continue
-    } else if (spec) {
-      // Fallback: old altitude modifiers when no elevation grid
-      if (spec.flight_altitude_ft < 500) effectiveRange *= 0.4
-      else if (spec.flight_altitude_ft < 5000) effectiveRange *= 0.7
-    }
 
-    // Sector check — skip targets outside radar's coverage arc
-    const sensor = adUnit.sensors.find(s => s.type === 'radar')
-    const sectorDeg = sensor?.sector_deg ?? 360
-    if (sectorDeg < 360) {
-      const bearingToTarget = bearing(adUnit.position, { lat: currentPos[1], lng: currentPos[0] })
-      // Normalize difference to [-180, 180]
-      const headingDiff = ((bearingToTarget - adUnit.heading) % 360 + 540) % 360 - 180
-      if (Math.abs(headingDiff) > sectorDeg / 2) continue
+      seen = true
+      break
     }
 
-    if (dist <= effectiveRange) {
+    if (seen) {
       threats.push({
         missile,
         distKm: dist,
diff --git a/src/engine/systems/friendly-ai.ts b/src/engine/systems/friendly-ai.ts
index ae8dc2b..e6f4d81 100644
--- a/src/engine/systems/friendly-ai.ts
+++ b/src/engine/systems/friendly-ai.ts
@@ -1,22 +1,35 @@
 /**
- * Autonomous offensive AI for units with weapons_free ROE.
- * Generic — works for any nation, any unit type with offensive weapons.
- * When a unit is set to weapons_free and its nation is at war,
- * it autonomously selects and fires at high-priority enemy targets in range.
+ * Auto-engagement doctrine — units of any nation fire on enemy CONTACTS, not ground truth.
+ *
+ * A unit may engage a target only with fire-control quality from getFireControlQuality:
+ * its own radar holds the target ('own'), or a live nation-level track exists and the
+ * unit is datalink-connected ('datalink' — AWACS/hub relays the picture). Datalink shots
+ * carry a miss chance against moving targets (combat.ts).
+ *
+ * ROE: weapons_free engages any valid track in weapon range; weapons_tight only targets
+ * within the self-defense bubble around the unit or a nearby friendly; hold_fire never.
  */
 
-import type { GameState, NationId, UnitId } from '@/types/game'
+import type { GameState, NationId, Unit, UnitCategory, UnitId } from '@/types/game'
 import type { Command } from '@/types/commands'
+import type { ElevationGrid } from './elevation'
 import type { SeededRNG } from '../utils/rng'
 import { weaponSpecs } from '@/data/weapons/missiles'
 import { haversine } from '../utils/geo'
+import { getFireControlQuality } from './visibility'
+
+const FIRE_COOLDOWN_TICKS = 90
+const SELF_DEFENSE_RADIUS_KM = 75
+/** A target already salvoed by the nation gets a grace period before the next salvo */
+const TARGET_REENGAGE_TICKS = 120
 
-const FIRE_COOLDOWN_TICKS = 300 // 5 minutes between autonomous salvos
 const lastFireTick = new Map<UnitId, number>()
+const lastTargetSalvoTick = new Map<string, number>() // `${nation}:${targetId}`
 
 /** Reset module-level state — must be called on save/load */
 export function resetFriendlyAIState(): void {
   lastFireTick.clear()
+  lastTargetSalvoTick.clear()
 }
 
 const CATEGORY_PRIORITY: Record<string, number> = {
@@ -35,73 +48,117 @@ const CATEGORY_PRIORITY: Record<string, number> = {
 // belong to drone-ai's swarm logic (its cooldowns + never-empty rules).
 const EXCLUDED_WEAPON_TYPES = new Set(['sam', 'cruise_missile', 'ballistic_missile', 'loitering_munition'])
 
-/** Process autonomous offensive fire for all weapons_free units at war */
-export function processFriendlyAI(state: GameState, rng: SeededRNG): Command[] {
+/** Anti-ship missiles only work against things that float */
+const ASHM_TARGETS = new Set<UnitCategory>(['ship', 'carrier_group', 'submarine'])
+
+function validTargetForWeapon(weaponType: string, category: UnitCategory): boolean {
+  if (weaponType === 'ashm') return ASHM_TARGETS.has(category)
+  return category !== 'aircraft' // generic tactical weapons can't hit fast movers
+}
+
+function salvoSizeFor(category: UnitCategory): number {
+  switch (category) {
+    case 'carrier_group': return 4
+    case 'ship': return 2
+    case 'submarine': return 1
+    default: return 2
+  }
+}
+
+/** Process autonomous engagement for all units at war (weapons_free or weapons_tight) */
+export function processFriendlyAI(state: GameState, _rng: SeededRNG, grid?: ElevationGrid | null): Command[] {
   const commands: Command[] = []
+  const tick = state.time.tick
 
   for (const unit of state.units.values()) {
     if (unit.status === 'destroyed') continue
-    if (unit.roe !== 'weapons_free') continue
+    if (unit.roe === 'hold_fire') continue
     // launchMissile rejects non-deployed launchers — skip them so the cooldown isn't burned for nothing
     if (unit.readiness && unit.readiness !== 'deployed') continue
 
-    // Must be at war
     const nation = state.nations[unit.nation]
     if (!nation || nation.atWar.length === 0) continue
 
-    // Cooldown check
     const lastFire = lastFireTick.get(unit.id) ?? -FIRE_COOLDOWN_TICKS
-    if (state.time.tick - lastFire < FIRE_COOLDOWN_TICKS) continue
+    if (tick - lastFire < FIRE_COOLDOWN_TICKS) continue
 
-    // Find tactical offensive weapons with ammo
     const offensiveWeapons = unit.weapons.filter(w => {
       const spec = weaponSpecs[w.weaponId]
       return spec && !EXCLUDED_WEAPON_TYPES.has(spec.type) && w.count > 0
     })
-
     if (offensiveWeapons.length === 0) continue
 
-    // Find enemy nations
     const enemyNations = new Set<NationId>(nation.atWar as NationId[])
 
-    // Find all enemy targets, sorted by priority
-    const enemies = Array.from(state.units.values())
+    const candidates = Array.from(state.units.values())
       .filter(u => enemyNations.has(u.nation) && u.status !== 'destroyed')
       .sort((a, b) => (CATEGORY_PRIORITY[b.category] ?? 0) - (CATEGORY_PRIORITY[a.category] ?? 0))
+    if (candidates.length === 0) continue
 
-    if (enemies.length === 0) continue
-
-    // For each offensive weapon, find a target in range
     let fired = false
     for (const loadout of offensiveWeapons) {
-      if (fired) break // one salvo per cooldown cycle
-
+      if (fired) break
       const spec = weaponSpecs[loadout.weaponId]
       if (!spec) continue
 
-      // Find best target in range
-      const target = enemies.find(e => {
-        const dist = haversine(unit.position, e.position)
-        return dist <= spec.range_km
-      })
-
-      if (!target) continue
-
-      // Fire 1-2 missiles
-      const salvoSize = Math.min(loadout.count, rng.int(1, 2))
-      for (let i = 0; i < salvoSize; i++) {
-        commands.push({
-          type: 'LAUNCH_MISSILE',
-          launcherId: unit.id,
-          weaponId: loadout.weaponId,
+      for (const target of candidates) {
+        if (!validTargetForWeapon(spec.type, target.category)) continue
+
+        const dist = haversine(unit.position, target.position)
+        if (dist > spec.range_km) continue
+
+        if (unit.roe === 'weapons_tight' && !isSelfDefense(state, unit, target)) continue
+
+        // Nation-level overkill guard — don't have every ship dump at the same contact
+        const salvoKey = `${unit.nation}:${target.id}`
+        const lastSalvo = lastTargetSalvoTick.get(salvoKey) ?? -TARGET_REENGAGE_TICKS
+        if (tick - lastSalvo < TARGET_REENGAGE_TICKS) continue
+
+        const quality = getFireControlQuality(state, unit, target, grid ?? null)
+        if (!quality) continue
+
+        const salvoSize = Math.min(loadout.count, salvoSizeFor(target.category))
+        for (let i = 0; i < salvoSize; i++) {
+          commands.push({
+            type: 'LAUNCH_MISSILE',
+            launcherId: unit.id,
+            weaponId: loadout.weaponId,
+            targetId: target.id,
+            trackQuality: quality,
+          })
+        }
+
+        state.events.push({
+          type: 'AUTO_ENGAGEMENT',
+          unitId: unit.id,
           targetId: target.id,
+          weaponName: spec.name,
+          count: salvoSize,
+          quality,
+          tick,
         })
-      }
+        state.pendingEvents.push(state.events[state.events.length - 1])
 
-      lastFireTick.set(unit.id, state.time.tick)
-      fired = true
+        lastFireTick.set(unit.id, tick)
+        lastTargetSalvoTick.set(salvoKey, tick)
+        fired = true
+        break
+      }
     }
   }
 
   return commands
 }
+
+/** weapons_tight: only engage targets near the unit itself or a nearby friendly */
+function isSelfDefense(state: GameState, unit: Unit, target: Unit): boolean {
+  if (haversine(unit.position, target.position) <= SELF_DEFENSE_RADIUS_KM) return true
+  for (const friendly of state.units.values()) {
+    if (friendly.nation !== unit.nation || friendly.status === 'destroyed') continue
+    if (haversine(friendly.position, target.position) <= SELF_DEFENSE_RADIUS_KM &&
+        haversine(unit.position, friendly.position) <= SELF_DEFENSE_RADIUS_KM * 2) {
+      return true
+    }
+  }
+  return false
+}
diff --git a/src/engine/systems/intel.ts b/src/engine/systems/intel.ts
new file mode 100644
index 0000000..b98962f
--- /dev/null
+++ b/src/engine/systems/intel.ts
@@ -0,0 +1,637 @@
+import type {
+  GameEvent,
+  GameState,
+  IntelProduct,
+  IntelState,
+  InterceptPrecedence,
+  NationId,
+  Position,
+  Unit,
+} from '@/types/game'
+import type { ElevationGrid } from './elevation'
+import type { SeededRNG } from '../utils/rng'
+import { buildIntelAssets, HORMUZ_OSINT_BOX, PASS_SWATH_KM } from '@/data/intel/assets'
+import { buildAgentRoster, AGENT_COVERAGE, AGENT_PASSIVE_INTERVAL_MIN } from '@/data/intel/agents'
+import { revealContact } from './visibility'
+import { getNextSalvoEstimate } from './ai'
+import { haversine, destination } from '../utils/geo'
+
+/**
+ * Intel suite v3 — ISR tasking, SIGINT intercepts, HUMINT sources, counterintel.
+ * Design: docs/plans/intel-suite-v3.md. All state lives in state.intel (plain
+ * data → saves/loads for free). Heavy evaluation runs once per game-minute.
+ */
+
+const MINUTE = 60
+const HOUR = 3600
+
+const INTERCEPT_INTERVAL_TICKS = 20 * MINUTE
+const SWEEP_INTERVAL_TICKS = 4 * HOUR
+const SWEEP_PARANOIA_THRESHOLD = 50
+const ENCRYPTION_PARANOIA_THRESHOLD = 70
+const ENCRYPTION_BLACKOUT_TICKS = 6 * HOUR
+const AGENT_TASK_COOLDOWN_TICKS = 1 * HOUR
+const EXFIL_DURATION_TICKS = 6 * HOUR
+const OPSEC_SWEEP_COOLDOWN_TICKS = 6 * HOUR
+const CLOUD_FAIL_THRESHOLD = 70
+const DECOY_COUNT = 4
+const PRODUCT_CAP = 30
+const GULF_PATROL_BOX = { south: 23.5, west: 47.5, north: 30.5, east: 59.5 }
+
+export function initIntelState(state: GameState): void {
+  state.intel = {
+    assets: buildIntelAssets(),
+    agents: buildAgentRoster(),
+    products: [],
+    taskings: [],
+    paranoia: 10,
+    leakLevel: 25,
+    productCounter: 0,
+  }
+}
+
+/** No module-level state — everything lives in state.intel. Kept for reset symmetry. */
+export function resetIntelState(): void {}
+
+// ---------------------------------------------------------------------------
+// Tick processing
+// ---------------------------------------------------------------------------
+
+export function processIntel(state: GameState, rng: SeededRNG, grid: ElevationGrid | null): void {
+  const intel = state.intel
+  if (!intel) return
+  const tick = state.time.tick
+
+  // SBIRS FLASH cards ride on this tick's launch events (always-on OPIR)
+  emitLaunchDetectionCards(state, intel)
+
+  if (tick % MINUTE !== 0) return
+
+  resolveSatelliteTaskings(state, intel, rng)
+  generateIntercept(state, intel, rng)
+  runAgentClock(state, intel, rng)
+  runCounterintel(state, intel, rng)
+  runWideAreaSensors(state, intel)
+  spawnDecoysAtWar(state, intel, rng, grid)
+}
+
+// ---------------------------------------------------------------------------
+// Satellite tasking (design §1.2)
+// ---------------------------------------------------------------------------
+
+export function taskSatellitePass(
+  state: GameState,
+  assetId: string,
+  target: Position,
+  cloudPct?: number,
+): void {
+  const intel = state.intel
+  if (!intel) return
+  const asset = intel.assets[assetId]
+  if (!asset || asset.status !== 'active' || asset.kind === 'sigint_air') return
+
+  // One queued tasking per asset — re-tasking replaces it
+  intel.taskings = intel.taskings.filter(t => t.assetId !== assetId)
+  intel.taskings.push({
+    id: `task_${(intel.productCounter = (intel.productCounter ?? 0) + 1)}`,
+    assetId,
+    target: { ...target },
+    queuedTick: state.time.tick,
+    cloudPct,
+  })
+}
+
+function resolveSatelliteTaskings(state: GameState, intel: IntelState, rng: SeededRNG): void {
+  const tick = state.time.tick
+  const done: string[] = []
+
+  for (const tasking of intel.taskings) {
+    const asset = intel.assets[tasking.assetId]
+    if (!asset || asset.status !== 'active') {
+      done.push(tasking.id)
+      continue
+    }
+    const revisitTicks = asset.revisit_min * MINUTE
+    if (tick - asset.lastCollectionTick < revisitTicks) continue
+
+    asset.lastCollectionTick = tick
+    done.push(tasking.id)
+
+    const cloudPct = tasking.cloudPct ?? rng.int(0, 100)
+    if (cloudPct >= CLOUD_FAIL_THRESHOLD) {
+      // Failed pass: cheap retry — half the revisit clock
+      asset.lastCollectionTick = tick - Math.floor(revisitTicks / 2)
+      emit(state, {
+        type: 'SATELLITE_PASS_FAILED',
+        assetId: asset.id,
+        target: tasking.target,
+        cloudPct,
+        tick,
+      })
+      continue
+    }
+
+    // Sweep the footprint
+    let found = 0
+    let revealedDecoys = 0
+    const byCategory = new Map<string, number>()
+    for (const unit of state.units.values()) {
+      if (unit.nation === asset.nation || unit.status === 'destroyed') continue
+      if (haversine(unit.position, tasking.target) > PASS_SWATH_KM) continue
+
+      const existing = state.visibility?.[asset.nation as string]?.[unit.id]
+      const level =
+        unit.category === 'airbase' || unit.category === 'naval_base' ||
+        existing?.level === 'tracked' || existing?.level === 'identified'
+          ? 'identified'
+          : 'tracked'
+      revealContact(state, asset.nation as string, unit, level)
+      found++
+      byCategory.set(unit.category, (byCategory.get(unit.category) ?? 0) + 1)
+
+      if (unit.isDecoy && !unit.decoyRevealed && (asset.niirs ?? 0) >= 7) {
+        unit.decoyRevealed = true
+        revealedDecoys++
+        emit(state, { type: 'DECOY_REVEALED', unitId: unit.id, tick })
+      }
+    }
+
+    pushProduct(intel, {
+      kind: 'imint',
+      tick,
+      assetId: asset.id,
+      target: tasking.target,
+      niirs: asset.niirs,
+      classification: asset.kind === 'commercial_sat' ? 'UNCLASSIFIED//COMMERCIAL' : 'TOP SECRET//TK//NOFORN',
+      caption: imintCaption(byCategory, revealedDecoys),
+    })
+
+    emit(state, {
+      type: 'SATELLITE_PASS_COMPLETE',
+      assetId: asset.id,
+      target: tasking.target,
+      found,
+      revealedDecoys,
+      tick,
+    })
+
+    if (asset.nation === 'usa') {
+      intel.paranoia = clamp(intel.paranoia + (asset.kind === 'commercial_sat' ? 2 : 4))
+    }
+  }
+
+  if (done.length > 0) {
+    intel.taskings = intel.taskings.filter(t => !done.includes(t.id))
+  }
+}
+
+function imintCaption(byCategory: Map<string, number>, revealedDecoys: number): string {
+  if (byCategory.size === 0) return 'No significant activity observed in AOI.'
+  const labels: Record<string, string> = {
+    missile_battery: 'probable TEL group',
+    sam_site: 'SAM emitter site',
+    ship: 'surface combatant',
+    carrier_group: 'capital surface group',
+    submarine: 'submarine (surfaced)',
+    airbase: 'air operations facility',
+    naval_base: 'naval facility',
+    aircraft: 'aircraft on apron',
+    minefield: 'suspected mine line',
+  }
+  const parts = Array.from(byCategory.entries()).map(([cat, n]) => `${n}× ${labels[cat] ?? cat}`)
+  const decoyNote = revealedDecoys > 0 ? `; ${revealedDecoys}× assessed DECOY (no thermal signature)` : ''
+  return parts.join(', ') + decoyNote + '.'
+}
+
+// ---------------------------------------------------------------------------
+// SIGINT (design §1.3)
+// ---------------------------------------------------------------------------
+
+const ROUTINE_CHATTER = [
+  'Logistics net: fuel convoy scheduling between Shiraz and coastal sites.',
+  'IRGCN harbor net: routine patrol rotation, nothing significant.',
+  'Air-defense net: calibration chatter, sectors quiet.',
+  'Provincial command net: leave rotations and ration complaints.',
+]
+
+function generateIntercept(state: GameState, intel: IntelState, rng: SeededRNG): void {
+  const tick = state.time.tick
+  const rc135 = intel.assets['rc135']
+  if (!rc135 || rc135.status !== 'active') return
+  if ((intel.encryptionUpgradedUntilTick ?? 0) > tick) return
+
+  const sigintPct = state.nations['usa']?.intelBudget?.sigint_pct ?? 30
+  const interval = Math.round(INTERCEPT_INTERVAL_TICKS * (1.5 - sigintPct / 100))
+  if (tick - (intel.lastIntInterceptTick ?? -interval) < interval) return
+  intel.lastIntInterceptTick = tick
+
+  let precedence: InterceptPrecedence = 'ROUTINE'
+  let text = ROUTINE_CHATTER[rng.int(0, ROUTINE_CHATTER.length - 1)]
+  let aboutUnitId: string | undefined
+
+  const salvoTick = getNextSalvoEstimate('iran')
+  const iranSupport = state.warStatus?.['iran']?.warSupport
+
+  if (salvoTick !== null && salvoTick - tick <= 30 * MINUTE && salvoTick >= tick) {
+    precedence = 'FLASH'
+    text = 'Missile brigade ordered to combat readiness — expect fires against US installations within the hour.'
+  } else {
+    const hidden = findHiddenEmitter(state)
+    if (hidden) {
+      precedence = 'IMMEDIATE'
+      aboutUnitId = hidden.id
+      revealContact(state, 'usa', hidden, 'detected')
+      text = `Geolocated C2 transmission: ${hidden.category === 'sam_site' ? 'air-defense battery' : 'missile unit'} operating vicinity ${hidden.position.lat.toFixed(1)}N ${hidden.position.lng.toFixed(1)}E.`
+    } else if (iranSupport !== undefined && iranSupport < 45) {
+      precedence = 'PRIORITY'
+      text = 'Leadership net: cohesion failing — open argument over continuing the war.'
+    }
+  }
+
+  emit(state, { type: 'INTERCEPT_DECRYPTED', precedence, text, aboutUnitId, tick })
+  pushProduct(intel, {
+    kind: 'sigint',
+    tick,
+    precedence,
+    classification: 'TOP SECRET//SI',
+    caption: text,
+  })
+  intel.paranoia = clamp(intel.paranoia + 2)
+}
+
+function findHiddenEmitter(state: GameState): Unit | null {
+  for (const unit of state.units.values()) {
+    if (unit.nation !== 'iran' || unit.status === 'destroyed') continue
+    if (unit.category !== 'missile_battery' && unit.category !== 'sam_site') continue
+    const contact = state.visibility?.['usa']?.[unit.id]
+    if (!contact || contact.level === 'unseen') return unit
+  }
+  return null
+}
+
+/** SBIRS: every Iranian launch this tick gets a FLASH OPIR card (cheap flavor + product) */
+function emitLaunchDetectionCards(state: GameState, intel: IntelState): void {
+  const tick = state.time.tick
+  const sbirs = intel.assets['sbirs']
+  if (!sbirs || sbirs.status !== 'active') return
+  for (let i = state.events.length - 1; i >= 0; i--) {
+    const e = state.events[i]
+    if (e.tick !== tick) break
+    if (e.type !== 'MISSILE_LAUNCHED') continue
+    const launcher = state.units.get(e.launcherId)
+    if (!launcher || launcher.nation !== 'iran') continue
+    pushProduct(intel, {
+      kind: 'sigint',
+      tick,
+      precedence: 'FLASH',
+      classification: 'TOP SECRET//TK',
+      caption: `OPIR LAUNCH DETECTION: booster plume ${launcher.position.lat.toFixed(2)}N ${launcher.position.lng.toFixed(2)}E — ${e.weaponName}. Launch point passed to targeting.`,
+    })
+  }
+}
+
+// ---------------------------------------------------------------------------
+// HUMINT (design §1.4)
+// ---------------------------------------------------------------------------
+
+export function taskAgent(state: GameState, _rng: SeededRNG, agentId: string): void {
+  const intel = state.intel
+  if (!intel) return
+  const agent = intel.agents[agentId]
+  if (!agent) return
+  if (agent.status === 'arrested' || agent.status === 'exfiltrated' || agent.status === 'exfiltrating') return
+  const tick = state.time.tick
+  if (tick - agent.lastTaskedTick < AGENT_TASK_COOLDOWN_TICKS) return
+
+  agent.status = 'active'
+  agent.lastTaskedTick = tick
+  agent.exposure = clamp(agent.exposure + 15 + intel.paranoia / 5)
+  intel.paranoia = clamp(intel.paranoia + 1)
+
+  let text = ''
+  switch (agent.id) {
+    case 'amber': {
+      const n = revealBox(state, 'usa', AGENT_COVERAGE['amber'], 'tracked', ['ship', 'submarine'])
+      text = n > 0
+        ? `Port movement log copied: ${n} hulls active in the Bandar Abbas–Jask complex. Berths and sortie states attached.`
+        : 'Port quiet — no significant sorties on the log.'
+      break
+    }
+    case 'opal': {
+      let revealed = 0
+      let decoys = 0
+      for (const unit of state.units.values()) {
+        if (revealed >= 2) break
+        if (unit.nation !== 'iran' || unit.status === 'destroyed') continue
+        if (unit.category !== 'missile_battery') continue
+        const contact = state.visibility?.['usa']?.[unit.id]
+        if (contact && (contact.level === 'tracked' || contact.level === 'identified')) continue
+        if (unit.isDecoy) {
+          if (!unit.decoyRevealed) {
+            unit.decoyRevealed = true
+            decoys++
+            emit(state, { type: 'DECOY_REVEALED', unitId: unit.id, tick })
+          }
+          continue
+        }
+        revealContact(state, 'usa', unit, 'identified')
+        revealed++
+      }
+      text = revealed > 0
+        ? `Dispersal annex photographed: ${revealed} launcher group(s) located with grid coordinates.`
+        : 'No new launcher movement in the annex this cycle.'
+      if (decoys > 0) text += ` Flags ${decoys} site(s) as inflatable decoys.`
+      break
+    }
+    case 'saffron': {
+      const support = state.warStatus?.['iran']?.warSupport
+      const offered = state.warStatus?.['iran']?.ceasefireOffered
+      text = support !== undefined
+        ? `Cabinet read: war support at ${Math.round(support)}%. ${offered ? 'Ceasefire feelers ALREADY authorized.' : support < 45 ? 'Ceasefire faction gaining ground.' : 'Leadership committed to continuing.'}`
+        : 'Cabinet read: leadership posture stable, no war council convened.'
+      break
+    }
+    case 'garnet': {
+      const n = revealBox(state, 'usa', AGENT_COVERAGE['garnet'], 'tracked', ['ship', 'submarine'])
+      text = n > 0
+        ? `Strait watch: ${n} contacts logged transiting the narrows, photos timestamped.`
+        : 'Strait watch: channel quiet this cycle.'
+      break
+    }
+  }
+
+  emit(state, { type: 'AGENT_REPORT', agentId: agent.id, codename: agent.codename, text, tick })
+  pushProduct(intel, {
+    kind: 'humint',
+    tick,
+    agentId: agent.id,
+    classification: 'SECRET//HCS',
+    caption: `${agent.codename}: ${text}`,
+  })
+}
+
+export function restAgent(state: GameState, agentId: string): void {
+  const agent = state.intel?.agents[agentId]
+  if (!agent) return
+  if (agent.status === 'active') agent.status = 'resting'
+}
+
+export function exfiltrateAgent(state: GameState, agentId: string): void {
+  const agent = state.intel?.agents[agentId]
+  if (!agent) return
+  if (agent.status !== 'active' && agent.status !== 'resting') return
+  agent.status = 'exfiltrating'
+  agent.exfilCompleteTick = state.time.tick + EXFIL_DURATION_TICKS
+}
+
+function runAgentClock(state: GameState, intel: IntelState, _rng: SeededRNG): void {
+  const tick = state.time.tick
+
+  for (const agent of Object.values(intel.agents)) {
+    // Exfil completion
+    if (agent.status === 'exfiltrating' && (agent.exfilCompleteTick ?? 0) <= tick) {
+      agent.status = 'exfiltrated'
+      emit(state, { type: 'AGENT_EXFILTRATED', agentId: agent.id, codename: agent.codename, tick })
+    }
+    // Resting exposure decay (1 per game-hour)
+    if (agent.status === 'resting' && tick % HOUR === 0) {
+      agent.exposure = Math.max(0, agent.exposure - 1)
+    }
+  }
+
+  // Passive coverage: AMBER + GARNET keep a coarse eye on their boxes
+  if (tick % (AGENT_PASSIVE_INTERVAL_MIN * MINUTE) === 0) {
+    for (const id of ['amber', 'garnet'] as const) {
+      const agent = intel.agents[id]
+      if (agent?.status === 'active') {
+        revealBox(state, 'usa', AGENT_COVERAGE[id], 'detected', ['ship', 'submarine'])
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Counterintel — Iranian sweeps, encryption, the player's leak level (design §1.5)
+// ---------------------------------------------------------------------------
+
+function runCounterintel(state: GameState, intel: IntelState, rng: SeededRNG): void {
+  const tick = state.time.tick
+  const atWar = (state.nations['iran']?.atWar.length ?? 0) > 0
+
+  // Encryption upgrade at high paranoia (war only)
+  if (atWar && intel.paranoia >= ENCRYPTION_PARANOIA_THRESHOLD && (intel.encryptionUpgradedUntilTick ?? 0) <= tick) {
+    intel.encryptionUpgradedUntilTick = tick + ENCRYPTION_BLACKOUT_TICKS
+    intel.paranoia = 40
+    emit(state, { type: 'ENCRYPTION_UPGRADED', untilTick: intel.encryptionUpgradedUntilTick, tick })
+  }
+
+  // Spy sweeps
+  if (intel.paranoia >= SWEEP_PARANOIA_THRESHOLD && tick - (intel.lastSweepTick ?? -SWEEP_INTERVAL_TICKS) >= SWEEP_INTERVAL_TICKS) {
+    intel.lastSweepTick = tick
+    let arrests = 0
+    for (const agent of Object.values(intel.agents)) {
+      if (agent.status !== 'active' && agent.status !== 'resting' && agent.status !== 'exfiltrating') continue
+      let chance = agent.exposure / 200 + intel.paranoia / 400
+      if (agent.status === 'exfiltrating') chance /= 2
+      if (rng.chance(chance)) {
+        agent.status = 'arrested'
+        arrests++
+        intel.leakLevel = clamp(intel.leakLevel + 10)
+        adjustWarSupport(state, 'usa', -3)
+        adjustWarSupport(state, 'iran', +2)
+        emit(state, { type: 'AGENT_ARRESTED', agentId: agent.id, codename: agent.codename, tick })
+      }
+    }
+    emit(state, { type: 'SPY_SWEEP', arrests, tick })
+  }
+
+  // Leak level drift
+  if (tick % HOUR === 0) {
+    const carrier = findPlayerCarrier(state)
+    if (carrier && inBox(carrier.position, HORMUZ_OSINT_BOX)) {
+      intel.leakLevel = clamp(intel.leakLevel + 1)
+    } else if (tick % (2 * HOUR) === 0) {
+      intel.leakLevel = Math.max(10, intel.leakLevel - 1)
+    }
+  }
+}
+
+/** Player strike → possible Iranian foreknowledge. Roll once per launch command. */
+export function maybeLeakStrike(state: GameState, rng: SeededRNG, targetId: string): boolean {
+  const intel = state.intel
+  if (!intel || intel.leakLevel < 60) return false
+  if (!rng.chance(intel.leakLevel / 200)) return false
+
+  const tick = state.time.tick
+  intel.paranoia = clamp(intel.paranoia + 2)
+  emit(state, { type: 'STRIKE_LEAKED', targetId, tick })
+
+  // Mobile land targets scoot — the contact the player fired on goes stale
+  const target = state.units.get(targetId)
+  if (target && target.status !== 'destroyed' &&
+      (target.category === 'missile_battery' || target.category === 'sam_site') &&
+      target.maxSpeed_kts > 0) {
+    const brng = rng.int(0, 359)
+    target.position = destination(target.position, brng, 15)
+    const contact = state.visibility?.['usa']?.[targetId]
+    if (contact) contact.level = 'detected'
+  }
+  return true
+}
+
+export function opsecSweep(state: GameState): void {
+  const intel = state.intel
+  if (!intel) return
+  const tick = state.time.tick
+  if (tick - (intel.lastOpsecSweepTick ?? -OPSEC_SWEEP_COOLDOWN_TICKS) < OPSEC_SWEEP_COOLDOWN_TICKS) return
+  intel.lastOpsecSweepTick = tick
+  intel.leakLevel = Math.max(10, intel.leakLevel - 25)
+  emit(state, { type: 'OPSEC_SWEEP_COMPLETE', newLeakLevel: intel.leakLevel, tick })
+}
+
+// ---------------------------------------------------------------------------
+// Wide-area sensors + Iran's coarse carrier picture (design §1.1, §1.5)
+// ---------------------------------------------------------------------------
+
+function runWideAreaSensors(state: GameState, intel: IntelState): void {
+  const tick = state.time.tick
+
+  // MQ-4C Triton: coarse maritime sweep of the Gulf box
+  const triton = intel.assets['mq4c']
+  if (triton?.status === 'active' && tick - triton.lastCollectionTick >= triton.revisit_min * MINUTE) {
+    triton.lastCollectionTick = tick
+    revealBox(state, 'usa', GULF_PATROL_BOX, 'detected', ['ship', 'submarine', 'carrier_group'])
+  }
+
+  // Iran's eyes on the carrier: picket boats (detected) / Mohajer-10 (tracked)
+  if (tick - (intel.lastCarrierOsintTick ?? 0) >= 30 * MINUTE) {
+    intel.lastCarrierOsintTick = tick
+    const carrier = findPlayerCarrier(state)
+    if (carrier && inBox(carrier.position, HORMUZ_OSINT_BOX)) {
+      const mohajer = intel.assets['mohajer10']
+      const level = (mohajer?.status === 'active' || intel.leakLevel >= 60) ? 'tracked' : 'detected'
+      revealContact(state, 'iran', carrier, level)
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Decoys (design §1.7)
+// ---------------------------------------------------------------------------
+
+function spawnDecoysAtWar(state: GameState, intel: IntelState, rng: SeededRNG, grid: ElevationGrid | null): void {
+  if (intel.decoysSpawned) return
+  if ((state.nations['iran']?.atWar.length ?? 0) === 0) return
+  intel.decoysSpawned = true
+
+  const batteries = Array.from(state.units.values()).filter(
+    u => u.nation === 'iran' && u.category === 'missile_battery' && u.status !== 'destroyed' && !u.isDecoy,
+  )
+  if (batteries.length === 0) return
+
+  for (let i = 0; i < DECOY_COUNT; i++) {
+    const anchor = batteries[rng.int(0, batteries.length - 1)]
+    let pos: Position | null = null
+    for (let attempt = 0; attempt < 8; attempt++) {
+      const candidate = destination(anchor.position, rng.int(0, 359), 5 + rng.int(0, 10))
+      if (!grid || !grid.isWater(candidate.lat, candidate.lng)) {
+        pos = candidate
+        break
+      }
+    }
+    if (!pos) continue
+
+    const decoy: Unit = {
+      id: `decoy_${i + 1}`,
+      name: 'Missile TEL group',
+      nation: 'iran',
+      category: 'missile_battery',
+      position: pos,
+      heading: rng.int(0, 359),
+      speed_kts: 0,
+      maxSpeed_kts: 30,
+      status: 'ready',
+      health: 40,
+      maxHealth: 40,
+      hardness: 80,
+      logistics: 0,
+      supplyStocks: [],
+      weapons: [],
+      pointDefense: [],
+      sensors: [],
+      waypoints: [],
+      roe: 'hold_fire',
+      subordinateIds: [],
+      isDecoy: true,
+    }
+    state.units.set(decoy.id, decoy)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Snapshot helper
+// ---------------------------------------------------------------------------
+
+export function paranoiaBand(paranoia: number): 'LOW' | 'ELEVATED' | 'HIGH' | 'SEVERE' {
+  if (paranoia < 30) return 'LOW'
+  if (paranoia < 55) return 'ELEVATED'
+  if (paranoia < 75) return 'HIGH'
+  return 'SEVERE'
+}
+
+// ---------------------------------------------------------------------------
+// Internals
+// ---------------------------------------------------------------------------
+
+function revealBox(
+  state: GameState,
+  observer: NationId,
+  box: { south: number; west: number; north: number; east: number },
+  level: 'detected' | 'tracked' | 'identified',
+  categories: string[],
+): number {
+  let n = 0
+  for (const unit of state.units.values()) {
+    if (unit.nation === observer || unit.status === 'destroyed') continue
+    if (!categories.includes(unit.category)) continue
+    if (!inBox(unit.position, box)) continue
+    revealContact(state, observer as string, unit, level)
+    n++
+  }
+  return n
+}
+
+function inBox(p: Position, box: { south: number; west: number; north: number; east: number }): boolean {
+  return p.lat >= box.south && p.lat <= box.north && p.lng >= box.west && p.lng <= box.east
+}
+
+function findPlayerCarrier(state: GameState): Unit | null {
+  for (const unit of state.units.values()) {
+    if (unit.nation === state.playerNation && unit.category === 'carrier_group' && unit.status !== 'destroyed') {
+      return unit
+    }
+  }
+  return null
+}
+
+function pushProduct(intel: IntelState, p: Omit<IntelProduct, 'id'>): void {
+  intel.productCounter = (intel.productCounter ?? 0) + 1
+  intel.products.unshift({ ...p, id: `prod_${intel.productCounter}` })
+  if (intel.products.length > PRODUCT_CAP) intel.products.length = PRODUCT_CAP
+}
+
+function adjustWarSupport(state: GameState, nation: NationId, delta: number): void {
+  if (state.gameOver) return
+  const ws = state.warStatus?.[nation]
+  if (ws) ws.warSupport = Math.max(0, Math.min(100, ws.warSupport + delta))
+}
+
+function clamp(v: number): number {
+  return Math.max(0, Math.min(100, v))
+}
+
+function emit(state: GameState, event: GameEvent): void {
+  state.events.push(event)
+  if (state.events.length > 2000) state.events.splice(0, state.events.length - 2000)
+  state.pendingEvents.push(event)
+}
diff --git a/src/engine/systems/movement.ts b/src/engine/systems/movement.ts
index 3f7360e..c3762a6 100644
--- a/src/engine/systems/movement.ts
+++ b/src/engine/systems/movement.ts
@@ -67,9 +67,18 @@ export function processMovement(state: GameState, elevationGrid?: ElevationGrid
           continue
         }
         if (!isNaval && nextIsWater) {
-          // Land unit hitting water — skip this waypoint
-          unit.waypoints.shift()
-          if (unit.waypoints.length === 0) finishMovement(unit)
+          // Land unit hitting water — halt and tell the player instead of silently
+          // skipping waypoints (which read as "my order vanished")
+          unit.waypoints = []
+          finishMovement(unit)
+          const event = {
+            type: 'ORDER_REJECTED' as const,
+            unitId: unit.id,
+            reason: 'route blocked by water',
+            tick: state.time.tick,
+          }
+          state.events.push(event)
+          state.pendingEvents.push(event)
           continue
         }
       }
@@ -113,7 +122,21 @@ export function processMovement(state: GameState, elevationGrid?: ElevationGrid
       const clearance = 50 // meters above terrain
       const cruiseAltM = (spec?.flight_altitude_ft ?? 200) * 0.3048 // ft to meters
 
-      const requiredAlt = Math.max(cruiseAltM, terrainElev + clearance)
+      // Look ahead along the heading so climbs start BEFORE a ridge face — sampling
+      // only the current cell made missiles fly into steep walls and teleport up
+      let maxTerrainAhead = terrainElev
+      if (missile.path.length >= 2) {
+        const prev = missile.path[missile.path.length - 2]
+        const last = missile.path[missile.path.length - 1]
+        const hdg = bearing({ lat: prev[1], lng: prev[0] }, { lat: last[1], lng: last[0] })
+        for (const aheadKm of [2, 5, 8]) {
+          const p = destination({ lat: curPos[1], lng: curPos[0] }, hdg, aheadKm)
+          const t = elevationGrid.getElevation(p.lat, p.lng)
+          if (t > maxTerrainAhead) maxTerrainAhead = t
+        }
+      }
+
+      const requiredAlt = Math.max(cruiseAltM, maxTerrainAhead + clearance)
 
       if (missile.altitude_m < requiredAlt) {
         // Terrain-following climb — cruise missiles can climb rapidly (up to 150m/s)
diff --git a/src/engine/systems/sensor-network.ts b/src/engine/systems/sensor-network.ts
index b9bb3c6..a69b279 100644
--- a/src/engine/systems/sensor-network.ts
+++ b/src/engine/systems/sensor-network.ts
@@ -1,6 +1,6 @@
 import type { GameState, Missile, NationId, UnitId, Unit } from '@/types/game'
 import type { ElevationGrid } from './elevation'
-import { detectThreats, type DetectedThreat } from './detection'
+import { detectThreats, elevationRangeBonus, type DetectedThreat } from './detection'
 import { haversine } from '../utils/geo'
 
 // ---------------------------------------------------------------------------
@@ -23,6 +23,8 @@ export interface SensorNetwork {
   sharedDetections: Map<NationId, Map<string, NetworkDetection>>
   /** nation → set of enemy unit IDs detected via ELINT (radar emission interception) */
   elintDetections: Map<NationId, Set<UnitId>>
+  /** unit → its own local detections from step 3 (only units that detected something) */
+  localDetections: Map<UnitId, DetectedThreat[]>
 }
 
 // ---------------------------------------------------------------------------
@@ -34,7 +36,8 @@ export interface SensorNetwork {
  *
  * 1. Find all hubs (units with datalink_range_km > 0, not destroyed)
  * 2. Connect each sensor-capable unit to hubs within datalink range (same nation)
- * 3. Run detectThreats() for each radar unit → local detections
+ * 3. Run detectThreats() for each radar unit → local detections, stashed on the
+ *    network so detectThreatsNetworked doesn't recompute them
  * 4. Propagate detections to the hubs each detector is connected to, then union
  *    every hub's picture into a per-nation common picture. Quality is resolved
  *    per receiving unit at query time (detectThreatsNetworked).
@@ -149,11 +152,15 @@ export function buildSensorNetwork(
     for (const enemy of state.units.values()) {
       if (enemy.status === 'destroyed') continue
       if (enemy.nation === unit.nation) continue // same nation — skip
+      if (enemy.emcon) continue // radar silent — no emissions to intercept
 
       // Check each enemy radar sensor
       for (const sensor of enemy.sensors) {
         if (sensor.type !== 'radar') continue
-        const elintRange = sensor.range_km * 1.5 // emissions detectable at 1.5x radar range
+        // Emissions detectable at 1.5x radar range; elevated emitters shine further
+        const emitterElev = grid?.getElevation(enemy.position.lat, enemy.position.lng) ?? 0
+        const elintRange = sensor.range_km * 1.5 *
+          elevationRangeBonus(emitterElev + (sensor.antenna_height_m ?? 15))
         const dist = haversine(unit.position, enemy.position)
         if (dist <= elintRange) {
           // Add enemy unit to ELINT detections for detecting unit's nation
@@ -169,7 +176,7 @@ export function buildSensorNetwork(
     }
   }
 
-  return { connections, hubDetections, sharedDetections, elintDetections }
+  return { connections, hubDetections, sharedDetections, elintDetections, localDetections }
 }
 
 // ---------------------------------------------------------------------------
@@ -197,8 +204,12 @@ export function detectThreatsNetworked(
   const resultMap = new Map<string, NetworkedThreat>()
 
   // --- Own local detections (highest priority) ---
-  const ownThreats = detectThreats(state, adUnit, grid)
+  // Reuse the picture computed in buildSensorNetwork; absent (nothing detected,
+  // or EMCON flipped mid-tick) → fresh call
+  const ownThreats = network.localDetections.get(adUnit.id) ?? detectThreats(state, adUnit, grid)
   for (const threat of ownThreats) {
+    // The stash is a tick-start snapshot — drop missiles resolved since (fuel expiry)
+    if (threat.missile.status !== 'inflight') continue
     resultMap.set(threat.missile.id, {
       ...threat,
       networkQuality: 'own',
@@ -255,3 +266,18 @@ export function isDetectedByELINT(
 ): boolean {
   return network.elintDetections.get(nation)?.has(unitId) ?? false
 }
+
+// ---------------------------------------------------------------------------
+// Datalink connectivity — can this unit receive fire-quality tracks from the net?
+// ---------------------------------------------------------------------------
+
+/** A unit is on the datalink if it is a hub itself or within range of any friendly hub */
+export function isDatalinkConnected(state: GameState, unit: Unit): boolean {
+  if (unit.datalink_range_km && unit.datalink_range_km > 0) return true
+  for (const hub of state.units.values()) {
+    if (hub.nation !== unit.nation || hub.status === 'destroyed') continue
+    if (!hub.datalink_range_km || hub.datalink_range_km <= 0) continue
+    if (haversine(unit.position, hub.position) <= hub.datalink_range_km) return true
+  }
+  return false
+}
diff --git a/src/engine/systems/strike-scheduler.ts b/src/engine/systems/strike-scheduler.ts
new file mode 100644
index 0000000..f663c35
--- /dev/null
+++ b/src/engine/systems/strike-scheduler.ts
@@ -0,0 +1,55 @@
+import type { GameState, ScheduledLaunch, TrackQuality } from '@/types/game'
+import type { Command } from '@/types/commands'
+
+type LaunchSalvoCommand = Extract<Command, { type: 'LAUNCH_SALVO' }>
+
+/**
+ * Queue every round of a delayed salvo (LAUNCH_SALVO with delayTicks > 0) —
+ * the TOT path. Unlike the spacing-only path NOTHING fires at command time:
+ * war declaration and launch events happen when each round's dueTick arrives
+ * (fireScheduledLaunch declares war on the first successful round). The leak
+ * roll already happened at command time; rounds reuse its result.
+ */
+export function scheduleSalvo(
+  state: GameState,
+  cmd: LaunchSalvoCommand,
+  compromised: boolean,
+  trackQuality?: TrackQuality,
+): void {
+  if (cmd.count <= 0) return
+  // A dueTick in the past would fire the backlog all at once next tick
+  const delay = Math.max(1, cmd.delayTicks ?? 1)
+  const spacing = cmd.spacingTicks ?? 0
+  state.scheduledLaunches ??= []
+  for (let i = 0; i < cmd.count; i++) {
+    state.scheduledLaunches.push({
+      dueTick: state.time.tick + delay + i * spacing,
+      launcherId: cmd.launcherId,
+      weaponId: cmd.weaponId,
+      targetId: cmd.targetId,
+      waypoints: cmd.waypoints,
+      trackQuality,
+      compromised,
+    })
+  }
+}
+
+/**
+ * Fires salvo rounds whose dueTick has arrived. Runs inside tick(), so a paused
+ * game (speed 0 — the loop never ticks) cannot fire scheduled rounds. All state
+ * lives on GameState, so save/load and scenario init need no extra plumbing.
+ */
+export function processScheduledLaunches(
+  state: GameState,
+  launchFn: (entry: ScheduledLaunch) => void,
+): void {
+  const pending = state.scheduledLaunches
+  if (!pending || pending.length === 0) return
+
+  const tick = state.time.tick
+  const due = pending.filter((e) => e.dueTick <= tick)
+  if (due.length === 0) return
+
+  state.scheduledLaunches = pending.filter((e) => e.dueTick > tick)
+  for (const entry of due) launchFn(entry)
+}
diff --git a/src/engine/systems/visibility.ts b/src/engine/systems/visibility.ts
index e1cdfe2..a35c3a0 100644
--- a/src/engine/systems/visibility.ts
+++ b/src/engine/systems/visibility.ts
@@ -3,6 +3,7 @@ import type {
   Nation,
   NationId,
   Position,
+  TrackQuality,
   Unit,
   UnitCategory,
   UnitId,
@@ -12,9 +13,10 @@ import type {
 import type { ElevationGrid } from './elevation'
 import type { SensorNetwork } from './sensor-network'
 import type { EspionageResult } from './espionage'
-import { hasLineOfSight } from './detection'
+import { hasLineOfSight, elevationRangeBonus, targetProminenceBonus } from './detection'
+import { isDatalinkConnected } from './sensor-network'
 import { getSatelliteDetections, pointToLineDistKm, DETECTION_FADE_TICKS } from './satellites'
-import { haversine } from '../utils/geo'
+import { haversine, bearing } from '../utils/geo'
 
 /**
  * Fog of war. Maintains state.visibility — per observing nation, a contact map over
@@ -34,6 +36,22 @@ const DEFAULT_SIGINT_MULTIPLIER = 1.5
 const DEFAULT_ANTENNA_HEIGHT_M = 15
 const TARGET_HEIGHT_M = 10
 
+/** Effective radar target height per category — drives the radar-horizon cap */
+const TARGET_HEIGHT_BY_CATEGORY: Partial<Record<UnitCategory, number>> = {
+  aircraft: 8000,
+  carrier_group: 40,
+  ship: 20,
+  naval_base: 30,
+  airbase: 25,
+  submarine: 2,
+  missile_battery: 5,
+  sam_site: 8,
+}
+
+function targetHeightM(category: UnitCategory): number {
+  return TARGET_HEIGHT_BY_CATEGORY[category] ?? TARGET_HEIGHT_M
+}
+
 const LEVEL_RANK: Record<VisibilityLevel, number> = { unseen: 0, detected: 1, tracked: 2, identified: 3 }
 
 interface ContactMeta {
@@ -70,6 +88,24 @@ export function resetVisibilityState(): void {
   metaByObserver.clear()
 }
 
+/**
+ * Seed scenario-start contacts: fixed military installations (airbases, naval bases)
+ * are public knowledge — both sides start with them identified and pinned.
+ */
+export function seedInitialVisibility(state: GameState): void {
+  state.visibility ??= {}
+  for (const nation of Object.values(state.nations)) {
+    const contacts = (state.visibility[nation.id as string] ??= {})
+    const meta = metaFor(nation.id as string)
+    for (const unit of state.units.values()) {
+      if (unit.nation === nation.id || unit.status === 'destroyed') continue
+      if (unit.category !== 'airbase' && unit.category !== 'naval_base') continue
+      if (contacts[unit.id]) continue
+      contacts[unit.id] = newContact(meta, unit, 'identified', state.time.tick)
+    }
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Per-minute source evaluation
 // ---------------------------------------------------------------------------
@@ -87,7 +123,8 @@ function evaluateSources(state: GameState, espionage: EspionageResult | null, gr
     for (const u of state.units.values()) {
       if (u.nation !== nation.id || u.status === 'destroyed' || u.sensors.length === 0) continue
       ownSensorUnits.push(u)
-      if (u.sensors.some(s => s.type === 'radar' && s.range_km > 0)) ownRadars.push(u)
+      // EMCON units don't radiate — passive ELINT antennas still listen
+      if (!u.emcon && u.sensors.some(s => s.type === 'radar' && s.range_km > 0)) ownRadars.push(u)
     }
 
     const humint = espionage?.humintRevealed.get(nation.id)
@@ -113,7 +150,7 @@ function evaluateSources(state: GameState, espionage: EspionageResult | null, gr
         if ((meta.get(unit.id)?.humintUntil ?? 0) > tick) {
           best = 'identified'
         }
-        if (best === 'unseen' && isElintDetected(ownSensorUnits, unit, sigintMultiplier)) {
+        if (best === 'unseen' && isElintDetected(ownSensorUnits, unit, sigintMultiplier, grid)) {
           best = 'detected'
         }
       }
@@ -145,24 +182,54 @@ function evaluateSources(state: GameState, espionage: EspionageResult | null, gr
 function radarContactLevel(ownRadars: Unit[], target: Unit, grid: ElevationGrid | null): VisibilityLevel {
   let best: VisibilityLevel = 'unseen'
   for (const radar of ownRadars) {
-    let range = 0
-    let antennaHeight = DEFAULT_ANTENNA_HEIGHT_M
-    for (const s of radar.sensors) {
-      if (s.type === 'radar' && s.range_km > range) {
-        range = s.range_km
-        antennaHeight = s.antenna_height_m ?? DEFAULT_ANTENNA_HEIGHT_M
-      }
+    const level = radarSeesUnit(radar, target, grid)
+    if (level === 'identified') return 'identified'
+    if (level === 'tracked') best = 'tracked'
+  }
+  return best
+}
+
+/**
+ * Can a single unit's radar see a target unit right now?
+ * Radar coverage is its nominal radius, stretched by height: a high-sited
+ * radar reaches further (elevation bonus) and a high-sitting target stands
+ * out and is spotted further away (prominence). Sector arcs and terrain
+ * line-of-sight still apply.
+ */
+export function radarSeesUnit(radar: Unit, target: Unit, grid: ElevationGrid | null): VisibilityLevel {
+  if (radar.status === 'destroyed' || radar.emcon) return 'unseen'
+  const dist = haversine(radar.position, target.position)
+  const targetAltAglM = targetHeightM(target.category)
+
+  const radarSiteElev = grid?.getElevation(radar.position.lat, radar.position.lng) ?? 0
+  const targetSiteElev = grid?.getElevation(target.position.lat, target.position.lng) ?? 0
+  const prominence = targetProminenceBonus(targetSiteElev + targetAltAglM)
+
+  let best: VisibilityLevel = 'unseen'
+  for (const s of radar.sensors) {
+    if (s.type !== 'radar' || s.range_km <= 0) continue
+
+    const antennaHeight = s.antenna_height_m ?? DEFAULT_ANTENNA_HEIGHT_M
+    const effRange = s.range_km * elevationRangeBonus(radarSiteElev + antennaHeight) * prominence
+    if (dist > effRange) continue
+
+    // Sector arc relative to the unit's heading
+    const sectorDeg = s.sector_deg ?? 360
+    if (sectorDeg < 360) {
+      const brg = bearing(radar.position, target.position)
+      const diff = ((brg - radar.heading) % 360 + 540) % 360 - 180
+      if (Math.abs(diff) > sectorDeg / 2) continue
     }
-    const dist = haversine(radar.position, target.position)
-    if (dist > range) continue
+
     if (grid) {
-      const radarAltM = grid.getElevation(radar.position.lat, radar.position.lng) + antennaHeight
-      const targetAltM = grid.getElevation(target.position.lat, target.position.lng) + TARGET_HEIGHT_M
+      const radarAltM = radarSiteElev + antennaHeight
+      const targetAltM = targetSiteElev + targetAltAglM
       if (!hasLineOfSight(radar.position, radarAltM, target.position.lat, target.position.lng, targetAltM, grid)) {
         continue
       }
     }
-    if (dist <= range * RADAR_IDENTIFY_FRACTION) return 'identified'
+
+    if (dist <= effRange * RADAR_IDENTIFY_FRACTION) return 'identified'
     best = 'tracked'
   }
   return best
@@ -179,13 +246,20 @@ function satelliteContactLevel(nation: Nation, unit: Unit, tick: number): Visibi
   return 'detected'
 }
 
-function isElintDetected(ownSensorUnits: Unit[], emitter: Unit, sigintMultiplier: number): boolean {
+function isElintDetected(ownSensorUnits: Unit[], emitter: Unit, sigintMultiplier: number, grid: ElevationGrid | null): boolean {
+  if (emitter.emcon) return false // radar silent — nothing to intercept
   let radarRange = 0
+  let antennaHeight = DEFAULT_ANTENNA_HEIGHT_M
   for (const s of emitter.sensors) {
-    if (s.type === 'radar' && s.range_km > radarRange) radarRange = s.range_km
+    if (s.type === 'radar' && s.range_km > radarRange) {
+      radarRange = s.range_km
+      antennaHeight = s.antenna_height_m ?? DEFAULT_ANTENNA_HEIGHT_M
+    }
   }
   if (radarRange <= 0) return false
-  const elintRange = radarRange * sigintMultiplier
+  // The flip side of height: an elevated emitter shines further — easier to intercept
+  const emitterElev = grid?.getElevation(emitter.position.lat, emitter.position.lng) ?? 0
+  const elintRange = radarRange * sigintMultiplier * elevationRangeBonus(emitterElev + antennaHeight)
   for (const own of ownSensorUnits) {
     if (haversine(own.position, emitter.position) <= elintRange) return true
   }
@@ -220,7 +294,8 @@ function applyEventReveals(state: GameState): void {
   }
 }
 
-function revealContact(state: GameState, observer: string, unit: Unit, level: VisibilityLevel): void {
+/** External reveal entry point — used by event reveals and the intel suite (satellites, HUMINT, SIGINT) */
+export function revealContact(state: GameState, observer: string, unit: Unit, level: VisibilityLevel): void {
   const tick = state.time.tick
   state.visibility ??= {}
   const contacts = (state.visibility[observer] ??= {})
@@ -370,3 +445,45 @@ const CONTACT_NAMES: Record<UnitCategory, string> = {
 export function contactDisplayName(category: UnitCategory): string {
   return CONTACT_NAMES[category] ?? 'Unknown contact'
 }
+
+// ---------------------------------------------------------------------------
+// Fire control — what may a unit shoot at, and on whose data?
+// ---------------------------------------------------------------------------
+
+const FIXED_SITE_CATEGORIES = new Set<UnitCategory>(['airbase', 'naval_base'])
+
+/**
+ * Fire-control quality for shooter → target:
+ *   'own'      — the shooter's own radar holds the target right now
+ *   'datalink' — a live nation-level track exists and the shooter is on the network,
+ *                or the target is a fixed site with known coordinates
+ *   null       — no engageable track; the shooter may not fire at this target
+ */
+export function getFireControlQuality(
+  state: GameState,
+  shooter: Unit,
+  target: Unit,
+  grid: ElevationGrid | null,
+): TrackQuality | null {
+  if (target.nation === shooter.nation || target.status === 'destroyed') return null
+
+  // Fixed installations are public knowledge — surveyed coordinates, no track needed
+  if (FIXED_SITE_CATEGORIES.has(target.category)) return 'datalink'
+
+  if (radarSeesUnit(shooter, target, grid) !== 'unseen') return 'own'
+
+  const contact = state.visibility?.[shooter.nation as string]?.[target.id]
+  if (!contact || contact.level === 'unseen') return null
+
+  // Unmoved SAM sites pin at their last fix — strikable on coordinates
+  if (target.category === 'sam_site' && contact.pinned &&
+      target.position.lat === contact.lastKnownPosition.lat &&
+      target.position.lng === contact.lastKnownPosition.lng) {
+    return 'datalink'
+  }
+
+  const live = contact.level === 'tracked' || contact.level === 'identified'
+  if (live && isDatalinkConnected(state, shooter)) return 'datalink'
+
+  return null
+}
diff --git a/src/engine/systems/war-support.ts b/src/engine/systems/war-support.ts
index 3113842..08a7b44 100644
--- a/src/engine/systems/war-support.ts
+++ b/src/engine/systems/war-support.ts
@@ -212,6 +212,12 @@ function evaluate(state: GameState): void {
       case 'UNIT_DESTROYED': {
         const unit = state.units.get(e.unitId)
         if (!unit) break
+        if (unit.isDecoy) {
+          // Killing an inflatable costs the victim nothing and hands them a propaganda win
+          const owner = (ws[unit.nation] ??= { warSupport: 100 })
+          owner.warSupport = clampSupport(owner.warSupport + 1)
+          break
+        }
         stats.unitsLost[unit.nation] = (stats.unitsLost[unit.nation] ?? 0) + 1
         const victim = state.nations[unit.nation]
         if (!victim || victim.atWar.length === 0) break
diff --git a/src/intel/__tests__/osint-feed.test.ts b/src/intel/__tests__/osint-feed.test.ts
new file mode 100644
index 0000000..f4434cf
--- /dev/null
+++ b/src/intel/__tests__/osint-feed.test.ts
@@ -0,0 +1,149 @@
+import { describe, it, expect } from 'vitest'
+import { generatePostsForEvent } from '../osint-feed'
+import { OSINT_ACCOUNTS } from '@/data/intel/osint-accounts'
+import type { GameEvent } from '@/types/game'
+
+const names = new Map<string, string>([
+  ['al_udeid', 'Al Udeid Air Base'],
+  ['cvn72_lincoln', 'CVN-72 Abraham Lincoln CSG'],
+  ['shahab_tabriz', 'Shahab-3 TEL (Tabriz)'],
+  ['irgc_fac', 'IRGC FAC Group (Hormuz)'],
+])
+
+const launched: GameEvent = {
+  type: 'MISSILE_LAUNCHED', missileId: 'm1', launcherId: 'shahab_tabriz',
+  targetId: 'al_udeid', weaponName: 'Shahab-3', tick: 500,
+}
+const impact: GameEvent = { type: 'MISSILE_IMPACT', missileId: 'm1', targetId: 'al_udeid', damage: 40, tick: 900 }
+const destroyedIranian: GameEvent = { type: 'UNIT_DESTROYED', unitId: 'irgc_fac', tick: 1200 }
+const warDeclared: GameEvent = { type: 'WAR_DECLARED', attacker: 'usa', defender: 'iran', tick: 10 }
+const mineHit: GameEvent = { type: 'MINE_CONTACT', minefieldId: 'mf1', targetId: 'cvn72_lincoln', damage: 25, tick: 333 }
+const laneChange: GameEvent = {
+  type: 'SHIPPING_LANE_STATUS_CHANGE', laneId: 'hormuz', newStatus: 'blocked', suppressionFactor: 1, tick: 700,
+}
+const oilSpike: GameEvent = { type: 'OIL_PRICE_CHANGE', newPrice: 142, oldPrice: 96, tick: 800 }
+const flashIntercept: GameEvent = {
+  type: 'INTERCEPT_DECRYPTED', precedence: 'FLASH', text: 'missile brigade ordered to combat readiness', tick: 60,
+}
+const routineIntercept: GameEvent = { type: 'INTERCEPT_DECRYPTED', precedence: 'ROUTINE', text: 'logistics chatter', tick: 61 }
+const supportCritical: GameEvent = { type: 'WAR_SUPPORT_CRITICAL', nation: 'usa', support: 28, tick: 5000 }
+
+function account(handle: string) {
+  return OSINT_ACCOUNTS.find((a) => a.handle === handle)!
+}
+
+function postsBy(posts: ReturnType<typeof generatePostsForEvent>, handle: string) {
+  return posts.filter((p) => p.handle === handle)
+}
+
+describe('generatePostsForEvent — archetype coverage', () => {
+  it('plane spotter covers launches and auto-engagements', () => {
+    expect(postsBy(generatePostsForEvent(launched, names, 500), '@GulfPlaneWatch')).toHaveLength(1)
+    const engage: GameEvent = {
+      type: 'AUTO_ENGAGEMENT', unitId: 'cvn72_lincoln', targetId: 'irgc_fac',
+      weaponName: 'SM-6', count: 2, quality: 'own', tick: 50,
+    }
+    expect(postsBy(generatePostsForEvent(engage, names, 50), '@GulfPlaneWatch')).toHaveLength(1)
+  })
+
+  it('aggregator covers impact, destruction and war declaration', () => {
+    expect(postsBy(generatePostsForEvent(impact, names, 900), '@CENTCOM_Watch')).toHaveLength(1)
+    expect(postsBy(generatePostsForEvent(destroyedIranian, names, 1200), '@CENTCOM_Watch')).toHaveLength(1)
+    const war = postsBy(generatePostsForEvent(warDeclared, names, 10), '@CENTCOM_Watch')
+    expect(war).toHaveLength(1)
+    expect(war[0].text).toMatch(/USA/)
+    expect(war[0].text).toMatch(/IRAN/)
+  })
+
+  it('webcam watcher covers mine hits and lane status', () => {
+    expect(postsBy(generatePostsForEvent(mineHit, names, 333), '@StraitSpotter')).toHaveLength(1)
+    expect(postsBy(generatePostsForEvent(laneChange, names, 700), '@StraitSpotter')).toHaveLength(1)
+  })
+
+  it('regime mouthpiece inflates Iranian launches and denies Iranian losses', () => {
+    expect(postsBy(generatePostsForEvent(launched, names, 500), '@IRGC_Media')).toHaveLength(1)
+    expect(postsBy(generatePostsForEvent(destroyedIranian, names, 1200), '@IRGC_Media')).toHaveLength(1)
+    // US weapon launch is not an Iranian launch — no inflated claim
+    const usLaunch: GameEvent = {
+      type: 'MISSILE_LAUNCHED', missileId: 'm2', launcherId: 'cvn72_lincoln',
+      targetId: 'irgc_fac', weaponName: 'BGM-109 Tomahawk', tick: 501,
+    }
+    expect(postsBy(generatePostsForEvent(usLaunch, names, 501), '@IRGC_Media')).toHaveLength(0)
+    // US loss draws no denial
+    const usLoss: GameEvent = { type: 'UNIT_DESTROYED', unitId: 'al_udeid', tick: 1300 }
+    expect(postsBy(generatePostsForEvent(usLoss, names, 1300), '@IRGC_Media')).toHaveLength(0)
+  })
+
+  it('oil analyst covers price moves and lane status', () => {
+    const oil = postsBy(generatePostsForEvent(oilSpike, names, 800), '@TankerTrackerz')
+    expect(oil).toHaveLength(1)
+    expect(oil[0].text).toContain('142')
+    expect(postsBy(generatePostsForEvent(laneChange, names, 700), '@TankerTrackerz')).toHaveLength(1)
+  })
+
+  it('imagery analyst posts delayed BDA after impacts', () => {
+    const bda = postsBy(generatePostsForEvent(impact, names, 900), '@OrbitalRecon')
+    expect(bda).toHaveLength(1)
+    expect(bda[0].text).toContain('Al Udeid Air Base')
+  })
+
+  it('leak channel reposts FLASH intercepts only', () => {
+    const flash = postsBy(generatePostsForEvent(flashIntercept, names, 60), '@SignalDesk')
+    expect(flash).toHaveLength(1)
+    expect(flash[0].text).toContain('missile brigade ordered to combat readiness')
+    expect(postsBy(generatePostsForEvent(routineIntercept, names, 61), '@SignalDesk')).toHaveLength(0)
+  })
+
+  it('joke indicator posts on war-support critical', () => {
+    expect(postsBy(generatePostsForEvent(supportCritical, names, 5000), '@PizzaIndexGulf')).toHaveLength(1)
+  })
+
+  it('uncovered events generate nothing', () => {
+    const repair: GameEvent = { type: 'UNIT_REPAIRED', unitId: 'al_udeid', healthRestored: 10, tick: 42 }
+    expect(generatePostsForEvent(repair, names, 42)).toHaveLength(0)
+  })
+})
+
+describe('generatePostsForEvent — delay semantics', () => {
+  it('every post surfaces no earlier than event tick + the account min delay', () => {
+    const allEvents = [launched, impact, destroyedIranian, mineHit, laneChange, oilSpike, flashIntercept, supportCritical]
+    for (const e of allEvents) {
+      for (const post of generatePostsForEvent(e, names, e.tick)) {
+        const [min, max] = account(post.handle).delayRangeSec
+        expect(post.tick).toBeGreaterThanOrEqual(e.tick + min)
+        expect(post.tick).toBeLessThanOrEqual(e.tick + max)
+      }
+    }
+  })
+
+  it('imagery analyst BDA is hours late, plane spotter is minutes late', () => {
+    const posts = generatePostsForEvent(impact, names, 900)
+    const bda = postsBy(posts, '@OrbitalRecon')[0]
+    expect(bda.tick).toBeGreaterThanOrEqual(900 + 21_600)
+    const spotter = postsBy(generatePostsForEvent(launched, names, 500), '@GulfPlaneWatch')[0]
+    expect(spotter.tick).toBeLessThanOrEqual(500 + 180)
+  })
+
+  it('never schedules a post before the current tick when events are consumed late', () => {
+    const late = generatePostsForEvent(launched, names, 99_999)
+    for (const post of late) {
+      expect(post.tick).toBeGreaterThanOrEqual(99_999)
+    }
+  })
+})
+
+describe('generatePostsForEvent — determinism', () => {
+  it('identical input produces identical posts', () => {
+    const a = generatePostsForEvent(impact, names, 900)
+    const b = generatePostsForEvent(impact, names, 900)
+    expect(a).toEqual(b)
+  })
+
+  it('different event ticks vary delay and text choice deterministically', () => {
+    const later: GameEvent = { ...impact, tick: 901 }
+    const a = generatePostsForEvent(impact, names, 900)
+    const b = generatePostsForEvent(later, names, 901)
+    expect(a.length).toBe(b.length)
+    expect(generatePostsForEvent(later, names, 901)).toEqual(b)
+  })
+})
diff --git a/src/intel/osint-feed.ts b/src/intel/osint-feed.ts
new file mode 100644
index 0000000..8f33e74
--- /dev/null
+++ b/src/intel/osint-feed.ts
@@ -0,0 +1,312 @@
+/**
+ * Diegetic OSINT feed — pure consumer of the snapshot event stream.
+ * Design: docs/plans/intel-suite-v3.md §2. The engine never sees this;
+ * posts are presentation derived from events the player already received.
+ */
+import { useEffect } from 'react'
+import { create } from 'zustand'
+import { useGameStore } from '@/store/game-store'
+import { OSINT_ACCOUNTS, type OsintAccount } from '@/data/intel/osint-accounts'
+import type { GameEvent } from '@/types/game'
+
+export interface OsintPost {
+  id: string
+  handle: string
+  displayName: string
+  color: string
+  /** Game tick the post surfaces at (event tick + the account's reporting delay) */
+  tick: number
+  text: string
+}
+
+const PUBLISHED_CAP = 100
+
+// ── Deterministic randomness ────────────────────────────────────────────────
+// LCG keyed on (event tick + type + handle) so re-renders/replays produce
+// identical posts. Never Math.random() here — this runs in render-adjacent paths.
+
+function hashString(s: string): number {
+  let h = 2166136261
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i)
+    h = Math.imul(h, 16777619)
+  }
+  return h >>> 0
+}
+
+function makeRng(seed: number): () => number {
+  let s = seed >>> 0
+  return () => {
+    s = (Math.imul(s, 1664525) + 1013904223) >>> 0
+    return s / 4294967296
+  }
+}
+
+function pick<T>(rng: () => number, arr: T[]): T {
+  return arr[Math.min(arr.length - 1, Math.floor(rng() * arr.length))]
+}
+
+// ── Nation heuristics (events carry no nation field; the feed is flavor) ────
+
+const IRAN_WEAPON_RE = /shahab|sejjil|fateh|zolfaghar|khalij|noor|soumar|hoveyzeh|shahed|sayyad|bavar|khordad|48n6|9m331/i
+const IRAN_UNIT_RE = /irgc|irin|bandar|bushehr|qeshm|jask|chabahar|khordad|bavar|s-300|tor-m1|shahab|sejjil|fateh|zolfaghar|shahed|soumar|ghadir|mehrabad|nebo|isfahan|tabriz|dezful|semnan|natanz|kermanshah|khorramabad|shiraz|tehran|\btel\b/i
+
+const WRONG_NAMES = [
+  'the Sirri complex',
+  'a facility near Lavan',
+  'the Asaluyeh site',
+  'a position outside Minab',
+  'the Kish installation',
+]
+
+function nameOf(id: string, names: Map<string, string>): string {
+  return names.get(id) ?? id
+}
+
+// ── Per-archetype text generators ───────────────────────────────────────────
+// Return null when the account does not cover the event.
+
+function buildText(
+  account: OsintAccount,
+  event: GameEvent,
+  names: Map<string, string>,
+  rng: () => number,
+): string | null {
+  switch (account.archetype) {
+    case 'plane_spotter': {
+      if (event.type === 'MISSILE_LAUNCHED') {
+        return pick(rng, [
+          `launch flash on the horizon, multiple plumes climbing. ${event.weaponName}? thread when I have photos`,
+          'whole building shook from the launch roar. something big just went up',
+          'to everyone DMing: yes, confirmed launch activity near the base. stay indoors',
+        ])
+      }
+      if (event.type === 'AUTO_ENGAGEMENT') {
+        return pick(rng, [
+          `air defense going loud RIGHT NOW — ${event.weaponName} x${event.count} per my count`,
+          'interceptors going up in pairs over the water. camera rolling',
+          `that sound is live ${event.weaponName} fire. engagement underway`,
+        ])
+      }
+      return null
+    }
+
+    case 'aggregator': {
+      const garble = rng() < account.errorRate
+      if (event.type === 'MISSILE_IMPACT') {
+        const target = garble ? pick(rng, WRONG_NAMES) : nameOf(event.targetId, names)
+        return pick(rng, [
+          `BREAKING: impact reported at ${target} — awaiting visual confirmation`,
+          `multiple sources reporting strikes on ${target}. developing`,
+        ])
+      }
+      if (event.type === 'UNIT_DESTROYED') {
+        const target = garble ? pick(rng, WRONG_NAMES) : nameOf(event.unitId, names)
+        return pick(rng, [
+          `CONFIRMED per two sources: ${target} destroyed`,
+          `BREAKING: total loss reported at ${target}. unverified footage circulating`,
+        ])
+      }
+      if (event.type === 'WAR_DECLARED') {
+        const a = event.attacker.toUpperCase()
+        const d = event.defender.toUpperCase()
+        return pick(rng, [
+          `BREAKING: ${a} DECLARES WAR ON ${d}`,
+          `it's happening — state of war: ${a} vs ${d}. live coverage thread below`,
+        ])
+      }
+      return null
+    }
+
+    case 'webcam_watcher': {
+      if (event.type === 'MINE_CONTACT') {
+        return pick(rng, [
+          'explosion low on the waterline mid-channel. vessel dead in the water on the south cam',
+          `something just hit ${nameOf(event.targetId, names)} — smoke visible on the strait cam`,
+        ])
+      }
+      if (event.type === 'SHIPPING_LANE_STATUS_CHANGE') {
+        if (event.newStatus === 'blocked') {
+          return pick(rng, [
+            'strait cam: traffic has STOPPED. nothing moving in either direction',
+            'zero hulls on the cam for an hour now. the lane is shut',
+          ])
+        }
+        if (event.newStatus === 'reduced') {
+          return pick(rng, [
+            'counting maybe a third of normal transits on the cam today. insurers spooked?',
+            'tankers holding at anchor outside the strait. traffic way down',
+          ])
+        }
+        return pick(rng, [
+          'cam shows convoys moving again. lane looks open',
+          'normal transit picture restored on the strait cam',
+        ])
+      }
+      return null
+    }
+
+    case 'regime_mouthpiece': {
+      if (event.type === 'MISSILE_LAUNCHED' && IRAN_WEAPON_RE.test(event.weaponName)) {
+        return pick(rng, [
+          'Crushing response underway. Dozens of missiles en route to the aggressor. Victory is assured.',
+          `The Guardians have unleashed ${event.weaponName}. The enemy will learn humility tonight.`,
+          'Waves of fire answer every insult. The occupiers’ bases are burning.',
+        ])
+      }
+      if (event.type === 'UNIT_DESTROYED' && IRAN_UNIT_RE.test(nameOf(event.unitId, names))) {
+        return pick(rng, [
+          `Enemy claims regarding ${nameOf(event.unitId, names)} are fabrication. All systems fully operational.`,
+          `Western media recycles old footage about ${nameOf(event.unitId, names)}. Nothing was hit.`,
+        ])
+      }
+      return null
+    }
+
+    case 'oil_analyst': {
+      if (event.type === 'OIL_PRICE_CHANGE') {
+        const up = event.newPrice > event.oldPrice
+        const px = event.newPrice.toFixed(0)
+        return pick(rng, [
+          `Brent ${up ? 'up' : 'down'} to $${px}/bbl. Gulf risk premium ${up ? 'widening' : 'unwinding'}.`,
+          `$${px} print. ${up ? 'War premium is real now' : 'Market shrugging off the Gulf'} — watching Hormuz transit counts.`,
+        ])
+      }
+      if (event.type === 'SHIPPING_LANE_STATUS_CHANGE') {
+        return pick(rng, [
+          `Hormuz status: ${event.newStatus.toUpperCase()}. ~20% of seaborne crude rides on this strait.`,
+          `Lane update — ${event.newStatus.toUpperCase()}. Charter rates will move before the wires do.`,
+        ])
+      }
+      return null
+    }
+
+    case 'imagery_analyst': {
+      if (event.type === 'MISSILE_IMPACT') {
+        const target = nameOf(event.targetId, names)
+        return pick(rng, [
+          `new collect over ${target}: crater analysis suggests a deep-penetration hit, secondary scarring visible`,
+          `BDA on ${target}: at least one aimpoint cratered, burn pattern consistent with fuel fire. full thread soon`,
+        ])
+      }
+      return null
+    }
+
+    case 'leak_channel': {
+      if (event.type === 'INTERCEPT_DECRYPTED' && event.precedence === 'FLASH') {
+        return pick(rng, [
+          `forwarded without comment: "${event.text}"`,
+          `from a usually-reliable channel: "${event.text}"`,
+        ])
+      }
+      return null
+    }
+
+    case 'joke_indicator': {
+      if (event.type === 'WAR_SUPPORT_CRITICAL') {
+        return pick(rng, [
+          'pizza deliveries around a certain five-sided building up sharply tonight. draw your own conclusions',
+          'late-night kebab orders near certain ministries: anomalous. the index never sleeps',
+        ])
+      }
+      return null
+    }
+  }
+}
+
+/**
+ * Pure core: posts an event generates across the whole account roster.
+ * Deterministic for a fixed (event, names, currentTick) — safe to call repeatedly.
+ * Each post's tick = event tick + the account's delay (never before currentTick).
+ */
+export function generatePostsForEvent(
+  event: GameEvent,
+  names: Map<string, string>,
+  currentTick: number,
+): OsintPost[] {
+  const posts: OsintPost[] = []
+  for (const account of OSINT_ACCOUNTS) {
+    const rng = makeRng(hashString(`${event.tick}:${event.type}:${account.handle}`))
+    const [min, max] = account.delayRangeSec
+    const delay = min + Math.round(rng() * (max - min))
+    const text = buildText(account, event, names, rng)
+    if (!text) continue
+    posts.push({
+      id: `osint-${event.tick}-${event.type}-${account.handle}`,
+      handle: account.handle,
+      displayName: account.displayName,
+      color: account.color,
+      tick: Math.max(event.tick + delay, currentTick),
+      text,
+    })
+  }
+  return posts
+}
+
+// ── Feed store: pending posts drain into published as the game clock passes ─
+
+interface OsintFeedStore {
+  pending: OsintPost[]
+  /** Newest first, capped at 100 */
+  published: OsintPost[]
+  lastBatch: GameEvent[] | null
+  ingest: (events: GameEvent[], names: Map<string, string>, currentTick: number) => void
+  advance: (currentTick: number) => void
+}
+
+export const useOsintFeedStore = create<OsintFeedStore>((set, get) => ({
+  pending: [],
+  published: [],
+  lastBatch: null,
+
+  ingest: (events, names, currentTick) => {
+    // Event batches are one-shot from the worker; multiple hook consumers may
+    // pass the same array — process each batch exactly once
+    if (events.length === 0 || get().lastBatch === events) return
+    const generated = events.flatMap((e) => generatePostsForEvent(e, names, currentTick))
+    if (generated.length === 0) {
+      set({ lastBatch: events })
+      return
+    }
+    const pending = [...get().pending, ...generated]
+    set({ lastBatch: events, pending })
+    get().advance(currentTick)
+  },
+
+  advance: (currentTick) => {
+    const { pending, published } = get()
+    // Posts are only published once due — a published tick in the future means
+    // the clock jumped backwards (new game / load): flush the feed
+    if (published.length > 0 && published[0].tick > currentTick) {
+      set({ pending: [], published: [], lastBatch: null })
+      return
+    }
+    if (pending.length === 0) return
+    const due = pending.filter((p) => p.tick <= currentTick)
+    if (due.length === 0) return
+    due.sort((a, b) => a.tick - b.tick)
+    set({
+      pending: pending.filter((p) => p.tick > currentTick),
+      published: [...due.reverse(), ...published].slice(0, PUBLISHED_CAP),
+    })
+  },
+}))
+
+/** Published OSINT posts, newest first (max 100). */
+export function useOsintFeed(): OsintPost[] {
+  const events = useGameStore((s) => s.viewState.events)
+  const tick = useGameStore((s) => s.viewState.time.tick)
+
+  useEffect(() => {
+    if (events.length === 0) return
+    const { units, time } = useGameStore.getState().viewState
+    const names = new Map(units.map((u) => [u.id, u.name] as const))
+    useOsintFeedStore.getState().ingest(events, names, time.tick)
+  }, [events])
+
+  useEffect(() => {
+    useOsintFeedStore.getState().advance(tick)
+  }, [tick])
+
+  return useOsintFeedStore((s) => s.published)
+}
diff --git a/src/store/__tests__/game-store.test.ts b/src/store/__tests__/game-store.test.ts
index 8e65d04..7d3b6f5 100644
--- a/src/store/__tests__/game-store.test.ts
+++ b/src/store/__tests__/game-store.test.ts
@@ -22,6 +22,7 @@ function makeViewState(
     warSupport: {},
     gameOver: null,
     objectives: [],
+    intel: { assets: [], agents: [], products: [], taskings: [], leakLevel: 0, paranoiaBand: 'LOW' as const, encryptionUpgradedUntilTick: null },
     ...overrides,
   }
 }
diff --git a/src/store/__tests__/map-intel-store.test.ts b/src/store/__tests__/map-intel-store.test.ts
new file mode 100644
index 0000000..0815d54
--- /dev/null
+++ b/src/store/__tests__/map-intel-store.test.ts
@@ -0,0 +1,180 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { useMapIntelStore } from '@/store/map-intel-store'
+import type { TrackPoint } from '@/store/map-intel-store'
+import type { ViewUnit } from '@/types/view'
+import type { GameEvent } from '@/types/game'
+
+function makeUnit(overrides: Partial<ViewUnit> & { id: string }): ViewUnit {
+  return {
+    name: 'Surface contact',
+    nation: 'iran',
+    category: 'ship',
+    position: { lng: 52, lat: 26 },
+    heading: 0,
+    speed_kts: 12,
+    status: 'moving',
+    health: 100,
+    maxHealth: 100,
+    logistics: 100,
+    supplyStocks: [],
+    weapons: [],
+    pointDefense: [],
+    sensors: [],
+    roe: 'weapons_tight',
+    waypoints: [],
+    subordinateIds: [],
+    visibility: 'tracked',
+    stale: false,
+    ...overrides,
+  }
+}
+
+function killed(unitId: string, tick: number): GameEvent {
+  return { type: 'UNIT_DESTROYED', unitId, tick }
+}
+
+beforeEach(() => {
+  useMapIntelStore.setState({ killMarkers: [], killSeenIds: {}, trackHistory: {} })
+})
+
+describe('kill markers', () => {
+  it('appends a marker at the destroyed unit position', () => {
+    const units = [makeUnit({ id: 'e1', position: { lng: 55, lat: 27 } })]
+    useMapIntelStore.getState().ingestKillEvents([killed('e1', 100)], units, 5000)
+
+    expect(useMapIntelStore.getState().killMarkers).toEqual([
+      { id: 'e1', position: [55, 27], tick: 100, addedAtMs: 5000 },
+    ])
+  })
+
+  it('does not duplicate markers when the cumulative event log is re-ingested', () => {
+    const units = [makeUnit({ id: 'e1' })]
+    const log = [killed('e1', 100)]
+    useMapIntelStore.getState().ingestKillEvents(log, units, 5000)
+    useMapIntelStore.getState().ingestKillEvents(log, units, 6000)
+    useMapIntelStore.getState().ingestKillEvents([...log, killed('e1', 100)], units, 7000)
+
+    expect(useMapIntelStore.getState().killMarkers).toHaveLength(1)
+  })
+
+  it('falls back to the last trail point when the unit is gone from the snapshot', () => {
+    const trail: TrackPoint[] = [
+      { position: [50, 25], tick: 10 },
+      { position: [51, 25.5], tick: 40 },
+    ]
+    useMapIntelStore.setState({ trackHistory: { e2: trail } })
+    useMapIntelStore.getState().ingestKillEvents([killed('e2', 60)], [], 5000)
+
+    expect(useMapIntelStore.getState().killMarkers).toEqual([
+      { id: 'e2', position: [51, 25.5], tick: 60, addedAtMs: 5000 },
+    ])
+  })
+
+  it('skips units with no known position, permanently', () => {
+    useMapIntelStore.getState().ingestKillEvents([killed('ghost', 10)], [], 5000)
+    expect(useMapIntelStore.getState().killMarkers).toEqual([])
+
+    // Once processed, a later snapshot containing the unit must not resurrect the event
+    useMapIntelStore.getState().ingestKillEvents([killed('ghost', 10)], [makeUnit({ id: 'ghost' })], 6000)
+    expect(useMapIntelStore.getState().killMarkers).toEqual([])
+  })
+
+  it('caps at 60 markers, dropping the oldest', () => {
+    const units: ViewUnit[] = []
+    const log: GameEvent[] = []
+    for (let i = 0; i < 70; i++) {
+      units.push(makeUnit({ id: `u${i}`, position: { lng: 50 + i * 0.1, lat: 26 } }))
+      log.push(killed(`u${i}`, i))
+    }
+    useMapIntelStore.getState().ingestKillEvents(log, units, 5000)
+
+    const markers = useMapIntelStore.getState().killMarkers
+    expect(markers).toHaveLength(60)
+    expect(markers[0].id).toBe('u10')
+    expect(markers[59].id).toBe('u69')
+  })
+
+  it('clears markers when the event log resets (new game)', () => {
+    useMapIntelStore.getState().ingestKillEvents([killed('e1', 1)], [makeUnit({ id: 'e1' })], 5000)
+    expect(useMapIntelStore.getState().killMarkers).toHaveLength(1)
+
+    useMapIntelStore.getState().ingestKillEvents([], [], 6000)
+    expect(useMapIntelStore.getState().killMarkers).toEqual([])
+    expect(useMapIntelStore.getState().killSeenIds).toEqual({})
+  })
+})
+
+describe('track history sampling', () => {
+  const sample = (units: ViewUnit[], tick: number) =>
+    useMapIntelStore.getState().sampleTrackHistory(units, tick, 'usa')
+
+  it('starts buffers for tracked/identified enemy contacts only', () => {
+    sample([
+      makeUnit({ id: 'e1', visibility: 'tracked' }),
+      makeUnit({ id: 'e2', visibility: 'identified' }),
+      makeUnit({ id: 'e3', visibility: 'detected' }),
+      makeUnit({ id: 'own1', nation: 'usa' }),
+      makeUnit({ id: 'dead1', status: 'destroyed' }),
+    ], 0)
+
+    expect(Object.keys(useMapIntelStore.getState().trackHistory).sort()).toEqual(['e1', 'e2'])
+  })
+
+  it('samples on the 30-tick cadence', () => {
+    const unitAt = (lng: number) => [makeUnit({ id: 'e1', position: { lng, lat: 26 } })]
+    sample(unitAt(50), 0)
+    sample(unitAt(50.1), 10)
+    sample(unitAt(50.2), 29)
+    expect(useMapIntelStore.getState().trackHistory.e1).toHaveLength(1)
+
+    sample(unitAt(50.3), 30)
+    expect(useMapIntelStore.getState().trackHistory.e1).toEqual([
+      { position: [50, 26], tick: 0 },
+      { position: [50.3, 26], tick: 30 },
+    ])
+  })
+
+  it('caps each buffer at 24 points, dropping the oldest', () => {
+    for (let i = 0; i <= 40; i++) {
+      sample([makeUnit({ id: 'e1', position: { lng: 50 + i, lat: 26 } })], i * 30)
+    }
+    const buf = useMapIntelStore.getState().trackHistory.e1
+    expect(buf).toHaveLength(24)
+    expect(buf[0].tick).toBe(17 * 30)
+    expect(buf[23].tick).toBe(40 * 30)
+  })
+
+  it('clears the buffer when the contact disappears from the snapshot', () => {
+    sample([makeUnit({ id: 'e1' })], 0)
+    expect(useMapIntelStore.getState().trackHistory.e1).toBeDefined()
+
+    sample([], 30)
+    expect(useMapIntelStore.getState().trackHistory).toEqual({})
+  })
+
+  it('drops the buffer when the contact is destroyed', () => {
+    sample([makeUnit({ id: 'e1' })], 0)
+    sample([makeUnit({ id: 'e1', status: 'destroyed' })], 30)
+    expect(useMapIntelStore.getState().trackHistory).toEqual({})
+  })
+
+  it('retains but does not extend the buffer while the contact is stale', () => {
+    sample([makeUnit({ id: 'e1' })], 0)
+    sample([makeUnit({ id: 'e1', stale: true })], 60)
+
+    expect(useMapIntelStore.getState().trackHistory.e1).toHaveLength(1)
+
+    // Track regained → sampling resumes
+    sample([makeUnit({ id: 'e1' })], 90)
+    expect(useMapIntelStore.getState().trackHistory.e1).toHaveLength(2)
+  })
+
+  it('resets the buffer when the tick regresses (new run)', () => {
+    sample([makeUnit({ id: 'e1' })], 300)
+    sample([makeUnit({ id: 'e1', position: { lng: 53, lat: 26.5 } })], 0)
+
+    expect(useMapIntelStore.getState().trackHistory.e1).toEqual([
+      { position: [53, 26.5], tick: 0 },
+    ])
+  })
+})
diff --git a/src/store/game-store.ts b/src/store/game-store.ts
index 6dc3d88..44e8f39 100644
--- a/src/store/game-store.ts
+++ b/src/store/game-store.ts
@@ -22,6 +22,15 @@ const emptyViewState: GameViewState = {
   warSupport: {},
   gameOver: null,
   objectives: [],
+  intel: {
+    assets: [],
+    agents: [],
+    products: [],
+    taskings: [],
+    leakLevel: 0,
+    paranoiaBand: 'LOW',
+    encryptionUpgradedUntilTick: null,
+  },
 }
 
 interface GameStore {
diff --git a/src/store/intel-store.ts b/src/store/intel-store.ts
index 2b735f7..5897cba 100644
--- a/src/store/intel-store.ts
+++ b/src/store/intel-store.ts
@@ -12,15 +12,19 @@ export interface EstimatedUnit {
   confirmed: boolean
 }
 
+export type IntelTab = 'isr' | 'sigint' | 'humint' | 'osint' | 'opsec'
+
 interface IntelState {
   estimatedUnits: EstimatedUnit[]
   placingCatalogId: string | null
+  activeTab: IntelTab
 
   addEstimate: (entry: UnitCatalogEntry, position: Position) => void
   removeEstimate: (id: string) => void
   moveEstimate: (id: string, position: Position) => void
   confirmEstimate: (id: string) => void
   setPlacing: (catalogId: string | null) => void
+  setActiveTab: (tab: IntelTab) => void
   reset: () => void
 }
 
@@ -29,6 +33,7 @@ let counter = 0
 const INITIAL_STATE = {
   estimatedUnits: [] as EstimatedUnit[],
   placingCatalogId: null as string | null,
+  activeTab: 'isr' as IntelTab,
 }
 
 export const useIntelStore = create<IntelState>((set) => ({
@@ -68,5 +73,7 @@ export const useIntelStore = create<IntelState>((set) => ({
 
   setPlacing: (catalogId) => set({ placingCatalogId: catalogId }),
 
+  setActiveTab: (tab) => set({ activeTab: tab }),
+
   reset: () => { counter = 0; set({ ...INITIAL_STATE }) },
 }))
diff --git a/src/store/map-intel-store.ts b/src/store/map-intel-store.ts
new file mode 100644
index 0000000..f1076f8
--- /dev/null
+++ b/src/store/map-intel-store.ts
@@ -0,0 +1,203 @@
+import { create } from 'zustand'
+import type { ViewUnit } from '@/types/view'
+import type { GameEvent } from '@/types/game'
+import { ADSB_POLL_INTERVAL_MS, adsbLiveUrl } from '@/data/feeds'
+
+export interface AdsbAircraft {
+  id: string
+  callsign: string
+  lat: number
+  lon: number
+  /** Ground track degrees true; null when the feed omits it */
+  track: number | null
+}
+
+export interface KillMarker {
+  id: string
+  /** [lng, lat] */
+  position: [number, number]
+  tick: number
+  /** UI wall clock at append — drives the ~10 s real-time death animation */
+  addedAtMs: number
+}
+
+export interface TrackPoint {
+  /** [lng, lat] */
+  position: [number, number]
+  tick: number
+}
+
+const ADSB_CENTER = { lat: 26.5, lon: 54.0, radiusNm: 220 }
+const ADSB_MAX_AIRCRAFT = 80
+
+const KILL_MARKER_CAP = 60
+/** 1 tick = 1 game-second → one trail point every ~30 game-seconds */
+const TRACK_SAMPLE_INTERVAL_TICKS = 30
+const TRACK_BUFFER_SIZE = 24
+
+interface MapIntelState {
+  /** One switch for AOU rings + tasking swaths + sensor rings */
+  intelOverlays: boolean
+  /** GIBS daily VIIRS raster base layer */
+  reconMosaic: boolean
+  /** Live ADS-B aircraft layer (airplanes.live polling) */
+  adsbLive: boolean
+  adsbAircraft: AdsbAircraft[]
+  /** Enemy contact id → tick when stale first became true (AOU growth anchor) */
+  staleSince: Record<string, number>
+  /** Destruction sites, oldest first, capped at KILL_MARKER_CAP */
+  killMarkers: KillMarker[]
+  /** Unit ids whose UNIT_DESTROYED has been processed (markers can be evicted, this can't) */
+  killSeenIds: Record<string, true>
+  /** Enemy contact id → recent positions, oldest first */
+  trackHistory: Record<string, TrackPoint[]>
+
+  toggleIntelOverlays: () => void
+  toggleReconMosaic: () => void
+  setAdsbLive: (on: boolean) => void
+  toggleAdsbLive: () => void
+  syncStaleContacts: (units: ViewUnit[], tick: number, playerNation: string) => void
+  ingestKillEvents: (eventLog: GameEvent[], units: ViewUnit[], nowMs?: number) => void
+  sampleTrackHistory: (units: ViewUnit[], tick: number, playerNation: string) => void
+}
+
+let adsbTimer: ReturnType<typeof setInterval> | null = null
+
+async function pollAdsb(): Promise<void> {
+  try {
+    const res = await fetch(adsbLiveUrl(ADSB_CENTER.lat, ADSB_CENTER.lon, ADSB_CENTER.radiusNm))
+    if (!res.ok) return
+    const body = (await res.json()) as { ac?: unknown[] } | null
+    const list = Array.isArray(body?.ac) ? body.ac : []
+    const aircraft: AdsbAircraft[] = []
+    for (const raw of list) {
+      const ac = raw as { hex?: unknown; flight?: unknown; lat?: unknown; lon?: unknown; track?: unknown; lastPosition?: { lat?: unknown; lon?: unknown } }
+      const lat = typeof ac.lat === 'number' ? ac.lat : ac.lastPosition?.lat
+      const lon = typeof ac.lon === 'number' ? ac.lon : ac.lastPosition?.lon
+      if (typeof lat !== 'number' || typeof lon !== 'number' || !Number.isFinite(lat) || !Number.isFinite(lon)) continue
+      aircraft.push({
+        id: typeof ac.hex === 'string' ? ac.hex : `${lat.toFixed(4)},${lon.toFixed(4)}`,
+        callsign: typeof ac.flight === 'string' ? ac.flight.trim() : '',
+        lat,
+        lon,
+        track: typeof ac.track === 'number' && Number.isFinite(ac.track) ? ac.track : null,
+      })
+      if (aircraft.length >= ADSB_MAX_AIRCRAFT) break
+    }
+    if (useMapIntelStore.getState().adsbLive) {
+      useMapIntelStore.setState({ adsbAircraft: aircraft })
+    }
+  } catch {
+    // ambient flavor layer — a dead external feed must never break the game
+  }
+}
+
+export const useMapIntelStore = create<MapIntelState>((set, get) => ({
+  intelOverlays: false,
+  reconMosaic: false,
+  adsbLive: false,
+  adsbAircraft: [],
+  staleSince: {},
+  killMarkers: [],
+  killSeenIds: {},
+  trackHistory: {},
+
+  toggleIntelOverlays: () => set((s) => ({ intelOverlays: !s.intelOverlays })),
+  toggleReconMosaic: () => set((s) => ({ reconMosaic: !s.reconMosaic })),
+
+  setAdsbLive: (on) => {
+    if (get().adsbLive === on) return
+    if (adsbTimer !== null) {
+      clearInterval(adsbTimer)
+      adsbTimer = null
+    }
+    if (on) {
+      set({ adsbLive: true })
+      void pollAdsb()
+      adsbTimer = setInterval(() => { void pollAdsb() }, ADSB_POLL_INTERVAL_MS)
+    } else {
+      set({ adsbLive: false, adsbAircraft: [] })
+    }
+  },
+
+  toggleAdsbLive: () => get().setAdsbLive(!get().adsbLive),
+
+  syncStaleContacts: (units, tick, playerNation) => {
+    const prev = get().staleSince
+    const next: Record<string, number> = {}
+    let added = false
+    for (const u of units) {
+      if (u.nation === playerNation || !u.stale || u.status === 'destroyed') continue
+      const since = prev[u.id]
+      if (since === undefined) added = true
+      next[u.id] = since ?? tick
+    }
+    // No additions and same key count → identical map, skip the set
+    if (!added && Object.keys(prev).length === Object.keys(next).length) return
+    set({ staleSince: next })
+  },
+
+  ingestKillEvents: (eventLog, units, nowMs = performance.now()) => {
+    const { killMarkers, killSeenIds, trackHistory } = get()
+    if (eventLog.length === 0) {
+      // eventLog only goes back to empty on new game/load — drop the previous run's markers
+      if (killMarkers.length > 0 || Object.keys(killSeenIds).length > 0) {
+        set({ killMarkers: [], killSeenIds: {} })
+      }
+      return
+    }
+    let seen: Record<string, true> | null = null
+    let added: KillMarker[] | null = null
+    for (const e of eventLog) {
+      if (e.type !== 'UNIT_DESTROYED') continue
+      if (killSeenIds[e.unitId] || seen?.[e.unitId]) continue
+      seen = seen ?? { ...killSeenIds }
+      seen[e.unitId] = true
+      const unit = units.find((u) => u.id === e.unitId)
+      const trail = trackHistory[e.unitId]
+      const position: [number, number] | undefined = unit
+        ? [unit.position.lng, unit.position.lat]
+        : trail && trail.length > 0
+          ? trail[trail.length - 1].position
+          : undefined
+      if (!position) continue // contact never had a known fix — nothing to mark
+      added = added ?? []
+      added.push({ id: e.unitId, position, tick: e.tick, addedAtMs: nowMs })
+    }
+    if (seen === null) return
+    set({
+      killMarkers: added ? [...killMarkers, ...added].slice(-KILL_MARKER_CAP) : killMarkers,
+      killSeenIds: seen,
+    })
+  },
+
+  sampleTrackHistory: (units, tick, playerNation) => {
+    const prev = get().trackHistory
+    const next: Record<string, TrackPoint[]> = {}
+    let changed = false
+    for (const u of units) {
+      if (u.nation === playerNation || u.status === 'destroyed') continue
+      const buf = prev[u.id]
+      const live = (u.visibility === 'tracked' || u.visibility === 'identified') && !u.stale
+      if (!live) {
+        // Degraded contact still in the snapshot: keep history, don't sample a frozen fix
+        if (buf) next[u.id] = buf
+        continue
+      }
+      const point: TrackPoint = { position: [u.position.lng, u.position.lat], tick }
+      if (buf === undefined || buf.length === 0 || tick < buf[buf.length - 1].tick) {
+        // tick behind the buffer = store reused across a new run
+        next[u.id] = [point]
+        changed = true
+      } else if (tick - buf[buf.length - 1].tick >= TRACK_SAMPLE_INTERVAL_TICKS) {
+        next[u.id] = [...buf, point].slice(-TRACK_BUFFER_SIZE)
+        changed = true
+      } else {
+        next[u.id] = buf
+      }
+    }
+    // Units gone from the snapshot drop out by not being copied over
+    if (!changed && Object.keys(prev).length === Object.keys(next).length) return
+    set({ trackHistory: next })
+  },
+}))
diff --git a/src/store/ui-store.ts b/src/store/ui-store.ts
index 8ac4fbd..5d2c4a9 100644
--- a/src/store/ui-store.ts
+++ b/src/store/ui-store.ts
@@ -1,6 +1,7 @@
 import { create } from 'zustand'
 import type { UnitId } from '@/types/game'
 import type { MapMode } from '@/styles/map-providers'
+import { audioManager } from '@/audio/audio-manager'
 
 export type LeftPanel = 'orbat' | 'stats' | 'economy' | null
 
@@ -18,6 +19,21 @@ export interface AutoPauseSettings {
   ceasefireOffered: boolean
 }
 
+export interface PanelOffset {
+  dx: number
+  dy: number
+}
+
+/** Mutable ref so Panel can swap its close callback without re-registering (which would reset focus order) */
+export interface PanelCloseRef {
+  current: (() => void) | undefined
+}
+
+interface PanelRegistration {
+  closeRef: PanelCloseRef
+  lastFocus: number
+}
+
 interface UIState {
   // Selection
   selectedUnitIds: Set<UnitId>
@@ -41,12 +57,28 @@ interface UIState {
   // Right-side panels (independent toggles)
   showIntel: boolean
 
+  // Intel suite v3
+  liveFeedsOpen: boolean
+  /** IMINT product open in the full-screen viewer (null = closed) */
+  viewedProductId: string | null
+  /** Contact the ISR FMV quadrant is staring at */
+  fmvTargetId: UnitId | null
+
   // Camera focus request (consumed by GameMap)
   mapFocus: MapFocus | null
 
   // Auto-pause triggers (session-only, applied by AlertFeed)
   autoPause: AutoPauseSettings
 
+  // Audio prefs — persisted by the AudioManager (localStorage); the store mirrors it
+  audioMuted: boolean
+  audioVolume: number
+
+  // Panel window management (session-only, keyed by panel title)
+  panelOffsets: Record<string, PanelOffset>
+  panelRegistry: Record<string, PanelRegistration>
+  panelFocusCounter: number
+
   // Actions — selection
   selectUnit: (id: UnitId | null) => void
   toggleUnitSelection: (id: UnitId) => void
@@ -69,14 +101,32 @@ interface UIState {
   // Right-side panels
   toggleIntel: () => void
 
+  // Intel suite v3
+  toggleLiveFeeds: () => void
+  setViewedProduct: (id: string | null) => void
+  setFmvTarget: (id: UnitId | null) => void
+
   // Camera focus
   focusMap: (lng: number, lat: number, zoom?: number) => void
 
   // Auto-pause
   toggleAutoPause: (key: keyof AutoPauseSettings) => void
+
+  // Audio
+  setAudioMuted: (muted: boolean) => void
+  toggleAudioMuted: () => void
+  setAudioVolume: (volume: number) => void
+
+  // Panel window management
+  setPanelOffset: (title: string, offset: PanelOffset) => void
+  registerPanel: (title: string, closeRef: PanelCloseRef) => void
+  unregisterPanel: (title: string) => void
+  focusPanel: (title: string) => void
+  /** Closes the topmost registered panel that has a close callback; false if none */
+  closeTopPanel: () => boolean
 }
 
-export const useUIStore = create<UIState>((set) => ({
+export const useUIStore = create<UIState>((set, get) => ({
   selectedUnitIds: new Set(),
   selectedUnitId: null,
   hoveredUnitId: null,
@@ -90,8 +140,16 @@ export const useUIStore = create<UIState>((set) => ({
   showStats: false,
   showEconomy: false,
   showIntel: false,
+  liveFeedsOpen: false,
+  viewedProductId: null,
+  fmvTargetId: null,
   mapFocus: null,
   autoPause: { warDeclared: true, ownUnitDestroyed: true, ceasefireOffered: true },
+  audioMuted: audioManager.isMuted(),
+  audioVolume: audioManager.getVolume(),
+  panelOffsets: {},
+  panelRegistry: {},
+  panelFocusCounter: 0,
 
   // Selection
   selectUnit: (id) => set({
@@ -126,6 +184,10 @@ export const useUIStore = create<UIState>((set) => ({
 
   toggleIntel: () => set((s) => ({ showIntel: !s.showIntel })),
 
+  toggleLiveFeeds: () => set((s) => ({ liveFeedsOpen: !s.liveFeedsOpen })),
+  setViewedProduct: (id) => set({ viewedProductId: id }),
+  setFmvTarget: (id) => set({ fmvTargetId: id }),
+
   focusMap: (lng, lat, zoom) => set((s) => ({
     mapFocus: { lng, lat, zoom, nonce: (s.mapFocus?.nonce ?? 0) + 1 },
   })),
@@ -134,6 +196,65 @@ export const useUIStore = create<UIState>((set) => ({
     autoPause: { ...s.autoPause, [key]: !s.autoPause[key] },
   })),
 
+  // Audio
+  setAudioMuted: (muted) => {
+    audioManager.setMuted(muted)
+    set({ audioMuted: muted })
+  },
+
+  toggleAudioMuted: () => {
+    const muted = !get().audioMuted
+    audioManager.setMuted(muted)
+    set({ audioMuted: muted })
+  },
+
+  setAudioVolume: (volume) => {
+    audioManager.setVolume(volume)
+    set({ audioVolume: audioManager.getVolume() })
+  },
+
+  // Panel window management
+  setPanelOffset: (title, offset) => set((s) => ({
+    panelOffsets: { ...s.panelOffsets, [title]: offset },
+  })),
+
+  registerPanel: (title, closeRef) => set((s) => {
+    const counter = s.panelFocusCounter + 1
+    return {
+      panelFocusCounter: counter,
+      panelRegistry: { ...s.panelRegistry, [title]: { closeRef, lastFocus: counter } },
+    }
+  }),
+
+  unregisterPanel: (title) => set((s) => {
+    if (!(title in s.panelRegistry)) return {}
+    const next = { ...s.panelRegistry }
+    delete next[title]
+    return { panelRegistry: next }
+  }),
+
+  focusPanel: (title) => set((s) => {
+    const reg = s.panelRegistry[title]
+    if (!reg) return {}
+    const isTop = Object.values(s.panelRegistry).every((r) => r.lastFocus <= reg.lastFocus)
+    if (isTop) return {}
+    const counter = s.panelFocusCounter + 1
+    return {
+      panelFocusCounter: counter,
+      panelRegistry: { ...s.panelRegistry, [title]: { ...reg, lastFocus: counter } },
+    }
+  }),
+
+  closeTopPanel: () => {
+    let top: PanelRegistration | undefined
+    for (const reg of Object.values(get().panelRegistry)) {
+      if (reg.closeRef.current && (!top || reg.lastFocus > top.lastFocus)) top = reg
+    }
+    if (!top) return false
+    top.closeRef.current?.()
+    return true
+  },
+
   // Panels — radio group
   setLeftPanel: (panel) => set({
     leftPanel: panel,
diff --git a/src/styles/__tests__/map-providers.test.ts b/src/styles/__tests__/map-providers.test.ts
new file mode 100644
index 0000000..ea432e7
--- /dev/null
+++ b/src/styles/__tests__/map-providers.test.ts
@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest'
+import { getMapStyle, HILLSHADE_LAYER_ID, TERRAIN_DEM_SOURCE_ID } from '../map-providers'
+
+const MODES = ['dark', 'satellite'] as const
+
+describe.each(MODES)('getMapStyle(%s) — terrain relief contract', (mode) => {
+  const style = getMapStyle(mode)
+
+  it('carries the terrarium raster-dem source capped at z12', () => {
+    const src = style.sources[TERRAIN_DEM_SOURCE_ID] as {
+      type?: string
+      tiles?: string[]
+      encoding?: string
+      tileSize?: number
+      maxzoom?: number
+      attribution?: string
+    }
+    expect(src).toBeDefined()
+    expect(src.type).toBe('raster-dem')
+    expect(src.encoding).toBe('terrarium')
+    expect(src.tileSize).toBe(512)
+    expect(src.maxzoom).toBe(12)
+    expect(src.tiles).toEqual(['https://tiles.mapterhorn.com/{z}/{x}/{y}.webp'])
+    expect(src.attribution).toContain('Mapzen/Tilezen, NASA SRTM')
+  })
+
+  it('carries a hillshade layer on that source, visible by default', () => {
+    const layer = style.layers.find((l) => l.id === HILLSHADE_LAYER_ID) as
+      | { type: string; source?: string; layout?: { visibility?: string }; paint?: Record<string, unknown> }
+      | undefined
+    expect(layer).toBeDefined()
+    expect(layer?.type).toBe('hillshade')
+    expect(layer?.source).toBe(TERRAIN_DEM_SOURCE_ID)
+    expect(layer?.layout?.visibility).not.toBe('none')
+    expect(layer?.paint?.['hillshade-exaggeration']).toBe(0.4)
+  })
+
+  it('is a plain JSON style object (serializable, version 8, unique layer ids)', () => {
+    expect(style.version).toBe(8)
+    expect(JSON.parse(JSON.stringify(style))).toEqual(style)
+    const ids = style.layers.map((l) => l.id)
+    expect(new Set(ids).size).toBe(ids.length)
+  })
+})
diff --git a/src/styles/map-providers.ts b/src/styles/map-providers.ts
index e4a81a0..98737a8 100644
--- a/src/styles/map-providers.ts
+++ b/src/styles/map-providers.ts
@@ -1,4 +1,4 @@
-import type { StyleSpecification } from 'maplibre-gl'
+import type { LayerSpecification, RasterDEMSourceSpecification, StyleSpecification } from 'maplibre-gl'
 
 export type MapMode = 'dark' | 'satellite'
 
@@ -6,6 +6,46 @@ export type MapMode = 'dark' | 'satellite'
 const ESRI_SAT =
   'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}'
 
+export const TERRAIN_DEM_SOURCE_ID = 'terrain-dem'
+export const HILLSHADE_LAYER_ID = 'terrain-hillshade'
+
+// ── Terrain relief (roadmap A.1) ────────────────────────────────────
+// Mapterhorn DEM — terrarium-encoded webp, template verified against
+// https://tiles.mapterhorn.com/tilejson.json 2026-06-11.
+// Fallback if Mapterhorn dies: AWS Terrain Tiles
+// https://s3.amazonaws.com/elevation-tiles-prod/terrarium/{z}/{x}/{y}.png
+// (encoding 'terrarium', tileSize 256).
+
+function buildTerrainDemSource(): RasterDEMSourceSpecification {
+  return {
+    type: 'raster-dem',
+    tiles: ['https://tiles.mapterhorn.com/{z}/{x}/{y}.webp'],
+    encoding: 'terrarium',
+    tileSize: 512,
+    maxzoom: 12, // native SRTM detail ceiling
+    attribution: 'Terrain: Mapzen/Tilezen, NASA SRTM',
+  }
+}
+
+// Low-contrast ops-room tuning: near-black shadows, faint blue-gray highlights —
+// relief depth without fighting unit icons. Default visible; the ELV toggle
+// flips visibility at runtime (GameMap).
+function buildHillshadeLayer(): LayerSpecification {
+  return {
+    id: HILLSHADE_LAYER_ID,
+    type: 'hillshade',
+    source: TERRAIN_DEM_SOURCE_ID,
+    paint: {
+      'hillshade-exaggeration': 0.4,
+      'hillshade-shadow-color': '#04060a',
+      'hillshade-highlight-color': '#3d4c61',
+      'hillshade-accent-color': '#0a0e14',
+      // 'map' keeps shading fixed to the NW sun regardless of bearing
+      'hillshade-illumination-anchor': 'map',
+    },
+  }
+}
+
 export function getMapStyle(mode: MapMode): StyleSpecification {
   return mode === 'dark' ? buildDarkStyle() : buildSatelliteStyle()
 }
@@ -24,6 +64,7 @@ function buildDarkStyle(): StyleSpecification {
         type: 'vector',
         url: 'https://tiles.openfreemap.org/planet',
       },
+      [TERRAIN_DEM_SOURCE_ID]: buildTerrainDemSource(),
     },
     layers: [
       // Background — very dark, CIC operations room
@@ -112,6 +153,10 @@ function buildDarkStyle(): StyleSpecification {
           'circle-opacity': 0.5,
         },
       },
+
+      // Hillshade relief — last in-style layer; GameMap anchors the country
+      // fills below it (beforeId) so shading reads over the political tint
+      buildHillshadeLayer(),
     ],
   }
 }
@@ -128,8 +173,9 @@ function buildSatelliteStyle(): StyleSpecification {
         type: 'raster',
         tiles: [ESRI_SAT],
         tileSize: 256,
-        attribution: '&copy; Esri',
+        attribution: '&copy; Esri · Terrain: Mapzen/Tilezen, NASA SRTM',
       },
+      [TERRAIN_DEM_SOURCE_ID]: buildTerrainDemSource(),
     },
     layers: [
       {
@@ -141,6 +187,7 @@ function buildSatelliteStyle(): StyleSpecification {
           'raster-brightness-max': 0.8,
         },
       },
+      buildHillshadeLayer(),
     ],
   }
 }
diff --git a/src/types/commands.ts b/src/types/commands.ts
index 35a982a..5c08b06 100644
--- a/src/types/commands.ts
+++ b/src/types/commands.ts
@@ -1,9 +1,9 @@
-import type { GameTime, IntelBudget, NationId, Position, ROE, UnitId, WeaponId } from './game'
+import type { AirMissionKind, GameTime, IntelBudget, NationId, Position, ROE, TrackQuality, UnitId, WeaponId } from './game'
 
 export type Command =
   | { type: 'MOVE_UNIT'; unitId: UnitId; waypoints: Position[] }
-  | { type: 'LAUNCH_MISSILE'; launcherId: UnitId; weaponId: WeaponId; targetId: UnitId; waypoints?: Position[] }
-  | { type: 'LAUNCH_SALVO'; launcherId: UnitId; weaponId: WeaponId; targetId: UnitId; count: number; waypoints?: Position[] }
+  | { type: 'LAUNCH_MISSILE'; launcherId: UnitId; weaponId: WeaponId; targetId: UnitId; waypoints?: Position[]; trackQuality?: TrackQuality }
+  | { type: 'LAUNCH_SALVO'; launcherId: UnitId; weaponId: WeaponId; targetId: UnitId; count: number; waypoints?: Position[]; spacingTicks?: number; delayTicks?: number }
   | { type: 'SET_ROE'; unitId: UnitId; roe: ROE }
   | { type: 'SET_SPEED'; speed: GameTime['speed'] }
   | { type: 'DECLARE_WAR'; target: NationId }
@@ -14,3 +14,12 @@ export type Command =
   | { type: 'SET_DRONE_MISSION'; unitId: UnitId; mission: 'military' | 'shipping_interdiction' }
   | { type: 'OFFER_CEASEFIRE'; target: NationId }
   | { type: 'RESIGN' }
+  | { type: 'TASK_SATELLITE_PASS'; assetId: string; target: Position; cloudPct?: number }
+  | { type: 'TASK_AGENT'; agentId: string }
+  | { type: 'REST_AGENT'; agentId: string }
+  | { type: 'EXFILTRATE_AGENT'; agentId: string }
+  | { type: 'OPSEC_SWEEP' }
+  | { type: 'SET_EMCON'; unitId: UnitId; emcon: boolean }
+  | { type: 'LAUNCH_AIR_MISSION'; kind: AirMissionKind; squadronId: string; fromUnitId: UnitId; flightSize: number; station?: Position; targetId?: UnitId; escortSead?: boolean; extendedRange?: boolean }
+  | { type: 'CANCEL_AIR_MISSION'; missionId: string }
+  | { type: 'SET_SURGE_OPS'; enabled: boolean }
diff --git a/src/types/game.ts b/src/types/game.ts
index cf98ba1..4049f4e 100644
--- a/src/types/game.ts
+++ b/src/types/game.ts
@@ -150,6 +150,16 @@ export interface Unit {
   damage_per_contact?: number
   /** For drone launcher units — current tactical mission */
   droneMission?: 'military' | 'shipping_interdiction'
+  /** EMCON: radar silent — invisible to ELINT, blind on own radar (network picture still applies) */
+  emcon?: boolean
+  /** Decoy unit (Iranian dummy TELs) — engine truth, scrubbed from snapshots until revealed */
+  isDecoy?: boolean
+  /** Set once the enemy has positively identified this decoy (NIIRS 7+ pass, HUMINT, or BDA) */
+  decoyRevealed?: boolean
+  /** Carrier groups + airbases: squadron pools (air war v5) */
+  airWing?: SquadronState[]
+  /** Flight units only — mission bookkeeping */
+  flightMeta?: { missionId: string; bingoTick: number; rtbTo: UnitId; a2aShots: number }
 }
 
 export interface WeaponStock {
@@ -301,6 +311,8 @@ export interface Missile {
   interceptTargetMissileId?: string
   /** Detection quality that led to this intercept (for accuracy modifier) */
   networkQuality?: 'own' | 'tracked' | 'detected'
+  /** Strike was leaked to the enemy before launch — heavy miss chance at impact */
+  compromised?: boolean
 }
 
 export interface ShippingLane {
@@ -317,6 +329,18 @@ export interface ShippingLane {
   status: 'open' | 'reduced' | 'blocked'
 }
 
+/** One salvo round queued for a future tick (LAUNCH_SALVO with spacingTicks) */
+export interface ScheduledLaunch {
+  dueTick: number
+  launcherId: UnitId
+  weaponId: WeaponId
+  targetId: UnitId
+  waypoints?: Position[]
+  trackQuality?: TrackQuality
+  /** Result of the salvo command's single leak roll — scheduled rounds never re-roll */
+  compromised?: boolean
+}
+
 export interface GameState {
   /** Which nation the player controls (enemy runs on AI) */
   playerNation: NationId
@@ -339,6 +363,14 @@ export interface GameState {
   warStatus?: Record<string, WarStatus>
   /** Set once the war has been resolved — the world keeps ticking but the game is decided */
   gameOver?: GameOverReport
+  /** Intel suite v3: ISR assets, HUMINT sources, products, counterintel meters */
+  intel?: IntelState
+  /** Salvo rounds awaiting their dueTick — drained by processScheduledLaunches each tick */
+  scheduledLaunches?: ScheduledLaunch[]
+  /** Air war v5: live + planned air missions */
+  airMissions?: AirMission[]
+  /** Air war v5: SURGE OPS lever — 96 h halved ready times, then ×1.5 sustained */
+  surgeOps?: { enabled: boolean; activatedTick?: number }
 }
 
 export type GameEvent =
@@ -360,3 +392,154 @@ export type GameEvent =
   | { type: 'CEASEFIRE_OFFERED'; by: NationId; tick: number }
   | { type: 'CEASEFIRE_REJECTED'; by: NationId; tick: number }
   | { type: 'WAR_ENDED'; outcome: 'ceasefire' | 'capitulation'; loser?: NationId; tick: number }
+  | { type: 'AIR_MISSION_LAUNCHED'; missionId: string; kind: AirMissionKind; flightName: string; tick: number }
+  | { type: 'FLIGHT_ON_STATION'; missionId: string; flightName: string; tick: number }
+  | { type: 'FLIGHT_RTB'; missionId: string; flightName: string; reason: string; tick: number }
+  | { type: 'FLIGHT_LOST'; missionId?: string; flightName: string; airframesLost: number; pilotFate: PilotFate; tick: number }
+  | { type: 'AIR_INTERCEPT'; attackerName: string; defenderName: string; kills: number; tick: number }
+  | { type: 'AUTO_ENGAGEMENT'; unitId: UnitId; targetId: UnitId; weaponName: string; count: number; quality: TrackQuality; tick: number }
+  | { type: 'MISSILE_MISSED'; missileId: string; targetId: UnitId; tick: number }
+  | { type: 'MISSILE_CRASHED'; missileId: string; position?: Position; tick: number }
+  | { type: 'ORDER_REJECTED'; unitId: UnitId; reason: string; tick: number }
+  | { type: 'SATELLITE_PASS_COMPLETE'; assetId: string; target: Position; found: number; revealedDecoys: number; tick: number }
+  | { type: 'SATELLITE_PASS_FAILED'; assetId: string; target: Position; cloudPct: number; tick: number }
+  | { type: 'INTERCEPT_DECRYPTED'; precedence: InterceptPrecedence; text: string; aboutUnitId?: UnitId; tick: number }
+  | { type: 'AGENT_REPORT'; agentId: string; codename: string; text: string; tick: number }
+  | { type: 'AGENT_ARRESTED'; agentId: string; codename: string; tick: number }
+  | { type: 'AGENT_EXFILTRATED'; agentId: string; codename: string; tick: number }
+  | { type: 'SPY_SWEEP'; arrests: number; tick: number }
+  | { type: 'ENCRYPTION_UPGRADED'; untilTick: number; tick: number }
+  | { type: 'DECOY_REVEALED'; unitId: UnitId; tick: number }
+  | { type: 'STRIKE_LEAKED'; targetId: UnitId; tick: number }
+  | { type: 'OPSEC_SWEEP_COMPLETE'; newLeakLevel: number; tick: number }
+
+/** Fire-control source for a shot: the shooter's own sensors, or a track relayed over datalink */
+export type TrackQuality = 'own' | 'datalink'
+
+// ---------------------------------------------------------------------------
+// Intel suite (v3) — design: docs/plans/intel-suite-v3.md
+// ---------------------------------------------------------------------------
+
+export type IntelAssetKind =
+  | 'optical_sat'      // KH-11 / Noor — taskable imagery passes
+  | 'commercial_sat'   // commercial layer — frequent, lower quality
+  | 'sigint_air'       // RC-135 — drives intercept cadence
+  | 'maritime_patrol'  // MQ-4C Triton — coarse wide-area ship refresh
+  | 'launch_detection' // SBIRS — always-on launch plume FLASH cards
+  | 'recon_drone'      // Mohajer-10 — Iran's carrier watcher
+  | 'fast_boats'       // IRGC shadowing — Iran's coarse carrier track
+
+export interface IntelAsset {
+  id: string
+  nation: NationId
+  name: string
+  kind: IntelAssetKind
+  status: 'active' | 'lost'
+  /** Game-minutes between collections (0 = continuous) */
+  revisit_min: number
+  lastCollectionTick: number
+  /** Imagery quality for products (NIIRS 0-9); >= 7 reveals decoys */
+  niirs?: number
+}
+
+export interface SatTasking {
+  id: string
+  assetId: string
+  target: Position
+  queuedTick: number
+  /** Real-world cloud cover 0-100 captured at tasking time (UI-fetched); undefined = roll it */
+  cloudPct?: number
+}
+
+export type InterceptPrecedence = 'FLASH' | 'IMMEDIATE' | 'PRIORITY' | 'ROUTINE'
+
+export type IntelProductKind = 'imint' | 'sigint' | 'humint'
+
+/** Metadata only — the UI fetches real imagery at view time */
+export interface IntelProduct {
+  id: string
+  kind: IntelProductKind
+  tick: number
+  classification: string
+  caption: string
+  assetId?: string
+  target?: Position
+  niirs?: number
+  precedence?: InterceptPrecedence
+  agentId?: string
+}
+
+export type AgentStatus = 'active' | 'resting' | 'exfiltrating' | 'exfiltrated' | 'arrested'
+
+export interface AgentSource {
+  id: string
+  codename: string
+  placement: string
+  product: string
+  status: AgentStatus
+  /** 0-100 — arrest risk during Iranian spy sweeps */
+  exposure: number
+  lastTaskedTick: number
+  exfilCompleteTick?: number
+}
+
+// ---------------------------------------------------------------------------
+// Air war v5 — design: docs/plans/air-war-v5.md
+// ---------------------------------------------------------------------------
+
+export type AirframeId = 'fa18e' | 'f35c' | 'ea18g' | 'e2d' | 'f14' | 'mig29' | 'su24' | 'su35'
+
+export interface SquadronState {
+  id: string
+  name: string
+  airframe: AirframeId
+  /** Airframes on the books (parked ones are strikeable via airbase damage) */
+  total: number
+  /** Ready to launch right now */
+  available: number
+  /** Ticks when turning-around airframes rejoin `available` */
+  readyAt: number[]
+}
+
+export type AirMissionKind = 'cap' | 'strike' | 'aew'
+export type AirMissionStatus = 'planning' | 'active' | 'complete' | 'aborted'
+export type PilotFate = 'kia' | 'rescued' | 'pow'
+
+export interface AirMission {
+  id: string
+  kind: AirMissionKind
+  nation: NationId
+  squadronId: string
+  fromUnitId: UnitId
+  flightSize: number
+  station?: Position
+  targetId?: UnitId
+  /** EA-18G pair attached (USA): SAM detect/pk ×0.6 near the flight, emitting SAMs become contacts */
+  escortSead?: boolean
+  /** Buddy tanking: +35% radius, costs 2 extra fa18e sorties */
+  extendedRange?: boolean
+  status: AirMissionStatus
+  createdTick: number
+  /** Strike missions only — launch window opens here (2-6 h planning) */
+  planningCompleteTick?: number
+  flightUnitId?: UnitId
+}
+
+export interface IntelState {
+  assets: Record<string, IntelAsset>
+  agents: Record<string, AgentSource>
+  /** Newest first, capped at 30 */
+  products: IntelProduct[]
+  taskings: SatTasking[]
+  /** 0-100 Iranian counterintel alert — drives sweeps, encryption upgrades */
+  paranoia: number
+  /** 0-100 how compromised the player's operations are */
+  leakLevel: number
+  encryptionUpgradedUntilTick?: number
+  lastSweepTick?: number
+  lastOpsecSweepTick?: number
+  lastIntInterceptTick?: number
+  lastCarrierOsintTick?: number
+  decoysSpawned?: boolean
+  productCounter?: number
+}
diff --git a/src/types/view.ts b/src/types/view.ts
index 502d631..4dcbc6c 100644
--- a/src/types/view.ts
+++ b/src/types/view.ts
@@ -1,15 +1,21 @@
 import type {
+  AgentSource,
+  AirMission,
   GameEvent,
   GameOverReport,
   GameTime,
+  IntelAsset,
+  IntelProduct,
   Missile,
   Nation,
   NationId,
   PointDefenseSystem,
   Position,
   ROE,
+  SatTasking,
   Sensor,
   ShippingLane,
+  SquadronState,
   SupplyLine,
   UnitCategory,
   UnitId,
@@ -19,6 +25,18 @@ import type {
   WeaponStock,
 } from './game'
 
+/** Intel slice of the snapshot — player-nation data only */
+export interface IntelViewState {
+  assets: IntelAsset[]
+  agents: AgentSource[]
+  products: IntelProduct[]
+  taskings: SatTasking[]
+  leakLevel: number
+  /** Fuzzy read of Iranian counterintel posture — exact paranoia stays hidden */
+  paranoiaBand: 'LOW' | 'ELEVATED' | 'HIGH' | 'SEVERE'
+  encryptionUpgradedUntilTick: number | null
+}
+
 /** Live status of one scenario objective, computed engine-side for the player's nation */
 export interface ObjectiveStatus {
   id: string
@@ -50,6 +68,12 @@ export interface GameViewState {
   gameOver: GameOverReport | null
   /** Scenario objectives for the player's side (empty at peace) */
   objectives: ObjectiveStatus[]
+  /** Intel suite: assets, sources, products, counterintel meters (player nation only) */
+  intel: IntelViewState
+  /** Air war: the player's missions (engine always supplies; optional to spare fixtures) */
+  airMissions?: AirMission[]
+  /** SURGE OPS lever state */
+  surgeOps?: boolean
 }
 
 export interface ViewUnit {
@@ -81,4 +105,10 @@ export interface ViewUnit {
   visibility: VisibilityLevel
   /** True when position is a last-known fix rather than a live track */
   stale: boolean
+  /** Own units: radar silent (EMCON) */
+  emcon?: boolean
+  /** Own carriers/airbases: squadron pools (never exposed for enemy units) */
+  airWing?: SquadronState[]
+  /** Enemy contacts: positively identified as a decoy */
+  decoyRevealed?: boolean
 }