feat: Resources & Industry — per-region resource profiles + industry LLM lever (v0.36.0, #59)

- 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

server/db.test.ts

@@ -36,6 +36,8 @@ function makeState(id: string): GameState {
     // (v0.35.0, #58) no active trades or embargoes.
     trades: [],
     embargoes: [],
+    // (v0.36.0, #59) no industry projects.
+    industry: [],
   };
 }
 
@@ -165,6 +167,17 @@ describe('openDb', () => {
     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

@@ -57,6 +57,9 @@ export function openDb(filePath: string): Db {
         // 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.test.ts

@@ -16,6 +16,7 @@ import type { LlmClient, ToolDefinition, WireMessage } from './llm';
 import { deterministicTurn, makeStubLlmClient } from './stub';
 import {
   activeWarPairs,
+  applyIndustryEffects,
   applyNationOp,
   applyTurnResult,
   atWar,
@@ -42,6 +43,7 @@ import {
   syncWarRelations,
   validateEconomyOps,
   validateHybridOps,
+  validateIndustryOps,
   validateMarkerOps,
   validateNationOps,
   validateRegionChanges,
@@ -122,6 +124,8 @@ function baseState(): GameState {
     // (v0.35.0, #58) no active trades or embargoes on a fresh state.
     trades: [],
     embargoes: [],
+    // (v0.36.0, #59) no industry projects on a fresh state.
+    industry: [],
   };
 }
 
@@ -559,7 +563,7 @@ describe('validateNationOps (v0.23 #16 P4a)', () => {
       relations: [],
       territoryChanges: [],
       unowned: [],
-      nationOps: [{ kind: 'rename', nationRef: 'France', to: 'French Republic' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] },
+      nationOps: [{ kind: 'rename', nationRef: 'France', to: 'French Republic' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
     });
     expect(withOps).not.toBeNull();
     expect(withOps!.nationOps).toEqual([{ kind: 'rename', nationRef: 'France', to: 'French Republic' }]);
@@ -581,7 +585,7 @@ describe('applyTurnResult (nation-op proposals, v0.23 #16 P4a)', () => {
       relations: [],
       territoryChanges: [],
       unowned: [],
-      nationOps: [{ kind: 'rename', nationRef: 'de', to: 'Reich' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] },
+      nationOps: [{ kind: 'rename', nationRef: 'de', to: 'Reich' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
     });
     expect(next.nations.de.name).toBe('DE'); // still the old name
     expect(next.pendingNationOps).toEqual([{ kind: 'rename', nationRef: 'de', to: 'Reich' }]);
@@ -602,7 +606,7 @@ describe('applyTurnResult (nation-op proposals, v0.23 #16 P4a)', () => {
       relations: [],
       territoryChanges: [],
       unowned: [],
-      nationOps: [{ kind: 'rename', nationRef: 'us', to: 'USA' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] }, // new proposal this turn
+      nationOps: [{ kind: 'rename', nationRef: 'us', to: 'USA' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] }, // new proposal this turn
     });
     expect(next.pendingNationOps).toEqual([
       { kind: 'rename', nationRef: 'de', to: 'Reich' }, // the old one survived
@@ -621,7 +625,7 @@ describe('applyTurnResult (nation-op proposals, v0.23 #16 P4a)', () => {
       relations: [],
       territoryChanges: [],
       unowned: [],
-      nationOps: [{ kind: 'rename', nationRef: 'de', to: 'Reich' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] },
+      nationOps: [{ kind: 'rename', nationRef: 'de', to: 'Reich' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
     });
     expect(next.pendingNationOps).toEqual([{ kind: 'rename', nationRef: 'de', to: 'Reich' }]);
   });
@@ -1078,7 +1082,7 @@ describe('applyTurnResult', () => {
       relations: [],
       territoryChanges: [],
       unowned: [],
-      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] },
+      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
     };
     applyTurnResult(state, result);
     expect(JSON.stringify(state)).toBe(snapshot);
@@ -1095,7 +1099,7 @@ describe('applyTurnResult', () => {
       relations: [],
       territoryChanges: [],
       unowned: [],
-      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] },
+      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
     expect(next.pending).toEqual([]);
@@ -1118,7 +1122,7 @@ describe('applyTurnResult', () => {
       // is not a real key at all. Both are proposed as a gain by DE.
       territoryChanges: [{ nation: 'de', gain: ['wales-bbbb', 'not-a-region-xyz'], lose: [] }],
       unowned: [],
-      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] },
+      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result, new Set(['wales-bbbb']));
     // the valid key was gained (taken from its sole previous owner); the bogus one was ignored
@@ -1144,7 +1148,7 @@ describe('applyTurnResult', () => {
       // released (not in state.unowned), so it does not enter GameState.unowned.
       territoryChanges: [{ nation: 'de', gain: ['POL', 'wales-bbbb'], lose: [] }],
       unowned: [],
-      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] },
+      nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result); // no validKeys -> nothing filtered
     expect(next.nations.de.territory).toContain('wales-bbbb');
@@ -1162,7 +1166,7 @@ describe('applyTurnResult (sole-ownership invariants, v0.21 #16 P2)', () => {
     regionChanges: [],
     relations: [],
     unowned: [],
-    nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] },
+    nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
   };
 
   it('a double claim (two different gainers, one key) is rejected: the key stays with its original owner', () => {
@@ -1252,7 +1256,7 @@ describe('applyTurnResult (no man\'s land, v0.22 #16 P3)', () => {
     relations: [],
     territoryChanges: [],
     unowned: [],
-    nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] },
+    nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
   };
 
   it('a release removes the key from its sole owner and marks it in GameState.unowned', () => {
@@ -1367,7 +1371,7 @@ describe('applyTurnResult (no man\'s land, v0.22 #16 P3)', () => {
 
   it('a lone release is meaningful (it survives the retry/nudge path)', () => {
     expect(
-      isMeaningful({ date: 'x', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [], unowned: ['GBR'], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] } }),
+      isMeaningful({ date: 'x', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [], unowned: ['GBR'], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] } }),
     ).toBe(true);
   });
 
@@ -1674,9 +1678,9 @@ describe('buildSystemPrompt (tool mode, v0.21 #16 P2)', () => {
 
 describe('isMeaningful', () => {
   it('is true with an event, false when everything is empty', () => {
-    expect(isMeaningful({ date: 'x', events: [{ nation: 'uk', type: 'military', title: 't', text: 'b', outcome: 'neutral' }], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [], unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] } })).toBe(true);
-    expect(isMeaningful({ date: 'x', events: [], stateChanges: [{ nation: 'uk', stat: 'military', op: 'set', value: 5 }], regionChanges: [], relations: [], territoryChanges: [], unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] } })).toBe(true);
-    expect(isMeaningful({ date: 'x', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [], unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] } })).toBe(false);
+    expect(isMeaningful({ date: 'x', events: [{ nation: 'uk', type: 'military', title: 't', text: 'b', outcome: 'neutral' }], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [], unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] } })).toBe(true);
+    expect(isMeaningful({ date: 'x', events: [], stateChanges: [{ nation: 'uk', stat: 'military', op: 'set', value: 5 }], regionChanges: [], relations: [], territoryChanges: [], unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] } })).toBe(true);
+    expect(isMeaningful({ date: 'x', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [], unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] } })).toBe(false);
   });
 
   it('(v0.23 #16 P4a) a turn that only proposes a nation-op is meaningful (it survives the retry/nudge path)', () => {
@@ -1689,7 +1693,7 @@ describe('isMeaningful', () => {
         relations: [],
         territoryChanges: [],
         unowned: [],
-        nationOps: [{ kind: 'rename', nationRef: 'de', to: 'Reich' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] },
+        nationOps: [{ kind: 'rename', nationRef: 'de', to: 'Reich' }], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
       }),
     ).toBe(true);
   });
@@ -1708,7 +1712,7 @@ describe('isMeaningful', () => {
         takeovers: [],
         wars: { declare: [], end: [] },
         hybrid: { ops: [] },
-        economy: { trade: [], embargo: [] },
+        economy: { trade: [], embargo: [] }, industry: { projects: [] },
         markers: { add: [{ type: 'city', name: 'Lyon', regionKey: 'rhone-rhne' }], remove: [] },
       }),
     ).toBe(true);
@@ -1728,7 +1732,7 @@ describe('isMeaningful', () => {
         takeovers: [{ nationRef: 'de', newRegimeName: 'The Reich' }],
         wars: { declare: [], end: [] },
         hybrid: { ops: [] },
-        economy: { trade: [], embargo: [] },
+        economy: { trade: [], embargo: [] }, industry: { projects: [] },
         markers: { add: [], remove: [] },
       }),
     ).toBe(true);
@@ -1750,7 +1754,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       takeovers: [{ nationRef: 'de', newRegimeName: 'The Reich' }],
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
-      economy: { trade: [], embargo: [] },
+      economy: { trade: [], embargo: [] }, industry: { projects: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1782,7 +1786,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       takeovers: [{ nationRef: 'uk', newRegimeName: 'The Commonwealth' }],
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
-      economy: { trade: [], embargo: [] },
+      economy: { trade: [], embargo: [] }, industry: { projects: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1805,7 +1809,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       takeovers: [{ nationRef: 'nonexistent', newRegimeName: 'New Name' }],
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
-      economy: { trade: [], embargo: [] },
+      economy: { trade: [], embargo: [] }, industry: { projects: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1831,7 +1835,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       takeovers: [{ nationRef: 'UK', newRegimeName: 'The Empire' }],
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
-      economy: { trade: [], embargo: [] },
+      economy: { trade: [], embargo: [] }, industry: { projects: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1856,7 +1860,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       takeovers: [{ nationRef: 'de', newRegimeName: '   ' }],
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
-      economy: { trade: [], embargo: [] },
+      economy: { trade: [], embargo: [] }, industry: { projects: [] },
       markers: { add: [], remove: [] },
     });
     expect(validated!.takeovers).toEqual([]);
@@ -1881,7 +1885,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       ],
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
-      economy: { trade: [], embargo: [] },
+      economy: { trade: [], embargo: [] }, industry: { projects: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1904,7 +1908,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       takeovers: [{ nationRef: 'de', newRegimeName: 'The Reich' }],
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
-      economy: { trade: [], embargo: [] },
+      economy: { trade: [], embargo: [] }, industry: { projects: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1925,7 +1929,7 @@ describe('takeovers (regime change, v0.32.0 #54)', () => {
       takeovers: [{ nationRef: 'De', newRegimeName: 'The Reich' }], // 'De' → resolves to 'de' by name
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
-      economy: { trade: [], embargo: [] },
+      economy: { trade: [], embargo: [] }, industry: { projects: [] },
       markers: { add: [], remove: [] },
     };
     const next = applyTurnResult(state, result);
@@ -1958,7 +1962,7 @@ describe('markers (point placement, v0.27 #44)', () => {
       takeovers: [],
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
-      economy: { trade: [], embargo: [] },
+      economy: { trade: [], embargo: [] }, industry: { projects: [] },
       markers: { add: [mk('city', 'Strasbourg', 'moselle-rygy')], remove: [] },
     };
     const next = applyTurnResult(state, result, undefined, centroidOf);
@@ -1983,13 +1987,13 @@ describe('markers (point placement, v0.27 #44)', () => {
     const add = [mk('city', 'Strasbourg', 'moselle-rygy')];
     const first = applyTurnResult(state, {
       date: '1939-09-03', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [],
-      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add, remove: [] },
+      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add, remove: [] },
     }, undefined, centroidOf);
     expect(first.markers).toHaveLength(1);
     // a second turn proposes the exact same marker again
     const second = applyTurnResult(first, {
       date: '1939-09-05', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [],
-      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add, remove: [] },
+      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add, remove: [] },
     }, undefined, centroidOf);
     expect(second.markers).toHaveLength(1);
     expect(second.markers[0].id).toBe(first.markers[0].id); // stable id, no second copy
@@ -2014,7 +2018,7 @@ describe('markers (point placement, v0.27 #44)', () => {
       takeovers: [],
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
-      economy: { trade: [], embargo: [] },
+      economy: { trade: [], embargo: [] }, industry: { projects: [] },
       markers: {
         add: [
           { type: 'city', name: 'Good', regionKey: 'moselle-rygy' }, // valid + centroid → kept
@@ -2060,7 +2064,7 @@ describe('markers (point placement, v0.27 #44)', () => {
       takeovers: [],
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
-      economy: { trade: [], embargo: [] },
+      economy: { trade: [], embargo: [] }, industry: { projects: [] },
       markers: {
         add: [
           { type: 'city', name: 'NewA', regionKey: 'new-a' },
@@ -2086,7 +2090,7 @@ describe('markers (point placement, v0.27 #44)', () => {
     ];
     const next = applyTurnResult(state, {
       date: '1939-09-03', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [],
-      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [idA, 'zzzz-not-there'] },
+      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [idA, 'zzzz-not-there'] },
     }, undefined, centroidOf);
     expect(next.markers).toHaveLength(1);
     expect(next.markers[0].id).toBe(idB); // only A removed; the bogus id was a no-op
@@ -2102,14 +2106,14 @@ describe('markers (point placement, v0.27 #44)', () => {
     // 1) uk releases the region → the marker becomes ownerless
     const released = applyTurnResult(state, {
       date: '1939-09-03', events: [], stateChanges: [], regionChanges: [], relations: [], territoryChanges: [],
-      unowned: ['moselle-rygy'], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] },
+      unowned: ['moselle-rygy'], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
     }, undefined, centroidOf);
     expect(released.markers[0].ownerNationId).toBeNull();
     // 2) de re-claims the region → the marker's owner follows to de
     const reclaimed = applyTurnResult(released, {
       date: '1939-09-05', events: [], stateChanges: [], regionChanges: [], relations: [],
       territoryChanges: [{ nation: 'de', gain: ['moselle-rygy'], lose: [] }],
-      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, markers: { add: [], remove: [] },
+      unowned: [], nationOps: [], takeovers: [], wars: { declare: [], end: [] }, hybrid: { ops: [] }, economy: { trade: [], embargo: [] }, industry: { projects: [] }, markers: { add: [], remove: [] },
     }, undefined, centroidOf);
     expect(reclaimed.markers[0].ownerNationId).toBe('de');
   });
@@ -2177,7 +2181,7 @@ describe('markers (point placement, v0.27 #44)', () => {
       nationOps: [],
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
-      economy: { trade: [], embargo: [] },
+      economy: { trade: [], embargo: [] }, industry: { projects: [] },
       markers: { add: [{ type: 'city', name: 'Strasbourg', regionKey: 'moselle-rygy' }], remove: [] },
     });
     const { state } = await runTurn({
@@ -2251,6 +2255,8 @@ function mkTurnState(
     // (v0.35.0, #58) no active trades or embargoes on a fresh state.
     trades: [],
     embargoes: [],
+    // (v0.36.0, #59) no industry projects on a fresh state.
+    industry: [],
   };
 }
 
@@ -2268,6 +2274,7 @@ function mkTurnResult(partial: Partial<TurnResult>): TurnResult {
     wars: partial.wars ?? { declare: [], end: [] },
     hybrid: partial.hybrid ?? { ops: [] },
     economy: partial.economy ?? { trade: [], embargo: [] },
+    industry: partial.industry ?? { projects: [] },
     markers: partial.markers ?? { add: [], remove: [] },
   };
 }
@@ -2991,7 +2998,7 @@ describe('validateTakeovers (v0.32.0 #54)', () => {
       takeovers: [{ nationRef: 'de', newRegimeName: 'The Reich' }, { nationRef: 'bad', newRegimeName: '' }],
       wars: { declare: [], end: [] },
       hybrid: { ops: [] },
-      economy: { trade: [], embargo: [] },
+      economy: { trade: [], embargo: [] }, industry: { projects: [] },
       markers: { add: [], remove: [] },
     });
     expect(withTakeovers).not.toBeNull();
@@ -3378,7 +3385,7 @@ describe('isMeaningful — wars (v0.33.0 #56)', () => {
         takeovers: [],
         wars: { declare: [{ sides: ['a', 'b'] }], end: [] },
         hybrid: { ops: [] },
-        economy: { trade: [], embargo: [] },
+        economy: { trade: [], embargo: [] }, industry: { projects: [] },
         markers: { add: [], remove: [] },
       }),
     ).toBe(true);
@@ -3398,7 +3405,7 @@ describe('isMeaningful — wars (v0.33.0 #56)', () => {
         takeovers: [],
         wars: { declare: [], end: [{ id: 'w1', outcome: 'armistice' }] },
         hybrid: { ops: [] },
-        economy: { trade: [], embargo: [] },
+        economy: { trade: [], embargo: [] }, industry: { projects: [] },
         markers: { add: [], remove: [] },
       }),
     ).toBe(true);
@@ -3418,7 +3425,7 @@ describe('isMeaningful — wars (v0.33.0 #56)', () => {
         takeovers: [],
         wars: { declare: [], end: [] },
         hybrid: { ops: [] },
-        economy: { trade: [], embargo: [] },
+        economy: { trade: [], embargo: [] }, industry: { projects: [] },
         markers: { add: [], remove: [] },
       }),
     ).toBe(false);
@@ -4128,5 +4135,217 @@ describe('stub — economy (v0.35.0 #58)', () => {
     };
     const result = deterministicTurn(payload);
     expect(result.economy).toEqual({ trade: [], embargo: [] });
+    expect(result.industry).toEqual({ projects: [] });
+  });
+});
+
+// --- Industry projects (v0.36.0, #59) ----------------------------------------
+
+describe('validateIndustryOps (v0.36.0 #59)', () => {
+  it('accepts well-formed project ops', () => {
+    const out = validateIndustryOps({ projects: [{ regionKey: 'moselle-rygy', type: 'oil' }] });
+    expect(out).toEqual({ projects: [{ regionKey: 'moselle-rygy', type: 'oil' }] });
+  });
+
+  it('drops ops with a missing regionKey, an unknown type, or a non-object entry', () => {
+    const out = validateIndustryOps({
+      projects: [
+        { type: 'oil' }, // no regionKey
+        { regionKey: 'k1', type: 'coal' }, // unknown type
+        { regionKey: '', type: 'iron' }, // empty key
+        'not-an-object',
+        null,
+        { regionKey: 'k2', type: 'food' }, // valid
+      ],
+    });
+    expect(out).toEqual({ projects: [{ regionKey: 'k2', type: 'food' }] });
+  });
+
+  it('a missing / malformed top-level object yields { projects: [] }', () => {
+    expect(validateIndustryOps(undefined)).toEqual({ projects: [] });
+    expect(validateIndustryOps(null)).toEqual({ projects: [] });
+    expect(validateIndustryOps('nope')).toEqual({ projects: [] });
+    expect(validateIndustryOps({})).toEqual({ projects: [] });
+    expect(validateIndustryOps({ projects: 'x' })).toEqual({ projects: [] });
+  });
+});
+
+describe('applyTurnResult — industry ops (v0.36.0 #59)', () => {
+  const state = () =>
+    mkTurnState(
+      {
+        uk: mkNation('uk', NS(50, 50, 50, 50), ['g1', 'g2']),
+        de: mkNation('de', NS(50, 50, 50, 50), ['d1']),
+      },
+      { g1: RS(50, 50, 50, 50), g2: RS(50, 50, 50, 50), d1: RS(50, 50, 50, 50) },
+    );
+
+  it('declares a project on each valid region (per-region set)', () => {
+    const next = applyTurnResult(state(), mkTurnResult({
+      industry: { projects: [{ regionKey: 'g1', type: 'oil' }, { regionKey: 'd1', type: 'industry' }] },
+    }));
+    expect(next.industry).toEqual([
+      { regionKey: 'g1', type: 'oil' },
+      { regionKey: 'd1', type: 'industry' },
+    ]);
+  });
+
+  it('re-declaring on a region that already hosts a project is a no-op (first type wins)', () => {
+    const s = state();
+    s.industry = [{ regionKey: 'g1', type: 'oil' }];
+    const next = applyTurnResult(s, mkTurnResult({
+      industry: { projects: [{ regionKey: 'g1', type: 'iron' }, { regionKey: 'g2', type: 'food' }] },
+    }));
+    expect(next.industry).toEqual([
+      { regionKey: 'g1', type: 'oil' }, // the existing type is never replaced
+      { regionKey: 'g2', type: 'food' },
+    ]);
+  });
+
+  it('drops a project whose region key is not in the valid-keys manifest', () => {
+    const next = applyTurnResult(
+      state(),
+      mkTurnResult({ industry: { projects: [{ regionKey: 'not-a-real-key-xyz', type: 'oil' }] } }),
+      new Set(['g1', 'g2', 'd1']),
+    );
+    expect(next.industry).toEqual([]);
+  });
+
+  it('active projects persist across turns (the set is never cleared on commit)', () => {
+    const s = state();
+    s.industry = [{ regionKey: 'g1', type: 'oil' }];
+    const next = applyTurnResult(s, mkTurnResult({}));
+    expect(next.industry).toEqual([{ regionKey: 'g1', type: 'oil' }]);
+  });
+});
+
+describe('applyIndustryEffects (v0.36.0 #59)', () => {
+  const mk = () =>
+    mkTurnState(
+      {
+        uk: mkNation('uk', NS(50, 50, 50, 50), ['g1']),
+        de: mkNation('de', NS(50, 50, 50, 50), ['d1']),
+      },
+      { g1: RS(50, 50, 50, 50), d1: RS(50, 50, 50, 50) },
+    );
+
+  it('boosts the region\'s SOLE owner by the base value (no resource manifest)', () => {
+    const s = mk();
+    s.industry = [{ regionKey: 'g1', type: 'oil' }];
+    applyIndustryEffects(s);
+    expect(s.nations.uk.stats.economy).toBe(51); // 50 + 1
+    expect(s.nations.de.stats.economy).toBe(50); // d1 hosts no project
+    // the boost is mirrored to every region the owner holds
+    expect(s.regionStats.g1.economy).toBe(51);
+    expect(s.regionStats.d1.economy).toBe(50);
+  });
+
+  it('adds one extra point when the region\'s industry value is >= 0.5 (and not below)', () => {
+    const s = mk();
+    s.industry = [{ regionKey: 'g1', type: 'oil' }, { regionKey: 'd1', type: 'iron' }];
+    applyIndustryEffects(
+      s,
+      (k) => (k === 'g1'
+        ? { oil: 0, iron: 0, food: 0, industry: 0.5 } // 0.5 >= 0.5 → boosted
+        : { oil: 0, iron: 0, food: 0, industry: 0.4 }), // 0.4 < 0.5 → base
+    );
+    expect(s.nations.uk.stats.economy).toBe(52); // 1 + 1
+    expect(s.nations.de.stats.economy).toBe(51); // 1 + 0
+  });
+
+  it('a nation owning several project regions gets each of their boosts', () => {
+    const s = mk();
+    s.nations.uk.territory = ['g1', 'd1'];
+    s.nations.de.territory = [];
+    s.industry = [{ regionKey: 'g1', type: 'oil' }, { regionKey: 'd1', type: 'iron' }];
+    applyIndustryEffects(s);
+    expect(s.nations.uk.stats.economy).toBe(52); // 2 projects × base 1
+  });
+
+  it('a project on an ownerless (released) region yields no boost but is kept', () => {
+    const s = mk();
+    s.nations.uk.territory = []; // g1 is no man's land
+    s.industry = [{ regionKey: 'g1', type: 'oil' }];
+    applyIndustryEffects(s);
+    expect(s.industry).toEqual([{ regionKey: 'g1', type: 'oil' }]); // kept, not removed
+    expect(s.nations.de.stats.economy).toBe(50); // nobody was boosted
+  });
+
+  it('a project on a region with 2+ owners (corrupt) yields no boost but is kept', () => {
+    const s = mk();
+    s.nations.de.territory = ['d1', 'g1']; // corrupt: g1 has two owners
+    s.industry = [{ regionKey: 'g1', type: 'oil' }];
+    applyIndustryEffects(s);
+    expect(s.industry).toEqual([{ regionKey: 'g1', type: 'oil' }]); // kept
+    expect(s.nations.uk.stats.economy).toBe(50);
+    expect(s.nations.de.stats.economy).toBe(50);
+  });
+
+  it('is a no-op when there are no active projects', () => {
+    const s = mk();
+    applyIndustryEffects(s);
+    expect(s.nations.uk.stats.economy).toBe(50);
+    expect(s.nations.de.stats.economy).toBe(50);
+  });
+});
+
+describe('isMeaningful — industry (v0.36.0 #59)', () => {
+  it('a project-only turn is meaningful; an empty industry is not', () => {
+    expect(isMeaningful(mkTurnResult({ industry: { projects: [{ regionKey: 'k', type: 'oil' }] } }))).toBe(true);
+    expect(isMeaningful(mkTurnResult({}))).toBe(false);
+  });
+});
+
+describe('buildSystemPrompt — industry contract (v0.36.0 #59)', () => {
+  it('documents the industry field and its constraints in both modes', () => {
+    for (const withTools of [false, true]) {
+      const p = buildSystemPrompt(preset, withTools);
+      expect(p).toContain('"industry": {"projects":');
+      expect(p).toContain('Industry ("industry") is the per-resource development lever');
+      expect(p).toContain('do not re-declare one on a region that already has one');
+    }
+  });
+});
+
+describe('buildUserPrompt — industry (v0.36.0 #59)', () => {
+  const state = mkTurnState(
+    { a: mkNation('a', NS(50, 50, 50, 50), ['ra1']), b: mkNation('b', NS(50, 50, 50, 50), ['rb1']) },
+    { ra1: RS(50, 50, 50, 50), rb1: RS(50, 50, 50, 50) },
+  );
+
+  it('carries the resource aggregate and active projects when provided', () => {
+    const out = JSON.parse(
+      buildUserPrompt(
+        state,
+        [],
+        undefined,
+        undefined,
+        [],
+        [],
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        { a: { oil: 0.9, iron: 0.1, food: 0.5, industry: 0.2 } },
+        [{ regionKey: 'ra1', type: 'oil' }],
+      ),
+    );
+    expect(out.resources).toEqual({ a: { oil: 0.9, iron: 0.1, food: 0.5, industry: 0.2 } });
+    expect(out.industry).toEqual([{ regionKey: 'ra1', type: 'oil' }]);
+  });
+
+  it('omits the resources/industry fields entirely when undefined', () => {
+    const out = JSON.parse(buildUserPrompt(state, [], undefined, undefined, [], [], undefined, undefined));
+    expect(out).not.toHaveProperty('resources');
+    expect(out).not.toHaveProperty('industry');
+  });
+});
+
+describe('runTurn — industry (v0.36.0 #59)', () => {
+  it('a result without an industry field leaves state.industry = [] (defensive init)', async () => {
+    const s = baseState();
+    delete (s as { industry?: unknown[] }).industry; // simulate a pre-v0.36 row
+    const { state } = await runTurn({ llm: fakeLlm([validResult]), preset, state: s, items: [] });
+    expect(state.industry).toEqual([]);
   });
 });

server/engine.ts

@@ -8,22 +8,26 @@ import type {
   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,
@@ -38,6 +42,7 @@ import {
   type EconomyTradeOp,
   type HybridOp,
   type HybridOpType,
+  type IndustryOps,
   type MarkerInfo,
   type MarkerSpec,
   type NationOp,
@@ -70,6 +75,13 @@ 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) ---
 
 /**
@@ -224,6 +236,7 @@ export function buildSystemPrompt(preset: Preset, withNeighboursTool = false): s
     '  "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>"]}',
     '}',
     '',
@@ -245,6 +258,7 @@ export function buildSystemPrompt(preset: Preset, withNeighboursTool = false): s
     '- 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.',
@@ -321,6 +335,22 @@ export function buildUserPrompt(
    * 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;
@@ -437,6 +467,8 @@ export function buildUserPrompt(
   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);
 }
 
@@ -578,6 +610,7 @@ export function validateTurnResult(
     wars: { declare: [], end: [] },
     hybrid: { ops: [] },
     economy: { trade: [], embargo: [] },
+    industry: { projects: [] },
     markers: { add: [], remove: [] },
   };
 
@@ -688,6 +721,14 @@ export function validateTurnResult(
   // 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).
@@ -962,6 +1003,34 @@ export function validateEconomyOps(raw: unknown): EconomyOps {
   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},
@@ -1368,8 +1437,127 @@ function suspendEconomyOnWar(next: GameState): void {
   next.embargoes = next.embargoes.filter((e) => !atWarNow(e.from, e.target));
 }
 
+// --- Industry projects: the per-region economy-boost lever (v0.36, #59) ------
+
 /**
- * A turn is "meaningful" if it produced at least an event, a stat change, a
+ * (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
@@ -1397,6 +1585,9 @@ export function isMeaningful(result: TurnResult): boolean {
     // 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
@@ -1441,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,
@@ -1449,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);
@@ -1779,6 +1981,27 @@ export function applyTurnResult(
   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
@@ -2250,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);
@@ -2282,6 +2514,20 @@ export async function runTurn(opts: {
   // 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,
@@ -2295,6 +2541,12 @@ export async function runTurn(opts: {
     // 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.';
@@ -2351,12 +2603,13 @@ export async function runTurn(opts: {
       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';
@@ -186,6 +186,10 @@ app.post('/api/games', (req: Request, res) => {
     // 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
@@ -370,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

@@ -57,6 +57,8 @@ const state: GameState = {
   // (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,
@@ -44,6 +45,7 @@ function mkState(
     wars: [],
     trades: [],
     embargoes: [],
+    industry: [],
   };
   if (regionStats !== undefined) base.regionStats = regionStats as GameState['regionStats'];
   else delete (base as { regionStats?: unknown }).regionStats; // simulate a legacy row
@@ -139,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';
@@ -114,6 +116,8 @@ describe('regions (region-key loader, v0.19 #16 P1)', () => {
       // (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);
@@ -172,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());
 
@@ -191,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();
     });
   });
 
@@ -248,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

@@ -67,6 +67,20 @@ export interface StubPayload {
    * 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 {
@@ -123,6 +137,10 @@ function truncate(s: string, n: number): string {
  * 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;
@@ -193,6 +211,7 @@ export function deterministicTurn(p: StubPayload): TurnResult {
     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)
   };
 }