@agent-e/core 1.5.5 → 1.5.7

package/dist/index.mjs

@@ -3484,86 +3484,152 @@ var MetricStore = class {
 };
 
 // src/PersonaTracker.ts
+var DEFAULT_PERSONA_CONFIG = {
+  whalePercentile: 0.05,
+  activeTraderPercentile: 0.2,
+  newEntrantWindow: 10,
+  dormantWindow: 20,
+  atRiskDropThreshold: 0.5,
+  powerUserMinSystems: 3,
+  historyWindow: 50
+};
 var PersonaTracker = class {
-  constructor() {
-    this.agentHistory = /* @__PURE__ */ new Map();
-    this.lastSeen = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.agents = /* @__PURE__ */ new Map();
+    this.config = { ...DEFAULT_PERSONA_CONFIG, ...config };
   }
-  /** Ingest a state snapshot and update agent signal history */
-  update(state) {
+  /**
+   * Ingest a state snapshot + events and update per-agent signals.
+   * Call this once per tick BEFORE getDistribution().
+   */
+  update(state, events) {
     const tick = state.tick;
-    for (const agentId of Object.keys(state.agentBalances)) {
-      this.lastSeen.set(agentId, tick);
-      const history = this.agentHistory.get(agentId) ?? [];
-      const inv = state.agentInventories[agentId] ?? {};
-      const uniqueItems = Object.values(inv).filter((q) => q > 0).length;
-      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);
-    }
-    if (tick % 50 === 0) {
-      for (const [id, lastTick] of this.lastSeen) {
-        if (tick - lastTick > 100) {
-          this.agentHistory.delete(id);
-          this.lastSeen.delete(id);
+    const txByAgent = /* @__PURE__ */ new Map();
+    if (events) {
+      for (const e of events) {
+        const agents = [e.actor];
+        if (e.from) agents.push(e.from);
+        if (e.to) agents.push(e.to);
+        for (const id of agents) {
+          if (!id) continue;
+          const entry = txByAgent.get(id) ?? { count: 0, volume: 0, systems: /* @__PURE__ */ new Set() };
+          entry.count++;
+          entry.volume += e.amount ?? 0;
+          if (e.system) entry.systems.add(e.system);
+          txByAgent.set(id, entry);
+        }
+      }
+    }
+    for (const [agentId, balances] of Object.entries(state.agentBalances)) {
+      const totalHoldings = Object.values(balances).reduce((s, v) => s + v, 0);
+      const tx = txByAgent.get(agentId);
+      const record = this.agents.get(agentId) ?? {
+        firstSeen: tick,
+        lastActive: tick,
+        snapshots: [],
+        previousTxRate: 0
+      };
+      const snapshot = {
+        totalHoldings,
+        txCount: tx?.count ?? 0,
+        txVolume: tx?.volume ?? 0,
+        systems: tx?.systems ?? /* @__PURE__ */ new Set()
+      };
+      record.snapshots.push(snapshot);
+      if (record.snapshots.length > this.config.historyWindow) {
+        const oldHalf = record.snapshots.slice(0, Math.floor(record.snapshots.length / 2));
+        record.previousTxRate = oldHalf.reduce((s, sn) => s + sn.txCount, 0) / Math.max(1, oldHalf.length);
+        record.snapshots = record.snapshots.slice(-this.config.historyWindow);
+      }
+      if ((tx?.count ?? 0) > 0) {
+        record.lastActive = tick;
+      }
+      this.agents.set(agentId, record);
+    }
+    const pruneThreshold = this.config.dormantWindow * 2;
+    if (tick % this.config.dormantWindow === 0) {
+      for (const [id, rec] of this.agents) {
+        if (tick - rec.lastActive > pruneThreshold && !(id in state.agentBalances)) {
+          this.agents.delete(id);
         }
       }
     }
   }
-  /** Classify all agents and return persona distribution */
+  /**
+   * Classify all tracked agents and return the population distribution.
+   * Returns { Whale: 0.05, ActiveTrader: 0.18, Passive: 0.42, ... }
+   */
   getDistribution() {
-    const counts = {
-      Active: 0,
-      Trader: 0,
-      Collector: 0,
-      Speculator: 0,
-      Earner: 0,
-      Builder: 0,
-      Social: 0,
-      HighValue: 0,
-      Influencer: 0
-    };
-    let total = 0;
-    for (const [, history] of this.agentHistory) {
-      const persona = this.classify(history);
+    const agentIds = [...this.agents.keys()];
+    const total = agentIds.length;
+    if (total === 0) return {};
+    const holdings = agentIds.map((id) => {
+      const rec = this.agents.get(id);
+      const latest = rec.snapshots[rec.snapshots.length - 1];
+      return latest?.totalHoldings ?? 0;
+    }).sort((a, b) => a - b);
+    const whaleThreshold = percentile(holdings, 1 - this.config.whalePercentile);
+    const txRates = agentIds.map((id) => {
+      const rec = this.agents.get(id);
+      return rec.snapshots.reduce((s, sn) => s + sn.txCount, 0) / Math.max(1, rec.snapshots.length);
+    }).sort((a, b) => a - b);
+    const activeTraderThreshold = percentile(txRates, 1 - this.config.activeTraderPercentile);
+    const medianTxRate = percentile(txRates, 0.5);
+    const counts = {};
+    const currentTick = Math.max(...agentIds.map((id) => this.agents.get(id).lastActive), 0);
+    for (let i = 0; i < agentIds.length; i++) {
+      const id = agentIds[i];
+      const rec = this.agents.get(id);
+      const snaps = rec.snapshots;
+      if (snaps.length === 0) continue;
+      const latestHoldings = snaps[snaps.length - 1].totalHoldings;
+      const agentTxRate = txRates[i];
+      const ticksSinceFirst = currentTick - rec.firstSeen;
+      const ticksSinceActive = currentTick - rec.lastActive;
+      const halfIdx = Math.floor(snaps.length / 2);
+      const earlyAvg = snaps.slice(0, Math.max(1, halfIdx)).reduce((s, sn) => s + sn.totalHoldings, 0) / Math.max(1, halfIdx);
+      const lateAvg = snaps.slice(halfIdx).reduce((s, sn) => s + sn.totalHoldings, 0) / Math.max(1, snaps.length - halfIdx);
+      const balanceDelta = lateAvg - earlyAvg;
+      const allSystems = /* @__PURE__ */ new Set();
+      for (const sn of snaps) {
+        for (const sys of sn.systems) allSystems.add(sys);
+      }
+      const recentSnaps = snaps.slice(-Math.min(10, snaps.length));
+      const recentTxRate = recentSnaps.reduce((s, sn) => s + sn.txCount, 0) / Math.max(1, recentSnaps.length);
+      let persona;
+      if (ticksSinceFirst <= this.config.newEntrantWindow) {
+        persona = "NewEntrant";
+      } else if (latestHoldings > 0 && ticksSinceActive > this.config.dormantWindow) {
+        persona = "Dormant";
+      } else if (rec.previousTxRate > 0 && recentTxRate < rec.previousTxRate * (1 - this.config.atRiskDropThreshold)) {
+        persona = "AtRisk";
+      } else if (latestHoldings >= whaleThreshold && whaleThreshold > 0) {
+        persona = "Whale";
+      } else if (allSystems.size >= this.config.powerUserMinSystems) {
+        persona = "PowerUser";
+      } else if (agentTxRate >= activeTraderThreshold && activeTraderThreshold > 0) {
+        persona = "ActiveTrader";
+      } else if (balanceDelta > 0 && agentTxRate < medianTxRate) {
+        persona = "Accumulator";
+      } else if (balanceDelta < 0 && agentTxRate >= medianTxRate) {
+        persona = "Spender";
+      } else {
+        persona = "Passive";
+      }
       counts[persona] = (counts[persona] ?? 0) + 1;
-      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 "Active";
-    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 "HighValue";
-    if (txRate > 10) return "Trader";
-    if (uniqueItems > 5 && extraction < 0) return "Collector";
-    if (extraction > 100) return "Earner";
-    if (extraction > 50) return "Speculator";
-    return "Active";
-  }
 };
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.ceil(p * sorted.length) - 1;
+  return sorted[Math.max(0, Math.min(idx, sorted.length - 1))];
+}
 
 // src/ParameterRegistry.ts
 var ParameterRegistry = class {
@@ -3806,7 +3872,7 @@ var AgentE = class {
       return;
     }
     this.store.record(metrics);
-    this.personaTracker.update(currentState);
+    this.personaTracker.update(currentState, events);
     metrics.personaDistribution = this.personaTracker.getDistribution();
     const { rolledBack, settled } = await this.executor.checkRollbacks(metrics, this.adapter);
     for (const plan2 of rolledBack) {