Merge pull request 'feat: Resources & Industry — per-region resource profiles + industry LLM lever (v0.36.0, #59)' (#70) from feat/59-resources-industry into master

- scripts/build-region-resources.mjs: deterministic, idempotent builder →
  public/region-resources.json (1,800 entries; FNV-1a hash × area factor, 0–1, 2dp)
- server/regions.ts: hasResources()/resourceOf() optional-manifest loader
- shared/types.ts: RegionResources, IndustryType/INDUSTRY_TYPES, IndustryProject,
  GameState.industry
- shared/protocol.ts: IndustryOps, TurnResult.industry, deriveNationResources
  (area×population-weighted average, 2dp)
- server/engine.ts: isIndustryType, validateIndustryOps, applyIndustryOps
  (per-region SET, first-declared-type wins), applyIndustryEffects
  (INDUSTRY_ECONOMY_BONUS=1, +1 when region industry≥0.5; sole-owner only;
  0/2+ owner regions kept but no boost; re-derive after), system+user prompt
  contract lines, runTurn resourceOf opt, nationResources in user payload
- server/db.ts: legacy-row industry default migration
- server/stub.ts: industry:{projects:[]} in stub result; resources/industry
  in StubPayload (never read)
- server/index.ts: resourceOf wired to jump route
- All test fixtures updated; new describe blocks in engine.test.ts,
  protocol.test.ts, regions.test.ts, db.test.ts
- CHANGELOG.md v0.36.0, AGENTS.md docs, package.json 0.36.0

Fixes #59

AGENTS.md

@@ -56,7 +56,7 @@ history/
 ├── eslint.config.js        # flat config (ESLint 9)
 ├── tsconfig.json           # strict; aliases @/ → src/, @shared/ → shared/
 ├── vite.config.ts          # dev server + proxy /api,/sse → :4321; @ / @shared aliases
-├── vitest.config.ts        # unit tests (server/**/*.test.ts + scripts/**/*.test.ts; 225 tests)
+├── vitest.config.ts        # unit tests (server/**/*.test.ts + scripts/**/*.test.ts; 407 tests)
 ├── playwright.config.ts    # deterministic e2e (webServer runs npm run dev, LLM_STUB=1)
 ├── index.html
 ├── presets/                # 5 scenario JSON files + index.json (manifest)
@@ -67,11 +67,13 @@ history/
 │   ├── region-adjacency.json # region key -> bordering region keys, 1,800 entries (the getNeighbours data, #16 P2)
 │   ├── region-centroids.json # region key -> {lat,lon,spread} anchor for map markers, 1,800 entries (#44)
 │   ├── region-geo.json     # region key -> {area (km²), population}, 1,800 entries (the area×population weighting for per-region stats, #46)
+│   ├── region-resources.json # region key -> synthesized {oil, iron, food, industry} (each 0–1, 2dp), 1,800 entries (the resource profiles that scale industry boosts + feed the prompt aggregate, #59)
 │   └── ne-admin0-pop.json  # ISO_A3 -> admin-0 POP_EST, 249 codes (the committed population SOURCE for region-geo.json — a small derived table, the 13 MB Natural Earth source is NOT committed, #46)
 ├── scripts/                # the geo/manifest data pipeline — .mjs (turf allowed HERE only;
 │   │                       #   never imported by .ts): generate → coarsen → cleanup → smooth →
 │   │                       #   fill-gaps → split-arkhangel → split-arkhangel-band → build-region-keys
 │   │                       #   → build-region-adjacency → build-region-centroids → build-region-geo
+│   │                       #   → build-region-resources
 │   │                       #   (build-region-geo reads the COMMITTED ne-admin0-pop.json; that small
 │   │                       #   table is distilled once from the 13 MB Natural Earth admin-0 source by
 │   │                       #   extract-admin0-pop.mjs — the raw source is never committed, #46)
@@ -131,6 +133,7 @@ history/
 | `npm run split:regions:band` | (re)apply the #41 Arctic-coast-band split (`RU-ARK` mainland's 28-part lat ≥ 68 band → `RU-PEO` + `RU-YAM`) — idempotent no-op once applied |
 | `npm run build:region-keys` / `build:region-adjacency` / `build:region-centroids` | (re)generate the `public/region-keys.json` / `region-adjacency.json` / `region-centroids.json` manifests — deterministic + idempotent (byte-identical re-run) |
 | `npm run build:region-geo` | (re)generate `public/region-geo.json` (region key → area km² + population) from `regions.geo.json` + `region-keys.json` + the committed `ne-admin0-pop.json` — deterministic + idempotent (byte-identical re-run; #46) |
+| `npm run build:region-resources` | (re)generate `public/region-resources.json` (region key → synthesized `{ oil, iron, food, industry }` 0–1 profile) from `region-keys.json` + `region-geo.json` (area factor) — deterministic + idempotent (byte-identical re-run; #59) |
 | `npm run extract:admin0-pop` | one-time distillation of the 13 MB Natural Earth admin-0 source → the committed `public/ne-admin0-pop.json` (ISO_A3 → `POP_EST`, 249 codes); the raw source is never committed (#46) |
 | `docker compose up -d --build` | prod image on :4321, routed via Traefik at `history.dev.kkhost.pl` |
 
@@ -350,6 +353,95 @@ history/
   (as `WarInfo[]`: id + sides + aims) so the model can `end` by id. The **stub never declares or
   ends** a war (`wars: { declare: [], end: [] }`) — e2e (CI, `LLM_STUB=1`) is unaffected and the
   path is unit-tested only (`server/engine.test.ts`).
+- **Hybrid war — `TurnResult.hybrid`, a deterministic non-kinetic operations spectrum (v0.34, #57).**
+  `TurnResult.hybrid = { ops: HybridOp[] }` (required; default `{ ops: [] }`) adds a covert /
+  hybrid-warfare spectrum alongside the kinetic `regionChanges` lever: `HybridOp =
+  { type, from, target, detail?, outcome? }` with `type ∈ spy | sabotage | assassinate |
+  cyber | economic | information | proxy` and `outcome ∈ success | exposed` (the LLM
+  declares its *intended* outcome; the engine applies the deterministic effect).
+  `from`/`target` are refs resolved by the shared `resolveNationRef` (id first, then
+  case-insensitive unique name); a `target` that is not a resolvable nation is treated
+  as a region key — it hits that region's SOLE owner (a key with 0 or 2+ owners — or the
+  acting nation itself — is dropped, never thrown). Per type: `sabotage` dips `economy`
+  (−3), `economic` dips `economy` (−5), `cyber` dips `military` (−3), `assassinate` dips
+  `stability` (−5); `information` nudges the from↔target relation one step apart (capped
+  at `hostile`), `proxy` likewise but capped at `rival`; `spy` is informational only.
+  A region-target dip lands on the single `regionStats[regionKey]` entry (hybrid ops
+  never move territory — `regionChanges` is the only lever that does); a nation-target
+  dip lands on every region the nation owns; afterwards the target's derived `stats` is
+  re-derived (0-region / no-entry guards), so the effect persists and the sole-ownership
+  invariant is untouched. **Exposed** (`outcome: "exposed"`) is a backfire: the intended
+  effect is NOT applied; instead the from↔target relation moves one step *toward*
+  `hostile` (capped; `war` is never created or escalated by an exposed op) and a
+  diplomatic/failed event is auto-appended to the turn's `events`.
+  **Additive only — no `GameState.hybrid` field, no `db.ts` change** (the ops are
+  consumed inside `applyTurnResult` after territory + wars and before markers).
+  `isMeaningful` counts hybrid ops; the system prompt documents the field + per-type
+  effects (the "unclear" fallback and the stub both return `hybrid: { ops: [] }`), and the
+  user payload carries the player's `relations` map so the model can reason about the
+  relation caps. The **stub never** proposes a hybrid op, so e2e (CI, `LLM_STUB=1`) is
+  unaffected and the path is unit-tested only (`server/engine.test.ts`).
+- **Trade & embargo economy layer — `GameState.trades` / `GameState.embargoes`, `TurnResult.economy` (v0.35, #58).**
+  `TurnResult.economy = { trade: EconomyTradeOp[]; embargo: EconomyEmbargoOp[] }` (required;
+  default `{ trade: [], embargo: [] }`) is the model's lever for the economic layer: a
+  bilateral **trade** (`{ a, b, lift? }` — symmetric, stored **sorted** `a < b`) and a
+  unilateral **embargo** (`{ from, target, lift? }` — ordered). No `lift` declares/imposes,
+  `lift: true` ends/lifts (a no-op when absent). Refs are resolved at apply time by the
+  shared `resolveNationRef` (id first, then case-insensitive unique name); an unknown /
+  ambiguous / self-pairing op is dropped (never thrown). The lists live in `GameState`
+  (`trades`/`embargoes`, required, `[]` at creation; a legacy SQLite row without them loads
+  as `[]` — additive, never wiped, like `wars`/`markers`). **Deterministic, no hidden
+  randomness.** Every committed turn, in `applyTurnResult` (after hybrid, before markers):
+  (1) `applyEconomyOps` applies this turn's declares/lifts to the active lists (idempotent
+  declares — an already-active pair/ordered pair is not duplicated); (2)
+  `suspendEconomyOnWar` **auto-suspends** any trade or embargo whose two nations are on
+  opposite sides of an **active** `War` (#56) — a war severs the economic link, so the
+  suspended pair stops producing its effect (this also drops a trade declared this turn
+  between two nations that just went to war); (3) `applyEconomyEffects` applies the per-turn
+  effect to the **full** active lists: each active trade gives **both** parties a small,
+  deterministic `economy` gain (`TRADE_ECONOMY_BONUS`), each active embargo dips the
+  **target's** `economy` only (`EMBARGO_ECONOMY_PENALTY`) — clamped to 0–100, mirrored to
+  every region the nation owns (`regionStats`), and each affected nation's derived `stats`
+  re-derived afterwards (same 0-region / no-entry guards as the hybrid dip). Sole ownership
+  is untouched (the layer moves stats, never territory). `isMeaningful` counts non-empty
+  `economy.trade` / `economy.embargo`; the system prompt documents the field + constraints
+  (at most 1–2 ops per turn, narrated in `events`; warring pairs auto-suspended), and the
+  user payload carries the active `trades`/`embargoes` so the model can `lift` them. The
+  **stub never** declares or lifts a trade/embargo (`economy: { trade: [], embargo: [] }`),
+  so e2e (CI, `LLM_STUB=1`) is unaffected and the path is unit-tested only
+  (`server/engine.test.ts`).
+- **Resources & Industry — per-region resource profiles + the `industry` lever (v0.36, #59).**
+  Since v0.36 each of the 1,800 sub-regions carries a **synthesized 4-value resource profile**
+  (`{ oil, iron, food, industry }`, each 0–1, 2dp) from the committed `public/region-resources.json`
+  — built by the deterministic, idempotent `scripts/build-region-resources.mjs` (an FNV-1a hash of
+  `` `${key}\u0000${resource}` `` scaled by an area factor from `region-geo.json`, clamped to 1,
+  byte-identical re-run) and loaded by `server/regions.ts` via the same optional-manifest pattern as
+  the other manifests (`hasResources()` / `resourceOf()`, probe `public/` then `dist/`; a missing or
+  malformed file degrades — boosts use the unscaled base value and the aggregate is omitted from the
+  prompt, never a crash). `TurnResult.industry = { projects: IndustryProject[] }` (required, default
+  `{ projects: [] }`; `IndustryProject = { regionKey, type }`, `type ∈ INDUSTRY_TYPES =
+  oil | iron | food | industry`) declares a project on a region. `applyTurnResult` maintains
+  `GameState.industry` (required, `[]` at creation; a legacy SQLite row without the field loads as
+  `[]` — `db.ts`, additive, never wiped) as a **per-region SET**: a region key not in the valid-keys
+  manifest is dropped; a region that already hosts a project is untouched (the first declared type
+  wins — re-declaring is a no-op, the type is never replaced). Every committed turn,
+  `applyIndustryEffects` (placed after the economy block, before markers; the owner is resolved from
+  the FINAL post-claim ownership) grants each active project's region's **SOLE owner** a small,
+  deterministic economy boost — `INDUSTRY_ECONOMY_BONUS = 1` plus one extra point when the region's
+  `industry` resource value is ≥ 0.5 (without the manifest, just the base) — clamped to 0–100,
+  mirrored to every region the owner holds (`regionStats`), and each affected nation's derived `stats`
+  re-derived afterwards (same 0-region / no-entry guards as the economy/hybrid dips). A project on a
+  region with 0 or 2+ owners yields no boost but is **kept** in the list (never removed, never
+  thrown); sole ownership is untouched (the layer moves stats, never territory). `isMeaningful`
+  counts non-empty `industry.projects`; the system prompt documents the field + constraints (a region
+  holds at most one project — never re-declare on a region that already has one; at most 1–2 per
+  turn, each narrated in `events`), and the user payload carries the active projects (`industry`)
+  plus each nation's aggregate resource profile (`resources` — `deriveNationResources` in
+  `shared/protocol.ts`, the area×population-weighted **average** of the owned regions' profiles;
+  omitted entirely when the manifest is not loaded). The **stub never** declares a project
+  (`industry: { projects: [] }`) — e2e (CI, `LLM_STUB=1`) is unaffected and the path is unit-tested
+  only (`server/engine.test.ts`, `server/protocol.test.ts`, `server/regions.test.ts`,
+  `server/db.test.ts`, `scripts/build-region-resources.test.ts`).
 - **Map click → dossier target (owner resolved from the RegionMap, by region key).**
   Clicking a sub-region does NOT open a popup — it switches the dossier to that sub-region's
   owning nation (`focusNation(ownerId, {name})` in `App.tsx`, which also records which region was

CHANGELOG.md

@@ -2,6 +2,72 @@
 
 All notable changes to **History** are listed here, newest first.
 
+## 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).
+  - **Types (`shared/types.ts`).** New `RegionResources` (`{ oil; iron; food; industry }`), `IndustryType` (`'oil' | 'iron' | 'food' | 'industry'`) + `INDUSTRY_TYPES` const, `IndustryProject` (`{ regionKey; type }`), and the required `GameState.industry: IndustryProject[]` field (placed after `embargoes`). `[]` on a fresh game; rows saved before v0.36 load with it defaulted to `[]` (additive, never wiped).
+  - **Protocol (`shared/protocol.ts`).** New `IndustryOps` (`{ projects: IndustryProject[] }`); `TurnResult.industry` is required, placed between `economy` and `markers`. New exported `deriveNationResources(regionKeys, resourceOf?, geoOf?)` — a nation's aggregate profile as the **area×population-weighted AVERAGE** (an average, not a median, is the meaningful aggregation for an abundance profile) of the resource profiles of its owned regions, same weight formula as `deriveNationStats`, 2dp-rounded, zero profile when no owned region has a profile.
+  - **Engine (`server/engine.ts`).**
+    - `isIndustryType(t)` — exported guard over the four types (mirrors `isHybridOpType`).
+    - `validateIndustryOps(raw)` — new exported, defensive validator (never throws): a missing/malformed object yields `{ projects: [] }`; each op needs a non-empty `regionKey` (≤120 chars) and a known `type`.
+    - `industryBoost(regionKey, resourceOf?)` — internal; `INDUSTRY_ECONOMY_BONUS = 1` plus one extra point when the region's `industry` value is ≥ 0.5 (without the manifest, just the base).
+    - `applyIndustryOps(next, ops, validKeys?)` — internal; applies the turn's projects to `GameState.industry` as a **per-region SET** — a key not in the valid-keys manifest is dropped; a region that already hosts a project is untouched (first type wins; re-declare is a no-op, the type is never replaced).
+    - `applyIndustryEffects(next, resourceOf?, geoOf?)` — new exported; the per-turn effect, applied **every committed turn** to the **full** active list: each project grants its region's **SOLE owner** (owner resolved from the FINAL post-claim ownership; 0 or 2+ owners → no boost, project **kept**, never thrown) a deterministic economy boost, clamped to 0–100, mirrored to every region the owner holds (`regionStats`), and each affected nation's derived `stats` re-derived afterwards (same 0-region / no-entry guards as the economy/hybrid dips). Sole ownership is untouched (the layer moves stats, never territory). No-op when there are no active projects; never throws.
+    - `applyTurnResult` — new `resourceOf` param (last) and **industry block** (after the economy block, before markers): `applyIndustryOps` → `applyIndustryEffects` (ops first, so a project declared this turn is paid this turn).
+    - `isMeaningful` — non-empty `industry.projects` makes a turn meaningful.
+    - `validateTurnResult` — initializes and validates `industry` (default `{ projects: [] }`).
+    - `buildSystemPrompt` — documents the `industry` field and a constraint bullet (a per-resource development lever; one project per region — never re-declare on a region that already has one; at most 1–2 per turn, each narrated in `events`) in both tool and plain modes.
+    - `buildUserPrompt` — new optional `nationResources` (each nation's aggregate profile) and `industryProjects` (the active projects) params — emitted as `resources` / `industry` in the payload, only when provided (so the stub / no-manifest prompt stays byte-identical).
+    - `runTurn` — new optional `resourceOf` (last); computes `nationResources` via `deriveNationResources` **only when** the resource manifest is loaded (otherwise omitted from the prompt); passes both new payload fields; the "unclear" fallback carries `industry: { projects: [] }`; `applyTurnResult` receives `resourceOf`.
+  - **Regions loader (`server/regions.ts`).** The optional-manifest pattern extended: `region-resources.json` is probed after `public/` then `dist/`; malformed entries (any of the four values not a finite number in [0,1]) are filtered out, a failure logs `[regions] failed to load region-resources.json, continuing without it` and the server keeps working without it; new `hasResources()` / `resourceOf(key)` accessors (mirror `hasGeo()` / `geoOf()`).
+  - **Server wiring (`server/index.ts`).** The jump route passes `resourceOf: hasResources() ? (key) => resourceOf(key) : undefined` into `runTurn` (like `geoOf`); fresh preset games are created with `industry: []` (dynamic games already via `shared/scenario.ts`).
+  - **Persistence (`server/db.ts`).** `load()` defaults `industry` to `[]` on rows saved before v0.36 (additive migration, alongside `unowned`/`pendingNationOps`/`markers`/`wars`/`trades`/`embargoes`) — legacy games are never wiped and never gain phantom projects.
+  - **Stub (`server/stub.ts`).** The deterministic stub returns `industry: { projects: [] }` — it **never** declares an industry project, so the e2e (CI, `LLM_STUB=1`) assertions are unaffected and the path is covered by unit tests only. `StubPayload` gains optional `resources` / `industry` fields (ignored).
+  - **Unit tests.** New: `scripts/build-region-resources.test.ts` (5 tests); `server/regions.test.ts` (resources load/spot-check/unknown-key, degradation, prod `dist/` layout, incl. a new "with the manifest" case); `server/protocol.test.ts` — `deriveNationResources` (7 tests: area×population weighting, unweighted degradation, profile-skipping, zero profile, single region, weight fallback, 2dp rounding); `server/db.test.ts` — legacy-row default; `server/engine.test.ts` — `validateIndustryOps` (shape/drops), `applyTurnResult` industry ops (declare, per-region SET / re-declare no-op, invalid-key drop, persistence across turns), `applyIndustryEffects` (sole-owner boost, ≥0.5 scaling, multi-project accumulation, ownerless/2+ owner kept-but-unpaid, no-op empty), `isMeaningful`, the system-prompt contract (both modes), the user-prompt payload (carried / omitted), and the `runTurn` defensive init; all pre-existing fixtures gained the new required fields (mechanical, deliberate updates).
+  - **Client.** No change — the industry layer is an engine/LLM concern; its effects surface through the existing stats and event feed.
+  - **AGENTS.md.** New convention entry documenting the resource manifest, the per-region SET semantics, the sole-owner per-turn boost, and the stub/test coverage; the `public/` layout, the scripts pipeline line, and the Commands table all gained `region-resources` / `build:region-resources`.
+
+## v0.35.0 — 2026-10-15 17:22
+- **#58: Trade & Embargoes — a bilateral trade + embargo economy layer with a deterministic per-turn effect and war auto-suspension.** Every prior turn lever moved borders, dipped stats one-shot, or proposed a player-confirmed change. This version adds `TurnResult.economy = { trade: EconomyTradeOp[]; embargo: EconomyEmbargoOp[] }` (required, default `{ trade: [], embargo: [] }`) so the model can declare/lift **bilateral trade agreements** and **unilateral embargoes**, which persist in `GameState` and apply a small, deterministic economic effect **every committed turn**. The engine is **fully deterministic (no hidden randomness)** and **additive** — declares add to the lists, lifts remove, and nothing else (not even a war, beyond the suspension below) mutates them.
+  - **Types (`shared/types.ts`).** New `TradeAgreement` (`{ a; b }` — a symmetric pair, stored sorted `a < b`) and `Embargo` (`{ from; target }` — an ordered unilateral pair) interfaces, plus the required `GameState.trades` and `GameState.embargoes` fields (placed after `wars`). Both are `[]` on a fresh game; rows saved before v0.35 load with them defaulted to `[]` (additive, never wiped).
+  - **Protocol (`shared/protocol.ts`).** New `EconomyTradeOp` (`{ a; b; lift? }`), `EconomyEmbargoOp` (`{ from; target; lift? }`), and `EconomyOps` (`{ trade; embargo }`) types. `TurnResult.economy` is required, placed between `hybrid` and `markers`; a no-`lift` op declares/imposes, `lift: true` ends/lifts.
+  - **Engine (`server/engine.ts`).**
+    - `validateEconomyOps(raw)` — new exported, defensive validator (never throws): a missing/malformed object yields `{ trade: [], embargo: [] }`; each op needs non-empty `a`/`b` (or `from`/`target`) refs (trimmed, ≤200 chars) and a boolean `lift` (default false). Raw refs are kept — resolution happens at apply time against the real state (like wars/hybrid ops).
+    - `applyEconomyOps(next, ops)` — internal; resolves each op's refs via `resolveNationRef` (id first, then unique case-insensitive name). An unresolvable / ambiguous / self-pairing op is dropped (never thrown). A no-`lift` trade **declares** the agreement idempotently (stored sorted, so `{a,b}` and `{b,a}` are the same pair); `lift: true` ends it (a no-op when absent). A no-`lift` embargo **imposes** the ordered from→target pair idempotently; `lift: true` lifts it.
+    - `suspendEconomyOnWar(next)` — internal; any active trade or embargo whose two nations are on **opposite sides of an active war** (v0.33, #56) is removed — a war severs the economic link, so the suspended agreement stops producing its per-turn effect from now on. Runs **after** the turn's war declare/end ops (so it sees the final `next.wars`, including a war declared this turn) and **before** the per-turn effect.
+    - `applyEconomyEffects(next, geoOf?)` — internal; the per-turn effect, applied **every committed turn** to the **full** active lists (not just this turn's declares): each active trade grants **both** parties a small, deterministic economy gain (`TRADE_ECONOMY_BONUS`); each active embargo applies a small, deterministic economy dip to the **target only** (`EMBARGO_ECONOMY_PENALTY`). Clamped to 0–100, mirrored to every region the nation owns (`regionStats`), and each affected nation's derived `stats` re-derived afterwards (same 0-region/no-entry guards as the hybrid dip). No-op when there are no active trades or embargoes; never throws.
+    - `applyTurnResult` — new **economy block** (after the hybrid block, before markers): `applyEconomyOps` → `suspendEconomyOnWar` → `applyEconomyEffects`, in that order (ops first, so a same-turn trade declared between two nations that just went to war is suspended; effects then run on the surviving full lists). Sole ownership is untouched (the economy layer moves stats, never territory).
+    - `isMeaningful` — a non-empty `economy.trade` or `economy.embargo` makes a turn meaningful.
+    - `validateTurnResult` — initializes and validates `economy` (default `{ trade: [], embargo: [] }`).
+    - `buildSystemPrompt` — documents the `economy` field and a constraint bullet (bilateral trade gains both parties; a unilateral embargo hits the target only; omit `lift` to declare/impose, `lift: true` to end/lift; at most 1–2 ops per turn, narrated in `events`; trades/embargoes between warring nations are auto-suspended) in both tool and plain modes.
+    - `buildUserPrompt` — new optional `trades` and `embargoes` params (the currently active agreements/embargoes) so the model knows what is active and can `lift` it; emitted only when provided.
+    - `runTurn` — passes `state.trades` and `state.embargoes` to `buildUserPrompt`; the "unclear" fallback carries `economy: { trade: [], embargo: [] }`.
+  - **Stub (`server/stub.ts`).** The deterministic stub returns `economy: { trade: [], embargo: [] }` — it **never** declares or lifts a trade or embargo, so the e2e (CI, `LLM_STUB=1`) assertions are unaffected and the path is covered by unit tests only (`server/engine.test.ts`).
+  - **Persistence (`server/db.ts`).** `load()` defaults `trades`/`embargoes` to `[]` on rows saved before v0.35 (additive migration, alongside `unowned`/`pendingNationOps`/`markers`/`wars`) — legacy games are never wiped and never gain phantom trades/embargoes.
+  - **Game creation (`server/index.ts`, `shared/scenario.ts`).** Fresh games (preset and dynamic) are created with `trades: []` and `embargoes: []`.
+
+## v0.34.0 — 2026-10-15 16:35
+- **#57: Espionage & Hybrid War — a non-kinetic operations spectrum with a deterministic per-type effect and an exposure backfire.** Every prior turn lever was kinetic (conquest, state-change, region-change, wars, takeovers) or a player-confirmed proposal (nation ops). This version adds `TurnResult.hybrid = { ops: HybridOp[] }` (required, default `{ ops: [] }`) so the model can run **covert, non-kinetic** operations: spies, sabotage, assassination attempts, cyberattacks, economic pressure, disinformation, and proxy support. Unlike territory these **never move borders** — they dip a target's stats or sour a relation. The engine is **fully deterministic (no hidden randomness)**: the LLM declares an intended `outcome` (`success` by default, or `exposed`); a successful op applies its small per-type effect, an `exposed` op **backfires** (no effect, the actor's relation with the target sours one step toward hostile, and an auto `diplomatic`/`failure` event is emitted).
+  - **Protocol (`shared/protocol.ts`).** New `HybridOpType` (the seven types) + `HYBRID_OP_TYPES` const, and the `HybridOp` interface (`{ type; from; target; detail?; outcome? }`). `from` is the acting nation (id or unique name — resolved at apply time); `target` is **either** a nation (id/name) **or** a region key (hits that region's sole owner). `TurnResult.hybrid = { ops: HybridOp[] }` is required, placed between `wars` and `markers`.
+  - **Engine (`server/engine.ts`).**
+    - `isHybridOpType(t)` — exported guard over the seven types.
+    - `validateHybridOps(raw)` — new exported, defensive validator (never throws): accepts the `{ ops: […] }` object **or** a bare array; each op needs a known `type`, a non-empty `from` (≤200) and non-empty `target` (≤200); `outcome:'exposed'` is kept (success/missing is omitted to keep the shape minimal); `detail` capped at 300.
+    - `HYBRID_STAT_EFFECT` — exported table of the deterministic per-type stat dip: `sabotage`→economy −3, `assassinate`→stability −5, `cyber`→military −3, `economic`→economy −5; `spy`/`information`/`proxy` have no stat effect.
+    - `shiftRelationTowardHostile(state, a, b, cap)` — exported; nudges the bilateral relation **one** rung up the hostile ladder (`ally→neutral→rival→hostile`), symmetrically, capped at `cap`; a missing relation starts at `neutral`; a `war` relation is never touched (a covert op neither fabricates nor downgrades a war). Used for the `information`/`proxy` nudge and the `exposed` backfire.
+    - `resolveHybridTarget(state, target, validKeys?)` — internal; resolves a target to the concrete nation it affects: a nation ref via `resolveNationRef`, else a region key's **sole** owner (0 or 2+ owners → not targetable); `validKeys` (when supplied) gates the region path.
+    - `applyHybridOp(next, op, geoOf?, validKeys?, regionNameOf?, actingTurn?)` — internal; resolves `from`/`target` (unknown/ambiguous actor, unresolvable target, and self-targets are dropped — never throw), then applies the per-type effect: an `exposed` op backfires (relation sours one step, cap hostile, auto `diplomatic`/`failure` event); a successful stat op dips the target's `regionStats` (the single named region for a region target, otherwise **every** region the target owns) and re-derives the target nation's aggregate stats (same 0-region/no-entry guards as the main recompute) so the effect persists; `information`/`proxy` nudge the relation (caps `hostile`/`rival`); `spy` is informational only.
+    - `applyTurnResult` — new **hybrid block** (after the wars block, before markers): applies each validated op against the post-wars state. Sole ownership is preserved (a hybrid op affects stats, never ownership).
+    - `isMeaningful` — a non-empty `hybrid.ops` makes a turn meaningful.
+    - `validateTurnResult` — initializes and validates `hybrid` (default `{ ops: [] }`).
+    - `buildSystemPrompt` — documents the `hybrid` field and a HARD CONSTRAINTS bullet (non-kinetic, never moves borders, the per-type effects, the `exposed` backfire, region-key targets hit the sole owner, at most a few per turn, narrate each in `events`) in both tool and plain modes.
+    - `buildUserPrompt` — new optional `relations` param (the player's `nationId → RelationStatus` map) so the model sees the ladder its ops nudge and the starting point before a backfire; emitted only when provided.
+    - `runTurn` — computes the player's `relations` from state and passes them as the last `buildUserPrompt` arg; the "unclear" fallback carries `hybrid: { ops: [] }`.
+  - **Additive only.** No `GameState` field, **no** DB migration, **no** `db.ts` change — `hybrid` lives entirely in the `TurnResult` and is consumed by `applyTurnResult`.
+  - **Stub (`server/stub.ts`).** `deterministicTurn` returns `hybrid: { ops: [] }` — the stub **never** runs a covert op (mirrors `nationOps: []`, `takeovers: []`, `wars`). `StubPayload` gains an optional `relations` field (ignored). E2E (CI, `LLM_STUB=1`) is fully unaffected; the path is unit-tested only.
+  - **Unit tests (`server/engine.test.ts`).** ~30 new tests: `isHybridOpType`; `validateHybridOps` (both raw shapes, trim/cap, exposed-vs-success, drop rules); `validateTurnResult` — hybrid; `isMeaningful` — hybrid; `shiftRelationTowardHostile` (ladder, caps, war-untouched, missing=neutral); `applyTurnResult` — hybrid (each stat type's dip, nation-vs-region target, the per-type relation nudge & caps, `exposed` backfire + auto event, exposed-on-war, drop rules for unknown actor / self-target / unknown region / double-owned region, the `validKeys` gate, borders-untouched invariant, `HYBRID_STAT_EFFECT` magnitudes); `buildSystemPrompt` — hybrid contract (both modes); `buildUserPrompt` — relations; stub — hybrid.
+  - **Client.** No change — hybrid ops are an engine/LLM concern; their effects surface through the existing stats, relations, and event feed.
+  - **AGENTS.md.** New convention entry documenting the `hybrid` field, the deterministic per-type effects, the `exposed` backfire, the region-vs-nation targeting, and the stub/test coverage.
+
 ## v0.33.0 — 2026-10-15 15:45
 - **#56: War as a first-class state — the `war` relation becomes a named `War` entity.** The v0.22+ `war` relation was a bare boolean flag on the `Relation` type with no lifecycle, no identity, and no way to distinguish "at war since 1939" from "at war since 1941" or to narrate the end of a conflict. This version promotes it to a first-class `War` entity in `GameState.wars` with a stable id, sides, declaration date/turn, optional aims, a lifecycle status (`active` / `armistice` / `capitulation`), and an optional front (region keys). The LLM declares and ends wars via `TurnResult.wars = { declare, end }` (both required, default `[]`); the engine creates/updates the entity and **derives** the `war` relation from active wars (any two nations on opposite sides of ≥1 active war get `war` in both directions, overriding lesser statuses — you cannot "make peace" without ending the war). When a war ends, the pairs it caused that are not covered by another active war fall back to `hostile`. A **bare** `war` relation with no matching active war (legacy/back-compat) is never downgraded and never force-created. **Mutual-defense drag-in**: when a war is declared, each belligerent's `ally`-relation partners are added to the war's `sides` (one level, no cascade; deterministic — sides in declared order, allies in sorted id order), so the dragged-in ally becomes `war` with all belligerents including its former ally.
   - **Types (`shared/types.ts`).** New `War` interface (`id`, `sides: string[]` ≥2 distinct, `declaredTurn: number`, `declaredDate?: string`, `aims?: string[]`, `status: 'active'|'armistice'|'capitulation'`, `front?: string[]`); `GameState.wars: War[]` (required, `[]` at creation; a legacy SQLite row without the field loads as `[]` — additive, never wipes).

package.json

@@ -1,6 +1,6 @@
 {
   "name": "history",
-  "version": "0.33.0",
+  "version": "0.36.0",
   "private": true,
   "type": "module",
   "description": "AI-driven alternate-history simulator — the LLM is the world engine (Pax Historia style).",
@@ -20,6 +20,7 @@
     "build:region-adjacency": "node scripts/build-region-adjacency.mjs",
     "build:region-centroids": "node scripts/build-region-centroids.mjs",
     "build:region-geo": "node scripts/build-region-geo.mjs",
+    "build:region-resources": "node scripts/build-region-resources.mjs",
     "extract:admin0-pop": "node scripts/extract-admin0-pop.mjs",
     "typecheck": "tsc --noEmit",
     "lint": "eslint .",

scripts/build-region-resources.mjs

@@ -0,0 +1,149 @@
+/**
+ * scripts/build-region-resources.mjs — build the region **resources** manifest:
+ * `public/region-resources.json` = `{ "<regionKey>": { "oil": <0-1>, "iron": <0-1>, "food": <0-1>, "industry": <0-1> }, ... }`.
+ *
+ * Every sub-region (region key, see `public/region-keys.json`) gets a
+ * synthesized four-value resource profile. For each resource dimension a
+ * value in [0, 1] (2 decimal places) is derived from the FNV-1a 32-bit hash
+ * of the region key (salted per resource — the same tiny, stable, pure
+ * string hash the region keys themselves use), then scaled MODESTLY by the
+ * region's area (from the committed `public/region-geo.json`, when present):
+ * larger regions carry a slightly higher value (a log-scaled factor of at
+ * most ~1.2), so a big region reads as holding more of each resource. The
+ * geo file is OPTIONAL — without it (or for a zero-area region) the factor
+ * is exactly 1 and the profile is pure hash.
+ *
+ * This is the v0.36 (#59) "Resources & Industry" data source: the engine
+ * scales each region's per-turn industry boost by its `industry` value, and
+ * the LLM prompt carries each nation's aggregate profile (the
+ * area×population-weighted mean of the owned regions' profiles, see
+ * `deriveNationResources` in shared/protocol.ts). The profiles are
+ * synthesized (there is no real per-sub-region resource census) — they exist
+ * to give the model a stable, deterministic world fact to reason about.
+ *
+ * Output contract (asserted by scripts/build-region-resources.test.ts):
+ *   - one entry for **every** region key, keyed identically to
+ *     `public/region-keys.json` (same key set, 1,800 entries);
+ *   - each entry is `{ oil, iron, food, industry }`, every value a finite
+ *     number in [0, 1] with at most 2 decimal places;
+ *   - keys are in sorted (deterministic) order.
+ *
+ * Deterministic + idempotent: fixed inputs (the key manifest, and the
+ * committed geo file when present), pure string hashing, fixed 2-dp
+ * rounding, and stable sorted key order → a re-run rewrites a byte-identical
+ * file (the test re-runs this script and compares bytes).
+ *
+ * Usage: `node scripts/build-region-resources.mjs`  (or `npm run build:region-resources`).
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(here, '..');
+
+const round2 = (v) => Math.round(v * 100) / 100;
+
+/** FNV-1a 32-bit — the same tiny, stable, pure hash the region keys use. */
+function fnv1a32(str) {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h >>> 0;
+}
+
+const RESOURCES = ['oil', 'iron', 'food', 'industry'];
+
+// --- load the inputs (plain parse) ------------------------------------------
+const keysPath = path.join(root, 'public', 'region-keys.json');
+const geoPath = path.join(root, 'public', 'region-geo.json');
+
+let idToKey;
+try {
+  idToKey = JSON.parse(readFileSync(keysPath, 'utf8'));
+} catch (err) {
+  console.error(`[build-region-resources] could not load ${keysPath}.`);
+  throw err;
+}
+
+// region-geo is OPTIONAL: a missing/broken file means "no area scaling"
+// (factor 1 for every region) — the profile is then pure hash.
+let areaByKey = {};
+try {
+  const parsed = JSON.parse(readFileSync(geoPath, 'utf8'));
+  for (const [k, v] of Object.entries(parsed)) {
+    if (v && typeof v.area === 'number' && Number.isFinite(v.area) && v.area >= 0) {
+      areaByKey[k] = v.area;
+    }
+  }
+} catch {
+  areaByKey = {};
+}
+
+/**
+ * The base value in [0, 1) for one (region key, resource): the low 14 bits of
+ * the salted FNV-1a hash, normalized. Stable across runs and platforms; a
+ * uniform-enough spread for a synthesized profile.
+ */
+const base = (key, resource) => (fnv1a32(`${key}\u0000${resource}`) & 0x3fff) / 0x4000;
+
+/**
+ * The area scaling factor: 1.0 for a region with no geo entry (or zero area),
+ * rising on a log scale (clamped) to at most ~1.2 for the largest regions —
+ * bigger regions hold proportionally more of each resource.
+ */
+const areaScale = (key) => {
+  const a = areaByKey[key];
+  if (!a || a <= 0) return 1;
+  // log10(1 + area) runs ~0.004 (tiny slivers) to ~5.5 (a 300k km² region);
+  // /8 + clamp keeps the factor in [1, 1.2].
+  const t = Math.min(1, Math.log10(1 + a) / 8);
+  return 1 + 0.2 * t;
+};
+
+// --- assemble the manifest (sorted keys) -------------------------------------
+const expectedKeys = Object.values(idToKey);
+const manifest = {};
+for (const k of [...expectedKeys].sort()) {
+  const scale = areaScale(k);
+  manifest[k] = {
+    oil: round2(Math.min(1, base(k, 'oil') * scale)),
+    iron: round2(Math.min(1, base(k, 'iron') * scale)),
+    food: round2(Math.min(1, base(k, 'food') * scale)),
+    industry: round2(Math.min(1, base(k, 'industry') * scale)),
+  };
+}
+
+// --- hard assertions (the test re-checks these against the committed file) ----
+if (Object.keys(manifest).length !== expectedKeys.length) {
+  throw new Error(
+    `expected ${expectedKeys.length} region-resources entries (one per region key), got ${Object.keys(manifest).length}`,
+  );
+}
+let scaled = 0;
+for (const [k, v] of Object.entries(manifest)) {
+  if (areaByKey[k]) scaled += 1;
+  for (const r of RESOURCES) {
+    const val = v[r];
+    if (typeof val !== 'number' || !Number.isFinite(val) || val < 0 || val > 1) {
+      throw new Error(`bad ${r} value for ${k}: ${JSON.stringify(val)}`);
+    }
+    if (Math.round(val * 100) / 100 !== val) {
+      throw new Error(`${r} over 2dp for ${k}: ${val}`);
+    }
+  }
+}
+
+// --- write idempotently (sorted keys, 2-space indent, trailing newline) ------
+writeFileSync(
+  path.join(root, 'public', 'region-resources.json'),
+  JSON.stringify(manifest, null, 2) + '\n',
+);
+
+// --- summary ------------------------------------------------------------------
+console.log(
+  `[build-region-resources] wrote public/region-resources.json — ${Object.keys(manifest).length} region keys` +
+    ` (${scaled} area-scaled, ${Object.keys(manifest).length - scaled} pure-hash)`,
+);

scripts/build-region-resources.test.ts

@@ -0,0 +1,106 @@
+/**
+ * scripts/build-region-resources.test.ts — validation for the committed
+ * `public/region-resources.json` (built by `scripts/build-region-resources.mjs`).
+ *
+ * The manifest maps each region key to a synthesized four-value resource
+ * profile `{ oil, iron, food, industry }` — each a finite number in [0, 1]
+ * (2 decimal places). It is the v0.36 (#59) "Resources & Industry" data
+ * source: the engine scales each region's per-turn industry boost by its
+ * `industry` value, and the LLM prompt carries each nation's aggregate
+ * profile (the area×population-weighted mean of the owned regions' profiles,
+ * `deriveNationResources` in shared/protocol.ts).
+ *
+ * Like the region-geo manifest, this is a load-bearing data artifact — the
+ * test pins its contract. It is dependency-free: it reads the JSON with plain
+ * `fs`/`JSON.parse` (no `@turf`/geojson types, which would pull `@types/geojson`
+ * into the tsc program and break `WorldMap.tsx` — see the v0.17 note). The
+ * determinism test re-runs the (turf-free) `.mjs` builder and compares bytes,
+ * matching that the builder is idempotent.
+ */
+import { readFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(here, '..');
+
+function readJson(rel: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(path.join(root, rel), 'utf8'));
+}
+
+interface ResourceEntry {
+  oil: number;
+  iron: number;
+  food: number;
+  industry: number;
+}
+
+const RESOURCES = ['oil', 'iron', 'food', 'industry'] as const;
+
+// feature id -> region key
+const manifest = readJson('public/region-keys.json') as Record<string, string>;
+const resources = readJson('public/region-resources.json') as Record<string, ResourceEntry>;
+const keys = Object.values(manifest);
+
+describe('region-resources.json', () => {
+  it('has exactly one entry per region key (same key set as region-keys.json)', () => {
+    expect(new Set(Object.keys(resources))).toEqual(new Set(keys));
+    expect(Object.keys(resources)).toHaveLength(1800);
+  });
+
+  it('is keyed in sorted (deterministic) order', () => {
+    const ks = Object.keys(resources);
+    expect(ks).toEqual([...ks].sort());
+  });
+
+  it('every entry is a finite { oil, iron, food, industry } in [0,1] with ≤ 2 dp', () => {
+    for (const [k, v] of Object.entries(resources)) {
+      for (const r of RESOURCES) {
+        const val = v[r];
+        expect(typeof val, `non-number ${r} for ${k}`).toBe('number');
+        expect(Number.isFinite(val), `non-finite ${r} for ${k}`).toBe(true);
+        expect(val >= 0, `negative ${r} for ${k}: ${val}`).toBe(true);
+        expect(val <= 1, `${r} above 1 for ${k}: ${val}`).toBe(true);
+        expect(
+          Math.round(val * 100) / 100 === val,
+          `${r} over 2dp for ${k}: ${val}`,
+        ).toBe(true);
+      }
+    }
+  });
+
+  it('spot-checks well-known regions for exact profiles', () => {
+    const is = (k: string, oil: number, iron: number, food: number, industry: number) => {
+      const v = resources[k];
+      expect(v, `missing resources for ${k}`).toBeDefined();
+      expect(v!.oil, `oil for ${k}`).toBe(oil);
+      expect(v!.iron, `iron for ${k}`).toBe(iron);
+      expect(v!.food, `food for ${k}`).toBe(food);
+      expect(v!.industry, `industry for ${k}`).toBe(industry);
+    };
+    is('california-kikh', 0.31, 0.1, 0.82, 0.97); // US-CA
+    is('arkhangel-sk-lhbk', 0.49, 0.52, 0.98, 0.82); // RU-ARK mainland core
+    is('pechora-qwhs', 0.11, 0.16, 1, 0.04); // RU-PEO (Arctic-coast band, #41)
+    is('yamal-gosw', 0.64, 1, 1, 0.49); // RU-YAM (Arctic-coast band, #41)
+    is('new-earth-eikt', 0.6, 0.56, 0.91, 0.66); // RU-ARK-NE (island group, #31)
+    is('severnaya-zemlya-awqp', 0.1, 0.48, 1, 0.3); // RU-ARK-SZ (island group, #31)
+    is('ain-lqtt', 0.94, 0.92, 0.51, 0.4); // FR-01 (Ain)
+  });
+
+  it('is deterministic: re-running the builder rewrites a byte-identical file', () => {
+    const file = path.join(root, 'public', 'region-resources.json');
+    const before = readFileSync(file, 'utf8');
+    // The builder is cwd-independent (it resolves the repo root from its own
+    // location) and idempotent: same input files (region-keys.json + the
+    // committed region-geo.json when present) + pure string hashing + fixed
+    // 2-dp rounding + stable (sorted) key order → identical bytes.
+    execFileSync(process.execPath, [path.join(root, 'scripts', 'build-region-resources.mjs')], {
+      cwd: root,
+      stdio: 'pipe',
+    });
+    const after = readFileSync(file, 'utf8');
+    expect(after).toBe(before);
+  });
+});

server/db.test.ts

@@ -33,6 +33,11 @@ function makeState(id: string): GameState {
     },
     // (v0.33.0, #56) no wars.
     wars: [],
+    // (v0.35.0, #58) no active trades or embargoes.
+    trades: [],
+    embargoes: [],
+    // (v0.36.0, #59) no industry projects.
+    industry: [],
   };
 }
 
@@ -149,6 +154,30 @@ describe('openDb', () => {
     db.close();
   });
 
+  it('(v0.35.0 #58) a legacy row saved before the trades/embargoes fields existed loads with them defaulted to []', () => {
+    const db = openDb(':memory:');
+    const legacy = makeState('legacy');
+    delete (legacy as { trades?: unknown[] }).trades; // a pre-v0.35 save (fields absent)
+    delete (legacy as { embargoes?: unknown[] }).embargoes;
+    db.save(legacy);
+    const loaded = db.load('legacy');
+    expect(loaded).not.toBeNull();
+    expect(loaded!.trades).toEqual([]);
+    expect(loaded!.embargoes).toEqual([]);
+    db.close();
+  });
+
+  it('(v0.36.0 #59) a legacy row saved before the industry field existed loads with it defaulted to []', () => {
+    const db = openDb(':memory:');
+    const legacy = makeState('legacy');
+    delete (legacy as { industry?: unknown[] }).industry; // a pre-v0.36 save (field absent)
+    db.save(legacy);
+    const loaded = db.load('legacy');
+    expect(loaded).not.toBeNull();
+    expect(loaded!.industry).toEqual([]);
+    db.close();
+  });
+
   it('delete removes a game by id and reports absence otherwise', () => {
     const db = openDb(':memory:');
     db.save(makeState('a'));

server/db.ts

@@ -53,6 +53,13 @@ export function openDb(filePath: string): Db {
         // (any pre-v0.33 `war` relation stays a bare/implicit relation — see
         // syncWarRelations, which never force-creates a War entity).
         if (state.wars === undefined) state.wars = [];
+        // (v0.35.0, #58) Same for the trade & embargo economy layer: a
+        // legacy game has no active trades or embargoes.
+        if (state.trades === undefined) state.trades = [];
+        if (state.embargoes === undefined) state.embargoes = [];
+        // (v0.36, #59) Same for the industry layer: a legacy game has no
+        // active industry projects.
+        if (state.industry === undefined) state.industry = [];
         // (v0.28, #46) Rows saved before per-region stats existed are migrated
         // ONCE at load time (and never re-migrated afterwards — the field is
         // then present): each owned region is seeded with a copy of its owner's

server/engine.ts

@@ -4,32 +4,45 @@
 // and (4) builds the advisor brainstorm prompt. The network call itself lives in
 // llm.ts (injectable) and is invoked by runTurn.
 import type {
+  Embargo,
   EventOutcome,
   EventType,
   GameState,
+  IndustryProject,
+  IndustryType,
   MapMarker,
   Nation,
   NationStats,
   Preset,
   RelationStatus,
+  RegionResources,
   RegionStats,
   RoundItem,
   StatKey,
+  TradeAgreement,
   War,
 } from '../shared/types';
-import { EVENT_TYPES, RELATION_STATUSES } from '../shared/types';
+import { EVENT_TYPES, INDUSTRY_TYPES, RELATION_STATUSES } from '../shared/types';
 import {
   addDays,
   canConquer,
   clampStat,
+  deriveNationResources,
   deriveNationStats,
   fnv1a32,
+  HYBRID_OP_TYPES,
   isDateLike,
   isMarkerType,
   makeEvent,
   markerId,
   MAX_MARKERS,
   nationForPrompt,
+  type EconomyEmbargoOp,
+  type EconomyOps,
+  type EconomyTradeOp,
+  type HybridOp,
+  type HybridOpType,
+  type IndustryOps,
   type MarkerInfo,
   type MarkerSpec,
   type NationOp,
@@ -55,6 +68,19 @@ const VALID_EVENT_TYPES = new Set<string>(EVENT_TYPES);
 const VALID_RELATIONS = new Set<string>(RELATION_STATUSES);
 const VALID_OUTCOMES = new Set<string>(['success', 'failure', 'partial', 'neutral']);
 const VALID_STATS = new Set<string>(['military', 'economy', 'stability', 'population']);
+const VALID_HYBRID_TYPES = new Set<string>(HYBRID_OP_TYPES);
+
+/** True when `t` is one of the seven known hybrid op types (v0.34.0, #57). */
+export function isHybridOpType(t: unknown): t is HybridOpType {
+  return typeof t === 'string' && VALID_HYBRID_TYPES.has(t);
+}
+
+const VALID_INDUSTRY_TYPES = new Set<string>(INDUSTRY_TYPES);
+
+/** True when `t` is one of the four known industry project types (v0.36, #59). */
+export function isIndustryType(t: unknown): t is IndustryType {
+  return typeof t === 'string' && VALID_INDUSTRY_TYPES.has(t);
+}
 
 // --- The LLM's getNeighbours tool (v0.21, #16 P2: contiguous region transfers) ---
 
@@ -154,7 +180,9 @@ export function playerFrontier(
  * (v0.21, #16 P2): the model may only move regions across a shared border, and
  * may verify borders with the tool before answering. The contract also
  * documents the `nationOps` proposal queue (v0.23, #16 P4a) — rename plus the
- * split/merge shapes applied on player confirm (v0.24, #16 P4b).
+ * split/merge shapes applied on player confirm (v0.24, #16 P4b), and the
+ * trade & embargo economy layer (v0.35.0, #58): bilateral trades and
+ * unilateral embargoes, each ended with a `lift: true` op.
  */
 export function buildSystemPrompt(preset: Preset, withNeighboursTool = false): string {
   const rules = preset.simulationRules
@@ -206,6 +234,9 @@ export function buildSystemPrompt(preset: Preset, withNeighboursTool = false): s
     '  ],',
     '  "takeovers": [{"nationRef":"<nation id or name>","newRegimeName":"<name of the new regime>"}],',
     '  "wars": {"declare":[{"sides":["<nationId>","<nationId>"],"aims":["<short aim>"]}],"end":[{"id":"<war id>","outcome":"<armistice|capitulation>","terms":"<short terms>"}]},',
+    '  "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>"}]},',
     '  "markers": {"add":[{"type":"<city|factory|army|port|capital|fleet|rocket|gathering>","name":"<short name>","regionKey":"<region key>"}],"remove":["<marker id>"]}',
     '}',
     '',
@@ -225,6 +256,9 @@ export function buildSystemPrompt(preset: Preset, withNeighboursTool = false): s
     '- Merge: add {"kind":"merge","nationRefs":["<id or name>","<id or name>"],"survivingRef":"<id or name of the surviving nation>","into":"<new name>"} when states reunify or one is absorbed. Use at least 2 input nations and "survivingRef" must name one of them — the survivor keeps its id and its stats.',
     '- Takeover (automatic, NOT player-confirmed): add {"takeovers":[{"nationRef":"<nation id or name>","newRegimeName":"<name of the new regime>"}]} when a low-stability nation (e.g. stability < 30) hosting a "gathering" marker is overthrown in a coup or revolution. This renames the nation to the new regime (e.g. "France" → "Vichy Regime"). Also emit a narrative "event" (political or social, outcome "success") and a stability/economy shock via "stateChanges". A takeover is an automatic in-world regime change — use "nationOps" rename only for a diplomatic/political name change that the player must confirm.',
     '- Wars ("wars") are named conflicts, each with a stable id. To DECLARE one, add {"declare":[{"sides":["<id>","<id>"],"aims":[...]}]} with at least 2 distinct belligerents: while it is active the engine AUTOMATICALLY sets both directions of every warring pair\'s relation to "war" and drags in the mutual-defense allies of each belligerent, so do NOT also emit a "war" relation for those pairs (you can never "make peace" between them without ending the war). To END an active war, add {"end":[{"id":"<war id from the user message\'s "wars" field>","outcome":"<armistice|capitulation>"}]} — only active wars can be ended, and when one ends its belligerent pairs fall back to "hostile". Propose at most 1-2 declarations per turn and narrate each declaration and each ending in "events".',
+    '- 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.',
     '- 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.',
@@ -242,6 +276,9 @@ export function buildSystemPrompt(preset: Preset, withNeighboursTool = false): s
  * other consumer) can read the exact items. The framing instruction tells the
  * model to simulate the combined consequences of the whole batch (or to let the
  * world advance on its own when the batch is empty) and return one TurnResult.
+ * (v0.35.0, #58) It also carries the currently active `trades` / `embargoes`
+ * (omitted entirely when undefined, like the other optional fields) so the
+ * model can reference them — and `lift` them — in `TurnResult.economy`.
  */
 export function buildUserPrompt(
   state: GameState,
@@ -276,6 +313,44 @@ export function buildUserPrompt(
    * Omitted entirely when undefined.
    */
   wars?: WarInfo[],
+  /**
+   * (v0.34.0, #57) The player's current relations to every other nation
+   * (`nationId -> RelationStatus`). Emitted verbatim (even when empty) so the
+   * model sees the relation ladder it can nudge with `information` / `proxy`
+   * hybrid ops and knows the current state before an `exposed` backfire.
+   * Omitted entirely when undefined.
+   */
+  relations?: Record<string, RelationStatus>,
+  /**
+   * (v0.35.0, #58) The currently active bilateral trade agreements (each a
+   * pair of nation ids). Emitted verbatim (even when empty) so the model
+   * knows which trades exist and can end one with `economy.trade` +
+   * `lift: true`. Omitted entirely when undefined.
+   */
+  trades?: TradeAgreement[],
+  /**
+   * (v0.35.0, #58) The currently active unilateral embargoes (each an
+   * `from` → `target` pair of nation ids). Emitted verbatim (even when
+   * empty) so the model knows which embargoes are in force and can lift one
+   * with `economy.embargo` + `lift: true`. Omitted entirely when undefined.
+   */
+  embargoes?: Embargo[],
+  /**
+   * (v0.36, #59) Each nation's AGGREGATE resource profile (nation id -> the
+   * area×population-weighted mean of the resource profiles of the regions it
+   * owns, via `deriveNationResources`). Emitted verbatim (even when empty) so
+   * the model can reason about which nations are rich in which resource and
+   * where to build industry projects. Omitted entirely when undefined (no
+   * resource manifest loaded).
+   */
+  nationResources?: Record<string, RegionResources>,
+  /**
+   * (v0.36, #59) The game's currently ACTIVE industry projects (each a region
+   * key + project type). Emitted verbatim (even when empty) so the model knows
+   * which regions already host a project (and should not be re-declared) and
+   * can reference them. Omitted entirely when undefined.
+   */
+  industryProjects?: IndustryProject[],
 ): string {
   const player = state.nations[state.playerNationId];
   const playerName = player?.name ?? state.playerNationId;
@@ -389,6 +464,11 @@ export function buildUserPrompt(
   if (noMansLand !== undefined) payload.unowned = noMansLand;
   if (markers !== undefined) payload.markers = markers;
   if (wars !== undefined) payload.wars = wars;
+  if (relations !== undefined) payload.relations = relations;
+  if (trades !== undefined) payload.trades = trades;
+  if (embargoes !== undefined) payload.embargoes = embargoes;
+  if (nationResources !== undefined) payload.resources = nationResources;
+  if (industryProjects !== undefined) payload.industry = industryProjects;
   return JSON.stringify(payload, null, 2);
 }
 
@@ -528,6 +608,9 @@ export function validateTurnResult(
     nationOps: [],
     takeovers: [],
     wars: { declare: [], end: [] },
+    hybrid: { ops: [] },
+    economy: { trade: [], embargo: [] },
+    industry: { projects: [] },
     markers: { add: [], remove: [] },
   };
 
@@ -626,6 +709,26 @@ export function validateTurnResult(
   // Applied directly by applyTurnResult (after takeovers, before markers).
   result.wars = validateWarOps(o.wars);
 
+  // (v0.34.0, #57) Covert hybrid ops (spies, sabotage, assassination, cyber,
+  // economic, disinformation, proxy). Applied directly by applyTurnResult
+  // (after wars, before markers) — a deterministic per-type effect or an
+  // exposed backfire.
+  result.hybrid = { ops: validateHybridOps(o.hybrid) };
+
+  // (v0.35.0, #58) Trade & embargo ops: a no-`lift` op declares / imposes,
+  // `lift: true` ends / lifts. Refs stay raw here and are resolved at apply
+  // time against the real state (like wars / hybrid ops); unknown /
+  // ambiguous / self-pairing ops are dropped there, never thrown.
+  result.economy = validateEconomyOps(o.economy);
+
+  // (v0.36, #59) Industry projects: the LLM names a region key + one of the
+  // four project types. Each project becomes an active entry in
+  // `GameState.industry` (a per-region SET). The region key is validated as a
+  // non-empty string here; whether the key is real and owned is checked at
+  // apply time (a project on a region with no sole owner yields no boost but
+  // is kept). Refs stay raw and the effect is deterministic at apply time.
+  result.industry = validateIndustryOps(o.industry);
+
   // (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).
@@ -806,6 +909,128 @@ export function validateWarOps(raw: unknown): { declare: WarDeclareOp[]; end: Wa
   return out;
 }
 
+/**
+ * (v0.34.0, #57) Validate the raw `hybrid` field of a turn into a safe
+ * `{ ops }` shape. Defensive like the rest of the parser — never throws. The
+ * raw value may be the object `{ ops: [...] }` (the TurnResult shape) or a bare
+ * array (be lenient about either). Each op needs a known `type` (one of
+ * {@link HYBRID_OP_TYPES}), a non-empty `from` (the acting nation, capped at
+ * 200 chars) and a non-empty `target` (a nation id/name or a region key, capped
+ * at 200 chars); an `outcome` of exactly `success` or `exposed` is kept (the
+ * default, `success`, is stored as absent to keep the shape minimal — the
+ * engine treats a missing outcome as success); a non-empty `detail` is capped
+ * at 300 chars. Resolution of `from` / `target` to concrete nation ids or
+ * region owners happens at apply time (`applyHybridOp`), not here.
+ */
+export function validateHybridOps(raw: unknown): HybridOp[] {
+  if (!Array.isArray(raw)) {
+    // Lenient: accept the `{ ops: [...] }` object shape (or a non-array → []).
+    if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+      const inner = (raw as Record<string, unknown>).ops;
+      if (!Array.isArray(inner)) return [];
+      return validateHybridOpsList(inner);
+    }
+    return [];
+  }
+  return validateHybridOpsList(raw);
+}
+
+function validateHybridOpsList(raw: unknown[]): HybridOp[] {
+  const out: HybridOp[] = [];
+  for (const e of raw) {
+    if (!e || typeof e !== 'object') continue;
+    const o = e as Record<string, unknown>;
+    if (!isHybridOpType(o.type)) continue;
+    const from = str(o.from, 200);
+    const target = str(o.target, 200);
+    if (!from || !target) continue;
+    const detail = str(o.detail, 300);
+    const exposed = o.outcome === 'exposed'; // 'success' / missing → success
+    out.push({
+      type: o.type,
+      from,
+      target,
+      ...(detail ? { detail } : {}),
+      ...(exposed ? { outcome: 'exposed' as const } : {}),
+    });
+  }
+  return out;
+}
+
+/**
+ * (v0.35.0, #58) Validate the raw `economy` object of a turn into a safe
+ * {@link EconomyOps}. Defensive like the rest of the parser — never throws.
+ * `trade`: each op needs non-empty `a` and `b` refs (a nation's id or unique
+ * name, capped at 200 chars) and a boolean `lift` (default false = declare);
+ * ops with a missing ref are dropped — ref resolution and the
+ * a≠b / from≠target checks happen at apply time against the real state
+ * (like wars / hybrid ops, whose raw refs are kept here). `embargo`: each op
+ * needs non-empty `from` and `target` refs and a boolean `lift` (default
+ * false = impose). A missing / malformed top-level object yields
+ * `{ trade: [], embargo: [] }`.
+ */
+export function validateEconomyOps(raw: unknown): EconomyOps {
+  const out: EconomyOps = { trade: [], embargo: [] };
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return out;
+  const o = raw as Record<string, unknown>;
+
+  if (Array.isArray(o.trade)) {
+    for (const e of o.trade) {
+      if (!e || typeof e !== 'object') continue;
+      const t = e as Record<string, unknown>;
+      const a = str(t.a, 200);
+      const b = str(t.b, 200);
+      if (!a || !b) continue;
+      const op: EconomyTradeOp = { a, b };
+      if (t.lift === true) op.lift = true;
+      out.trade.push(op);
+    }
+  }
+
+  if (Array.isArray(o.embargo)) {
+    for (const e of o.embargo) {
+      if (!e || typeof e !== 'object') continue;
+      const t = e as Record<string, unknown>;
+      const from = str(t.from, 200);
+      const target = str(t.target, 200);
+      if (!from || !target) continue;
+      const op: EconomyEmbargoOp = { from, target };
+      if (t.lift === true) op.lift = true;
+      out.embargo.push(op);
+    }
+  }
+
+  return out;
+}
+
+/**
+ * (v0.36, #59) Validate the raw `industry` object of a turn into a safe
+ * {@link IndustryOps}. Defensive like the rest of the parser — never throws.
+ * `projects`: each op needs a non-empty `regionKey` (capped at 120 chars) and a
+ * known project {@link IndustryType} (one of INDUSTRY_TYPES); ops with a
+ * missing/malformed field are dropped. The region key is kept raw here (like
+ * the hybrid / economy refs) — whether it is a *valid* region key, and whether
+ * its region ends the turn with a sole owner, is checked at apply time against
+ * the manifest and the final ownership (a project on a region with no sole
+ * owner yields no boost but is kept). A missing / malformed top-level object
+ * yields `{ projects: [] }`.
+ */
+export function validateIndustryOps(raw: unknown): IndustryOps {
+  const out: IndustryOps = { projects: [] };
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return out;
+  const o = raw as Record<string, unknown>;
+  if (Array.isArray(o.projects)) {
+    for (const e of o.projects) {
+      if (!e || typeof e !== 'object') continue;
+      const p = e as Record<string, unknown>;
+      const regionKey = str(p.regionKey, 120);
+      if (!regionKey || !isIndustryType(p.type)) continue;
+      out.projects.push({ regionKey, type: p.type });
+    }
+  }
+  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},
@@ -879,8 +1104,460 @@ export function syncWarRelations(prev: GameState, next: GameState): void {
   }
 }
 
+// --- Hybrid war (v0.34.0, #57): covert, non-kinetic operations -------------
+//
+// The engine's DETERMINISTIC effects for the seven hybrid op types. There is no
+// hidden randomness: the LLM declares an intended `outcome` (success / exposed)
+// and the engine acts only on that. Each effect is small and documented:
+//
+//   spy         informational only — no stat, no relation (pure intel)
+//   sabotage    a small ECONOMY dip on the target
+//   assassinate a small STABILITY dip on the target (absent the named-leaders
+//               feature, #61, a leader's removal sours the polity)
+//   cyber       a small MILITARY dip on the target
+//   economic    a small ECONOMY dip on the target
+//   information a relation nudge toward hostile (cap hostile) — disinformation
+//   proxy       a light relation nudge toward hostile (cap rival) — proxy war
+//
+// A successful stat op dips the target's `regionStats` (the single named region
+// when the target was a region key, otherwise every region the target owns) and
+// re-derives the target nation's aggregate stats so the effect persists. A
+// successful information/proxy and any exposed op sour the actor's relation
+// with the target by one step on the hostile ladder.
+
+/** The deterministic per-type stat effect of a hybrid op (v0.34.0, #57). */
+export const HYBRID_STAT_EFFECT: Record<HybridOpType, { stat: StatKey; delta: number } | null> = {
+  spy: null, // informational only
+  sabotage: { stat: 'economy', delta: -3 },
+  assassinate: { stat: 'stability', delta: -5 },
+  cyber: { stat: 'military', delta: -3 },
+  economic: { stat: 'economy', delta: -5 },
+  information: null, // relation nudge only
+  proxy: null, // relation nudge only
+};
+
 /**
- * A turn is "meaningful" if it produced at least an event, a stat change, a
+ * The hostile-relations ladder, weakest to strongest (the `cap` in
+ * {@link shiftRelationTowardHostile} is a member of this array). A missing
+ * relation is treated as `neutral`; `war` is never touched (a war is its own
+ * entity — a covert op neither fabricates nor ends one).
+ */
+const HOSTILE_ORDER: RelationStatus[] = ['ally', 'neutral', 'rival', 'hostile'];
+
+/**
+ * (v0.34.0, #57) Nudge the bilateral relation between nations `a` and `b`
+ * ONE step toward hostile (on the {@link HOSTILE_ORDER} ladder), applied
+ * symmetrically to both directions, but never past the given `cap`. A missing
+ * relation starts at `neutral`; a `war` relation is never touched (a covert op
+ * neither fabricates nor downgrades a war). Used for the `information` /
+ * `proxy` nudge and the `exposed` backfire. Mutates `state` in place (the
+ * caller passes a clone — applyTurnResult does). Never throws.
+ */
+export function shiftRelationTowardHostile(
+  state: GameState,
+  a: string,
+  b: string,
+  cap: RelationStatus,
+): void {
+  const na = state.nations[a];
+  const nb = state.nations[b];
+  if (!na || !nb) return;
+  const capIdx = HOSTILE_ORDER.indexOf(cap);
+  if (capIdx === -1) return; // unknown cap: no-op (defensive)
+  const step = (cur: RelationStatus | undefined): RelationStatus | null => {
+    if (cur === 'war') return null; // never touch a war relation
+    const s = cur ?? 'neutral'; // a missing relation is neutral
+    const i = HOSTILE_ORDER.indexOf(s);
+    if (i === -1) return 'neutral'; // defensive: unknown status
+    if (i >= capIdx) return s; // at or past the cap: no change
+    return HOSTILE_ORDER[i + 1];
+  };
+  const stepA = step(na.relations[b]);
+  if (stepA !== null) na.relations[b] = stepA;
+  const stepB = step(nb.relations[a]);
+  if (stepB !== null) nb.relations[a] = stepB;
+}
+
+/**
+ * (v0.34.0, #57) The display name of a hybrid op's target for the auto
+ * backfire event: a nation target shows the nation's name; a region target
+ * shows the region's display name (or its raw key when no resolver is given).
+ */
+function hybridTargetDisplayName(
+  target: { nation: Nation; regionKey?: string },
+  regionNameOf?: (key: string) => string | undefined,
+): string {
+  if (target.regionKey !== undefined) return regionNameOf?.(target.regionKey) ?? target.regionKey;
+  return target.nation.name;
+}
+
+/**
+ * (v0.34.0, #57) Resolve a hybrid op's `target` (a nation id/name OR a region
+ * key) to the concrete nation it affects. A nation ref resolves via
+ * {@link resolveNationRef}; a region key resolves to its SOLE owner (a region
+ * with zero or 2+ owners can't be a valid target). Returns the affected nation
+ * plus the specific region key (when the target was a region) so a stat op can
+ * dip just that region. `validKeys` (when supplied) gates the region-key path;
+ * a ref that is neither a known nation nor a valid region key returns `null`.
+ * Pure; never throws.
+ */
+function resolveHybridTarget(
+  state: GameState,
+  target: string,
+  validKeys?: ReadonlySet<string>,
+): { nation: Nation; regionKey?: string } | null {
+  const id = resolveNationRef(state, target);
+  if (id !== null) {
+    const n = state.nations[id];
+    return n ? { nation: n } : null;
+  }
+  const key = (target ?? '').trim();
+  if (!key) return null;
+  if (validKeys && !validKeys.has(key)) return null; // unknown region key
+  const owners = Object.values(state.nations).filter((n) => n.territory.includes(key));
+  if (owners.length !== 1) return null; // 0 or 2+ owners: not a targetable region
+  return { nation: owners[0], regionKey: key };
+}
+
+/**
+ * (v0.34.0, #57) Apply ONE hybrid op to the (cloned) `next` state, mutating it
+ * in place and never throwing. Resolution order:
+ *   1. `from` must resolve to a nation (id first, then a unique name); an
+ *      unknown / ambiguous actor drops the op.
+ *   2. `target` must resolve to a concrete nation (a nation ref, or a region
+ *      key's sole owner); an unresolvable target drops the op.
+ *   3. A self-target (`from` and the target nation are the same) is dropped.
+ * Then, per type:
+ *   - an `exposed` op BACKFIRES: no intended effect, the actor's relation with
+ *     the target sours by one step (cap hostile), and an auto diplomatic/
+ *     failure event is emitted (the engine's own narrative, mirroring the
+ *     "repelled" auto-event).
+ *   - a successful stat op (sabotage / assassinate / cyber / economic) dips the
+ *     target's `regionStats` by its per-type delta — the single named region
+ *     when the target was a region key, otherwise every region the target
+ *     owns — then re-derives the target nation's aggregate stats (the same
+ *     0-region / no-entry guards as the main recompute), so the effect
+ *     persists to the next turn.
+ *   - a successful `information` / `proxy` sours the actor's relation with the
+ *     target by one step (information caps at hostile, proxy at rival).
+ *   - `spy` is informational only (no stat, no relation) — a no-op except for
+ *     whatever the LLM narrates in `events`.
+ */
+function applyHybridOp(
+  next: GameState,
+  op: HybridOp,
+  geoOf?: (key: string) => { area: number; population: number } | undefined,
+  validKeys?: ReadonlySet<string>,
+  regionNameOf?: (key: string) => string | undefined,
+  actingTurn?: number,
+): void {
+  const turn = actingTurn ?? next.turn;
+  const from = resolveNationRef(next, op.from);
+  if (from === null) return; // unknown / ambiguous actor: drop
+  const target = resolveHybridTarget(next, op.target, validKeys);
+  if (target === null) return; // unresolvable target: drop
+  if (from === target.nation.id) return; // self-target: drop
+
+  if (op.outcome === 'exposed') {
+    // Backfire: no intended effect; the relation sours by one step (cap
+    // hostile) and an auto diplomatic/failure event is emitted.
+    shiftRelationTowardHostile(next, from, target.nation.id, 'hostile');
+    const actor = next.nations[from];
+    next.events.push(
+      makeEvent(
+        {
+          nation: from,
+          type: 'diplomatic',
+          title: 'Covert operation exposed',
+          text: `${actor?.name ?? from}'s ${op.type} operation against ${hybridTargetDisplayName(
+            target,
+            regionNameOf,
+          )} was exposed; relations sour in response.`,
+          outcome: 'failure',
+        },
+        turn,
+        next.date,
+      ),
+    );
+    return;
+  }
+
+  const eff = HYBRID_STAT_EFFECT[op.type];
+  if (eff) {
+    // A successful stat op: dip the target's region(s), then re-derive.
+    if (target.regionKey !== undefined) {
+      const rs = next.regionStats[target.regionKey];
+      if (rs) rs[eff.stat] = clampStat(rs[eff.stat] + eff.delta);
+    } else {
+      for (const key of target.nation.territory) {
+        const rs = next.regionStats[key];
+        if (!rs) continue;
+        rs[eff.stat] = clampStat(rs[eff.stat] + eff.delta);
+      }
+    }
+    // Re-derive the target nation's aggregate stats. The main recompute ran
+    // earlier this turn, so without this the dip would be washed out next
+    // turn. The same 0-region / no-entry guards as the main recompute apply.
+    if (target.nation.territory.length > 0) {
+      if (target.nation.territory.some((k) => next.regionStats[k])) {
+        target.nation.stats = deriveNationStats(
+          target.nation.territory,
+          next.regionStats,
+          geoOf,
+        );
+      }
+    }
+    return;
+  }
+
+  // information / proxy: a relation nudge (spy is a pure no-op here).
+  if (op.type === 'information') shiftRelationTowardHostile(next, from, target.nation.id, 'hostile');
+  else if (op.type === 'proxy') shiftRelationTowardHostile(next, from, target.nation.id, 'rival');
+}
+
+// --- Economy ops: trade + embargo (v0.35.0, #58) ------------------------------
+
+/**
+ * (v0.35.0, #58) The per-turn economic effect of the economy layer, applied
+ * EVERY committed turn (not just to this turn's declares): each active
+ * bilateral trade grants both parties a small, deterministic economy gain;
+ * each active embargo applies a small, deterministic economy dip to the
+ * target only. Clamped to 0–100. The effect lands on `stats.economy` AND on
+ * every region the nation owns (`regionStats`), mirroring the hybrid-op
+ * effect, and each affected nation's derived stats are re-derived afterwards
+ * (the same 0-region / no-entry guards as `applyHybridOp`). No-op when there
+ * are no active trades or embargoes. Never throws.
+ */
+const TRADE_ECONOMY_BONUS = 1;
+const EMBARGO_ECONOMY_PENALTY = 1;
+
+export function applyEconomyEffects(
+  next: GameState,
+  geoOf?: (key: string) => { area: number; population: number } | undefined,
+): void {
+  if (next.trades.length === 0 && next.embargoes.length === 0) return;
+
+  // nation id -> signed economy delta (trades add for both parties, embargoes
+  // subtract for the target; deltas accumulate for nations hit by several).
+  const delta = new Map<string, number>();
+  for (const t of next.trades) {
+    for (const id of [t.a, t.b]) {
+      delta.set(id, (delta.get(id) ?? 0) + TRADE_ECONOMY_BONUS);
+    }
+  }
+  for (const e of next.embargoes) {
+    delta.set(e.target, (delta.get(e.target) ?? 0) - EMBARGO_ECONOMY_PENALTY);
+  }
+
+  const affected = new Set<string>();
+  for (const [id, d] of delta) {
+    const n = next.nations[id];
+    if (!n) continue; // a nation removed this turn (a merge): the delta is dropped
+    const cur = clampStat(n.stats.economy + d);
+    if (cur === n.stats.economy) continue; // no change (already at the clamp)
+    n.stats.economy = cur;
+    for (const key of n.territory) {
+      const rs = next.regionStats[key];
+      if (rs) rs.economy = clampStat(rs.economy + d);
+    }
+    affected.add(id);
+  }
+
+  if (affected.size > 0) {
+    for (const id of affected) {
+      const n = next.nations[id];
+      if (n && n.territory.length > 0 && n.territory.some((k) => next.regionStats[k])) {
+        n.stats = deriveNationStats(n.territory, next.regionStats, geoOf);
+      }
+    }
+  }
+}
+
+/**
+ * (v0.35.0, #58) Apply the turn's economy ops to the active lists on
+ * `next`, RESOLVING the (possibly name-based) refs against the current
+ * state: a no-`lift` trade op declares the bilateral agreement (idempotent —
+ * an already-active pair is not duplicated; the pair is stored sorted, since
+ * a trade is symmetric); `lift: true` ends it (a no-op when absent). A no-
+ * `lift` embargo op imposes the unilateral embargo (idempotent — the ordered
+ * from→target pair is kept as-is); `lift: true` lifts it. An op whose refs
+ * don't resolve to distinct EXISTING nations is dropped (defensive — never
+ * throws). Mutates `next` in place.
+ */
+function applyEconomyOps(next: GameState, ops: EconomyOps): void {
+  const tradeKey = (a: string, b: string): string => (a < b ? `${a}\u0000${b}` : `${b}\u0000${a}`);
+  const embargoKey = (f: string, t: string): string => `${f}\u0000${t}`;
+
+  for (const op of ops.trade) {
+    const a = resolveNationRef(next, op.a);
+    const b = resolveNationRef(next, op.b);
+    if (!a || !b || a === b) continue; // unknown / ambiguous / self: drop
+    const key = tradeKey(a, b);
+    if (op.lift === true) {
+      next.trades = next.trades.filter((t) => tradeKey(t.a, t.b) !== key);
+    } else if (!next.trades.some((t) => tradeKey(t.a, t.b) === key)) {
+      // stored sorted (a < b): a trade is symmetric, so the agreement has a
+      // canonical shape no matter which way the LLM named the pair.
+      next.trades.push(a < b ? { a, b } : { a: b, b: a });
+    }
+  }
+
+  for (const op of ops.embargo) {
+    const from = resolveNationRef(next, op.from);
+    const target = resolveNationRef(next, op.target);
+    if (!from || !target || from === target) continue; // unknown / ambiguous / self: drop
+    const key = embargoKey(from, target);
+    if (op.lift === true) {
+      next.embargoes = next.embargoes.filter((e) => embargoKey(e.from, e.target) !== key);
+    } else if (!next.embargoes.some((e) => embargoKey(e.from, e.target) === key)) {
+      next.embargoes.push({ from, target });
+    }
+  }
+}
+
+/**
+ * (v0.35.0, #58) Auto-suspend the economy layer when war breaks out: any
+ * active trade or embargo whose two nations are on OPPOSITE sides of an
+ * active war (v0.33, #56) is removed — a war severs the economic link, so
+ * the suspended agreement stops producing its per-turn effect from now on.
+ * A trade/embargo between two non-belligerents, or between two nations on
+ * the SAME side, is untouched. Mutates `next` in place; idempotent. Must be
+ * called AFTER the war declare/end ops of the turn (so it sees the final
+ * `next.wars`). Never throws.
+ */
+function suspendEconomyOnWar(next: GameState): void {
+  if (next.trades.length === 0 && next.embargoes.length === 0) return;
+  const warring = activeWarPairs(next.wars);
+  const atWarNow = (x: string, y: string): boolean => {
+    if (x === y) return false;
+    const key = x < y ? `${x}\u0000${y}` : `${y}\u0000${x}`;
+    return warring.has(key);
+  };
+  next.trades = next.trades.filter((t) => !atWarNow(t.a, t.b));
+  next.embargoes = next.embargoes.filter((e) => !atWarNow(e.from, e.target));
+}
+
+// --- Industry projects: the per-region economy-boost lever (v0.36, #59) ------
+
+/**
+ * (v0.36, #59) The BASE per-turn economy boost one industry project grants its
+ * region's sole owner. A project's actual boost is this base plus one extra
+ * point when the region's `industry` resource value is at least 0.5 (a region
+ * with a strong industry profile yields a bigger return). The base value is
+ * deliberately the same magnitude as {@link TRADE_ECONOMY_BONUS} /
+ * {@link EMBARGO_ECONOMY_PENALTY}.
+ */
+const INDUSTRY_ECONOMY_BONUS = 1;
+
+/**
+ * (v0.36, #59) The per-turn economy boost for ONE industry project sitting in
+ * `regionKey`: {@link INDUSTRY_ECONOMY_BONUS} plus one extra point when the
+ * region's `industry` resource value (from `resourceOf`) is at least 0.5.
+ * Without the resource manifest (or for a region with no profile) the boost is
+ * the base value. Pure + deterministic.
+ */
+function industryBoost(
+  regionKey: string,
+  resourceOf?: (key: string) => RegionResources | undefined,
+): number {
+  const r = resourceOf?.(regionKey);
+  return INDUSTRY_ECONOMY_BONUS + (r && r.industry >= 0.5 ? 1 : 0);
+}
+
+/**
+ * (v0.36, #59) Apply the turn's industry ops to `GameState.industry` as a
+ * PER-REGION SET: each op names a region key + a project type. A region key
+ * that is not a valid manifest key (`validKeys`, when supplied) is dropped; a
+ * region that already hosts a project is untouched (the first declared type
+ * wins — re-declaring on the same region is a no-op, the type is never
+ * replaced). Otherwise the project is appended. Mutates `next` in place.
+ * Nothing here throws.
+ */
+function applyIndustryOps(
+  next: GameState,
+  ops: IndustryOps,
+  validKeys?: ReadonlySet<string>,
+): void {
+  if (ops.projects.length === 0) return;
+  const has = (key: string) => next.industry.some((p) => p.regionKey === key);
+  for (const p of ops.projects) {
+    if (validKeys && !validKeys.has(p.regionKey)) continue; // unknown region key: drop
+    if (has(p.regionKey)) continue; // a region hosts at most one project
+    next.industry.push({ regionKey: p.regionKey, type: p.type });
+  }
+}
+
+/**
+ * (v0.36, #59) The per-turn economic effect of the industry layer, applied
+ * EVERY committed turn (not just to this turn's adds): each active project
+ * grants its region's SOLE owner a small, deterministic economy boost (see
+ * {@link industryBoost}) — clamped to 0–100, mirrored to every region the
+ * owner holds (`regionStats`), and each affected nation's derived stats are
+ * re-derived afterwards (the same 0-region / no-entry guards as
+ * `applyEconomyEffects`). A project whose region ends the turn with NO owner,
+ * or 2+ owners (released to no man's land / corrupt), yields no boost but is
+ * kept in the list. Sole ownership is untouched. No-op when there are no
+ * active projects. Never throws.
+ */
+export function applyIndustryEffects(
+  next: GameState,
+  resourceOf?: (key: string) => RegionResources | undefined,
+  geoOf?: (key: string) => { area: number; population: number } | undefined,
+): void {
+  if (next.industry.length === 0) return;
+
+  // Map each region key to its SOLE owner (a key with 0 or 2+ owners maps to
+  // nothing and yields no boost).
+  const ownerOf = new Map<string, string>();
+  {
+    const owners = new Map<string, string[]>();
+    for (const n of Object.values(next.nations)) {
+      for (const key of n.territory) {
+        const list = owners.get(key);
+        if (list) list.push(n.id);
+        else owners.set(key, [n.id]);
+      }
+    }
+    for (const [key, list] of owners) {
+      if (list.length === 1) ownerOf.set(key, list[0]);
+    }
+  }
+
+  // nation id -> accumulated economy boost (a nation owning several project
+  // regions gets each of their boosts).
+  const delta = new Map<string, number>();
+  for (const p of next.industry) {
+    const owner = ownerOf.get(p.regionKey);
+    if (!owner) continue; // 0 or 2+ owners: no boost (the project is kept)
+    const n = next.nations[owner];
+    if (!n) continue; // a nation removed this turn (a merge): the boost is dropped
+    delta.set(owner, (delta.get(owner) ?? 0) + industryBoost(p.regionKey, resourceOf));
+  }
+
+  const affected = new Set<string>();
+  for (const [id, d] of delta) {
+    const n = next.nations[id];
+    if (!n) continue;
+    n.stats.economy = clampStat(n.stats.economy + d);
+    for (const key of n.territory) {
+      const rs = next.regionStats[key];
+      if (rs) rs.economy = clampStat(rs.economy + d);
+    }
+    affected.add(id);
+  }
+
+  if (affected.size > 0) {
+    for (const id of affected) {
+      const n = next.nations[id];
+      if (n && n.territory.length > 0 && n.territory.some((k) => next.regionStats[k])) {
+        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
  * when the model under-narrates it), a nation-op proposal (v0.23 #16 P4a:
  * a proposal is a real pending-world change the player will resolve, so it
@@ -901,6 +1578,16 @@ export function isMeaningful(result: TurnResult): boolean {
     // (v0.33.0, #56) a war declared or ended is a real world change.
     result.wars.declare.length > 0 ||
     result.wars.end.length > 0 ||
+    // (v0.34.0, #57) a hybrid op (a successful one or an exposed backfire) is
+    // a real world change (a stat dip or a soured relation).
+    result.hybrid.ops.length > 0 ||
+    // (v0.35.0, #58) a trade declared/ended or an embargo imposed/lifted this
+    // turn is a real world change (the active economy lists moved).
+    result.economy.trade.length > 0 ||
+    result.economy.embargo.length > 0 ||
+    // (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.27, #44) a marker placed or removed this turn is a real world change.
     result.markers.add.length > 0 ||
     result.markers.remove.length > 0
@@ -945,6 +1632,13 @@ function genericUnclearEvent(state: GameState): TurnEventSpec {
  * (from the geo `properties.name`, via server/regions.ts) for the text of the
  * engine-emitted "invasion repelled" event; without it the event falls back to
  * the raw key. Pure either way.
+ *
+ * `resourceOf` (v0.36, #59) resolves a region key to its synthesized resource
+ * profile (`{ oil, iron, food, industry }`, from public/region-resources.json
+ * via server/regions.ts). It is used to scale each industry project's per-turn
+ * economy boost by the region's `industry` value (a region with a strong
+ * industry profile yields a bigger return). Without it the boost is the
+ * unscaled base value — the engine stays pure and deterministic either way.
  */
 export function applyTurnResult(
   state: GameState,
@@ -953,12 +1647,16 @@ export function applyTurnResult(
   centroidOf?: (key: string) => { lat: number; lon: number; spread: number } | undefined,
   geoOf?: (key: string) => { area: number; population: number } | undefined,
   regionNameOf?: (key: string) => string | undefined,
+  resourceOf?: (key: string) => RegionResources | undefined,
 ): GameState {
   const next: GameState = JSON.parse(JSON.stringify(state));
   next.version = (state.version ?? 0) + 1; // every mutation is a new revision
   // (v0.28, #46) per-region stats table; a legacy/corrupt clone without the
   // field starts empty (the turn then re-inits claimed regions as it goes).
   next.regionStats = next.regionStats ?? {};
+  // (v0.36, #59) active industry projects; a legacy/corrupt clone without the
+  // field starts empty (the turn then only ever adds to it).
+  next.industry = next.industry ?? [];
   const actingTurn = state.turn; // this action resolves the current turn
   next.turn = state.turn + 1; // then we advance to the next turn to play
   next.date = isDateLike(result.date) ? result.date : addDays(state.date, 2);
@@ -1246,6 +1944,64 @@ export function applyTurnResult(
     syncWarRelations(state, next);
   }
 
+  // --- Hybrid war (v0.34.0, #57): covert, non-kinetic operations ---
+  //
+  // Each op's deterministic per-type effect is applied to the post-wars state
+  // (a stat dip on the target's regions, or a relation nudge toward hostile).
+  // An `exposed` op backfires instead. They never move borders, so they run
+  // after the territory changes and before the markers (a marker's owner is
+  // recomputed from the final ownership, unaffected by a stat/relation dip).
+  for (const op of result.hybrid.ops) {
+    applyHybridOp(next, op, geoOf, validKeys, regionNameOf, actingTurn);
+  }
+
+  // --- Trade & embargo economy layer (v0.35.0, #58) ---
+  //
+  // Placed AFTER the wars block (so the auto-suspension sees the FINAL
+  // next.wars, including wars declared this turn) and before markers /
+  // nationOps (which never touch the economy lists). Order:
+  //   (1) APPLY OPS: the turn's declare/lift ops mutate the active
+  //       GameState.trades / GameState.embargoes lists (a declare is
+  //       idempotent; refs resolved against the current state, unknown /
+  //       ambiguous / self-pairing ops dropped).
+  //   (2) WAR AUTO-SUSPENSION: any active trade or embargo whose two
+  //       nations are on opposite sides of an active war is removed —
+  //       a war severs the economic link, so the suspended agreement
+  //       stops producing its per-turn effect from now on (this also
+  //       drops a trade declared this turn between two nations that just
+  //       went to war).
+  //   (3) PER-TURN EFFECT: the FULL active lists (not just this turn's
+  //       declares) each apply their deterministic effect this turn —
+  //       trade: both parties' economy up a little; embargo: the
+  //       target's economy down a little — clamped, mirrored to the
+  //       owning nations' regions, and re-derived like the hybrid dip.
+  // Additive only: declares add, lifts remove, and nothing else (not even
+  // a war) mutates the lists besides the suspension above.
+  applyEconomyOps(next, result.economy);
+  suspendEconomyOnWar(next);
+  applyEconomyEffects(next, geoOf);
+
+  // --- Industry projects (v0.36, #59): per-region economy-boost lever ---
+  //
+  // Placed AFTER the economy block (both move stats, and the industry boost
+  // should compose with the trade/embargo effects of the same turn) and
+  // before markers / nationOps. Order:
+  //   (1) APPLY OPS: this turn's `industry.projects` are added to
+  //       `GameState.industry` as a per-region SET — a region key that is not
+  //       a valid manifest key is dropped, and a region that already hosts a
+  //       project is untouched (the first declared type wins; re-declaring is
+  //       a no-op).
+  //   (2) PER-TURN EFFECT: the FULL active project list (not just this
+  //       turn's adds) each grants their region's SOLE owner a small,
+  //       deterministic economy boost scaled by the region's `industry`
+  //       resource value — clamped, mirrored to every region the owner holds,
+  //       and re-derived like the economy/hybrid effects. A project whose
+  //       region ends the turn with no owner (or 2+ owners) yields no boost
+  //       but is KEPT (the region may be re-claimed later). Sole ownership is
+  //       untouched (the layer moves stats, never territory).
+  applyIndustryOps(next, result.industry, validKeys);
+  applyIndustryEffects(next, resourceOf, geoOf);
+
   // --- Map markers (v0.27, #44) ---
   //
   // Markers are anchored to a region key and are processed against the FINAL
@@ -1717,8 +2473,17 @@ export async function runTurn(opts: {
    * it falls back to the raw region key. Pure either way.
    */
   regionNameOf?: (key: string) => string | undefined;
+  /**
+   * (v0.36, #59) Region-key -> synthesized resource profile resolver (from
+   * public/region-resources.json via server/regions.ts). Present, each
+   * industry project's per-turn economy boost is scaled by its region's
+   * `industry` value, and each nation's aggregate resource profile is carried
+   * in the user prompt; absent, industry boosts use the unscaled base value
+   * and the profile is omitted.
+   */
+  resourceOf?: (key: string) => RegionResources | undefined;
 }): Promise<{ state: GameState; result: TurnResult }> {
-  const { llm, preset, state, items, regionReference, validRegionKeys, getNeighbours, centroidOf, geoOf, regionKeyResolver, regionNameOf } = opts;
+  const { llm, preset, state, items, regionReference, validRegionKeys, getNeighbours, centroidOf, geoOf, regionKeyResolver, regionNameOf, resourceOf } = opts;
   const chatWithTools = llm.chatWithTools;
   const useTools = getNeighbours !== undefined && chatWithTools !== undefined;
   const system = buildSystemPrompt(preset, useTools);
@@ -1744,6 +2509,25 @@ export async function runTurn(opts: {
       sides: w.sides,
       ...(w.aims && w.aims.length > 0 ? { aims: w.aims } : {}),
     }));
+  // (v0.34.0, #57) the player's current relations to every other nation, so the
+  // model sees the ladder its `information` / `proxy` hybrid ops nudge (and the
+  // starting point before an `exposed` backfire). Always emitted ({} when the
+  // player has no relations yet).
+  const relations = state.nations[state.playerNationId]?.relations ?? {};
+  // (v0.36, #59) each nation's AGGREGATE resource profile (the area×population-
+  // weighted mean of the resource profiles of the regions it owns). Carried in
+  // the user prompt ONLY when the resource manifest is loaded (resourceOf
+  // present); otherwise omitted (undefined) so the prompt — and the stub —
+  // stay identical to the no-manifest case.
+  const nationResources =
+    resourceOf === undefined
+      ? undefined
+      : Object.fromEntries(
+          Object.values(state.nations).map((n) => [
+            n.id,
+            deriveNationResources(n.territory, resourceOf, geoOf),
+          ]),
+        );
   const user = buildUserPrompt(
     state,
     items,
@@ -1752,6 +2536,17 @@ export async function runTurn(opts: {
     state.unowned ?? [],
     markers,
     wars,
+    relations,
+    // (v0.35.0, #58) the active trade / embargo lists, so the model can
+    // reference — and `lift` — what is currently in force.
+    state.trades,
+    state.embargoes,
+    // (v0.36, #59) the aggregate resource profiles (undefined without the
+    // manifest) + the active industry projects, so the model knows which
+    // regions already host a project and which nations are rich in which
+    // resource.
+    nationResources,
+    state.industry ?? [],
   );
   const nudge =
     'Your previous output was invalid. Respond with ONLY the JSON object described above for this batch — no prose, no fences.';
@@ -1806,12 +2601,15 @@ export async function runTurn(opts: {
       nationOps: [],
       takeovers: [],
       wars: { declare: [], end: [] },
+      hybrid: { ops: [] },
+      economy: { trade: [], embargo: [] },
+      industry: { projects: [] },
       markers: { add: [], remove: [] },
     };
   }
 
   return {
-    state: applyTurnResult(state, result, validRegionKeys, centroidOf, geoOf, regionNameOf),
+    state: applyTurnResult(state, result, validRegionKeys, centroidOf, geoOf, regionNameOf, resourceOf),
     result,
   };
 }

server/index.ts

@@ -25,7 +25,7 @@ import { makeScenarioStubLlmClient } from './stubScenario';
 import { finalizeWorld, generateDraft } from './scenario';
 import { askAdvisor, confirmNationOp, queueRoundItem, rejectNationOp, removeRoundItem, resolveRegionKey, runTurn } from './engine';
 import { buildRegionMap } from './map';
-import { allTerritoryKeys, centroidOf, expandCountriesToKeys, geoOf, hasAdjacency, hasCentroids, hasGeo, loadRegions, neighboursOf, referenceForKeys, regionName, validCountryCodes, validKeys } from './regions';
+import { allTerritoryKeys, centroidOf, expandCountriesToKeys, geoOf, hasAdjacency, hasCentroids, hasGeo, hasResources, loadRegions, neighboursOf, referenceForKeys, regionName, resourceOf, validCountryCodes, validKeys } from './regions';
 import { createPresetStore } from './presets';
 import { createTemplateStore } from './templates';
 import { openDb, type Db } from './db';
@@ -182,6 +182,14 @@ app.post('/api/games', (req: Request, res) => {
     // (any preset-level `war` relation stays a bare/implicit one, not an
     // entity — see syncWarRelations).
     wars: [],
+    // (v0.35.0, #58) No active trades or embargoes on a fresh game; the LLM
+    // declares (and lifts) them over time via TurnResult.economy.
+    trades: [],
+    embargoes: [],
+    // (v0.36.0, #59) No active industry projects on a fresh game; the LLM
+    // declares them over time via TurnResult.industry (one per region, a
+    // per-region SET).
+    industry: [],
   };
   // v0.19 (#16 P1): expand each nation's ISO_A3 country list to the region keys
   // of all its sub-regions, so ownership (and the choropleth) is at region
@@ -366,6 +374,12 @@ app.post('/api/games/:id/jump', async (req, res) => {
       // event (geo properties.name, else the raw key). Always on — the
       // resolver is pure and degrades to the key when the manifest is absent.
       regionNameOf: (k) => regionName(k),
+      // (v0.36.0, #59) when the region-resources manifest (the synthesized
+      // per-region resource profiles) loaded, hand the engine the resolver —
+      // the industry boost is then scaled by each region's `industry` value
+      // (without it boosts use the unscaled base value) and each nation's
+      // aggregate resource profile is carried in the user prompt.
+      resourceOf: hasResources() ? (key) => resourceOf(key) : undefined,
     });
     db.save(state);
     broadcast(id, 'turn', { state, result });

server/map.test.ts

@@ -54,6 +54,11 @@ const state: GameState = {
   regionStats: {},
   // (v0.33.0, #56) the map is ownership-only; wars are unused here.
   wars: [],
+  // (v0.35.0, #58) the map is ownership-only; trades/embargoes are unused here.
+  trades: [],
+  embargoes: [],
+  // (v0.36.0, #59) the map is ownership-only; industry is unused here.
+  industry: [],
 };
 
 // The RegionMap built from the fixture: the authoritative region key → owner source.

server/protocol.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest';
 import {
   canConquer,
   CONQUEST_MILITARY_MARGIN,
+  deriveNationResources,
   deriveNationStats,
   migrateRegionStats,
   seedRegionStats,
@@ -42,6 +43,9 @@ function mkState(
     markers: [],
     regionStats: {} as GameState['regionStats'],
     wars: [],
+    trades: [],
+    embargoes: [],
+    industry: [],
   };
   if (regionStats !== undefined) base.regionStats = regionStats as GameState['regionStats'];
   else delete (base as { regionStats?: unknown }).regionStats; // simulate a legacy row
@@ -137,6 +141,81 @@ describe('deriveNationStats', () => {
   });
 });
 
+// --- deriveNationResources ---------------------------------------------------
+
+describe('deriveNationResources (v0.36.0 #59)', () => {
+  const prof: Record<string, { oil: number; iron: number; food: number; industry: number }> = {
+    a: { oil: 0.2, iron: 0.2, food: 0.2, industry: 0.2 },
+    b: { oil: 0.8, iron: 0.8, food: 0.8, industry: 0.8 },
+  };
+  const geo: Record<string, { area: number; population: number }> = {
+    a: { area: 100, population: 1000 },
+    b: { area: 1000, population: 1000 },
+  };
+
+  it('weights by area×population: the larger region dominates the average', () => {
+    // a: weight 100×1000=100000, b: weight 1000×1000=1000000
+    // → (0.2×1e5 + 0.8×1e6)/1.1e6 = 82/110 = 0.7454… → 0.75 on every axis
+    expect(deriveNationResources(['a', 'b'], (k) => prof[k], (k) => geo[k])).toEqual({
+      oil: 0.75, iron: 0.75, food: 0.75, industry: 0.75,
+    });
+  });
+
+  it('degrades to a uniform (unweighted) average without geo: equal weights', () => {
+    // equal weights 1,1 → the true mean 0.5 on every axis
+    expect(deriveNationResources(['a', 'b'], (k) => prof[k])).toEqual({
+      oil: 0.5, iron: 0.5, food: 0.5, industry: 0.5,
+    });
+    // same when geoOf is provided but returns undefined for the keys (missing geo)
+    expect(deriveNationResources(['a', 'b'], (k) => prof[k], () => undefined)).toEqual({
+      oil: 0.5, iron: 0.5, food: 0.5, industry: 0.5,
+    });
+  });
+
+  it('skips a region key that has no resource-profile entry', () => {
+    // b has no profile → only a is counted → a's values
+    const out = deriveNationResources(['a', 'b'], (k) => (k === 'a' ? prof.a : undefined), (k) => geo[k]);
+    expect(out).toEqual(prof.a);
+  });
+
+  it('returns the zero profile when none of the owned regions has a profile', () => {
+    expect(deriveNationResources(['a', 'b'], () => undefined)).toEqual({
+      oil: 0, iron: 0, food: 0, industry: 0,
+    });
+  });
+
+  it('a single region yields exactly that region\'s profile', () => {
+    expect(deriveNationResources(['a'], (k) => prof[k], (k) => geo[k])).toEqual(prof.a);
+  });
+
+  it('treats zero/negative area or population as a fallback weight of 1', () => {
+    // a: area 0 → weight 1×1000=1000; b: full weight 1e6 → b dominates
+    const g: Record<string, { area: number; population: number }> = {
+      a: { area: 0, population: 1000 },
+      b: { area: 1000, population: 1000 },
+    };
+    expect(deriveNationResources(['a', 'b'], (k) => prof[k], (k) => g[k])).toEqual({
+      oil: 0.8, iron: 0.8, food: 0.8, industry: 0.8,
+    });
+  });
+
+  it('rounds each axis to 2 decimal places', () => {
+    // a=0.2 (w=1×1=1) + b=0.4 (w=2×1=2) → (0.2×1 + 0.4×2)/(1+2) = 1.0/3 = 0.3333… → 0.33
+    const g: Record<string, { area: number; population: number }> = {
+      a: { area: 1, population: 1 },
+      b: { area: 2, population: 1 },
+    };
+    const out = deriveNationResources(
+      ['a', 'b'],
+      (k) => k === 'a'
+        ? { oil: 0.2, iron: 0.2, food: 0.2, industry: 0.2 }
+        : { oil: 0.4, iron: 0.4, food: 0.4, industry: 0.4 },
+      (k) => g[k],
+    );
+    expect(out).toEqual({ oil: 0.33, iron: 0.33, food: 0.33, industry: 0.33 });
+  });
+});
+
 // --- seedRegionStats ---------------------------------------------------------
 
 describe('seedRegionStats', () => {

server/regions.test.ts

@@ -12,11 +12,13 @@ import {
   hasCentroids,
   hasGeo,
   hasRegionData,
+  hasResources,
   loadRegions,
   neighboursOf,
   referenceForKeys,
   regionName,
   resetRegions,
+  resourceOf,
   validKeys,
 } from './regions';
 import type { GameState } from '../shared/types';
@@ -111,6 +113,11 @@ describe('regions (region-key loader, v0.19 #16 P1)', () => {
       // (v0.28, #46) unused here (allTerritoryKeys is ownership-only).
       regionStats: {},
       wars: [],
+      // (v0.35.0, #58) unused here (allTerritoryKeys is ownership-only).
+      trades: [],
+      embargoes: [],
+      // (v0.36.0, #59) unused here (allTerritoryKeys is ownership-only).
+      industry: [],
     };
     // 16 GBR sub-regions + 42 FRA sub-regions, no overlap between the two.
     expect(allTerritoryKeys(state).size).toBe(58);
@@ -169,6 +176,16 @@ describe('regions (region-key loader, v0.19 #16 P1)', () => {
     expect(geoOf('not-a-real-key-xyz')).toBeUndefined();
   });
 
+  it('(v0.36 #59) hasResources() is true and resourceOf resolves a real key to a 4-value profile', () => {
+    expect(hasResources()).toBe(true);
+    // exact spot-check values pinned from the committed manifest (Ain, FRA)
+    expect(resourceOf('ain-lqtt')).toEqual({ oil: 0.94, iron: 0.92, food: 0.51, industry: 0.4 });
+  });
+
+  it('(v0.36 #59) resourceOf returns undefined for an unknown key', () => {
+    expect(resourceOf('not-a-real-key-xyz')).toBeUndefined();
+  });
+
   describe('graceful degradation with no region data', () => {
     beforeEach(() => resetRegions());
 
@@ -188,6 +205,9 @@ describe('regions (region-key loader, v0.19 #16 P1)', () => {
       // and no region-geo: the per-region stats weighting degrades to uniform
       expect(hasGeo()).toBe(false);
       expect(geoOf('ain-lqtt')).toBeUndefined();
+      // and no region-resources: industry boosts use the unscaled base value
+      expect(hasResources()).toBe(false);
+      expect(resourceOf('ain-lqtt')).toBeUndefined();
     });
   });
 
@@ -245,6 +265,19 @@ describe('loadRegions resolves the manifest per environment (dev public/ vs prod
     // and no region-geo (not copied into this dist/) -> stats weighting is uniform
     expect(hasGeo()).toBe(false);
     expect(geoOf('ain-lqtt')).toBeUndefined();
+    // and no region-resources (not copied into this dist/) -> boosts unscaled
+    expect(hasResources()).toBe(false);
+    expect(resourceOf('ain-lqtt')).toBeUndefined();
+  });
+
+  it('(v0.36 #59) a dist/ WITH the region-resources manifest loads it (prod layout)', () => {
+    copyFileSync(
+      path.join(realRoot, 'public', 'region-resources.json'),
+      path.join(prodRoot, 'dist', 'region-resources.json'),
+    );
+    expect(loadRegions(prodRoot)).toBe(true);
+    expect(hasResources()).toBe(true);
+    expect(resourceOf('ain-lqtt')).toEqual({ oil: 0.94, iron: 0.92, food: 0.51, industry: 0.4 });
   });
 
   it('(v0.27 #44) a dist/ WITH the centroids manifest loads them (prod layout)', () => {

server/regions.ts

@@ -19,6 +19,9 @@
 //     — the data behind LLM-placed map markers (v0.27, #44)
 //   - geoOf(): a region key's area (km²) + population (from region-geo.json)
 //     — the weighting source for the per-region stats model (v0.28, #46)
+//   - resourceOf(): a region key's synthesized resource profile (from
+//     region-resources.json) — the data behind the LLM's industry lever
+//     (v0.36, #59)
 //
 // Deliberately turf-free: it reads the JSON files with plain JSON.parse and
 // never imports @turf/@types/geojson (importing one pulls @types/geojson into
@@ -26,7 +29,7 @@
 // Loaded once at boot; the accessors below are pure data reads thereafter.
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
-import type { GameState } from '../shared/types';
+import type { GameState, RegionResources } from '../shared/types';
 
 /** { name, parent } for one sub-region, where parent is the ISO_A3 country. */
 interface RegionInfo {
@@ -49,6 +52,8 @@ interface RegionData {
   centroids: Record<string, { lat: number; lon: number; spread: number }>;
   /** region key -> { area (km²), population } (from public/region-geo.json, v0.28 #46). */
   geo: Record<string, { area: number; population: number }>;
+  /** region key -> resource profile (from public/region-resources.json, v0.36 #59). */
+  resources: Record<string, RegionResources>;
 }
 
 let data: RegionData | null = null;
@@ -77,6 +82,7 @@ export function loadRegions(root: string): boolean {
   const adjacencyFile = 'region-adjacency.json';
   const centroidsFile = 'region-centroids.json';
   const regionGeoFile = 'region-geo.json';
+  const regionResourcesFile = 'region-resources.json';
   const base = [
     path.join(root, 'public'), // dev: Vite serves public/ at /
     path.join(root, 'dist'), // prod: Vite copies public/* -> dist/ (== clientDir)
@@ -185,7 +191,40 @@ export function loadRegions(root: string): boolean {
       }
     }
 
-    data = { idToKey, keyToInfo, keysByCountry, validKeys, adjacency, centroids, geo };
+    // The region-resources manifest (v0.36, #59): a synthesized four-value
+    // resource profile per region key — the data behind the LLM's industry
+    // lever. OPTIONAL like the others: a missing/broken file means "no
+    // resource data" — industry boosts degrade to the unscaled base value and
+    // the prompt omits the aggregate profile — while everything else keeps
+    // working.
+    let resources: Record<string, RegionResources> = {};
+    const resourcesPath = path.join(base, regionResourcesFile);
+    if (existsSync(resourcesPath)) {
+      try {
+        const raw = JSON.parse(readFileSync(resourcesPath, 'utf8')) as Record<
+          string,
+          { oil?: unknown; iron?: unknown; food?: unknown; industry?: unknown }
+        >;
+        // Keep only well-formed entries (all four values finite numbers in
+        // [0, 1]); a corrupt file degrades to "none".
+        for (const [k, v] of Object.entries(raw)) {
+          if (
+            v &&
+            typeof v.oil === 'number' && Number.isFinite(v.oil) && v.oil >= 0 && v.oil <= 1 &&
+            typeof v.iron === 'number' && Number.isFinite(v.iron) && v.iron >= 0 && v.iron <= 1 &&
+            typeof v.food === 'number' && Number.isFinite(v.food) && v.food >= 0 && v.food <= 1 &&
+            typeof v.industry === 'number' && Number.isFinite(v.industry) && v.industry >= 0 && v.industry <= 1
+          ) {
+            resources[k] = { oil: v.oil, iron: v.iron, food: v.food, industry: v.industry };
+          }
+        }
+      } catch (err) {
+        console.error('[regions] failed to load region-resources.json, continuing without it', err);
+        resources = {};
+      }
+    }
+
+    data = { idToKey, keyToInfo, keysByCountry, validKeys, adjacency, centroids, geo, resources };
     return validKeys.size > 0;
   } catch (err) {
     console.error('[regions] failed to load region data', err);
@@ -322,6 +361,29 @@ export function geoOf(key: string): { area: number; population: number } | undef
   return data?.geo[key];
 }
 
+/**
+ * True when the region-resources manifest loaded with at least one entry
+ * (v0.36, #59). The server's jump route uses this to decide whether to hand
+ * the engine a resource resolver (which lets a turn scale industry boosts by a
+ * region's `industry` value and carry each nation's aggregate resource profile
+ * in the LLM prompt) or skip both (industry boosts fall back to the unscaled
+ * base value).
+ */
+export function hasResources(): boolean {
+  return data !== null && Object.keys(data.resources).length > 0;
+}
+
+/**
+ * The synthesized resource profile for a region key (v0.36, #59): the
+ * four-value `{ oil, iron, food, industry }` from the committed
+ * `public/region-resources.json`. `undefined` for an unknown key or when no
+ * resource data is loaded (industry boosts then use the unscaled base value,
+ * and the aggregate profile is simply omitted from the prompt).
+ */
+export function resourceOf(key: string): RegionResources | undefined {
+  return data?.resources[key];
+}
+
 /**
  * The union of the region keys that share a land border with any of the given
  * keys — deduplicated, the queried keys themselves excluded, and sorted for

server/stub.ts

@@ -3,7 +3,7 @@
 // speaks the OpenAI chat-completions wire shape, so it plugs in as a Transport.
 import { createLlmClient, type ChatMessage, type Transport } from './llm';
 import { addDays, clampStat, type TerritoryChange, type TurnEventSpec, type TurnResult } from '../shared/protocol';
-import type { RoundItem } from '../shared/types';
+import type { RelationStatus, RoundItem } from '../shared/types';
 
 export const ADVISOR_MARKER = '<<ADVISOR>>';
 
@@ -45,6 +45,42 @@ export interface StubPayload {
    * tests against applyTurnResult, not by the stub.
    */
   wars?: Array<{ id: string; sides: string[]; aims?: string[] }>;
+  /**
+   * (v0.34.0, #57) The player's current relations to every other nation
+   * (`nationId -> RelationStatus`), emitted by the engine's user prompt. The
+   * stub ignores this field — it never runs a hybrid op (see
+   * deterministicTurn), so the hybrid path is covered by unit tests only.
+   */
+  relations?: Record<string, RelationStatus>;
+  /**
+   * (v0.35.0, #58) The currently active bilateral trade agreements
+   * (`{ a, b }` nation-id pairs), emitted by the engine's user prompt. The
+   * stub ignores this field — it never declares, lifts or suspends a trade
+   * (see deterministicTurn), so the trade path is covered by unit tests only.
+   */
+  trades?: Array<{ a: string; b: string }>;
+  /**
+   * (v0.35.0, #58) The currently active unilateral embargoes
+   * (`{ from, target }` nation-id pairs), emitted by the engine's user
+   * prompt. The stub ignores this field — it never imposes, lifts or
+   * suspends an embargo (see deterministicTurn), so the embargo path is
+   * covered by unit tests only.
+   */
+  embargoes?: Array<{ from: string; target: string }>;
+  /**
+   * (v0.36.0, #59) Each nation's aggregate resource profile
+   * (`{ oil, iron, food, industry }`), emitted by the engine's user prompt.
+   * The stub ignores this field — it never declares an industry project (see
+   * deterministicTurn), so the industry path is covered by unit tests only.
+   */
+  resources?: Record<string, { oil: number; iron: number; food: number; industry: number }>;
+  /**
+   * (v0.36.0, #59) The currently active industry projects
+   * (`{ regionKey, type }`), emitted by the engine's user prompt. The stub
+   * ignores this field — it never declares an industry project (see
+   * deterministicTurn), so the industry path is covered by unit tests only.
+   */
+  industry?: Array<{ regionKey: string; type: string }>;
 }
 
 function truncate(s: string, n: number): string {
@@ -92,6 +128,19 @@ function truncate(s: string, n: number): string {
  * (v0.33.0, #56) The stub likewise NEVER declares or ends a war (it always
  * returns `wars: { declare: [], end: [] }`) — the war path is covered by unit
  * tests only, keeping the e2e assertions untouched.
+ *
+ * (v0.34.0, #57) The stub likewise NEVER runs a hybrid / covert op (it always
+ * returns `hybrid: { ops: [] }`) — the hybrid-war path is covered by unit
+ * tests only, keeping the e2e assertions untouched.
+ *
+ * (v0.35.0, #58) The stub likewise NEVER declares, lifts or suspends a trade
+ * or an embargo (it always returns `economy: { trade: [], embargo: [] }`) —
+ * the trade & embargo economy path is covered by unit tests only, keeping
+ * the e2e assertions untouched.
+ *
+ * (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.
  */
 export function deterministicTurn(p: StubPayload): TurnResult {
   const state = p.state;
@@ -160,6 +209,9 @@ export function deterministicTurn(p: StubPayload): TurnResult {
     nationOps: [], // the stub never proposes nation ops (see doc comment)
     takeovers: [], // the stub never performs a takeover (see doc comment)
     wars: { declare: [], end: [] }, // the stub never declares/ends wars (see doc comment)
+    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)
     markers: { add: [], remove: [] }, // the stub never touches markers (see doc comment)
   };
 }

shared/protocol.ts

@@ -6,10 +6,12 @@ import type {
   EventOutcome,
   EventType,
   GameState,
+  IndustryProject,
   MarkerType,
   Nation,
   NationStats,
   RelationStatus,
+  RegionResources,
   RegionStats,
   StatKey,
 } from './types';
@@ -305,6 +307,132 @@ export function isMarkerType(t: unknown): t is MarkerType {
   return typeof t === 'string' && (MARKER_TYPES as string[]).includes(t);
 }
 
+// --- Hybrid war (v0.34.0, #57): non-kinetic operations ---------------------
+//
+// The LLM can run covert, non-kinetic operations each turn: spies, sabotage,
+// assassination attempts, cyberattacks, economic pressure, disinformation, and
+// proxy support. Unlike kinetic conquest (territory), these never move borders
+// — they dip a target's stats or sour a relation. The LLM declares an intended
+// outcome (`success` or `exposed`); the engine is fully deterministic (no
+// hidden randomness) and acts only on that declaration: a successful op applies
+// its small, per-type effect, and an "exposed" op backfires (no effect, the
+// actor's relation with the target sours by one step, and an auto
+// diplomatic/failure event is emitted).
+
+/** The seven covert operation types a hybrid op can be (v0.34.0, #57). */
+export type HybridOpType =
+  | 'spy'
+  | 'sabotage'
+  | 'assassinate'
+  | 'cyber'
+  | 'economic'
+  | 'information'
+  | 'proxy';
+
+/** All hybrid op types, in canonical order (the LLM contract + validator). */
+export const HYBRID_OP_TYPES: HybridOpType[] = [
+  'spy',
+  'sabotage',
+  'assassinate',
+  'cyber',
+  'economic',
+  'information',
+  'proxy',
+];
+
+/**
+ * (v0.34.0, #57) One covert (non-kinetic) operation the LLM may run in a turn
+ * (`TurnResult.hybrid.ops`). `from` is the acting nation (its id or a unique
+ * name — resolved by the engine's `resolveNationRef`). `target` is EITHER a
+ * nation (id or unique name) or a specific region key; a region target hits
+ * that region's sole owner (a region with zero or 2+ owners can't be
+ * targeted). `detail` is a short narrative (the LLM may also narrate the op in
+ * `events`). `outcome` is the LLM's *intended* result: `success` (the default)
+ * applies the op's deterministic effect, while `exposed` backfires it — the
+ * effect is NOT applied, the actor's relation with the target sours by one
+ * step, and an auto diplomatic/failure event is emitted.
+ */
+export interface HybridOp {
+  /** The operation type (see {@link HybridOpType}). */
+  type: HybridOpType;
+  /** The acting nation's id or current name (resolved by `resolveNationRef`). */
+  from: string;
+  /** The target: a nation's id/name, or a region key (hits that region's owner). */
+  target: string;
+  /** Short narrative detail (optional). */
+  detail?: string;
+  /** The LLM's intended result; `exposed` backfires the op. Defaults to success. */
+  outcome?: 'success' | 'exposed';
+}
+
+// --- Trade & embargo ops (v0.35.0, #58) --------------------------------------
+
+/**
+ * (v0.35.0, #58) A bilateral TRADE op in `TurnResult.economy.trade`: `a` and
+ * `b` are the two parties (each a nation's id or unique name — resolved by
+ * the engine's `resolveNationRef`; a pair that resolves to the same nation,
+ * or contains an unknown/ambiguous ref, is dropped defensively). Without
+ * `lift` the op DECLARES the agreement (idempotent — an already-active
+ * agreement is not duplicated); `lift: true` ENDS it.
+ */
+export interface EconomyTradeOp {
+  /** First party's id or unique name. */
+  a: string;
+  /** Second party's id or unique name (distinct from `a` after resolution). */
+  b: string;
+  /** `true` → end this bilateral trade; default `false` = declare it. */
+  lift?: boolean;
+}
+
+/**
+ * (v0.35.0, #58) A unilateral EMBARGO op in `TurnResult.economy.embargo`:
+ * `from` blocks trade with `target` (each a nation's id or unique name —
+ * resolved by `resolveNationRef`; an unknown/ambiguous ref or
+ * `from === target` is dropped defensively). Without `lift` the op imposes
+ * the embargo (idempotent — an already-active one is not duplicated);
+ * `lift: true` LIFTS it.
+ */
+export interface EconomyEmbargoOp {
+  /** The imposing nation's id or unique name. */
+  from: string;
+  /** The embargoed nation's id or unique name (distinct from `from`). */
+  target: string;
+  /** `true` → lift this embargo; default `false` = impose it. */
+  lift?: boolean;
+}
+
+/**
+ * (v0.35.0, #58) The turn's trade-and-embargo operations, nested under
+ * `TurnResult.economy`. Both arrays are required and default to `[]`. The
+ * engine applies the ops to `GameState.trades` / `GameState.embargoes`
+ * (add = declare/impose, remove = lift) and, on every committed turn, applies
+ * the per-turn economic effect of the FULL active lists (trade: both
+ * parties' economy up a little; embargo: the target's economy down a
+ * little). Active trades/embargoes between nations on opposite sides of an
+ * active war (v0.33, #56) are suspended (removed) automatically.
+ */
+export interface EconomyOps {
+  /** Bilateral trades (declare or lift). */
+  trade: EconomyTradeOp[];
+  /** Unilateral embargoes (impose or lift). */
+  embargo: EconomyEmbargoOp[];
+}
+
+/**
+ * (v0.36, #59) The turn's INDUSTRY operations, nested under
+ * `TurnResult.industry`. `projects` lists the industry projects the LLM builds
+ * this turn: each names a **region key** (the region must be valid, and — for
+ * the boost to take effect — will need a sole owner at apply time) and one of
+ * the four project {@link IndustryType}s. The engine applies each project to
+ * `GameState.industry` (a per-region SET — a region already hosting a project
+ * keeps the first one declared; a region key not in the valid manifest is
+ * dropped, never thrown). Required; default `{ projects: [] }`.
+ */
+export interface IndustryOps {
+  /** The industry projects built this turn (region key + type). */
+  projects: IndustryProject[];
+}
+
 /** The exact JSON object the world-simulator LLM must return for a turn. */
 export interface TurnResult {
   date: string;
@@ -367,6 +495,48 @@ export interface TurnResult {
    * aims) in the user payload's `wars` field, so it can `end` by id.
    */
   wars: { declare: WarDeclareOp[]; end: WarEndOp[] };
+  /**
+   * (v0.34.0, #57) Covert, non-kinetic ("hybrid") operations this turn — spies,
+   * sabotage, assassination attempts, cyberattacks, economic pressure,
+   * disinformation, and proxy support. Unlike `nationOps` (player-confirmed
+   * proposals) these are applied directly by the turn, like territory / state
+   * changes: each op's deterministic per-type effect is applied by
+   * `applyTurnResult` (a small stat dip on the target's regions, or a
+   * relation nudge toward hostile for `information` / `proxy`); an `exposed`
+   * op backfires (no effect, the actor's relation with the target sours by
+   * one step, and an auto diplomatic/failure event is emitted). They never
+   * move borders — sole ownership is untouched. Required (default
+   * `{ ops: [] }`).
+   */
+  hybrid: { ops: HybridOp[] };
+  /**
+   * (v0.35.0, #58) Trade and embargo ops — the economy layer. `trade`
+   * declares (or, with `lift: true`, ends) bilateral trade agreements
+   * between two nations; `embargo` imposes (or, with `lift: true`, lifts)
+   * a unilateral embargo on a target. Both arrays are required and default
+   * to `[]`. Applied directly by `applyTurnResult` (add to / remove from
+   * `GameState.trades` / `GameState.embargoes`), and the per-turn economic
+   * effect of the FULL active lists is applied on every committed turn (a
+   * trade lifts both parties' economy a little; an embargo lowers the
+   * target's economy a little — clamped, deterministic). Active
+   * trades/embargoes between nations on opposite sides of an active war are
+   * suspended automatically.
+   */
+  economy: EconomyOps;
+  /**
+   * (v0.36, #59) Industry projects built this turn — the LLM's "industry"
+   * lever. `projects` lists `{ regionKey, type }` pairs: the model names a
+   * region it (believes it) controls and one of the four project types
+   * (`oil` / `iron` / `food` / `industry`). Applied directly by
+   * `applyTurnResult`: each project is added to `GameState.industry` (a
+   * per-region SET — re-declaring on a region that already has a project is a
+   * no-op), and on every committed turn each active project gives its region's
+   * SOLE owner a small, deterministic economy boost scaled by that region's
+   * `industry` resource value (a region with no owner, or 2+ owners, yields no
+   * boost but keeps its project). They never move borders — sole ownership is
+   * untouched. Required; default `{ projects: [] }`.
+   */
+  industry: IndustryOps;
   /**
    * (v0.27, #44) Map-marker ops this turn. `add` places new named markers
    * (the engine positions each at its region's centroid + a small
@@ -815,3 +985,49 @@ export function migrateRegionStats(
   }
   return next;
 }
+
+/**
+ * (v0.36, #59) Derive a nation's aggregate {@link RegionResources} from the
+ * resource profiles of the regions it owns: each of the four resource values is
+ * the **area×population-weighted AVERAGE** (an average — not a median — is the
+ * meaningful aggregation for an abundance profile) over the nation's owned
+ * region keys. A region's weight is the same
+ * `(area > 0 ? area : 1) × (population > 0 ? population : 1)` as
+ * {@link deriveNationStats} — both factors fall back to 1 when the region has
+ * no geo entry (`geoOf` returns `undefined` for it), so every region carries
+ * weight ≥ 1 and a missing geo degrades gracefully to a uniform (unweighted)
+ * average. A region key with no resource-profile entry (`resourceOf` returns
+ * `undefined` for it — the manifest is not loaded, or the key is absent) is
+ * skipped. Returns the zero profile when the nation owns no region with a
+ * profile. Pure + shared.
+ */
+export function deriveNationResources(
+  regionKeys: string[],
+  resourceOf?: (key: string) => RegionResources | undefined,
+  geoOf?: (key: string) => { area: number; population: number } | undefined,
+): RegionResources {
+  const zero: RegionResources = { oil: 0, iron: 0, food: 0, industry: 0 };
+  const sums: Record<keyof RegionResources, number> = { oil: 0, iron: 0, food: 0, industry: 0 };
+  let totalW = 0;
+  for (const key of regionKeys) {
+    const r = resourceOf?.(key);
+    if (!r) continue; // a key with no resource profile is skipped
+    const g = geoOf?.(key);
+    const a = g && g.area > 0 ? g.area : 1;
+    const p = g && g.population > 0 ? g.population : 1;
+    const w = a * p;
+    totalW += w;
+    sums.oil += r.oil * w;
+    sums.iron += r.iron * w;
+    sums.food += r.food * w;
+    sums.industry += r.industry * w;
+  }
+  if (totalW <= 0) return zero;
+  const round2 = (v: number) => Math.round(v * 100) / 100;
+  return {
+    oil: round2(sums.oil / totalW),
+    iron: round2(sums.iron / totalW),
+    food: round2(sums.food / totalW),
+    industry: round2(sums.industry / totalW),
+  };
+}

shared/scenario.ts

@@ -456,6 +456,11 @@ export function worldDraftToGameState(
     // (v0.33.0, #56) No wars on a fresh (dynamic) game; any preset-level `war`
     // relation stays a bare/implicit one, not an entity (see syncWarRelations).
     wars: [],
+    // (v0.35.0, #58) No trades/embargoes on a fresh (dynamic) game.
+    trades: [],
+    embargoes: [],
+    // (v0.36, #59) No industry projects on a fresh (dynamic) game.
+    industry: [],
   };
   return state;
 }

shared/types.ts

@@ -26,6 +26,23 @@ export interface RegionStats {
   population: number;
 }
 
+/**
+ * (v0.36, #59) A region's synthesized four-value resource profile — each value
+ * a finite fraction in [0, 1]. Built once per region key by
+ * `scripts/build-region-resources.mjs` into the committed
+ * `public/region-resources.json` (the engine reads it via `regions.resourceOf`).
+ * The engine scales a region's per-turn industry boost by its `industry` value,
+ * and a nation's aggregate profile (the area×population-weighted mean of its
+ * owned regions' profiles, see `protocol.deriveNationResources`) is what the
+ * LLM prompt carries so the model can reason about where to build.
+ */
+export interface RegionResources {
+  oil: number;
+  iron: number;
+  food: number;
+  industry: number;
+}
+
 export const STAT_KEYS = ['military', 'economy', 'stability', 'population'] as const;
 export type StatKey = (typeof STAT_KEYS)[number];
 
@@ -143,6 +160,67 @@ export interface MapMarker {
   placedTurn: number;
 }
 
+/**
+ * (v0.35.0, #58) An active BILATERAL TRADE agreement between two distinct
+ * nations. Declared by the LLM via `TurnResult.economy.trade` (a no-`lift`
+ * op) and ended by a `lift: true` op; while active it yields a small,
+ * deterministic economy gain to BOTH parties every committed turn. The
+ * engine suspends (removes) the trade automatically when the two parties end
+ * up on opposite sides of an active war (v0.33, #56).
+ */
+export interface TradeAgreement {
+  /** First party's nation id. */
+  a: string;
+  /** Second party's nation id (distinct from `a`; the pair is symmetric). */
+  b: string;
+}
+
+/**
+ * (v0.35.0, #58) An active UNILATERAL EMBARGO: `from` blocks trade with
+ * `target` (which must differ from `from`). Declared by the LLM via
+ * `TurnResult.economy.embargo` (a no-`lift` op) and lifted by a `lift: true`
+ * op; while active it applies a small, deterministic economy dip to the
+ * TARGET only, every committed turn. The engine suspends (removes) the
+ * embargo automatically when the two nations end up on opposite sides of an
+ * active war (v0.33, #56).
+ */
+export interface Embargo {
+  /** The imposing nation's id. */
+  from: string;
+  /** The embargoed nation's id (distinct from `from`). */
+  target: string;
+}
+
+// --- Resources & industry (v0.36, #59) ---------------------------------------
+//
+// The LLM can build per-region INDUSTRY PROJECTS (an oil facility, an iron
+// mine, a food operation, or a factory) on regions it controls; each active
+// project gives that region's sole owner a small, deterministic economy boost
+// every committed turn, scaled by the region's `industry` resource value from
+// the committed resource manifest. The active projects live in
+// `GameState.industry` — the LLM's "industry" lever.
+
+/** The four industry project types a region can host (v0.36, #59). */
+export type IndustryType = 'oil' | 'iron' | 'food' | 'industry';
+
+/** All industry project types, in canonical order (the LLM contract + validator). */
+export const INDUSTRY_TYPES: IndustryType[] = ['oil', 'iron', 'food', 'industry'];
+
+/**
+ * (v0.36, #59) One active industry project: a building of a given
+ * {@link IndustryType} in a specific region. The engine keys the per-turn
+ * economy boost by the region's SOLE owner (a region with no owner or 2+
+ * owners yields no boost) and scales it by the region's `industry` resource
+ * value. A region hosts at most ONE project — re-declaring on a region that
+ * already has one is a no-op (the first declared type wins).
+ */
+export interface IndustryProject {
+  /** The region key the project sits in (see `public/region-keys.json`). */
+  regionKey: string;
+  /** The kind of project built there (see {@link IndustryType}). */
+  type: IndustryType;
+}
+
 /**
  * (v0.33.0, #56) A first-class **war** — a named, ongoing armed conflict
  * between two or more nations. Unlike the boolean `war` relation (which a
@@ -303,6 +381,40 @@ export interface GameState {
    * additive, no data wipe.
    */
   wars: War[];
+  /**
+   * (v0.35.0, #58) Active bilateral trade agreements (see {@link TradeAgreement}):
+   * declared/ended by a turn's `economy.trade` ops (a no-`lift` op declares,
+   * `lift: true` ends). Every committed turn the engine applies a small,
+   * deterministic economy gain to BOTH parties of each active agreement, and
+   * suspends (removes) any agreement whose two parties are on opposite sides
+   * of an active war (v0.33, #56). Always `[]` on a fresh game; rows saved
+   * before v0.35 load with this defaulted to `[]` (see server/db.ts) —
+   * additive, no data wipe.
+   */
+  trades: TradeAgreement[];
+  /**
+   * (v0.35.0, #58) Active unilateral embargoes (see {@link Embargo}):
+   * imposed/lifted by a turn's `economy.embargo` ops (a no-`lift` op imposes,
+   * `lift: true` lifts). Every committed turn the engine applies a small,
+   * deterministic economy dip to each embargo's TARGET only, and suspends
+   * (removes) any embargo whose two nations are on opposite sides of an
+   * active war (v0.33, #56). Always `[]` on a fresh game; rows saved before
+   * v0.35 load with this defaulted to `[]` (see server/db.ts) — additive,
+   * no data wipe.
+   */
+  embargoes: Embargo[];
+  /**
+   * (v0.36, #59) Active industry projects (see {@link IndustryProject}): built
+   * by a turn's `industry.projects` ops (the LLM names a region key + a
+   * project type). Each region hosts at most one project — re-declaring on a
+   * region that already has one is a no-op. Every committed turn the engine
+   * gives each project's region's SOLE owner a small, deterministic economy
+   * boost scaled by that region's `industry` resource value. A project on a
+   * region that ends a turn with no owner (or 2+ owners) yields no boost but
+   * is NOT removed. Always `[]` on a fresh game; rows saved before v0.36 load
+   * with this defaulted to `[]` (see server/db.ts) — additive, no data wipe.
+   */
+  industry: IndustryProject[];
 }
 
 /**