@agent-e/core 1.2.0 → 1.3.0

package/dist/index.mjs

@@ -84,9 +84,9 @@ var DEFAULT_TICK_CONFIG = {
 var Observer = class {
   constructor(tickConfig) {
     this.previousMetrics = null;
-    this.previousPrices = {};
+    this.previousPricesByCurrency = {};
     this.customMetricFns = {};
-    this.anchorBaseline = null;
+    this.anchorBaselineByCurrency = {};
     this.tickConfig = { ...DEFAULT_TICK_CONFIG, ...tickConfig };
   }
   registerCustomMetric(name, fn) {
@@ -94,23 +94,28 @@ var Observer = class {
   }
   compute(state, recentEvents) {
     const tick = state.tick;
-    const balances = Object.values(state.agentBalances);
     const roles = Object.values(state.agentRoles);
-    const totalAgents = balances.length;
-    let faucetVolume = 0;
-    let sinkVolume = 0;
+    const totalAgents = Object.keys(state.agentBalances).length;
+    let productionAmount = 0;
+    const faucetVolumeByCurrency = {};
+    const sinkVolumeByCurrency = {};
     const tradeEvents = [];
     const roleChangeEvents = [];
     let churnCount = 0;
+    const defaultCurrency = state.currencies[0] ?? "default";
     for (const e of recentEvents) {
+      const curr = e.currency ?? defaultCurrency;
       switch (e.type) {
         case "mint":
         case "spawn":
-          faucetVolume += e.amount ?? 0;
+          faucetVolumeByCurrency[curr] = (faucetVolumeByCurrency[curr] ?? 0) + (e.amount ?? 0);
           break;
         case "burn":
         case "consume":
-          sinkVolume += e.amount ?? 0;
+          sinkVolumeByCurrency[curr] = (sinkVolumeByCurrency[curr] ?? 0) + (e.amount ?? 0);
+          break;
+        case "produce":
+          productionAmount += e.amount ?? 1;
           break;
         case "trade":
           tradeEvents.push(e);
@@ -124,20 +129,68 @@ var Observer = class {
           break;
       }
     }
-    const totalSupply = balances.reduce((s, b) => s + b, 0);
+    const currencies = state.currencies;
+    const totalSupplyByCurrency = {};
+    const balancesByCurrency = {};
+    for (const [_agentId, balances] of Object.entries(state.agentBalances)) {
+      for (const [curr, bal] of Object.entries(balances)) {
+        totalSupplyByCurrency[curr] = (totalSupplyByCurrency[curr] ?? 0) + bal;
+        if (!balancesByCurrency[curr]) balancesByCurrency[curr] = [];
+        balancesByCurrency[curr].push(bal);
+      }
+    }
+    const netFlowByCurrency = {};
+    const tapSinkRatioByCurrency = {};
+    const inflationRateByCurrency = {};
+    const velocityByCurrency = {};
+    for (const curr of currencies) {
+      const faucet = faucetVolumeByCurrency[curr] ?? 0;
+      const sink = sinkVolumeByCurrency[curr] ?? 0;
+      netFlowByCurrency[curr] = faucet - sink;
+      tapSinkRatioByCurrency[curr] = sink > 0 ? faucet / sink : faucet > 0 ? Infinity : 1;
+      const prevSupply = this.previousMetrics?.totalSupplyByCurrency?.[curr] ?? totalSupplyByCurrency[curr] ?? 0;
+      const currSupply = totalSupplyByCurrency[curr] ?? 0;
+      inflationRateByCurrency[curr] = prevSupply > 0 ? (currSupply - prevSupply) / prevSupply : 0;
+      const currTrades = tradeEvents.filter((e) => (e.currency ?? defaultCurrency) === curr);
+      velocityByCurrency[curr] = currSupply > 0 ? currTrades.length / currSupply : 0;
+    }
+    const giniCoefficientByCurrency = {};
+    const medianBalanceByCurrency = {};
+    const meanBalanceByCurrency = {};
+    const top10PctShareByCurrency = {};
+    const meanMedianDivergenceByCurrency = {};
+    for (const curr of currencies) {
+      const bals = balancesByCurrency[curr] ?? [];
+      const sorted = [...bals].sort((a, b) => a - b);
+      const supply = totalSupplyByCurrency[curr] ?? 0;
+      const count = sorted.length;
+      const median = computeMedian(sorted);
+      const mean = count > 0 ? supply / count : 0;
+      const top10Idx = Math.floor(count * 0.9);
+      const top10Sum = sorted.slice(top10Idx).reduce((s, b) => s + b, 0);
+      giniCoefficientByCurrency[curr] = computeGini(sorted);
+      medianBalanceByCurrency[curr] = median;
+      meanBalanceByCurrency[curr] = mean;
+      top10PctShareByCurrency[curr] = supply > 0 ? top10Sum / supply : 0;
+      meanMedianDivergenceByCurrency[curr] = median > 0 ? Math.abs(mean - median) / median : 0;
+    }
+    const avgOf = (rec) => {
+      const vals = Object.values(rec);
+      return vals.length > 0 ? vals.reduce((s, v) => s + v, 0) / vals.length : 0;
+    };
+    const totalSupply = Object.values(totalSupplyByCurrency).reduce((s, v) => s + v, 0);
+    const faucetVolume = Object.values(faucetVolumeByCurrency).reduce((s, v) => s + v, 0);
+    const sinkVolume = Object.values(sinkVolumeByCurrency).reduce((s, v) => s + v, 0);
     const netFlow = faucetVolume - sinkVolume;
     const tapSinkRatio = sinkVolume > 0 ? faucetVolume / sinkVolume : faucetVolume > 0 ? Infinity : 1;
-    const prevSupply = this.previousMetrics?.totalSupply ?? totalSupply;
-    const inflationRate = prevSupply > 0 ? (totalSupply - prevSupply) / prevSupply : 0;
     const velocity = totalSupply > 0 ? tradeEvents.length / totalSupply : 0;
-    const sortedBalances = [...balances].sort((a, b) => a - b);
+    const prevTotalSupply = this.previousMetrics?.totalSupply ?? totalSupply;
+    const inflationRate = prevTotalSupply > 0 ? (totalSupply - prevTotalSupply) / prevTotalSupply : 0;
+    const giniCoefficient = avgOf(giniCoefficientByCurrency);
+    const medianBalance = avgOf(medianBalanceByCurrency);
     const meanBalance = totalAgents > 0 ? totalSupply / totalAgents : 0;
-    const medianBalance = computeMedian(sortedBalances);
-    const top10Idx = Math.floor(totalAgents * 0.9);
-    const top10Sum = sortedBalances.slice(top10Idx).reduce((s, b) => s + b, 0);
-    const top10PctShare = totalSupply > 0 ? top10Sum / totalSupply : 0;
-    const giniCoefficient = computeGini(sortedBalances);
-    const meanMedianDivergence = medianBalance > 0 ? Math.abs(meanBalance - medianBalance) / medianBalance : 0;
+    const top10PctShare = avgOf(top10PctShareByCurrency);
+    const meanMedianDivergence = avgOf(meanMedianDivergenceByCurrency);
     const populationByRole = {};
     const roleShares = {};
     for (const role of roles) {
@@ -152,15 +205,25 @@ var Observer = class {
       churnByRole[role] = (churnByRole[role] ?? 0) + 1;
     }
     const churnRate = churnCount / Math.max(1, totalAgents);
-    const prices = { ...state.marketPrices };
-    const priceVolatility = {};
-    for (const [resource, price] of Object.entries(prices)) {
-      const prev = this.previousPrices[resource] ?? price;
-      priceVolatility[resource] = prev > 0 ? Math.abs(price - prev) / prev : 0;
-    }
-    this.previousPrices = { ...prices };
-    const priceValues = Object.values(prices);
-    const priceIndex = priceValues.length > 0 ? priceValues.reduce((s, p) => s + p, 0) / priceValues.length : 0;
+    const pricesByCurrency = {};
+    const priceVolatilityByCurrency = {};
+    const priceIndexByCurrency = {};
+    for (const [curr, resourcePrices] of Object.entries(state.marketPrices)) {
+      pricesByCurrency[curr] = { ...resourcePrices };
+      const pricePrev = this.previousPricesByCurrency?.[curr] ?? {};
+      const volMap = {};
+      for (const [resource, price] of Object.entries(resourcePrices)) {
+        const prev = pricePrev[resource] ?? price;
+        volMap[resource] = prev > 0 ? Math.abs(price - prev) / prev : 0;
+      }
+      priceVolatilityByCurrency[curr] = volMap;
+      const pVals = Object.values(resourcePrices);
+      priceIndexByCurrency[curr] = pVals.length > 0 ? pVals.reduce((s, p) => s + p, 0) / pVals.length : 0;
+    }
+    this.previousPricesByCurrency = JSON.parse(JSON.stringify(pricesByCurrency));
+    const prices = pricesByCurrency[defaultCurrency] ?? {};
+    const priceVolatility = priceVolatilityByCurrency[defaultCurrency] ?? {};
+    const priceIndex = priceIndexByCurrency[defaultCurrency] ?? 0;
     const supplyByResource = {};
     for (const inv of Object.values(state.agentInventories)) {
       for (const [resource, qty] of Object.entries(inv)) {
@@ -185,70 +248,92 @@ var Observer = class {
         pinchPoints[resource] = "optimal";
       }
     }
-    const productionIndex = recentEvents.filter((e) => e.type === "produce").reduce((s, e) => s + (e.amount ?? 1), 0);
+    const productionIndex = productionAmount;
     const maxPossibleProduction = productionIndex + sinkVolume;
     const capacityUsage = maxPossibleProduction > 0 ? productionIndex / maxPossibleProduction : 0;
     const satisfactions = Object.values(state.agentSatisfaction ?? {});
     const avgSatisfaction = satisfactions.length > 0 ? satisfactions.reduce((s, v) => s + v, 0) / satisfactions.length : 80;
     const blockedAgentCount = satisfactions.filter((s) => s < 20).length;
     const timeToValue = totalAgents > 0 ? blockedAgentCount / totalAgents * 100 : 0;
-    const poolSizes = { ...state.poolSizes ?? {} };
-    if (!this.anchorBaseline && tick === 1 && totalSupply > 0) {
-      this.anchorBaseline = {
-        currencyPerPeriod: totalSupply / Math.max(1, totalAgents),
-        itemsPerCurrency: priceIndex > 0 ? 1 / priceIndex : 0
-      };
+    const poolSizesByCurrency = {};
+    const poolSizesAggregate = {};
+    if (state.poolSizes) {
+      for (const [pool, currencyAmounts] of Object.entries(state.poolSizes)) {
+        poolSizesByCurrency[pool] = { ...currencyAmounts };
+        poolSizesAggregate[pool] = Object.values(currencyAmounts).reduce((s, v) => s + v, 0);
+      }
     }
-    let anchorRatioDrift = 0;
-    if (this.anchorBaseline && totalAgents > 0) {
-      const currentCurrencyPerPeriod = totalSupply / totalAgents;
-      anchorRatioDrift = this.anchorBaseline.currencyPerPeriod > 0 ? (currentCurrencyPerPeriod - this.anchorBaseline.currencyPerPeriod) / this.anchorBaseline.currencyPerPeriod : 0;
-    }
-    let arbitrageIndex = 0;
-    const priceKeys = Object.keys(prices).filter((k) => prices[k] > 0);
-    if (priceKeys.length >= 2) {
-      let pairCount = 0;
-      let totalDivergence = 0;
-      for (let i = 0; i < priceKeys.length; i++) {
-        for (let j = i + 1; j < priceKeys.length; j++) {
-          const pA = prices[priceKeys[i]];
-          const pB = prices[priceKeys[j]];
-          let ratio = pA / pB;
-          ratio = Math.max(1e-3, Math.min(1e3, ratio));
-          totalDivergence += Math.abs(Math.log(ratio));
-          pairCount++;
+    const anchorRatioDriftByCurrency = {};
+    if (tick === 1) {
+      for (const curr of currencies) {
+        const supply = totalSupplyByCurrency[curr] ?? 0;
+        if (supply > 0) {
+          this.anchorBaselineByCurrency[curr] = {
+            currencyPerPeriod: supply / Math.max(1, totalAgents),
+            itemsPerCurrency: (priceIndexByCurrency[curr] ?? 0) > 0 ? 1 / priceIndexByCurrency[curr] : 0
+          };
         }
       }
-      arbitrageIndex = pairCount > 0 ? Math.min(1, totalDivergence / pairCount) : 0;
     }
+    for (const curr of currencies) {
+      const baseline = this.anchorBaselineByCurrency[curr];
+      if (baseline && totalAgents > 0) {
+        const currentCPP = (totalSupplyByCurrency[curr] ?? 0) / totalAgents;
+        anchorRatioDriftByCurrency[curr] = baseline.currencyPerPeriod > 0 ? (currentCPP - baseline.currencyPerPeriod) / baseline.currencyPerPeriod : 0;
+      } else {
+        anchorRatioDriftByCurrency[curr] = 0;
+      }
+    }
+    const anchorRatioDrift = avgOf(anchorRatioDriftByCurrency);
+    const arbitrageIndexByCurrency = {};
+    for (const curr of currencies) {
+      const cPrices = pricesByCurrency[curr] ?? {};
+      const priceKeys = Object.keys(cPrices).filter((k) => cPrices[k] > 0);
+      if (priceKeys.length >= 2) {
+        let pairCount = 0;
+        let totalDivergence = 0;
+        for (let i = 0; i < priceKeys.length; i++) {
+          for (let j = i + 1; j < priceKeys.length; j++) {
+            const pA = cPrices[priceKeys[i]];
+            const pB = cPrices[priceKeys[j]];
+            let ratio = pA / pB;
+            ratio = Math.max(1e-3, Math.min(1e3, ratio));
+            totalDivergence += Math.abs(Math.log(ratio));
+            pairCount++;
+          }
+        }
+        arbitrageIndexByCurrency[curr] = pairCount > 0 ? Math.min(1, totalDivergence / pairCount) : 0;
+      } else {
+        arbitrageIndexByCurrency[curr] = 0;
+      }
+    }
+    const arbitrageIndex = avgOf(arbitrageIndexByCurrency);
     const contentDropEvents = recentEvents.filter(
       (e) => e.metadata?.["contentDrop"] === true
     );
     const contentDropAge = contentDropEvents.length > 0 ? tick - Math.max(...contentDropEvents.map((e) => e.timestamp)) : (this.previousMetrics?.contentDropAge ?? 0) + 1;
-    let giftTrades = 0;
-    if (tradeEvents.length > 0) {
-      for (const e of tradeEvents) {
-        const marketPrice = prices[e.resource ?? ""] ?? 0;
+    const giftTradeRatioByCurrency = {};
+    const disposalTradeRatioByCurrency = {};
+    for (const curr of currencies) {
+      const currTrades = tradeEvents.filter((e) => (e.currency ?? defaultCurrency) === curr);
+      const cPrices = pricesByCurrency[curr] ?? {};
+      let gifts = 0;
+      let disposals = 0;
+      for (const e of currTrades) {
+        const marketPrice = cPrices[e.resource ?? ""] ?? 0;
         const tradePrice = e.price ?? 0;
-        if (tradePrice === 0 || marketPrice > 0 && tradePrice < marketPrice * 0.3) {
-          giftTrades++;
-        }
-      }
-    }
-    const giftTradeRatio = tradeEvents.length > 0 ? giftTrades / tradeEvents.length : 0;
-    let disposalTrades = 0;
-    if (tradeEvents.length > 0) {
-      for (const e of tradeEvents) {
+        if (tradePrice === 0 || marketPrice > 0 && tradePrice < marketPrice * 0.3) gifts++;
         if (e.from && e.resource) {
           const sellerInv = state.agentInventories[e.from]?.[e.resource] ?? 0;
           const avgInv = (supplyByResource[e.resource] ?? 0) / Math.max(1, totalAgents);
-          if (sellerInv > avgInv * 3) {
-            disposalTrades++;
-          }
+          if (sellerInv > avgInv * 3) disposals++;
         }
       }
+      giftTradeRatioByCurrency[curr] = currTrades.length > 0 ? gifts / currTrades.length : 0;
+      disposalTradeRatioByCurrency[curr] = currTrades.length > 0 ? disposals / currTrades.length : 0;
     }
-    const disposalTradeRatio = tradeEvents.length > 0 ? disposalTrades / tradeEvents.length : 0;
+    const giftTradeRatio = avgOf(giftTradeRatioByCurrency);
+    const disposalTradeRatio = avgOf(disposalTradeRatioByCurrency);
     const custom = {};
     for (const [name, fn] of Object.entries(this.customMetricFns)) {
       try {
@@ -260,10 +345,57 @@ var Observer = class {
     const metrics = {
       tick,
       timestamp: Date.now(),
+      currencies,
+      // Per-currency
+      totalSupplyByCurrency,
+      netFlowByCurrency,
+      velocityByCurrency,
+      inflationRateByCurrency,
+      faucetVolumeByCurrency,
+      sinkVolumeByCurrency,
+      tapSinkRatioByCurrency,
+      anchorRatioDriftByCurrency,
+      giniCoefficientByCurrency,
+      medianBalanceByCurrency,
+      meanBalanceByCurrency,
+      top10PctShareByCurrency,
+      meanMedianDivergenceByCurrency,
+      priceIndexByCurrency,
+      pricesByCurrency,
+      priceVolatilityByCurrency,
+      poolSizesByCurrency,
+      extractionRatioByCurrency: {},
+      newUserDependencyByCurrency: {},
+      currencyInsulationByCurrency: {},
+      arbitrageIndexByCurrency,
+      giftTradeRatioByCurrency,
+      disposalTradeRatioByCurrency,
+      // Aggregates
       totalSupply,
       netFlow,
       velocity,
       inflationRate,
+      faucetVolume,
+      sinkVolume,
+      tapSinkRatio,
+      anchorRatioDrift,
+      giniCoefficient,
+      medianBalance,
+      meanBalance,
+      top10PctShare,
+      meanMedianDivergence,
+      priceIndex,
+      prices,
+      priceVolatility,
+      poolSizes: poolSizesAggregate,
+      extractionRatio: NaN,
+      newUserDependency: NaN,
+      smokeTestRatio: NaN,
+      currencyInsulation: NaN,
+      arbitrageIndex,
+      giftTradeRatio,
+      disposalTradeRatio,
+      // Unchanged
       populationByRole,
       roleShares,
       totalAgents,
@@ -271,38 +403,18 @@ var Observer = class {
       churnByRole,
       personaDistribution: {},
       // populated by PersonaTracker
-      giniCoefficient,
-      medianBalance,
-      meanBalance,
-      top10PctShare,
-      meanMedianDivergence,
-      priceIndex,
       productionIndex,
       capacityUsage,
-      prices,
-      priceVolatility,
       supplyByResource,
       demandSignals,
       pinchPoints,
       avgSatisfaction,
       blockedAgentCount,
       timeToValue,
-      faucetVolume,
-      sinkVolume,
-      tapSinkRatio,
-      poolSizes,
-      anchorRatioDrift,
-      extractionRatio: NaN,
-      newUserDependency: NaN,
-      smokeTestRatio: NaN,
-      currencyInsulation: NaN,
       sharkToothPeaks: this.previousMetrics?.sharkToothPeaks ?? [],
       sharkToothValleys: this.previousMetrics?.sharkToothValleys ?? [],
       eventCompletionRate: NaN,
-      arbitrageIndex,
       contentDropAge,
-      giftTradeRatio,
-      disposalTradeRatio,
       custom
     };
     this.previousMetrics = metrics;
@@ -376,48 +488,75 @@ function emptyMetrics(tick = 0) {
   return {
     tick,
     timestamp: Date.now(),
+    currencies: [],
+    // Per-currency
+    totalSupplyByCurrency: {},
+    netFlowByCurrency: {},
+    velocityByCurrency: {},
+    inflationRateByCurrency: {},
+    faucetVolumeByCurrency: {},
+    sinkVolumeByCurrency: {},
+    tapSinkRatioByCurrency: {},
+    anchorRatioDriftByCurrency: {},
+    giniCoefficientByCurrency: {},
+    medianBalanceByCurrency: {},
+    meanBalanceByCurrency: {},
+    top10PctShareByCurrency: {},
+    meanMedianDivergenceByCurrency: {},
+    priceIndexByCurrency: {},
+    pricesByCurrency: {},
+    priceVolatilityByCurrency: {},
+    poolSizesByCurrency: {},
+    extractionRatioByCurrency: {},
+    newUserDependencyByCurrency: {},
+    currencyInsulationByCurrency: {},
+    arbitrageIndexByCurrency: {},
+    giftTradeRatioByCurrency: {},
+    disposalTradeRatioByCurrency: {},
+    // Aggregates
     totalSupply: 0,
     netFlow: 0,
     velocity: 0,
     inflationRate: 0,
-    populationByRole: {},
-    roleShares: {},
-    totalAgents: 0,
-    churnRate: 0,
-    churnByRole: {},
-    personaDistribution: {},
+    faucetVolume: 0,
+    sinkVolume: 0,
+    tapSinkRatio: 1,
+    anchorRatioDrift: 0,
     giniCoefficient: 0,
     medianBalance: 0,
     meanBalance: 0,
     top10PctShare: 0,
     meanMedianDivergence: 0,
     priceIndex: 0,
-    productionIndex: 0,
-    capacityUsage: 0,
     prices: {},
     priceVolatility: {},
+    poolSizes: {},
+    extractionRatio: NaN,
+    newUserDependency: NaN,
+    smokeTestRatio: NaN,
+    currencyInsulation: NaN,
+    arbitrageIndex: 0,
+    giftTradeRatio: 0,
+    disposalTradeRatio: 0,
+    // Unchanged
+    populationByRole: {},
+    roleShares: {},
+    totalAgents: 0,
+    churnRate: 0,
+    churnByRole: {},
+    personaDistribution: {},
+    productionIndex: 0,
+    capacityUsage: 0,
     supplyByResource: {},
     demandSignals: {},
     pinchPoints: {},
     avgSatisfaction: 100,
     blockedAgentCount: 0,
     timeToValue: 0,
-    faucetVolume: 0,
-    sinkVolume: 0,
-    tapSinkRatio: 1,
-    poolSizes: {},
-    anchorRatioDrift: 0,
-    extractionRatio: NaN,
-    newUserDependency: NaN,
-    smokeTestRatio: NaN,
-    currencyInsulation: NaN,
     sharkToothPeaks: [],
     sharkToothValleys: [],
     eventCompletionRate: NaN,
-    arbitrageIndex: 0,
     contentDropAge: 0,
-    giftTradeRatio: 0,
-    disposalTradeRatio: 0,
     custom: {}
   };
 }
@@ -883,38 +1022,44 @@ var P12_OnePrimaryFaucet = {
   id: "P12",
   name: "One Primary Faucet",
   category: "currency",
-  description: "Multiple independent currency sources (gathering + crafting + quests) each creating gold causes uncontrolled inflation. One clear primary faucet makes the economy predictable and auditable.",
+  description: "Multiple independent currency sources (gathering + production + quests) each creating currency causes uncontrolled inflation. One clear primary faucet makes the economy predictable and auditable.",
   check(metrics, thresholds) {
-    const { netFlow, faucetVolume, sinkVolume } = metrics;
-    if (netFlow > thresholds.netFlowWarnThreshold) {
-      return {
-        violated: true,
-        severity: 5,
-        evidence: { netFlow, faucetVolume, sinkVolume },
-        suggestedAction: {
-          parameter: "productionCost",
-          direction: "increase",
-          magnitude: 0.15,
-          reasoning: `Net flow +${netFlow.toFixed(1)} g/t. Inflationary. Increase crafting cost (primary sink) to balance faucet output.`
-        },
-        confidence: 0.8,
-        estimatedLag: 8
-      };
-    }
-    if (netFlow < -thresholds.netFlowWarnThreshold) {
-      return {
-        violated: true,
-        severity: 4,
-        evidence: { netFlow, faucetVolume, sinkVolume },
-        suggestedAction: {
-          parameter: "productionCost",
-          direction: "decrease",
-          magnitude: 0.15,
-          reasoning: `Net flow ${netFlow.toFixed(1)} g/t. Deflationary. Decrease crafting cost to ease sink pressure.`
-        },
-        confidence: 0.8,
-        estimatedLag: 8
-      };
+    for (const curr of metrics.currencies) {
+      const netFlow = metrics.netFlowByCurrency[curr] ?? 0;
+      const faucetVolume = metrics.faucetVolumeByCurrency[curr] ?? 0;
+      const sinkVolume = metrics.sinkVolumeByCurrency[curr] ?? 0;
+      if (netFlow > thresholds.netFlowWarnThreshold) {
+        return {
+          violated: true,
+          severity: 5,
+          evidence: { currency: curr, netFlow, faucetVolume, sinkVolume },
+          suggestedAction: {
+            parameter: "productionCost",
+            direction: "increase",
+            currency: curr,
+            magnitude: 0.15,
+            reasoning: `[${curr}] Net flow +${netFlow.toFixed(1)}/tick. Inflationary. Increase production cost (primary sink) to balance faucet output.`
+          },
+          confidence: 0.8,
+          estimatedLag: 8
+        };
+      }
+      if (netFlow < -thresholds.netFlowWarnThreshold) {
+        return {
+          violated: true,
+          severity: 4,
+          evidence: { currency: curr, netFlow, faucetVolume, sinkVolume },
+          suggestedAction: {
+            parameter: "productionCost",
+            direction: "decrease",
+            currency: curr,
+            magnitude: 0.15,
+            reasoning: `[${curr}] Net flow ${netFlow.toFixed(1)}/tick. Deflationary. Decrease production cost to ease sink pressure.`
+          },
+          confidence: 0.8,
+          estimatedLag: 8
+        };
+      }
     }
     return { violated: false };
   }
@@ -925,28 +1070,30 @@ var P13_PotsAreZeroSumAndSelfRegulate = {
   category: "currency",
   description: "Competitive pot math: winRate \xD7 multiplier > (1 - houseCut) drains the pot. At 65% win rate, multiplier must be \u2264 1.38. We use 1.5 for slight surplus buffer.",
   check(metrics, thresholds) {
-    const { poolSizes, populationByRole } = metrics;
-    const totalAgents = metrics.totalAgents;
+    const { populationByRole } = metrics;
     const roleEntries = Object.entries(populationByRole).sort((a, b) => b[1] - a[1]);
-    const dominantRole = roleEntries[0]?.[0];
     const dominantCount = roleEntries[0]?.[1] ?? 0;
-    for (const [poolName, poolSize] of Object.entries(poolSizes)) {
-      if (dominantCount > 5 && poolSize < 50) {
-        const { poolWinRate, poolHouseCut } = thresholds;
-        const maxSustainableMultiplier = (1 - poolHouseCut) / poolWinRate;
-        return {
-          violated: true,
-          severity: 7,
-          evidence: { pool: poolName, poolSize, participants: dominantCount, maxSustainableMultiplier },
-          suggestedAction: {
-            parameter: "rewardRate",
-            direction: "decrease",
-            magnitude: 0.15,
-            reasoning: `${poolName} pool at ${poolSize.toFixed(0)} currency with ${dominantCount} active participants. Sustainable multiplier \u2264 ${maxSustainableMultiplier.toFixed(2)}. Reduce reward multiplier to prevent pool drain.`
-          },
-          confidence: 0.85,
-          estimatedLag: 3
-        };
+    for (const [poolName, currencyAmounts] of Object.entries(metrics.poolSizesByCurrency)) {
+      for (const curr of metrics.currencies) {
+        const poolSize = currencyAmounts[curr] ?? 0;
+        if (dominantCount > 5 && poolSize < 50) {
+          const { poolWinRate, poolHouseCut } = thresholds;
+          const maxSustainableMultiplier = (1 - poolHouseCut) / poolWinRate;
+          return {
+            violated: true,
+            severity: 7,
+            evidence: { currency: curr, pool: poolName, poolSize, participants: dominantCount, maxSustainableMultiplier },
+            suggestedAction: {
+              parameter: "rewardRate",
+              direction: "decrease",
+              currency: curr,
+              magnitude: 0.15,
+              reasoning: `[${curr}] ${poolName} pool at ${poolSize.toFixed(0)} currency with ${dominantCount} active participants. Sustainable multiplier \u2264 ${maxSustainableMultiplier.toFixed(2)}. Reduce reward multiplier to prevent pool drain.`
+            },
+            confidence: 0.85,
+            estimatedLag: 3
+          };
+        }
       }
     }
     return { violated: false };
@@ -958,22 +1105,27 @@ var P14_TrackActualInjection = {
   category: "currency",
   description: 'Counting resource gathering as "currency injected" is misleading. Currency enters through faucet mechanisms (spawning, rewards). Fake metrics break every downstream decision.',
   check(metrics, _thresholds) {
-    const { faucetVolume, netFlow, totalSupply } = metrics;
-    const supplyGrowthRate = Math.abs(netFlow) / Math.max(1, totalSupply);
-    if (supplyGrowthRate > 0.1) {
-      return {
-        violated: true,
-        severity: 4,
-        evidence: { faucetVolume, netFlow, supplyGrowthRate },
-        suggestedAction: {
-          parameter: "yieldRate",
-          direction: "decrease",
-          magnitude: 0.1,
-          reasoning: `Supply growing at ${(supplyGrowthRate * 100).toFixed(1)}%/tick. Verify gold injection tracking. Resources should not create gold directly.`
-        },
-        confidence: 0.55,
-        estimatedLag: 5
-      };
+    for (const curr of metrics.currencies) {
+      const faucetVolume = metrics.faucetVolumeByCurrency[curr] ?? 0;
+      const netFlow = metrics.netFlowByCurrency[curr] ?? 0;
+      const totalSupply = metrics.totalSupplyByCurrency[curr] ?? 0;
+      const supplyGrowthRate = Math.abs(netFlow) / Math.max(1, totalSupply);
+      if (supplyGrowthRate > 0.1) {
+        return {
+          violated: true,
+          severity: 4,
+          evidence: { currency: curr, faucetVolume, netFlow, supplyGrowthRate },
+          suggestedAction: {
+            parameter: "yieldRate",
+            direction: "decrease",
+            currency: curr,
+            magnitude: 0.1,
+            reasoning: `[${curr}] Supply growing at ${(supplyGrowthRate * 100).toFixed(1)}%/tick. Verify currency injection tracking. Resources should not create currency directly.`
+          },
+          confidence: 0.55,
+          estimatedLag: 5
+        };
+      }
     }
     return { violated: false };
   }
@@ -982,26 +1134,30 @@ var P15_PoolsNeedCapAndDecay = {
   id: "P15",
   name: "Pools Need Cap + Decay",
   category: "currency",
-  description: "Any pool (bank, reward pool) without a cap accumulates infinitely. Bank pool at 42% of gold supply means 42% of the economy is frozen. Cap at 5%, decay at 2%/tick.",
+  description: "Any pool (bank, reward pool) without a cap accumulates infinitely. A pool at 42% of total supply means 42% of the economy is frozen. Cap at 5%, decay at 2%/tick.",
   check(metrics, thresholds) {
-    const { poolSizes, totalSupply } = metrics;
     const { poolCapPercent } = thresholds;
-    for (const [pool, size] of Object.entries(poolSizes)) {
-      const shareOfSupply = size / Math.max(1, totalSupply);
-      if (shareOfSupply > poolCapPercent * 2) {
-        return {
-          violated: true,
-          severity: 6,
-          evidence: { pool, size, shareOfSupply, cap: poolCapPercent },
-          suggestedAction: {
-            parameter: "transactionFee",
-            direction: "decrease",
-            magnitude: 0.1,
-            reasoning: `${pool} pool at ${(shareOfSupply * 100).toFixed(1)}% of supply (cap: ${(poolCapPercent * 100).toFixed(0)}%). Gold frozen. Lower fees to encourage circulation over accumulation.`
-          },
-          confidence: 0.85,
-          estimatedLag: 5
-        };
+    for (const [pool, currencyAmounts] of Object.entries(metrics.poolSizesByCurrency)) {
+      for (const curr of metrics.currencies) {
+        const size = currencyAmounts[curr] ?? 0;
+        const totalSupply = metrics.totalSupplyByCurrency[curr] ?? 0;
+        const shareOfSupply = size / Math.max(1, totalSupply);
+        if (shareOfSupply > poolCapPercent * 2) {
+          return {
+            violated: true,
+            severity: 6,
+            evidence: { currency: curr, pool, size, shareOfSupply, cap: poolCapPercent },
+            suggestedAction: {
+              parameter: "transactionFee",
+              direction: "decrease",
+              currency: curr,
+              magnitude: 0.1,
+              reasoning: `[${curr}] ${pool} pool at ${(shareOfSupply * 100).toFixed(1)}% of supply (cap: ${(poolCapPercent * 100).toFixed(0)}%). Currency frozen. Lower fees to encourage circulation over accumulation.`
+            },
+            confidence: 0.85,
+            estimatedLag: 5
+          };
+        }
       }
     }
     return { violated: false };
@@ -1013,23 +1169,27 @@ var P16_WithdrawalPenaltyScales = {
   category: "currency",
   description: "A 50-tick lock period with a penalty calculated as /100 means agents can exit after 1 tick and keep 99% of accrued yield. Penalty must scale linearly: (1 - ticksStaked/lockDuration) \xD7 yield.",
   check(metrics, _thresholds) {
-    const { poolSizes, totalSupply } = metrics;
-    const stakedEstimate = totalSupply * 0.15;
-    for (const [poolName, poolSize] of Object.entries(poolSizes)) {
-      if (poolSize < 10 && stakedEstimate > 100) {
-        return {
-          violated: true,
-          severity: 3,
-          evidence: { pool: poolName, poolSize, estimatedStaked: stakedEstimate },
-          suggestedAction: {
-            parameter: "transactionFee",
-            direction: "increase",
-            magnitude: 0.05,
-            reasoning: `${poolName} pool depleted while significant currency should be locked. Early withdrawals may be draining the pool. Ensure withdrawal penalty scales with lock duration.`
-          },
-          confidence: 0.45,
-          estimatedLag: 10
-        };
+    for (const [poolName, currencyAmounts] of Object.entries(metrics.poolSizesByCurrency)) {
+      for (const curr of metrics.currencies) {
+        const poolSize = currencyAmounts[curr] ?? 0;
+        const totalSupply = metrics.totalSupplyByCurrency[curr] ?? 0;
+        const stakedEstimate = totalSupply * 0.15;
+        if (poolSize < 10 && stakedEstimate > 100) {
+          return {
+            violated: true,
+            severity: 3,
+            evidence: { currency: curr, pool: poolName, poolSize, estimatedStaked: stakedEstimate },
+            suggestedAction: {
+              parameter: "transactionFee",
+              direction: "increase",
+              currency: curr,
+              magnitude: 0.05,
+              reasoning: `[${curr}] ${poolName} pool depleted while significant currency should be locked. Early withdrawals may be draining the pool. Ensure withdrawal penalty scales with lock duration.`
+            },
+            confidence: 0.45,
+            estimatedLag: 10
+          };
+        }
       }
     }
     return { violated: false };
@@ -1041,22 +1201,27 @@ var P32_VelocityAboveSupply = {
   category: "currency",
   description: "Low transactions despite adequate supply means liquidity is trapped. High supply with low velocity = stagnation, not abundance.",
   check(metrics, _thresholds) {
-    const { velocity, totalSupply, supplyByResource } = metrics;
+    const { supplyByResource } = metrics;
     const totalResources = Object.values(supplyByResource).reduce((s, v) => s + v, 0);
-    if (velocity < 3 && totalSupply > 100 && totalResources > 20) {
-      return {
-        violated: true,
-        severity: 4,
-        evidence: { velocity, totalSupply, totalResources },
-        suggestedAction: {
-          parameter: "transactionFee",
-          direction: "decrease",
-          magnitude: 0.2,
-          reasoning: `Velocity ${velocity}/t with ${totalResources} resources in system. Economy stagnant despite available supply. Lower trading friction.`
-        },
-        confidence: 0.75,
-        estimatedLag: 5
-      };
+    for (const curr of metrics.currencies) {
+      const velocity = metrics.velocityByCurrency[curr] ?? 0;
+      const totalSupply = metrics.totalSupplyByCurrency[curr] ?? 0;
+      if (velocity < 3 && totalSupply > 100 && totalResources > 20) {
+        return {
+          violated: true,
+          severity: 4,
+          evidence: { currency: curr, velocity, totalSupply, totalResources },
+          suggestedAction: {
+            parameter: "transactionFee",
+            direction: "decrease",
+            currency: curr,
+            magnitude: 0.2,
+            reasoning: `[${curr}] Velocity ${velocity}/t with ${totalResources} resources in system. Economy stagnant despite available supply. Lower trading friction.`
+          },
+          confidence: 0.75,
+          estimatedLag: 5
+        };
+      }
     }
     return { violated: false };
   }
@@ -1067,32 +1232,38 @@ var P58_NoNaturalNumeraire = {
   category: "currency",
   description: "No single commodity naturally stabilizes as currency in barter-heavy economies. Multiple items rotate as de facto units of account, but none locks in. If a num\xE9raire is needed, design and enforce it \u2014 emergence alone will not produce one.",
   check(metrics, _thresholds) {
-    const { prices, velocity, totalSupply } = metrics;
-    const priceValues = Object.values(prices).filter((p) => p > 0);
-    if (priceValues.length < 3) return { violated: false };
-    const mean = priceValues.reduce((s, p) => s + p, 0) / priceValues.length;
-    const coeffOfVariation = mean > 0 ? Math.sqrt(
-      priceValues.reduce((s, p) => s + (p - mean) ** 2, 0) / priceValues.length
-    ) / mean : 0;
-    if (coeffOfVariation < 0.25 && velocity > 5 && totalSupply > 100) {
-      return {
-        violated: true,
-        severity: 3,
-        evidence: {
-          coeffOfVariation,
-          velocity,
-          numResources: priceValues.length,
-          meanPrice: mean
-        },
-        suggestedAction: {
-          parameter: "productionCost",
-          direction: "increase",
-          magnitude: 0.1,
-          reasoning: `Price coefficient of variation ${coeffOfVariation.toFixed(2)} with velocity ${velocity.toFixed(1)}. All items priced similarly in an active economy \u2014 no natural num\xE9raire emerging. If a designated currency exists, increase its sink demand to differentiate it.`
-        },
-        confidence: 0.5,
-        estimatedLag: 20
-      };
+    for (const curr of metrics.currencies) {
+      const currPrices = metrics.pricesByCurrency[curr] ?? {};
+      const velocity = metrics.velocityByCurrency[curr] ?? 0;
+      const totalSupply = metrics.totalSupplyByCurrency[curr] ?? 0;
+      const priceValues = Object.values(currPrices).filter((p) => p > 0);
+      if (priceValues.length < 3) continue;
+      const mean = priceValues.reduce((s, p) => s + p, 0) / priceValues.length;
+      const coeffOfVariation = mean > 0 ? Math.sqrt(
+        priceValues.reduce((s, p) => s + (p - mean) ** 2, 0) / priceValues.length
+      ) / mean : 0;
+      if (coeffOfVariation < 0.25 && velocity > 5 && totalSupply > 100) {
+        return {
+          violated: true,
+          severity: 3,
+          evidence: {
+            currency: curr,
+            coeffOfVariation,
+            velocity,
+            numResources: priceValues.length,
+            meanPrice: mean
+          },
+          suggestedAction: {
+            parameter: "productionCost",
+            direction: "increase",
+            currency: curr,
+            magnitude: 0.1,
+            reasoning: `[${curr}] Price coefficient of variation ${coeffOfVariation.toFixed(2)} with velocity ${velocity.toFixed(1)}. All items priced similarly in an active economy \u2014 no natural num\xE9raire emerging. If a designated currency exists, increase its sink demand to differentiate it.`
+          },
+          confidence: 0.5,
+          estimatedLag: 20
+        };
+      }
     }
     return { violated: false };
   }
@@ -1139,25 +1310,22 @@ var P18_FirstProducerNeedsStartingInventory = {
   description: "A producer with 0 resources and 0 currency must sell nothing to get currency before they can buy raw materials. This creates a chicken-and-egg freeze. Starting inventory (2 goods + 4 raw materials + 40 currency) breaks the deadlock.",
   check(metrics, _thresholds) {
     if (metrics.tick > 20) return { violated: false };
+    const hasAgents = metrics.totalAgents > 0;
     for (const [resource, supply] of Object.entries(metrics.supplyByResource)) {
-      if (supply === 0) {
-        for (const [role, population] of Object.entries(metrics.populationByRole)) {
-          if (population > 0) {
-            return {
-              violated: true,
-              severity: 8,
-              evidence: { tick: metrics.tick, resource, supply, role, population },
-              suggestedAction: {
-                parameter: "productionCost",
-                direction: "decrease",
-                magnitude: 0.5,
-                reasoning: `Bootstrap failure: ${role} exists but ${resource} supply is 0 on tick 1-20. Drastically reduce production cost to allow immediate output.`
-              },
-              confidence: 0.9,
-              estimatedLag: 2
-            };
-          }
-        }
+      if (supply === 0 && hasAgents) {
+        return {
+          violated: true,
+          severity: 8,
+          evidence: { tick: metrics.tick, resource, supply, totalAgents: metrics.totalAgents },
+          suggestedAction: {
+            parameter: "productionCost",
+            direction: "decrease",
+            magnitude: 0.5,
+            reasoning: `Bootstrap failure: ${resource} supply is 0 at tick ${metrics.tick} with ${metrics.totalAgents} agents. Drastically reduce production cost to allow immediate output.`
+          },
+          confidence: 0.9,
+          estimatedLag: 2
+        };
       }
     }
     return { violated: false };
@@ -1783,26 +1951,33 @@ var P42_TheMedianPrinciple = {
   category: "statistical",
   description: "When (mean - median) / median > 0.3, mean is a lie. A few high-balance agents raise the mean while most agents have low balances. Always balance to median when divergence exceeds 30%.",
   check(metrics, thresholds) {
-    const { meanMedianDivergence, giniCoefficient } = metrics;
-    if (meanMedianDivergence > thresholds.meanMedianDivergenceMax) {
-      return {
-        violated: true,
-        severity: 5,
-        evidence: {
-          meanMedianDivergence,
-          giniCoefficient,
-          meanBalance: metrics.meanBalance,
-          medianBalance: metrics.medianBalance
-        },
-        suggestedAction: {
-          parameter: "transactionFee",
-          direction: "increase",
-          magnitude: 0.15,
-          reasoning: `Mean/median divergence ${(meanMedianDivergence * 100).toFixed(0)}% (threshold: ${(thresholds.meanMedianDivergenceMax * 100).toFixed(0)}%). Economy has outliers skewing metrics. Use median for decisions. Raise auction fees to redistribute wealth.`
-        },
-        confidence: 0.85,
-        estimatedLag: 15
-      };
+    for (const curr of metrics.currencies) {
+      const meanMedianDivergence = metrics.meanMedianDivergenceByCurrency[curr] ?? 0;
+      const giniCoefficient = metrics.giniCoefficientByCurrency[curr] ?? 0;
+      const meanBalance = metrics.meanBalanceByCurrency[curr] ?? 0;
+      const medianBalance = metrics.medianBalanceByCurrency[curr] ?? 0;
+      if (meanMedianDivergence > thresholds.meanMedianDivergenceMax) {
+        return {
+          violated: true,
+          severity: 5,
+          evidence: {
+            currency: curr,
+            meanMedianDivergence,
+            giniCoefficient,
+            meanBalance,
+            medianBalance
+          },
+          suggestedAction: {
+            parameter: "transactionFee",
+            direction: "increase",
+            currency: curr,
+            magnitude: 0.15,
+            reasoning: `[${curr}] Mean/median divergence ${(meanMedianDivergence * 100).toFixed(0)}% (threshold: ${(thresholds.meanMedianDivergenceMax * 100).toFixed(0)}%). Economy has outliers skewing metrics. Use median for decisions. Raise transaction fees to redistribute wealth.`
+          },
+          confidence: 0.85,
+          estimatedLag: 15
+        };
+      }
     }
     return { violated: false };
   }
@@ -2010,51 +2185,56 @@ var P33_FairNotEqual = {
   category: "player_experience",
   description: "Gini = 0 is boring \u2014 everyone has the same and there is nothing to strive for. Healthy inequality from skill/effort is fine. Inequality from money (pay-to-win) is toxic. Target Gini 0.3-0.45: meaningful spread, not oligarchy.",
   check(metrics, thresholds) {
-    const { giniCoefficient } = metrics;
-    if (giniCoefficient < 0.1) {
-      return {
-        violated: true,
-        severity: 3,
-        evidence: { giniCoefficient },
-        suggestedAction: {
-          parameter: "rewardRate",
-          direction: "increase",
-          magnitude: 0.1,
-          reasoning: `Gini ${giniCoefficient.toFixed(2)} \u2014 near-perfect equality. Economy lacks stakes. Increase winner rewards to create meaningful spread.`
-        },
-        confidence: 0.6,
-        estimatedLag: 20
-      };
-    }
-    if (giniCoefficient > thresholds.giniRedThreshold) {
-      return {
-        violated: true,
-        severity: 7,
-        evidence: { giniCoefficient },
-        suggestedAction: {
-          parameter: "transactionFee",
-          direction: "increase",
-          magnitude: 0.2,
-          reasoning: `Gini ${giniCoefficient.toFixed(2)} \u2014 oligarchy level. Toxic inequality. Raise transaction fees to redistribute wealth from rich to pool.`
-        },
-        confidence: 0.85,
-        estimatedLag: 10
-      };
-    }
-    if (giniCoefficient > thresholds.giniWarnThreshold) {
-      return {
-        violated: true,
-        severity: 4,
-        evidence: { giniCoefficient },
-        suggestedAction: {
-          parameter: "transactionFee",
-          direction: "increase",
-          magnitude: 0.1,
-          reasoning: `Gini ${giniCoefficient.toFixed(2)} \u2014 high inequality warning. Gently raise fees to slow wealth concentration.`
-        },
-        confidence: 0.75,
-        estimatedLag: 15
-      };
+    for (const curr of metrics.currencies) {
+      const giniCoefficient = metrics.giniCoefficientByCurrency[curr] ?? 0;
+      if (giniCoefficient < 0.1) {
+        return {
+          violated: true,
+          severity: 3,
+          evidence: { currency: curr, giniCoefficient },
+          suggestedAction: {
+            parameter: "rewardRate",
+            direction: "increase",
+            currency: curr,
+            magnitude: 0.1,
+            reasoning: `[${curr}] Gini ${giniCoefficient.toFixed(2)} \u2014 near-perfect equality. Economy lacks stakes. Increase winner rewards to create meaningful spread.`
+          },
+          confidence: 0.6,
+          estimatedLag: 20
+        };
+      }
+      if (giniCoefficient > thresholds.giniRedThreshold) {
+        return {
+          violated: true,
+          severity: 7,
+          evidence: { currency: curr, giniCoefficient },
+          suggestedAction: {
+            parameter: "transactionFee",
+            direction: "increase",
+            currency: curr,
+            magnitude: 0.2,
+            reasoning: `[${curr}] Gini ${giniCoefficient.toFixed(2)} \u2014 oligarchy level. Toxic inequality. Raise transaction fees to redistribute wealth from rich to pool.`
+          },
+          confidence: 0.85,
+          estimatedLag: 10
+        };
+      }
+      if (giniCoefficient > thresholds.giniWarnThreshold) {
+        return {
+          violated: true,
+          severity: 4,
+          evidence: { currency: curr, giniCoefficient },
+          suggestedAction: {
+            parameter: "transactionFee",
+            direction: "increase",
+            currency: curr,
+            magnitude: 0.1,
+            reasoning: `[${curr}] Gini ${giniCoefficient.toFixed(2)} \u2014 high inequality warning. Gently raise fees to slow wealth concentration.`
+          },
+          confidence: 0.75,
+          estimatedLag: 15
+        };
+      }
     }
     return { violated: false };
   }
@@ -2587,33 +2767,41 @@ var Simulator = class {
   runForward(metrics, action, ticks, _thresholds) {
     const multiplier = this.actionMultiplier(action);
     const noise = () => 1 + (Math.random() - 0.5) * 0.1;
-    let supply = metrics.totalSupply;
+    const currencies = metrics.currencies;
+    const targetCurrency = action.currency;
+    const supplies = { ...metrics.totalSupplyByCurrency };
+    const netFlows = { ...metrics.netFlowByCurrency };
+    const ginis = { ...metrics.giniCoefficientByCurrency };
+    const velocities = { ...metrics.velocityByCurrency };
     let satisfaction = metrics.avgSatisfaction;
-    let gini = metrics.giniCoefficient;
-    let velocity = metrics.velocity;
-    let netFlow = metrics.netFlow;
-    const churnRate = metrics.churnRate;
     for (let t = 0; t < ticks; t++) {
-      const effectOnFlow = this.flowEffect(action, metrics) * multiplier * noise();
-      netFlow = netFlow * 0.9 + effectOnFlow * 0.1;
-      supply += netFlow * noise();
-      supply = Math.max(0, supply);
-      const satDelta = netFlow > 0 && netFlow < 20 ? 0.5 : netFlow < 0 ? -1 : 0;
+      for (const curr of currencies) {
+        const isTarget = !targetCurrency || targetCurrency === curr;
+        const effectOnFlow = isTarget ? this.flowEffect(action, metrics, curr) * multiplier * noise() : 0;
+        netFlows[curr] = (netFlows[curr] ?? 0) * 0.9 + effectOnFlow * 0.1;
+        supplies[curr] = Math.max(0, (supplies[curr] ?? 0) + (netFlows[curr] ?? 0) * noise());
+        ginis[curr] = (ginis[curr] ?? 0) * 0.99 + 0.35 * 0.01 * noise();
+        velocities[curr] = (supplies[curr] ?? 0) / Math.max(1, metrics.totalAgents) * 0.01 * noise();
+      }
+      const avgNetFlow = currencies.length > 0 ? Object.values(netFlows).reduce((s, v) => s + v, 0) / currencies.length : 0;
+      const satDelta = avgNetFlow > 0 && avgNetFlow < 20 ? 0.5 : avgNetFlow < 0 ? -1 : 0;
       satisfaction = Math.min(100, Math.max(0, satisfaction + satDelta * noise()));
-      gini = gini * 0.99 + 0.35 * 0.01 * noise();
-      velocity = supply / Math.max(1, metrics.totalAgents) * 0.01 * noise();
-      const agentLoss = metrics.totalAgents * churnRate * noise();
-      void agentLoss;
     }
+    const totalSupply = Object.values(supplies).reduce((s, v) => s + v, 0);
     const projected = {
       ...metrics,
       tick: metrics.tick + ticks,
-      totalSupply: supply,
-      netFlow,
-      velocity,
-      giniCoefficient: Math.max(0, Math.min(1, gini)),
+      currencies,
+      totalSupplyByCurrency: supplies,
+      netFlowByCurrency: netFlows,
+      velocityByCurrency: velocities,
+      giniCoefficientByCurrency: ginis,
+      totalSupply,
+      netFlow: Object.values(netFlows).reduce((s, v) => s + v, 0),
+      velocity: totalSupply > 0 && currencies.length > 0 ? Object.values(velocities).reduce((s, v) => s + v, 0) / currencies.length : 0,
+      giniCoefficient: currencies.length > 0 ? Object.values(ginis).reduce((s, v) => s + v, 0) / currencies.length : 0,
       avgSatisfaction: satisfaction,
-      inflationRate: metrics.totalSupply > 0 ? (supply - metrics.totalSupply) / metrics.totalSupply : 0
+      inflationRate: metrics.totalSupply > 0 ? (totalSupply - metrics.totalSupply) / metrics.totalSupply : 0
     };
     return projected;
   }
@@ -2621,16 +2809,16 @@ var Simulator = class {
     const base = action.magnitude ?? 0.1;
     return action.direction === "increase" ? 1 + base : 1 - base;
   }
-  flowEffect(action, metrics) {
+  flowEffect(action, metrics, currency) {
     const { parameter, direction } = action;
     const sign = direction === "increase" ? -1 : 1;
     const roleEntries = Object.entries(metrics.populationByRole).sort((a, b) => b[1] - a[1]);
     const dominantRoleCount = roleEntries[0]?.[1] ?? 0;
     if (parameter === "productionCost") {
-      return sign * metrics.netFlow * 0.2;
+      return sign * (metrics.netFlowByCurrency[currency] ?? 0) * 0.2;
     }
     if (parameter === "transactionFee") {
-      return sign * metrics.velocity * 10 * 0.1;
+      return sign * (metrics.velocityByCurrency[currency] ?? 0) * 10 * 0.1;
     }
     if (parameter === "entryFee") {
       return sign * dominantRoleCount * 0.5;
@@ -2639,14 +2827,22 @@ var Simulator = class {
       return -sign * dominantRoleCount * 0.3;
     }
     if (parameter === "yieldRate") {
-      return sign * metrics.faucetVolume * 0.15;
+      return sign * (metrics.faucetVolumeByCurrency[currency] ?? 0) * 0.15;
     }
-    return sign * metrics.netFlow * 0.1;
+    return sign * (metrics.netFlowByCurrency[currency] ?? 0) * 0.1;
   }
   checkImprovement(before, after, action) {
     const satisfactionImproved = after.avgSatisfaction >= before.avgSatisfaction - 2;
-    const flowMoreBalanced = Math.abs(after.netFlow) <= Math.abs(before.netFlow) * 1.2;
-    const notWorseGini = after.giniCoefficient <= before.giniCoefficient + 0.05;
+    const flowMoreBalanced = before.currencies.every((curr) => {
+      const afterFlow = Math.abs(after.netFlowByCurrency[curr] ?? 0);
+      const beforeFlow = Math.abs(before.netFlowByCurrency[curr] ?? 0);
+      return afterFlow <= beforeFlow * 1.2 || afterFlow < 1;
+    });
+    const notWorseGini = before.currencies.every((curr) => {
+      const afterGini = after.giniCoefficientByCurrency[curr] ?? 0;
+      const beforeGini = before.giniCoefficientByCurrency[curr] ?? 0;
+      return afterGini <= beforeGini + 0.05;
+    });
     void action;
     return satisfactionImproved && flowMoreBalanced && notWorseGini;
   }
@@ -2657,6 +2853,21 @@ var Simulator = class {
       const vals = outcomes.map((o) => o[key]).filter((v) => typeof v === "number" && !isNaN(v));
       return vals.length > 0 ? vals.reduce((a, b) => a + b, 0) / vals.length : 0;
     };
+    const avgRecord = (key) => {
+      const allKeys = /* @__PURE__ */ new Set();
+      for (const o of outcomes) {
+        const rec = o[key];
+        if (rec && typeof rec === "object" && !Array.isArray(rec)) {
+          Object.keys(rec).forEach((k) => allKeys.add(k));
+        }
+      }
+      const result = {};
+      for (const k of allKeys) {
+        const vals = outcomes.map((o) => o[key]?.[k]).filter((v) => typeof v === "number" && !isNaN(v));
+        result[k] = vals.length > 0 ? vals.reduce((a, b) => a + b, 0) / vals.length : 0;
+      }
+      return result;
+    };
     return {
       ...base,
       totalSupply: avg("totalSupply"),
@@ -2664,7 +2875,11 @@ var Simulator = class {
       velocity: avg("velocity"),
       giniCoefficient: avg("giniCoefficient"),
       avgSatisfaction: avg("avgSatisfaction"),
-      inflationRate: avg("inflationRate")
+      inflationRate: avg("inflationRate"),
+      totalSupplyByCurrency: avgRecord("totalSupplyByCurrency"),
+      netFlowByCurrency: avgRecord("netFlowByCurrency"),
+      velocityByCurrency: avgRecord("velocityByCurrency"),
+      giniCoefficientByCurrency: avgRecord("giniCoefficientByCurrency")
     };
   }
 };
@@ -2723,6 +2938,7 @@ var Planner = class {
       id: `plan_${metrics.tick}_${param}`,
       diagnosis,
       parameter: param,
+      ...action.currency !== void 0 ? { currency: action.currency } : {},
       currentValue,
       targetValue,
       maxChangePercent: thresholds.maxAdjustmentPercent,
@@ -2764,7 +2980,7 @@ var Executor = class {
   }
   async apply(plan, adapter, currentParams) {
     const originalValue = currentParams[plan.parameter] ?? plan.currentValue;
-    await adapter.setParam(plan.parameter, plan.targetValue);
+    await adapter.setParam(plan.parameter, plan.targetValue, plan.diagnosis.violation.suggestedAction.currency);
     plan.appliedAt = plan.diagnosis.tick;
     this.activePlans.push({ plan, originalValue });
   }
@@ -2786,7 +3002,7 @@ var Executor = class {
       const metricValue = this.getMetricValue(metrics, rc.metric);
       const shouldRollback = rc.direction === "below" ? metricValue < rc.threshold : metricValue > rc.threshold;
       if (shouldRollback) {
-        await adapter.setParam(plan.parameter, originalValue);
+        await adapter.setParam(plan.parameter, originalValue, plan.diagnosis.violation.suggestedAction.currency);
         rolledBack.push(plan);
       } else {
         const settledTick = rc.checkAfterTick + 10;
@@ -2919,6 +3135,18 @@ var DecisionLog = class {
 };
 
 // src/MetricStore.ts
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let val = obj;
+  for (const part of parts) {
+    if (val !== null && typeof val === "object") {
+      val = val[part];
+    } else {
+      return NaN;
+    }
+  }
+  return typeof val === "number" ? val : NaN;
+}
 var RingBuffer = class {
   constructor(capacity) {
     this.capacity = capacity;
@@ -2996,10 +3224,9 @@ var MetricStore = class {
       if (q.to !== void 0 && m.tick > q.to) return false;
       return true;
     });
-    const metricKey = q.metric;
     const points = filtered.map((m) => ({
       tick: m.tick,
-      value: typeof m[metricKey] === "number" ? m[metricKey] : NaN
+      value: getNestedValue(m, q.metric)
     }));
     return { metric: q.metric, resolution, points };
   }
@@ -3024,6 +3251,21 @@ var MetricStore = class {
       const vals = snapshots.map((s) => s[key]).filter((v) => !isNaN(v));
       return vals.length > 0 ? vals.reduce((a, b) => a + b, 0) / vals.length : 0;
     };
+    const avgRecord = (key) => {
+      const allKeys = /* @__PURE__ */ new Set();
+      for (const s of snapshots) {
+        const rec = s[key];
+        if (rec && typeof rec === "object" && !Array.isArray(rec)) {
+          Object.keys(rec).forEach((k) => allKeys.add(k));
+        }
+      }
+      const result = {};
+      for (const k of allKeys) {
+        const vals = snapshots.map((s) => s[key]?.[k]).filter((v) => typeof v === "number" && !isNaN(v));
+        result[k] = vals.length > 0 ? vals.reduce((a, b) => a + b, 0) / vals.length : 0;
+      }
+      return result;
+    };
     return {
       ...last,
       totalSupply: avg("totalSupply"),
@@ -3043,7 +3285,21 @@ var MetricStore = class {
       tapSinkRatio: avg("tapSinkRatio"),
       productionIndex: avg("productionIndex"),
       capacityUsage: avg("capacityUsage"),
-      anchorRatioDrift: avg("anchorRatioDrift")
+      anchorRatioDrift: avg("anchorRatioDrift"),
+      // Per-currency averages
+      totalSupplyByCurrency: avgRecord("totalSupplyByCurrency"),
+      netFlowByCurrency: avgRecord("netFlowByCurrency"),
+      velocityByCurrency: avgRecord("velocityByCurrency"),
+      inflationRateByCurrency: avgRecord("inflationRateByCurrency"),
+      faucetVolumeByCurrency: avgRecord("faucetVolumeByCurrency"),
+      sinkVolumeByCurrency: avgRecord("sinkVolumeByCurrency"),
+      tapSinkRatioByCurrency: avgRecord("tapSinkRatioByCurrency"),
+      anchorRatioDriftByCurrency: avgRecord("anchorRatioDriftByCurrency"),
+      giniCoefficientByCurrency: avgRecord("giniCoefficientByCurrency"),
+      medianBalanceByCurrency: avgRecord("medianBalanceByCurrency"),
+      meanBalanceByCurrency: avgRecord("meanBalanceByCurrency"),
+      top10PctShareByCurrency: avgRecord("top10PctShareByCurrency"),
+      meanMedianDivergenceByCurrency: avgRecord("meanMedianDivergenceByCurrency")
     };
   }
 };