Fix open economy: real intermediate imports, balanced trade, importPush cap

Three bugs in OpenEconomy:
1. Imported intermediates scaled with priceLevel² (sectorOutputs already
   includes PL, then multiplied by PL again) — removed double-counting
2. Imported intermediates used nominal sector output — now divides by PL
   to get real output, since foreign goods are priced in EUR not PLN
3. ER import effect was inverted: (baseER/ER)^ε reduced PLN bill when
   PLN weakened — corrected to (ER/baseER)^(1-ε) net effect

Two calibration fixes:
- OeExportBase = 475M (balances initial trade with intermediate imports;
  legacy ExportBase=190M was calibrated without I-O imports)
- OeImportPushCap = 3%/month (prevents runaway ER→inflation→ER spiral)

Export competitiveness now uses real exchange rate (PL/ER) instead of
separate PL and ER terms that double-counted.

Result: ER stable at 4.33→2.66 (appreciation from deflation-driven
export competitiveness). PLN advantage over EUR preserved (61% vs 78%
unemployment at BDP=2000).

Author: speedcom

src/main/scala/sfc/config/SimConfig.scala

@@ -217,6 +217,16 @@ object Config:
   val OeErFloor: Double   = sys.env.get("OE_ER_FLOOR").map(_.trim.toDouble).getOrElse(2.5)
   val OeErCeiling: Double = sys.env.get("OE_ER_CEILING").map(_.trim.toDouble).getOrElse(10.0)
 
+  // Export base for open economy.  Default 475M balances initial trade when
+  // intermediate imports (~200M) are added to the existing consumption imports (~275M).
+  // The legacy ExportBase (190M) was calibrated without intermediate imports.
+  val OeExportBase: Double = sys.env.get("OE_EXPORT_BASE").map(_.trim.toDouble)
+    .getOrElse(475000000.0) * ScaleFactor
+
+  // Import-push inflation cap (monthly).  Prevents runaway ER→inflation→ER spiral.
+  // At 3% cap, even a 100% ER deviation contributes at most 3% monthly inflation.
+  val OeImportPushCap: Double = 0.03
+
   // Hardcoded calibration (NBP/GUS/WIOD)
   val OeForeignGdpGrowth      = 0.015   // EZ annual real GDP growth
   val OeExportPriceElasticity  = 0.8     // Marshall-Lerner

src/main/scala/sfc/engine/OpenEconomy.scala

@@ -21,21 +21,32 @@ object OpenEconomy:
     val nSectors = 6
 
     // A. Export demand (structural)
+    // Foreign buyers care about the real exchange rate: PL / (ER/baseER).
+    // When PL rises but ER depreciates proportionally, real price unchanged.
+    // This replaces the separate priceCompetitiveness × erCompetitiveness terms
+    // which double-counted and let PL crush exports even when ER compensated.
     val foreignGdpFactor = Math.pow(1.0 + Config.OeForeignGdpGrowth / 12.0, month.toDouble)
-    val erCompetitiveness = if rc.isEurozone then 1.0
-      else Math.pow(prevForex.exchangeRate / Config.BaseExRate, Config.OeExportPriceElasticity)
     val ulcEffect = 1.0 + autoRatio * Config.OeUlcExportBoost
-    val priceCompetitiveness = if priceLevel > 0 then
-      Math.pow(1.0 / priceLevel, Config.OeExportPriceElasticity)
-    else 1.0
-    val exports = Config.ExportBase * foreignGdpFactor * priceCompetitiveness *
-      erCompetitiveness * ulcEffect
+    val realExRate = if rc.isEurozone then 1.0
+      else
+        val nominalER = prevForex.exchangeRate / Config.BaseExRate  // >1 when PLN weaker
+        val realPrice = if priceLevel > 0 && nominalER > 0 then priceLevel / nominalER
+                        else 1.0
+        Math.pow(1.0 / Math.max(0.1, realPrice), Config.OeExportPriceElasticity)
+    val exports = Config.OeExportBase * foreignGdpFactor * realExRate * ulcEffect
 
     // B. Imported intermediates (cross-border I-O)
-    val erImportEffect = if rc.isEurozone then 1.0
-      else Math.pow(Config.BaseExRate / prevForex.exchangeRate, Config.OeErElasticity)
+    // Intermediate imports = real domestic output × import share × ER net effect.
+    // sectorOutputs is nominal (includes priceLevel), so divide by PL to get real output.
+    // PLN import bill: quantity × foreign price × ER. With demand elasticity ε:
+    //   bill ∝ realOutput × (ER/baseER)^(1-ε).  For ε<1 bill rises with depreciation.
+    val erNetEffect = if rc.isEurozone then 1.0
+      else Math.pow(prevForex.exchangeRate / Config.BaseExRate,
+                    1.0 - Config.OeErElasticity)
     val importedInterm = (0 until nSectors).map { s =>
-      sectorOutputs(s) * Config.OeImportContent(s) * erImportEffect * priceLevel
+      val realOutput = if priceLevel > 0 then sectorOutputs(s) / priceLevel
+                       else sectorOutputs(s)
+      realOutput * Config.OeImportContent(s) * erNetEffect
     }.toVector
     val totalImportedInterm = importedInterm.sum
 

src/main/scala/sfc/engine/Simulation.scala

@@ -28,8 +28,10 @@ object Sectors:
     val demandPull    = (demandMult - 1.0) * 0.15
     val costPush      = wageGrowth * 0.25
     // EUR: no exchange rate pass-through (single currency area)
-    val importPush    = if rc.isEurozone then 0.0
+    val rawImportPush = if rc.isEurozone then 0.0
                         else Math.max(0.0, exRateDeviation) * Config.ImportPropensity * 0.25
+    val importPush    = if Config.OeEnabled then Math.min(rawImportPush, Config.OeImportPushCap)
+                        else rawImportPush
     val techDeflation = autoRatio * 0.060 + hybridRatio * 0.018
     // Soft floor: beyond -1.5%/month, deflation passes through at 30% rate
     // (models downward price stickiness -- Bewley 1999, Schmitt-Grohe & Uribe 2016)