feat(#61): named leaders — assassination / death / appointment with succession (v0.38.0)

Per-nation named leaders (Nation.leader) and a required TurnResult.leaders
lever ({ changes: [{ target, name, cause }] }). Each change sets the target
nation's leader and applies a deterministic stability dip by cause
(assassination -15, death -3, appointed 0) mirrored to its regions and
re-derived into its stats, plus a narration event (military for an
assassination, political for a death/appointment). An assassination/death
requires the target to already have a leader (a leaderless target is
dropped); an appointment always creates/sets one. Unknown/ambiguous targets
are dropped, never thrown.

- shared/types.ts: optional Nation.leader
- shared/protocol.ts: LeaderCause/LeaderChange/LeaderOps, LEADER_STABILITY_EFFECT,
  TurnResult.leaders (required, between nuclear and markers), leader in nationForPrompt
- server/engine.ts: validateLeaderOps, applyLeaderChange, the applyTurnResult
  leader block (after nuclear, before markers), isMeaningful, system-prompt
  contract + constraint, validateTurnResult + runTurn fallback
- server/stub.ts: leaders always { changes: [] } (e2e unaffected)
- tests: 15 engine.test.ts leader tests + 2 db.test.ts round-trips
- version 0.37.0 -> 0.38.0, CHANGELOG entry

CHANGELOG.md

@@ -2,6 +2,39 @@
 
 All notable changes to **History** are listed here, newest first.
 
+## v0.38.0 — 2026-10-15 20:06
+- **#61: Named leaders — a per-nation `leader` + a `TurnResult.leaders` lever (assassination / death / appointment) with a deterministic stability effect and succession narration.** Each nation may carry a single named head of state (`Nation.leader`); the model changes it each turn via `leaders.changes`. The engine is **fully deterministic (no hidden randomness)** and **additive** (no `db.ts` change — `leader` is an optional `Nation` field; a pre-v0.38 row loads with it absent, i.e. "no leader").
+  - **Types (`shared/types.ts`).** `Nation.leader?: { name: string }` (optional; `undefined`/absent = the nation has no leader).
+  - **Protocol (`shared/protocol.ts`).** New `LeaderCause` (`'assassination' | 'death' | 'appointed'`), `LeaderChange` (`{ target; name; cause }` — `target` is a nation ref, `name` is the new leader's name), and `LeaderOps` (`{ changes: LeaderChange[] }`); `TurnResult.leaders` is **required**, placed between `nuclear` and `markers`, default `{ changes: [] }`. New exported **`LEADER_STABILITY_EFFECT = { assassination: −15, death: −3, appointed: 0 }`** (the deterministic stability dip by cause). `nationForPrompt` now includes the nation's `leader` (omitted when absent), so `buildUserPrompt` carries each nation's current leader with no separate wiring.
+  - **Engine (`server/engine.ts`).**
+    - `validateLeaderOps(raw)` — new exported, defensive validator (never throws): accepts a `{ changes: [...] }` object or a bare array; each change needs a non-empty `target` (≤120), a non-empty `name` (≤120), and a `cause` that is one of the three literals — anything else is dropped. Refs stay raw (resolved at apply time, like wars / hybrid / nuclear ops).
+    - `applyLeaderChange(next, op, geoOf?, actingTurn?)` — new, mirrors `applyHybridOp` (single-stat, nation-target). Resolves the target (unknown / ambiguous → dropped, never thrown). **GATE**: an `assassination`/`death` requires the target to already have a leader (a leaderless target is dropped); `appointed` is always valid (it creates the first leader). On a valid change it sets `n.leader = { name }` and applies `LEADER_STABILITY_EFFECT[cause]` to `n.stats.stability` (clamped 0–100) mirrored to every region the nation owns (`regionStats`), then re-derives the nation's stats (the same 0-region / no-entry guards as hybrid / economy / industry, so a 0-region nation keeps its directly-mutated value). Finally it appends a narration event: a dramatic **`military`** event for an assassination, a **`political`** succession event for a death or an appointment. The replacement never moves territory (sole ownership is untouched).
+    - `applyTurnResult` — the leader block runs **after `nuclear` and before `markers`** (order: events → relations → territory → stateChanges → recompute → takeovers → wars → hybrid → economy → industry → nuclear → **leaders** → markers → nationOps).
+    - `isMeaningful` — a non-empty `leaders.changes` makes a turn meaningful.
+    - `validateTurnResult` — initializes and validates `leaders` (default `{ changes: [] }`).
+    - `buildSystemPrompt` — documents the `leaders` field (the three causes, the stability effects, the leaderless-gate, the "at most 1–2 per turn, narrated" rule) and contrasts it with the lighter `hybrid.assassinate` op (a −5 dip, no leader replacement) in both tool and plain modes.
+    - `runTurn` — the "unclear" fallback carries `leaders: { changes: [] }`.
+  - **Stub (`server/stub.ts`).** `deterministicTurn` always returns `leaders: { changes: [] }` and the `StubPayload` nations type gains an optional `leader` — the stub **never** changes a leader, so the e2e (CI, `LLM_STUB=1`) is unaffected and the path is covered by unit tests only.
+  - **Tests.** New unit tests in `engine.test.ts`: `validateLeaderOps` (`{changes}` object, bare array, unknown-cause drop, missing target/name drop, malformed top-level, mixed batch keeps only valid); `isMeaningful` (a leader change is meaningful, empty leaders is not); `applyTurnResult` (assassination with a leader → replaced + −15 + `military` event; assassination / death on a leaderless nation → dropped, no stat change, no event; death → replaced + −3 + `political` succession event; appointment on a leader-having and on a leaderless nation → sets the leader, neutral (no dip); a multi-region nation → every region dipped and stats re-derived; an unknown target and an ambiguous (two-nation-same-name) target → dropped without throwing). Two `db.test.ts` round-trips: a legacy row with no leader loads with it absent, and a set leader round-trips through save/load.
+- **Version** bumped `0.37.0 → 0.38.0`.
+
+## v0.37.0 — 2026-10-15 19:15
+- **#60: Nuclear / WMD — a per-nation `nuclear` capability flag + a `TurnResult.nuclear` lever (`arm` + `strikes`) with deterministic strikes and MAD retaliation.** A nation is *nuclear-capable* when its `nuclear` flag is `true` **or** it currently owns a `rocket` marker (a launch site is an arsenal). The model can **arm** nations (grant the flag — idempotent; a newly-armed nation is capable the same turn, since `arm` is applied before `strikes`) and fire **strikes** (`{ from, target }`). The engine is **fully deterministic (no hidden randomness)** and **additive** (a `db.ts` change is not needed — `nuclear` is an optional `Nation` field; a pre-v0.37 row loads with the flag absent).
+  - **Capability (`shared/protocol.ts`).** `isNuclearCapable(nation, markers)` — exported pure helper: `nation.nuclear === true` **or** it owns a `rocket` marker (`marker.type === 'rocket' && marker.ownerNationId === nation.id`). Markers supply the *pre-turn* rocket set, so a rocket placed this turn makes the owner capable from the *next* turn.
+  - **Types (`shared/types.ts`).** `Nation.nuclear?: boolean` (optional; `undefined`/absent = not armed; default `false` behavior).
+  - **Protocol (`shared/protocol.ts`).** New `NuclearStrike` (`{ from; target }` — `from` is the striking nation, `target` is a nation ref or a region key) and `NuclearOps` (`{ arm: string[]; strikes: NuclearStrike[] }`); `TurnResult.nuclear` is **required**, placed between `industry` and `markers`, default `{ arm: [], strikes: [] }`. New exported `NuclearStatKey` (`'economy' | 'military' | 'stability'`) and the two deterministic collapse tables: **`NUCLEAR_COLLAPSE = { economy: −40, military: −50, stability: −40 }**` (a full strike's effect on the struck nation / region owner) and **`NUCLEAR_RETALIATION = { economy: −20, military: −25, stability: −20 }`**` (the half-strength MAD backfire).
+  - **Engine (`server/engine.ts`).**
+    - `validateNuclearOps(raw)` — new exported, defensive validator (never throws): a missing/malformed object yields `{ arm: [], strikes: [] }`; `arm` entries are non-empty strings (≤120 chars) deduped; a strike needs a non-empty `from` **and** `target` (≤120) and is **dropped when it targets itself** (same ref, case-insensitive) — a self-strike is a no-op, never thrown.
+    - `applyNuclearOps(next, ops, state, geoOf?, validKeys?, regionNameOf?, actingTurn?)` — new exported, the load-bearing nuclear block. **`arm` first** (idempotent; a resolve miss or a self-arm is a no-op), then **`strikes`** in order: resolve `from` (an unresolvable or non-capable striker is **dropped** — capability checked against the *pre-turn* marker set plus any flag granted this turn); a `target` that is a **nation** collapses it (the `NUCLEAR_COLLAPSE` deltas applied to its `stats` and every region it owns, each affected nation's derived stats re-derived, 0-region / no-entry guards as elsewhere), ends **every active war it fights** by **capitulation** (`endWarsBetween` captures the active pairs *before* ending so a war declared+ended the same turn is handled), and downgrades the now-inactive `war` relations to `hostile`; a `target` that is a **region key** releases it to no man's land (a key with 0 or 2+ owners, or one the striker itself owns, is **dropped**), deletes its `regionStats` entry, and collapses its **sole owner** the same way. **MAD**: if the struck nation (or the struck region's sole owner) is itself nuclear-capable, it retaliates against the striker for the half-strength `NUCLEAR_RETALIATION` (clamped, mirrored, re-derived) and the two nations' relations are forced to `hostile` (`forceHostile` — both directions, unless already `war`). Each strike and each retaliation appends a dramatic **`military`** event (`war` is not a valid `EventType`). Sole ownership is never broken by a strike (a region is released, not re-claimed) and the block never throws.
+    - `applyTurnResult` — the nuclear block runs **after `industry` and before `markers`** (order: events → relations → territory → stateChanges → recompute → wars → hybrid → economy → industry → **nuclear** → markers → nationOps); it passes the *original* (pre-turn) `state` for the capability marker set and the current `regionNameOf` for event text.
+    - `isMeaningful` — a non-empty `nuclear.arm` or `nuclear.strikes` makes a turn meaningful.
+    - `validateTurnResult` — initializes and validates `nuclear` (default `{ arm: [], strikes: [] }`).
+    - `buildSystemPrompt` — documents the `nuclear` field and a constraint bullet (the capability rule; `arm` is idempotent; a strike hits a nation or a region; the collapse + capitulation + MAD outcomes; at most one strike per turn, always narrated) in both tool and plain modes.
+    - `buildUserPrompt` — new optional `nuclear` param (`Record<string, boolean>`, the per-nation capability map); when provided, each `state.nations` entry in the payload is stamped with its `nuclear` capability; when undefined the key is omitted entirely (stub / no-capability prompt stays byte-identical). `runTurn` always supplies the map (computed from `isNuclearCapable` over `state.markers`).
+  - **Stub (`server/stub.ts`).** `deterministicTurn` always returns `nuclear: { arm: [], strikes: [] }` — the stub **never** arms a nation or fires a strike, so the e2e (CI, `LLM_STUB=1`) is unaffected and the nuclear path is covered by unit tests only.
+  - **Tests.** 29 new unit tests: `isNuclearCapable` (flag / own rocket / non-rocket / other's rocket / null owner); `validateNuclearOps` (well-formed, `arm` dedupe, missing `from`/`target`, self-target drop, malformed top-level); `applyTurnResult` nuclear (arm idempotency across turns, arm+strike same turn, region strike → release + stats deleted + owner collapse + no MAD + the single `military` event, nation strike + pre-existing war → capitulation + hostile, nation strike + same-turn declare → capitulation + hostile, MAD on a capable nation target, MAD on a capable region owner, rocket-marker-only capability, non-capable striker dropped, 2+-owner region dropped, 0-owner/unowned region dropped, self-target dropped, malformed strikes never throw); `isMeaningful` (arm / strike); `buildUserPrompt` (per-nation capability stamped when the map is given, omitted when undefined); and two `db.test.ts` round-trips (a legacy row with no flag loads with it absent; a set flag round-trips through save/load).
+- **Version** bumped `0.36.0 → 0.37.0`.
+
 ## v0.36.0 — 2026-10-15 18:17
 - **#59: Resources & Industry — per-region synthesized resource profiles + a per-region industry-project lever with a deterministic per-turn economy boost.** Every prior lever moved borders, dipped stats one-shot, or proposed a player-confirmed change; this version adds a **resource abundance layer** (every sub-region gets a synthesized 4-value profile) and a **development lever**: the model can build industry projects (oil facilities, iron mines, food operations, factories) in individual regions, and every committed turn each active project pays its region's sole owner a small, deterministic economy gain scaled by the region's `industry` resource value. The engine is **fully deterministic (no hidden randomness)**: the resource profiles are a pure function of the region key (FNV-1a) scaled by an area factor, and the per-turn effect is a fixed, clamped, mirrored, re-derived stat adjustment.
   - **Manifest (`public/region-resources.json`, new).** 1,800 entries — region key → `{ oil, iron, food, industry }` (each 0–1, 2dp) — built by the new turf-free, deterministic, **idempotent** `scripts/build-region-resources.mjs` (`npm run build:region-resources`): per resource, `(fnv1a32(`${key}\u0000${resource}`) & 0x3fff) / 0x4000` → [0,1), times an area factor `1 + 0.2·min(1, log10(1+area)/8)` (max ≈1.2) from `region-geo.json` (missing geo / zero area → pure hash), clamped to 1, keys sorted, byte-identical re-run. Pinned by `scripts/build-region-resources.test.ts` (key-set equality vs `region-keys.json`, sorted order, per-entry shape, spot-checked values, determinism via a re-run).

package.json

@@ -1,6 +1,6 @@
 {
   "name": "history",
-  "version": "0.36.0",
+  "version": "0.38.0",
   "private": true,
   "type": "module",
   "description": "AI-driven alternate-history simulator — the LLM is the world engine (Pax Historia style).",

server/db.test.ts

@@ -178,6 +178,50 @@ describe('openDb', () => {
     db.close();
   });
 
+  it('(v0.37.0 #60) a legacy row saved before the nation nuclear flag existed loads with it absent (not capable)', () => {
+    const db = openDb(':memory:');
+    // makeState has no nation.nuclear field — a pre-v0.37 save. The flag is
+    // optional and not re-stamped by load, so an absent flag stays absent.
+    db.save(makeState('legacy'));
+    const loaded = db.load('legacy');
+    expect(loaded).not.toBeNull();
+    expect(loaded!.nations.uk.nuclear).toBeUndefined();
+    db.close();
+  });
+
+  it('(v0.37.0 #60) a set nation nuclear flag round-trips through save/load', () => {
+    const db = openDb(':memory:');
+    const s = makeState('nuc');
+    s.nations.uk.nuclear = true; // armed (e.g. by a turn's nuclear.arm op)
+    db.save(s);
+    const loaded = db.load('nuc');
+    expect(loaded).not.toBeNull();
+    expect(loaded!.nations.uk.nuclear).toBe(true);
+    db.close();
+  });
+
+  it('(v0.38.0 #61) a legacy row saved before the nation leader field existed loads with it absent (no leader)', () => {
+    const db = openDb(':memory:');
+    // makeState has no nation.leader field — a pre-v0.38 save. The field is
+    // optional and not re-stamped by load, so an absent leader stays absent.
+    db.save(makeState('legacy'));
+    const loaded = db.load('legacy');
+    expect(loaded).not.toBeNull();
+    expect(loaded!.nations.uk.leader).toBeUndefined();
+    db.close();
+  });
+
+  it('(v0.38.0 #61) a set nation leader round-trips through save/load', () => {
+    const db = openDb(':memory:');
+    const s = makeState('ldr');
+    s.nations.uk.leader = { name: 'Admiral Old' };
+    db.save(s);
+    const loaded = db.load('ldr');
+    expect(loaded).not.toBeNull();
+    expect(loaded!.nations.uk.leader).toEqual({ name: 'Admiral Old' });
+    db.close();
+  });
+
   it('delete removes a game by id and reports absence otherwise', () => {
     const db = openDb(':memory:');
     db.save(makeState('a'));

server/engine.test.ts

@@ -1,15 +1,19 @@
 import { describe, expect, it } from 'vitest';
-import type { GameState, MarkerType, Nation, NationStats, Preset, RelationStatus, RegionStats, RoundItem, War } from '../shared/types';
+import type { GameState, MapMarker, MarkerType, Nation, NationStats, Preset, RelationStatus, RegionStats, RoundItem, War } from '../shared/types';
 import {
   CONQUEST_MILITARY_MARGIN,
   makeEvent,
   markerId,
   MAX_MARKERS,
   seedRegionStats,
+  isNuclearCapable,
+  NUCLEAR_COLLAPSE,
+  NUCLEAR_RETALIATION,
   type HybridOp,
   type MarkerInfo,
   type MarkerSpec,
   type NationOp,
+  type NuclearStrike,
   type TurnResult,
 } from '../shared/protocol';
 import type { LlmClient, ToolDefinition, WireMessage } from './llm';
@@ -44,7 +48,9 @@ import {
   validateEconomyOps,
   validateHybridOps,
   validateIndustryOps,
+  validateLeaderOps,
   validateMarkerOps,
+  validateNuclearOps,
   validateNationOps,
   validateRegionChanges,
   validateTakeovers,
@@ -563,7 +569,7 @@ describe('validateNationOps (v0.23 #16 P4a)', () => {
       relations: [],
       territoryChanges: [],
       unowned: [],
-      nationOps: [{ kind: 'rename', nationRef: 'France', to: 'French Republic' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
+      nationOps: [{ kind: 'rename', nationRef: 'France', to: 'French Republic' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] },
     });
     expect(withOps).not.toBeNull();
     expect(withOps!.nationOps).toEqual([{ kind: 'rename', nationRef: 'France', to: 'French Republic' }]);
@@ -585,7 +591,7 @@ describe('applyTurnResult (nation-op proposals, v0.23 #16 P4a)', () => {
       relations: [],
       territoryChanges: [],
       unowned: [],
-      nationOps: [{ kind: 'rename', nationRef: 'de', to: 'Reich' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
+      nationOps: [{ kind: 'rename', nationRef: 'de', to: 'Reich' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] },
     });
     expect(next.nations.de.name).toBe('DE'); // still the old name
     expect(next.pendingNationOps).toEqual([{ kind: 'rename', nationRef: 'de', to: 'Reich' }]);
@@ -606,7 +612,7 @@ describe('applyTurnResult (nation-op proposals, v0.23 #16 P4a)', () => {
       relations: [],
       territoryChanges: [],
       unowned: [],
-      nationOps: [{ kind: 'rename', nationRef: 'us', to: 'USA' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] }, // new proposal this turn
+      nationOps: [{ kind: 'rename', nationRef: 'us', to: 'USA' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] }, // new proposal this turn
     });
     expect(next.pendingNationOps).toEqual([
       { kind: 'rename', nationRef: 'de', to: 'Reich' }, // the old one survived
@@ -625,7 +631,7 @@ describe('applyTurnResult (nation-op proposals, v0.23 #16 P4a)', () => {
       relations: [],
       territoryChanges: [],
       unowned: [],
-      nationOps: [{ kind: 'rename', nationRef: 'de', to: 'Reich' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
+      nationOps: [{ kind: 'rename', nationRef: 'de', to: 'Reich' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] },
     });
     expect(next.pendingNationOps).toEqual([{ kind: 'rename', nationRef: 'de', to: 'Reich' }]);
   });
@@ -1082,7 +1088,7 @@ describe('applyTurnResult', () => {
       relations: [],
       territoryChanges: [],
       unowned: [],
-      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
+      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] },
     };
     applyTurnResult(state, result);
     expect(JSON.stringify(state)).toBe(snapshot);
@@ -1099,7 +1105,7 @@ describe('applyTurnResult', () => {
       relations: [],
       territoryChanges: [],
       unowned: [],
-      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
+      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
     expect(next.pending).toEqual([]);
@@ -1122,7 +1128,7 @@ describe('applyTurnResult', () => {
       // is not a real key at all. Both are proposed as a gain by DE.
       territoryChanges: [{ nation: 'de', gain: ['wales-bbbb', 'not-a-region-xyz'], lose: [] }],
       unowned: [],
-      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
+      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result, new Set(['wales-bbbb']));
     // the valid key was gained (taken from its sole previous owner); the bogus one was ignored
@@ -1148,7 +1154,7 @@ describe('applyTurnResult', () => {
       // released (not in state.unowned), so it does not enter GameState.unowned.
       territoryChanges: [{ nation: 'de', gain: ['POL', 'wales-bbbb'], lose: [] }],
       unowned: [],
-      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
+      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result); // no validKeys -> nothing filtered
     expect(next.nations.de.territory).toContain('wales-bbbb');
@@ -1166,7 +1172,7 @@ describe('applyTurnResult (sole-ownership invariants, v0.21 #16 P2)', () => {
     regionChanges: [],
     relations: [],
     unowned: [],
-    nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
+    nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] },
   };
 
   it('a double claim (two different gainers, one key) is rejected: the key stays with its original owner', () => {
@@ -1256,7 +1262,7 @@ describe('applyTurnResult (no man\'s land, v0.22 #16 P3)', () => {
     relations: [],
     territoryChanges: [],
     unowned: [],
-    nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
+    nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] },
   };
 
   it('a release removes the key from its sole owner and marks it in GameState.unowned', () => {
@@ -1371,7 +1377,7 @@ describe('applyTurnResult (no man\'s land, v0.22 #16 P3)', () => {
 
   it('a lone release is meaningful (it survives the retry/nudge path)', () => {
     expect(
-      isMeaningful({ date: 'x', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [], unowned: ['GBR'], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] } }),
+      isMeaningful({ date: 'x', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [], unowned: ['GBR'], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] } }),
     ).toBe(true);
   });
 
@@ -1678,9 +1684,9 @@ describe('buildSystemPrompt (tool mode, v0.21 #16 P2)', () => {
 
 describe('isMeaningful', () => {
   it('is true with an event, false when everything is empty', () => {
-    expect(isMeaningful({ date: 'x', events: [{ nation: 'uk', type: 'military', title: 't', text: 'b', outcome: 'neutral' }], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [], unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] } })).toBe(true);
-    expect(isMeaningful({ date: 'x', events: [], stateChanges: [{ nation: 'uk', stat: 'military', op: 'set', value: 5 }], regionChanges: [], relations: [], territoryChanges: [], unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] } })).toBe(true);
-    expect(isMeaningful({ date: 'x', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [], unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] } })).toBe(false);
+    expect(isMeaningful({ date: 'x', events: [{ nation: 'uk', type: 'military', title: 't', text: 'b', outcome: 'neutral' }], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [], unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] } })).toBe(true);
+    expect(isMeaningful({ date: 'x', events: [], stateChanges: [{ nation: 'uk', stat: 'military', op: 'set', value: 5 }], regionChanges: [], relations: [], territoryChanges: [], unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] } })).toBe(true);
+    expect(isMeaningful({ date: 'x', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [], unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] } })).toBe(false);
   });
 
   it('(v0.23 #16 P4a) a turn that only proposes a nation-op is meaningful (it survives the retry/nudge path)', () => {
@@ -1693,7 +1699,7 @@ describe('isMeaningful', () => {
         relations: [],
         territoryChanges: [],
         unowned: [],
-        nationOps: [{ kind: 'rename', nationRef: 'de', to: 'Reich' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
+        nationOps: [{ kind: 'rename', nationRef: 'de', to: 'Reich' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] },
       }),
     ).toBe(true);
   });
@@ -1713,6 +1719,7 @@ describe('isMeaningful', () => {
         wars: { declare: [], end: [] },
         hybrid: { ops: [] },
         economy: { trade: [], embargo: [] }, industry: { projects: [] },
+        nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
         markers: { add: [{ type: 'city', name: 'Lyon', regionKey: 'rhone-rhne' }], remove: [] },
       }),
     ).toBe(true);
@@ -1733,6 +1740,7 @@ describe('isMeaningful', () => {
         wars: { declare: [], end: [] },
         hybrid: { ops: [] },
         economy: { trade: [], embargo: [] }, industry: { projects: [] },
+        nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
         markers: { add: [], remove: [] },
       }),
     ).toBe(true);
@@ -1755,6 +1763,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] }, industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1787,6 +1796,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] }, industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1810,6 +1820,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] }, industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1836,6 +1847,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] }, industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1861,6 +1873,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] }, industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
       markers: { add: [], remove: [] },
     });
     expect(validated!.takeovers).toEqual([]);
@@ -1886,6 +1899,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] }, industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1909,6 +1923,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] }, industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1930,6 +1945,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] }, industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1963,6 +1979,7 @@ describe('markers (point placement, v0.27 #44)', () => {
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] }, industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
       markers: { add: [mk('city', 'Strasbourg', 'moselle-rygy')], remove: [] },
     };
     const next = applyTurnResult(state, result, undefined, centroidOf);
@@ -1987,13 +2004,13 @@ describe('markers (point placement, v0.27 #44)', () => {
     const add = [mk('city', 'Strasbourg', 'moselle-rygy')];
     const first = applyTurnResult(state, {
       date: '1939-09-03', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [],
-      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add, remove: [] },
+      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add, remove: [] },
     }, undefined, centroidOf);
     expect(first.markers).toHaveLength(1);
     // a second turn proposes the exact same marker again
     const second = applyTurnResult(first, {
       date: '1939-09-05', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [],
-      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add, remove: [] },
+      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add, remove: [] },
     }, undefined, centroidOf);
     expect(second.markers).toHaveLength(1);
     expect(second.markers[0].id).toBe(first.markers[0].id); // stable id, no second copy
@@ -2019,6 +2036,7 @@ describe('markers (point placement, v0.27 #44)', () => {
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] }, industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
       markers: {
         add: [
           { type: 'city', name: 'Good', regionKey: 'moselle-rygy' }, // valid + centroid → kept
@@ -2065,6 +2083,7 @@ describe('markers (point placement, v0.27 #44)', () => {
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] }, industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
       markers: {
         add: [
           { type: 'city', name: 'NewA', regionKey: 'new-a' },
@@ -2090,7 +2109,7 @@ describe('markers (point placement, v0.27 #44)', () => {
     ];
     const next = applyTurnResult(state, {
       date: '1939-09-03', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [],
-      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [idA, 'zzzz-not-there'] },
+      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [idA, 'zzzz-not-there'] },
     }, undefined, centroidOf);
     expect(next.markers).toHaveLength(1);
     expect(next.markers[0].id).toBe(idB); // only A removed; the bogus id was a no-op
@@ -2106,14 +2125,14 @@ describe('markers (point placement, v0.27 #44)', () => {
     // 1) uk releases the region → the marker becomes ownerless
     const released = applyTurnResult(state, {
       date: '1939-09-03', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [],
-      unowned: ['moselle-rygy'], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
+      unowned: ['moselle-rygy'], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] },
     }, undefined, centroidOf);
     expect(released.markers[0].ownerNationId).toBeNull();
     // 2) de re-claims the region → the marker's owner follows to de
     const reclaimed = applyTurnResult(released, {
       date: '1939-09-05', events: [], stateChanges: [], regionChanges: [], relations: [],
       territoryChanges: [{ nation: 'de', gain: ['moselle-rygy'], lose: [] }],
-      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
+      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, nuclear: { arm: [], strikes: [] }, leaders: { changes: [] }, markers: { add: [], remove: [] },
     }, undefined, centroidOf);
     expect(reclaimed.markers[0].ownerNationId).toBe('de');
   });
@@ -2182,6 +2201,7 @@ describe('markers (point placement, v0.27 #44)', () => {
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] }, industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
       markers: { add: [{ type: 'city', name: 'Strasbourg', regionKey: 'moselle-rygy' }], remove: [] },
     });
     const { state } = await runTurn({
@@ -2275,6 +2295,8 @@ function mkTurnResult(partial: Partial<TurnResult>): TurnResult {
     hybrid: partial.hybrid ?? { ops: [] },
     economy: partial.economy ?? { trade: [], embargo: [] },
     industry: partial.industry ?? { projects: [] },
+    nuclear: partial.nuclear ?? { arm: [], strikes: [] },
+    leaders: partial.leaders ?? { changes: [] },
     markers: partial.markers ?? { add: [], remove: [] },
   };
 }
@@ -2999,6 +3021,7 @@ describe('validateTakeovers (v0.32.0 #54)', () => {
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] }, industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
       markers: { add: [], remove: [] },
     });
     expect(withTakeovers).not.toBeNull();
@@ -3386,6 +3409,7 @@ describe('isMeaningful — wars (v0.33.0 #56)', () => {
         wars: { declare: [{ sides: ['a', 'b'] }], end: [] },
         hybrid: { ops: [] },
         economy: { trade: [], embargo: [] }, industry: { projects: [] },
+        nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
         markers: { add: [], remove: [] },
       }),
     ).toBe(true);
@@ -3406,6 +3430,7 @@ describe('isMeaningful — wars (v0.33.0 #56)', () => {
         wars: { declare: [], end: [{ id: 'w1', outcome: 'armistice' }] },
         hybrid: { ops: [] },
         economy: { trade: [], embargo: [] }, industry: { projects: [] },
+        nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
         markers: { add: [], remove: [] },
       }),
     ).toBe(true);
@@ -3426,6 +3451,7 @@ describe('isMeaningful — wars (v0.33.0 #56)', () => {
         wars: { declare: [], end: [] },
         hybrid: { ops: [] },
         economy: { trade: [], embargo: [] }, industry: { projects: [] },
+        nuclear: { arm: [], strikes: [] }, leaders: { changes: [] },
         markers: { add: [], remove: [] },
       }),
     ).toBe(false);
@@ -4349,3 +4375,448 @@ describe('runTurn — industry (v0.36.0 #59)', () => {
     expect(state.industry).toEqual([]);
   });
 });
+
+// --- Nuclear / WMD (v0.37.0, #60) -------------------------------------------
+
+describe('isNuclearCapable (v0.37.0 #60)', () => {
+  const marker = (id: string, type: MarkerType, ownerNationId: string | null): MapMarker =>
+    ({ id, type, name: 'site', regionKey: 'g1', lat: 0, lon: 0, ownerNationId, placedTurn: 1 });
+  const n = (id: string, nuclear?: boolean): Nation =>
+    nuclear ? { ...mkNation(id, NS(50, 50, 50, 50), []), nuclear } : mkNation(id, NS(50, 50, 50, 50), []);
+
+  it('is true when the nuclear flag is set', () => {
+    expect(isNuclearCapable(n('uk', true), [])).toBe(true);
+  });
+  it('is true when the nation owns a rocket marker (a launch site is an arsenal)', () => {
+    expect(isNuclearCapable(n('uk'), [marker('m1', 'rocket', 'uk')])).toBe(true);
+  });
+  it('is false when the flag is unset and no rocket marker is owned', () => {
+    expect(isNuclearCapable(n('uk'), [marker('m1', 'city', 'uk')])).toBe(false);
+  });
+  it('a rocket marker owned by another nation does not confer capability', () => {
+    expect(isNuclearCapable(n('uk'), [marker('m1', 'rocket', 'de')])).toBe(false);
+  });
+  it('a rocket marker with a null owner does not confer capability', () => {
+    expect(isNuclearCapable(n('uk'), [marker('m1', 'rocket', null)])).toBe(false);
+  });
+});
+
+describe('validateNuclearOps (v0.37.0 #60)', () => {
+  it('accepts well-formed arm + strikes', () => {
+    const out = validateNuclearOps({ arm: ['uk'], strikes: [{ from: 'uk', target: 'de' }] });
+    expect(out).toEqual({ arm: ['uk'], strikes: [{ from: 'uk', target: 'de' }] });
+  });
+  it('dedupes arm refs and drops empty / non-string entries', () => {
+    const out = validateNuclearOps({ arm: ['uk', 'uk', '', '   ', 'de', null, 5] as unknown[] });
+    expect(out.arm).toEqual(['uk', 'de']);
+  });
+  it('drops a strike missing a from or a target', () => {
+    const out = validateNuclearOps({
+      strikes: [
+        { target: 'de' } as unknown as NuclearStrike, // no from
+        { from: 'uk' } as unknown as NuclearStrike, // no target
+        'not-an-object' as unknown as NuclearStrike,
+        null as unknown as NuclearStrike,
+        { from: 'uk', target: 'g1' }, // valid
+      ],
+    });
+    expect(out.strikes).toEqual([{ from: 'uk', target: 'g1' }]);
+  });
+  it('drops a self-target (from === target, case-insensitive)', () => {
+    const out = validateNuclearOps({ strikes: [{ from: 'UK', target: 'uk' }, { from: 'uk', target: 'de' }] });
+    expect(out.strikes).toEqual([{ from: 'uk', target: 'de' }]);
+  });
+  it('a missing / malformed top-level object yields { arm: [], strikes: [] }', () => {
+    expect(validateNuclearOps(undefined)).toEqual({ arm: [], strikes: [] });
+    expect(validateNuclearOps(null)).toEqual({ arm: [], strikes: [] });
+    expect(validateNuclearOps('nope')).toEqual({ arm: [], strikes: [] });
+    expect(validateNuclearOps({})).toEqual({ arm: [], strikes: [] });
+    expect(validateNuclearOps({ arm: 'x', strikes: 'y' })).toEqual({ arm: [], strikes: [] });
+  });
+});
+
+describe('applyTurnResult — nuclear ops (v0.37.0 #60)', () => {
+  // uk starts nuclear-capable (the flag); de is not. Each owns one region.
+  const base = (): GameState => {
+    const uk: Nation = { ...mkNation('uk', NS(50, 50, 50, 50), ['g1']), nuclear: true };
+    const de: Nation = { ...mkNation('de', NS(50, 50, 50, 50), ['d1']) };
+    return mkTurnState({ uk, de }, { g1: RS(50, 50, 50, 50), d1: RS(50, 50, 50, 50) });
+  };
+
+  it('arming a nation sets its nuclear flag (idempotent across turns)', () => {
+    const next = applyTurnResult(base(), mkTurnResult({ nuclear: { arm: ['uk', 'de'], strikes: [] } }));
+    expect(next.nations.uk.nuclear).toBe(true);
+    expect(next.nations.de.nuclear).toBe(true);
+    const next2 = applyTurnResult(next, mkTurnResult({ nuclear: { arm: ['uk'], strikes: [] } }));
+    expect(next2.nations.uk.nuclear).toBe(true);
+    expect(next2.nations.de.nuclear).toBe(true); // unchanged
+  });
+
+  it('a nation that arms this turn is capable and can strike in the same turn', () => {
+    const s = base();
+    delete (s.nations.uk as { nuclear?: boolean }).nuclear; // start unarmed
+    const next = applyTurnResult(s, mkTurnResult({
+      nuclear: { arm: ['uk'], strikes: [{ from: 'uk', target: 'd1' }] },
+    }));
+    expect(next.nations.uk.nuclear).toBe(true);
+    expect(next.unowned).toContain('d1'); // the armed-this-turn strike landed
+  });
+
+  it('a region strike releases the region, deletes its stats, and collapses the owner', () => {
+    const next = applyTurnResult(base(), mkTurnResult({
+      nuclear: { arm: [], strikes: [{ from: 'uk', target: 'd1' }] },
+    }));
+    expect(next.nations.de.territory).toEqual([]);
+    expect(next.unowned).toContain('d1');
+    expect(next.regionStats['d1']).toBeUndefined();
+    expect(next.regionStats['g1']).toBeDefined();
+    expect(next.nations.de.stats.economy).toBe(50 + NUCLEAR_COLLAPSE.economy);
+    expect(next.nations.de.stats.military).toBe(50 + NUCLEAR_COLLAPSE.military);
+    expect(next.nations.de.stats.stability).toBe(50 + NUCLEAR_COLLAPSE.stability);
+    expect(next.nations.de.stats.population).toBe(50);
+    // de is not capable → no MAD, the striker is unharmed
+    expect(next.nations.uk.stats.military).toBe(50);
+    expect(next.nations.uk.stats.economy).toBe(50);
+    expect(next.events).toHaveLength(1);
+    expect(next.events[0].type).toBe('military');
+    expect(next.events[0].title).toBe('Nuclear strike on d1');
+  });
+
+  it('a nation strike devastates the target and ends a shared war in capitulation (relation → hostile)', () => {
+    const s = base();
+    s.wars = [{ id: 'w1', sides: ['uk', 'de'], declaredTurn: 1, declaredDate: '1939-09-01', status: 'active' }];
+    const next = applyTurnResult(s, mkTurnResult({
+      nuclear: { arm: [], strikes: [{ from: 'uk', target: 'de' }] },
+    }));
+    expect(next.nations.de.stats.military).toBe(50 + NUCLEAR_COLLAPSE.military);
+    expect(next.wars.find((w) => w.id === 'w1')?.status).toBe('capitulation');
+    expect(next.nations.uk.relations.de).toBe('hostile');
+    expect(next.nations.de.relations.uk).toBe('hostile');
+    // de is not capable → no MAD
+    expect(next.nations.uk.stats.military).toBe(50);
+  });
+
+  it('a nation strike ends a war declared in the same turn (the sync-then-end ordering)', () => {
+    const next = applyTurnResult(base(), mkTurnResult({
+      wars: { declare: [{ sides: ['uk', 'de'] }], end: [] },
+      nuclear: { arm: [], strikes: [{ from: 'uk', target: 'de' }] },
+    }));
+    const w = next.wars.find((w) => w.sides.includes('uk') && w.sides.includes('de'));
+    expect(w?.status).toBe('capitulation');
+    expect(next.nations.uk.relations.de).toBe('hostile');
+    expect(next.nations.de.relations.uk).toBe('hostile');
+  });
+
+  it('a strike on a nuclear-capable target triggers a MAD retaliation on the striker', () => {
+    const s = base();
+    s.nations.de.nuclear = true; // the target is capable
+    const next = applyTurnResult(s, mkTurnResult({
+      nuclear: { arm: [], strikes: [{ from: 'uk', target: 'de' }] },
+    }));
+    expect(next.nations.de.stats.military).toBe(50 + NUCLEAR_COLLAPSE.military);
+    expect(next.nations.uk.stats.military).toBe(50 + NUCLEAR_RETALIATION.military);
+    expect(next.nations.uk.stats.economy).toBe(50 + NUCLEAR_RETALIATION.economy);
+    expect(next.nations.uk.stats.stability).toBe(50 + NUCLEAR_RETALIATION.stability);
+    expect(next.nations.uk.relations.de).toBe('hostile');
+    expect(next.nations.de.relations.uk).toBe('hostile');
+    expect(next.events).toHaveLength(2);
+    expect(next.events.some((e) => e.title === 'MAD retaliation')).toBe(true);
+  });
+
+  it('a region strike on a nuclear-capable owner triggers a MAD retaliation', () => {
+    const s = base();
+    s.nations.de.nuclear = true; // the owner of d1 is capable
+    const next = applyTurnResult(s, mkTurnResult({
+      nuclear: { arm: [], strikes: [{ from: 'uk', target: 'd1' }] },
+    }));
+    expect(next.unowned).toContain('d1');
+    expect(next.nations.de.stats.military).toBe(50 + NUCLEAR_COLLAPSE.military);
+    expect(next.nations.uk.stats.military).toBe(50 + NUCLEAR_RETALIATION.military);
+    expect(next.nations.uk.relations.de).toBe('hostile');
+    expect(next.nations.de.relations.uk).toBe('hostile');
+    expect(next.events).toHaveLength(2);
+  });
+
+  it('a nation with a rocket marker (not the flag) can strike', () => {
+    const s = base();
+    delete (s.nations.uk as { nuclear?: boolean }).nuclear; // no flag
+    s.markers = [{ id: 'm1', type: 'rocket', name: 'site', regionKey: 'g1', lat: 0, lon: 0, ownerNationId: 'uk', placedTurn: 1 }];
+    const next = applyTurnResult(s, mkTurnResult({
+      nuclear: { arm: [], strikes: [{ from: 'uk', target: 'd1' }] },
+    }));
+    expect(next.unowned).toContain('d1');
+  });
+
+  it('a strike by a non-nuclear-capable nation is dropped (never thrown)', () => {
+    const s = base();
+    delete (s.nations.uk as { nuclear?: boolean }).nuclear;
+    const next = applyTurnResult(s, mkTurnResult({
+      nuclear: { arm: [], strikes: [{ from: 'uk', target: 'd1' }] },
+    }));
+    expect(next.nations.de.territory).toEqual(['d1']);
+    expect(next.unowned).toEqual([]);
+    expect(next.nations.de.stats.military).toBe(50);
+    expect(next.events).toHaveLength(0);
+  });
+
+  it('a strike on a region with two or more owners is dropped (never thrown)', () => {
+    const s = base();
+    s.nations.uk.territory = ['g1', 'd1']; // d1 now has two owners (uk, de)
+    const next = applyTurnResult(s, mkTurnResult({
+      nuclear: { arm: [], strikes: [{ from: 'uk', target: 'd1' }] },
+    }));
+    expect(next.unowned).toEqual([]);
+    expect(next.nations.de.stats.military).toBe(50);
+    expect(next.events).toHaveLength(0);
+  });
+
+  it('a strike on an unowned (no-man\'s-land) region is dropped (nothing to devastate)', () => {
+    const s = base();
+    s.nations.de.territory = []; // d1 has zero owners
+    s.unowned = ['d1'];
+    delete s.regionStats['d1'];
+    const next = applyTurnResult(s, mkTurnResult({
+      nuclear: { arm: [], strikes: [{ from: 'uk', target: 'd1' }] },
+    }));
+    expect(next.unowned).toEqual(['d1']);
+    expect(next.nations.uk.stats.military).toBe(50);
+    expect(next.events).toHaveLength(0);
+  });
+
+  it('a strike whose target is the striker itself is dropped (never thrown)', () => {
+    const next = applyTurnResult(base(), mkTurnResult({
+      nuclear: { arm: [], strikes: [{ from: 'uk', target: 'uk' }] },
+    }));
+    expect(next.nations.uk.stats.military).toBe(50);
+    expect(next.events).toHaveLength(0);
+  });
+
+  it('never throws on malformed strikes (unknown from, unknown target, empty strings)', () => {
+    const next = applyTurnResult(base(), mkTurnResult({
+      nuclear: {
+        arm: [],
+        strikes: [
+          { from: 'ghost', target: 'de' },
+          { from: 'uk', target: 'nowhere' },
+          { from: 'uk', target: '' },
+        ],
+      },
+    }));
+    expect(next.nations.de.stats.military).toBe(50);
+    expect(next.events).toHaveLength(0);
+  });
+});
+
+describe('isMeaningful — nuclear (v0.37.0 #60)', () => {
+  it('a turn with only an arm op or a strike is meaningful', () => {
+    expect(isMeaningful(mkTurnResult({ nuclear: { arm: ['uk'], strikes: [] } }))).toBe(true);
+    expect(isMeaningful(mkTurnResult({ nuclear: { arm: [], strikes: [{ from: 'uk', target: 'de' }] } }))).toBe(true);
+  });
+  it('a turn with empty nuclear ops and nothing else is not meaningful', () => {
+    expect(isMeaningful(mkTurnResult({ nuclear: { arm: [], strikes: [] }, leaders: { changes: [] } }))).toBe(false);
+  });
+});
+
+describe('buildUserPrompt — nuclear capability (v0.37.0 #60)', () => {
+  const state = (): GameState =>
+    mkTurnState(
+      {
+        uk: { ...mkNation('uk', NS(50, 50, 50, 50), ['g1']), nuclear: true },
+        de: mkNation('de', NS(50, 50, 50, 50), ['d1']),
+      },
+      { g1: RS(50, 50, 50, 50), d1: RS(50, 50, 50, 50) },
+    );
+
+  it('stamps each nation\'s nuclear capability when the map is provided', () => {
+    const out = JSON.parse(
+      buildUserPrompt(state(), [], undefined, undefined, [], [], undefined, undefined, undefined, undefined, undefined, undefined, {
+        uk: true,
+        de: false,
+      }),
+    );
+    expect(out.state.nations.uk.nuclear).toBe(true);
+    expect(out.state.nations.de.nuclear).toBe(false);
+  });
+
+  it('omits the nuclear capability entirely when the map is undefined', () => {
+    const out = JSON.parse(
+      buildUserPrompt(state(), [], undefined, undefined, [], [], undefined, undefined, undefined, undefined, undefined, undefined),
+    );
+    expect(out.state.nations.uk).not.toHaveProperty('nuclear');
+    expect(out.state.nations.de).not.toHaveProperty('nuclear');
+  });
+});
+
+describe('named leaders (v0.38.0 #61)', () => {
+  // `uk` starts with a named leader; `de` has none. Each owns one region
+  // seeded to its stats (the fresh-state invariant), so a uniform dip leaves
+  // the derived median equal to the dipped value.
+  const leaderBase = (): GameState => {
+    const uk: Nation = { ...mkNation('uk', NS(50, 50, 50, 50), ['g1']), leader: { name: 'Admiral Old' } };
+    const de: Nation = { ...mkNation('de', NS(50, 50, 50, 50), ['d1']) };
+    return mkTurnState({ uk, de }, { g1: RS(50, 50, 50, 50), d1: RS(50, 50, 50, 50) });
+  };
+
+  describe('validateLeaderOps', () => {
+    it('accepts a {changes} object and a bare array of valid changes', () => {
+      const fromObj = validateLeaderOps({
+        changes: [
+          { target: 'uk', name: 'New Leader', cause: 'assassination' },
+          { target: 'de', name: 'Other', cause: 'death' },
+        ],
+      });
+      expect(fromObj).toEqual([
+        { target: 'uk', name: 'New Leader', cause: 'assassination' },
+        { target: 'de', name: 'Other', cause: 'death' },
+      ]);
+      expect(validateLeaderOps([{ target: 'uk', name: 'X', cause: 'appointed' }])).toEqual([
+        { target: 'uk', name: 'X', cause: 'appointed' },
+      ]);
+    });
+
+    it('drops a change with an unknown cause', () => {
+      expect(validateLeaderOps({ changes: [{ target: 'uk', name: 'X', cause: 'explosion' }] })).toEqual([]);
+    });
+
+    it('drops a change missing a target or a name', () => {
+      expect(
+        validateLeaderOps({
+          changes: [
+            { target: '', name: 'X', cause: 'appointed' },
+            { target: 'uk', name: '', cause: 'death' },
+          ],
+        }),
+      ).toEqual([]);
+    });
+
+    it('returns [] for undefined / non-object / non-array-changes input', () => {
+      expect(validateLeaderOps(undefined)).toEqual([]);
+      expect(validateLeaderOps('nope')).toEqual([]);
+      expect(validateLeaderOps({ changes: 'nope' })).toEqual([]);
+    });
+
+    it('keeps only the valid changes of a mixed batch', () => {
+      const out = validateLeaderOps({
+        changes: [
+          { target: 'uk', name: 'Good', cause: 'appointed' },
+          { target: 'uk', name: 'Bad', cause: 'nope' },
+          null,
+          { target: 'uk', name: 'Also Good', cause: 'death' },
+        ],
+      });
+      expect(out).toEqual([
+        { target: 'uk', name: 'Good', cause: 'appointed' },
+        { target: 'uk', name: 'Also Good', cause: 'death' },
+      ]);
+    });
+  });
+
+  describe('isMeaningful — leaders', () => {
+    it('a turn with only a leader change is meaningful', () => {
+      expect(isMeaningful(mkTurnResult({ leaders: { changes: [{ target: 'uk', name: 'X', cause: 'death' }] } }))).toBe(true);
+    });
+    it('a turn with empty leaders and nothing else is not meaningful', () => {
+      expect(isMeaningful(mkTurnResult({ leaders: { changes: [] } }))).toBe(false);
+    });
+  });
+
+  describe('applyTurnResult — leaders', () => {
+    it('assassinating a nation with a leader replaces it, dips stability, and adds a military event', () => {
+      const next = applyTurnResult(
+        leaderBase(),
+        mkTurnResult({ leaders: { changes: [{ target: 'uk', name: 'New Leader', cause: 'assassination' }] } }),
+      );
+      expect(next.nations.uk.leader).toEqual({ name: 'New Leader' });
+      expect(next.nations.uk.stats.stability).toBe(35); // 50 - 15
+      expect(next.regionStats.g1.stability).toBe(35); // mirrored to the region
+      expect(next.events).toHaveLength(1);
+      expect(next.events[0]!.type).toBe('military');
+    });
+
+    it('assassinating a leaderless nation is dropped (no leader, no stat change, no event)', () => {
+      const next = applyTurnResult(
+        leaderBase(),
+        mkTurnResult({ leaders: { changes: [{ target: 'de', name: 'New Leader', cause: 'assassination' }] } }),
+      );
+      expect(next.nations.de.leader).toBeUndefined();
+      expect(next.nations.de.stats).toEqual(NS(50, 50, 50, 50));
+      expect(next.events).toHaveLength(0);
+    });
+
+    it('a death of a leader replaces it, dips stability a little, and adds a political succession event', () => {
+      const next = applyTurnResult(
+        leaderBase(),
+        mkTurnResult({ leaders: { changes: [{ target: 'uk', name: 'Successor', cause: 'death' }] } }),
+      );
+      expect(next.nations.uk.leader).toEqual({ name: 'Successor' });
+      expect(next.nations.uk.stats.stability).toBe(47); // 50 - 3
+      expect(next.events).toHaveLength(1);
+      expect(next.events[0]!.type).toBe('political');
+    });
+
+    it('a death of a leaderless nation is dropped', () => {
+      const next = applyTurnResult(
+        leaderBase(),
+        mkTurnResult({ leaders: { changes: [{ target: 'de', name: 'X', cause: 'death' }] } }),
+      );
+      expect(next.nations.de.leader).toBeUndefined();
+      expect(next.nations.de.stats).toEqual(NS(50, 50, 50, 50));
+      expect(next.events).toHaveLength(0);
+    });
+
+    it('an appointment on a nation that has a leader replaces it with no stability dip', () => {
+      const next = applyTurnResult(
+        leaderBase(),
+        mkTurnResult({ leaders: { changes: [{ target: 'uk', name: 'New PM', cause: 'appointed' }] } }),
+      );
+      expect(next.nations.uk.leader).toEqual({ name: 'New PM' });
+      expect(next.nations.uk.stats).toEqual(NS(50, 50, 50, 50)); // neutral: no dip
+      expect(next.events).toHaveLength(1);
+      expect(next.events[0]!.type).toBe('political');
+    });
+
+    it('an appointment creates the first leader on a leaderless nation', () => {
+      const next = applyTurnResult(
+        leaderBase(),
+        mkTurnResult({ leaders: { changes: [{ target: 'de', name: 'First', cause: 'appointed' }] } }),
+      );
+      expect(next.nations.de.leader).toEqual({ name: 'First' });
+      expect(next.nations.de.stats).toEqual(NS(50, 50, 50, 50));
+    });
+
+    it('a leader change on a multi-region nation dips every region and re-derives its stats', () => {
+      const uk: Nation = { ...mkNation('uk', NS(50, 50, 50, 50), ['g1', 'g2']), leader: { name: 'Old' } };
+      const state = mkTurnState({ uk }, { g1: RS(50, 50, 50, 50), g2: RS(50, 50, 50, 50) });
+      const next = applyTurnResult(
+        state,
+        mkTurnResult({ leaders: { changes: [{ target: 'uk', name: 'New', cause: 'assassination' }] } }),
+      );
+      expect(next.regionStats.g1.stability).toBe(35);
+      expect(next.regionStats.g2.stability).toBe(35);
+      expect(next.nations.uk.stats.stability).toBe(35); // re-derived from the dipped regions
+    });
+
+    it('an unknown target is dropped without throwing (no leader change, no event, no crash)', () => {
+      const next = applyTurnResult(
+        leaderBase(),
+        mkTurnResult({ leaders: { changes: [{ target: 'ghost', name: 'X', cause: 'assassination' }] } }),
+      );
+      expect(next.nations.uk.leader).toEqual({ name: 'Admiral Old' }); // untouched
+      expect(next.events).toHaveLength(0);
+    });
+
+    it('an ambiguous target (two nations share the name) is dropped without throwing', () => {
+      const a: Nation = { ...mkNation('a', NS(50, 50, 50, 50), ['g1']), name: 'Same', leader: { name: 'Old' } };
+      const b: Nation = { ...mkNation('b', NS(50, 50, 50, 50), ['d1']), name: 'Same' };
+      const state = mkTurnState({ a, b }, { g1: RS(50, 50, 50, 50), d1: RS(50, 50, 50, 50) });
+      const next = applyTurnResult(
+        state,
+        mkTurnResult({ leaders: { changes: [{ target: 'Same', name: 'New', cause: 'assassination' }] } }),
+      );
+      // 'Same' matches two nations -> ambiguous -> dropped; neither leader changes.
+      expect(next.nations.a.leader).toEqual({ name: 'Old' });
+      expect(next.nations.b.leader).toBeUndefined();
+      expect(next.events).toHaveLength(0);
+    });
+  });
+});

server/engine.ts

@@ -33,9 +33,13 @@ import {
   HYBRID_OP_TYPES,
   isDateLike,
   isMarkerType,
+  isNuclearCapable,
+  LEADER_STABILITY_EFFECT,
   makeEvent,
   markerId,
   MAX_MARKERS,
+  NUCLEAR_COLLAPSE,
+  NUCLEAR_RETALIATION,
   nationForPrompt,
   type EconomyEmbargoOp,
   type EconomyOps,
@@ -43,9 +47,13 @@ import {
   type HybridOp,
   type HybridOpType,
   type IndustryOps,
+  type LeaderCause,
+  type LeaderChange,
   type MarkerInfo,
   type MarkerSpec,
   type NationOp,
+  type NuclearOps,
+  type NuclearStatKey,
   type RegionStatChange,
   type Takeover,
   type TurnEventSpec,
@@ -237,6 +245,8 @@ export function buildSystemPrompt(preset: Preset, withNeighboursTool = false): s
     '  "hybrid": {"ops":[{"type":"<spy|sabotage|assassinate|cyber|economic|information|proxy>","from":"<nation id or name>","target":"<nation id or name, or region key>","detail":"<short detail>","outcome":"<success|exposed>"}]},',
     '  "economy": {"trade":[{"a":"<nationId>","b":"<nationId>","lift":<true|false>}],"embargo":[{"from":"<nationId>","target":"<nationId>","lift":<true|false>}]},',
     '  "industry": {"projects":[{"regionKey":"<region key>","type":"<oil|iron|food|industry>"}]},',
+    '  "nuclear": {"arm":["<nation id or name>"],"strikes":[{"from":"<nuclear-capable nation id or name>","target":"<nation id or name, or region key>"}]},',
+    '  "leaders": {"changes":[{"target":"<nation id or name>","name":"<new leader name>","cause":"<assassination|death|appointed>"}]},',
     '  "markers": {"add":[{"type":"<city|factory|army|port|capital|fleet|rocket|gathering>","name":"<short name>","regionKey":"<region key>"}],"remove":["<marker id>"]}',
     '}',
     '',
@@ -259,7 +269,9 @@ export function buildSystemPrompt(preset: Preset, withNeighboursTool = false): s
     '- Covert / hybrid ops ("hybrid.ops") are non-kinetic operations — spies, sabotage, assassination attempts, cyberattacks, economic pressure, disinformation, and proxy support. Unlike territory they NEVER move borders: a successful op applies a small, deterministic effect (a small dip in the target\'s economy / stability / military for sabotage / assassinate / cyber / economic, or a relation nudge toward hostile for information / proxy), while an "exposed" op backfires (no effect, and the actor\'s relation with the target sours by one step toward hostile). "target" may be a nation id / name or a region key (a region key hits that region\'s sole owner). Keep each detail short, propose at most a few per turn, and narrate each op in "events".',
     '- Economy ("economy") is the trade & embargo layer: a bilateral trade (trade: {"a":"..","b":".."}) gives BOTH parties a small, deterministic economy gain every turn, while a unilateral embargo (embargo: {"from":"..","target":".."}) lowers only the TARGET\'s economy every turn. Omit "lift" to declare / impose, and set "lift":true to end or lift an existing one (the user message\'s "trades"/"embargoes" fields list what is currently active). Propose at most 1-2 operations per turn and narrate each one in "events". Trades and embargoes between nations at war are suspended automatically by the engine.',
     '- Industry ("industry") is the per-resource development lever: each project is a building in one region you (or a nation) controls — {"regionKey":"<region key>","type":"<oil|iron|food|industry>"} (an oil facility, an iron mine, a food operation, or a factory). Every committed turn each active project gives its region\'s owner a small, deterministic economy gain, the bigger the region\'s industry profile (see the "resources" field). A region holds at most one project — do not re-declare one on a region that already has one (the user message\'s "industry" field lists what is already built). Propose at most 1-2 new projects per turn and narrate each one in "events".',
-    '- Prefer 1-4 events per turn; keep each text 1-3 sentences.',
+    '- Nuclear / WMD ("nuclear"): a nation is "nuclear-capable" when its "nuclear" flag is true or it currently owns a "rocket" marker. "arm" names (by id or name) nations to grant the "nuclear" flag — idempotent (already-armed nations are unchanged); a newly armed nation is capable this same turn. "strikes" is a list of "NuclearStrike" objects, each "{from, target}" — "from" is the striking nation (must be nuclear-capable and never itself) and "target" is either a nation (its nation collapses: economy -40, military -50, stability -40; every active war the target fights ends by capitulation and the "war" relations it caused downgrade to "hostile") or a region key (that region is released to no man\'s land, its regionStats entry deleted, and its sole owner collapses the same way — a region with 0 or 2+ owners, or one the striker itself owns, is dropped). If the struck nation (or the struck region\'s owner) is itself nuclear-capable, a "MAD" retaliation is applied: it strikes the striker back for half the collapse, and the two nations\' relations are forced to "hostile". At most one strike per turn; always narrate a strike (and a retaliation, if any) in "events".',
+    '- Leaders ("leaders") name each nation\'s current head of state and change it. Each change is {"target":"<nation id or name>","name":"<new leader name>","cause":"<assassination|death|appointed>"}: "assassination" kills the current leader (a dramatic, destabilizing blow — a −15 stability dip, a "military" event) and is only valid when the target already has a leader; "death" is a natural-causes succession (a quieter −3 dip, a "political" event), also only valid for a nation that has a leader; "appointed" sets (or creates) a leader and is always valid (a neutral 0 effect, a "political" event). Propose at most 1-2 changes per turn and narrate each one in "events". This is the HEAVY leader lever — use the lighter "hybrid" {"type":"assassinate"} op (a −5 stability dip, no leader replacement) for a mere hit on a leader or region without changing who is in charge. The user message\'s "nations" field lists each nation\'s current "leader" (omitted when a nation has none).',
+  '- Prefer 1-4 events per turn; keep each text 1-3 sentences.',
     '- Keep your internal reasoning brief (a few sentences) and go straight to the JSON result; do not over-deliberate or re-derive facts already present in the state.',
     '- Keep every stat value between 0 and 100.',
     '- Per-region stat changes ("regionChanges") target ONE region\'s stats directly, by its region key (preferred) or name, and make that region differ from the rest of its nation (a garrisoned border province, a bombed-out city, an industrial heartland). A nation-wide "stateChanges" entry applies to ALL of a nation\'s regions; a "regionChanges" entry overrides it for that one region. The user message\'s "playerRegionStats" lists the player\'s own regions\' current stats; use region keys from the "regions" table.',
@@ -351,6 +363,15 @@ export function buildUserPrompt(
    * can reference them. Omitted entirely when undefined.
    */
   industryProjects?: IndustryProject[],
+  /**
+   * (v0.37.0, #60) Each nation's nuclear capability (nation id -> boolean),
+   * computed by the caller via `isNuclearCapable` (the nation's `nuclear` flag
+   * OR a current `rocket` marker). When defined, each nation in the `state.
+   * nations` map is stamped with `nuclear: true|false` so the model knows who
+   * can arm/strike and who can MAD-retaliate. Omitted entirely (no `nuclear`
+   * key on any nation) when undefined.
+   */
+  nuclear?: Record<string, boolean>,
 ): string {
   const player = state.nations[state.playerNationId];
   const playerName = player?.name ?? state.playerNationId;
@@ -440,7 +461,10 @@ export function buildUserPrompt(
       date: state.date,
       playerNationId: state.playerNationId,
       nations: Object.fromEntries(
-        Object.entries(state.nations).map(([id, n]) => [id, nationForPrompt(n)]),
+        Object.entries(state.nations).map(([id, n]) => [
+          id,
+          nuclear ? { ...nationForPrompt(n), nuclear: nuclear[id] ?? false } : nationForPrompt(n),
+        ]),
       ),
       recentEvents: state.events.slice(-5).map((e) => ({
         turn: e.turn,
@@ -611,6 +635,8 @@ export function validateTurnResult(
     hybrid: { ops: [] },
     economy: { trade: [], embargo: [] },
     industry: { projects: [] },
+    nuclear: { arm: [], strikes: [] },
+    leaders: { changes: [] },
     markers: { add: [], remove: [] },
   };
 
@@ -729,6 +755,21 @@ export function validateTurnResult(
   // is kept). Refs stay raw and the effect is deterministic at apply time.
   result.industry = validateIndustryOps(o.industry);
 
+  // (v0.37, #60) Nuclear / WMD ops: `arm` grants an arsenal to the named
+  // nations and `strikes` are nuclear strikes fired this turn. Refs stay raw
+  // here (resolved against the real state at apply time, like wars / hybrid
+  // ops); an unresolvable ref, a non-capable striker, or an invalid region is
+  // dropped at apply time, never thrown. Applied directly by applyTurnResult
+  // (after industry, before markers).
+  result.nuclear = validateNuclearOps(o.nuclear);
+
+  // (v0.38, #61) Leader changes: assassinations / deaths / appointments of
+  // named leaders. Refs stay raw here (resolved against the real state at
+  // apply time, like wars / hybrid / nuclear ops); an unresolvable target or a
+  // leaderless assassination/death is dropped at apply time, never thrown.
+  // Applied by applyTurnResult after nuclear, before markers.
+  result.leaders = { changes: validateLeaderOps(o.leaders) };
+
   // (v0.27, #44) Map-marker ops: new placements (validated here) and
   // removals by stable id. Applied by applyTurnResult after the territory
   // moves (a new marker's owner is the region's post-turn owner).
@@ -1031,6 +1072,73 @@ export function validateIndustryOps(raw: unknown): IndustryOps {
   return out;
 }
 
+/**
+ * (v0.37, #60) Validate the raw `nuclear` object of a turn into a safe
+ * {@link NuclearOps}. Defensive like the rest of the parser — never throws.
+ * `arm`: non-empty nation refs (capped at 120 chars), deduped; a ref is
+ * resolved (id or name) at APPLY time, so an unknown ref is dropped there, not
+ * here. `strikes`: each needs a non-empty `from` (the striking nation ref) and
+ * a non-empty `target` (a nation ref OR a region key), each capped at 120
+ * chars; a self-target (`from` and `target` the same ref) is dropped here. A
+ * missing / malformed top-level object yields `{ arm: [], strikes: [] }`.
+ */
+export function validateNuclearOps(raw: unknown): NuclearOps {
+  const out: NuclearOps = { arm: [], strikes: [] };
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return out;
+  const o = raw as Record<string, unknown>;
+  if (Array.isArray(o.arm)) {
+    for (const e of o.arm) {
+      const s = typeof e === 'string' ? e.trim() : '';
+      if (s && !out.arm.includes(s)) out.arm.push(s.slice(0, 120));
+    }
+  }
+  if (Array.isArray(o.strikes)) {
+    for (const e of o.strikes) {
+      if (!e || typeof e !== 'object') continue;
+      const s = e as Record<string, unknown>;
+      const from = str(s.from, 120);
+      const target = str(s.target, 120);
+      if (!from || !target) continue;
+      if (from.toLowerCase() === target.toLowerCase()) continue; // self-target: drop
+      out.strikes.push({ from, target });
+    }
+  }
+  return out;
+}
+
+/**
+ * (v0.38, #61) Validate the raw `leaders` object of a turn into a safe
+ * `LeaderChange[]`. Defensive like the rest of the parser — never throws.
+ * Accepts a `{ changes: [...] }` object or a bare array (lenient). Each change
+ * needs a non-empty `target` (a nation ref, capped at 120 chars), a non-empty
+ * `name` (the new leader's name, capped at 120 chars), and a `cause` that is
+ * one of the three known literals (assassination / death / appointed). Refs
+ * stay raw here (resolved against the real state at apply time, like the wars
+ * / hybrid / nuclear ops); a leaderless assassination/death is dropped at
+ * apply time, never thrown.
+ */
+export function validateLeaderOps(raw: unknown): LeaderChange[] {
+  const out: LeaderChange[] = [];
+  const list = Array.isArray(raw)
+    ? raw
+    : raw && typeof raw === 'object'
+      ? (raw as Record<string, unknown>).changes
+      : undefined;
+  if (!Array.isArray(list)) return out;
+  for (const e of list) {
+    if (!e || typeof e !== 'object') continue;
+    const s = e as Record<string, unknown>;
+    const target = str(s.target, 120);
+    const name = str(s.name, 120);
+    if (!target || !name) continue;
+    const cause = typeof s.cause === 'string' ? s.cause : '';
+    if (cause === 'assassination' || cause === 'death' || cause === 'appointed') {
+      out.push({ target, name, cause: cause as LeaderCause });
+    }
+  }
+  return out;
+}
+
 /**
  * (v0.33.0, #56) The UNORDERED pairs of belligerents of a set of ACTIVE
  * wars: a war with sides [a, b, c] contributes the pairs {a,b}, {a,c},
@@ -1315,6 +1423,85 @@ function applyHybridOp(
   else if (op.type === 'proxy') shiftRelationTowardHostile(next, from, target.nation.id, 'rival');
 }
 
+// --- Named leaders (v0.38, #61) -----------------------------------------------
+
+/**
+ * (v0.38, #61) Apply a single leader change to `next` (in place). The target
+ * nation is resolved by the shared resolver (id first, then a case-insensitive
+ * unique name; an unknown or ambiguous ref is dropped, never thrown). A GATE
+ * then applies: an `assassination` or `death` requires the target to already
+ * have a leader (a leaderless target is dropped); an `appointed` change is
+ * always valid (it creates the first leader). On a valid change the target's
+ * `leader` is set to the new name and a DETERMINISTIC stability dip
+ * (`LEADER_STABILITY_EFFECT[cause]`) is applied to its `stats.stability`
+ * (clamped 0–100) and mirrored to every region the nation owns
+ * (`regionStats`); the nation's derived stats are re-derived afterwards (the
+ * same 0-region / no-entry guards as the hybrid/economy/industry effects, so a
+ * 0-region nation keeps its directly-mutated value). Finally a narration event
+ * is appended: a dramatic `military` event for an assassination, a `political`
+ * succession event for a death or an appointment. The replacement never moves
+ * territory (sole ownership is untouched).
+ */
+function applyLeaderChange(
+  next: GameState,
+  op: LeaderChange,
+  geoOf?: (key: string) => { area: number; population: number } | undefined,
+  actingTurn?: number,
+): void {
+  const turn = actingTurn ?? next.turn;
+  const id = resolveNationRef(next, op.target);
+  if (id === null) return; // unknown / ambiguous target: drop, never throw
+  const n = next.nations[id];
+
+  // GATE: assassination / death require an existing leader; an appointment is
+  // always valid (it creates the first leader).
+  if (op.cause !== 'appointed' && !n.leader) return;
+
+  const prevName = n.leader?.name;
+  n.leader = { name: op.name };
+
+  const delta = LEADER_STABILITY_EFFECT[op.cause];
+  if (delta !== 0) {
+    n.stats.stability = clampStat(n.stats.stability + delta);
+    for (const key of n.territory) {
+      const rs = next.regionStats[key];
+      if (!rs) continue;
+      rs.stability = clampStat(rs.stability + delta);
+    }
+    // Re-derive the nation's aggregate stats (the main recompute ran earlier
+    // this turn, so without this the dip would be washed out next turn).
+    if (n.territory.length > 0 && n.territory.some((k) => next.regionStats[k])) {
+      n.stats = deriveNationStats(n.territory, next.regionStats, geoOf);
+    }
+  }
+
+  const title =
+    op.cause === 'assassination'
+      ? `${prevName ?? 'The leader'} of ${n.name} is assassinated`
+      : op.cause === 'death'
+        ? `${prevName ?? 'The leader'} of ${n.name} dies`
+        : `${n.name} appoints ${op.name}`;
+  const text =
+    op.cause === 'assassination'
+      ? `${n.name}'s leader ${prevName ?? ''} was assassinated; ${op.name} takes power amid turmoil.`
+      : op.cause === 'death'
+        ? `${n.name}'s leader ${prevName ?? ''} has died; ${op.name} succeeds to power.`
+        : `${n.name} has appointed ${op.name} as its new leader.`;
+  next.events.push(
+    makeEvent(
+      {
+        nation: n.id,
+        type: op.cause === 'assassination' ? 'military' : 'political',
+        title,
+        text,
+        outcome: 'success',
+      },
+      turn,
+      next.date,
+    ),
+  );
+}
+
 // --- Economy ops: trade + embargo (v0.35.0, #58) ------------------------------
 
 /**
@@ -1556,6 +1743,300 @@ export function applyIndustryEffects(
   }
 }
 
+// --- Nuclear / WMD (v0.37, #60): the WMD lever --------------------------------
+//
+// A nuclear strike is a DETERMINISTIC devastation (no hidden randomness): the
+// LLM decides which nuclear-capable nation strikes and what it targets; the
+// engine decides the size of the effect (NUCLEAR_COLLAPSE / NUCLEAR_RETALIATION
+// in protocol.ts). This block runs AFTER the industry effects and BEFORE the
+// marker owner-recompute, because a region strike RELEASES its region to no
+// man's land, which changes the final ownership the markers depend on.
+//
+//   ARM: each `arm` ref (id or name) is resolved and that nation's `nuclear`
+//        flag is set to true (idempotent; an unresolvable ref is dropped).
+//        Arming runs first, so a nation that arms AND strikes this turn is
+//        capable.
+//
+//   STRIKE: each strike is validated independently (never throws):
+//     (a) `from` must resolve to a nuclear-capable nation (the `nuclear` flag
+//         or a rocket marker), else dropped.
+//     (b) The target is a NATION (a ref resolving to a distinct nation) or a
+//         REGION (a region key / name with a SOLE owner that is not the
+//         striker):
+//         - a nation target: the target's economy / military / stability are
+//           devastated (NUCLEAR_COLLAPSE, mirrored to its regions); if `from`
+//           and the target are on opposite sides of an active war, that war
+//           ends in `capitulation` and the warring relation falls back to
+//           hostile; if the target is nuclear-capable, the striker suffers a
+//           half-strength MAD retaliation.
+//         - a region target: the region is released to no man's land (its
+//           regionStats entry leaves the table), its former owner is
+//           devastated (NUCLEAR_COLLAPSE), and if that owner is nuclear-capable
+//           the striker suffers a half-strength MAD retaliation.
+//     (c) every applied strike appends a dramatic event (the EXISTING `military`
+//         category — no new category is invented), and a MAD strike appends an
+//         extra "MAD retaliation" event.
+//
+//   After all strikes, every affected nation's derived stats are re-derived
+//   (the same 0-region / no-entry guards as the main recompute), so the
+//   collapse persists and the sole-ownership invariant is untouched.
+
+/** The three stats a nuclear strike collapses (population is never touched). */
+const NUCLEAR_STATS: NuclearStatKey[] = ['economy', 'military', 'stability'];
+
+/**
+ * Devastate one nation's stats AND every region it owns (mirroring the
+ * collapse into `regionStats`, like the economy / hybrid layers), clamped to
+ * 0–100. Never throws.
+ */
+function collapseNationStats(
+  next: GameState,
+  nationId: string,
+  collapse: Record<NuclearStatKey, number>,
+): void {
+  const n = next.nations[nationId];
+  if (!n) return;
+  for (const k of NUCLEAR_STATS) {
+    const d = collapse[k];
+    n.stats[k] = clampStat(n.stats[k] + d);
+    for (const key of n.territory) {
+      const rs = next.regionStats[key];
+      if (rs) rs[k] = clampStat(rs[k] + d);
+    }
+  }
+}
+
+/**
+ * Release a region key to no man's land, reusing the turn's release semantics:
+ * the key leaves its SOLE owner's territory, is marked in `GameState.unowned`,
+ * and its `regionStats` entry is deleted. A key with 0 or 2+ owners (or an
+ * already-unowned key) is left untouched. Never throws.
+ */
+function releaseRegionToNoMansLand(next: GameState, key: string): void {
+  if (next.unowned.includes(key)) return; // already no man's land
+  const owners = Object.values(next.nations).filter((n) => n.territory.includes(key));
+  if (owners.length !== 1) return; // 0 or 2+ owners: not releasable
+  next.nations[owners[0]!.id].territory = next.nations[owners[0]!.id].territory.filter(
+    (k) => k !== key,
+  );
+  next.unowned.push(key);
+  delete next.regionStats[key];
+}
+
+/**
+ * End every ACTIVE war whose sides include both `a` and `b` (a nuclear
+ * capitulation), then downgrade the `war` relation of every pair that is no
+ * longer covered by an active war back to `hostile` (the war → relation sync).
+ * Capturing the active pairs immediately BEFORE the end keeps this correct for
+ * a war declared and ended in the SAME turn (where the start-of-turn `prev`
+ * that `syncWarRelations` uses would not contain it). Never throws.
+ */
+function endWarsBetween(next: GameState, a: string, b: string): void {
+  const before = activeWarPairs(next.wars);
+  let ended = false;
+  for (const w of next.wars) {
+    if (w.status === 'active' && w.sides.includes(a) && w.sides.includes(b)) {
+      w.status = 'capitulation';
+      ended = true;
+    }
+  }
+  if (!ended) return;
+  const after = activeWarPairs(next.wars);
+  for (const key of before) {
+    if (after.has(key)) continue; // still covered by another active war
+    const [x, y] = key.split('\u0000');
+    const nx = next.nations[x];
+    const ny = next.nations[y];
+    if (!nx || !ny) continue;
+    if (nx.relations[y] === 'war' || ny.relations[x] === 'war') {
+      nx.relations[y] = 'hostile';
+      ny.relations[x] = 'hostile';
+    }
+  }
+}
+
+/**
+ * Force the relation between two nations to `hostile` in BOTH directions —
+ * the aftermath of a MAD exchange. A `war` relation is never downgraded (the
+ * war entity owns it while active — e.g. a region strike that devastates one
+ * warring side without ending the war). Never throws.
+ */
+function forceHostile(next: GameState, a: string, b: string): void {
+  const na = next.nations[a];
+  const nb = next.nations[b];
+  if (!na || !nb) return;
+  if (na.relations[b] !== 'war') na.relations[b] = 'hostile';
+  if (nb.relations[a] !== 'war') nb.relations[a] = 'hostile';
+}
+
+/**
+ * Apply a turn's nuclear ops to the (cloned) `next` state, mutating it in
+ * place and never throwing. See the section comment above for the full
+ * contract. `state` is the ORIGINAL (pre-turn) state — its `markers` supply the
+ * "owns a rocket" half of nuclear capability (a rocket marker placed this very
+ * turn makes its owner capable only from the next turn, while a nation that
+ * ARMS this turn is capable immediately, since arming runs first).
+ */
+export function applyNuclearOps(
+  next: GameState,
+  ops: NuclearOps,
+  state: GameState,
+  geoOf?: (key: string) => { area: number; population: number } | undefined,
+  validKeys?: ReadonlySet<string>,
+  regionNameOf?: (key: string) => string | undefined,
+  actingTurn?: number,
+): void {
+  if (ops.arm.length === 0 && ops.strikes.length === 0) return;
+  const turn = actingTurn ?? next.turn;
+  const markers = state.markers ?? [];
+  const capable = (id: string): boolean => {
+    const n = next.nations[id];
+    return n ? isNuclearCapable(n, markers) : false;
+  };
+
+  // (1) ARM: set the nuclear flag (idempotent); unresolvable refs are dropped.
+  for (const ref of ops.arm) {
+    const id = resolveNationRef(next, ref);
+    if (id === null) continue;
+    const n = next.nations[id];
+    if (!n) continue;
+    n.nuclear = true;
+  }
+
+  const affected = new Set<string>();
+  const regionDisplay = (key: string): string => regionNameOf?.(key) ?? key;
+
+  // (2) STRIKES: each validated independently against the post-arm state.
+  for (const strike of ops.strikes) {
+    const fromId = resolveNationRef(next, strike.from);
+    if (fromId === null) continue; // unknown / ambiguous striker: drop
+    const from = next.nations[fromId];
+    if (!from) continue;
+    if (!capable(fromId)) continue; // a non-capable nation cannot strike
+    if (fromId === resolveNationRef(next, strike.target)) continue; // self: drop
+
+    // Resolve the target: a NATION (a ref resolving to a distinct nation) or a
+    // REGION (a region key / name with a sole owner that is not the striker).
+    let target:
+      | { kind: 'nation'; nation: Nation }
+      | { kind: 'region'; key: string; owner: Nation }
+      | null = null;
+    const tid = resolveNationRef(next, strike.target);
+    if (tid !== null) {
+      const tn = next.nations[tid];
+      if (tn) target = { kind: 'nation', nation: tn };
+    } else {
+      const rk = validKeys
+        ? resolveRegionKey(strike.target, validKeys, regionNameOf ?? (() => undefined))
+        : (strike.target.trim() || null);
+      if (rk !== null) {
+        const owners = Object.values(next.nations).filter((n) => n.territory.includes(rk));
+        if (owners.length === 1 && owners[0]!.id !== fromId) {
+          target = { kind: 'region', key: rk, owner: owners[0]! };
+        }
+        // a 0/2+-owner region, or a region the striker owns (self), is dropped
+      }
+    }
+    if (target === null) continue; // unresolvable target: drop
+
+    if (target.kind === 'nation') {
+      // Devastate the target nation.
+      collapseNationStats(next, target.nation.id, NUCLEAR_COLLAPSE);
+      affected.add(target.nation.id);
+      // A strike on a nation at war with the striker ends that war in
+      // capitulation (the relation then falls back to hostile).
+      endWarsBetween(next, fromId, target.nation.id);
+      // MAD: a nuclear-capable target strikes back at half strength and the
+      // two nations end the exchange at least hostile.
+      if (capable(target.nation.id)) {
+        collapseNationStats(next, fromId, NUCLEAR_RETALIATION);
+        affected.add(fromId);
+        forceHostile(next, fromId, target.nation.id);
+        next.events.push(
+          makeEvent(
+            {
+              nation: fromId,
+              type: 'military',
+              title: 'MAD retaliation',
+              text: `${target.nation.name} launches a retaliatory nuclear strike against ${from.name}; mutual assured destruction devastates ${from.name} in turn.`,
+              outcome: 'failure',
+            },
+            turn,
+            next.date,
+          ),
+        );
+      }
+      next.events.push(
+        makeEvent(
+          {
+            nation: fromId,
+            type: 'military',
+            title: `Nuclear strike on ${target.nation.name}`,
+            text: `${from.name} devastates ${target.nation.name} with a nuclear strike; the target's economy, military and stability collapse.`,
+            outcome: 'success',
+          },
+          turn,
+          next.date,
+        ),
+      );
+    } else {
+      // Devastate the region: release it to no man's land, then devastate its
+      // former owner.
+      const owner = target.owner;
+      releaseRegionToNoMansLand(next, target.key);
+      collapseNationStats(next, owner.id, NUCLEAR_COLLAPSE);
+      affected.add(owner.id);
+      // MAD: a nuclear-capable owner strikes back at half strength and the
+      // two nations end the exchange at least hostile.
+      if (capable(owner.id)) {
+        collapseNationStats(next, fromId, NUCLEAR_RETALIATION);
+        affected.add(fromId);
+        forceHostile(next, fromId, owner.id);
+        next.events.push(
+          makeEvent(
+            {
+              nation: fromId,
+              type: 'military',
+              title: 'MAD retaliation',
+              text: `${owner.name} launches a retaliatory nuclear strike against ${from.name} in response to the devastation of ${regionDisplay(
+                target.key,
+              )}; mutual assured destruction devastates ${from.name} in turn.`,
+              outcome: 'failure',
+            },
+            turn,
+            next.date,
+          ),
+        );
+      }
+      next.events.push(
+        makeEvent(
+          {
+            nation: fromId,
+            type: 'military',
+            title: `Nuclear strike on ${regionDisplay(target.key)}`,
+            text: `${from.name} obliterates ${regionDisplay(
+              target.key,
+            )} with a nuclear strike, reducing the region to no man's land and devastating its former owner, ${owner.name}.`,
+            outcome: 'success',
+          },
+          turn,
+          next.date,
+        ),
+      );
+    }
+  }
+
+  // (3) RE-DERIVE: every affected nation's aggregate stats (the same 0-region /
+  // no-entry guards as the main recompute), so the collapse persists.
+  for (const id of affected) {
+    const n = next.nations[id];
+    if (!n) continue;
+    if (n.territory.length === 0) continue; // 0-region guard: no regions to aggregate
+    if (!n.territory.some((k) => next.regionStats[k])) continue; // no entry: keep n.stats
+    n.stats = deriveNationStats(n.territory, next.regionStats, geoOf);
+  }
+}
+
 /**
  * A turn is "meaningful" if it produced at least an event, a stat change, a stat change, a
  * no-man's-land release (v0.22 #16 P3: a release is a real world change even
@@ -1588,6 +2069,13 @@ export function isMeaningful(result: TurnResult): boolean {
     // (v0.36, #59) an industry project built this turn is a real world change
     // (the active project list moved).
     result.industry.projects.length > 0 ||
+    // (v0.37, #60) a nation arming a nuclear arsenal or a nuclear strike fired
+    // this turn is a real world change.
+    result.nuclear.arm.length > 0 ||
+    result.nuclear.strikes.length > 0 ||
+    // (v0.38, #61) a leader assassinated / died / appointed this turn is a real
+    // world change (a nation's leader and stability moved).
+    result.leaders.changes.length > 0 ||
     // (v0.27, #44) a marker placed or removed this turn is a real world change.
     result.markers.add.length > 0 ||
     result.markers.remove.length > 0
@@ -2002,6 +2490,26 @@ export function applyTurnResult(
   applyIndustryOps(next, result.industry, validKeys);
   applyIndustryEffects(next, resourceOf, geoOf);
 
+  // --- Nuclear / WMD (v0.37, #60): the WMD lever ---
+  //
+  // Placed AFTER the industry/economy effects (both move stats) and BEFORE the
+  // markers block (a region strike releases its region to no man's land, which
+  // changes the FINAL ownership the marker owner-recompute depends on). See
+  // applyNuclearOps for the full contract (arm, strike, MAD, re-derive).
+  // `state` (the original pre-turn state) supplies the markers used for the
+  // rocket-marker half of nuclear capability.
+  applyNuclearOps(next, result.nuclear, state, geoOf, validKeys, regionNameOf, actingTurn);
+
+  // --- Named leaders (v0.38, #61) ---
+  //
+  // Placed AFTER the nuclear block (both are the "heavier" levers) and BEFORE
+  // the markers block (markers recompute their owner from the FINAL post-claim
+  // ownership; leaders only touch stats, so ordering w.r.t. markers is
+  // immaterial, but keeping the levers grouped is clearer). Each change sets
+  // the target's leader, applies a deterministic stability dip by cause, and
+  // appends a narration event. A leaderless assassination/death is dropped.
+  for (const op of result.leaders.changes) applyLeaderChange(next, op, geoOf, actingTurn);
+
   // --- Map markers (v0.27, #44) ---
   //
   // Markers are anchored to a region key and are processed against the FINAL
@@ -2528,6 +3036,12 @@ export async function runTurn(opts: {
             deriveNationResources(n.territory, resourceOf, geoOf),
           ]),
         );
+  // (v0.37.0, #60) each nation's nuclear capability (its `nuclear` flag OR a
+  // current `rocket` marker), so the model knows who can arm/strike and who
+  // can MAD-retaliate. Always emitted (computed from the PRE-turn markers).
+  const nuclearCapability = Object.fromEntries(
+    Object.values(state.nations).map((n) => [n.id, isNuclearCapable(n, state.markers ?? [])]),
+  );
   const user = buildUserPrompt(
     state,
     items,
@@ -2547,6 +3061,8 @@ export async function runTurn(opts: {
     // resource.
     nationResources,
     state.industry ?? [],
+    // (v0.37.0, #60) per-nation nuclear capability (flag or rocket marker).
+    nuclearCapability,
   );
   const nudge =
     'Your previous output was invalid. Respond with ONLY the JSON object described above for this batch — no prose, no fences.';
@@ -2604,6 +3120,8 @@ export async function runTurn(opts: {
       hybrid: { ops: [] },
       economy: { trade: [], embargo: [] },
       industry: { projects: [] },
+      nuclear: { arm: [], strikes: [] },
+      leaders: { changes: [] },
       markers: { add: [], remove: [] },
     };
   }

server/stub.ts

@@ -13,7 +13,21 @@ export interface StubPayload {
     turn: number;
     date: string;
     playerNationId: string;
-    nations: Record<string, { stats: Record<string, number>; territory?: string[] }>;
+    // `nuclear` (v0.37.0, #60) is the per-nation nuclear capability stamped by
+    // the engine (its `nuclear` flag OR a `rocket` marker); the stub ignores
+    // it — it never arms or strikes (see deterministicTurn).
+    // `leader` (v0.38.0, #61) is the per-nation named leader stamped by the
+    // engine; the stub ignores it — it never changes a leader (see
+    // deterministicTurn).
+    nations: Record<
+      string,
+      {
+        stats: Record<string, number>;
+        territory?: string[];
+        nuclear?: boolean;
+        leader?: { name: string };
+      }
+    >;
   };
   /** The raw pending round the engine emitted (one entry per queued item). */
   pending?: RoundItem[];
@@ -141,6 +155,11 @@ function truncate(s: string, n: number): string {
  * (v0.36.0, #59) The stub likewise NEVER declares an industry project (it
  * always returns `industry: { projects: [] }`) — the per-region industry
  * path is covered by unit tests only, keeping the e2e assertions untouched.
+ *
+ * (v0.37.0, #60) The stub likewise NEVER arms a nation or fires a nuclear
+ * strike (it always returns `nuclear: { arm: [], strikes: [] }`) — the
+ * nuclear / WMD path is covered by unit tests only, keeping the e2e
+ * assertions untouched.
  */
 export function deterministicTurn(p: StubPayload): TurnResult {
   const state = p.state;
@@ -212,6 +231,8 @@ export function deterministicTurn(p: StubPayload): TurnResult {
     hybrid: { ops: [] }, // the stub never runs hybrid/covert ops (see doc comment)
     economy: { trade: [], embargo: [] }, // the stub never touches trades/embargoes (see doc comment)
     industry: { projects: [] }, // the stub never declares industry projects (see doc comment)
+    nuclear: { arm: [], strikes: [] }, // the stub never arms or strikes (see doc comment)
+    leaders: { changes: [] }, // the stub never changes leaders (see doc comment)
     markers: { add: [], remove: [] }, // the stub never touches markers (see doc comment)
   };
 }

shared/protocol.ts

@@ -7,6 +7,7 @@ import type {
   EventType,
   GameState,
   IndustryProject,
+  MapMarker,
   MarkerType,
   Nation,
   NationStats,
@@ -433,6 +434,132 @@ export interface IndustryOps {
   projects: IndustryProject[];
 }
 
+/**
+ * (v0.37, #60) A single nuclear strike. `from` names the striking nation
+ * (id or name — it must be **nuclear-capable**, see `isNuclearCapable`);
+ * `target` names what is struck — either a **region key** (the region is
+ * devastated to no man's land and its former owner devastated) or a
+ * **nation** (id or name — the target's economy / military / stability are
+ * devastated; if the striker and the target are on opposite sides of an
+ * active war, that war ends in `capitulation`).
+ */
+export interface NuclearStrike {
+  /** The striking nation (id or name). Must be nuclear-capable. */
+  from: string;
+  /** The struck target: a region key, or a nation (id or name). */
+  target: string;
+}
+
+/**
+ * (v0.37, #60) The turn's NUCLEAR operations, nested under
+ * `TurnResult.nuclear`. `arm` names the nations (id or name) that declare a
+ * nuclear arsenal this turn (idempotent — arming an already-armed nation is a
+ * no-op; an unresolvable ref is dropped); `strikes` are the nuclear strikes
+ * fired this turn (at most one per turn in the prompt contract; each is
+ * validated independently — an invalid `from` or `target` is dropped, never
+ * thrown). A strike on a nuclear-capable target (or the owner of a struck
+ * region) triggers a smaller "MAD" retaliation on the striker. Required;
+ * default `{ arm: [], strikes: [] }`.
+ */
+export interface NuclearOps {
+  /** Nation refs (id or name) arming a nuclear arsenal this turn. */
+  arm: string[];
+  /** The nuclear strikes fired this turn. */
+  strikes: NuclearStrike[];
+}
+
+// --- Named leaders (v0.38, #61) -----------------------------------------------
+//
+// Each nation may have a single named leader (`Nation.leader`). The LLM changes
+// it each turn via `TurnResult.leaders`. A change names a target nation (id or
+// name) and the outcome: an `assassination` (a leader killed — a dramatic,
+// destabilizing blow), a `death` (a leader dies of natural causes — a quieter
+// succession), or an `appointed` leader (a neutral succession / new head of
+// state). The engine sets the nation's leader to the new name and applies a
+// DETERMINISTIC stability dip (see `LEADER_STABILITY_EFFECT` below) — no hidden
+// randomness. A change whose target has no current leader may only *appoint*
+// one (an assassination/death of a leaderless nation is dropped, not thrown).
+
+/** How a nation's leader changed this turn (v0.38, #61). */
+export type LeaderCause = 'assassination' | 'death' | 'appointed';
+
+/** A single leader change: the target nation, the new leader's name, the cause. */
+export interface LeaderChange {
+  /** The target nation, by id or name (resolved by the shared resolver). */
+  target: string;
+  /** The new leader's name (the incoming / successor head of state). */
+  name: string;
+  /** What happened to the leader this turn. */
+  cause: LeaderCause;
+}
+
+/** The leader-ops block of a `TurnResult`. Required; default `{ changes: [] }`. */
+export interface LeaderOps {
+  changes: LeaderChange[];
+}
+
+/**
+ * The deterministic stability effect of each leader-cause (v0.38, #61).
+ * Assassination is the most destabilizing, a natural death a minor wobble, an
+ * appointment is neutral. Applied to the target's `stability` (clamped 0–100),
+ * mirrored to its `regionStats`, and its derived stats re-derived afterwards.
+ */
+export const LEADER_STABILITY_EFFECT: Record<LeaderCause, number> = {
+  assassination: -15,
+  death: -3,
+  appointed: 0,
+};
+
+// --- Nuclear / WMD effect math (v0.37, #60) ----------------------------------
+//
+// A nuclear strike is a DETERMINISTIC, devastating stat collapse — there is no
+// hidden randomness (the LLM decides WHO strikes and WHAT is targeted; the
+// engine decides the size of the effect). The two magnitude tables below are
+// the single source of truth for the collapse: a full strike devastates a
+// nation (or the former owner of a devastated region) by `NUCLEAR_COLLAPSE`,
+// while a "MAD" retaliation (fired when a nuclear-capable nation is struck)
+// devastates the STRIKER by half that, `NUCLEAR_RETALIATION`. Both dip the
+// three war-relevant stats only (population is untouched); each value is the
+// signed per-turn delta the engine clamps against 0–100.
+
+/** The stats a nuclear strike collapses (population is never touched). */
+export type NuclearStatKey = 'economy' | 'military' | 'stability';
+
+/**
+ * (v0.37, #60) The deterministic stat collapse a FULL nuclear strike inflicts
+ * on its target (a struck nation, or the former owner of a devastated region):
+ * a heavy dip in economy / military / stability. Shared so the engine and the
+ * unit tests agree on the exact magnitudes.
+ */
+export const NUCLEAR_COLLAPSE: Record<NuclearStatKey, number> = {
+  economy: -40,
+  military: -50,
+  stability: -40,
+};
+
+/**
+ * (v0.37, #60) The deterministic stat collapse of a "MAD" RETALIATION — fired
+ * automatically when a nuclear-capable nation (or the owner of a devastated
+ * region) is struck — which hits the STRIKER at half the full collapse.
+ */
+export const NUCLEAR_RETALIATION: Record<NuclearStatKey, number> = {
+  economy: NUCLEAR_COLLAPSE.economy / 2,
+  military: NUCLEAR_COLLAPSE.military / 2,
+  stability: NUCLEAR_COLLAPSE.stability / 2,
+};
+
+/**
+ * (v0.37, #60) Whether a nation is **nuclear-capable** — i.e. able to fire a
+ * nuclear strike and subject to MAD retaliation: its `nuclear` flag is set, OR
+ * it owns a `rocket` marker (a launch site is an arsenal). A legacy nation
+ * without the flag is not nuclear unless it has a rocket marker. Pure +
+ * shared (used by the engine and the unit tests).
+ */
+export function isNuclearCapable(nation: Nation, markers: readonly MapMarker[]): boolean {
+  if (nation.nuclear === true) return true;
+  return markers.some((m) => m.ownerNationId === nation.id && m.type === 'rocket');
+}
+
 /** The exact JSON object the world-simulator LLM must return for a turn. */
 export interface TurnResult {
   date: string;
@@ -537,6 +664,36 @@ export interface TurnResult {
    * untouched. Required; default `{ projects: [] }`.
    */
   industry: IndustryOps;
+  /**
+   * (v0.37, #60) Nuclear / WMD ops — the LLM's nuclear lever. `arm` names
+   * the nations that declare a nuclear arsenal this turn (idempotent);
+   * `strikes` are the nuclear strikes fired this turn (at most one per turn
+   * in the prompt contract). A strike may target a **region** (devastated to
+   * no man's land, its former owner devastated) or a **nation** (its economy
+   * / military / stability devastated; a strike that lands on a nation
+   * warring with the striker ends that war in capitulation). A strike on a
+   * nuclear-capable target (or the owner of a struck region) triggers a
+   * smaller, automatic "MAD" retaliation on the striker. Only
+   * nuclear-capable nations (the `Nation.nuclear` flag set, or owning a
+   * `rocket` marker) may strike. Applied directly by `applyTurnResult`,
+   * never queued. Required; default `{ arm: [], strikes: [] }`.
+   */
+  nuclear: NuclearOps;
+  /**
+   * (v0.38, #61) Leader changes this turn. Each change names a target nation
+   * (id or name) and sets its leader to the new name, applying a deterministic
+   * stability effect by cause: `assassination` (leader killed — a dramatic
+   * −15 to the target's stability, a `military` event), `death` (natural
+   * causes — a quieter −3 succession, a `political` event), or `appointed`
+   * (a neutral 0 succession, a `political` event). An assassination/death
+   * requires the target to already have a leader (a leaderless target is
+   * dropped, never thrown); an appointment is always valid (it creates the
+   * first leader). At most 1–2 per turn, each narrated in `events`. This is
+   * the *leader* lever — heavier and more destabilizing than the lighter
+   * `hybrid.assassinate` op (a −5 stability dip on a nation or region, with
+   * no leader replacement). Required; default `{ changes: [] }`.
+   */
+  leaders: LeaderOps;
   /**
    * (v0.27, #44) Map-marker ops this turn. `add` places new named markers
    * (the engine positions each at its region's centroid + a small
@@ -849,6 +1006,7 @@ export function nationForPrompt(n: Nation) {
     stats: n.stats,
     territory: n.territory,
     relations: n.relations,
+    leader: n.leader,
   };
 }
 

shared/types.ts

@@ -72,6 +72,22 @@ export interface Nation {
   stats: NationStats;
   territory: string[];
   relations: Record<string, RelationStatus>;
+  /**
+   * Whether the nation controls nuclear weapons (v0.37, #60). Optional — a
+   * legacy game loaded from SQLite has no flag, which means "not nuclear".
+   * A nation is *nuclear-capable* (for the `nuclear` lever and MAD
+   * retaliation) when this is `true` OR it owns a `rocket` marker (see
+   * `isNuclearCapable` in `protocol.ts`).
+   */
+  nuclear?: boolean;
+  /**
+   * The nation's current named leader (v0.38, #61). Optional — a legacy game
+   * (or a nation the LLM has never given a leader to) has none, which is the
+   * "no leader" baseline. The LLM changes it via `TurnResult.leaders`
+   * (assassination / death / appointment, see `LeaderChange` in `protocol.ts`);
+   * each change carries a deterministic stability effect + a narration event.
+   */
+  leader?: { name: string };
 }
 
 /** Categories a narrative event can take. */