@agent-e/core 1.5.0 → 1.5.2

package/dist/index.js

@@ -36,7 +36,7 @@ __export(index_exports, {
   OPEN_ECONOMY_PRINCIPLES: () => OPEN_ECONOMY_PRINCIPLES,
   OPERATIONS_PRINCIPLES: () => OPERATIONS_PRINCIPLES,
   Observer: () => Observer,
-  P10_SpawnWeightingUsesInversePopulation: () => P10_SpawnWeightingUsesInversePopulation,
+  P10_EntryWeightingUsesInversePopulation: () => P10_EntryWeightingUsesInversePopulation,
   P11_TwoTierPressure: () => P11_TwoTierPressure,
   P12_OnePrimaryFaucet: () => P12_OnePrimaryFaucet,
   P13_PotsAreZeroSumAndSelfRegulate: () => P13_PotsAreZeroSumAndSelfRegulate,
@@ -56,9 +56,9 @@ __export(index_exports, {
   P26_ContinuousPressureBeatsThresholdCuts: () => P26_ContinuousPressureBeatsThresholdCuts,
   P27_AdjustmentsNeedCooldowns: () => P27_AdjustmentsNeedCooldowns,
   P28_StructuralDominanceIsNotPathological: () => P28_StructuralDominanceIsNotPathological,
-  P29_PinchPoint: () => P29_PinchPoint,
+  P29_BottleneckDetection: () => P29_BottleneckDetection,
   P2_ClosedLoopsNeedDirectHandoff: () => P2_ClosedLoopsNeedDirectHandoff,
-  P30_MovingPinchPoint: () => P30_MovingPinchPoint,
+  P30_DynamicBottleneckRotation: () => P30_DynamicBottleneckRotation,
   P31_AnchorValueTracking: () => P31_AnchorValueTracking,
   P32_VelocityAboveSupply: () => P32_VelocityAboveSupply,
   P33_FairNotEqual: () => P33_FairNotEqual,
@@ -81,16 +81,16 @@ __export(index_exports, {
   P49_IdleAssetTax: () => P49_IdleAssetTax,
   P4_MaterialsFlowFasterThanCooldown: () => P4_MaterialsFlowFasterThanCooldown,
   P50_PayPowerRatio: () => P50_PayPowerRatio,
-  P51_SharkTooth: () => P51_SharkTooth,
+  P51_CyclicalEngagement: () => P51_CyclicalEngagement,
   P52_EndowmentEffect: () => P52_EndowmentEffect,
   P53_EventCompletionRate: () => P53_EventCompletionRate,
-  P54_LiveOpsCadence: () => P54_LiveOpsCadence,
+  P54_OperationalCadence: () => P54_OperationalCadence,
   P55_ArbitrageThermometer: () => P55_ArbitrageThermometer,
-  P56_ContentDropShock: () => P56_ContentDropShock,
+  P56_SupplyShockAbsorption: () => P56_SupplyShockAbsorption,
   P57_CombinatorialPriceSpace: () => P57_CombinatorialPriceSpace,
   P58_NoNaturalNumeraire: () => P58_NoNaturalNumeraire,
   P59_GiftEconomyNoise: () => P59_GiftEconomyNoise,
-  P5_ProfitabilityIsCompetitive: () => P5_ProfitabilityIsCompetitive,
+  P5_ProfitabilityIsRelative: () => P5_ProfitabilityIsRelative,
   P60_SurplusDisposalAsymmetry: () => P60_SurplusDisposalAsymmetry,
   P6_CrowdingMultiplierOnAllRoles: () => P6_CrowdingMultiplierOnAllRoles,
   P7_NonSpecialistsSubsidiseSpecialists: () => P7_NonSpecialistsSubsidiseSpecialists,
@@ -109,6 +109,7 @@ __export(index_exports, {
   SYSTEM_DYNAMICS_PRINCIPLES: () => SYSTEM_DYNAMICS_PRINCIPLES,
   Simulator: () => Simulator,
   emptyMetrics: () => emptyMetrics,
+  findWorstSystem: () => findWorstSystem,
   validateEconomyState: () => validateEconomyState
 });
 module.exports = __toCommonJS(index_exports);
@@ -147,7 +148,7 @@ var DEFAULT_THRESHOLDS = {
   cooldownTicks: 15,
   // Currency (P13)
   poolWinRate: 0.65,
-  poolHouseCut: 0.1,
+  poolOperatorShare: 0.1,
   // Population balance (P9)
   roleSwitchFrictionMax: 0.05,
   // >5% of population switching in one period = herd
@@ -208,6 +209,12 @@ var Observer = class {
     this.customMetricFns[name] = fn;
   }
   compute(state, recentEvents) {
+    if (!state.currencies || state.currencies.length === 0) {
+      console.warn("[AgentE] Warning: state.currencies is empty. Metrics will be zeroed.");
+    }
+    if (!state.agentBalances || Object.keys(state.agentBalances).length === 0) {
+      console.warn("[AgentE] Warning: state.agentBalances is empty.");
+    }
     const tick = state.tick;
     const roles = Object.values(state.agentRoles);
     const totalAgents = Object.keys(state.agentBalances).length;
@@ -255,7 +262,7 @@ var Observer = class {
         if (!actorsBySystem[e.system]) actorsBySystem[e.system] = /* @__PURE__ */ new Set();
         actorsBySystem[e.system].add(e.actor);
         const amt = e.amount ?? 0;
-        if (e.type === "mint" || e.type === "enter") {
+        if (e.type === "mint") {
           flowBySystem[e.system] = (flowBySystem[e.system] ?? 0) + amt;
         } else if (e.type === "burn" || e.type === "consume") {
           flowBySystem[e.system] = (flowBySystem[e.system] ?? 0) - amt;
@@ -263,7 +270,7 @@ var Observer = class {
       }
       if (e.sourceOrSink) {
         const amt = e.amount ?? 0;
-        if (e.type === "mint" || e.type === "enter") {
+        if (e.type === "mint") {
           flowBySource[e.sourceOrSink] = (flowBySource[e.sourceOrSink] ?? 0) + amt;
         } else if (e.type === "burn" || e.type === "consume") {
           flowBySink[e.sourceOrSink] = (flowBySink[e.sourceOrSink] ?? 0) + amt;
@@ -302,7 +309,7 @@ var Observer = class {
       const faucet = faucetVolumeByCurrency[curr] ?? 0;
       const sink = sinkVolumeByCurrency[curr] ?? 0;
       netFlowByCurrency[curr] = faucet - sink;
-      tapSinkRatioByCurrency[curr] = sink > 0 ? faucet / sink : faucet > 0 ? Infinity : 1;
+      tapSinkRatioByCurrency[curr] = sink > 0 ? Math.min(faucet / sink, 100) : faucet > 0 ? 100 : 1;
       const prevSupply = this.previousMetrics?.totalSupplyByCurrency?.[curr] ?? totalSupplyByCurrency[curr] ?? 0;
       const currSupply = totalSupplyByCurrency[curr] ?? 0;
       inflationRateByCurrency[curr] = prevSupply > 0 ? (currSupply - prevSupply) / prevSupply : 0;
@@ -337,7 +344,7 @@ var Observer = class {
     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 tapSinkRatio = sinkVolume > 0 ? Math.min(faucetVolume / sinkVolume, 100) : faucetVolume > 0 ? 100 : 1;
     const velocity = totalSupply > 0 ? tradeEvents.length / totalSupply : 0;
     const prevTotalSupply = this.previousMetrics?.totalSupply ?? totalSupply;
     const inflationRate = prevTotalSupply > 0 ? (totalSupply - prevTotalSupply) / prevTotalSupply : 0;
@@ -375,7 +382,9 @@ var Observer = class {
       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));
+    this.previousPricesByCurrency = Object.fromEntries(
+      Object.entries(pricesByCurrency).map(([c, p]) => [c, { ...p }])
+    );
     const prices = pricesByCurrency[defaultCurrency] ?? {};
     const priceVolatility = priceVolatilityByCurrency[defaultCurrency] ?? {};
     const priceIndex = priceIndexByCurrency[defaultCurrency] ?? 0;
@@ -395,9 +404,9 @@ var Observer = class {
     for (const resource of /* @__PURE__ */ new Set([...Object.keys(supplyByResource), ...Object.keys(demandSignals)])) {
       const s = supplyByResource[resource] ?? 0;
       const d = demandSignals[resource] ?? 0;
-      if (d > 2 && s / d < 0.5) {
+      if (d > 0 && d > 2 && s / d < 0.5) {
         pinchPoints[resource] = "scarce";
-      } else if (s > 3 && d > 0 && s / d > 3) {
+      } else if (d > 0 && s > 3 && s / d > 3) {
         pinchPoints[resource] = "oversupplied";
       } else {
         pinchPoints[resource] = "optimal";
@@ -443,21 +452,11 @@ var Observer = class {
     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;
+      const logPrices = Object.values(cPrices).filter((p) => p > 0).map((p) => Math.log(p));
+      if (logPrices.length >= 2) {
+        const mean = logPrices.reduce((s, v) => s + v, 0) / logPrices.length;
+        const variance = logPrices.reduce((s, v) => s + (v - mean) ** 2, 0) / logPrices.length;
+        arbitrageIndexByCurrency[curr] = Math.min(1, Math.sqrt(variance));
       } else {
         arbitrageIndexByCurrency[curr] = 0;
       }
@@ -544,10 +543,10 @@ var Observer = class {
       prices,
       priceVolatility,
       poolSizes: poolSizesAggregate,
-      extractionRatio: NaN,
-      newUserDependency: NaN,
-      smokeTestRatio: NaN,
-      currencyInsulation: NaN,
+      extractionRatio: 0,
+      newUserDependency: 0,
+      smokeTestRatio: 0,
+      currencyInsulation: 0,
       arbitrageIndex,
       giftTradeRatio,
       disposalTradeRatio,
@@ -569,8 +568,11 @@ var Observer = class {
       timeToValue,
       sharkToothPeaks: this.previousMetrics?.sharkToothPeaks ?? [],
       sharkToothValleys: this.previousMetrics?.sharkToothValleys ?? [],
-      eventCompletionRate: NaN,
+      eventCompletionRate: 0,
       contentDropAge,
+      systems: state.systems ?? [],
+      sources: state.sources ?? [],
+      sinks: state.sinks ?? [],
       flowBySystem,
       activityBySystem,
       participantsBySystem,
@@ -598,7 +600,7 @@ function computeGini(sorted) {
   for (let i = 0; i < n; i++) {
     numerator += (2 * (i + 1) - n - 1) * (sorted[i] ?? 0);
   }
-  return Math.abs(numerator) / (n * sum);
+  return Math.min(1, Math.abs(numerator) / (n * sum));
 }
 
 // src/Diagnoser.ts
@@ -694,10 +696,10 @@ function emptyMetrics(tick = 0) {
     prices: {},
     priceVolatility: {},
     poolSizes: {},
-    extractionRatio: NaN,
-    newUserDependency: NaN,
-    smokeTestRatio: NaN,
-    currencyInsulation: NaN,
+    extractionRatio: 0,
+    newUserDependency: 0,
+    smokeTestRatio: 0,
+    currencyInsulation: 0,
     arbitrageIndex: 0,
     giftTradeRatio: 0,
     disposalTradeRatio: 0,
@@ -718,8 +720,11 @@ function emptyMetrics(tick = 0) {
     timeToValue: 0,
     sharkToothPeaks: [],
     sharkToothValleys: [],
-    eventCompletionRate: NaN,
+    eventCompletionRate: 0,
     contentDropAge: 0,
+    systems: [],
+    sources: [],
+    sinks: [],
     flowBySystem: {},
     activityBySystem: {},
     participantsBySystem: {},
@@ -920,9 +925,9 @@ var SUPPLY_CHAIN_PRINCIPLES = [
 ];
 
 // src/principles/incentives.ts
-var P5_ProfitabilityIsCompetitive = {
+var P5_ProfitabilityIsRelative = {
   id: "P5",
-  name: "Profitability Is Competitive, Not Absolute",
+  name: "Profitability Is Relative, Not Absolute",
   category: "incentive",
   description: "Any profitability formula that returns the same number regardless of how many agents are already in that role will cause stampedes. 97 intermediaries happened because profit = transactions \xD7 10 with no competition denominator.",
   check(metrics, thresholds) {
@@ -986,7 +991,7 @@ var P7_NonSpecialistsSubsidiseSpecialists = {
   id: "P7",
   name: "Non-Specialists Subsidise Specialists in Zero-Sum Games",
   category: "incentive",
-  description: "In zero-sum pools (competitive pool, staking), the math only works if non-specialists overpay relative to specialists. If the pool is >70% specialists, there is no one left to subsidise and the pot drains.",
+  description: "In zero-sum pools (staking, prize pools, etc.), the math only works if non-specialists overpay relative to specialists. If the pool is >70% specialists, there is no one left to subsidise and the pot drains.",
   check(metrics, _thresholds) {
     const { poolSizes } = metrics;
     for (const [poolName, poolSize] of Object.entries(poolSizes)) {
@@ -1022,7 +1027,7 @@ var P8_RegulatorCannotFightDesign = {
   id: "P8",
   name: "Regulator Cannot Fight the Design",
   category: "incentive",
-  description: "If the economy is designed to have a majority role (e.g. dominant role exceeds 55%), the regulator must know this and exempt that role from population suppression. AgentE at tick 1 seeing dominant role exceeds 55% and slashing competitive pool rewards is overreach.",
+  description: "If the economy is designed to have a majority role (e.g. dominant role exceeds 55%), the regulator must know this and exempt that role from population suppression. AgentE at tick 1 seeing dominant role exceeds 55% and slashing pool rewards is overreach.",
   check(metrics, _thresholds) {
     const { roleShares, avgSatisfaction } = metrics;
     if (avgSatisfaction < 45) {
@@ -1047,7 +1052,7 @@ var P8_RegulatorCannotFightDesign = {
   }
 };
 var INCENTIVE_PRINCIPLES = [
-  P5_ProfitabilityIsCompetitive,
+  P5_ProfitabilityIsRelative,
   P6_CrowdingMultiplierOnAllRoles,
   P7_NonSpecialistsSubsidiseSpecialists,
   P8_RegulatorCannotFightDesign
@@ -1058,7 +1063,7 @@ var P9_RoleSwitchingNeedsFriction = {
   id: "P9",
   name: "Role Switching Needs Friction",
   category: "population",
-  description: "If >5% of the population switches roles in a single evaluation period, it is a herd movement, not rational rebalancing. Without friction (satisfaction cost, cooldown), one good tick causes mass migration.",
+  description: "If >5% of the population switches roles in a single evaluation period, it is a herd movement, not rational rebalancing. Without friction (satisfaction cost, minimum interval), one good tick causes mass migration.",
   check(metrics, thresholds) {
     const { churnByRole, roleShares } = metrics;
     const totalChurn = Object.values(churnByRole).reduce((s, v) => s + v, 0);
@@ -1081,7 +1086,7 @@ var P9_RoleSwitchingNeedsFriction = {
     return { violated: false };
   }
 };
-var P10_SpawnWeightingUsesInversePopulation = {
+var P10_EntryWeightingUsesInversePopulation = {
   id: "P10",
   name: "Entry Weighting Uses Inverse Population",
   category: "population",
@@ -1187,7 +1192,7 @@ var P46_PersonaDiversity = {
 };
 var POPULATION_PRINCIPLES = [
   P9_RoleSwitchingNeedsFriction,
-  P10_SpawnWeightingUsesInversePopulation,
+  P10_EntryWeightingUsesInversePopulation,
   P11_TwoTierPressure,
   P46_PersonaDiversity
 ];
@@ -1243,7 +1248,7 @@ var P13_PotsAreZeroSumAndSelfRegulate = {
   id: "P13",
   name: "Pots Self-Regulate with Correct Multiplier",
   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.",
+  description: "Pool math: winRate \xD7 multiplier > (1 - operatorShare) 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 { populationByRole } = metrics;
     const roleEntries = Object.entries(populationByRole).sort((a, b) => b[1] - a[1]);
@@ -1252,8 +1257,8 @@ var P13_PotsAreZeroSumAndSelfRegulate = {
       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;
+          const { poolWinRate, poolOperatorShare } = thresholds;
+          const maxSustainableMultiplier = (1 - poolOperatorShare) / poolWinRate;
           return {
             violated: true,
             severity: 7,
@@ -1278,7 +1283,7 @@ var P14_TrackActualInjection = {
   id: "P14",
   name: "Track Actual Currency Injection, Not Value Creation",
   category: "currency",
-  description: 'Counting resource gathering as "currency injected" is misleading. Currency enters through faucet mechanisms (entering, rewards). Fake metrics break every downstream decision.',
+  description: 'Counting resource extraction as "currency injected" is misleading. Currency enters through faucet mechanisms (entering, rewards). Fake metrics break every downstream decision.',
   check(metrics, _thresholds) {
     for (const curr of metrics.currencies) {
       const faucetVolume = metrics.faucetVolumeByCurrency[curr] ?? 0;
@@ -1536,7 +1541,7 @@ var P19_StartingSupplyExceedsDemand = {
           parameterType: "reward",
           direction: "increase",
           magnitude: 0.2,
-          reasoning: `${mostPopulatedRole} (${population} agents) has insufficient resources (${resourcesPerAgent.toFixed(2)} per agent). Cold-start scarcity. Boost competitive pool reward to attract participation despite scarcity.`
+          reasoning: `${mostPopulatedRole} (${population} agents) has insufficient resources (${resourcesPerAgent.toFixed(2)} per agent). Cold-start scarcity. Boost pool reward to attract participation despite scarcity.`
         },
         confidence: 0.75,
         estimatedLag: 5
@@ -1866,7 +1871,7 @@ var REGULATOR_PRINCIPLES = [
 ];
 
 // src/principles/market-dynamics.ts
-var P29_PinchPoint = {
+var P29_BottleneckDetection = {
   id: "P29",
   name: "Bottleneck Detection",
   category: "market_dynamics",
@@ -1911,7 +1916,7 @@ var P29_PinchPoint = {
     return { violated: false };
   }
 };
-var P30_MovingPinchPoint = {
+var P30_DynamicBottleneckRotation = {
   id: "P30",
   name: "Dynamic Bottleneck Rotation",
   category: "market_dynamics",
@@ -1986,8 +1991,8 @@ var P57_CombinatorialPriceSpace = {
   }
 };
 var MARKET_DYNAMICS_PRINCIPLES = [
-  P29_PinchPoint,
-  P30_MovingPinchPoint,
+  P29_BottleneckDetection,
+  P30_DynamicBottleneckRotation,
   P57_CombinatorialPriceSpace
 ];
 
@@ -2281,7 +2286,7 @@ var P35_DestructionCreatesValue = {
             scope: { tags: ["entry"] },
             direction: "decrease",
             magnitude: 0.1,
-            reasoning: `${resource} supply at ${supply} units with low destruction (sink ${sinkVolume}/t). Resources not being consumed. Lower competitive pool entry to increase resource usage.`
+            reasoning: `${resource} supply at ${supply} units with low destruction (sink ${sinkVolume}/t). Resources not being consumed. Lower pool entry to increase resource usage.`
           },
           confidence: 0.7,
           estimatedLag: 5
@@ -2295,7 +2300,7 @@ var P40_ReplacementRate = {
   id: "P40",
   name: "Replacement Rate \u2265 2\xD7 Consumption",
   category: "resource",
-  description: "Respawn/production rate must be at least 2\xD7 consumption rate for equilibrium. At 1\xD7 you drift toward depletion. At 2\xD7 you have a buffer for demand spikes.",
+  description: "Replacement/production rate must be at least 2\xD7 consumption rate for equilibrium. At 1\xD7 you drift toward depletion. At 2\xD7 you have a buffer for demand spikes.",
   check(metrics, thresholds) {
     const { productionIndex, sinkVolume } = metrics;
     if (sinkVolume > 0 && productionIndex > 0) {
@@ -2662,7 +2667,7 @@ var OPEN_ECONOMY_PRINCIPLES = [
 ];
 
 // src/principles/operations.ts
-var P51_SharkTooth = {
+var P51_CyclicalEngagement = {
   id: "P51",
   name: "Cyclical Engagement Pattern",
   category: "operations",
@@ -2718,7 +2723,7 @@ var P52_EndowmentEffect = {
   id: "P52",
   name: "Endowment Effect",
   category: "operations",
-  description: "Participants who never owned premium items do not value them. Free trial activities that let participants experience premium items drive conversions because ownership creates perceived value (endowment effect).",
+  description: "Participants who never owned premium assets do not value them. Free trial activities that let participants experience premium assets drive conversions because ownership creates perceived value (endowment effect).",
   check(metrics, _thresholds) {
     const { avgSatisfaction, churnRate } = metrics;
     const { eventCompletionRate } = metrics;
@@ -2787,11 +2792,11 @@ var P53_EventCompletionRate = {
     return { violated: false };
   }
 };
-var P54_LiveOpsCadence = {
+var P54_OperationalCadence = {
   id: "P54",
   name: "Operational Cadence",
   category: "operations",
-  description: ">50% of activities that are re-wrapped existing content \u2192 staleness. The cadence must include genuinely new content at regular intervals. This is an advisory principle \u2014 AgentE can flag but cannot fix content.",
+  description: ">50% of activities that are re-wrapped existing supply \u2192 stagnation. The cadence must include genuinely new supply at regular intervals. This is an advisory principle \u2014 AgentE can flag but cannot fix supply.",
   check(metrics, _thresholds) {
     const { velocity, avgSatisfaction } = metrics;
     if (velocity < 2 && avgSatisfaction < 55 && metrics.tick > 100) {
@@ -2803,7 +2808,7 @@ var P54_LiveOpsCadence = {
           parameterType: "reward",
           direction: "increase",
           magnitude: 0.1,
-          reasoning: "Low velocity and satisfaction after long runtime. Possible content staleness. Increase rewards as bridge while new content is developed (developer action required)."
+          reasoning: "Low velocity and satisfaction after long runtime. Possible supply stagnation. Increase rewards as bridge while new supply is developed (developer action required)."
         },
         confidence: 0.4,
         estimatedLag: 30
@@ -2812,11 +2817,11 @@ var P54_LiveOpsCadence = {
     return { violated: false };
   }
 };
-var P56_ContentDropShock = {
+var P56_SupplyShockAbsorption = {
   id: "P56",
   name: "Supply Shock Absorption",
   category: "operations",
-  description: "Every new-item injection shatters existing price equilibria \u2014 arbitrage spikes as participants re-price. Build cooldown windows for price discovery before measuring post-drop economic health.",
+  description: "Every new-item injection shatters existing price equilibria \u2014 arbitrage spikes as participants re-price. Build stabilization windows for price discovery before measuring post-injection economic health.",
   check(metrics, thresholds) {
     const { contentDropAge, arbitrageIndex } = metrics;
     if (contentDropAge > 0 && contentDropAge <= thresholds.contentDropCooldownTicks) {
@@ -2835,7 +2840,7 @@ var P56_ContentDropShock = {
             scope: { tags: ["transaction"] },
             direction: "decrease",
             magnitude: 0.1,
-            reasoning: `Content drop ${contentDropAge} ticks ago \u2014 arbitrage at ${arbitrageIndex.toFixed(2)} exceeds post-drop max (${thresholds.postDropArbitrageMax}). Price discovery struggling. Lower trading friction temporarily.`
+            reasoning: `Supply injection ${contentDropAge} ticks ago \u2014 arbitrage at ${arbitrageIndex.toFixed(2)} exceeds post-injection max (${thresholds.postDropArbitrageMax}). Price discovery struggling. Lower trading friction temporarily.`
           },
           confidence: 0.6,
           estimatedLag: 5
@@ -2846,11 +2851,11 @@ var P56_ContentDropShock = {
   }
 };
 var OPERATIONS_PRINCIPLES = [
-  P51_SharkTooth,
+  P51_CyclicalEngagement,
   P52_EndowmentEffect,
   P53_EventCompletionRate,
-  P54_LiveOpsCadence,
-  P56_ContentDropShock
+  P54_OperationalCadence,
+  P56_SupplyShockAbsorption
 ];
 
 // src/principles/index.ts
@@ -2888,15 +2893,24 @@ var ALL_PRINCIPLES = [
 ];
 
 // src/Simulator.ts
+var DEFAULT_SIM_CONFIG = {
+  sinkMultiplier: 0.2,
+  faucetMultiplier: 0.15,
+  frictionMultiplier: 0.1,
+  frictionVelocityScale: 10,
+  redistributionMultiplier: 0.3,
+  neutralMultiplier: 0.05,
+  minIterations: 100,
+  maxProjectionTicks: 20
+};
 var Simulator = class {
-  constructor(registry) {
+  constructor(registry, simConfig) {
     this.diagnoser = new Diagnoser(ALL_PRINCIPLES);
-    // Cache beforeViolations for the *current* tick only (one entry max).
-    // Using a Map here is intentional but the cache must be bounded — we only
-    // care about the tick that is currently being evaluated, so we evict any
-    // entries whose key differs from the incoming tick.
-    this.beforeViolationsCache = /* @__PURE__ */ new Map();
+    // Cache beforeViolations for the *current* tick only.
+    this.cachedViolationsTick = -1;
+    this.cachedViolations = /* @__PURE__ */ new Set();
     this.registry = registry;
+    this.simConfig = { ...DEFAULT_SIM_CONFIG, ...simConfig };
   }
   /**
    * Simulate the effect of applying `action` to the current economy forward `forwardTicks`.
@@ -2920,16 +2934,13 @@ var Simulator = class {
     const mean = this.averageMetrics(outcomes);
     const netImprovement = this.checkImprovement(currentMetrics, p50, action);
     const tick = currentMetrics.tick;
-    if (this.beforeViolationsCache.size > 0 && !this.beforeViolationsCache.has(tick)) {
-      this.beforeViolationsCache.clear();
-    }
-    let beforeViolations = this.beforeViolationsCache.get(tick);
-    if (!beforeViolations) {
-      beforeViolations = new Set(
+    if (this.cachedViolationsTick !== tick) {
+      this.cachedViolations = new Set(
         this.diagnoser.diagnose(currentMetrics, thresholds).map((d) => d.principle.id)
       );
-      this.beforeViolationsCache.set(tick, beforeViolations);
+      this.cachedViolationsTick = tick;
     }
+    const beforeViolations = this.cachedViolations;
     const afterViolations = new Set(
       this.diagnoser.diagnose(p50, thresholds).map((d) => d.principle.id)
     );
@@ -3009,25 +3020,32 @@ var Simulator = class {
     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;
-    const resolvedKey = action.resolvedParameter;
     let impact;
-    if (resolvedKey && this.registry) {
-      impact = this.registry.getFlowImpact(resolvedKey);
+    if (this.registry) {
+      const resolved = this.registry.resolve(action.parameterType, action.scope);
+      if (resolved) {
+        impact = resolved.flowImpact;
+      }
     }
     if (!impact) {
       impact = this.inferFlowImpact(action.parameterType);
     }
+    const cfg = this.simConfig;
     switch (impact) {
       case "sink":
-        return sign * (metrics.netFlowByCurrency[currency] ?? 0) * 0.2;
+        return sign * (metrics.netFlowByCurrency[currency] ?? 0) * cfg.sinkMultiplier;
       case "faucet":
-        return -sign * dominantRoleCount * 0.3;
+        return -sign * dominantRoleCount * cfg.redistributionMultiplier;
       case "neutral":
-        return sign * dominantRoleCount * 0.5;
+        return sign * dominantRoleCount * cfg.neutralMultiplier;
       case "mixed":
-        return sign * (metrics.faucetVolumeByCurrency[currency] ?? 0) * 0.15;
+        return sign * (metrics.faucetVolumeByCurrency[currency] ?? 0) * cfg.faucetMultiplier;
+      case "friction":
+        return sign * (metrics.netFlowByCurrency[currency] ?? 0) * cfg.frictionMultiplier;
+      case "redistribution":
+        return sign * dominantRoleCount * cfg.neutralMultiplier;
       default:
-        return sign * (metrics.netFlowByCurrency[currency] ?? 0) * 0.1;
+        return sign * (metrics.netFlowByCurrency[currency] ?? 0) * cfg.frictionMultiplier;
     }
   }
   /** Infer flow impact from parameter type when registry is unavailable */
@@ -3048,7 +3066,7 @@ var Simulator = class {
         return "mixed";
     }
   }
-  checkImprovement(before, after, action) {
+  checkImprovement(before, after, _action) {
     const satisfactionImproved = after.avgSatisfaction >= before.avgSatisfaction - 2;
     const flowMoreBalanced = before.currencies.every((curr) => {
       const afterFlow = Math.abs(after.netFlowByCurrency[curr] ?? 0);
@@ -3060,7 +3078,6 @@ var Simulator = class {
       const beforeGini = before.giniCoefficientByCurrency[curr] ?? 0;
       return afterGini <= beforeGini + 0.05;
     });
-    void action;
     return satisfactionImproved && flowMoreBalanced && notWorseGini;
   }
   averageMetrics(outcomes) {
@@ -3108,6 +3125,8 @@ var Planner = class {
     this.constraints = /* @__PURE__ */ new Map();
     this.cooldowns = /* @__PURE__ */ new Map();
     // param → last-applied-tick
+    this.typeCooldowns = /* @__PURE__ */ new Map();
+    // type+scope key → last-applied-tick
     this.activePlanCount = 0;
   }
   lock(param) {
@@ -3130,6 +3149,8 @@ var Planner = class {
    */
   plan(diagnosis, metrics, simulationResult, currentParams, thresholds, registry) {
     const action = diagnosis.violation.suggestedAction;
+    const typeKey = this.typeCooldownKey(action.parameterType, action.scope);
+    if (this.isTypeCooldown(typeKey, metrics.tick, thresholds.cooldownTicks)) return null;
     let param;
     let resolvedBaseline;
     let scope;
@@ -3187,6 +3208,9 @@ var Planner = class {
   }
   recordApplied(plan, tick) {
     this.cooldowns.set(plan.parameter, tick);
+    const action = plan.diagnosis.violation.suggestedAction;
+    const typeKey = this.typeCooldownKey(action.parameterType, action.scope);
+    this.typeCooldowns.set(typeKey, tick);
     this.activePlanCount++;
   }
   recordRolledBack(_plan) {
@@ -3203,13 +3227,35 @@ var Planner = class {
   /** Reset all cooldowns (useful for testing) */
   resetCooldowns() {
     this.cooldowns.clear();
+    this.typeCooldowns.clear();
+  }
+  /** V1.5.2: Reset active plan count (e.g., on system restart) */
+  resetActivePlans() {
+    this.activePlanCount = 0;
+  }
+  /** V1.5.2: Current active plan count (for diagnostics) */
+  getActivePlanCount() {
+    return this.activePlanCount;
+  }
+  typeCooldownKey(type, scope) {
+    const parts = [type];
+    if (scope?.system) parts.push(`sys:${scope.system}`);
+    if (scope?.currency) parts.push(`cur:${scope.currency}`);
+    if (scope?.tags?.length) parts.push(`tags:${scope.tags.sort().join(",")}`);
+    return parts.join("|");
+  }
+  isTypeCooldown(typeKey, currentTick, cooldownTicks) {
+    const lastApplied = this.typeCooldowns.get(typeKey);
+    if (lastApplied === void 0) return false;
+    return currentTick - lastApplied < cooldownTicks;
   }
 };
 
 // src/Executor.ts
 var Executor = class {
-  constructor() {
+  constructor(settlementWindowTicks = 200) {
     this.activePlans = [];
+    this.maxActiveTicks = settlementWindowTicks;
   }
   async apply(plan, adapter, currentParams) {
     const originalValue = currentParams[plan.parameter] ?? plan.currentValue;
@@ -3228,8 +3274,7 @@ var Executor = class {
     for (const active of this.activePlans) {
       const { plan, originalValue } = active;
       const rc = plan.rollbackCondition;
-      const maxActiveTicks = 200;
-      if (plan.appliedAt !== void 0 && metrics.tick - plan.appliedAt > maxActiveTicks) {
+      if (plan.appliedAt !== void 0 && metrics.tick - plan.appliedAt > this.maxActiveTicks) {
         settled.push(plan);
         continue;
       }
@@ -3296,9 +3341,9 @@ var DecisionLog = class {
       reasoning: this.buildReasoning(diagnosis, plan, result),
       metricsSnapshot: metrics
     };
-    this.entries.unshift(entry);
-    if (this.entries.length > this.maxEntries) {
-      this.entries.pop();
+    this.entries.push(entry);
+    if (this.entries.length > this.maxEntries * 1.5) {
+      this.entries = this.entries.slice(-this.maxEntries);
     }
     return entry;
   }
@@ -3313,8 +3358,10 @@ var DecisionLog = class {
       reasoning: reason,
       metricsSnapshot: metrics
     };
-    this.entries.unshift(entry);
-    if (this.entries.length > this.maxEntries) this.entries.pop();
+    this.entries.push(entry);
+    if (this.entries.length > this.maxEntries * 1.5) {
+      this.entries = this.entries.slice(-this.maxEntries);
+    }
   }
   query(filter) {
     return this.entries.filter((e) => {
@@ -3327,7 +3374,7 @@ var DecisionLog = class {
     });
   }
   latest(n = 30) {
-    return this.entries.slice(0, n);
+    return this.entries.slice(-n).reverse();
   }
   export(format = "json") {
     if (format === "text") {
@@ -3556,10 +3603,13 @@ var MetricStore = class {
 var PersonaTracker = class {
   constructor() {
     this.agentHistory = /* @__PURE__ */ new Map();
+    this.lastSeen = /* @__PURE__ */ new Map();
   }
   /** Ingest a state snapshot and update agent signal history */
   update(state) {
+    const tick = state.tick;
     for (const agentId of Object.keys(state.agentBalances)) {
+      this.lastSeen.set(agentId, tick);
       const history = this.agentHistory.get(agentId) ?? [];
       const inv = state.agentInventories[agentId] ?? {};
       const uniqueItems = Object.values(inv).filter((q) => q > 0).length;
@@ -3577,6 +3627,14 @@ var PersonaTracker = class {
       if (history.length > 50) history.shift();
       this.agentHistory.set(agentId, history);
     }
+    if (tick % 50 === 0) {
+      for (const [id, lastTick] of this.lastSeen) {
+        if (tick - lastTick > 100) {
+          this.agentHistory.delete(id);
+          this.lastSeen.delete(id);
+        }
+      }
+    }
   }
   /** Classify all agents and return persona distribution */
   getDistribution() {
@@ -3640,25 +3698,30 @@ var ParameterRegistry = class {
    * Resolve a parameterType + scope to a concrete RegisteredParameter.
    * Returns the best match, or undefined if no match.
    *
-   * Matching rules (in priority order):
-   * 1. Exact type match + all scope fields match
-   * 2. Exact type match + partial scope match (tags overlap)
-   * 3. Exact type match + no scope constraints
-   * 4. undefined (no match)
+   * Matching rules:
+   * 1. Filter candidates by type
+   * 2. Score each by scope specificity (system +10, currency +5, tags +3 each)
+   * 3. Mismatched scope fields disqualify (score = -Infinity)
+   * 4. Ties broken by `priority` (higher wins), then registration order
+   * 5. All disqualified → undefined
    */
   resolve(type, scope) {
     const candidates = this.findByType(type);
     if (candidates.length === 0) return void 0;
     if (candidates.length === 1) return candidates[0];
-    let bestScore = -1;
+    let bestScore = -Infinity;
+    let bestPriority = -Infinity;
     let best;
     for (const candidate of candidates) {
-      const score = this.scopeMatchScore(candidate.scope, scope);
-      if (score > bestScore) {
+      const score = this.scopeSpecificity(candidate.scope, scope);
+      const prio = candidate.priority ?? 0;
+      if (score > bestScore || score === bestScore && prio > bestPriority) {
         bestScore = score;
+        bestPriority = prio;
         best = candidate;
       }
     }
+    if (bestScore === -Infinity) return void 0;
     return best;
   }
   /** Find all parameters of a given type. */
@@ -3700,28 +3763,60 @@ var ParameterRegistry = class {
   get size() {
     return this.parameters.size;
   }
+  /**
+   * Validate the registry for common misconfigurations.
+   * Returns warnings (non-fatal) and errors (likely broken).
+   */
+  validate() {
+    const warnings = [];
+    const errors = [];
+    const typeMap = /* @__PURE__ */ new Map();
+    for (const param of this.parameters.values()) {
+      const list = typeMap.get(param.type) ?? [];
+      list.push(param);
+      typeMap.set(param.type, list);
+    }
+    for (const [type, params] of typeMap) {
+      if (params.length > 1) {
+        const unscopedCount = params.filter((p) => !p.scope).length;
+        if (unscopedCount > 1) {
+          errors.push(
+            `Type '${type}' has ${unscopedCount} unscoped parameters \u2014 resolve() cannot distinguish them`
+          );
+        }
+      }
+    }
+    for (const param of this.parameters.values()) {
+      if (!param.flowImpact) {
+        warnings.push(`Parameter '${param.key}' has no flowImpact \u2014 Simulator will use inference`);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      warnings,
+      errors
+    };
+  }
   // ── Private ─────────────────────────────────────────────────────────────
-  scopeMatchScore(paramScope, queryScope) {
+  scopeSpecificity(paramScope, queryScope) {
     if (!queryScope) return 0;
     if (!paramScope) return 0;
     let score = 0;
     if (queryScope.system && paramScope.system) {
       if (queryScope.system === paramScope.system) score += 10;
-      else return -1;
+      else return -Infinity;
     }
     if (queryScope.currency && paramScope.currency) {
       if (queryScope.currency === paramScope.currency) score += 5;
-      else return -1;
+      else return -Infinity;
     }
     if (queryScope.tags && queryScope.tags.length > 0 && paramScope.tags && paramScope.tags.length > 0) {
       const overlap = queryScope.tags.filter((t) => paramScope.tags.includes(t)).length;
       if (overlap > 0) {
         score += overlap * 3;
       } else {
-        return -1;
+        return -Infinity;
       }
-    } else if (queryScope.tags && queryScope.tags.length > 0 && paramScope.tags && paramScope.tags.length > 0) {
-      return -1;
     }
     return score;
   }
@@ -3731,7 +3826,6 @@ var ParameterRegistry = class {
 var AgentE = class {
   constructor(config) {
     this.planner = new Planner();
-    this.executor = new Executor();
     this.registry = new ParameterRegistry();
     // ── State ──
     this.log = new DecisionLog();
@@ -3753,6 +3847,9 @@ var AgentE = class {
       mode: this.mode,
       dominantRoles: config.dominantRoles ?? [],
       idealDistribution: config.idealDistribution ?? {},
+      validateRegistry: config.validateRegistry ?? true,
+      simulation: config.simulation ?? {},
+      settlementWindowTicks: config.settlementWindowTicks ?? 200,
       tickConfig: config.tickConfig ?? { duration: 1, unit: "tick" },
       gracePeriod: config.gracePeriod ?? 50,
       checkInterval: config.checkInterval ?? 5,
@@ -3773,7 +3870,13 @@ var AgentE = class {
     if (config.parameters) {
       this.registry.registerAll(config.parameters);
     }
-    this.simulator = new Simulator(this.registry);
+    if (config.validateRegistry !== false && this.registry.size > 0) {
+      const validation = this.registry.validate();
+      for (const w of validation.warnings) console.warn(`[AgentE] Registry warning: ${w}`);
+      for (const e of validation.errors) console.error(`[AgentE] Registry error: ${e}`);
+    }
+    this.executor = new Executor(config.settlementWindowTicks);
+    this.simulator = new Simulator(this.registry, config.simulation);
     if (config.onDecision) this.on("decision", config.onDecision);
     if (config.onAlert) this.on("alert", config.onAlert);
     if (config.onRollback) this.on("rollback", config.onRollback);
@@ -3809,7 +3912,7 @@ var AgentE = class {
     if (!this.isRunning || this.isPaused) return;
     const currentState = state ?? await Promise.resolve(this.adapter.getState());
     this.currentTick = currentState.tick;
-    const events = [...this.eventBuffer];
+    const events = this.eventBuffer;
     this.eventBuffer = [];
     let metrics;
     try {
@@ -3927,7 +4030,9 @@ var AgentE = class {
   // ── Events ──────────────────────────────────────────────────────────────────
   on(event, handler) {
     const list = this.handlers.get(event) ?? [];
-    list.push(handler);
+    if (!list.includes(handler)) {
+      list.push(handler);
+    }
     this.handlers.set(event, list);
     return this;
   }
@@ -3940,8 +4045,12 @@ var AgentE = class {
     const list = this.handlers.get(event) ?? [];
     let result;
     for (const handler of list) {
-      result = handler(...args);
-      if (result === false) return false;
+      try {
+        result = handler(...args);
+        if (result === false) return false;
+      } catch (err) {
+        console.error(`[AgentE] Handler error on '${event}':`, err);
+      }
     }
     return result;
   }
@@ -3969,6 +4078,31 @@ var AgentE = class {
   }
 };
 
+// src/utils.ts
+function findWorstSystem(metrics, check, tolerancePercent = 0) {
+  const systems = metrics.systems;
+  if (systems.length === 0) return void 0;
+  let worstSystem;
+  let worstScore = -Infinity;
+  let totalScore = 0;
+  for (const sys of systems) {
+    const score = check(sys, metrics);
+    totalScore += score;
+    if (score > worstScore) {
+      worstScore = score;
+      worstSystem = sys;
+    }
+  }
+  if (!worstSystem) return void 0;
+  if (tolerancePercent > 0 && systems.length > 1) {
+    const avg = totalScore / systems.length;
+    if (avg === 0) return { system: worstSystem, score: worstScore };
+    const excessPercent = (worstScore - avg) / Math.abs(avg) * 100;
+    if (excessPercent < tolerancePercent) return void 0;
+  }
+  return { system: worstSystem, score: worstScore };
+}
+
 // src/StateValidator.ts
 function validateEconomyState(state) {
   const errors = [];
@@ -4320,7 +4454,7 @@ function describeValue(value) {
   OPEN_ECONOMY_PRINCIPLES,
   OPERATIONS_PRINCIPLES,
   Observer,
-  P10_SpawnWeightingUsesInversePopulation,
+  P10_EntryWeightingUsesInversePopulation,
   P11_TwoTierPressure,
   P12_OnePrimaryFaucet,
   P13_PotsAreZeroSumAndSelfRegulate,
@@ -4340,9 +4474,9 @@ function describeValue(value) {
   P26_ContinuousPressureBeatsThresholdCuts,
   P27_AdjustmentsNeedCooldowns,
   P28_StructuralDominanceIsNotPathological,
-  P29_PinchPoint,
+  P29_BottleneckDetection,
   P2_ClosedLoopsNeedDirectHandoff,
-  P30_MovingPinchPoint,
+  P30_DynamicBottleneckRotation,
   P31_AnchorValueTracking,
   P32_VelocityAboveSupply,
   P33_FairNotEqual,
@@ -4365,16 +4499,16 @@ function describeValue(value) {
   P49_IdleAssetTax,
   P4_MaterialsFlowFasterThanCooldown,
   P50_PayPowerRatio,
-  P51_SharkTooth,
+  P51_CyclicalEngagement,
   P52_EndowmentEffect,
   P53_EventCompletionRate,
-  P54_LiveOpsCadence,
+  P54_OperationalCadence,
   P55_ArbitrageThermometer,
-  P56_ContentDropShock,
+  P56_SupplyShockAbsorption,
   P57_CombinatorialPriceSpace,
   P58_NoNaturalNumeraire,
   P59_GiftEconomyNoise,
-  P5_ProfitabilityIsCompetitive,
+  P5_ProfitabilityIsRelative,
   P60_SurplusDisposalAsymmetry,
   P6_CrowdingMultiplierOnAllRoles,
   P7_NonSpecialistsSubsidiseSpecialists,
@@ -4393,6 +4527,7 @@ function describeValue(value) {
   SYSTEM_DYNAMICS_PRINCIPLES,
   Simulator,
   emptyMetrics,
+  findWorstSystem,
   validateEconomyState
 });
 //# sourceMappingURL=index.js.map