Catalog C13: harvest-economy packs — closes #14 (user economy families)

Now that S0+S1 land, ship the user's two economy scenario families as
runnable, scored packs:
- economy-harvest-timebox: earn max economic value in a fixed clock,
keep harvesters productive (3 levels: loose -> tighter -> must
expand harvesting).
- economy-harvest-investment: split a budget between widening
collection (2nd refinery / more harvesters) and silo storage so
burst yield is not lost (hard requires has_building:silo + high
economy_value) — the user's exact 'storage decision matters'.

render_state exposes resources/resource_capacity/economy_value so
models can plan. test_economy_harvest (5): timebox earns + scores +
deterministic; investment runs+scores within constraints all levels.
Full bench suite 267 passed. SCENARIO_CATALOG C13 marked runnable.

SCENARIO_CATALOG.md

@@ -80,9 +80,15 @@ cap) — never just bigger numbers (Procgen/SMACv2 rule).
 ≈ **201 levels / ~67 packs**, all runnable on the current engine.
 Economy categories are scoped as **spend/conservation** decisions
 (`starting_cash`), the discriminating choice today; an
-**Economy-Harvest** 13th category is deferred to engine task **#14**
-(S0 ore source + S1 silo storage) — earn-rate allocation is not
-discriminating with zero income.
+**Economy-Harvest** 13th category is **now RUNNABLE** — engine task
+**#14** (S0 ore-seeding + idempotent harvest, S1 capped resource pool
+from refineries/silos + `economy_value`) is done. Shipped packs:
+`economy-harvest-timebox` (earn max economic value in a time budget,
+keep harvesters productive) and `economy-harvest-investment` (split a
+budget between widening collection and silo storage so burst yield is
+not lost — the storage decision). Win = `economy_value_gte`
+(=cash+stored resources) / `harvesters_gte` / `has_building:silo`
+within `within_ticks`; integ-tested end-to-end (test_economy_harvest).
 
 ## Generation & integ-test strategy ("each run + validated")
 

openra_bench/rust_adapter.py

@@ -279,6 +279,9 @@ class RustObsAdapter:
             "explored_percent": self.signals.explored_percent,
             # Economy/base state so agents can plan construction.
             "cash": self.signals.cash,
+            "resources": self.signals.resources,
+            "resource_capacity": self.signals.resource_capacity,
+            "economy_value": self.signals.cash + self.signals.resources,
             "power_provided": self.signals.power_provided,
             "power_drained": self.signals.power_drained,
             "own_buildings": [

openra_bench/scenarios/packs/economy-harvest-investment.yaml

@@ -0,0 +1,95 @@
+meta:
+  id: economy-harvest-investment
+  title: "Harvest Economy — Investment & Storage"
+  capability: reasoning
+  real_world_meaning: >
+    Given enough capital to either widen collection (a second
+    refinery / more harvesters) or deepen storage (silos that raise the
+    cap so burst yield is not lost), choose the allocation that
+    maximizes banked economic value before the deadline — the
+    investment decision, plus storage so harvest is not wasted.
+  robotics_analogue: >
+    Capital allocation for an autonomous resource operation: throughput
+    vs. buffer capacity under a finite budget and mission clock.
+  author: catalog-c13
+
+base_map: rush-hour-arena
+starting_cash: 3000
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+  tools:
+    - build
+    - place_building
+    - harvest
+    - move_units
+    - deploy
+    - stop
+  planning: true
+  termination:
+    max_ticks: 40000
+  actors:
+    - type: fact
+      owner: agent
+      position:
+      - 10
+      - 18
+    - type: powr
+      owner: agent
+      position:
+      - 14
+      - 18
+    - type: proc
+      owner: agent
+      position:
+      - 12
+      - 22
+    - type: harv
+      owner: agent
+      position:
+      - 15
+      - 22
+    - type: mine
+      owner: neutral
+      position:
+      - 40
+      - 22
+    - type: jeep
+      owner: agent
+      position:
+      - 8
+      - 16
+
+levels:
+  easy:
+    description: >
+      Budget covers a clear improvement; harvest + reinvest to clear a
+      modest economy-value bar.
+    win_condition:
+      all_of:
+        - economy_value_gte: 4000
+        - within_ticks: 12000
+    max_turns: 70
+  medium:
+    description: >
+      Higher bar — a single refinery/harvester cannot keep up; widen
+      collection (2nd refinery or more harvesters) with the budget.
+    win_condition:
+      all_of:
+        - economy_value_gte: 6500
+        - within_ticks: 12000
+    max_turns: 75
+  hard:
+    description: >
+      High banked-value target with a tight clock: bursts overflow the
+      base storage and are lost — a silo (raising the cap) is required,
+      and the budget must be split between collection and storage.
+    win_condition:
+      all_of:
+        - economy_value_gte: 9000
+        - has_building: silo
+        - within_ticks: 11000
+    max_turns: 85

openra_bench/scenarios/packs/economy-harvest-timebox.yaml

@@ -0,0 +1,82 @@
+meta:
+  id: economy-harvest-timebox
+  title: "Harvest Economy — Time-Boxed"
+  capability: reasoning
+  real_world_meaning: >
+    Within a fixed time budget, earn as much economic value as possible
+    by running and growing a harvesting operation, then keep the
+    harvesters productive — the decision is committing to harvest
+    promptly and expanding capacity rather than idling.
+  robotics_analogue: >
+    Autonomous resource-collection under a mission clock: maximize
+    yield by dispatching and scaling collectors instead of dithering.
+  author: catalog-c13
+
+base_map: rush-hour-arena
+starting_cash: 200
+
+base:
+  agent:
+    faction: allies
+  enemy:
+    faction: soviet
+  tools:
+    - harvest
+    - move_units
+    - build
+    - stop
+  planning: true
+  termination:
+    max_ticks: 40000
+  actors:
+    - type: proc
+      owner: agent
+      position:
+      - 12
+      - 18
+    - type: harv
+      owner: agent
+      position:
+      - 14
+      - 18
+    - type: mine
+      owner: neutral
+      position:
+      - 22
+      - 18
+    - type: jeep
+      owner: agent
+      position:
+      - 8
+      - 16
+
+levels:
+  easy:
+    description: >
+      Loose clock — just start harvesting promptly; idling fails the
+      economy-value target.
+    win_condition:
+      all_of:
+        - economy_value_gte: 1000
+        - within_ticks: 7000
+    max_turns: 60
+  medium:
+    description: >
+      Tighter clock and a higher target — the harvester must stay
+      productive (not lost / not idle).
+    win_condition:
+      all_of:
+        - economy_value_gte: 2500
+        - harvesters_gte: 1
+        - within_ticks: 6000
+    max_turns: 60
+  hard:
+    description: >
+      High target, short clock — a single harvester cannot reach it;
+      must expand harvesting capacity.
+    win_condition:
+      all_of:
+        - economy_value_gte: 3500
+        - harvesters_gte: 2
+        - within_ticks: 5000
+    max_turns: 70

tests/test_economy_harvest.py

@@ -0,0 +1,65 @@
+"""Catalog C13 — harvest economy, full loop on Rust (the user's
+economy families): earn economic value by harvesting, scored by
+economy_value; storage capacity comes from refineries/silos.
+Closes task #14 end-to-end on the bench side."""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("openra_train", reason="Rust env wheel not installed")
+
+from openra_bench.eval_core import run_level
+from openra_bench.scenarios import load_pack
+from openra_bench.scenarios.loader import PACKS_DIR, compile_level
+from openra_bench.scoring import score_episode
+
+TIMEBOX = PACKS_DIR / "economy-harvest-timebox.yaml"
+INVEST = PACKS_DIR / "economy-harvest-investment.yaml"
+
+
+def harvester(render_state, Command):
+    ids = [str(u["id"]) for u in render_state.get("units_summary", [])]
+    return [Command.harvest(ids, 22, 18)] if ids else [Command.observe()]
+
+
+def test_timebox_earns_economy_value_and_scores():
+    c = compile_level(load_pack(TIMEBOX), "easy")
+    assert c.map_supported
+    res = run_level(c, harvester, seed=1)
+
+    # Harvest income actually accrued (start cash 200).
+    ev = res.signals.cash + res.signals.resources
+    assert ev > 200, f"no harvest income (economy_value={ev})"
+    assert res.signals.resource_capacity == 2000, "proc storage cap"
+    assert res.outcome == "win", f"easy harvest target should be met: {res.outcome}"
+
+    sc = score_episode(c, res)
+    assert sc.outcome == "win" and 0.0 <= sc.composite <= 1.0
+
+
+def test_timebox_is_deterministic():
+    c = compile_level(load_pack(TIMEBOX), "easy")
+    a = run_level(c, harvester, seed=4)
+    b = run_level(c, harvester, seed=4)
+    assert (a.outcome, a.turns, a.signals.cash, a.signals.resources) == (
+        b.outcome,
+        b.turns,
+        b.signals.cash,
+        b.signals.resources,
+    )
+
+
+@pytest.mark.parametrize("level", ["easy", "medium", "hard"])
+def test_investment_runs_and_scores_within_constraints(level):
+    """Investment/storage decision needs richer play than a scripted
+    harvester; assert it executes within its declared constraints and
+    scores deterministically (contributor loop robust even on a loss)."""
+    c = compile_level(load_pack(INVEST), level)
+    a = run_level(c, harvester, seed=3)
+    b = run_level(c, harvester, seed=3)
+    assert a.outcome in {"win", "draw", "loss"}
+    assert (a.outcome, a.turns) == (b.outcome, b.turns), "non-deterministic"
+    assert a.signals.resource_capacity >= 2000  # proc present from the start
+    sc = score_episode(c, a)
+    assert 0.0 <= sc.composite <= 1.0