@agent-e/core 1.1.0

package/dist/index.js

@@ -0,0 +1,3442 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ALL_PRINCIPLES: () => ALL_PRINCIPLES,
+  AgentE: () => AgentE,
+  BOOTSTRAP_PRINCIPLES: () => BOOTSTRAP_PRINCIPLES,
+  CURRENCY_FLOW_PRINCIPLES: () => CURRENCY_FLOW_PRINCIPLES,
+  DEFAULT_THRESHOLDS: () => DEFAULT_THRESHOLDS,
+  DecisionLog: () => DecisionLog,
+  Diagnoser: () => Diagnoser,
+  Executor: () => Executor,
+  FEEDBACK_LOOP_PRINCIPLES: () => FEEDBACK_LOOP_PRINCIPLES,
+  INCENTIVE_PRINCIPLES: () => INCENTIVE_PRINCIPLES,
+  LIVEOPS_PRINCIPLES: () => LIVEOPS_PRINCIPLES,
+  MARKET_DYNAMICS_PRINCIPLES: () => MARKET_DYNAMICS_PRINCIPLES,
+  MEASUREMENT_PRINCIPLES: () => MEASUREMENT_PRINCIPLES,
+  MetricStore: () => MetricStore,
+  OPEN_ECONOMY_PRINCIPLES: () => OPEN_ECONOMY_PRINCIPLES,
+  Observer: () => Observer,
+  P10_SpawnWeightingUsesInversePopulation: () => P10_SpawnWeightingUsesInversePopulation,
+  P11_TwoTierPressure: () => P11_TwoTierPressure,
+  P12_OnePrimaryFaucet: () => P12_OnePrimaryFaucet,
+  P13_PotsAreZeroSumAndSelfRegulate: () => P13_PotsAreZeroSumAndSelfRegulate,
+  P14_TrackActualInjection: () => P14_TrackActualInjection,
+  P15_PoolsNeedCapAndDecay: () => P15_PoolsNeedCapAndDecay,
+  P16_WithdrawalPenaltyScales: () => P16_WithdrawalPenaltyScales,
+  P17_GracePeriodBeforeIntervention: () => P17_GracePeriodBeforeIntervention,
+  P18_FirstProducerNeedsStartingInventory: () => P18_FirstProducerNeedsStartingInventory,
+  P19_StartingSupplyExceedsDemand: () => P19_StartingSupplyExceedsDemand,
+  P1_ProductionMatchesConsumption: () => P1_ProductionMatchesConsumption,
+  P20_DecayPreventsAccumulation: () => P20_DecayPreventsAccumulation,
+  P21_PriceFromGlobalSupply: () => P21_PriceFromGlobalSupply,
+  P22_MarketAwarenessPreventsSurplus: () => P22_MarketAwarenessPreventsSurplus,
+  P23_ProfitabilityFactorsFeasibility: () => P23_ProfitabilityFactorsFeasibility,
+  P24_BlockedAgentsDecayFaster: () => P24_BlockedAgentsDecayFaster,
+  P25_CorrectLeversForCorrectProblems: () => P25_CorrectLeversForCorrectProblems,
+  P26_ContinuousPressureBeatsThresholdCuts: () => P26_ContinuousPressureBeatsThresholdCuts,
+  P27_AdjustmentsNeedCooldowns: () => P27_AdjustmentsNeedCooldowns,
+  P28_StructuralDominanceIsNotPathological: () => P28_StructuralDominanceIsNotPathological,
+  P29_PinchPoint: () => P29_PinchPoint,
+  P2_ClosedLoopsNeedDirectHandoff: () => P2_ClosedLoopsNeedDirectHandoff,
+  P30_MovingPinchPoint: () => P30_MovingPinchPoint,
+  P31_AnchorValueTracking: () => P31_AnchorValueTracking,
+  P32_VelocityAboveSupply: () => P32_VelocityAboveSupply,
+  P33_FairNotEqual: () => P33_FairNotEqual,
+  P34_ExtractionRatio: () => P34_ExtractionRatio,
+  P35_DestructionCreatesValue: () => P35_DestructionCreatesValue,
+  P36_MechanicFrictionDetector: () => P36_MechanicFrictionDetector,
+  P37_LatecommerProblem: () => P37_LatecommerProblem,
+  P38_CommunicationPreventsRevolt: () => P38_CommunicationPreventsRevolt,
+  P39_TheLagPrinciple: () => P39_TheLagPrinciple,
+  P3_BootstrapCapitalCoversFirstTransaction: () => P3_BootstrapCapitalCoversFirstTransaction,
+  P40_ReplacementRate: () => P40_ReplacementRate,
+  P41_MultiResolutionMonitoring: () => P41_MultiResolutionMonitoring,
+  P42_TheMedianPrinciple: () => P42_TheMedianPrinciple,
+  P43_SimulationMinimum: () => P43_SimulationMinimum,
+  P44_ComplexityBudget: () => P44_ComplexityBudget,
+  P45_TimeBudget: () => P45_TimeBudget,
+  P46_PersonaDiversity: () => P46_PersonaDiversity,
+  P47_SmokeTest: () => P47_SmokeTest,
+  P48_CurrencyInsulation: () => P48_CurrencyInsulation,
+  P49_IdleAssetTax: () => P49_IdleAssetTax,
+  P4_MaterialsFlowFasterThanCooldown: () => P4_MaterialsFlowFasterThanCooldown,
+  P50_PayPowerRatio: () => P50_PayPowerRatio,
+  P51_SharkTooth: () => P51_SharkTooth,
+  P52_EndowmentEffect: () => P52_EndowmentEffect,
+  P53_EventCompletionRate: () => P53_EventCompletionRate,
+  P54_LiveOpsCadence: () => P54_LiveOpsCadence,
+  P55_ArbitrageThermometer: () => P55_ArbitrageThermometer,
+  P56_ContentDropShock: () => P56_ContentDropShock,
+  P57_CombinatorialPriceSpace: () => P57_CombinatorialPriceSpace,
+  P58_NoNaturalNumeraire: () => P58_NoNaturalNumeraire,
+  P59_GiftEconomyNoise: () => P59_GiftEconomyNoise,
+  P5_ProfitabilityIsCompetitive: () => P5_ProfitabilityIsCompetitive,
+  P60_SurplusDisposalAsymmetry: () => P60_SurplusDisposalAsymmetry,
+  P6_CrowdingMultiplierOnAllRoles: () => P6_CrowdingMultiplierOnAllRoles,
+  P7_NonSpecialistsSubsidiseSpecialists: () => P7_NonSpecialistsSubsidiseSpecialists,
+  P8_RegulatorCannotFightDesign: () => P8_RegulatorCannotFightDesign,
+  P9_RoleSwitchingNeedsFriction: () => P9_RoleSwitchingNeedsFriction,
+  PERSONA_HEALTHY_RANGES: () => PERSONA_HEALTHY_RANGES,
+  PLAYER_EXPERIENCE_PRINCIPLES: () => PLAYER_EXPERIENCE_PRINCIPLES,
+  POPULATION_PRINCIPLES: () => POPULATION_PRINCIPLES,
+  PersonaTracker: () => PersonaTracker,
+  Planner: () => Planner,
+  REGULATOR_PRINCIPLES: () => REGULATOR_PRINCIPLES,
+  RESOURCE_MGMT_PRINCIPLES: () => RESOURCE_MGMT_PRINCIPLES,
+  STATISTICAL_PRINCIPLES: () => STATISTICAL_PRINCIPLES,
+  SUPPLY_CHAIN_PRINCIPLES: () => SUPPLY_CHAIN_PRINCIPLES,
+  SYSTEM_DYNAMICS_PRINCIPLES: () => SYSTEM_DYNAMICS_PRINCIPLES,
+  Simulator: () => Simulator,
+  emptyMetrics: () => emptyMetrics
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/defaults.ts
+var DEFAULT_THRESHOLDS = {
+  // Statistical (P42-P43)
+  meanMedianDivergenceMax: 0.3,
+  simulationMinIterations: 100,
+  // Population (P46)
+  personaMonocultureMax: 0.4,
+  personaMinClusters: 3,
+  // Open Economy (P34, P47-P48)
+  extractionRatioYellow: 0.5,
+  extractionRatioRed: 0.65,
+  smokeTestWarning: 0.3,
+  smokeTestCritical: 0.1,
+  currencyInsulationMax: 0.5,
+  // Player Experience (P45, P50)
+  timeBudgetRatio: 0.8,
+  payPowerRatioMax: 2,
+  payPowerRatioTarget: 1.5,
+  // LiveOps (P51, P53)
+  sharkToothPeakDecay: 0.95,
+  sharkToothValleyDecay: 0.9,
+  eventCompletionMin: 0.4,
+  eventCompletionMax: 0.8,
+  // System Dynamics (P39, P44)
+  lagMultiplierMin: 3,
+  lagMultiplierMax: 5,
+  complexityBudgetMax: 20,
+  // Resource (P40)
+  replacementRateMultiplier: 2,
+  // Regulator (P26-P27)
+  maxAdjustmentPercent: 0.15,
+  cooldownTicks: 15,
+  // Currency (P13)
+  arenaWinRate: 0.65,
+  arenaHouseCut: 0.1,
+  // Population balance (P9)
+  roleSwitchFrictionMax: 0.05,
+  // >5% of population switching in one period = herd
+  // Pool limits (P15)
+  poolCapPercent: 0.05,
+  // no pool > 5% of total currency
+  poolDecayRate: 0.02,
+  // Profitability (P5)
+  stampedeProfitRatio: 3,
+  // one role's profit > 3× median → stampede risk
+  // Satisfaction (P24)
+  blockedAgentMaxFraction: 0.15,
+  // Gini (P33)
+  giniWarnThreshold: 0.45,
+  giniRedThreshold: 0.6,
+  // Churn (P9)
+  churnWarnRate: 0.05,
+  // Net flow (P12)
+  netFlowWarnThreshold: 10,
+  // V1.1 (P55-P60)
+  arbitrageIndexWarning: 0.35,
+  arbitrageIndexCritical: 0.55,
+  contentDropCooldownTicks: 30,
+  postDropArbitrageMax: 0.45,
+  relativePriceConvergenceTarget: 0.85,
+  priceDiscoveryWindowTicks: 20,
+  giftTradeFilterRatio: 0.15,
+  disposalTradeWeightDiscount: 0.5
+};
+var PERSONA_HEALTHY_RANGES = {
+  Gamer: { min: 0.2, max: 0.4 },
+  Trader: { min: 0.05, max: 0.15 },
+  Collector: { min: 0.05, max: 0.15 },
+  Speculator: { min: 0, max: 0.1 },
+  Earner: { min: 0, max: 0.15 },
+  Builder: { min: 0.05, max: 0.15 },
+  Social: { min: 0.1, max: 0.2 },
+  Whale: { min: 0, max: 0.05 },
+  Influencer: { min: 0, max: 0.05 }
+};
+
+// src/Observer.ts
+var Observer = class {
+  constructor() {
+    this.previousMetrics = null;
+    this.previousPrices = {};
+    this.customMetricFns = {};
+    this.anchorBaseline = null;
+  }
+  registerCustomMetric(name, fn) {
+    this.customMetricFns[name] = fn;
+  }
+  compute(state, recentEvents) {
+    const tick = state.tick;
+    const balances = Object.values(state.agentBalances);
+    const roles = Object.values(state.agentRoles);
+    const totalAgents = balances.length;
+    const totalSupply = balances.reduce((s, b) => s + b, 0);
+    const faucetVolume = recentEvents.filter((e) => e.type === "mint" || e.type === "spawn").reduce((s, e) => s + (e.amount ?? 0), 0);
+    const sinkVolume = recentEvents.filter((e) => e.type === "burn" || e.type === "consume").reduce((s, e) => s + (e.amount ?? 0), 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 tradeEvents = recentEvents.filter((e) => e.type === "trade");
+    const velocity = totalSupply > 0 ? tradeEvents.length / totalSupply : 0;
+    const sortedBalances = [...balances].sort((a, b) => a - b);
+    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 populationByRole = {};
+    const roleShares = {};
+    for (const role of roles) {
+      populationByRole[role] = (populationByRole[role] ?? 0) + 1;
+    }
+    for (const [role, count] of Object.entries(populationByRole)) {
+      roleShares[role] = count / Math.max(1, totalAgents);
+    }
+    const churnByRole = {};
+    const roleChanges = recentEvents.filter((e) => e.type === "churn" || e.type === "role_change");
+    for (const e of roleChanges) {
+      const role = e.role ?? "unknown";
+      churnByRole[role] = (churnByRole[role] ?? 0) + 1;
+    }
+    const churnCount = recentEvents.filter((e) => e.type === "churn").length;
+    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 supplyByResource = {};
+    for (const inv of Object.values(state.agentInventories)) {
+      for (const [resource, qty] of Object.entries(inv)) {
+        supplyByResource[resource] = (supplyByResource[resource] ?? 0) + qty;
+      }
+    }
+    const demandSignals = {};
+    for (const e of tradeEvents) {
+      if (e.resource) {
+        demandSignals[e.resource] = (demandSignals[e.resource] ?? 0) + (e.amount ?? 1);
+      }
+    }
+    const pinchPoints = {};
+    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) {
+        pinchPoints[resource] = "scarce";
+      } else if (s > 3 && d > 0 && s / d > 3) {
+        pinchPoints[resource] = "oversupplied";
+      } else {
+        pinchPoints[resource] = "optimal";
+      }
+    }
+    const productionIndex = recentEvents.filter((e) => e.type === "produce").reduce((s, e) => s + (e.amount ?? 1), 0);
+    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 = tick > 0 ? Math.max(0, 20 - tick * 0.1) : 20;
+    const poolSizes = { ...state.poolSizes ?? {} };
+    if (!this.anchorBaseline && tick === 1 && totalSupply > 0) {
+      this.anchorBaseline = {
+        goldPerHour: totalSupply / Math.max(1, totalAgents),
+        itemsPerGold: priceIndex > 0 ? 1 / priceIndex : 0
+      };
+    }
+    let anchorRatioDrift = 0;
+    if (this.anchorBaseline && totalAgents > 0) {
+      const currentGoldPerHour = totalSupply / totalAgents;
+      anchorRatioDrift = this.anchorBaseline.goldPerHour > 0 ? (currentGoldPerHour - this.anchorBaseline.goldPerHour) / this.anchorBaseline.goldPerHour : 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]];
+          const ratio = pA / pB;
+          totalDivergence += Math.abs(Math.log(ratio));
+          pairCount++;
+        }
+      }
+      arbitrageIndex = pairCount > 0 ? Math.min(1, totalDivergence / pairCount) : 0;
+    }
+    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 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 (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++;
+          }
+        }
+      }
+    }
+    const disposalTradeRatio = tradeEvents.length > 0 ? disposalTrades / tradeEvents.length : 0;
+    const custom = {};
+    for (const [name, fn] of Object.entries(this.customMetricFns)) {
+      try {
+        custom[name] = fn(state);
+      } catch {
+        custom[name] = NaN;
+      }
+    }
+    const metrics = {
+      tick,
+      timestamp: Date.now(),
+      totalSupply,
+      netFlow,
+      velocity,
+      inflationRate,
+      populationByRole,
+      roleShares,
+      totalAgents,
+      churnRate,
+      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;
+    return metrics;
+  }
+};
+function computeMedian(sorted) {
+  if (sorted.length === 0) return 0;
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? ((sorted[mid - 1] ?? 0) + (sorted[mid] ?? 0)) / 2 : sorted[mid] ?? 0;
+}
+function computeGini(sorted) {
+  const n = sorted.length;
+  if (n === 0) return 0;
+  const sum = sorted.reduce((a, b) => a + b, 0);
+  if (sum === 0) return 0;
+  let numerator = 0;
+  for (let i = 0; i < n; i++) {
+    numerator += (2 * (i + 1) - n - 1) * (sorted[i] ?? 0);
+  }
+  return Math.abs(numerator) / (n * sum);
+}
+
+// src/Diagnoser.ts
+var Diagnoser = class {
+  constructor(principles) {
+    this.principles = [];
+    this.principles = [...principles];
+  }
+  addPrinciple(principle) {
+    this.principles.push(principle);
+  }
+  removePrinciple(id) {
+    this.principles = this.principles.filter((p) => p.id !== id);
+  }
+  /**
+   * Run all principles against current metrics.
+   * Returns violations sorted by severity (highest first).
+   * Only one action is taken per cycle — the highest severity violation.
+   */
+  diagnose(metrics, thresholds) {
+    const diagnoses = [];
+    for (const principle of this.principles) {
+      try {
+        const result = principle.check(metrics, thresholds);
+        if (result.violated) {
+          diagnoses.push({
+            principle,
+            violation: result,
+            tick: metrics.tick
+          });
+        }
+      } catch (err) {
+        console.warn(`[AgentE] Principle ${principle.id} threw an error:`, err);
+      }
+    }
+    diagnoses.sort((a, b) => {
+      const severityDiff = b.violation.severity - a.violation.severity;
+      if (severityDiff !== 0) return severityDiff;
+      return b.violation.confidence - a.violation.confidence;
+    });
+    return diagnoses;
+  }
+  getPrinciples() {
+    return [...this.principles];
+  }
+};
+
+// src/types.ts
+function emptyMetrics(tick = 0) {
+  return {
+    tick,
+    timestamp: Date.now(),
+    totalSupply: 0,
+    netFlow: 0,
+    velocity: 0,
+    inflationRate: 0,
+    populationByRole: {},
+    roleShares: {},
+    totalAgents: 0,
+    churnRate: 0,
+    churnByRole: {},
+    personaDistribution: {},
+    giniCoefficient: 0,
+    medianBalance: 0,
+    meanBalance: 0,
+    top10PctShare: 0,
+    meanMedianDivergence: 0,
+    priceIndex: 0,
+    productionIndex: 0,
+    capacityUsage: 0,
+    prices: {},
+    priceVolatility: {},
+    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: {}
+  };
+}
+
+// src/principles/supply-chain.ts
+var P1_ProductionMatchesConsumption = {
+  id: "P1",
+  name: "Production Must Match Consumption",
+  category: "supply_chain",
+  description: "If producer rate < consumer rate, supply deficit kills the economy. 105 ore rotting at Forge (V0.4.6) happened because this was out of balance.",
+  check(metrics, _thresholds) {
+    const { supplyByResource, demandSignals, populationByRole } = metrics;
+    const violations = [];
+    for (const resource of Object.keys(demandSignals)) {
+      const demand = demandSignals[resource] ?? 0;
+      const supply = supplyByResource[resource] ?? 0;
+      if (demand > 5 && supply / Math.max(1, demand) < 0.5) {
+        violations.push(resource);
+      }
+    }
+    const crafters = (populationByRole["Crafter"] ?? 0) + (populationByRole["Alchemist"] ?? 0);
+    const consumers = populationByRole["Fighter"] ?? 0;
+    const productionDeficit = consumers > 0 && crafters / consumers < 0.1;
+    if (violations.length > 0 || productionDeficit) {
+      return {
+        violated: true,
+        severity: 7,
+        evidence: { scarceResources: violations, crafters, consumers },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: "decrease",
+          magnitude: 0.15,
+          reasoning: "Lower crafting cost to incentivise more production."
+        },
+        confidence: violations.length > 0 ? 0.85 : 0.6,
+        estimatedLag: 10
+      };
+    }
+    return { violated: false };
+  }
+};
+var P2_ClosedLoopsNeedDirectHandoff = {
+  id: "P2",
+  name: "Closed Loops Need Direct Handoff",
+  category: "supply_chain",
+  description: "Raw materials listed on an open market create noise and liquidity problems. Gatherers delivering ore directly to Crafters at the Forge is faster and cleaner.",
+  check(metrics, _thresholds) {
+    const { supplyByResource, prices, velocity } = metrics;
+    const ore = supplyByResource["ore"] ?? 0;
+    const wood = supplyByResource["wood"] ?? 0;
+    const orePrice = prices["ore"] ?? 0;
+    const woodPrice = prices["wood"] ?? 0;
+    const oreBacklog = ore > 50 && orePrice > 0;
+    const woodBacklog = wood > 50 && woodPrice > 0;
+    const stagnant = velocity < 3;
+    if ((oreBacklog || woodBacklog) && stagnant) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: { ore, wood, velocity },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "increase",
+          magnitude: 0.2,
+          reasoning: "Raise AH fees to discourage raw material listings. Direct hand-off at production zones is the correct channel."
+        },
+        confidence: 0.7,
+        estimatedLag: 5
+      };
+    }
+    return { violated: false };
+  }
+};
+var P3_BootstrapCapitalCoversFirstTransaction = {
+  id: "P3",
+  name: "Bootstrap Capital Covers First Transaction",
+  category: "supply_chain",
+  description: "A new producer must be able to afford their first transaction without selling anything first. Crafter starting with 15g but needing 30g to accept ore hand-off blocks the entire supply chain from tick 1.",
+  check(metrics, _thresholds) {
+    const { populationByRole, supplyByResource, prices } = metrics;
+    const crafters = populationByRole["Crafter"] ?? 0;
+    const alchemists = populationByRole["Alchemist"] ?? 0;
+    const weapons = supplyByResource["weapons"] ?? 0;
+    const potions = supplyByResource["potions"] ?? 0;
+    const crafterBootstrapFail = crafters > 0 && weapons === 0 && (prices["ore"] ?? 0) > 0;
+    const alchemistBootstrapFail = alchemists > 0 && potions === 0 && (prices["wood"] ?? 0) > 0;
+    if (crafterBootstrapFail || alchemistBootstrapFail) {
+      return {
+        violated: true,
+        severity: 8,
+        evidence: { crafters, alchemists, weapons, potions },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: "decrease",
+          magnitude: 0.3,
+          reasoning: "Producers cannot complete first transaction. Lower production cost to unblock bootstrap."
+        },
+        confidence: 0.8,
+        estimatedLag: 3
+      };
+    }
+    return { violated: false };
+  }
+};
+var P4_MaterialsFlowFasterThanCooldown = {
+  id: "P4",
+  name: "Materials Flow Faster Than Cooldown",
+  category: "supply_chain",
+  description: "Input delivery rate must exceed or match production cooldown rate. If Crafters craft every 5 ticks but only receive ore every 10 ticks, they starve regardless of supply levels.",
+  check(metrics, _thresholds) {
+    const { supplyByResource, populationByRole, velocity } = metrics;
+    const gatherers = populationByRole["Gatherer"] ?? 0;
+    const crafters = populationByRole["Crafter"] ?? 0;
+    const alchemists = populationByRole["Alchemist"] ?? 0;
+    const producers = crafters + alchemists;
+    const gathererToProcuderRatio = gatherers / Math.max(1, producers);
+    if (producers > 0 && gathererToProcuderRatio < 0.5 && velocity < 5) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: { gatherers, crafters, alchemists, gathererToProcuderRatio },
+        suggestedAction: {
+          parameter: "miningYield",
+          direction: "increase",
+          magnitude: 0.15,
+          reasoning: "Too few gatherers relative to producers. Increase yield to compensate."
+        },
+        confidence: 0.65,
+        estimatedLag: 8
+      };
+    }
+    const ore = supplyByResource["ore"] ?? 0;
+    const wood = supplyByResource["wood"] ?? 0;
+    if (ore > 80 || wood > 80) {
+      return {
+        violated: true,
+        severity: 4,
+        evidence: { ore, wood, gatherers, producers },
+        suggestedAction: {
+          parameter: "miningYield",
+          direction: "decrease",
+          magnitude: 0.2,
+          reasoning: "Raw materials piling up. Gatherers outpacing producers."
+        },
+        confidence: 0.8,
+        estimatedLag: 5
+      };
+    }
+    return { violated: false };
+  }
+};
+var P60_SurplusDisposalAsymmetry = {
+  id: "P60",
+  name: "Surplus Disposal Asymmetry",
+  category: "supply_chain",
+  description: "Most trades liquidate unwanted surplus, not deliberate production. Price signals from disposal trades are weaker demand indicators than production-for-sale trades \u2014 weight them accordingly.",
+  check(metrics, thresholds) {
+    const { disposalTradeRatio } = metrics;
+    if (disposalTradeRatio > 0.6) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: {
+          disposalTradeRatio,
+          discount: thresholds.disposalTradeWeightDiscount
+        },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: "decrease",
+          magnitude: 0.1,
+          reasoning: `${(disposalTradeRatio * 100).toFixed(0)}% of trades are surplus disposal. Price signals unreliable as demand indicators. Lower production costs to shift balance toward deliberate production-for-sale. ADVISORY: Weight disposal-trade prices at ${thresholds.disposalTradeWeightDiscount}\xD7 in index calculations.`
+        },
+        confidence: 0.65,
+        estimatedLag: 15
+      };
+    }
+    return { violated: false };
+  }
+};
+var SUPPLY_CHAIN_PRINCIPLES = [
+  P1_ProductionMatchesConsumption,
+  P2_ClosedLoopsNeedDirectHandoff,
+  P3_BootstrapCapitalCoversFirstTransaction,
+  P4_MaterialsFlowFasterThanCooldown,
+  P60_SurplusDisposalAsymmetry
+];
+
+// src/principles/incentives.ts
+var P5_ProfitabilityIsCompetitive = {
+  id: "P5",
+  name: "Profitability Is Competitive, 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 Traders happened because profit = transactions \xD7 10 with no competition denominator.",
+  check(metrics, thresholds) {
+    const { roleShares, populationByRole } = metrics;
+    const highShareRoles = [];
+    for (const [role, share] of Object.entries(roleShares)) {
+      if (share > 0.45) highShareRoles.push(role);
+    }
+    if (highShareRoles.length > 0) {
+      const dominantRole = highShareRoles[0];
+      return {
+        violated: true,
+        severity: 6,
+        evidence: {
+          dominantRole,
+          share: roleShares[dominantRole],
+          population: populationByRole[dominantRole]
+        },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "increase",
+          magnitude: thresholds.maxAdjustmentPercent,
+          reasoning: `${dominantRole} share at ${((roleShares[dominantRole] ?? 0) * 100).toFixed(0)}%. Likely stampede from non-competitive profitability formula. Raise market friction to slow role accumulation.`
+        },
+        confidence: 0.75,
+        estimatedLag: 15
+      };
+    }
+    return { violated: false };
+  }
+};
+var P6_CrowdingMultiplierOnAllRoles = {
+  id: "P6",
+  name: "Crowding Multiplier Applies to ALL Roles",
+  category: "incentive",
+  description: "Every role needs an inverse-population profitability scaling. A role without crowding pressure is a stampede waiting to happen.",
+  check(metrics, _thresholds) {
+    const { roleShares } = metrics;
+    for (const [role, share] of Object.entries(roleShares)) {
+      if (share > 0.35) {
+        return {
+          violated: true,
+          severity: 5,
+          evidence: { role, share },
+          suggestedAction: {
+            parameter: "craftingCost",
+            direction: "increase",
+            magnitude: 0.1,
+            reasoning: `${role} at ${(share * 100).toFixed(0)}% \u2014 no crowding pressure detected. Apply role-specific cost increase to simulate saturation.`
+          },
+          confidence: 0.7,
+          estimatedLag: 10
+        };
+      }
+    }
+    return { violated: false };
+  }
+};
+var P7_NonSpecialistsSubsidiseSpecialists = {
+  id: "P7",
+  name: "Non-Specialists Subsidise Specialists in Zero-Sum Games",
+  category: "incentive",
+  description: "In zero-sum pools (arena, 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.",
+  check(metrics, _thresholds) {
+    const { populationByRole, poolSizes } = metrics;
+    const arenaPot = poolSizes["arena"] ?? poolSizes["arenaPot"] ?? 0;
+    if (arenaPot <= 0) return { violated: false };
+    const fighters = populationByRole["Fighter"] ?? 0;
+    const total = metrics.totalAgents;
+    const fighterShare = fighters / Math.max(1, total);
+    if (fighterShare > 0.7 && arenaPot < 100) {
+      return {
+        violated: true,
+        severity: 6,
+        evidence: { fighterShare, arenaPot },
+        suggestedAction: {
+          parameter: "arenaEntryFee",
+          direction: "decrease",
+          magnitude: 0.1,
+          reasoning: "Arena pot draining \u2014 too many specialists, not enough subsidising non-specialists. Lower entry fee to attract diverse participants."
+        },
+        confidence: 0.75,
+        estimatedLag: 5
+      };
+    }
+    return { violated: false };
+  }
+};
+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. 55% Fighters), the regulator must know this and exempt that role from population suppression. AgentE at tick 1 seeing 55% Fighters and slashing arena rewards is overreach.",
+  check(metrics, _thresholds) {
+    const { roleShares, avgSatisfaction } = metrics;
+    if (avgSatisfaction < 45) {
+      const dominantRole = Object.entries(roleShares).sort((a, b) => b[1] - a[1])[0];
+      if (dominantRole && dominantRole[1] > 0.3) {
+        return {
+          violated: true,
+          severity: 4,
+          evidence: { dominantRole: dominantRole[0], share: dominantRole[1], avgSatisfaction },
+          suggestedAction: {
+            parameter: "arenaReward",
+            direction: "increase",
+            magnitude: 0.1,
+            reasoning: `Low satisfaction with ${dominantRole[0]} dominant. Regulator may be suppressing a structurally necessary role. Ease pressure on dominant role rewards.`
+          },
+          confidence: 0.55,
+          estimatedLag: 8
+        };
+      }
+    }
+    return { violated: false };
+  }
+};
+var INCENTIVE_PRINCIPLES = [
+  P5_ProfitabilityIsCompetitive,
+  P6_CrowdingMultiplierOnAllRoles,
+  P7_NonSpecialistsSubsidiseSpecialists,
+  P8_RegulatorCannotFightDesign
+];
+
+// src/principles/population.ts
+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.",
+  check(metrics, thresholds) {
+    const { churnByRole, roleShares } = metrics;
+    const totalChurn = Object.values(churnByRole).reduce((s, v) => s + v, 0);
+    if (totalChurn > thresholds.roleSwitchFrictionMax) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: { totalChurnRate: totalChurn, churnByRole },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: "increase",
+          magnitude: 0.05,
+          reasoning: `Role switch rate ${(totalChurn * 100).toFixed(1)}% exceeds friction threshold. Increase production costs to slow herd movement.`
+        },
+        confidence: 0.65,
+        estimatedLag: 20
+      };
+    }
+    void roleShares;
+    return { violated: false };
+  }
+};
+var P10_SpawnWeightingUsesInversePopulation = {
+  id: "P10",
+  name: "Spawn Weighting Uses Inverse Population",
+  category: "population",
+  description: "New agents should preferentially fill the least-populated roles. Flat spawn probability causes initial imbalances to compound.",
+  check(metrics, _thresholds) {
+    const { roleShares } = metrics;
+    if (Object.keys(roleShares).length === 0) return { violated: false };
+    const shares = Object.values(roleShares);
+    const mean = shares.reduce((s, v) => s + v, 0) / shares.length;
+    const variance = shares.reduce((s, v) => s + (v - mean) ** 2, 0) / shares.length;
+    const stdDev = Math.sqrt(variance);
+    if (stdDev > 0.2) {
+      const minRole = Object.entries(roleShares).sort((a, b) => a[1] - b[1])[0];
+      return {
+        violated: true,
+        severity: 4,
+        evidence: { roleShares, stdDev, leastPopulatedRole: minRole?.[0] },
+        suggestedAction: {
+          parameter: "miningYield",
+          direction: "increase",
+          magnitude: 0.05,
+          reasoning: `High role share variance (\u03C3=${stdDev.toFixed(2)}). Spawn weighting may not be filling under-populated roles. Increasing yield makes under-populated producer roles more attractive.`
+        },
+        confidence: 0.6,
+        estimatedLag: 20
+      };
+    }
+    return { violated: false };
+  }
+};
+var P11_TwoTierPressure = {
+  id: "P11",
+  name: "Two-Tier Pressure (Continuous + Hard)",
+  category: "population",
+  description: "Corrections only at thresholds create delayed response. Continuous gentle pressure (1% per tick toward ideal) plus hard cuts for extreme cases catches imbalances early.",
+  check(metrics, _thresholds) {
+    const { roleShares } = metrics;
+    for (const [role, share] of Object.entries(roleShares)) {
+      if (share > 0.45) {
+        return {
+          violated: true,
+          severity: 6,
+          evidence: { role, share },
+          suggestedAction: {
+            parameter: "auctionFee",
+            direction: "increase",
+            magnitude: 0.15,
+            reasoning: `${role} at ${(share * 100).toFixed(0)}% \u2014 continuous pressure was insufficient. Hard intervention needed alongside resumed continuous pressure.`
+          },
+          confidence: 0.8,
+          estimatedLag: 10
+        };
+      }
+    }
+    return { violated: false };
+  }
+};
+var P46_PersonaDiversity = {
+  id: "P46",
+  name: "Persona Diversity",
+  category: "population",
+  description: "Any single behavioral persona above 40% = monoculture. Need at least 3 distinct persona clusters each above 15%.",
+  check(metrics, thresholds) {
+    const { personaDistribution } = metrics;
+    if (Object.keys(personaDistribution).length === 0) return { violated: false };
+    for (const [persona, share] of Object.entries(personaDistribution)) {
+      if (share > thresholds.personaMonocultureMax) {
+        return {
+          violated: true,
+          severity: 5,
+          evidence: { dominantPersona: persona, share, personaDistribution },
+          suggestedAction: {
+            parameter: "arenaReward",
+            direction: "increase",
+            magnitude: 0.1,
+            reasoning: `${persona} persona at ${(share * 100).toFixed(0)}% \u2014 behavioral monoculture. Diversify reward structures to attract other persona types.`
+          },
+          confidence: 0.7,
+          estimatedLag: 30
+        };
+      }
+    }
+    const significantClusters = Object.values(personaDistribution).filter((s) => s >= 0.15).length;
+    if (significantClusters < thresholds.personaMinClusters) {
+      return {
+        violated: true,
+        severity: 3,
+        evidence: { significantClusters, required: thresholds.personaMinClusters },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "decrease",
+          magnitude: 0.05,
+          reasoning: `Only ${significantClusters} significant persona clusters (need ${thresholds.personaMinClusters}). Lower trade barriers to attract non-dominant persona types.`
+        },
+        confidence: 0.55,
+        estimatedLag: 40
+      };
+    }
+    return { violated: false };
+  }
+};
+var POPULATION_PRINCIPLES = [
+  P9_RoleSwitchingNeedsFriction,
+  P10_SpawnWeightingUsesInversePopulation,
+  P11_TwoTierPressure,
+  P46_PersonaDiversity
+];
+
+// src/principles/currency-flow.ts
+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.",
+  check(metrics, thresholds) {
+    const { netFlow, faucetVolume, sinkVolume } = metrics;
+    if (netFlow > thresholds.netFlowWarnThreshold) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: { netFlow, faucetVolume, sinkVolume },
+        suggestedAction: {
+          parameter: "craftingCost",
+          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: "craftingCost",
+          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
+      };
+    }
+    return { violated: false };
+  }
+};
+var P13_PotsAreZeroSumAndSelfRegulate = {
+  id: "P13",
+  name: "Pots Self-Regulate with Correct Multiplier",
+  category: "currency",
+  description: "Arena 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 } = metrics;
+    const arenaPot = poolSizes["arena"] ?? poolSizes["arenaPot"] ?? 0;
+    const fighters = metrics.populationByRole["Fighter"] ?? 0;
+    if (fighters > 5 && arenaPot < 50) {
+      const { arenaWinRate, arenaHouseCut } = thresholds;
+      const maxSustainableMultiplier = (1 - arenaHouseCut) / arenaWinRate;
+      return {
+        violated: true,
+        severity: 7,
+        evidence: { arenaPot, fighters, maxSustainableMultiplier },
+        suggestedAction: {
+          parameter: "arenaReward",
+          direction: "decrease",
+          magnitude: 0.15,
+          reasoning: `Arena pot at ${arenaPot.toFixed(0)}g with ${fighters} fighters. Sustainable multiplier \u2264 ${maxSustainableMultiplier.toFixed(2)}. Reduce reward multiplier to prevent pot drain.`
+        },
+        confidence: 0.85,
+        estimatedLag: 3
+      };
+    }
+    return { violated: false };
+  }
+};
+var P14_TrackActualInjection = {
+  id: "P14",
+  name: "Track Actual Gold Injection, Not Value Creation",
+  category: "currency",
+  description: 'Counting resource gathering as "gold injected" is a lie. Gold only enters when Fighters spawn (100-150g each). 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: "miningYield",
+          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
+      };
+    }
+    return { violated: false };
+  }
+};
+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.",
+  check(metrics, thresholds) {
+    const { poolSizes, totalSupply } = metrics;
+    const { poolCapPercent } = thresholds;
+    for (const [pool, size] of Object.entries(poolSizes)) {
+      if (pool === "arena" || pool === "arenaPot") continue;
+      const shareOfSupply = size / Math.max(1, totalSupply);
+      if (shareOfSupply > poolCapPercent * 2) {
+        return {
+          violated: true,
+          severity: 6,
+          evidence: { pool, size, shareOfSupply, cap: poolCapPercent },
+          suggestedAction: {
+            parameter: "auctionFee",
+            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
+        };
+      }
+    }
+    return { violated: false };
+  }
+};
+var P16_WithdrawalPenaltyScales = {
+  id: "P16",
+  name: "Withdrawal Penalty Scales with Lock Duration",
+  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 bankPool = poolSizes["bank"] ?? poolSizes["bankPool"] ?? 0;
+    const stakedEstimate = totalSupply * 0.15;
+    if (bankPool < 10 && stakedEstimate > 100) {
+      return {
+        violated: true,
+        severity: 3,
+        evidence: { bankPool, estimatedStaked: stakedEstimate },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "increase",
+          magnitude: 0.05,
+          reasoning: "Bank pool depleted while significant gold should be staked. Early withdrawals may be draining yield pool. Ensure withdrawal penalty scales with lock duration."
+        },
+        confidence: 0.45,
+        estimatedLag: 10
+      };
+    }
+    return { violated: false };
+  }
+};
+var P32_VelocityAboveSupply = {
+  id: "P32",
+  name: "Velocity > Supply for Liquidity",
+  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 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: "auctionFee",
+          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
+      };
+    }
+    return { violated: false };
+  }
+};
+var P58_NoNaturalNumeraire = {
+  id: "P58",
+  name: "No Natural Num\xE9raire",
+  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: "craftingCost",
+          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
+      };
+    }
+    return { violated: false };
+  }
+};
+var CURRENCY_FLOW_PRINCIPLES = [
+  P12_OnePrimaryFaucet,
+  P13_PotsAreZeroSumAndSelfRegulate,
+  P14_TrackActualInjection,
+  P15_PoolsNeedCapAndDecay,
+  P16_WithdrawalPenaltyScales,
+  P32_VelocityAboveSupply,
+  P58_NoNaturalNumeraire
+];
+
+// src/principles/bootstrap.ts
+var P17_GracePeriodBeforeIntervention = {
+  id: "P17",
+  name: "Grace Period Before Intervention",
+  category: "bootstrap",
+  description: "Any intervention before tick 50 is premature. The economy needs time to bootstrap with designed distributions. AgentE intervening at tick 1 against 55% Fighters (designed) killed the economy instantly.",
+  check(metrics, _thresholds) {
+    if (metrics.tick < 30 && metrics.avgSatisfaction < 40) {
+      return {
+        violated: true,
+        severity: 7,
+        evidence: { tick: metrics.tick, avgSatisfaction: metrics.avgSatisfaction },
+        suggestedAction: {
+          parameter: "arenaEntryFee",
+          direction: "decrease",
+          magnitude: 0.2,
+          reasoning: `Very low satisfaction at tick ${metrics.tick}. Intervention may have fired during grace period. Ease all costs to let economy bootstrap.`
+        },
+        confidence: 0.7,
+        estimatedLag: 10
+      };
+    }
+    return { violated: false };
+  }
+};
+var P18_FirstProducerNeedsStartingInventory = {
+  id: "P18",
+  name: "First Producer Needs Starting Inventory + Capital",
+  category: "bootstrap",
+  description: "A Crafter with 0 weapons and 0 gold must sell nothing to get gold before they can buy ore. This creates a chicken-and-egg freeze. Starting inventory (2 weapons + 4 ore + 40g) breaks the deadlock.",
+  check(metrics, _thresholds) {
+    if (metrics.tick > 20) return { violated: false };
+    const weapons = metrics.supplyByResource["weapons"] ?? 0;
+    const potions = metrics.supplyByResource["potions"] ?? 0;
+    const crafters = metrics.populationByRole["Crafter"] ?? 0;
+    const alchemists = metrics.populationByRole["Alchemist"] ?? 0;
+    if (crafters > 0 && weapons === 0 || alchemists > 0 && potions === 0) {
+      return {
+        violated: true,
+        severity: 8,
+        evidence: { tick: metrics.tick, weapons, potions, crafters, alchemists },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: "decrease",
+          magnitude: 0.5,
+          reasoning: "Bootstrap failure: producers have no products on tick 1-20. Drastically reduce production cost to allow immediate output."
+        },
+        confidence: 0.9,
+        estimatedLag: 2
+      };
+    }
+    return { violated: false };
+  }
+};
+var P19_StartingSupplyExceedsDemand = {
+  id: "P19",
+  name: "Starting Supply Exceeds Initial Demand",
+  category: "bootstrap",
+  description: "Launch with more consumables than you think you need. Early scarcity creates an AH gridlock where everyone wants to buy and nobody has anything to sell.",
+  check(metrics, _thresholds) {
+    if (metrics.tick > 30) return { violated: false };
+    const fighters = metrics.populationByRole["Fighter"] ?? 0;
+    const weapons = metrics.supplyByResource["weapons"] ?? 0;
+    const potions = metrics.supplyByResource["potions"] ?? 0;
+    if (fighters > 5 && weapons < fighters * 0.5) {
+      return {
+        violated: true,
+        severity: 6,
+        evidence: { fighters, weapons, potions, weaponsPerFighter: weapons / Math.max(1, fighters) },
+        suggestedAction: {
+          parameter: "arenaReward",
+          direction: "increase",
+          magnitude: 0.2,
+          reasoning: `${fighters} fighters but only ${weapons} weapons. Cold-start scarcity. Boost arena reward to attract fighters even without weapons.`
+        },
+        confidence: 0.75,
+        estimatedLag: 5
+      };
+    }
+    return { violated: false };
+  }
+};
+var BOOTSTRAP_PRINCIPLES = [
+  P17_GracePeriodBeforeIntervention,
+  P18_FirstProducerNeedsStartingInventory,
+  P19_StartingSupplyExceedsDemand
+];
+
+// src/principles/feedback-loops.ts
+var P20_DecayPreventsAccumulation = {
+  id: "P20",
+  name: "Decay Prevents Accumulation",
+  category: "feedback",
+  description: "Resources without decay create infinite hoarding. A Gatherer who never sells has 500 ore rotting in their pocket while Crafters starve. 2-10% decay per period forces circulation.",
+  check(metrics, _thresholds) {
+    const { supplyByResource, velocity, totalAgents } = metrics;
+    const totalResources = Object.values(supplyByResource).reduce((s, v) => s + v, 0);
+    const resourcesPerAgent = totalResources / Math.max(1, totalAgents);
+    if (resourcesPerAgent > 20 && velocity < 3) {
+      return {
+        violated: true,
+        severity: 4,
+        evidence: { totalResources, resourcesPerAgent, velocity },
+        suggestedAction: {
+          parameter: "miningYield",
+          direction: "decrease",
+          magnitude: 0.1,
+          reasoning: `${totalResources.toFixed(0)} resources with velocity ${velocity}/t. Likely hoarding. Reduce yield to increase scarcity and force circulation.`
+        },
+        confidence: 0.65,
+        estimatedLag: 15
+      };
+    }
+    return { violated: false };
+  }
+};
+var P21_PriceFromGlobalSupply = {
+  id: "P21",
+  name: "Price Reflects Global Supply, Not Just AH Listings",
+  category: "feedback",
+  description: "If prices only update from Auction House activity, agents with hoarded inventory see artificially high prices and keep gathering when they should stop.",
+  check(metrics, _thresholds) {
+    const { priceVolatility, supplyByResource, prices } = metrics;
+    for (const resource of Object.keys(prices)) {
+      const volatility = priceVolatility[resource] ?? 0;
+      const supply = supplyByResource[resource] ?? 0;
+      if (volatility > 0.3 && supply > 30) {
+        return {
+          violated: true,
+          severity: 3,
+          evidence: { resource, volatility, supply, price: prices[resource] },
+          suggestedAction: {
+            parameter: "auctionFee",
+            direction: "increase",
+            magnitude: 0.05,
+            reasoning: `${resource} price volatile (${(volatility * 100).toFixed(0)}%) despite supply ${supply}. Price may not reflect global inventory. Increase trading friction to stabilise.`
+          },
+          confidence: 0.55,
+          estimatedLag: 10
+        };
+      }
+    }
+    return { violated: false };
+  }
+};
+var P22_MarketAwarenessPreventsSurplus = {
+  id: "P22",
+  name: "Market Awareness Prevents Overproduction",
+  category: "feedback",
+  description: "Producers who craft without checking market prices will create surpluses that crash prices. Agents need to see prices before deciding to produce.",
+  check(metrics, _thresholds) {
+    const { supplyByResource, prices, productionIndex } = metrics;
+    const weapons = supplyByResource["weapons"] ?? 0;
+    const weaponPrice = prices["weapons"] ?? 0;
+    const healthyWeaponPrice = 30;
+    if (weapons > 100 && weaponPrice < healthyWeaponPrice * 0.5 && productionIndex > 0) {
+      return {
+        violated: true,
+        severity: 4,
+        evidence: { weapons, weaponPrice, productionIndex },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: "increase",
+          magnitude: 0.1,
+          reasoning: `${weapons} weapons with price ${weaponPrice.toFixed(0)}g but still producing. Producers appear unaware of market. Raise production cost to slow output.`
+        },
+        confidence: 0.7,
+        estimatedLag: 8
+      };
+    }
+    return { violated: false };
+  }
+};
+var P23_ProfitabilityFactorsFeasibility = {
+  id: "P23",
+  name: "Profitability Factors Execution Feasibility",
+  category: "feedback",
+  description: "An agent who calculates profit = weapon_price - ore_cost but has no gold to buy ore is chasing phantom profit. Feasibility (can I afford the inputs?) must be part of the profitability calc.",
+  check(metrics, _thresholds) {
+    const { avgSatisfaction, blockedAgentCount, totalAgents } = metrics;
+    const blockedFraction = blockedAgentCount / Math.max(1, totalAgents);
+    if (blockedFraction > 0.2 && avgSatisfaction < 60) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: { blockedFraction, blockedAgentCount, avgSatisfaction },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: "decrease",
+          magnitude: 0.15,
+          reasoning: `${(blockedFraction * 100).toFixed(0)}% of agents blocked with low satisfaction. Agents may have roles they cannot afford to execute. Lower production costs to restore feasibility.`
+        },
+        confidence: 0.7,
+        estimatedLag: 5
+      };
+    }
+    return { violated: false };
+  }
+};
+var P24_BlockedAgentsDecayFaster = {
+  id: "P24",
+  name: "Blocked Agents Decay Faster",
+  category: "feedback",
+  description: "An agent who cannot perform their preferred activity loses satisfaction faster and churns sooner. Blocked agents must be identified and unblocked, or they become silent bottlenecks that skew churn data.",
+  check(metrics, thresholds) {
+    const { blockedAgentCount, totalAgents, churnRate } = metrics;
+    const blockedFraction = blockedAgentCount / Math.max(1, totalAgents);
+    if (blockedFraction > thresholds.blockedAgentMaxFraction) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: { blockedFraction, blockedAgentCount, churnRate },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "decrease",
+          magnitude: 0.15,
+          reasoning: `${(blockedFraction * 100).toFixed(0)}% of agents blocked. Blocked agents churn silently, skewing metrics. Lower fees to unblock market participation.`
+        },
+        confidence: 0.75,
+        estimatedLag: 5
+      };
+    }
+    return { violated: false };
+  }
+};
+var FEEDBACK_LOOP_PRINCIPLES = [
+  P20_DecayPreventsAccumulation,
+  P21_PriceFromGlobalSupply,
+  P22_MarketAwarenessPreventsSurplus,
+  P23_ProfitabilityFactorsFeasibility,
+  P24_BlockedAgentsDecayFaster
+];
+
+// src/principles/regulator.ts
+var P25_CorrectLeversForCorrectProblems = {
+  id: "P25",
+  name: "Target the Correct Lever",
+  category: "regulator",
+  description: "Adjusting sinks for supply-side inflation is wrong. Inflation from too much gathering \u2192 reduce mining yield. Inflation from pot payout \u2192 reduce reward multiplier. Matching lever to cause prevents oscillation.",
+  check(metrics, thresholds) {
+    const { netFlow, supplyByResource } = metrics;
+    const ore = supplyByResource["ore"] ?? 0;
+    const wood = supplyByResource["wood"] ?? 0;
+    const resourceFlood = ore + wood > 100;
+    if (netFlow > thresholds.netFlowWarnThreshold && resourceFlood) {
+      return {
+        violated: true,
+        severity: 4,
+        evidence: { netFlow, ore, wood },
+        suggestedAction: {
+          parameter: "miningYield",
+          direction: "decrease",
+          magnitude: 0.15,
+          reasoning: `Inflation with raw material backlog (ore ${ore}, wood ${wood}). Root cause is gathering. Correct lever: miningYield, not fees.`
+        },
+        confidence: 0.75,
+        estimatedLag: 8
+      };
+    }
+    return { violated: false };
+  }
+};
+var P26_ContinuousPressureBeatsThresholdCuts = {
+  id: "P26",
+  name: "Continuous 1%/tick > One-Time 10% Cut",
+  category: "regulator",
+  description: "Large one-time adjustments cause overshoot and oscillation. 1% per tick for 10 ticks reaches the same destination with far less disruption. This principle is enforced by maxAdjustmentPercent in the Planner.",
+  check(metrics, thresholds) {
+    const { inflationRate } = metrics;
+    if (Math.abs(inflationRate) > 0.2) {
+      return {
+        violated: true,
+        severity: 4,
+        evidence: { inflationRate },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: inflationRate > 0 ? "increase" : "decrease",
+          magnitude: Math.min(thresholds.maxAdjustmentPercent, 0.05),
+          // force smaller step
+          reasoning: `Inflation rate ${(inflationRate * 100).toFixed(1)}% \u2014 possible oscillation. Apply smaller correction to avoid overshoot.`
+        },
+        confidence: 0.6,
+        estimatedLag: 5
+      };
+    }
+    return { violated: false };
+  }
+};
+var P27_AdjustmentsNeedCooldowns = {
+  id: "P27",
+  name: "Adjustments Need Cooldowns",
+  category: "regulator",
+  description: "Adjusting the same parameter twice in a window causes oscillation. Minimum 15 ticks between same-parameter adjustments. This is enforced in the Planner but checked here as a diagnostic.",
+  check(metrics, _thresholds) {
+    const { churnRate, avgSatisfaction } = metrics;
+    if (churnRate > 0.08 && avgSatisfaction < 50) {
+      return {
+        violated: true,
+        severity: 4,
+        evidence: { churnRate, avgSatisfaction },
+        suggestedAction: {
+          parameter: "arenaEntryFee",
+          direction: "decrease",
+          magnitude: 0.05,
+          reasoning: `High churn (${(churnRate * 100).toFixed(1)}%) with low satisfaction. Possible oscillation from rapid adjustments. Apply small correction only.`
+        },
+        confidence: 0.5,
+        estimatedLag: 10
+      };
+    }
+    return { violated: false };
+  }
+};
+var P28_StructuralDominanceIsNotPathological = {
+  id: "P28",
+  name: "Structural Dominance \u2260 Pathological Monopoly",
+  category: "regulator",
+  description: 'A designed Fighter majority (55%) should not trigger population suppression. AgentE must distinguish between "this role is dominant BY DESIGN" (configured via dominantRoles) and "this role took over unexpectedly".',
+  check(metrics, _thresholds) {
+    const { roleShares, avgSatisfaction } = metrics;
+    const dominant = Object.entries(roleShares).sort((a, b) => b[1] - a[1])[0];
+    if (!dominant) return { violated: false };
+    const [dominantRole, dominantShare] = dominant;
+    if (dominantShare > 0.4 && avgSatisfaction > 70) {
+      return { violated: false };
+    }
+    if (dominantShare > 0.4 && avgSatisfaction < 50) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: { dominantRole, dominantShare, avgSatisfaction },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: "decrease",
+          magnitude: 0.1,
+          reasoning: `${dominantRole} dominant (${(dominantShare * 100).toFixed(0)}%) with low satisfaction. Pathological dominance \u2014 agents trapped, not thriving. Ease costs to allow role switching.`
+        },
+        confidence: 0.65,
+        estimatedLag: 15
+      };
+    }
+    return { violated: false };
+  }
+};
+var P38_CommunicationPreventsRevolt = {
+  id: "P38",
+  name: "Communication Prevents Revolt",
+  category: "regulator",
+  description: "Every adjustment must be logged with reasoning. An adjustment made without explanation to players causes revolt. AgentE logs every decision \u2014 this principle checks that logging is active.",
+  check(metrics, _thresholds) {
+    const { churnRate } = metrics;
+    if (churnRate > 0.1) {
+      return {
+        violated: true,
+        severity: 3,
+        evidence: { churnRate },
+        suggestedAction: {
+          parameter: "arenaReward",
+          direction: "increase",
+          magnitude: 0.1,
+          reasoning: `High churn (${(churnRate * 100).toFixed(1)}%) \u2014 agents leaving. Ensure all recent adjustments are logged with reasoning to diagnose cause.`
+        },
+        confidence: 0.5,
+        estimatedLag: 10
+      };
+    }
+    return { violated: false };
+  }
+};
+var REGULATOR_PRINCIPLES = [
+  P25_CorrectLeversForCorrectProblems,
+  P26_ContinuousPressureBeatsThresholdCuts,
+  P27_AdjustmentsNeedCooldowns,
+  P28_StructuralDominanceIsNotPathological,
+  P38_CommunicationPreventsRevolt
+];
+
+// src/principles/market-dynamics.ts
+var P29_PinchPoint = {
+  id: "P29",
+  name: "Pinch Point",
+  category: "market_dynamics",
+  description: "Every economy has a resource that constrains all downstream activity. In AgentE v0: weapons are the pinch point (Fighters need them, Crafters make them). If demand drops \u2192 oversupply. If frustration rises \u2192 undersupply.",
+  check(metrics, _thresholds) {
+    const { pinchPoints, supplyByResource, demandSignals } = metrics;
+    for (const [resource, status] of Object.entries(pinchPoints)) {
+      if (status === "scarce") {
+        const supply = supplyByResource[resource] ?? 0;
+        const demand = demandSignals[resource] ?? 0;
+        return {
+          violated: true,
+          severity: 7,
+          evidence: { resource, supply, demand, status },
+          suggestedAction: {
+            parameter: "craftingCost",
+            direction: "decrease",
+            magnitude: 0.15,
+            reasoning: `${resource} is a pinch point and currently SCARCE (supply ${supply}, demand ${demand}). Reduce production cost to increase throughput.`
+          },
+          confidence: 0.8,
+          estimatedLag: 5
+        };
+      }
+      if (status === "oversupplied") {
+        const supply = supplyByResource[resource] ?? 0;
+        return {
+          violated: true,
+          severity: 4,
+          evidence: { resource, supply, status },
+          suggestedAction: {
+            parameter: "craftingCost",
+            direction: "increase",
+            magnitude: 0.1,
+            reasoning: `${resource} is a pinch point and OVERSUPPLIED (supply ${supply}). Raise production cost to reduce surplus.`
+          },
+          confidence: 0.7,
+          estimatedLag: 8
+        };
+      }
+    }
+    return { violated: false };
+  }
+};
+var P30_MovingPinchPoint = {
+  id: "P30",
+  name: "Moving Pinch Point",
+  category: "market_dynamics",
+  description: "Player progression shifts the demand curve. A static pinch point that works at level 1 will be cleared at level 10. The pinch point must move with the player to maintain ongoing scarcity and engagement.",
+  check(metrics, _thresholds) {
+    const { capacityUsage, supplyByResource, avgSatisfaction } = metrics;
+    const totalResources = Object.values(supplyByResource).reduce((s, v) => s + v, 0);
+    const resourcesPerAgent = totalResources / Math.max(1, metrics.totalAgents);
+    if (capacityUsage > 0.9 && resourcesPerAgent > 15 && avgSatisfaction > 75) {
+      return {
+        violated: true,
+        severity: 3,
+        evidence: { capacityUsage, resourcesPerAgent, avgSatisfaction },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: "increase",
+          magnitude: 0.1,
+          reasoning: "Economy operating at full capacity with abundant resources and high satisfaction. Pinch point may have been cleared. Increase production cost to restore scarcity."
+        },
+        confidence: 0.55,
+        estimatedLag: 20
+      };
+    }
+    return { violated: false };
+  }
+};
+var P57_CombinatorialPriceSpace = {
+  id: "P57",
+  name: "Combinatorial Price Space",
+  category: "market_dynamics",
+  description: "N tradeable items generate (N\u22121)N/2 relative prices. With thousands of items no single agent can track them all. Design for distributed self-organization, not centralized pricing.",
+  check(metrics, thresholds) {
+    const { prices, priceVolatility } = metrics;
+    const priceKeys = Object.keys(prices);
+    const n = priceKeys.length;
+    const relativePriceCount = n * (n - 1) / 2;
+    if (n < 2) return { violated: false };
+    let convergedPairs = 0;
+    for (let i = 0; i < priceKeys.length; i++) {
+      for (let j = i + 1; j < priceKeys.length; j++) {
+        const volA = priceVolatility[priceKeys[i]] ?? 0;
+        const volB = priceVolatility[priceKeys[j]] ?? 0;
+        if (volA < 0.2 && volB < 0.2) {
+          convergedPairs++;
+        }
+      }
+    }
+    const convergenceRate = convergedPairs / Math.max(1, relativePriceCount);
+    if (convergenceRate < thresholds.relativePriceConvergenceTarget && n >= 4) {
+      return {
+        violated: true,
+        severity: 4,
+        evidence: {
+          totalItems: n,
+          relativePriceCount,
+          convergedPairs,
+          convergenceRate,
+          target: thresholds.relativePriceConvergenceTarget
+        },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "decrease",
+          magnitude: 0.1,
+          reasoning: `Only ${(convergenceRate * 100).toFixed(0)}% of ${relativePriceCount} relative prices have converged (target: ${(thresholds.relativePriceConvergenceTarget * 100).toFixed(0)}%). Price space too complex for distributed discovery. Lower friction to help.`
+        },
+        confidence: 0.6,
+        estimatedLag: thresholds.priceDiscoveryWindowTicks
+      };
+    }
+    return { violated: false };
+  }
+};
+var MARKET_DYNAMICS_PRINCIPLES = [
+  P29_PinchPoint,
+  P30_MovingPinchPoint,
+  P57_CombinatorialPriceSpace
+];
+
+// src/principles/measurement.ts
+var P31_AnchorValueTracking = {
+  id: "P31",
+  name: "Anchor Value Tracking",
+  category: "measurement",
+  description: "1 hour of play = X gold = Y items. If this ratio drifts, the economy is inflating or deflating in ways that players feel before metrics catch it. Track the ratio constantly.",
+  check(metrics, _thresholds) {
+    const { anchorRatioDrift, inflationRate } = metrics;
+    if (Math.abs(anchorRatioDrift) > 0.25) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: { anchorRatioDrift, inflationRate },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: anchorRatioDrift > 0 ? "increase" : "decrease",
+          magnitude: 0.1,
+          reasoning: `Anchor ratio has drifted ${(anchorRatioDrift * 100).toFixed(0)}% from baseline. Time-to-value for players is changing. Adjust production costs to restore.`
+        },
+        confidence: 0.65,
+        estimatedLag: 10
+      };
+    }
+    return { violated: false };
+  }
+};
+var P41_MultiResolutionMonitoring = {
+  id: "P41",
+  name: "Multi-Resolution Monitoring",
+  category: "measurement",
+  description: "Single-resolution monitoring misses crises that develop slowly (coarse only) or explode suddenly (fine only). Monitor at fine (per-tick), medium (per-10-ticks), and coarse (per-100-ticks) simultaneously.",
+  check(metrics, _thresholds) {
+    const { giniCoefficient, avgSatisfaction } = metrics;
+    if (giniCoefficient > 0.5 && avgSatisfaction > 65) {
+      return {
+        violated: true,
+        severity: 4,
+        evidence: { giniCoefficient, avgSatisfaction },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "increase",
+          magnitude: 0.1,
+          reasoning: `Gini ${giniCoefficient.toFixed(2)} rising despite okay satisfaction. Early warning from fine-resolution monitoring. Raise trading fees to slow wealth concentration before it hurts satisfaction.`
+        },
+        confidence: 0.7,
+        estimatedLag: 20
+      };
+    }
+    return { violated: false };
+  }
+};
+var P55_ArbitrageThermometer = {
+  id: "P55",
+  name: "Arbitrage Thermometer",
+  category: "measurement",
+  description: "A virtual economy is never in true equilibrium \u2014 it oscillates around it. The aggregate arbitrage window across relative prices is a live health metric: rising arbitrage signals destabilization, falling signals recovery.",
+  check(metrics, thresholds) {
+    const { arbitrageIndex } = metrics;
+    if (arbitrageIndex > thresholds.arbitrageIndexCritical) {
+      return {
+        violated: true,
+        severity: 7,
+        evidence: {
+          arbitrageIndex,
+          warning: thresholds.arbitrageIndexWarning,
+          critical: thresholds.arbitrageIndexCritical
+        },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "decrease",
+          magnitude: 0.15,
+          reasoning: `Arbitrage index ${arbitrageIndex.toFixed(2)} exceeds critical threshold (${thresholds.arbitrageIndexCritical}). Relative prices are diverging \u2014 economy destabilizing. Lower trading friction to accelerate price convergence.`
+        },
+        confidence: 0.8,
+        estimatedLag: 8
+      };
+    }
+    if (arbitrageIndex > thresholds.arbitrageIndexWarning) {
+      return {
+        violated: true,
+        severity: 4,
+        evidence: {
+          arbitrageIndex,
+          warning: thresholds.arbitrageIndexWarning
+        },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "decrease",
+          magnitude: 0.08,
+          reasoning: `Arbitrage index ${arbitrageIndex.toFixed(2)} above warning threshold (${thresholds.arbitrageIndexWarning}). Early sign of price divergence. Gently reduce friction to support self-correction.`
+        },
+        confidence: 0.65,
+        estimatedLag: 12
+      };
+    }
+    return { violated: false };
+  }
+};
+var P59_GiftEconomyNoise = {
+  id: "P59",
+  name: "Gift-Economy Noise",
+  category: "measurement",
+  description: "Non-market exchanges \u2014 gifts, charity trades, social signaling \u2014 contaminate price signals. Filter gift-like and below-market transactions before computing economic indicators.",
+  check(metrics, thresholds) {
+    const { giftTradeRatio } = metrics;
+    if (giftTradeRatio > thresholds.giftTradeFilterRatio) {
+      return {
+        violated: true,
+        severity: 4,
+        evidence: {
+          giftTradeRatio,
+          threshold: thresholds.giftTradeFilterRatio
+        },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "increase",
+          magnitude: 0.05,
+          reasoning: `${(giftTradeRatio * 100).toFixed(0)}% of trades are gift-like (price = 0 or <30% market). Exceeds filter threshold (${(thresholds.giftTradeFilterRatio * 100).toFixed(0)}%). Price signals contaminated. Slightly raise trading fees to discourage zero-value listings. ADVISORY: Consider filtering sub-market trades from price index computation.`
+        },
+        confidence: 0.7,
+        estimatedLag: 5
+      };
+    }
+    return { violated: false };
+  }
+};
+var MEASUREMENT_PRINCIPLES = [
+  P31_AnchorValueTracking,
+  P41_MultiResolutionMonitoring,
+  P55_ArbitrageThermometer,
+  P59_GiftEconomyNoise
+];
+
+// src/principles/statistical.ts
+var P42_TheMedianPrinciple = {
+  id: "P42",
+  name: "The Median Principle",
+  category: "statistical",
+  description: "When (mean - median) / median > 0.3, mean is a lie. A few whales with 10,000g raise the mean while most agents have 50g. 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: "auctionFee",
+          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
+      };
+    }
+    return { violated: false };
+  }
+};
+var P43_SimulationMinimum = {
+  id: "P43",
+  name: "Simulation Minimum (100 Iterations)",
+  category: "statistical",
+  description: "Fewer than 100 Monte Carlo iterations produces unreliable predictions. The variance of a 10-iteration simulation is so high that you might as well be guessing. This principle enforces the minimum in the Simulator.",
+  check(metrics, thresholds) {
+    const { inflationRate } = metrics;
+    if (Math.abs(inflationRate) > 0.3) {
+      return {
+        violated: true,
+        severity: 3,
+        evidence: { inflationRate, minIterations: thresholds.simulationMinIterations },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: inflationRate > 0 ? "increase" : "decrease",
+          magnitude: 0.05,
+          reasoning: `Large inflation rate swing (${(inflationRate * 100).toFixed(0)}%). Ensure all decisions use \u2265${thresholds.simulationMinIterations} simulation iterations. Apply conservative correction.`
+        },
+        confidence: 0.5,
+        estimatedLag: 5
+      };
+    }
+    return { violated: false };
+  }
+};
+var STATISTICAL_PRINCIPLES = [
+  P42_TheMedianPrinciple,
+  P43_SimulationMinimum
+];
+
+// src/principles/system-dynamics.ts
+var P39_TheLagPrinciple = {
+  id: "P39",
+  name: "The Lag Principle",
+  category: "system_dynamics",
+  description: "Total lag = 3-5\xD7 observation interval. If you observe every 5 ticks, expect effects after 15-25 ticks. Adjusting again before lag expires = overshoot. This is enforced by the Planner but diagnosed here.",
+  check(metrics, thresholds) {
+    const { inflationRate, netFlow } = metrics;
+    const inflationPositive = inflationRate > 0.05;
+    const netFlowNegative = netFlow < -5;
+    const inflationNegative = inflationRate < -0.05;
+    const netFlowPositive = netFlow > 5;
+    const oscillating = inflationPositive && netFlowNegative || inflationNegative && netFlowPositive;
+    if (oscillating) {
+      const lagMin = thresholds.lagMultiplierMin;
+      const lagMax = thresholds.lagMultiplierMax;
+      return {
+        violated: true,
+        severity: 5,
+        evidence: { inflationRate, netFlow, lagRange: [lagMin, lagMax] },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: "increase",
+          magnitude: 0.03,
+          // very small — oscillation means over-adjusting
+          reasoning: `Inflation and net flow moving in opposite directions \u2014 overshoot pattern. Wait for lag to resolve (${lagMin}-${lagMax}\xD7 observation interval). Apply minimal correction only.`
+        },
+        confidence: 0.65,
+        estimatedLag: thresholds.lagMultiplierMax * 5
+        // conservative
+      };
+    }
+    return { violated: false };
+  }
+};
+var P44_ComplexityBudget = {
+  id: "P44",
+  name: "Complexity Budget",
+  category: "system_dynamics",
+  description: "More than 20 active adjustable parameters \u2192 exponential debugging cost. Each parameter that affects <5% of a core metric should be pruned. AgentE tracks active parameters and flags when budget exceeded.",
+  check(metrics, thresholds) {
+    const customMetricCount = Object.keys(metrics.custom).length;
+    if (customMetricCount > thresholds.complexityBudgetMax) {
+      return {
+        violated: true,
+        severity: 3,
+        evidence: { customMetricCount, budgetMax: thresholds.complexityBudgetMax },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "decrease",
+          magnitude: 0.01,
+          reasoning: `${customMetricCount} custom metrics tracked (budget: ${thresholds.complexityBudgetMax}). Consider pruning low-impact parameters. Applying minimal correction to avoid adding complexity.`
+        },
+        confidence: 0.4,
+        estimatedLag: 0
+      };
+    }
+    return { violated: false };
+  }
+};
+var SYSTEM_DYNAMICS_PRINCIPLES = [
+  P39_TheLagPrinciple,
+  P44_ComplexityBudget
+];
+
+// src/principles/resource-mgmt.ts
+var P35_DestructionCreatesValue = {
+  id: "P35",
+  name: "Destruction Creates Value",
+  category: "resource",
+  description: "If nothing is ever permanently lost, inflation is inevitable. Weapon durability (breaks after 3 fights), potion consumption on use, and ore costs for crafting are all destruction mechanisms. Without them, supply grows without bound.",
+  check(metrics, _thresholds) {
+    const { supplyByResource, sinkVolume, netFlow } = metrics;
+    const weapons = supplyByResource["weapons"] ?? 0;
+    const potions = supplyByResource["potions"] ?? 0;
+    if ((weapons > 200 || potions > 200) && sinkVolume < 5 && netFlow > 0) {
+      return {
+        violated: true,
+        severity: 6,
+        evidence: { weapons, potions, sinkVolume, netFlow },
+        suggestedAction: {
+          parameter: "arenaEntryFee",
+          direction: "decrease",
+          magnitude: 0.1,
+          reasoning: `${weapons} weapons + ${potions} potions with low destruction (sink ${sinkVolume}/t). Consumables not being consumed. Lower arena entry to increase weapon/potion usage.`
+        },
+        confidence: 0.7,
+        estimatedLag: 5
+      };
+    }
+    return { violated: false };
+  }
+};
+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.",
+  check(metrics, thresholds) {
+    const { productionIndex, sinkVolume } = metrics;
+    if (sinkVolume > 0 && productionIndex > 0) {
+      const replacementRatio = productionIndex / sinkVolume;
+      if (replacementRatio < 1) {
+        return {
+          violated: true,
+          severity: 6,
+          evidence: { productionIndex, sinkVolume, replacementRatio },
+          suggestedAction: {
+            parameter: "miningYield",
+            direction: "increase",
+            magnitude: 0.15,
+            reasoning: `Replacement rate ${replacementRatio.toFixed(2)} (need \u2265${thresholds.replacementRateMultiplier}). Production below consumption. Resources will deplete. Increase yield.`
+          },
+          confidence: 0.8,
+          estimatedLag: 5
+        };
+      } else if (replacementRatio > thresholds.replacementRateMultiplier * 3) {
+        return {
+          violated: true,
+          severity: 3,
+          evidence: { productionIndex, sinkVolume, replacementRatio },
+          suggestedAction: {
+            parameter: "miningYield",
+            direction: "decrease",
+            magnitude: 0.1,
+            reasoning: `Replacement rate ${replacementRatio.toFixed(2)} \u2014 overproducing. Production far exceeds consumption. Reduce yield to prevent glut.`
+          },
+          confidence: 0.7,
+          estimatedLag: 8
+        };
+      }
+    }
+    return { violated: false };
+  }
+};
+var P49_IdleAssetTax = {
+  id: "P49",
+  name: "Idle Asset Tax",
+  category: "resource",
+  description: 'Appreciating assets without holding cost \u2192 wealth concentration. If hoarding an asset makes you richer just by holding it, everyone hoards. Decay rates, storage costs, or expiry are "idle asset taxes" that force circulation.',
+  check(metrics, _thresholds) {
+    const { giniCoefficient, top10PctShare, velocity } = metrics;
+    if (giniCoefficient > 0.55 && top10PctShare > 0.6 && velocity < 5) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: { giniCoefficient, top10PctShare, velocity },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "increase",
+          magnitude: 0.15,
+          reasoning: `Gini ${giniCoefficient.toFixed(2)}, top 10% hold ${(top10PctShare * 100).toFixed(0)}%, velocity ${velocity}. Wealth concentrated in idle assets. Raise trading costs to simulate holding tax.`
+        },
+        confidence: 0.7,
+        estimatedLag: 15
+      };
+    }
+    return { violated: false };
+  }
+};
+var RESOURCE_MGMT_PRINCIPLES = [
+  P35_DestructionCreatesValue,
+  P40_ReplacementRate,
+  P49_IdleAssetTax
+];
+
+// src/principles/player-experience.ts
+var P33_FairNotEqual = {
+  id: "P33",
+  name: "Fair \u2260 Equal",
+  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: "arenaReward",
+          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: "auctionFee",
+          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: "auctionFee",
+          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
+      };
+    }
+    return { violated: false };
+  }
+};
+var P36_MechanicFrictionDetector = {
+  id: "P36",
+  name: "Mechanic Friction Detector",
+  category: "player_experience",
+  description: "Deterministic + probabilistic systems \u2192 expectation mismatch. When crafting is guaranteed but combat is random, players feel betrayed by the random side. Mix mechanics carefully or segregate them entirely.",
+  check(metrics, _thresholds) {
+    const { avgSatisfaction, churnRate, velocity } = metrics;
+    if (churnRate > 0.1 && avgSatisfaction < 50 && velocity > 3) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: { churnRate, avgSatisfaction, velocity },
+        suggestedAction: {
+          parameter: "arenaReward",
+          direction: "increase",
+          magnitude: 0.15,
+          reasoning: `Churn ${(churnRate * 100).toFixed(1)}% with satisfaction ${avgSatisfaction.toFixed(0)} despite active economy (velocity ` + velocity.toFixed(1) + "). Suggests mechanic friction (deterministic vs random systems). Increase rewards to compensate for perceived unfairness. ADVISORY: Review if mixing guaranteed and probabilistic mechanics."
+        },
+        confidence: 0.55,
+        estimatedLag: 15
+      };
+    }
+    return { violated: false };
+  }
+};
+var P37_LatecommerProblem = {
+  id: "P37",
+  name: "Latecomer Problem",
+  category: "player_experience",
+  description: "A new participant must reach viability in reasonable time. If all the good roles are saturated and prices are high, new agents cannot contribute and churn immediately.",
+  check(metrics, _thresholds) {
+    const { timeToValue, avgSatisfaction, churnRate } = metrics;
+    if (churnRate > 0.08 && avgSatisfaction < 55 && timeToValue > 20) {
+      return {
+        violated: true,
+        severity: 6,
+        evidence: { timeToValue, avgSatisfaction, churnRate },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: "decrease",
+          magnitude: 0.15,
+          reasoning: `New agents taking ${timeToValue} ticks to reach viability. Churn ${(churnRate * 100).toFixed(1)}%, satisfaction ${avgSatisfaction.toFixed(0)}. Lower production costs to help new participants contribute faster.`
+        },
+        confidence: 0.7,
+        estimatedLag: 10
+      };
+    }
+    return { violated: false };
+  }
+};
+var P45_TimeBudget = {
+  id: "P45",
+  name: "Time Budget",
+  category: "player_experience",
+  description: "required_time \u2264 available_time \xD7 0.8. If the economy requires more engagement than participants can realistically give, it is a disguised paywall. The 0.8 buffer accounts for real life.",
+  check(metrics, thresholds) {
+    const { timeToValue, avgSatisfaction } = metrics;
+    const timePressure = timeToValue > 30;
+    const dissatisfied = avgSatisfaction < 55;
+    if (timePressure && dissatisfied) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: { timeToValue, avgSatisfaction, timeBudgetRatio: thresholds.timeBudgetRatio },
+        suggestedAction: {
+          parameter: "arenaEntryFee",
+          direction: "decrease",
+          magnitude: 0.15,
+          reasoning: `Time-to-value ${timeToValue} ticks with ${avgSatisfaction.toFixed(0)} satisfaction. Economy requires too much time investment. Lower barriers to participation.`
+        },
+        confidence: 0.65,
+        estimatedLag: 10
+      };
+    }
+    return { violated: false };
+  }
+};
+var P50_PayPowerRatio = {
+  id: "P50",
+  name: "Pay-Power Ratio",
+  category: "player_experience",
+  description: "spender / non-spender power ratio > 2.0 = pay-to-win territory. Target 1.5 (meaningful advantage without shutting out non-payers). Above 2.0, non-paying participants start leaving.",
+  check(metrics, thresholds) {
+    const { top10PctShare, giniCoefficient } = metrics;
+    const wealthToTopFraction = top10PctShare;
+    if (wealthToTopFraction > 0.7 && giniCoefficient > 0.55) {
+      return {
+        violated: true,
+        severity: 6,
+        evidence: {
+          top10PctShare,
+          giniCoefficient,
+          threshold: thresholds.payPowerRatioMax
+        },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "increase",
+          magnitude: 0.2,
+          reasoning: `Top 10% hold ${(top10PctShare * 100).toFixed(0)}% of wealth (Gini ${giniCoefficient.toFixed(2)}). Wealth advantage may exceed pay-power ratio threshold. Redistribute via higher trading fees.`
+        },
+        confidence: 0.65,
+        estimatedLag: 15
+      };
+    }
+    return { violated: false };
+  }
+};
+var PLAYER_EXPERIENCE_PRINCIPLES = [
+  P33_FairNotEqual,
+  P36_MechanicFrictionDetector,
+  P37_LatecommerProblem,
+  P45_TimeBudget,
+  P50_PayPowerRatio
+];
+
+// src/principles/open-economy.ts
+var P34_ExtractionRatio = {
+  id: "P34",
+  name: "Extraction Ratio",
+  category: "open_economy",
+  description: "If >65% of participants are net extractors (taking value out without putting it in), the economy needs external subsidy (new user influx) to survive. Above 65%, any slowdown in new users collapses the economy.",
+  check(metrics, thresholds) {
+    const { extractionRatio } = metrics;
+    if (isNaN(extractionRatio)) return { violated: false };
+    if (extractionRatio > thresholds.extractionRatioRed) {
+      return {
+        violated: true,
+        severity: 8,
+        evidence: { extractionRatio, threshold: thresholds.extractionRatioRed },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "increase",
+          magnitude: 0.25,
+          reasoning: `Extraction ratio ${(extractionRatio * 100).toFixed(0)}% (critical: ${(thresholds.extractionRatioRed * 100).toFixed(0)}%). Economy is extraction-heavy and subsidy-dependent. Raise fees to increase the cost of extraction.`
+        },
+        confidence: 0.85,
+        estimatedLag: 10
+      };
+    }
+    if (extractionRatio > thresholds.extractionRatioYellow) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: { extractionRatio, threshold: thresholds.extractionRatioYellow },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "increase",
+          magnitude: 0.1,
+          reasoning: `Extraction ratio ${(extractionRatio * 100).toFixed(0)}% (warning: ${(thresholds.extractionRatioYellow * 100).toFixed(0)}%). Economy trending toward extraction-heavy. Apply early pressure.`
+        },
+        confidence: 0.75,
+        estimatedLag: 15
+      };
+    }
+    return { violated: false };
+  }
+};
+var P47_SmokeTest = {
+  id: "P47",
+  name: "Smoke Test",
+  category: "open_economy",
+  description: "intrinsic_utility_value / total_market_value < 0.3 = economy is >70% speculation. If utility value drops below 10%, a single bad week can collapse the entire market. Real utility (weapons that help you fight, potions that heal) must anchor value.",
+  check(metrics, thresholds) {
+    const { smokeTestRatio } = metrics;
+    if (isNaN(smokeTestRatio)) return { violated: false };
+    if (smokeTestRatio < thresholds.smokeTestCritical) {
+      return {
+        violated: true,
+        severity: 9,
+        evidence: { smokeTestRatio, threshold: thresholds.smokeTestCritical },
+        suggestedAction: {
+          parameter: "arenaReward",
+          direction: "increase",
+          magnitude: 0.2,
+          reasoning: `Utility/market ratio ${(smokeTestRatio * 100).toFixed(0)}% (critical). Economy is >90% speculative. Collapse risk is extreme. Increase utility rewards to anchor real value.`
+        },
+        confidence: 0.9,
+        estimatedLag: 20
+      };
+    }
+    if (smokeTestRatio < thresholds.smokeTestWarning) {
+      return {
+        violated: true,
+        severity: 6,
+        evidence: { smokeTestRatio, threshold: thresholds.smokeTestWarning },
+        suggestedAction: {
+          parameter: "arenaReward",
+          direction: "increase",
+          magnitude: 0.1,
+          reasoning: `Utility/market ratio ${(smokeTestRatio * 100).toFixed(0)}% (warning). Economy is >70% speculative. Boost utility rewards to restore intrinsic value anchor.`
+        },
+        confidence: 0.75,
+        estimatedLag: 20
+      };
+    }
+    return { violated: false };
+  }
+};
+var P48_CurrencyInsulation = {
+  id: "P48",
+  name: "Currency Insulation",
+  category: "open_economy",
+  description: "Gameplay economy correlation with external markets > 0.5 = insulation failure. When your in-game gold price tracks ETH/USD, external market crashes destroy in-game economies. Good design insulates the two.",
+  check(metrics, thresholds) {
+    const { currencyInsulation } = metrics;
+    if (isNaN(currencyInsulation)) return { violated: false };
+    if (currencyInsulation > thresholds.currencyInsulationMax) {
+      return {
+        violated: true,
+        severity: 6,
+        evidence: { currencyInsulation, threshold: thresholds.currencyInsulationMax },
+        suggestedAction: {
+          parameter: "auctionFee",
+          direction: "increase",
+          magnitude: 0.1,
+          reasoning: `Currency correlation with external market: ${(currencyInsulation * 100).toFixed(0)}% (max: ${(thresholds.currencyInsulationMax * 100).toFixed(0)}%). Economy is exposed to external market shocks. Increase internal friction to reduce external correlation.`
+        },
+        confidence: 0.7,
+        estimatedLag: 30
+      };
+    }
+    return { violated: false };
+  }
+};
+var OPEN_ECONOMY_PRINCIPLES = [
+  P34_ExtractionRatio,
+  P47_SmokeTest,
+  P48_CurrencyInsulation
+];
+
+// src/principles/liveops.ts
+var P51_SharkTooth = {
+  id: "P51",
+  name: "Shark Tooth Pattern",
+  category: "liveops",
+  description: "Each event peak should be \u226595% of the previous peak. If peaks are shrinking (shark tooth becoming flat), event fatigue is setting in. If valleys are deepening, the off-event economy is failing to sustain engagement.",
+  check(metrics, thresholds) {
+    const { sharkToothPeaks, sharkToothValleys } = metrics;
+    if (sharkToothPeaks.length < 2) return { violated: false };
+    const lastPeak = sharkToothPeaks[sharkToothPeaks.length - 1] ?? 0;
+    const prevPeak = sharkToothPeaks[sharkToothPeaks.length - 2] ?? 0;
+    if (prevPeak > 0 && lastPeak / prevPeak < thresholds.sharkToothPeakDecay) {
+      return {
+        violated: true,
+        severity: 5,
+        evidence: {
+          lastPeak,
+          prevPeak,
+          ratio: lastPeak / prevPeak,
+          threshold: thresholds.sharkToothPeakDecay
+        },
+        suggestedAction: {
+          parameter: "arenaReward",
+          direction: "increase",
+          magnitude: 0.1,
+          reasoning: `Peak engagement dropped to ${(lastPeak / prevPeak * 100).toFixed(0)}% of previous peak (threshold: ${(thresholds.sharkToothPeakDecay * 100).toFixed(0)}%). Event fatigue detected. Boost event rewards to restore peak engagement.`
+        },
+        confidence: 0.75,
+        estimatedLag: 30
+      };
+    }
+    if (sharkToothValleys.length >= 2) {
+      const lastValley = sharkToothValleys[sharkToothValleys.length - 1] ?? 0;
+      const prevValley = sharkToothValleys[sharkToothValleys.length - 2] ?? 0;
+      if (prevValley > 0 && lastValley / prevValley < thresholds.sharkToothValleyDecay) {
+        return {
+          violated: true,
+          severity: 4,
+          evidence: { lastValley, prevValley, ratio: lastValley / prevValley },
+          suggestedAction: {
+            parameter: "craftingCost",
+            direction: "decrease",
+            magnitude: 0.1,
+            reasoning: "Between-event engagement declining (deepening valleys). Base economy not sustaining participants between events. Lower production costs to improve off-event value."
+          },
+          confidence: 0.65,
+          estimatedLag: 20
+        };
+      }
+    }
+    return { violated: false };
+  }
+};
+var P52_EndowmentEffect = {
+  id: "P52",
+  name: "Endowment Effect",
+  category: "liveops",
+  description: "Players who never owned premium items do not value them. Free trial events that let players experience premium items drive conversions because ownership creates perceived value (endowment effect).",
+  check(metrics, _thresholds) {
+    const { avgSatisfaction, churnRate } = metrics;
+    const { eventCompletionRate } = metrics;
+    if (isNaN(eventCompletionRate)) return { violated: false };
+    if (eventCompletionRate > 0.9 && avgSatisfaction < 60) {
+      return {
+        violated: true,
+        severity: 4,
+        evidence: { eventCompletionRate, avgSatisfaction, churnRate },
+        suggestedAction: {
+          parameter: "arenaReward",
+          direction: "increase",
+          magnitude: 0.15,
+          reasoning: `${(eventCompletionRate * 100).toFixed(0)}% event completion but satisfaction only ${avgSatisfaction.toFixed(0)}. Events not creating perceived value. Increase reward quality/quantity.`
+        },
+        confidence: 0.6,
+        estimatedLag: 20
+      };
+    }
+    return { violated: false };
+  }
+};
+var P53_EventCompletionRate = {
+  id: "P53",
+  name: "Event Completion Rate Sweet Spot",
+  category: "liveops",
+  description: "Free completion at 60-80% is the sweet spot. <40% = predatory design. >80% = no monetization pressure. 100% free = zero reason to ever spend.",
+  check(metrics, thresholds) {
+    const { eventCompletionRate } = metrics;
+    if (isNaN(eventCompletionRate)) return { violated: false };
+    if (eventCompletionRate < thresholds.eventCompletionMin) {
+      return {
+        violated: true,
+        severity: 6,
+        evidence: {
+          eventCompletionRate,
+          min: thresholds.eventCompletionMin,
+          max: thresholds.eventCompletionMax
+        },
+        suggestedAction: {
+          parameter: "craftingCost",
+          direction: "decrease",
+          magnitude: 0.15,
+          reasoning: `Event completion rate ${(eventCompletionRate * 100).toFixed(0)}% \u2014 predatory territory (min: ${(thresholds.eventCompletionMin * 100).toFixed(0)}%). Too hard for free players. Lower barriers to participation.`
+        },
+        confidence: 0.8,
+        estimatedLag: 10
+      };
+    }
+    if (eventCompletionRate > thresholds.eventCompletionMax) {
+      return {
+        violated: true,
+        severity: 3,
+        evidence: { eventCompletionRate, max: thresholds.eventCompletionMax },
+        suggestedAction: {
+          parameter: "arenaEntryFee",
+          direction: "increase",
+          magnitude: 0.05,
+          reasoning: `Event completion rate ${(eventCompletionRate * 100).toFixed(0)}% \u2014 no monetization pressure (max: ${(thresholds.eventCompletionMax * 100).toFixed(0)}%). Slightly raise costs to create meaningful premium differentiation.`
+        },
+        confidence: 0.55,
+        estimatedLag: 10
+      };
+    }
+    return { violated: false };
+  }
+};
+var P54_LiveOpsCadence = {
+  id: "P54",
+  name: "LiveOps Cadence",
+  category: "liveops",
+  description: ">50% of events 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.",
+  check(metrics, _thresholds) {
+    const { velocity, avgSatisfaction } = metrics;
+    if (velocity < 2 && avgSatisfaction < 55 && metrics.tick > 100) {
+      return {
+        violated: true,
+        severity: 3,
+        evidence: { velocity, avgSatisfaction, tick: metrics.tick },
+        suggestedAction: {
+          parameter: "arenaReward",
+          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)."
+        },
+        confidence: 0.4,
+        estimatedLag: 30
+      };
+    }
+    return { violated: false };
+  }
+};
+var P56_ContentDropShock = {
+  id: "P56",
+  name: "Content-Drop Shock",
+  category: "liveops",
+  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.",
+  check(metrics, thresholds) {
+    const { contentDropAge, arbitrageIndex } = metrics;
+    if (contentDropAge > 0 && contentDropAge <= thresholds.contentDropCooldownTicks) {
+      if (arbitrageIndex > thresholds.postDropArbitrageMax) {
+        return {
+          violated: true,
+          severity: 5,
+          evidence: {
+            contentDropAge,
+            arbitrageIndex,
+            cooldownTicks: thresholds.contentDropCooldownTicks,
+            postDropMax: thresholds.postDropArbitrageMax
+          },
+          suggestedAction: {
+            parameter: "auctionFee",
+            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.`
+          },
+          confidence: 0.7,
+          estimatedLag: 5
+        };
+      }
+    }
+    return { violated: false };
+  }
+};
+var LIVEOPS_PRINCIPLES = [
+  P51_SharkTooth,
+  P52_EndowmentEffect,
+  P53_EventCompletionRate,
+  P54_LiveOpsCadence,
+  P56_ContentDropShock
+];
+
+// src/principles/index.ts
+var ALL_PRINCIPLES = [
+  ...SUPPLY_CHAIN_PRINCIPLES,
+  // P1-P4, P60
+  ...INCENTIVE_PRINCIPLES,
+  // P5-P8
+  ...POPULATION_PRINCIPLES,
+  // P9-P11, P46
+  ...CURRENCY_FLOW_PRINCIPLES,
+  // P12-P16, P32, P58
+  ...BOOTSTRAP_PRINCIPLES,
+  // P17-P19
+  ...FEEDBACK_LOOP_PRINCIPLES,
+  // P20-P24
+  ...REGULATOR_PRINCIPLES,
+  // P25-P28, P38
+  ...MARKET_DYNAMICS_PRINCIPLES,
+  // P29-P30, P57
+  ...MEASUREMENT_PRINCIPLES,
+  // P31, P41, P55, P59
+  ...STATISTICAL_PRINCIPLES,
+  // P42-P43
+  ...SYSTEM_DYNAMICS_PRINCIPLES,
+  // P39, P44
+  ...RESOURCE_MGMT_PRINCIPLES,
+  // P35, P40, P49
+  ...PLAYER_EXPERIENCE_PRINCIPLES,
+  // P33, P36, P37, P45, P50
+  ...OPEN_ECONOMY_PRINCIPLES,
+  // P34, P47-P48
+  ...LIVEOPS_PRINCIPLES
+  // P51-P54, P56
+];
+
+// src/Simulator.ts
+var Simulator = class {
+  constructor() {
+    this.diagnoser = new Diagnoser(ALL_PRINCIPLES);
+  }
+  /**
+   * Simulate the effect of applying `action` to the current economy forward `forwardTicks`.
+   * Runs `iterations` Monte Carlo trials and returns the outcome distribution.
+   *
+   * The inner model is intentionally lightweight — it models how key metrics evolve
+   * under a parameter change using simplified dynamics. This is not a full agent simulation;
+   * it is a fast inner model that catches obvious over/under-corrections.
+   */
+  simulate(action, currentMetrics, thresholds, iterations = 100, forwardTicks = 20) {
+    const actualIterations = Math.max(thresholds.simulationMinIterations, iterations);
+    const outcomes = [];
+    for (let i = 0; i < actualIterations; i++) {
+      const projected = this.runForward(currentMetrics, action, forwardTicks, thresholds);
+      outcomes.push(projected);
+    }
+    const sorted = [...outcomes].sort((a, b) => a.avgSatisfaction - b.avgSatisfaction);
+    const p10 = sorted[Math.floor(actualIterations * 0.1)] ?? emptyMetrics();
+    const p50 = sorted[Math.floor(actualIterations * 0.5)] ?? emptyMetrics();
+    const p90 = sorted[Math.floor(actualIterations * 0.9)] ?? emptyMetrics();
+    const mean = this.averageMetrics(outcomes);
+    const netImprovement = this.checkImprovement(currentMetrics, p50, action);
+    const beforeViolations = new Set(
+      this.diagnoser.diagnose(currentMetrics, thresholds).map((d) => d.principle.id)
+    );
+    const afterViolations = new Set(
+      this.diagnoser.diagnose(p50, thresholds).map((d) => d.principle.id)
+    );
+    const newViolations = [...afterViolations].filter((id) => !beforeViolations.has(id));
+    const noNewProblems = newViolations.length === 0;
+    const satisfactions = outcomes.map((o) => o.avgSatisfaction);
+    const meanSat = satisfactions.reduce((s, v) => s + v, 0) / satisfactions.length;
+    const stdDev = Math.sqrt(
+      satisfactions.reduce((s, v) => s + (v - meanSat) ** 2, 0) / satisfactions.length
+    );
+    const ci = [meanSat - 1.96 * stdDev, meanSat + 1.96 * stdDev];
+    const estimatedEffectTick = currentMetrics.tick + thresholds.lagMultiplierMin * 5;
+    const overshootRisk = sorted.slice(Math.floor(actualIterations * 0.8)).filter((m) => Math.abs(m.netFlow) > Math.abs(currentMetrics.netFlow) * 2).length / (actualIterations * 0.2);
+    return {
+      proposedAction: action,
+      iterations: actualIterations,
+      forwardTicks,
+      outcomes: { p10, p50, p90, mean },
+      netImprovement,
+      noNewProblems,
+      confidenceInterval: ci,
+      estimatedEffectTick,
+      overshootRisk: Math.min(1, overshootRisk)
+    };
+  }
+  /**
+   * Lightweight forward model: apply action then project key metrics forward.
+   * Uses simplified dynamics — not a full agent replay.
+   */
+  runForward(metrics, action, ticks, _thresholds) {
+    const multiplier = this.actionMultiplier(action);
+    const noise = () => 1 + (Math.random() - 0.5) * 0.1;
+    let supply = metrics.totalSupply;
+    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;
+      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 projected = {
+      ...metrics,
+      tick: metrics.tick + ticks,
+      totalSupply: supply,
+      netFlow,
+      velocity,
+      giniCoefficient: Math.max(0, Math.min(1, gini)),
+      avgSatisfaction: satisfaction,
+      inflationRate: metrics.totalSupply > 0 ? (supply - metrics.totalSupply) / metrics.totalSupply : 0
+    };
+    return projected;
+  }
+  actionMultiplier(action) {
+    const base = action.magnitude ?? 0.1;
+    return action.direction === "increase" ? 1 + base : 1 - base;
+  }
+  flowEffect(action, metrics) {
+    const { parameter, direction } = action;
+    const sign = direction === "increase" ? -1 : 1;
+    if (parameter === "craftingCost" || parameter === "alchemyCost") {
+      return sign * metrics.netFlow * 0.2;
+    }
+    if (parameter === "auctionFee") {
+      return sign * metrics.velocity * 10 * 0.1;
+    }
+    if (parameter === "arenaEntryFee") {
+      return sign * (metrics.populationByRole["Fighter"] ?? 0) * 0.5;
+    }
+    if (parameter === "arenaReward") {
+      return -sign * (metrics.populationByRole["Fighter"] ?? 0) * 0.3;
+    }
+    if (parameter === "miningYield" || parameter === "lumberYield") {
+      return sign * metrics.faucetVolume * 0.15;
+    }
+    return sign * metrics.netFlow * 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;
+    void action;
+    return satisfactionImproved && flowMoreBalanced && notWorseGini;
+  }
+  averageMetrics(outcomes) {
+    if (outcomes.length === 0) return emptyMetrics();
+    const base = { ...outcomes[0] };
+    const avg = (key) => {
+      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;
+    };
+    return {
+      ...base,
+      totalSupply: avg("totalSupply"),
+      netFlow: avg("netFlow"),
+      velocity: avg("velocity"),
+      giniCoefficient: avg("giniCoefficient"),
+      avgSatisfaction: avg("avgSatisfaction"),
+      inflationRate: avg("inflationRate")
+    };
+  }
+};
+
+// src/Planner.ts
+var Planner = class {
+  constructor() {
+    this.lockedParams = /* @__PURE__ */ new Set();
+    this.constraints = /* @__PURE__ */ new Map();
+    this.cooldowns = /* @__PURE__ */ new Map();
+    // param → last-applied-tick
+    this.activePlanCount = 0;
+  }
+  lock(param) {
+    this.lockedParams.add(param);
+  }
+  unlock(param) {
+    this.lockedParams.delete(param);
+  }
+  constrain(param, constraint) {
+    this.constraints.set(param, constraint);
+  }
+  /**
+   * Convert a diagnosis into an ActionPlan.
+   * Returns null if:
+   * - parameter is locked
+   * - parameter is still in cooldown
+   * - simulation result failed
+   * - complexity budget exceeded
+   */
+  plan(diagnosis, metrics, simulationResult, currentParams, thresholds) {
+    const action = diagnosis.violation.suggestedAction;
+    const param = action.parameter;
+    if (this.lockedParams.has(param)) return null;
+    if (this.isOnCooldown(param, metrics.tick, thresholds.cooldownTicks)) return null;
+    if (!simulationResult.netImprovement) return null;
+    if (!simulationResult.noNewProblems) return null;
+    if (this.activePlanCount >= thresholds.complexityBudgetMax) return null;
+    const currentValue = currentParams[param] ?? 1;
+    const magnitude = Math.min(action.magnitude ?? 0.1, thresholds.maxAdjustmentPercent);
+    let targetValue;
+    if (action.direction === "set" && action.absoluteValue !== void 0) {
+      targetValue = action.absoluteValue;
+    } else if (action.direction === "increase") {
+      targetValue = currentValue * (1 + magnitude);
+    } else {
+      targetValue = currentValue * (1 - magnitude);
+    }
+    const constraint = this.constraints.get(param);
+    if (constraint) {
+      targetValue = Math.max(constraint.min, Math.min(constraint.max, targetValue));
+    }
+    if (Math.abs(targetValue - currentValue) < 1e-3) return null;
+    const estimatedLag = diagnosis.violation.estimatedLag ?? simulationResult.estimatedEffectTick - metrics.tick;
+    const plan = {
+      id: `plan_${metrics.tick}_${param}`,
+      diagnosis,
+      parameter: param,
+      currentValue,
+      targetValue,
+      maxChangePercent: thresholds.maxAdjustmentPercent,
+      cooldownTicks: thresholds.cooldownTicks,
+      rollbackCondition: {
+        metric: "avgSatisfaction",
+        direction: "below",
+        threshold: Math.max(20, metrics.avgSatisfaction - 10),
+        // rollback if sat drops >10 pts
+        checkAfterTick: metrics.tick + estimatedLag + 3
+      },
+      simulationResult,
+      estimatedLag
+    };
+    return plan;
+  }
+  recordApplied(plan, tick) {
+    this.cooldowns.set(plan.parameter, tick);
+    this.activePlanCount++;
+  }
+  recordRolledBack(_plan) {
+    this.activePlanCount = Math.max(0, this.activePlanCount - 1);
+  }
+  isOnCooldown(param, currentTick, cooldownTicks) {
+    const lastApplied = this.cooldowns.get(param);
+    if (lastApplied === void 0) return false;
+    return currentTick - lastApplied < cooldownTicks;
+  }
+  /** Reset all cooldowns (useful for testing) */
+  resetCooldowns() {
+    this.cooldowns.clear();
+  }
+};
+
+// src/Executor.ts
+var Executor = class {
+  constructor() {
+    this.activePlans = [];
+  }
+  async apply(plan, adapter, currentParams) {
+    const originalValue = currentParams[plan.parameter] ?? plan.currentValue;
+    await adapter.setParam(plan.parameter, plan.targetValue);
+    plan.appliedAt = plan.diagnosis.tick;
+    this.activePlans.push({ plan, originalValue });
+  }
+  /**
+   * Check all active plans for rollback conditions.
+   * Called every tick after metrics are computed.
+   * Returns list of plans that were rolled back.
+   */
+  async checkRollbacks(metrics, adapter) {
+    const rolledBack = [];
+    const remaining = [];
+    for (const active of this.activePlans) {
+      const { plan, originalValue } = active;
+      const rc = plan.rollbackCondition;
+      if (metrics.tick < rc.checkAfterTick) {
+        remaining.push(active);
+        continue;
+      }
+      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);
+        rolledBack.push(plan);
+      } else {
+        const settledTick = rc.checkAfterTick + 10;
+        if (metrics.tick > settledTick) {
+        } else {
+          remaining.push(active);
+        }
+      }
+    }
+    this.activePlans = remaining;
+    return rolledBack;
+  }
+  getMetricValue(metrics, metricPath) {
+    const parts = metricPath.split(".");
+    let value = metrics;
+    for (const part of parts) {
+      if (value !== null && typeof value === "object") {
+        value = value[part];
+      } else {
+        return NaN;
+      }
+    }
+    return typeof value === "number" ? value : NaN;
+  }
+  getActivePlans() {
+    return this.activePlans.map((a) => a.plan);
+  }
+};
+
+// src/DecisionLog.ts
+var DecisionLog = class {
+  constructor(maxEntries = 1e3) {
+    this.entries = [];
+    this.maxEntries = maxEntries;
+  }
+  record(diagnosis, plan, result, metrics) {
+    const entry = {
+      id: `decision_${metrics.tick}_${plan.parameter}`,
+      tick: metrics.tick,
+      timestamp: Date.now(),
+      diagnosis,
+      plan,
+      result,
+      reasoning: this.buildReasoning(diagnosis, plan, result),
+      metricsSnapshot: metrics
+    };
+    this.entries.unshift(entry);
+    if (this.entries.length > this.maxEntries) {
+      this.entries.pop();
+    }
+    return entry;
+  }
+  recordSkip(diagnosis, result, metrics, reason) {
+    const entry = {
+      id: `skip_${metrics.tick}_${diagnosis.principle.id}`,
+      tick: metrics.tick,
+      timestamp: Date.now(),
+      diagnosis,
+      plan: this.stubPlan(diagnosis, metrics),
+      result,
+      reasoning: reason,
+      metricsSnapshot: metrics
+    };
+    this.entries.unshift(entry);
+    if (this.entries.length > this.maxEntries) this.entries.pop();
+  }
+  query(filter) {
+    return this.entries.filter((e) => {
+      if (filter?.since !== void 0 && e.tick < filter.since) return false;
+      if (filter?.until !== void 0 && e.tick > filter.until) return false;
+      if (filter?.issue && e.diagnosis.principle.id !== filter.issue) return false;
+      if (filter?.parameter && e.plan.parameter !== filter.parameter) return false;
+      if (filter?.result && e.result !== filter.result) return false;
+      return true;
+    });
+  }
+  latest(n = 30) {
+    return this.entries.slice(0, n);
+  }
+  export(format = "json") {
+    if (format === "text") {
+      return this.entries.map((e) => `[Tick ${e.tick}] ${e.result.toUpperCase()} \u2014 ${e.reasoning}`).join("\n");
+    }
+    return JSON.stringify(this.entries, null, 2);
+  }
+  buildReasoning(diagnosis, plan, result) {
+    const sim = plan.simulationResult;
+    const simSummary = `Simulation (${sim.iterations} iterations, ${sim.forwardTicks} ticks forward): p50 satisfaction ${sim.outcomes.p50.avgSatisfaction.toFixed(0)}, net improvement ${sim.netImprovement}, no new problems ${sim.noNewProblems}, overshoot risk ${(sim.overshootRisk * 100).toFixed(0)}%.`;
+    const actionSummary = `[${diagnosis.principle.id}] ${diagnosis.principle.name}: ${plan.parameter} ${plan.currentValue.toFixed(3)} \u2192 ${plan.targetValue.toFixed(3)}. Severity ${diagnosis.violation.severity}/10, confidence ${(diagnosis.violation.confidence * 100).toFixed(0)}%.`;
+    if (result === "applied") {
+      return `${actionSummary} ${simSummary} Expected effect in ${plan.estimatedLag} ticks.`;
+    }
+    return `${actionSummary} Skipped (${result}). ${simSummary}`;
+  }
+  stubPlan(diagnosis, metrics) {
+    const action = diagnosis.violation.suggestedAction;
+    return {
+      id: `stub_${metrics.tick}`,
+      diagnosis,
+      parameter: action.parameter,
+      currentValue: 1,
+      targetValue: 1,
+      maxChangePercent: 0,
+      cooldownTicks: 0,
+      rollbackCondition: {
+        metric: "avgSatisfaction",
+        direction: "below",
+        threshold: 0,
+        checkAfterTick: 0
+      },
+      simulationResult: {
+        proposedAction: action,
+        iterations: 0,
+        forwardTicks: 0,
+        outcomes: {
+          p10: metrics,
+          p50: metrics,
+          p90: metrics,
+          mean: metrics
+        },
+        netImprovement: false,
+        noNewProblems: true,
+        confidenceInterval: [0, 0],
+        estimatedEffectTick: 0,
+        overshootRisk: 0
+      },
+      estimatedLag: 0
+    };
+  }
+};
+
+// src/MetricStore.ts
+var RingBuffer = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.head = 0;
+    this.count = 0;
+    this.buf = new Array(capacity);
+  }
+  push(item) {
+    this.buf[this.head] = item;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.count < this.capacity) this.count++;
+  }
+  /** All items in chronological order (oldest first) */
+  toArray() {
+    if (this.count === 0) return [];
+    const result = [];
+    const start = this.count < this.capacity ? 0 : this.head;
+    for (let i = 0; i < this.count; i++) {
+      result.push(this.buf[(start + i) % this.capacity]);
+    }
+    return result;
+  }
+  last() {
+    if (this.count === 0) return void 0;
+    const idx = (this.head - 1 + this.capacity) % this.capacity;
+    return this.buf[idx];
+  }
+  get length() {
+    return this.count;
+  }
+};
+var MetricStore = class {
+  constructor() {
+    /** Fine: last 200 ticks, one entry per tick */
+    this.fine = new RingBuffer(200);
+    /** Medium: last 200 windows of 10 ticks */
+    this.medium = new RingBuffer(200);
+    /** Coarse: last 200 epochs of 100 ticks */
+    this.coarse = new RingBuffer(200);
+    this.ticksSinceLastMedium = 0;
+    this.ticksSinceLastCoarse = 0;
+    this.mediumAccumulator = [];
+    this.coarseAccumulator = [];
+  }
+  record(metrics) {
+    this.fine.push(metrics);
+    this.mediumAccumulator.push(metrics);
+    this.ticksSinceLastMedium++;
+    if (this.ticksSinceLastMedium >= 10) {
+      this.medium.push(this.aggregate(this.mediumAccumulator));
+      this.mediumAccumulator = [];
+      this.ticksSinceLastMedium = 0;
+    }
+    this.coarseAccumulator.push(metrics);
+    this.ticksSinceLastCoarse++;
+    if (this.ticksSinceLastCoarse >= 100) {
+      this.coarse.push(this.aggregate(this.coarseAccumulator));
+      this.coarseAccumulator = [];
+      this.ticksSinceLastCoarse = 0;
+    }
+  }
+  latest(resolution = "fine") {
+    const buf = this.bufferFor(resolution);
+    return buf.last() ?? emptyMetrics();
+  }
+  query(q) {
+    const resolution = q.resolution ?? "fine";
+    const buf = this.bufferFor(resolution);
+    const all = buf.toArray();
+    const filtered = all.filter((m) => {
+      if (q.from !== void 0 && m.tick < q.from) return false;
+      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
+    }));
+    return { metric: q.metric, resolution, points };
+  }
+  /** Check if fine and coarse resolution metrics diverge significantly */
+  divergenceDetected() {
+    const f = this.fine.last();
+    const c = this.coarse.last();
+    if (!f || !c) return false;
+    const fineSat = f.avgSatisfaction;
+    const coarseSat = c.avgSatisfaction;
+    return Math.abs(fineSat - coarseSat) > 20;
+  }
+  bufferFor(resolution) {
+    if (resolution === "medium") return this.medium;
+    if (resolution === "coarse") return this.coarse;
+    return this.fine;
+  }
+  aggregate(snapshots) {
+    if (snapshots.length === 0) return emptyMetrics();
+    const last = snapshots[snapshots.length - 1];
+    const avg = (key) => {
+      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;
+    };
+    return {
+      ...last,
+      totalSupply: avg("totalSupply"),
+      netFlow: avg("netFlow"),
+      velocity: avg("velocity"),
+      inflationRate: avg("inflationRate"),
+      giniCoefficient: avg("giniCoefficient"),
+      medianBalance: avg("medianBalance"),
+      meanBalance: avg("meanBalance"),
+      top10PctShare: avg("top10PctShare"),
+      meanMedianDivergence: avg("meanMedianDivergence"),
+      avgSatisfaction: avg("avgSatisfaction"),
+      churnRate: avg("churnRate"),
+      blockedAgentCount: avg("blockedAgentCount"),
+      faucetVolume: avg("faucetVolume"),
+      sinkVolume: avg("sinkVolume"),
+      tapSinkRatio: avg("tapSinkRatio"),
+      productionIndex: avg("productionIndex"),
+      capacityUsage: avg("capacityUsage"),
+      anchorRatioDrift: avg("anchorRatioDrift")
+    };
+  }
+};
+
+// src/PersonaTracker.ts
+var PersonaTracker = class {
+  constructor() {
+    this.agentHistory = /* @__PURE__ */ new Map();
+  }
+  /** Ingest a state snapshot and update agent signal history */
+  update(state) {
+    for (const agentId of Object.keys(state.agentBalances)) {
+      const history = this.agentHistory.get(agentId) ?? [];
+      const inv = state.agentInventories[agentId] ?? {};
+      const uniqueItems = Object.values(inv).filter((q) => q > 0).length;
+      history.push({
+        transactionCount: 0,
+        // would be computed from events in full impl
+        netExtraction: 0,
+        // gold out vs in
+        uniqueItemsHeld: uniqueItems,
+        holdingDuration: 1,
+        spendAmount: 0,
+        sessionActivity: 1,
+        socialInteractions: 0
+      });
+      if (history.length > 50) history.shift();
+      this.agentHistory.set(agentId, history);
+    }
+  }
+  /** Classify all agents and return persona distribution */
+  getDistribution() {
+    const counts = {
+      Gamer: 0,
+      Trader: 0,
+      Collector: 0,
+      Speculator: 0,
+      Earner: 0,
+      Builder: 0,
+      Social: 0,
+      Whale: 0,
+      Influencer: 0
+    };
+    let total = 0;
+    for (const [, history] of this.agentHistory) {
+      const persona = this.classify(history);
+      counts[persona]++;
+      total++;
+    }
+    if (total === 0) return {};
+    const distribution = {};
+    for (const [persona, count] of Object.entries(counts)) {
+      distribution[persona] = count / total;
+    }
+    return distribution;
+  }
+  classify(history) {
+    if (history.length === 0) return "Gamer";
+    const avg = (key) => {
+      const vals = history.map((h) => h[key]);
+      return vals.reduce((s, v) => s + v, 0) / vals.length;
+    };
+    const txRate = avg("transactionCount");
+    const extraction = avg("netExtraction");
+    const uniqueItems = avg("uniqueItemsHeld");
+    const spend = avg("spendAmount");
+    if (spend > 1e3) return "Whale";
+    if (txRate > 10) return "Trader";
+    if (uniqueItems > 5 && extraction < 0) return "Collector";
+    if (extraction > 100) return "Earner";
+    if (extraction > 50) return "Speculator";
+    return "Gamer";
+  }
+};
+
+// src/AgentE.ts
+var AgentE = class {
+  constructor(config) {
+    // ── Pipeline ──
+    this.observer = new Observer();
+    this.simulator = new Simulator();
+    this.planner = new Planner();
+    this.executor = new Executor();
+    // ── State ──
+    this.log = new DecisionLog();
+    this.store = new MetricStore();
+    this.personaTracker = new PersonaTracker();
+    this.params = {};
+    this.eventBuffer = [];
+    this.isRunning = false;
+    this.isPaused = false;
+    this.currentTick = 0;
+    // ── Event handlers ──
+    this.handlers = /* @__PURE__ */ new Map();
+    /** Access to the metric time-series store */
+    this.metrics = {
+      query: (q) => this.store.query(q),
+      latest: (resolution) => this.store.latest(resolution)
+    };
+    this.mode = config.mode ?? "autonomous";
+    this.config = {
+      mode: this.mode,
+      dominantRoles: config.dominantRoles ?? [],
+      idealDistribution: config.idealDistribution ?? {},
+      gracePeriod: config.gracePeriod ?? 50,
+      checkInterval: config.checkInterval ?? 5,
+      maxAdjustmentPercent: config.maxAdjustmentPercent ?? 0.15,
+      cooldownTicks: config.cooldownTicks ?? 15
+    };
+    this.thresholds = {
+      ...DEFAULT_THRESHOLDS,
+      ...config.thresholds ?? {},
+      maxAdjustmentPercent: config.maxAdjustmentPercent ?? DEFAULT_THRESHOLDS.maxAdjustmentPercent,
+      cooldownTicks: config.cooldownTicks ?? DEFAULT_THRESHOLDS.cooldownTicks
+    };
+    this.diagnoser = new Diagnoser(ALL_PRINCIPLES);
+    if (config.onDecision) this.on("decision", config.onDecision);
+    if (config.onAlert) this.on("alert", config.onAlert);
+    if (config.onRollback) this.on("rollback", config.onRollback);
+    if (config.dominantRoles && config.dominantRoles.length > 0) {
+    }
+  }
+  // ── Connection ──────────────────────────────────────────────────────────────
+  connect(adapter) {
+    this.adapter = adapter;
+    if (adapter.onEvent) {
+      adapter.onEvent((event) => this.eventBuffer.push(event));
+    }
+    return this;
+  }
+  start() {
+    if (!this.adapter) throw new Error("[AgentE] Call .connect(adapter) before .start()");
+    this.isRunning = true;
+    this.isPaused = false;
+    return this;
+  }
+  pause() {
+    this.isPaused = true;
+  }
+  resume() {
+    this.isPaused = false;
+  }
+  stop() {
+    this.isRunning = false;
+    this.isPaused = false;
+  }
+  // ── Main cycle (call once per tick from your game loop) ────────────────────
+  async tick(state) {
+    if (!this.isRunning || this.isPaused) return;
+    const currentState = state ?? await Promise.resolve(this.adapter.getState());
+    this.currentTick = currentState.tick;
+    const events = [...this.eventBuffer];
+    this.eventBuffer = [];
+    const metrics = this.observer.compute(currentState, events);
+    this.store.record(metrics);
+    this.personaTracker.update(currentState);
+    metrics.personaDistribution = this.personaTracker.getDistribution();
+    const rolledBack = await this.executor.checkRollbacks(metrics, this.adapter);
+    for (const plan2 of rolledBack) {
+      this.planner.recordRolledBack(plan2);
+      this.emit("rollback", plan2, "rollback condition triggered");
+    }
+    if (metrics.tick < this.config.gracePeriod) return;
+    if (metrics.tick % this.config.checkInterval !== 0) return;
+    const diagnoses = this.diagnoser.diagnose(metrics, this.thresholds);
+    for (const diagnosis of diagnoses) {
+      this.emit("alert", diagnosis);
+    }
+    const topDiagnosis = diagnoses[0];
+    if (!topDiagnosis) return;
+    const simulationResult = this.simulator.simulate(
+      topDiagnosis.violation.suggestedAction,
+      metrics,
+      this.thresholds,
+      100,
+      // always >= minimum (P43)
+      20
+    );
+    const plan = this.planner.plan(
+      topDiagnosis,
+      metrics,
+      simulationResult,
+      this.params,
+      this.thresholds
+    );
+    if (!plan) {
+      let reason = "skipped_cooldown";
+      if (!simulationResult.netImprovement) reason = "skipped_simulation_failed";
+      this.log.recordSkip(topDiagnosis, reason, metrics, `Skipped: ${reason}`);
+      return;
+    }
+    if (this.mode === "advisor") {
+      const entry2 = this.log.record(topDiagnosis, plan, "skipped_override", metrics);
+      this.emit("decision", entry2);
+      return;
+    }
+    const vetoed = this.emit("beforeAction", plan);
+    if (vetoed === false) {
+      this.log.recordSkip(topDiagnosis, "skipped_override", metrics, "vetoed by beforeAction hook");
+      return;
+    }
+    await this.executor.apply(plan, this.adapter, this.params);
+    this.params[plan.parameter] = plan.targetValue;
+    this.planner.recordApplied(plan, metrics.tick);
+    const entry = this.log.record(topDiagnosis, plan, "applied", metrics);
+    this.emit("decision", entry);
+    this.emit("afterAction", entry);
+  }
+  /** Apply a plan manually (for advisor mode) */
+  async apply(plan) {
+    await this.executor.apply(plan, this.adapter, this.params);
+    this.params[plan.parameter] = plan.targetValue;
+    this.planner.recordApplied(plan, this.currentTick);
+  }
+  // ── Developer API ───────────────────────────────────────────────────────────
+  lock(param) {
+    this.planner.lock(param);
+  }
+  unlock(param) {
+    this.planner.unlock(param);
+  }
+  constrain(param, bounds) {
+    this.planner.constrain(param, bounds);
+  }
+  addPrinciple(principle) {
+    this.diagnoser.addPrinciple(principle);
+  }
+  removePrinciple(id) {
+    this.diagnoser.removePrinciple(id);
+  }
+  registerCustomMetric(name, fn) {
+    this.observer.registerCustomMetric(name, fn);
+  }
+  getDecisions(filter) {
+    return this.log.query(filter);
+  }
+  getPrinciples() {
+    return this.diagnoser.getPrinciples();
+  }
+  getActivePlans() {
+    return this.executor.getActivePlans();
+  }
+  // ── Events ──────────────────────────────────────────────────────────────────
+  on(event, handler) {
+    const list = this.handlers.get(event) ?? [];
+    list.push(handler);
+    this.handlers.set(event, list);
+    return this;
+  }
+  off(event, handler) {
+    const list = this.handlers.get(event) ?? [];
+    this.handlers.set(event, list.filter((h) => h !== handler));
+    return this;
+  }
+  emit(event, ...args) {
+    const list = this.handlers.get(event) ?? [];
+    let result;
+    for (const handler of list) {
+      result = handler(...args);
+      if (result === false) return false;
+    }
+    return result;
+  }
+  // ── Diagnostics ─────────────────────────────────────────────────────────────
+  diagnoseNow() {
+    const metrics = this.store.latest();
+    return this.diagnoser.diagnose(metrics, this.thresholds);
+  }
+  getHealth() {
+    const m = this.store.latest();
+    if (m.tick === 0) return 100;
+    let health = 100;
+    if (m.avgSatisfaction < 65) health -= 15;
+    if (m.avgSatisfaction < 50) health -= 10;
+    if (m.giniCoefficient > 0.45) health -= 15;
+    if (m.giniCoefficient > 0.6) health -= 10;
+    if (Math.abs(m.netFlow) > 10) health -= 15;
+    if (Math.abs(m.netFlow) > 20) health -= 10;
+    if (m.churnRate > 0.05) health -= 15;
+    return Math.max(0, Math.min(100, health));
+  }
+  // ── Ingest events directly (event-driven mode) ───────────────────────────
+  ingest(event) {
+    this.eventBuffer.push(event);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALL_PRINCIPLES,
+  AgentE,
+  BOOTSTRAP_PRINCIPLES,
+  CURRENCY_FLOW_PRINCIPLES,
+  DEFAULT_THRESHOLDS,
+  DecisionLog,
+  Diagnoser,
+  Executor,
+  FEEDBACK_LOOP_PRINCIPLES,
+  INCENTIVE_PRINCIPLES,
+  LIVEOPS_PRINCIPLES,
+  MARKET_DYNAMICS_PRINCIPLES,
+  MEASUREMENT_PRINCIPLES,
+  MetricStore,
+  OPEN_ECONOMY_PRINCIPLES,
+  Observer,
+  P10_SpawnWeightingUsesInversePopulation,
+  P11_TwoTierPressure,
+  P12_OnePrimaryFaucet,
+  P13_PotsAreZeroSumAndSelfRegulate,
+  P14_TrackActualInjection,
+  P15_PoolsNeedCapAndDecay,
+  P16_WithdrawalPenaltyScales,
+  P17_GracePeriodBeforeIntervention,
+  P18_FirstProducerNeedsStartingInventory,
+  P19_StartingSupplyExceedsDemand,
+  P1_ProductionMatchesConsumption,
+  P20_DecayPreventsAccumulation,
+  P21_PriceFromGlobalSupply,
+  P22_MarketAwarenessPreventsSurplus,
+  P23_ProfitabilityFactorsFeasibility,
+  P24_BlockedAgentsDecayFaster,
+  P25_CorrectLeversForCorrectProblems,
+  P26_ContinuousPressureBeatsThresholdCuts,
+  P27_AdjustmentsNeedCooldowns,
+  P28_StructuralDominanceIsNotPathological,
+  P29_PinchPoint,
+  P2_ClosedLoopsNeedDirectHandoff,
+  P30_MovingPinchPoint,
+  P31_AnchorValueTracking,
+  P32_VelocityAboveSupply,
+  P33_FairNotEqual,
+  P34_ExtractionRatio,
+  P35_DestructionCreatesValue,
+  P36_MechanicFrictionDetector,
+  P37_LatecommerProblem,
+  P38_CommunicationPreventsRevolt,
+  P39_TheLagPrinciple,
+  P3_BootstrapCapitalCoversFirstTransaction,
+  P40_ReplacementRate,
+  P41_MultiResolutionMonitoring,
+  P42_TheMedianPrinciple,
+  P43_SimulationMinimum,
+  P44_ComplexityBudget,
+  P45_TimeBudget,
+  P46_PersonaDiversity,
+  P47_SmokeTest,
+  P48_CurrencyInsulation,
+  P49_IdleAssetTax,
+  P4_MaterialsFlowFasterThanCooldown,
+  P50_PayPowerRatio,
+  P51_SharkTooth,
+  P52_EndowmentEffect,
+  P53_EventCompletionRate,
+  P54_LiveOpsCadence,
+  P55_ArbitrageThermometer,
+  P56_ContentDropShock,
+  P57_CombinatorialPriceSpace,
+  P58_NoNaturalNumeraire,
+  P59_GiftEconomyNoise,
+  P5_ProfitabilityIsCompetitive,
+  P60_SurplusDisposalAsymmetry,
+  P6_CrowdingMultiplierOnAllRoles,
+  P7_NonSpecialistsSubsidiseSpecialists,
+  P8_RegulatorCannotFightDesign,
+  P9_RoleSwitchingNeedsFriction,
+  PERSONA_HEALTHY_RANGES,
+  PLAYER_EXPERIENCE_PRINCIPLES,
+  POPULATION_PRINCIPLES,
+  PersonaTracker,
+  Planner,
+  REGULATOR_PRINCIPLES,
+  RESOURCE_MGMT_PRINCIPLES,
+  STATISTICAL_PRINCIPLES,
+  SUPPLY_CHAIN_PRINCIPLES,
+  SYSTEM_DYNAMICS_PRINCIPLES,
+  Simulator,
+  emptyMetrics
+});
+//# sourceMappingURL=index.js.map