@sherwoodagent/cli 0.38.5 → 0.40.4

package/dist/{agent-TB7VNLFH.js → agent-XBYSALOA.js}

@@ -1,21 +1,22 @@
 import {
-  getResearchProvider
-} from "./chunk-B4AH26UI.js";
-import {
-  BASE_STRATEGY_ABI
-} from "./chunk-OQUGUIYM.js";
+  getResearchProvider,
+  isX402WalletFunded
+} from "./chunk-DNX3P5YK.js";
 import "./chunk-OFR3LCYE.js";
 import {
   hyperevm,
   hyperevmTestnet
 } from "./chunk-IJG4CTOI.js";
 import "./chunk-WCBG44IQ.js";
+import {
+  BASE_STRATEGY_ABI
+} from "./chunk-W3GXAODE.js";
 
 // src/commands/agent.ts
 import chalk8 from "chalk";
-import { readFile as readFile12, writeFile as writeFile11, mkdir as mkdir13 } from "fs/promises";
-import { join as join12 } from "path";
-import { homedir as homedir12 } from "os";
+import { readFile as readFile13, writeFile as writeFile13, mkdir as mkdir15 } from "fs/promises";
+import { join as join14 } from "path";
+import { homedir as homedir14 } from "os";
 import ora from "ora";
 
 // src/agent/index.ts
@@ -689,19 +690,28 @@ function clamp(v, min = -1, max = 1) {
 
 // src/agent/scoring.ts
 var DEFAULT_WEIGHTS = {
-  smartMoney: 0.25,
-  technical: 0.2,
-  sentiment: 0.2,
-  onchain: 0.15,
+  smartMoney: 0.15,
+  technical: 0.1,
+  sentiment: 0.4,
+  onchain: 0.2,
   fundamental: 0.1,
-  event: 0.1
+  event: 0.05
 };
 var WEIGHT_PROFILES = {
   default: DEFAULT_WEIGHTS,
-  majors: { smartMoney: 0.3, technical: 0.3, sentiment: 0.2, onchain: 0.2, fundamental: 0, event: 0 },
-  altcoin: { smartMoney: 0.2, technical: 0.15, sentiment: 0.15, onchain: 0.15, fundamental: 0.2, event: 0.15 },
-  sentHeavy: { smartMoney: 0.1, technical: 0.15, sentiment: 0.4, onchain: 0.15, fundamental: 0.1, event: 0.1 },
-  techHeavy: { smartMoney: 0.1, technical: 0.4, sentiment: 0.15, onchain: 0.15, fundamental: 0.1, event: 0.1 }
+  // Majors (BTC/ETH/SOL): no TVL/event data. 4 active categories.
+  // Same rebalance rationale as DEFAULT_WEIGHTS — replay calibration showed
+  // sentiment-heavy profiles dominating production-stack data; this profile
+  // concentrates the freed-up weight into sentiment + onchain (the two
+  // categories that produce directional opinions on majors). Technical and
+  // smartMoney shrink because both are lagging or unfunded in practice.
+  majors: { smartMoney: 0.15, technical: 0.1, sentiment: 0.4, onchain: 0.35, fundamental: 0, event: 0 },
+  // Altcoins: keep fundamental (TVL data exists) and event. Sentiment lifted
+  // here too but less aggressively — altcoins respond more to TVL/flow than
+  // majors, and the sentimentContrarian extremes-only fix means sentiment
+  // weight is dormant most of the time.
+  altcoin: { smartMoney: 0.15, technical: 0.15, sentiment: 0.3, onchain: 0.2, fundamental: 0.1, event: 0.1 }
+  // sentHeavy/techHeavy removed — unvalidated, added parameter complexity without evidence of benefit
 };
 var MAJORS_TOKEN_IDS = /* @__PURE__ */ new Set(["bitcoin", "ethereum", "solana"]);
 function profileForToken(tokenId, userProfile) {
@@ -722,7 +732,11 @@ var DEFAULT_THRESHOLDS = {
 var REGIME_THRESHOLDS = {
   "trending-up": { strongBuy: 0.55, buy: 0.25, sell: -0.4, strongSell: -0.7 },
   "trending-down": { strongBuy: 0.7, buy: 0.4, sell: -0.25, strongSell: -0.55 },
-  "ranging": { strongBuy: 0.65, buy: 0.4, sell: -0.4, strongSell: -0.65 },
+  // Ranging BUY lowered 0.30 → 0.25 to match trending-up. Production cycles
+  // showed scores capping at 0.27 for hours at a time during ranging regimes,
+  // missing real entries (BTC 0.272, DOGE 0.266, AAVE 0.266 all HOLD'd).
+  // Symmetric SELL lowered to -0.25 to keep the band balanced.
+  "ranging": { strongBuy: 0.55, buy: 0.25, sell: -0.25, strongSell: -0.55 },
   "high-volatility": { strongBuy: 0.7, buy: 0.45, sell: -0.45, strongSell: -0.7 },
   "low-volatility": { strongBuy: 0.6, buy: 0.3, sell: -0.3, strongSell: -0.6 }
 };
@@ -983,33 +997,61 @@ function scoreEvent(data) {
     details: details.join("; ")
   };
 }
-function computeTradeDecision(signals, weights, regimeAdjustments, correlationCheck, regime) {
+var LAGGING_TECHNICAL_SIGNALS = /* @__PURE__ */ new Set(["technical", "meanReversion"]);
+var SIGNAL_CATEGORY_MAP = {
+  technical: "technical",
+  sentiment: "sentiment",
+  onchain: "onchain",
+  fundamental: "fundamental",
+  event: "event",
+  smartMoney: "smartMoney",
+  // Strategy signal mappings to categories
+  // momentum intentionally has no key in getStrategyAdjustments() — it keeps
+  // full weight during momentum overrides (not dampened like lagging indicators).
+  momentum: "technical",
+  breakoutOnChain: "technical",
+  meanReversion: "technical",
+  multiTimeframe: "technical",
+  dexFlow: "onchain",
+  fundingRate: "onchain",
+  // FIX 2: was "fundamental" — wasted on majors (0.00 weight)
+  tvlMomentum: "fundamental",
+  sentimentContrarian: "sentiment",
+  twitterSentiment: "sentiment",
+  tokenUnlock: "event",
+  hyperliquidFlow: "onchain"
+};
+var X402_CATEGORIES = /* @__PURE__ */ new Set(["smartMoney", "event"]);
+function computeTradeDecision(signals, weights, regimeAdjustments, correlationCheck, regime, x402Available) {
   const w = weights ?? DEFAULT_WEIGHTS;
   const thresholds = thresholdsForRegime(regime);
-  const weightMap = {
-    technical: w.technical,
-    sentiment: w.sentiment,
-    onchain: w.onchain,
-    fundamental: w.fundamental,
-    event: w.event,
-    smartMoney: w.smartMoney,
-    // Strategy signal mappings to categories
-    breakoutOnChain: w.technical,
-    meanReversion: w.technical,
-    multiTimeframe: w.technical,
-    dexFlow: w.onchain,
-    fundingRate: w.fundamental,
-    tvlMomentum: w.fundamental,
-    sentimentContrarian: w.sentiment,
-    twitterSentiment: w.sentiment,
-    tokenUnlock: w.event,
-    hyperliquidFlow: w.onchain
-  };
+  const excludedCategories = /* @__PURE__ */ new Set();
+  if (x402Available === false) {
+    for (const cat of X402_CATEGORIES) {
+      if (w[cat] > 0) excludedCategories.add(cat);
+    }
+  }
+  const categoryCounts = {};
+  for (const signal of signals) {
+    if (signal._weightOverride !== void 0) continue;
+    const category = SIGNAL_CATEGORY_MAP[signal.name];
+    if (!category || excludedCategories.has(category)) continue;
+    categoryCounts[category] = (categoryCounts[category] ?? 0) + 1;
+  }
   let totalWeight = 0;
   let weightedSum = 0;
   let weightedConfidence = 0;
   for (const signal of signals) {
-    const signalWeight = signal._weightOverride ?? weightMap[signal.name] ?? 0.1;
+    let signalWeight;
+    if (signal._weightOverride !== void 0) {
+      signalWeight = signal._weightOverride;
+    } else {
+      const category = SIGNAL_CATEGORY_MAP[signal.name];
+      if (category && excludedCategories.has(category)) continue;
+      const categoryWeight = category ? w[category] : 0.1;
+      const count = category ? categoryCounts[category] ?? 1 : 1;
+      signalWeight = categoryWeight / count;
+    }
     let adjustedValue = signal.value;
     let adjustedConfidence = signal.confidence;
     if (regimeAdjustments && signal.name in regimeAdjustments) {
@@ -1017,12 +1059,36 @@ function computeTradeDecision(signals, weights, regimeAdjustments, correlationCh
       adjustedValue *= adjustment;
       adjustedConfidence *= adjustment;
     }
+    if (regime && (regime === "trending-up" || regime === "trending-down") && LAGGING_TECHNICAL_SIGNALS.has(signal.name)) {
+      signalWeight *= 0.5;
+    }
     weightedSum += adjustedValue * signalWeight;
     weightedConfidence += adjustedConfidence * signalWeight;
     totalWeight += signalWeight;
   }
   let score = totalWeight > 0 ? weightedSum / totalWeight : 0;
   const confidence = totalWeight > 0 ? weightedConfidence / totalWeight : 0;
+  if (Math.abs(score) > 0.01) {
+    const scoreSign = Math.sign(score);
+    const categoryNetDirection = /* @__PURE__ */ new Map();
+    for (const signal of signals) {
+      const category = SIGNAL_CATEGORY_MAP[signal.name];
+      if (!category || excludedCategories.has(category)) continue;
+      if (signal._weightOverride !== void 0) continue;
+      const current = categoryNetDirection.get(category) ?? 0;
+      categoryNetDirection.set(category, current + signal.value);
+    }
+    let agreeing = 0;
+    let totalActive = 0;
+    for (const [, netValue] of categoryNetDirection) {
+      totalActive++;
+      if (Math.sign(netValue) === scoreSign) agreeing++;
+    }
+    if (agreeing >= 4 && totalActive >= 4) {
+      const bonus = 1 + 0.15 * (agreeing - 3);
+      score *= Math.min(bonus, 1.45);
+    }
+  }
   if (correlationCheck) {
     if (correlationCheck.btcBias === "bearish" && score > 0) {
       score *= correlationCheck.suppressionFactor;
@@ -1035,6 +1101,7 @@ function computeTradeDecision(signals, weights, regimeAdjustments, correlationCh
     }
     score = Math.max(-1, Math.min(1, score));
   }
+  score = Math.max(-1, Math.min(1, score));
   let action;
   if (score >= thresholds.strongBuy) action = "STRONG_BUY";
   else if (score >= thresholds.buy) action = "BUY";
@@ -1053,191 +1120,6 @@ function computeTradeDecision(signals, weights, regimeAdjustments, correlationCh
   };
 }
 
-// src/agent/strategies/smart-money.ts
-var SmartMoneyStrategy = class {
-  name = "smartMoney";
-  description = "Analyzes Nansen smart-money netflow to detect institutional accumulation or distribution";
-  requiredData = ["nansenData"];
-  async analyze(ctx) {
-    const details = [];
-    if (!ctx.nansenData) {
-      return {
-        name: this.name,
-        value: 0,
-        confidence: 0.1,
-        source: "Smart Money Convergence",
-        details: "No Nansen smart-money data available"
-      };
-    }
-    const data = ctx.nansenData;
-    const flows = data.flows;
-    if (!flows || flows.length === 0) {
-      return {
-        name: this.name,
-        value: 0,
-        confidence: 0.1,
-        source: "Smart Money Convergence",
-        details: "No smart-money flow data found"
-      };
-    }
-    const netflow = flows.reduce(
-      (sum, f) => sum + Number(f.netflow ?? f.net_flow ?? 0),
-      0
-    );
-    const accumulating = flows.filter(
-      (f) => Number(f.netflow ?? f.net_flow ?? 0) < 0
-      // negative = leaving exchanges = buying
-    ).length;
-    const distributing = flows.length - accumulating;
-    const convergenceRatio = Math.max(accumulating, distributing) / flows.length;
-    const isConverging = convergenceRatio > 0.7;
-    let value = 0;
-    let confidence = 0.5;
-    if (netflow < 0) {
-      const magnitude = Math.min(Math.abs(netflow) / 1e6, 1);
-      value = 0.5 + magnitude * 0.5;
-      details.push(`Smart money buying: net outflow ${Math.abs(netflow).toFixed(0)} tokens`);
-      confidence = 0.6;
-    } else if (netflow > 0) {
-      const magnitude = Math.min(Math.abs(netflow) / 1e6, 1);
-      value = -(0.5 + magnitude * 0.5);
-      details.push(`Smart money selling: net inflow ${netflow.toFixed(0)} tokens`);
-      confidence = 0.6;
-    } else {
-      details.push("Smart money neutral: no significant flow");
-    }
-    if (isConverging && value !== 0) {
-      const bonus = value > 0 ? 0.15 : -0.15;
-      value = clamp(value + bonus);
-      details.push(`${accumulating}/${flows.length} wallets accumulating (convergence signal)`);
-      confidence += 0.15;
-    } else {
-      details.push(`Mixed signals: ${accumulating} accumulating, ${distributing} distributing`);
-    }
-    return {
-      name: this.name,
-      value: clamp(value),
-      confidence: Math.min(confidence, 1),
-      source: "Smart Money Convergence",
-      details: details.join("; ")
-    };
-  }
-};
-
-// src/agent/strategies/token-unlock.ts
-function parseUnlocks(messariData) {
-  const unlocks = [];
-  const profile = messariData.profile;
-  const tokenomics = profile?.economics ?? profile?.tokenomics ?? messariData.tokenomics;
-  const schedule = tokenomics?.vesting_schedule ?? tokenomics?.unlock_schedule ?? messariData.unlock_schedule;
-  if (!schedule || !Array.isArray(schedule)) return unlocks;
-  const now = Date.now();
-  for (const entry of schedule) {
-    const unlockDate = entry.date ?? entry.unlock_date ?? entry.timestamp;
-    if (!unlockDate) continue;
-    const unlockTime = typeof unlockDate === "number" ? unlockDate : new Date(String(unlockDate)).getTime();
-    const daysUntil = (unlockTime - now) / (1e3 * 60 * 60 * 24);
-    if (daysUntil < 0 || daysUntil > 30) continue;
-    const percentOfSupply = Number(entry.percent ?? entry.percent_of_supply ?? entry.amount_pct ?? 0);
-    const typeRaw = String(entry.type ?? entry.category ?? entry.recipient ?? "unknown").toLowerCase();
-    let type = "unknown";
-    if (typeRaw.includes("team") || typeRaw.includes("founder")) type = "team";
-    else if (typeRaw.includes("investor") || typeRaw.includes("vc") || typeRaw.includes("seed") || typeRaw.includes("private")) type = "investor";
-    else if (typeRaw.includes("community") || typeRaw.includes("airdrop")) type = "community";
-    else if (typeRaw.includes("ecosystem") || typeRaw.includes("treasury")) type = "ecosystem";
-    unlocks.push({ percentOfSupply, daysUntil, type });
-  }
-  return unlocks;
-}
-var TokenUnlockStrategy = class {
-  name = "tokenUnlock";
-  description = "Detects upcoming token unlocks and signals potential selling pressure";
-  requiredData = ["messariData"];
-  async analyze(ctx) {
-    if (!ctx.messariData && !ctx.unlockData) {
-      return {
-        name: this.name,
-        value: 0,
-        confidence: 0.1,
-        source: "Token Unlock Frontrun",
-        details: "No unlock data available"
-      };
-    }
-    if (!ctx.messariData && ctx.unlockData) {
-      return this.analyzeFromUnlockData(ctx.unlockData);
-    }
-    const unlocks = parseUnlocks(ctx.messariData);
-    if (unlocks.length === 0) {
-      return {
-        name: this.name,
-        value: 0,
-        confidence: 0.3,
-        source: "Token Unlock Frontrun",
-        details: "No upcoming token unlocks detected within 30 days"
-      };
-    }
-    let value = 0;
-    let confidence = 0.5;
-    const details = [];
-    for (const unlock of unlocks) {
-      let signal = 0;
-      if (unlock.percentOfSupply > 5 && unlock.daysUntil <= 7) {
-        signal = -(0.6 + Math.min((unlock.percentOfSupply - 5) / 15, 0.4));
-        confidence = 0.8;
-      } else if (unlock.percentOfSupply > 2 && unlock.daysUntil <= 14) {
-        signal = -(0.3 + Math.min((unlock.percentOfSupply - 2) / 10, 0.5));
-        confidence = Math.max(confidence, 0.6);
-      } else if (unlock.percentOfSupply > 1) {
-        signal = -0.2;
-      }
-      if (unlock.type === "team" || unlock.type === "investor") {
-        signal = clamp(signal * 1.5);
-        details.push(
-          `${unlock.percentOfSupply.toFixed(1)}% supply unlocking in ${Math.ceil(unlock.daysUntil)} days (type: ${unlock.type}) \u2014 elevated sell pressure`
-        );
-      } else {
-        details.push(
-          `${unlock.percentOfSupply.toFixed(1)}% supply unlocking in ${Math.ceil(unlock.daysUntil)} days (type: ${unlock.type})`
-        );
-      }
-      if (signal < value) value = signal;
-    }
-    return {
-      name: this.name,
-      value: clamp(value),
-      confidence: Math.min(confidence, 1),
-      source: "Token Unlock Frontrun",
-      details: details.join("; ")
-    };
-  }
-  /** Analyze from DefiLlama FDV-based unlock estimates (free fallback) */
-  analyzeFromUnlockData(data) {
-    if (data.upcomingUnlocks.length === 0 || data.totalUpcomingPercent < 0.5) {
-      return {
-        name: this.name,
-        value: 0,
-        confidence: 0.2,
-        source: "Token Unlock Frontrun",
-        details: "No significant upcoming unlocks detected"
-      };
-    }
-    let value = 0;
-    const pct = data.totalUpcomingPercent;
-    if (pct > 5) value = -0.6;
-    else if (pct > 2) value = -0.4;
-    else if (pct > 1) value = -0.2;
-    const details = data.upcomingUnlocks.map((u) => u.description).join("; ");
-    return {
-      name: this.name,
-      value: clamp(value),
-      confidence: 0.4,
-      // lower confidence since these are estimates
-      source: "Token Unlock Frontrun",
-      details: details || `~${pct.toFixed(1)}% estimated weekly vesting`
-    };
-  }
-};
-
 // src/agent/strategies/sentiment-contrarian.ts
 var SentimentContrarianStrategy = class {
   name = "sentimentContrarian";
@@ -1261,22 +1143,15 @@ var SentimentContrarianStrategy = class {
       value = 1 - fg / 20 * 0.4;
       confidence = 0.9;
       details.push(`Extreme fear (F&G=${fg}): strong contrarian buy signal`);
-    } else if (fg < 35) {
-      value = 0.5 - (fg - 20) / 15 * 0.3;
-      confidence = 0.7;
-      details.push(`Fear (F&G=${fg}): contrarian buy signal`);
-    } else if (fg <= 65) {
-      value = 0;
-      confidence = 0.3;
-      details.push(`Neutral sentiment (F&G=${fg}): no contrarian edge`);
-    } else if (fg <= 80) {
-      value = -(0.2 + (fg - 65) / 15 * 0.3);
-      confidence = 0.7;
-      details.push(`Greed (F&G=${fg}): contrarian sell signal`);
-    } else {
+    } else if (fg > 80) {
       value = -(0.6 + (fg - 80) / 20 * 0.4);
       confidence = 0.9;
       details.push(`Extreme greed (F&G=${fg}): strong contrarian sell signal`);
+    } else {
+      value = 0;
+      confidence = 0.1;
+      const label = fg < 35 ? "mild fear" : fg > 65 ? "mild greed" : "neutral";
+      details.push(`${label} (F&G=${fg}): below extremes, no edge`);
     }
     if (ctx.sentimentZScore !== void 0) {
       const z = ctx.sentimentZScore;
@@ -1418,120 +1293,6 @@ var BreakoutOnChainStrategy = class {
   }
 };
 
-// src/agent/strategies/tvl-momentum.ts
-function calculateTvlGrowthWoW(tvlData) {
-  let history;
-  if (Array.isArray(tvlData)) {
-    history = tvlData;
-  } else if (tvlData?.tvl && Array.isArray(tvlData.tvl)) {
-    history = tvlData.tvl;
-  } else if (tvlData?.chainTvls) {
-    const combined = Object.values(tvlData.chainTvls).find((chain) => chain?.tvl && Array.isArray(chain.tvl));
-    if (combined) history = combined.tvl;
-  }
-  if (!history || history.length < 8) return null;
-  const sortedHistory = [...history].sort((a, b) => (a.date ?? 0) - (b.date ?? 0));
-  const current = sortedHistory[sortedHistory.length - 1];
-  const weekAgo = sortedHistory[Math.max(0, sortedHistory.length - 8)];
-  const currentTvl = current?.totalLiquidityUSD ?? current?.tvl ?? 0;
-  const weekAgoTvl = weekAgo?.totalLiquidityUSD ?? weekAgo?.tvl ?? 0;
-  if (weekAgoTvl === 0) return null;
-  return (currentTvl - weekAgoTvl) / weekAgoTvl;
-}
-function getCurrentTvl(tvlData) {
-  if (typeof tvlData === "number") return tvlData;
-  if (Array.isArray(tvlData) && tvlData.length > 0) {
-    const last = tvlData[tvlData.length - 1];
-    return last?.totalLiquidityUSD ?? last?.tvl ?? null;
-  }
-  if (tvlData?.tvl) {
-    if (typeof tvlData.tvl === "number") return tvlData.tvl;
-    if (Array.isArray(tvlData.tvl) && tvlData.tvl.length > 0) {
-      const last = tvlData.tvl[tvlData.tvl.length - 1];
-      return last?.totalLiquidityUSD ?? last?.tvl ?? null;
-    }
-  }
-  return null;
-}
-var TvlMomentumStrategy = class {
-  name = "tvlMomentum";
-  description = "Analyzes TVL growth trends \u2014 bullish on rising TVL, bearish on declining";
-  requiredData = ["tvlData"];
-  async analyze(ctx) {
-    if (!ctx.tvlData) {
-      return {
-        name: this.name,
-        value: 0,
-        confidence: 0.1,
-        source: "TVL Momentum",
-        details: "No TVL data available (token may not be a DeFi protocol)"
-      };
-    }
-    const details = [];
-    let value = 0;
-    let confidence = 0.4;
-    const growthWoW = calculateTvlGrowthWoW(ctx.tvlData);
-    if (growthWoW === null) {
-      return {
-        name: this.name,
-        value: 0,
-        confidence: 0.15,
-        source: "TVL Momentum",
-        details: "Insufficient TVL history for momentum calculation"
-      };
-    }
-    const growthPct = growthWoW * 100;
-    if (growthWoW > 0.2) {
-      value = 0.6 + Math.min((growthWoW - 0.2) / 0.3, 0.2);
-      confidence = 0.5;
-      details.push(`TVL surging +${growthPct.toFixed(1)}% WoW: strong bullish momentum`);
-    } else if (growthWoW > 0.1) {
-      value = 0.3 + (growthWoW - 0.1) / 0.1 * 0.3;
-      confidence = 0.45;
-      details.push(`TVL growing +${growthPct.toFixed(1)}% WoW: bullish momentum`);
-    } else if (growthWoW >= -0.02 && growthWoW <= 0.02) {
-      value = 0;
-      confidence = 0.3;
-      details.push(`TVL flat (${growthPct >= 0 ? "+" : ""}${growthPct.toFixed(1)}% WoW): neutral`);
-    } else if (growthWoW > 0.02) {
-      value = 0.1 + (growthWoW - 0.02) / 0.08 * 0.2;
-      details.push(`TVL mildly growing +${growthPct.toFixed(1)}% WoW`);
-    } else if (growthWoW >= -0.05) {
-      value = -0.1 - (Math.abs(growthWoW) - 0.02) / 0.03 * 0.2;
-      details.push(`TVL mildly declining ${growthPct.toFixed(1)}% WoW`);
-    } else if (growthWoW >= -0.15) {
-      value = -(0.3 + (Math.abs(growthWoW) - 0.05) / 0.1 * 0.3);
-      confidence = 0.45;
-      details.push(`TVL declining ${growthPct.toFixed(1)}% WoW: bearish momentum`);
-    } else {
-      value = -(0.7 + Math.min((Math.abs(growthWoW) - 0.15) / 0.15, 0.2));
-      confidence = 0.5;
-      details.push(`TVL crashing ${growthPct.toFixed(1)}% WoW: strong bearish momentum`);
-    }
-    if (ctx.marketData) {
-      const mcap = ctx.marketData.market_cap?.usd ?? ctx.marketData.usd_market_cap;
-      const currentTvl = getCurrentTvl(ctx.tvlData);
-      if (mcap && currentTvl && currentTvl > 0) {
-        const ratio = mcap / currentTvl;
-        if (ratio < 1) {
-          value = clamp(value + 0.15);
-          details.push(`Mcap/TVL ratio ${ratio.toFixed(2)} < 1.0 (potentially undervalued)`);
-        } else if (ratio > 10) {
-          value = clamp(value - 0.1);
-          details.push(`Mcap/TVL ratio ${ratio.toFixed(1)} (potentially overvalued)`);
-        }
-      }
-    }
-    return {
-      name: this.name,
-      value: clamp(value),
-      confidence: Math.min(confidence, 1),
-      source: "TVL Momentum",
-      details: details.join("; ")
-    };
-  }
-};
-
 // src/agent/strategies/funding-rate.ts
 function annualizedYieldFromFundingRate(rate8h) {
   return rate8h * 3 * 365;
@@ -1833,104 +1594,6 @@ var DexFlowStrategy = class {
   }
 };
 
-// src/agent/strategies/mean-reversion.ts
-var MeanReversionStrategy = class {
-  name = "meanReversion";
-  description = "Mean reversion strategy for range-bound markets using BB + RSI + volume";
-  requiredData = ["candles", "technicals"];
-  async analyze(ctx) {
-    if (!ctx.candles || !ctx.technicals || ctx.candles.length < 21) {
-      return {
-        name: this.name,
-        value: 0,
-        confidence: 0.1,
-        source: "Mean Reversion",
-        details: "Insufficient data for mean reversion analysis"
-      };
-    }
-    const tech = ctx.technicals;
-    const details = [];
-    let value = 0;
-    let confidence = 0.6;
-    const currentPrice = ctx.candles[ctx.candles.length - 1].close;
-    if (tech.bb.squeeze) {
-      return {
-        name: this.name,
-        value: 0,
-        confidence: 0.2,
-        source: "Mean Reversion",
-        details: "BB squeeze active \u2014 awaiting breakout, mean reversion inactive"
-      };
-    }
-    const isTrending = tech.bb.width > 0.15;
-    if (isTrending) {
-      confidence -= 0.2;
-      details.push(`BB width ${tech.bb.width.toFixed(4)} (trending market, reduced confidence)`);
-    } else {
-      details.push(`BB width ${tech.bb.width.toFixed(4)} (range-bound, favorable)`);
-    }
-    const ema50 = tech.ema.ema50;
-    const ema200 = tech.ema.ema200;
-    const bullishTrend = !isNaN(ema50) && !isNaN(ema200) && ema50 > ema200;
-    const bearishTrend = !isNaN(ema50) && !isNaN(ema200) && ema50 < ema200;
-    const volumeSpike = tech.volume.ratio > 1.5;
-    if (currentPrice < tech.bb.lower && tech.rsi < 30) {
-      value = 0.6;
-      details.push(`Price $${currentPrice.toFixed(2)} below lower BB $${tech.bb.lower.toFixed(2)}`);
-      details.push(`RSI ${tech.rsi.toFixed(1)} oversold`);
-      if (volumeSpike) {
-        value += 0.1;
-        confidence += 0.1;
-        details.push(`Volume spike ${tech.volume.ratio.toFixed(1)}x (capitulation confirmed)`);
-      }
-      if (bearishTrend) {
-        confidence -= 0.15;
-        details.push("Bearish EMA trend \u2014 reduced confidence on buy");
-      } else if (bullishTrend) {
-        confidence += 0.1;
-        details.push("Bullish EMA trend supports mean reversion buy");
-      }
-    } else if (currentPrice > tech.bb.upper && tech.rsi > 70) {
-      value = -0.6;
-      details.push(`Price $${currentPrice.toFixed(2)} above upper BB $${tech.bb.upper.toFixed(2)}`);
-      details.push(`RSI ${tech.rsi.toFixed(1)} overbought`);
-      if (volumeSpike) {
-        value -= 0.1;
-        confidence += 0.1;
-        details.push(`Volume spike ${tech.volume.ratio.toFixed(1)}x (euphoria confirmed)`);
-      }
-      if (bullishTrend) {
-        confidence -= 0.15;
-        details.push("Bullish EMA trend \u2014 reduced confidence on sell");
-      } else if (bearishTrend) {
-        confidence += 0.1;
-        details.push("Bearish EMA trend supports mean reversion sell");
-      }
-    } else if (currentPrice < tech.bb.lower) {
-      value = 0.2;
-      details.push(`Price below lower BB but RSI ${tech.rsi.toFixed(1)} not oversold yet`);
-    } else if (currentPrice > tech.bb.upper) {
-      value = -0.2;
-      details.push(`Price above upper BB but RSI ${tech.rsi.toFixed(1)} not overbought yet`);
-    } else if (tech.rsi < 30) {
-      value = 0.15;
-      details.push(`RSI ${tech.rsi.toFixed(1)} oversold but price within BB range`);
-    } else if (tech.rsi > 70) {
-      value = -0.15;
-      details.push(`RSI ${tech.rsi.toFixed(1)} overbought but price within BB range`);
-    } else {
-      details.push("No mean reversion signal \u2014 price within normal range");
-    }
-    return {
-      name: this.name,
-      value: clamp(value),
-      confidence: Math.min(Math.max(confidence, 0.1), 1),
-      source: "Mean Reversion",
-      details: details.join("; ")
-    };
-  }
-};
-
 // src/agent/strategies/hyperliquid-flow.ts
 var HyperliquidFlowStrategy = class {
   name = "hyperliquidFlow";
@@ -2267,20 +1930,25 @@ var MultiTimeframeStrategy = class {
 
 // src/agent/strategies/index.ts
 var DEFAULT_STRATEGIES = [
-  new SmartMoneyStrategy(),
-  new TokenUnlockStrategy(),
+  // ── Active signals (fire rate >25% in production) ──
   new SentimentContrarianStrategy(),
+  // 100% fire rate — F&G based
   new BreakoutOnChainStrategy(),
-  new TvlMomentumStrategy(),
+  // 95% fire rate
   new FundingRateStrategy(),
+  // 52% fire rate — HL native
   new DexFlowStrategy(),
-  new MeanReversionStrategy(),
-  // TwitterSentimentStrategy disabled — Twitter API returns 402 (paid tier
-  // required) for most token queries. Re-enable when we have an API path
-  // that doesn't break. The class is still exported so it can be reinstated
-  // by appending `new TwitterSentimentStrategy()` here.
+  // 18% fire rate
   new HyperliquidFlowStrategy(),
+  // 57% fire rate
   new MultiTimeframeStrategy()
+  // 78% fire rate
+  // ── Disabled: zero or near-zero fire rate in production ──
+  // SmartMoneyStrategy — replaced by Nansen HL perp-trades in index.ts
+  // TwitterSentimentStrategy — Twitter API returns 402
+  // TokenUnlockStrategy — 0% fire rate, no data source
+  // TvlMomentumStrategy — 0% fire rate for majors (no TVL on BTC/SOL)
+  // MeanReversionStrategy — 0% fire rate, BB conditions never met
 ];
 async function runStrategies(ctx, configs) {
   const signals = [];
@@ -3224,14 +2892,14 @@ var MarketRegimeDetector = class _MarketRegimeDetector {
   }
   /**
    * Detect current market regime using BTC candles.
-   * Returns cached result if less than 15 minutes old.
+   * Returns cached result if less than 5 minutes old.
    */
   async detect(btcCandles) {
     try {
       const cached = await this.loadCache();
       const now = Date.now();
       const cacheAge = now - cached.timestamp;
-      const CACHE_DURATION = 15 * 60 * 1e3;
+      const CACHE_DURATION = 5 * 60 * 1e3;
       if (cacheAge < CACHE_DURATION) {
         return cached.analysis;
       }
@@ -3260,6 +2928,8 @@ var MarketRegimeDetector = class _MarketRegimeDetector {
     }
     const closes = candles.map((c) => c.close);
     const currentPrice = closes[closes.length - 1];
+    const momentumResult = this.checkMomentumOverride(candles, currentPrice);
+    if (momentumResult) return momentumResult;
     const ema50 = calculateEMA(closes, 50);
     const ema200 = calculateEMA(closes, 200);
     const currentEma50 = this.getLastValidValue(ema50);
@@ -3328,6 +2998,8 @@ var MarketRegimeDetector = class _MarketRegimeDetector {
     }
     const closes = candles.map((c) => c.close);
     const currentPrice = closes[closes.length - 1];
+    const momentumResult = this.checkMomentumOverride(candles, currentPrice);
+    if (momentumResult) return momentumResult;
     const ema50 = calculateEMA(closes, 50);
     const ema200 = calculateEMA(closes, 200);
     const currentEma50 = this.getLastValidValue(ema50);
@@ -3477,6 +3149,68 @@ var MarketRegimeDetector = class _MarketRegimeDetector {
       return "neutral";
     }
   }
+  /**
+   * Fast momentum check — catches intraday trends that EMA/ADX miss.
+   * Returns a RegimeAnalysis if momentum override fires, or null to fall
+   * through to the standard EMA/ADX classification.
+   *
+   * Threshold is volatility-adjusted: 1.5× the 14-candle ATR as a
+   * percentage of current price, floored at 2% and capped at 8%.
+   * - BTC (daily ATR ~2%): threshold ≈ 3% — same as before
+   * - SOL (daily ATR ~5%): threshold ≈ 7.5% — avoids false triggers on normal alt vol
+   * - FARTCOIN (daily ATR ~10%): threshold = 8% cap — only fires on genuinely unusual moves
+   *
+   * Requirements for trending-up: price above threshold AND in the upper
+   * half of the range (prevents false positives on bounces within a larger
+   * downtrend). Symmetric for trending-down.
+   */
+  checkMomentumOverride(candles, currentPrice) {
+    const MOMENTUM_LOOKBACK = 24;
+    const MIN_THRESHOLD = 0.02;
+    const MAX_THRESHOLD = 0.08;
+    const ATR_MULTIPLIER = 1.5;
+    const atrValues = calculateATR(candles, 14);
+    const currentAtr = this.getLastValidValue(atrValues);
+    const atrPct = currentPrice > 0 && !isNaN(currentAtr) ? currentAtr / currentPrice : 0.02;
+    const threshold = Math.min(MAX_THRESHOLD, Math.max(MIN_THRESHOLD, atrPct * ATR_MULTIPLIER));
+    const bb = calculateBollingerBands(candles, 20, 2);
+    const currentBbWidth = this.getLastValidValue(bb.width);
+    let volLevel = "normal";
+    if (!isNaN(currentBbWidth)) {
+      if (currentBbWidth < 0.04) volLevel = "low";
+      else if (currentBbWidth > 0.2) volLevel = "extreme";
+      else if (currentBbWidth > 0.1) volLevel = "high";
+    }
+    const recentCandles = candles.slice(-MOMENTUM_LOOKBACK);
+    const recentLow = Math.min(...recentCandles.map((c) => c.low));
+    const recentHigh = Math.max(...recentCandles.map((c) => c.high));
+    const pctAboveLow = recentLow > 0 ? (currentPrice - recentLow) / recentLow : 0;
+    const pctBelowHigh = recentHigh > 0 ? (recentHigh - currentPrice) / recentHigh : 0;
+    const recentMid = (recentHigh + recentLow) / 2;
+    const inUpperHalf = currentPrice >= recentMid;
+    const inLowerHalf = currentPrice <= recentMid;
+    if (pctAboveLow >= threshold && inUpperHalf) {
+      return {
+        regime: "trending-up",
+        confidence: Math.min(0.85, 0.5 + pctAboveLow * 5),
+        btcTrend: "up",
+        volatilityLevel: volLevel,
+        details: `Momentum override: price +${(pctAboveLow * 100).toFixed(1)}% above ${MOMENTUM_LOOKBACK}-candle low (threshold ${(threshold * 100).toFixed(1)}%, ATR-adjusted)`,
+        strategyAdjustments: this.getStrategyAdjustments("trending-up")
+      };
+    }
+    if (pctBelowHigh >= threshold && inLowerHalf) {
+      return {
+        regime: "trending-down",
+        confidence: Math.min(0.85, 0.5 + pctBelowHigh * 5),
+        btcTrend: "down",
+        volatilityLevel: volLevel,
+        details: `Momentum override: price -${(pctBelowHigh * 100).toFixed(1)}% below ${MOMENTUM_LOOKBACK}-candle high (threshold ${(threshold * 100).toFixed(1)}%, ATR-adjusted)`,
+        strategyAdjustments: this.getStrategyAdjustments("trending-down")
+      };
+    }
+    return null;
+  }
   getStrategyAdjustments(regime) {
     const baseMultipliers = {
       "trending-up": {
@@ -4171,7 +3905,7 @@ var TradingAgent = class {
     this.alertSystem = new AlertSystem();
   }
   /** Analyze a single token — gather all data and score. */
-  async analyzeToken(tokenId) {
+  async analyzeToken(tokenId, opts) {
     const signals = [];
     let technicalSignals;
     let fearAndGreedValue;
@@ -4225,6 +3959,36 @@ var TradingAgent = class {
       candles = ohlcResult.value;
       technicalSignals = getLatestSignals(candles);
       signals.push(scoreTechnical(technicalSignals));
+      if (candles.length >= 24) {
+        const recent = candles.slice(-24);
+        const currentClose = recent[recent.length - 1].close;
+        const recentLow = Math.min(...recent.map((c) => c.low));
+        const recentHigh = Math.max(...recent.map((c) => c.high));
+        const pctFromLow = recentLow > 0 ? (currentClose - recentLow) / recentLow : 0;
+        const pctFromHigh = recentHigh > 0 ? (recentHigh - currentClose) / recentHigh : 0;
+        let momentumValue = 0;
+        let momentumDetails = "";
+        if (pctFromHigh < 0.01) {
+          momentumValue = Math.min(0.6, pctFromLow * 5);
+          momentumDetails = `Price +${(pctFromLow * 100).toFixed(1)}% from 24-candle low, near highs`;
+        } else if (pctFromLow < 0.01) {
+          momentumValue = -Math.min(0.6, pctFromHigh * 5);
+          momentumDetails = `Price -${(pctFromHigh * 100).toFixed(1)}% from 24-candle high, near lows`;
+        } else if (recentHigh > recentLow) {
+          const rangePosition = (currentClose - recentLow) / (recentHigh - recentLow);
+          momentumValue = (rangePosition - 0.5) * 0.4;
+          momentumDetails = `Mid-range (${(rangePosition * 100).toFixed(0)}th percentile of 24-candle range)`;
+        }
+        if (Math.abs(momentumValue) > 0.02) {
+          signals.push({
+            name: "momentum",
+            value: momentumValue,
+            confidence: Math.min(0.7, 0.3 + Math.abs(momentumValue)),
+            source: "Price Momentum",
+            details: momentumDetails
+          });
+        }
+      }
     } else if (ohlcResult.status === "rejected") {
       console.error(chalk.dim(`  Technical analysis failed for ${tokenId}: ${ohlcResult.reason}`));
     }
@@ -4233,7 +3997,6 @@ var TradingAgent = class {
       fearAndGreedValue = fgData[0].value;
       const values = fgData.map((d) => d.value);
       sentimentZScore = this.sentiment.computeSentimentZScore(values);
-      signals.push(scoreSentiment(fearAndGreedValue, sentimentZScore));
     } else if (fearGreedResult.status === "rejected") {
       console.error(chalk.dim(`  Sentiment data failed: ${fearGreedResult.reason}`));
     }
@@ -4269,58 +4032,65 @@ var TradingAgent = class {
     }
     let nansenData = void 0;
     let messariData = void 0;
-    if (this.config.useX402) {
-      const [nansenResult, messariResult] = await Promise.allSettled([
-        // 4. Smart-money & on-chain data (via Nansen x402)
-        getResearchProvider("nansen").query({ type: "smart-money", target: tokenId }),
-        // 5. Fundamentals & events (via Messari x402)
-        getResearchProvider("messari").query({ type: "token", target: tokenId })
+    const x402Enabled = this.config.useX402 && !opts?.skipX402;
+    let x402Available = x402Enabled ? false : void 0;
+    if (x402Enabled) {
+      x402Available = await isX402WalletFunded();
+      if (!x402Available) {
+        console.error(chalk.yellow(`  x402 wallet has insufficient USDC \u2014 skipping paid signals (smartMoney, event) for this cycle`));
+      }
+    }
+    if (x402Enabled && x402Available) {
+      const hlSymbolMap = {
+        bitcoin: "BTC",
+        ethereum: "ETH",
+        solana: "SOL",
+        arbitrum: "ARB",
+        aave: "AAVE",
+        uniswap: "UNI",
+        dogecoin: "DOGE",
+        ripple: "XRP",
+        hyperliquid: "HYPE",
+        "worldcoin-wld": "WLD",
+        bittensor: "TAO",
+        zcash: "ZEC",
+        fartcoin: "FARTCOIN",
+        pepe: "PEPE",
+        polkadot: "DOT"
+      };
+      const hlSymbol = hlSymbolMap[tokenId] ?? tokenId.toUpperCase();
+      const nansenProvider = getResearchProvider("nansen");
+      const [hlPerpResult] = await Promise.allSettled([
+        nansenProvider.queryHyperliquidSmartMoney(hlSymbol)
       ]);
-      if (nansenResult.status === "fulfilled") {
-        const smResult = nansenResult.value;
-        nansenData = smResult.data;
-        const flows = smResult.data.flows;
-        if (flows && flows.length > 0) {
-          const netflow = flows.reduce((sum, f) => sum + Number(f.netflow ?? f.net_flow ?? 0), 0);
-          signals.push(scoreOnChain({
-            exchangeNetFlow: netflow,
-            whaleAccumulating: netflow < 0
-          }));
-        } else {
-          signals.push(scoreOnChain({}));
-        }
-        console.error(chalk.dim(`  x402 Nansen smart-money: cost ${smResult.costUsdc} USDC`));
-      } else {
-        console.error(chalk.dim(`  x402 Nansen smart-money unavailable: ${nansenResult.reason} \u2014 using free data only`));
-        signals.push(scoreOnChain({}));
-      }
-      if (messariResult.status === "fulfilled") {
-        const tokenResult = messariResult.value;
-        messariData = tokenResult.data;
-        const d = tokenResult.data;
-        const metrics = d.metrics;
-        const profile = d.profile;
-        const mcapToTvl = metrics ? Number(metrics.mcap_to_tvl ?? 0) || void 0 : void 0;
-        const existingFundIdx = signals.findIndex((s) => s.name === "fundamental");
-        if (existingFundIdx >= 0) signals.splice(existingFundIdx, 1);
-        if (mcapToTvl || metrics) {
-          signals.push(scoreFundamental({ mcapToTvl }));
+      if (hlPerpResult.status === "fulfilled") {
+        const hlResult = hlPerpResult.value;
+        const trades = hlResult.data.trades;
+        if (trades && trades.length > 0) {
+          let longValueUsd = 0;
+          let shortValueUsd = 0;
+          for (const t of trades) {
+            const val = Number(t.value_usd ?? 0);
+            const side = String(t.side ?? "").toLowerCase();
+            if (side === "long") longValueUsd += val;
+            else if (side === "short") shortValueUsd += val;
+          }
+          const totalValue = longValueUsd + shortValueUsd;
+          const longRatio = totalValue > 0 ? longValueUsd / totalValue : 0.5;
+          const smBias = (longRatio - 0.5) * 2;
+          signals.push({
+            name: "smartMoney",
+            value: smBias * 0.5,
+            confidence: Math.min(0.7, 0.3 + trades.length / 30 * 0.4),
+            source: "Nansen HL Smart Money",
+            details: `${trades.length} trades: $${(longValueUsd / 1e6).toFixed(1)}M long / $${(shortValueUsd / 1e6).toFixed(1)}M short (${(longRatio * 100).toFixed(0)}% long)`
+          });
+          console.error(chalk.dim(`  x402 Nansen HL perps: ${trades.length} trades, ${(longRatio * 100).toFixed(0)}% long bias, cost ${hlResult.costUsdc} USDC`));
         } else {
-          signals.push(scoreFundamental({}));
+          console.error(chalk.dim(`  x402 Nansen HL perps: no recent trades for ${hlSymbol}`));
         }
-        const hasPositiveCatalyst = profile ? Boolean(profile.is_verified || profile.tag_names) : false;
-        signals.push(scoreEvent({ positiveEvent: hasPositiveCatalyst || void 0 }));
-        console.error(chalk.dim(`  x402 Messari token: cost ${tokenResult.costUsdc} USDC`));
       } else {
-        console.error(chalk.dim(`  x402 Messari unavailable: ${messariResult.reason} \u2014 using free data only`));
-        if (!signals.some((s) => s.name === "fundamental")) {
-          signals.push(scoreFundamental({}));
-        }
-        signals.push(scoreEvent({}));
-      }
-    } else {
-      if (!signals.some((s) => s.name === "fundamental")) {
-        signals.push(scoreFundamental({}));
+        console.error(chalk.dim(`  x402 Nansen HL perps unavailable: ${hlPerpResult.reason}`));
       }
       signals.push(scoreEvent({}));
     }
@@ -4442,7 +4212,8 @@ var TradingAgent = class {
       resolvedWeights,
       regimeAnalysis?.strategyAdjustments,
       correlationCheck,
-      regimeAnalysis?.regime
+      regimeAnalysis?.regime,
+      x402Available
     );
     const result = {
       token: tokenId,
@@ -4459,14 +4230,43 @@ var TradingAgent = class {
   updateTokens(tokens) {
     this.config.tokens = tokens;
   }
-  /** Analyze all watchlist tokens. */
+  /** Analyze all watchlist tokens.
+   *
+   *  When `x402TopN` is set and x402 is enabled, uses a two-pass approach:
+   *  1. Score ALL tokens with free signals only (no x402 cost)
+   *  2. Re-score the top N tokens by free-signal score WITH x402 paid data
+   *
+   *  This reduces x402 cost from ~$0.16×10 = $1.60/run to ~$0.16×3 = $0.48/run
+   *  while concentrating paid data on the tokens most likely to fire trades.
+   */
   async analyzeAll() {
-    const results = [];
+    const topN = this.config.x402TopN;
+    const shouldTwoPass = this.config.useX402 && topN && topN > 0 && topN < this.config.tokens.length;
+    if (!shouldTwoPass) {
+      const results = [];
+      for (const token of this.config.tokens) {
+        const result = await this.analyzeToken(token);
+        results.push(result);
+      }
+      return results;
+    }
+    console.error(chalk.dim(`  x402 top-${topN} mode: scoring all ${this.config.tokens.length} tokens with free signals first...`));
+    const freeResults = [];
     for (const token of this.config.tokens) {
-      const result = await this.analyzeToken(token);
-      results.push(result);
+      const result = await this.analyzeToken(token, { skipX402: true });
+      freeResults.push(result);
     }
-    return results;
+    const ranked = [...freeResults].sort(
+      (a, b) => Math.abs(b.decision.score) - Math.abs(a.decision.score)
+    );
+    const topTokens = new Set(ranked.slice(0, topN).map((r) => r.token));
+    console.error(chalk.dim(`  x402 enriching top ${topN}: ${[...topTokens].join(", ")}`));
+    const enrichedMap = /* @__PURE__ */ new Map();
+    for (const token of topTokens) {
+      const enriched = await this.analyzeToken(token);
+      enrichedMap.set(token, enriched);
+    }
+    return freeResults.map((r) => enrichedMap.get(r.token) ?? r);
   }
   /** Analyze all tokens and generate alerts for state changes. */
   async analyzeAllWithAlerts() {
@@ -4708,7 +4508,8 @@ var DynamicTokenSelector = class {
     const config = {
       minVolume24h: 5e6,
       // $5M minimum
-      topByVolume: 10,
+      topByVolume: 18,
+      // bumped 10 → 18 for more shots on goal per cycle
       fundingExtremes: 5,
       minFundingRate: 3e-4,
       // 0.03%
@@ -4807,7 +4608,7 @@ var DynamicTokenSelector = class {
         }
       }
     }
-    const tokens = Array.from(selectedTokens).slice(0, 20);
+    const tokens = Array.from(selectedTokens).slice(0, 25);
     return {
       tokens,
       reason: Object.fromEntries(
@@ -4901,7 +4702,7 @@ import { homedir as homedir11 } from "os";
 import chalk2 from "chalk";
 import { createWalletClient, http, encodeFunctionData, encodeAbiParameters } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
-var TradeExecutor = class {
+var TradeExecutor = class _TradeExecutor {
   config;
   riskManager;
   portfolio;
@@ -4910,62 +4711,118 @@ var TradeExecutor = class {
     this.riskManager = riskManager;
     this.portfolio = portfolio;
   }
+  /** CoinGecko token ID → Hyperliquid perp asset index.
+   *  Used by multi-asset execution to resolve which HL perp to trade
+   *  when a signal fires. One strategy clone can trade any of these. */
+  static TOKEN_TO_ASSET_INDEX = {
+    bitcoin: 0,
+    ethereum: 1,
+    solana: 2,
+    arbitrum: 4,
+    dogecoin: 6,
+    chainlink: 8,
+    aave: 10,
+    uniswap: 11,
+    ripple: 23,
+    polkadot: 28,
+    avalanche: 35,
+    hyperliquid: 131,
+    zcash: 144,
+    bittensor: 148,
+    "worldcoin-wld": 265,
+    fartcoin: 343,
+    "fetch-ai": 373,
+    pepe: 166,
+    pendle: 249,
+    sui: 116,
+    near: 71,
+    aptos: 83
+  };
+  /** Resolve a CoinGecko token ID to its HL perp asset index. */
+  static resolveAssetIndex(tokenId) {
+    return _TradeExecutor.TOKEN_TO_ASSET_INDEX[tokenId];
+  }
   /** Execute a trade based on a decision */
   async execute(decision, tokenId, currentPrice) {
-    if (decision.action === "SELL" || decision.action === "STRONG_SELL") {
+    if ((decision.action === "SELL" || decision.action === "STRONG_SELL") && this.config.mode !== "hyperliquid-perp") {
       const sellState = await this.portfolio.load();
       const existing = sellState.positions.find((p) => p.tokenId === tokenId);
-      if (!existing) {
-        return {
-          success: false,
-          error: `No open position in ${tokenId} to sell`,
-          dryRun: this.config.dryRun
-        };
-      }
-      try {
-        const reason = decision.action === "STRONG_SELL" ? "Strong sell signal" : "Sell signal";
-        if (this.config.dryRun) {
-          console.error(chalk2.cyan(`[DRY RUN] Paper trade: SELL ${existing.quantity.toFixed(6)} ${tokenId} @ $${currentPrice.toFixed(4)}`));
+      const existingSide = existing?.side ?? "long";
+      if (existing && existingSide === "long") {
+        try {
+          const reason = decision.action === "STRONG_SELL" ? "Strong sell signal" : "Sell signal";
+          if (this.config.dryRun) {
+            console.error(chalk2.cyan(`[DRY RUN] Paper trade: SELL ${existing.quantity.toFixed(6)} ${tokenId} @ $${currentPrice.toFixed(4)}`));
+          }
+          const closeResult = await this.portfolio.closePosition(tokenId, currentPrice, reason);
+          return {
+            success: true,
+            position: { ...existing, currentPrice, pnlUsd: closeResult.pnl, pnlPercent: closeResult.pnlPercent },
+            dryRun: this.config.dryRun
+          };
+        } catch (err) {
+          return {
+            success: false,
+            error: `Failed to close position: ${err.message}`,
+            dryRun: this.config.dryRun
+          };
         }
-        const closeResult = await this.portfolio.closePosition(tokenId, currentPrice, reason);
-        return {
-          success: true,
-          position: { ...existing, currentPrice, pnlUsd: closeResult.pnl, pnlPercent: closeResult.pnlPercent },
-          dryRun: this.config.dryRun
-        };
-      } catch (err) {
-        return {
-          success: false,
-          error: `Failed to close position: ${err.message}`,
-          dryRun: this.config.dryRun
-        };
       }
     }
-    if (decision.action !== "BUY" && decision.action !== "STRONG_BUY") {
+    if (decision.action !== "BUY" && decision.action !== "STRONG_BUY" && decision.action !== "SELL" && decision.action !== "STRONG_SELL") {
       return {
         success: false,
         error: `Action ${decision.action} does not trigger execution`,
         dryRun: this.config.dryRun
       };
     }
+    if (this.config.mode === "hyperliquid-perp") {
+      const resolvedIndex = _TradeExecutor.resolveAssetIndex(tokenId);
+      if (resolvedIndex === void 0) {
+        return {
+          success: false,
+          error: `Token ${tokenId} has no known Hyperliquid perp asset index \u2014 skipping execution`,
+          dryRun: this.config.dryRun
+        };
+      }
+    }
     const state = await this.portfolio.load();
     this.riskManager.updatePortfolio(state);
-    const stopLossDistance = currentPrice * 0.08;
-    const stopLossPrice = currentPrice - stopLossDistance;
-    const takeProfitPrice = currentPrice * (1 + 0.08 * 2.5);
+    const isShort = decision.action === "SELL" || decision.action === "STRONG_SELL";
+    const direction = isShort ? "short" : "long";
+    const STOP_LOSS_PCT2 = 0.03;
+    const RR_RATIO = 2;
+    const stopLossDistance = currentPrice * STOP_LOSS_PCT2;
+    const stopLossPrice = isShort ? currentPrice + stopLossDistance : currentPrice - stopLossDistance;
+    const takeProfitPrice = isShort ? currentPrice * (1 - STOP_LOSS_PCT2 * RR_RATIO) : currentPrice * (1 + STOP_LOSS_PCT2 * RR_RATIO);
+    const existingSameSide = state.positions.find(
+      (p) => p.tokenId === tokenId && (p.side ?? "long") === direction
+    );
+    const isPyramid = existingSameSide !== void 0;
+    const sizeMultiplier = isPyramid ? 0.5 ** ((existingSameSide.addCount ?? 0) + 1) : 1;
     const sizing = this.riskManager.calculatePositionSize(
       currentPrice,
       stopLossPrice,
       state.totalValue
     );
-    if (sizing.quantity <= 0 || sizing.sizeUsd <= 0) {
+    const pyramidQuantity = sizing.quantity * sizeMultiplier;
+    const pyramidSizeUsd = sizing.sizeUsd * sizeMultiplier;
+    if (pyramidQuantity <= 0 || pyramidSizeUsd <= 0) {
       return {
         success: false,
         error: "Position sizing returned zero \u2014 check portfolio value and stop distance",
         dryRun: this.config.dryRun
       };
     }
-    const check = this.riskManager.canOpenPosition(tokenId, sizing.sizeUsd);
+    const MIN_PYRAMID_USD = 15;
+    if (isPyramid && pyramidSizeUsd < MIN_PYRAMID_USD) {
+      return {
+        success: false,
+        error: `Pyramid add #${(existingSameSide.addCount ?? 0) + 1} would be $${pyramidSizeUsd.toFixed(2)} \u2014 below $${MIN_PYRAMID_USD} HL minimum notional. Skipping.`,
+        dryRun: this.config.dryRun
+      };
+    }
+    const check = this.riskManager.canOpenPosition(tokenId, pyramidSizeUsd, direction);
     if (!check.allowed) {
       return {
         success: false,
@@ -4975,15 +4832,15 @@ var TradeExecutor = class {
     }
     const order = {
       tokenId,
-      side: "buy",
-      amountUsd: sizing.sizeUsd,
+      side: isShort ? "sell" : "buy",
+      amountUsd: pyramidSizeUsd,
       maxSlippage: 0.015,
       stopLoss: stopLossPrice,
       takeProfit: takeProfitPrice
     };
     if (this.config.dryRun) {
       try {
-        const position = await this.executeDryRun(order, currentPrice);
+        const position = await this.executeDryRun(order, currentPrice, isPyramid);
         return { success: true, position, dryRun: true };
       } catch (err) {
         return {
@@ -4995,12 +4852,13 @@ var TradeExecutor = class {
     } else {
       try {
         const result = await this.executeLive(order, currentPrice);
-        const position = await this.portfolio.openPosition({
+        const position = isPyramid ? await this.portfolio.addToPosition(tokenId, result.executedPrice, pyramidQuantity, direction) : await this.portfolio.openPosition({
           tokenId,
           symbol: tokenId.toUpperCase(),
+          side: direction,
           entryPrice: result.executedPrice,
           currentPrice: result.executedPrice,
-          quantity: sizing.quantity,
+          quantity: pyramidQuantity,
           entryTimestamp: Date.now(),
           stopLoss: order.stopLoss,
           takeProfit: order.takeProfit,
@@ -5040,13 +4898,19 @@ var TradeExecutor = class {
     return results;
   }
   /** Dry-run execution — paper trade */
-  async executeDryRun(order, currentPrice) {
+  async executeDryRun(order, currentPrice, isPyramid = false) {
     const quantity = order.amountUsd / currentPrice;
-    console.error(chalk2.cyan(`[DRY RUN] Paper trade: BUY ${quantity.toFixed(6)} ${order.tokenId} @ $${currentPrice.toFixed(4)}`));
+    const direction = order.side === "sell" ? "short" : "long";
+    const sideLabel = isPyramid ? direction === "short" ? "PYRAMID SHORT" : "PYRAMID BUY" : direction === "short" ? "SHORT" : "BUY";
+    console.error(chalk2.cyan(`[DRY RUN] Paper trade: ${sideLabel} ${quantity.toFixed(6)} ${order.tokenId} @ $${currentPrice.toFixed(4)}`));
     console.error(chalk2.cyan(`  Size: $${order.amountUsd.toFixed(2)} | SL: $${order.stopLoss.toFixed(4)} | TP: $${order.takeProfit.toFixed(4)}`));
+    if (isPyramid) {
+      return this.portfolio.addToPosition(order.tokenId, currentPrice, quantity, direction);
+    }
     const position = await this.portfolio.openPosition({
       tokenId: order.tokenId,
       symbol: order.tokenId.toUpperCase(),
+      side: direction,
       entryPrice: currentPrice,
       currentPrice,
       quantity,
@@ -5078,16 +4942,18 @@ var TradeExecutor = class {
       chain,
       transport: http()
     });
-    const limitPx = priceToUint64(currentPrice * 1.01);
+    const assetIndex = _TradeExecutor.resolveAssetIndex(order.tokenId) ?? this.config.assetIndex ?? 3;
+    const isShort = order.side === "sell";
+    const limitPx = isShort ? priceToUint64(currentPrice * 0.99) : priceToUint64(currentPrice * 1.01);
     const quantity = order.amountUsd / currentPrice;
-    const assetIndex = this.config.assetIndex ?? 3;
     const szDec = await getSzDecimals(assetIndex);
     const sz = sizeToUint64(quantity, szDec);
     const stopLossPx = priceToUint64(order.stopLoss);
     const stopLossSz = sz;
+    const action = isShort ? 7 : 6;
     const actionData = encodeAbiParameters(
-      [{ type: "uint8" }, { type: "uint64" }, { type: "uint64" }, { type: "uint64" }, { type: "uint64" }],
-      [1, limitPx, sz, stopLossPx, stopLossSz]
+      [{ type: "uint8" }, { type: "uint32" }, { type: "uint64" }, { type: "uint64" }, { type: "uint64" }, { type: "uint64" }],
+      [action, assetIndex, limitPx, sz, stopLossPx, stopLossSz]
     );
     const txData = encodeFunctionData({
       abi: BASE_STRATEGY_ABI,
@@ -5213,6 +5079,75 @@ var PortfolioTracker = class {
     this.historyPath = join10(base, "trades.json");
     this.state = { ...DEFAULT_PORTFOLIO };
   }
+  /**
+   * Initialize portfolio from on-chain vault balance instead of the
+   * hardcoded $10k default. Reads totalAssets() from the vault that
+   * the strategy clone is deployed to.
+   *
+   * Call once on startup (before the first cycle) when no persisted
+   * portfolio.json exists. If a portfolio already exists on disk,
+   * this is a no-op — we trust the persisted state.
+   *
+   * @param strategyClone - HyperliquidPerpStrategy clone address
+   * @param chain - 'hyperevm' | 'hyperevm-testnet'
+   */
+  async initFromOnChain(strategyClone, chain) {
+    try {
+      await readFile10(this.statePath, "utf-8");
+      return;
+    } catch {
+    }
+    try {
+      const { createPublicClient, http: http2 } = await import("viem");
+      const { hyperevm: hyperevm2, hyperevmTestnet: hyperevmTestnet2 } = await import("./network-KSMKPKNL.js");
+      const { BASE_STRATEGY_ABI: BASE_STRATEGY_ABI2, SYNDICATE_VAULT_ABI } = await import("./abis-TXCLIR2K.js");
+      const selectedChain = chain === "hyperevm-testnet" ? hyperevmTestnet2 : hyperevm2;
+      const client = createPublicClient({
+        chain: selectedChain,
+        transport: http2()
+      });
+      const vaultAddr = await client.readContract({
+        address: strategyClone,
+        abi: BASE_STRATEGY_ABI2,
+        functionName: "vault"
+      });
+      if (!vaultAddr || vaultAddr === "0x0000000000000000000000000000000000000000") {
+        console.error("[portfolio] Strategy clone has no vault \u2014 using default portfolio");
+        return;
+      }
+      const totalAssets = await client.readContract({
+        address: vaultAddr,
+        abi: SYNDICATE_VAULT_ABI,
+        functionName: "totalAssets"
+      });
+      const vaultValueUsd = Number(totalAssets) / 1e6;
+      if (vaultValueUsd > 0) {
+        this.state = {
+          ...DEFAULT_PORTFOLIO,
+          totalValue: vaultValueUsd,
+          cash: vaultValueUsd
+        };
+        await this.save(this.state);
+        console.error(`[portfolio] Initialized from on-chain vault: $${vaultValueUsd.toFixed(2)} USDC`);
+      } else {
+        console.error("[portfolio] Vault has 0 assets \u2014 using default portfolio");
+      }
+    } catch (err) {
+      console.error(`[portfolio] Failed to read on-chain balance: ${err.message} \u2014 using default`);
+    }
+  }
+  /**
+   * Force-refresh portfolio value from on-chain vault balance.
+   * Unlike initFromOnChain(), this runs even if portfolio.json exists.
+   * Call via `sherwood agent config --sync-vault` or on explicit user request.
+   */
+  async syncFromOnChain(strategyClone, chain) {
+    try {
+      await import("fs/promises").then((fs) => fs.unlink(this.statePath));
+    } catch {
+    }
+    await this.initFromOnChain(strategyClone, chain);
+  }
   /** Load portfolio state from disk with validation */
   async load() {
     try {
@@ -5255,6 +5190,8 @@ var PortfolioTracker = class {
     await this.load();
     const fullPosition = {
       ...position,
+      addCount: position.addCount ?? 0,
+      lastAddTimestamp: position.lastAddTimestamp ?? position.entryTimestamp,
       pnlPercent: 0,
       pnlUsd: 0
     };
@@ -5267,6 +5204,47 @@ var PortfolioTracker = class {
     await this.save(this.state);
     return fullPosition;
   }
+  /**
+   * Pyramid into an existing position.
+   * Computes a quantity-weighted average entry price and increments `addCount`.
+   * Cash is debited at the new fill price. Stops/take-profits stay anchored to
+   * the prior values (caller is free to widen them after).
+   *
+   * Throws if no existing position exists or the side disagrees.
+   */
+  async addToPosition(tokenId, addPrice, addQuantity, side) {
+    if (addQuantity <= 0) throw new Error(`Invalid add quantity: ${addQuantity}`);
+    if (addPrice <= 0) throw new Error(`Invalid add price: ${addPrice}`);
+    await this.load();
+    const idx = this.state.positions.findIndex((p) => p.tokenId === tokenId);
+    if (idx === -1) throw new Error(`No open position for ${tokenId} to pyramid into`);
+    const pos = this.state.positions[idx];
+    const existingSide = pos.side ?? "long";
+    if (existingSide !== side) {
+      throw new Error(`Cannot pyramid ${side} on existing ${existingSide} position in ${tokenId}`);
+    }
+    const newQty = pos.quantity + addQuantity;
+    const weightedEntry = (pos.entryPrice * pos.quantity + addPrice * addQuantity) / newQty;
+    const updated = {
+      ...pos,
+      entryPrice: weightedEntry,
+      quantity: newQty,
+      currentPrice: addPrice,
+      addCount: (pos.addCount ?? 0) + 1,
+      lastAddTimestamp: Date.now(),
+      pnlPercent: 0,
+      // recomputed on next price update
+      pnlUsd: 0
+    };
+    this.state.positions[idx] = updated;
+    this.state.cash -= addPrice * addQuantity;
+    this.state.totalValue = this.state.cash + this.state.positions.reduce(
+      (sum, p) => sum + p.quantity * p.currentPrice,
+      0
+    );
+    await this.save(this.state);
+    return updated;
+  }
   /** Close a position and record trade */
   async closePosition(tokenId, exitPrice, reason) {
     await this.load();
@@ -5275,13 +5253,14 @@ var PortfolioTracker = class {
       throw new Error(`No open position for ${tokenId}`);
     }
     const pos = this.state.positions[idx];
-    const pnlUsd = (exitPrice - pos.entryPrice) * pos.quantity;
-    const pnlPercent = (exitPrice - pos.entryPrice) / pos.entryPrice;
+    const isShort = pos.side === "short";
+    const pnlUsd = isShort ? (pos.entryPrice - exitPrice) * pos.quantity : (exitPrice - pos.entryPrice) * pos.quantity;
+    const pnlPercent = isShort ? (pos.entryPrice - exitPrice) / (pos.entryPrice || 1) : (exitPrice - pos.entryPrice) / (pos.entryPrice || 1);
     const duration = Math.floor((Date.now() - pos.entryTimestamp) / 1e3);
     const record = {
       tokenId: pos.tokenId,
       symbol: pos.symbol,
-      side: "long",
+      side: pos.side ?? "long",
       entryPrice: pos.entryPrice,
       exitPrice,
       quantity: pos.quantity,
@@ -5313,8 +5292,9 @@ var PortfolioTracker = class {
       const price = prices[pos.tokenId];
       if (price !== void 0) {
         pos.currentPrice = price;
-        pos.pnlUsd = (price - pos.entryPrice) * pos.quantity;
-        pos.pnlPercent = (price - pos.entryPrice) / pos.entryPrice;
+        const isShort = pos.side === "short";
+        pos.pnlUsd = isShort ? (pos.entryPrice - price) * pos.quantity : (price - pos.entryPrice) * pos.quantity;
+        pos.pnlPercent = isShort ? (pos.entryPrice - price) / (pos.entryPrice || 1) : (price - pos.entryPrice) / (pos.entryPrice || 1);
       }
     }
     this.state.totalValue = this.state.cash + this.state.positions.reduce(
@@ -5465,7 +5445,8 @@ var DEFAULT_RISK_CONFIG = {
   maxSinglePosition: 0.1,
   maxCorrelatedExposure: 0.2,
   maxConcurrentTrades: 8,
-  hardStopPercent: 0.12,
+  hardStopPercent: 0.05,
+  // 5% hard stop — short-term trades shouldn't bleed past this
   trailingStopAtr: 1.5,
   trailingStopPct: 0,
   // OFF — opt in via config
@@ -5479,6 +5460,8 @@ var DEFAULT_RISK_CONFIG = {
   maxSlippage: { large: 5e-3, mid: 0.015, small: 0.03 },
   riskPerTrade: 0.02
 };
+var MAX_PYRAMID_ADDS = 2;
+var PYRAMID_MIN_SPACING_MS = 4 * 60 * 60 * 1e3;
 var EMPTY_PORTFOLIO = {
   totalValue: 0,
   positions: [],
@@ -5494,8 +5477,11 @@ var RiskManager = class {
     this.config = { ...DEFAULT_RISK_CONFIG, ...config };
     this.portfolio = { ...EMPTY_PORTFOLIO };
   }
-  /** Check if we can open a new position */
-  canOpenPosition(token, sizeUsd) {
+  /** Check if we can open a new position (or pyramid into an existing one).
+   *  When `direction` is omitted, defaults to 'long' for backward compatibility.
+   *  An existing position with a different direction always rejects (no flips
+   *  via pyramid — flips must explicitly close the prior position first). */
+  canOpenPosition(token, sizeUsd, direction = "long") {
     if (this.portfolio.positions.length >= this.config.maxConcurrentTrades) {
       return { allowed: false, reason: `Max concurrent trades (${this.config.maxConcurrentTrades}) reached` };
     }
@@ -5528,7 +5514,20 @@ var RiskManager = class {
     }
     const existing = this.portfolio.positions.find((p) => p.tokenId === token);
     if (existing) {
-      return { allowed: false, reason: `Already have an open position in ${token}` };
+      const existingSide = existing.side ?? "long";
+      if (existingSide !== direction) {
+        return { allowed: false, reason: `Conflicting position in ${token} (existing ${existingSide}, signal ${direction}) \u2014 close first` };
+      }
+      const addCount = existing.addCount ?? 0;
+      if (addCount >= MAX_PYRAMID_ADDS) {
+        return { allowed: false, reason: `Pyramid cap reached for ${token} (${MAX_PYRAMID_ADDS} adds)` };
+      }
+      const lastAdd = existing.lastAddTimestamp ?? existing.entryTimestamp;
+      const elapsed = Date.now() - lastAdd;
+      if (elapsed < PYRAMID_MIN_SPACING_MS) {
+        const remainHrs = ((PYRAMID_MIN_SPACING_MS - elapsed) / 36e5).toFixed(1);
+        return { allowed: false, reason: `Pyramid spacing not met for ${token} (next add in ${remainHrs}h)` };
+      }
     }
     if (sizeUsd > this.portfolio.cash) {
       return { allowed: false, reason: `Insufficient cash: need $${sizeUsd.toFixed(2)}, have $${this.portfolio.cash.toFixed(2)}` };
@@ -5584,21 +5583,25 @@ var RiskManager = class {
       return { quantity: 0, sizeUsd: 0, riskUsd: 0 };
     }
     const riskPct = maxRiskPercent ?? this.config.riskPerTrade;
-    const riskUsd = portfolioValue * riskPct;
+    let riskUsd = portfolioValue * riskPct;
     const riskPerUnit = Math.abs(entryPrice - stopLossPrice);
     if (riskPerUnit <= 0) {
       return { quantity: 0, sizeUsd: 0, riskUsd: 0 };
     }
-    const quantity = riskUsd / riskPerUnit;
-    const sizeUsd = quantity * entryPrice;
+    let quantity = riskUsd / riskPerUnit;
+    let sizeUsd = quantity * entryPrice;
     const maxSizeUsd = portfolioValue * this.config.maxSinglePosition;
     if (sizeUsd > maxSizeUsd) {
-      const cappedQuantity = maxSizeUsd / entryPrice;
-      return {
-        quantity: cappedQuantity,
-        sizeUsd: maxSizeUsd,
-        riskUsd: cappedQuantity * riskPerUnit
-      };
+      sizeUsd = maxSizeUsd;
+      quantity = maxSizeUsd / entryPrice;
+      riskUsd = quantity * riskPerUnit;
+    }
+    const MIN_POSITION_USD = 15;
+    const effectiveFloor = Math.min(MIN_POSITION_USD, maxSizeUsd);
+    if (sizeUsd < effectiveFloor && portfolioValue >= MIN_POSITION_USD * 2) {
+      sizeUsd = effectiveFloor;
+      quantity = sizeUsd / entryPrice;
+      riskUsd = quantity * riskPerUnit;
     }
     return { quantity, sizeUsd, riskUsd };
   }
@@ -5658,25 +5661,43 @@ var RiskManager = class {
   updateTrailingStops(positions) {
     return positions.map((pos) => {
       if (pos.currentPrice <= 0 || pos.entryPrice <= 0) return pos;
-      const pnlPct = (pos.currentPrice - pos.entryPrice) / pos.entryPrice;
+      const isShort = pos.side === "short";
+      const pnlPct = isShort ? (pos.entryPrice - pos.currentPrice) / (pos.entryPrice || 1) : (pos.currentPrice - pos.entryPrice) / (pos.entryPrice || 1);
       let newStop = pos.stopLoss;
-      if (this.config.breakevenTriggerPct > 0 && pnlPct >= this.config.breakevenTriggerPct) {
-        newStop = Math.max(newStop, pos.entryPrice);
-      }
-      if (this.config.profitLockSteps.length > 0) {
+      if (isShort) {
+        if (this.config.breakevenTriggerPct > 0 && pnlPct >= this.config.breakevenTriggerPct) {
+          newStop = Math.min(newStop, pos.entryPrice);
+        }
+        for (const step of this.config.profitLockSteps) {
+          if (pnlPct >= step.trigger) {
+            const lockedStop = pos.entryPrice * (1 - step.lock);
+            newStop = Math.min(newStop, lockedStop);
+          }
+        }
+        if (this.config.trailingStopPct > 0) {
+          const trailStop = pos.currentPrice * (1 + this.config.trailingStopPct);
+          newStop = Math.min(newStop, trailStop);
+        }
+        if (newStop < pos.stopLoss) {
+          return { ...pos, stopLoss: newStop, trailingStop: newStop };
+        }
+      } else {
+        if (this.config.breakevenTriggerPct > 0 && pnlPct >= this.config.breakevenTriggerPct) {
+          newStop = Math.max(newStop, pos.entryPrice);
+        }
         for (const step of this.config.profitLockSteps) {
           if (pnlPct >= step.trigger) {
             const lockedStop = pos.entryPrice * (1 + step.lock);
             newStop = Math.max(newStop, lockedStop);
           }
         }
-      }
-      if (this.config.trailingStopPct > 0) {
-        const trailStop = pos.currentPrice * (1 - this.config.trailingStopPct);
-        newStop = Math.max(newStop, trailStop);
-      }
-      if (newStop > pos.stopLoss) {
-        return { ...pos, stopLoss: newStop, trailingStop: newStop };
+        if (this.config.trailingStopPct > 0) {
+          const trailStop = pos.currentPrice * (1 - this.config.trailingStopPct);
+          newStop = Math.max(newStop, trailStop);
+        }
+        if (newStop > pos.stopLoss) {
+          return { ...pos, stopLoss: newStop, trailingStop: newStop };
+        }
       }
       return pos;
     });
@@ -5708,31 +5729,37 @@ var RiskManager = class {
       const price = currentPrices[pos.tokenId];
       if (price === void 0) continue;
       const updatedPos = { ...pos, currentPrice: price };
-      const pnlPercent = (price - pos.entryPrice) / pos.entryPrice;
+      const isShort = pos.side === "short";
+      const pnlPercent = isShort ? (pos.entryPrice - price) / (pos.entryPrice || 1) : (price - pos.entryPrice) / (pos.entryPrice || 1);
       if (pnlPercent <= -this.config.hardStopPercent) {
         toClose.push(updatedPos);
         reasons[pos.tokenId] = `Hard stop hit: ${(pnlPercent * 100).toFixed(1)}% loss (limit: -${(this.config.hardStopPercent * 100).toFixed(0)}%)`;
         continue;
       }
-      if (price <= pos.stopLoss) {
+      const stopHit = isShort ? price >= pos.stopLoss : price <= pos.stopLoss;
+      if (stopHit) {
         toClose.push(updatedPos);
         reasons[pos.tokenId] = `Stop loss hit at $${pos.stopLoss.toFixed(4)} (price: $${price.toFixed(4)})`;
         continue;
       }
-      if (pos.trailingStop !== void 0 && price <= pos.trailingStop) {
-        toClose.push(updatedPos);
-        reasons[pos.tokenId] = `Trailing stop hit at $${pos.trailingStop.toFixed(4)} (price: $${price.toFixed(4)})`;
-        continue;
+      if (pos.trailingStop !== void 0) {
+        const trailHit = isShort ? price >= pos.trailingStop : price <= pos.trailingStop;
+        if (trailHit) {
+          toClose.push(updatedPos);
+          reasons[pos.tokenId] = `Trailing stop hit at $${pos.trailingStop.toFixed(4)} (price: $${price.toFixed(4)})`;
+          continue;
+        }
       }
-      if (price >= pos.takeProfit) {
+      const tpHit = isShort ? price <= pos.takeProfit : price >= pos.takeProfit;
+      if (tpHit) {
         toClose.push(updatedPos);
         reasons[pos.tokenId] = `Take profit hit at $${pos.takeProfit.toFixed(4)} (price: $${price.toFixed(4)})`;
         continue;
       }
-      const holdingDays = (Date.now() - pos.entryTimestamp) / (1e3 * 60 * 60 * 24);
-      if (holdingDays > 7 && pnlPercent < 0.02 && pnlPercent > -0.02) {
+      const holdingHours = (Date.now() - pos.entryTimestamp) / (1e3 * 60 * 60);
+      if (holdingHours > 48 && pnlPercent < 0.01 && pnlPercent > -0.01) {
         toClose.push(updatedPos);
-        reasons[pos.tokenId] = `Time stop: held ${holdingDays.toFixed(0)} days with only ${(pnlPercent * 100).toFixed(1)}% PnL`;
+        reasons[pos.tokenId] = `Time stop: held ${(holdingHours / 24).toFixed(1)} days with only ${(pnlPercent * 100).toFixed(1)}% PnL`;
         continue;
       }
     }
@@ -5913,6 +5940,12 @@ var AgentLoop = class {
     this.running = true;
     const stateDir = join11(homedir11(), ".sherwood", "agent");
     await mkdir12(stateDir, { recursive: true });
+    if (this.config.execution.strategyClone && this.config.execution.chain) {
+      await this.portfolio.initFromOnChain(
+        this.config.execution.strategyClone,
+        this.config.execution.chain
+      );
+    }
     const cfg = this.config.agent;
     console.log("");
     console.log(chalk6.bold("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
@@ -6032,7 +6065,7 @@ var AgentLoop = class {
     const signals = [];
     for (const result of results) {
       const { action, score } = result.decision;
-      signals.push({ token: result.token, score, action });
+      signals.push({ token: result.token, score, action, regime: result.regime?.regime });
       if (action === "STRONG_BUY" || action === "BUY" || action === "SELL" || action === "STRONG_SELL") {
         try {
           const priceData = await this.coingecko.getPrice([result.token], ["usd"]);
@@ -6122,10 +6155,21 @@ function parseCycleInterval(cycle) {
 
 // src/agent/backtest.ts
 import chalk7 from "chalk";
-var CANDLE_BASED_STRATEGIES = [
+var BACKTEST_STRATEGIES = [
   "breakoutOnChain",
-  "meanReversion",
-  "multiTimeframe"
+  // 95% fire rate — candle-based
+  "multiTimeframe",
+  // 78% fire rate — candle-based
+  "sentimentContrarian",
+  // 100% fire rate — uses fearAndGreed from context
+  "momentum",
+  // computed from candles directly in the backtest loop
+  "fundingRate",
+  // fires when ctx.fundingRateData is set (won't fire in backtest — ok)
+  "dexFlow",
+  // fires when ctx.dexData is set (won't fire in backtest — ok)
+  "hyperliquidFlow"
+  // fires when ctx.hyperliquidData is set (won't fire — ok)
 ];
 var Backtester = class _Backtester {
   config;
@@ -6206,12 +6250,84 @@ var Backtester = class _Backtester {
     }
     return { candles: allCandles, fearAndGreedData };
   }
+  /**
+   * Pre-compute per-candle strategy signals and regime classification.
+   * Called once per token by the calibrator; result is fed back into
+   * `simulate(..., precomputed)` to skip the network-bound strategy stack.
+   *
+   * Filters signals to BACKTEST_STRATEGIES (the calibrator does not vary
+   * `config.strategies`). Regime is always computed and returned —
+   * `simulate()` will only consume it when `config.useRegime` is set.
+   */
+  async precomputeSignals(allCandles, fearAndGreedData) {
+    const stepSize = this.config.cycle === "1h" ? 1 : this.config.cycle === "4h" ? 4 : 24;
+    const step = Math.max(1, Math.floor(stepSize / 24));
+    const windowSize = 30;
+    const out = new Array(allCandles.length).fill(null);
+    for (let i = windowSize; i < allCandles.length; i += step) {
+      const windowCandles = allCandles.slice(Math.max(0, i - 200), i);
+      if (windowCandles.length < windowSize) continue;
+      const currentCandle = allCandles[i];
+      const currentDate = new Date(currentCandle.timestamp).toISOString().split("T")[0];
+      const currentPrice = currentCandle.close;
+      try {
+        const technicals = getLatestSignals(windowCandles);
+        let fearAndGreed;
+        const fgValue = fearAndGreedData[currentDate];
+        if (fgValue !== void 0) {
+          const classification = fgValue < 25 ? "Extreme Fear" : fgValue < 40 ? "Fear" : fgValue < 60 ? "Neutral" : fgValue < 75 ? "Greed" : "Extreme Greed";
+          fearAndGreed = { value: fgValue, classification };
+        }
+        const ctx = {
+          tokenId: this.config.tokenId,
+          candles: windowCandles,
+          technicals,
+          fearAndGreed
+        };
+        const rawSignals = await runStrategies(ctx);
+        if (windowCandles.length >= 24) {
+          const recent = windowCandles.slice(-24);
+          const recentLow = Math.min(...recent.map((c) => c.low));
+          const recentHigh = Math.max(...recent.map((c) => c.high));
+          const pctFromLow = recentLow > 0 ? (currentPrice - recentLow) / recentLow : 0;
+          const pctFromHigh = recentHigh > 0 ? (recentHigh - currentPrice) / recentHigh : 0;
+          let momentumValue = 0;
+          if (pctFromHigh < 0.01) momentumValue = Math.min(0.6, pctFromLow * 5);
+          else if (pctFromLow < 0.01) momentumValue = -Math.min(0.6, pctFromHigh * 5);
+          else if (recentHigh > recentLow) {
+            const rangePosition = (currentPrice - recentLow) / (recentHigh - recentLow);
+            momentumValue = (rangePosition - 0.5) * 0.4;
+          }
+          if (Math.abs(momentumValue) > 0.02) {
+            rawSignals.push({
+              name: "momentum",
+              value: momentumValue,
+              confidence: Math.min(0.7, 0.3 + Math.abs(momentumValue)),
+              source: "Price Momentum",
+              details: `Backtest momentum`
+            });
+          }
+        }
+        const filtered = rawSignals.filter((s) => BACKTEST_STRATEGIES.includes(s.name));
+        const regime = MarketRegimeDetector.classifyFromCandles(windowCandles).regime;
+        out[i] = { signals: filtered.length > 0 ? filtered : rawSignals, regime };
+      } catch {
+        out[i] = null;
+      }
+    }
+    return out;
+  }
   /**
    * Run the simulation loop on pre-fetched data. Pure of network IO.
    * The calibrator uses this directly after fetchData() to replay many
    * config permutations without re-fetching per permutation.
+   *
+   * When `precomputed` is supplied, the inner per-candle strategy stack
+   * (network-bound) is skipped and the cached signals/regime are used
+   * instead. Smoothing is also skipped on the precomputed path — the
+   * caller is responsible for applying it before precomputing if needed.
    */
-  async simulate(allCandles, fearAndGreedData) {
+  async simulate(allCandles, fearAndGreedData, precomputed) {
     const stepSize = this.config.cycle === "1h" ? 1 : this.config.cycle === "4h" ? 4 : 24;
     const step = Math.max(1, Math.floor(stepSize / 24));
     let capital = this.config.initialCapital;
@@ -6225,12 +6341,10 @@ var Backtester = class _Backtester {
       if (this.config.strategies.length > 0) {
         console.log(chalk7.dim(`  Using user-specified strategies: ${this.config.strategies.join(", ")}`));
       } else {
-        const availableStrategies = [...CANDLE_BASED_STRATEGIES];
+        console.log(chalk7.dim(`  Using backtest strategies: ${BACKTEST_STRATEGIES.join(", ")} + momentum`));
         if (Object.keys(fearAndGreedData).length > 0) {
-          availableStrategies.push("sentimentContrarian");
+          console.log(chalk7.dim(`  Fear & Greed data available \u2014 sentimentContrarian active`));
         }
-        console.log(chalk7.dim(`  Using candle-based strategies: ${availableStrategies.join(", ")}`));
-        console.log(chalk7.dim(`  Filtered out external data strategies to prevent zero-signal noise`));
       }
       console.log();
     }
@@ -6240,41 +6354,74 @@ var Backtester = class _Backtester {
       const currentDate = new Date(currentCandle.timestamp).toISOString().split("T")[0];
       const currentPrice = currentCandle.close;
       if (windowCandles.length < windowSize) continue;
-      const equity = position ? capital * (currentPrice / position.entryPrice) : capital;
+      const equity = position ? capital * (1 + (position.side === "short" ? (position.entryPrice - currentPrice) / position.entryPrice : (currentPrice - position.entryPrice) / position.entryPrice)) : capital;
       equityCurve.push({ date: currentDate, value: equity });
       let decision;
       try {
-        const technicals = getLatestSignals(windowCandles);
-        let fearAndGreed;
-        const fgValue = fearAndGreedData[currentDate];
-        if (fgValue !== void 0) {
-          const classification = fgValue < 25 ? "Extreme Fear" : fgValue < 40 ? "Fear" : fgValue < 60 ? "Neutral" : fgValue < 75 ? "Greed" : "Extreme Greed";
-          fearAndGreed = { value: fgValue, classification };
-        }
-        const ctx = {
-          tokenId: this.config.tokenId,
-          candles: windowCandles,
-          technicals,
-          fearAndGreed
-        };
-        let signals = await runStrategies(ctx);
-        if (smoother) {
-          signals = await smoother.smooth(this.config.tokenId, signals, currentCandle.timestamp);
-        }
-        let filtered = signals;
-        if (this.config.strategies.length > 0) {
-          filtered = signals.filter((s) => this.config.strategies.some(
-            (name) => s.name.toLowerCase().includes(name.toLowerCase())
-          ));
-        } else {
-          filtered = signals.filter((s) => CANDLE_BASED_STRATEGIES.includes(s.name) || fearAndGreed && s.name === "sentimentContrarian");
-        }
+        let filtered;
         let regime;
-        if (this.config.useRegime) {
-          regime = MarketRegimeDetector.classifyFromCandles(windowCandles).regime;
+        if (precomputed) {
+          const entry = precomputed[i];
+          if (!entry) continue;
+          filtered = entry.signals;
+          regime = this.config.useRegime ? entry.regime : void 0;
+        } else {
+          const technicals = getLatestSignals(windowCandles);
+          let fearAndGreed;
+          const fgValue = fearAndGreedData[currentDate];
+          if (fgValue !== void 0) {
+            const classification = fgValue < 25 ? "Extreme Fear" : fgValue < 40 ? "Fear" : fgValue < 60 ? "Neutral" : fgValue < 75 ? "Greed" : "Extreme Greed";
+            fearAndGreed = { value: fgValue, classification };
+          }
+          const ctx = {
+            tokenId: this.config.tokenId,
+            candles: windowCandles,
+            technicals,
+            fearAndGreed
+          };
+          let signals = await runStrategies(ctx);
+          if (windowCandles.length >= 24) {
+            const recent = windowCandles.slice(-24);
+            const recentLow = Math.min(...recent.map((c) => c.low));
+            const recentHigh = Math.max(...recent.map((c) => c.high));
+            const pctFromLow = recentLow > 0 ? (currentPrice - recentLow) / recentLow : 0;
+            const pctFromHigh = recentHigh > 0 ? (recentHigh - currentPrice) / recentHigh : 0;
+            let momentumValue = 0;
+            if (pctFromHigh < 0.01) {
+              momentumValue = Math.min(0.6, pctFromLow * 5);
+            } else if (pctFromLow < 0.01) {
+              momentumValue = -Math.min(0.6, pctFromHigh * 5);
+            } else if (recentHigh > recentLow) {
+              const rangePosition = (currentPrice - recentLow) / (recentHigh - recentLow);
+              momentumValue = (rangePosition - 0.5) * 0.4;
+            }
+            if (Math.abs(momentumValue) > 0.02) {
+              signals.push({
+                name: "momentum",
+                value: momentumValue,
+                confidence: Math.min(0.7, 0.3 + Math.abs(momentumValue)),
+                source: "Price Momentum",
+                details: `Backtest momentum`
+              });
+            }
+          }
+          if (smoother) {
+            signals = await smoother.smooth(this.config.tokenId, signals, currentCandle.timestamp);
+          }
+          if (this.config.strategies.length > 0) {
+            filtered = signals.filter((s) => this.config.strategies.some(
+              (name) => s.name.toLowerCase().includes(name.toLowerCase())
+            ));
+          } else {
+            filtered = signals.filter((s) => BACKTEST_STRATEGIES.includes(s.name));
+          }
+          if (filtered.length === 0) filtered = signals;
+          if (this.config.useRegime) {
+            regime = MarketRegimeDetector.classifyFromCandles(windowCandles).regime;
+          }
         }
         decision = computeTradeDecision(
-          filtered.length > 0 ? filtered : signals,
+          filtered,
           this.config.customWeights,
           void 0,
           void 0,
@@ -6309,31 +6456,60 @@ var Backtester = class _Backtester {
       } catch {
         continue;
       }
+      const STOP_LOSS_PCT2 = 0.03;
+      const TAKE_PROFIT_PCT2 = 0.06;
+      const TIME_STOP_HOURS2 = 48;
+      const TRAIL_PCT2 = this.config.trailingStopPct ?? 0.025;
       if (!position && (decision.action === "BUY" || decision.action === "STRONG_BUY")) {
         position = {
+          side: "long",
+          entryPrice: currentPrice,
+          entryDate: currentDate,
+          signal: decision.action,
+          extremePrice: currentPrice,
+          entryTimestamp: currentCandle.timestamp
+        };
+      } else if (!position && (decision.action === "SELL" || decision.action === "STRONG_SELL")) {
+        position = {
+          side: "short",
           entryPrice: currentPrice,
           entryDate: currentDate,
           signal: decision.action,
-          highWaterMark: currentPrice
+          extremePrice: currentPrice,
+          // for shorts this becomes a low-water mark
+          entryTimestamp: currentCandle.timestamp
         };
       } else if (position) {
-        if (currentPrice > position.highWaterMark) {
-          position.highWaterMark = currentPrice;
+        const isShort = position.side === "short";
+        if (isShort) {
+          if (currentPrice < position.extremePrice) position.extremePrice = currentPrice;
+        } else {
+          if (currentPrice > position.extremePrice) position.extremePrice = currentPrice;
         }
-        const trailingStopHit = this.config.trailingStopPct !== void 0 && currentPrice <= position.highWaterMark * (1 - this.config.trailingStopPct);
-        const sellSignal = decision.action === "SELL" || decision.action === "STRONG_SELL";
-        if (trailingStopHit || sellSignal) {
-          const pnlPercent = (currentPrice - position.entryPrice) / position.entryPrice;
+        const pnlPercent = isShort ? (position.entryPrice - currentPrice) / position.entryPrice : (currentPrice - position.entryPrice) / position.entryPrice;
+        const holdingHours = (currentCandle.timestamp - position.entryTimestamp) / (1e3 * 60 * 60);
+        let exitReason = null;
+        if (pnlPercent <= -STOP_LOSS_PCT2) {
+          exitReason = `STOP_LOSS (${(pnlPercent * 100).toFixed(1)}%)`;
+        } else if (pnlPercent >= TAKE_PROFIT_PCT2) {
+          exitReason = `TAKE_PROFIT (+${(pnlPercent * 100).toFixed(1)}%)`;
+        } else if (TRAIL_PCT2 > 0 && (isShort ? currentPrice >= position.extremePrice * (1 + TRAIL_PCT2) : currentPrice <= position.extremePrice * (1 - TRAIL_PCT2))) {
+          exitReason = `TRAILING_STOP (extreme $${position.extremePrice.toFixed(2)}, ${isShort ? "+" : "-"}${(TRAIL_PCT2 * 100).toFixed(1)}%)`;
+        } else if (holdingHours > TIME_STOP_HOURS2 && Math.abs(pnlPercent) < 0.01) {
+          exitReason = `TIME_STOP (${(holdingHours / 24).toFixed(1)}d, ${(pnlPercent * 100).toFixed(1)}%)`;
+        } else if (isShort ? decision.action === "BUY" || decision.action === "STRONG_BUY" : decision.action === "SELL" || decision.action === "STRONG_SELL") {
+          exitReason = decision.action;
+        }
+        if (exitReason) {
           capital *= 1 + pnlPercent;
           returns.push(pnlPercent);
-          const exitReason = trailingStopHit ? `TRAILING_STOP (-${(this.config.trailingStopPct * 100).toFixed(1)}%)` : decision.action;
           trades.push({
             entryDate: position.entryDate,
             exitDate: currentDate,
             entryPrice: position.entryPrice,
             exitPrice: currentPrice,
             pnlPercent,
-            signal: `${position.signal} \u2192 ${exitReason}`
+            signal: `${position.signal}${isShort ? " [SHORT]" : ""} \u2192 ${exitReason}`
           });
           position = null;
         }
@@ -6343,7 +6519,7 @@ var Backtester = class _Backtester {
       const lastCandle = allCandles[allCandles.length - 1];
       const lastPrice = lastCandle.close;
       const lastDate = new Date(lastCandle.timestamp).toISOString().split("T")[0];
-      const pnlPercent = (lastPrice - position.entryPrice) / position.entryPrice;
+      const pnlPercent = position.side === "short" ? (position.entryPrice - lastPrice) / position.entryPrice : (lastPrice - position.entryPrice) / position.entryPrice;
       capital *= 1 + pnlPercent;
       returns.push(pnlPercent);
       trades.push({
@@ -6352,7 +6528,7 @@ var Backtester = class _Backtester {
         entryPrice: position.entryPrice,
         exitPrice: lastPrice,
         pnlPercent,
-        signal: `${position.signal} \u2192 CLOSE`
+        signal: `${position.signal}${position.side === "short" ? " [SHORT]" : ""} \u2192 CLOSE`
       });
     }
     const totalReturn = capital - this.config.initialCapital;
@@ -6692,6 +6868,508 @@ var Backtester = class _Backtester {
   }
 };
 
+// src/agent/calibrator.ts
+import { mkdir as mkdir13, writeFile as writeFile11 } from "fs/promises";
+import { join as join12 } from "path";
+import { homedir as homedir12 } from "os";
+var WEIGHT_PROFILES2 = {
+  // ── Live production profiles (from scoring.ts; keep in sync) ──
+  "default-live": { smartMoney: 0.15, technical: 0.1, sentiment: 0.4, onchain: 0.2, fundamental: 0.1, event: 0.05 },
+  "majors-live": { smartMoney: 0.15, technical: 0.1, sentiment: 0.4, onchain: 0.35, fundamental: 0, event: 0 },
+  "altcoin-live": { smartMoney: 0.15, technical: 0.15, sentiment: 0.3, onchain: 0.2, fundamental: 0.1, event: 0.1 },
+  // ── Exploratory profiles (historical baselines + variants) ──
+  default: { smartMoney: 0.25, technical: 0.2, sentiment: 0.2, onchain: 0.15, fundamental: 0.1, event: 0.1 },
+  techHeavy: { smartMoney: 0.1, technical: 0.4, sentiment: 0.15, onchain: 0.15, fundamental: 0.1, event: 0.1 },
+  sentHeavy: { smartMoney: 0.1, technical: 0.15, sentiment: 0.4, onchain: 0.15, fundamental: 0.1, event: 0.1 },
+  onchainHvy: { smartMoney: 0.1, technical: 0.2, sentiment: 0.15, onchain: 0.35, fundamental: 0.1, event: 0.1 },
+  balanced: { smartMoney: 0.17, technical: 0.17, sentiment: 0.17, onchain: 0.17, fundamental: 0.16, event: 0.16 },
+  momentum: { smartMoney: 0.15, technical: 0.35, sentiment: 0.1, onchain: 0.25, fundamental: 0.1, event: 0.05 },
+  contrarian: { smartMoney: 0.1, technical: 0.1, sentiment: 0.4, onchain: 0.1, fundamental: 0.15, event: 0.15 },
+  flowBased: { smartMoney: 0.2, technical: 0.15, sentiment: 0.1, onchain: 0.35, fundamental: 0.1, event: 0.1 }
+};
+var BUY_THRESHOLDS = [0.2, 0.25, 0.3, 0.4, 0.5];
+var SELL_THRESHOLDS = [-0.2, -0.25, -0.3, -0.4, -0.5];
+var DEFAULT_CALIBRATION_TOKENS = [
+  "bitcoin",
+  "ethereum",
+  "solana",
+  "aave",
+  "uniswap",
+  "chainlink",
+  "arbitrum"
+];
+function buildCalibrationConfigs() {
+  const configs = [];
+  for (const [profileName, weights] of Object.entries(WEIGHT_PROFILES2)) {
+    for (const buyThreshold of BUY_THRESHOLDS) {
+      for (const sellThreshold of SELL_THRESHOLDS) {
+        configs.push({ profileName, weights, buyThreshold, sellThreshold });
+      }
+    }
+  }
+  return configs;
+}
+async function runCalibration(opts) {
+  const { tokens, days, capital, onProgress } = opts;
+  const configs = buildCalibrationConfigs();
+  const log = onProgress ?? (() => {
+  });
+  const endDate = /* @__PURE__ */ new Date();
+  endDate.setDate(endDate.getDate() - 1);
+  const startDate = new Date(endDate);
+  startDate.setDate(startDate.getDate() - days);
+  const startStr = startDate.toISOString().slice(0, 10);
+  const endStr = endDate.toISOString().slice(0, 10);
+  const resultMap = /* @__PURE__ */ new Map();
+  for (const cfg of configs) {
+    const key = configKey(cfg);
+    resultMap.set(key, {
+      config: cfg,
+      tokenResults: [],
+      avgReturn: 0,
+      avgSharpe: 0,
+      worstDrawdown: 0,
+      totalTrades: 0
+    });
+  }
+  for (let ti = 0; ti < tokens.length; ti++) {
+    const tokenId = tokens[ti];
+    log(`[${ti + 1}/${tokens.length}] Fetching data for ${tokenId}...`);
+    const baseBt = new Backtester({
+      tokenId,
+      startDate: startStr,
+      endDate: endStr,
+      initialCapital: capital,
+      strategies: [],
+      cycle: "1d",
+      verbose: false
+    });
+    let candles;
+    let fearAndGreedData;
+    try {
+      const data = await baseBt.fetchData();
+      candles = data.candles;
+      fearAndGreedData = data.fearAndGreedData;
+      log(`  Got ${candles.length} candles + ${Object.keys(fearAndGreedData).length} F&G points`);
+    } catch (err) {
+      log(`  SKIP ${tokenId}: ${err.message}`);
+      for (const cfg of configs) {
+        const key = configKey(cfg);
+        resultMap.get(key).tokenResults.push({
+          tokenId,
+          totalReturn: 0,
+          sharpeRatio: 0,
+          maxDrawdown: 0,
+          winRate: 0,
+          numTrades: 0
+        });
+      }
+      continue;
+    }
+    log(`  Precomputing signals for ${candles.length} candles...`);
+    let precomputed;
+    try {
+      precomputed = await baseBt.precomputeSignals(candles, fearAndGreedData);
+      const valid = precomputed.filter((p) => p !== null).length;
+      log(`  Precomputed ${valid} candle signal sets`);
+    } catch (err) {
+      log(`  SKIP ${tokenId}: precompute failed: ${err.message}`);
+      for (const cfg of configs) {
+        const key = configKey(cfg);
+        resultMap.get(key).tokenResults.push({
+          tokenId,
+          totalReturn: 0,
+          sharpeRatio: 0,
+          maxDrawdown: 0,
+          winRate: 0,
+          numTrades: 0
+        });
+      }
+      continue;
+    }
+    log(`  Running ${configs.length} configs on ${tokenId}...`);
+    for (let ci = 0; ci < configs.length; ci++) {
+      const cfg = configs[ci];
+      const key = configKey(cfg);
+      try {
+        const bt = new Backtester({
+          tokenId,
+          startDate: startStr,
+          endDate: endStr,
+          initialCapital: capital,
+          strategies: [],
+          cycle: "1d",
+          verbose: false,
+          customWeights: cfg.weights,
+          buyThreshold: cfg.buyThreshold,
+          sellThreshold: cfg.sellThreshold
+        });
+        const result = await bt.simulate(candles, fearAndGreedData, precomputed);
+        resultMap.get(key).tokenResults.push({
+          tokenId,
+          totalReturn: result.totalReturnPercent,
+          sharpeRatio: result.sharpeRatio,
+          maxDrawdown: result.maxDrawdown,
+          winRate: result.winRate,
+          numTrades: result.totalTrades
+        });
+      } catch {
+        resultMap.get(key).tokenResults.push({
+          tokenId,
+          totalReturn: 0,
+          sharpeRatio: 0,
+          maxDrawdown: 0,
+          winRate: 0,
+          numTrades: 0
+        });
+      }
+      if ((ci + 1) % 50 === 0) {
+        log(`  ${tokenId}: ${ci + 1}/${configs.length} configs done`);
+      }
+    }
+    log(`  ${tokenId} complete`);
+    if (ti < tokens.length - 1) {
+      log(`  Pausing 5s for CoinGecko rate limits...`);
+      await sleep(5e3);
+    }
+  }
+  const results = [];
+  for (const entry of resultMap.values()) {
+    const tr = entry.tokenResults;
+    if (tr.length === 0) continue;
+    entry.avgReturn = tr.reduce((s, r) => s + r.totalReturn, 0) / tr.length;
+    entry.avgSharpe = tr.reduce((s, r) => s + r.sharpeRatio, 0) / tr.length;
+    entry.worstDrawdown = Math.max(...tr.map((r) => r.maxDrawdown));
+    entry.totalTrades = tr.reduce((s, r) => s + r.numTrades, 0);
+    results.push(entry);
+  }
+  results.sort((a, b) => {
+    const aZero = a.totalTrades === 0;
+    const bZero = b.totalTrades === 0;
+    if (aZero !== bZero) return aZero ? 1 : -1;
+    if (Math.abs(b.avgSharpe - a.avgSharpe) > 1e-3) return b.avgSharpe - a.avgSharpe;
+    return b.avgReturn - a.avgReturn;
+  });
+  await saveResults(results);
+  return results;
+}
+function configKey(cfg) {
+  return `${cfg.profileName}|buy=${cfg.buyThreshold}|sell=${cfg.sellThreshold}`;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function saveResults(results) {
+  const dir = join12(homedir12(), ".sherwood", "agent");
+  await mkdir13(dir, { recursive: true });
+  const path = join12(dir, "calibration-results.json");
+  const payload = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    totalConfigs: results.length,
+    results: results.map((r, i) => ({
+      rank: i + 1,
+      profile: r.config.profileName,
+      buyThreshold: r.config.buyThreshold,
+      sellThreshold: r.config.sellThreshold,
+      weights: r.config.weights,
+      avgReturn: r.avgReturn,
+      avgSharpe: r.avgSharpe,
+      worstDrawdown: r.worstDrawdown,
+      totalTrades: r.totalTrades,
+      tokenResults: r.tokenResults
+    }))
+  };
+  await writeFile11(path, JSON.stringify(payload, null, 2), "utf-8");
+}
+function formatCalibrationTable(results, topN = 20) {
+  const lines = [];
+  lines.push("");
+  lines.push("  Calibration Results (ranked by Sharpe ratio)");
+  lines.push("  " + "=".repeat(110));
+  lines.push(
+    "  " + "Rank".padEnd(6) + "Profile".padEnd(13) + "Buy".padEnd(7) + "Sell".padEnd(7) + "Avg Return".padEnd(13) + "Avg Sharpe".padEnd(13) + "Worst DD".padEnd(11) + "Trades".padEnd(9) + "Tokens"
+  );
+  lines.push("  " + "-".repeat(110));
+  const top = results.slice(0, topN);
+  for (let i = 0; i < top.length; i++) {
+    const r = top[i];
+    const rank = String(i + 1).padEnd(6);
+    const profile = r.config.profileName.padEnd(13);
+    const buy = String(r.config.buyThreshold).padEnd(7);
+    const sell = String(r.config.sellThreshold).padEnd(7);
+    const avgRet = (r.avgReturn.toFixed(2) + "%").padEnd(13);
+    const avgSharpe = r.avgSharpe.toFixed(3).padEnd(13);
+    const worstDD = (r.worstDrawdown.toFixed(2) + "%").padEnd(11);
+    const trades = String(r.totalTrades).padEnd(9);
+    const tokenCount = String(r.tokenResults.length);
+    lines.push("  " + rank + profile + buy + sell + avgRet + avgSharpe + worstDD + trades + tokenCount);
+  }
+  lines.push("  " + "-".repeat(110));
+  if (results.length > 0) {
+    const best = results[0];
+    lines.push("");
+    lines.push("  BEST CONFIGURATION:");
+    lines.push(`    Profile:        ${best.config.profileName}`);
+    lines.push(`    Buy threshold:  ${best.config.buyThreshold}`);
+    lines.push(`    Sell threshold: ${best.config.sellThreshold}`);
+    lines.push(`    Weights:        smartMoney=${best.config.weights.smartMoney} technical=${best.config.weights.technical} sentiment=${best.config.weights.sentiment} onchain=${best.config.weights.onchain} fundamental=${best.config.weights.fundamental} event=${best.config.weights.event}`);
+    lines.push(`    Avg return:     ${best.avgReturn.toFixed(2)}%`);
+    lines.push(`    Avg Sharpe:     ${best.avgSharpe.toFixed(3)}`);
+    lines.push(`    Worst drawdown: ${best.worstDrawdown.toFixed(2)}%`);
+    lines.push("");
+    lines.push("  Per-token breakdown (best config):");
+    for (const tr of best.tokenResults) {
+      lines.push(`    ${tr.tokenId.padEnd(12)} return: ${tr.totalReturn.toFixed(2).padStart(8)}%  sharpe: ${tr.sharpeRatio.toFixed(3).padStart(7)}  trades: ${tr.numTrades}`);
+    }
+  }
+  lines.push("");
+  const savePath = join12(homedir12(), ".sherwood", "agent", "calibration-results.json");
+  lines.push(`  Full results saved to ${savePath}`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/agent/replay-calibrator.ts
+import { readFile as readFile11, mkdir as mkdir14, writeFile as writeFile12 } from "fs/promises";
+import { join as join13 } from "path";
+import { homedir as homedir13 } from "os";
+var STOP_LOSS_PCT = 0.03;
+var TAKE_PROFIT_PCT = 0.06;
+var TRAIL_PCT = 0.025;
+var TIME_STOP_HOURS = 48;
+async function loadSignalHistory(path) {
+  const raw = await readFile11(path, "utf-8");
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      rows.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return rows;
+}
+function groupByToken(rows) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (!grouped.has(r.tokenId)) grouped.set(r.tokenId, []);
+    grouped.get(r.tokenId).push(r);
+  }
+  for (const list of grouped.values()) {
+    list.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  }
+  return grouped;
+}
+function replayToken(tokenRows, config, useRegime) {
+  let position = null;
+  const returns = [];
+  const trades = [];
+  const equityCurve = [1];
+  let equity = 1;
+  for (let i = 0; i < tokenRows.length; i++) {
+    const row = tokenRows[i];
+    const ts = Date.parse(row.timestamp);
+    const price = row.price;
+    if (!Number.isFinite(price) || price <= 0) continue;
+    const signals = row.signals.map((s) => ({
+      name: s.name,
+      value: s.value,
+      confidence: s.confidence,
+      source: "",
+      details: ""
+    }));
+    const regime = useRegime ? row.regime && row.regime !== "unknown" ? row.regime : void 0 : void 0;
+    let decision = computeTradeDecision(
+      signals,
+      config.weights,
+      void 0,
+      void 0,
+      regime
+    );
+    const buy = config.buyThreshold;
+    const sell = config.sellThreshold;
+    if (buy <= sell) continue;
+    const strongBuy = buy + 0.3;
+    const strongSell = sell - 0.3;
+    let action;
+    if (decision.score >= strongBuy) action = "STRONG_BUY";
+    else if (decision.score >= buy) action = "BUY";
+    else if (decision.score <= strongSell) action = "STRONG_SELL";
+    else if (decision.score <= sell) action = "SELL";
+    else action = "HOLD";
+    decision = { ...decision, action };
+    if (position) {
+      const isShort = position.side === "short";
+      if (isShort) {
+        if (price < position.extremePrice) position.extremePrice = price;
+      } else {
+        if (price > position.extremePrice) position.extremePrice = price;
+      }
+      const pnlPercent = isShort ? (position.entryPrice - price) / position.entryPrice : (price - position.entryPrice) / position.entryPrice;
+      const holdingHours = (ts - position.entryTimestamp) / (1e3 * 60 * 60);
+      let exitReason = null;
+      if (pnlPercent <= -STOP_LOSS_PCT) exitReason = "STOP";
+      else if (pnlPercent >= TAKE_PROFIT_PCT) exitReason = "TP";
+      else if (TRAIL_PCT > 0 && (isShort ? price >= position.extremePrice * (1 + TRAIL_PCT) : price <= position.extremePrice * (1 - TRAIL_PCT))) {
+        exitReason = "TRAIL";
+      } else if (holdingHours > TIME_STOP_HOURS && Math.abs(pnlPercent) < 0.01) {
+        exitReason = "TIME";
+      } else if (isShort ? action === "BUY" || action === "STRONG_BUY" : action === "SELL" || action === "STRONG_SELL") {
+        exitReason = "FLIP";
+      }
+      if (exitReason) {
+        equity *= 1 + pnlPercent;
+        equityCurve.push(equity);
+        returns.push(pnlPercent);
+        trades.push({ pnlPercent, durationMs: ts - position.entryTimestamp });
+        position = null;
+      }
+    }
+    if (!position) {
+      if (action === "BUY" || action === "STRONG_BUY") {
+        position = { side: "long", entryPrice: price, entryTimestamp: ts, extremePrice: price, signal: action };
+      } else if (action === "SELL" || action === "STRONG_SELL") {
+        position = { side: "short", entryPrice: price, entryTimestamp: ts, extremePrice: price, signal: action };
+      }
+    }
+  }
+  if (position) {
+    let lastValidPrice = null;
+    for (let i = tokenRows.length - 1; i >= 0; i--) {
+      const p = tokenRows[i].price;
+      if (Number.isFinite(p) && p > 0) {
+        lastValidPrice = p;
+        break;
+      }
+    }
+    if (lastValidPrice !== null) {
+      const pnlPercent = position.side === "short" ? (position.entryPrice - lastValidPrice) / position.entryPrice : (lastValidPrice - position.entryPrice) / position.entryPrice;
+      const lastTs = Date.parse(tokenRows[tokenRows.length - 1].timestamp);
+      equity *= 1 + pnlPercent;
+      equityCurve.push(equity);
+      returns.push(pnlPercent);
+      trades.push({ pnlPercent, durationMs: lastTs - position.entryTimestamp });
+    }
+  }
+  const totalReturn = equity - 1;
+  const winRate = returns.length > 0 ? returns.filter((r) => r > 0).length / returns.length : 0;
+  let sharpeRatio = 0;
+  if (returns.length > 1) {
+    const mean = returns.reduce((a, b) => a + b, 0) / returns.length;
+    const variance = returns.reduce((s, r) => s + (r - mean) ** 2, 0) / (returns.length - 1);
+    const stdDev = Math.sqrt(variance);
+    if (stdDev > 0) {
+      const avgHoldDays = trades.length > 0 ? trades.reduce((s, t) => s + t.durationMs, 0) / trades.length / (1e3 * 60 * 60 * 24) : 1;
+      const tradesPerYear = Math.max(252 / Math.max(avgHoldDays, 1), 1);
+      sharpeRatio = mean / stdDev * Math.sqrt(tradesPerYear);
+    }
+  }
+  let peak = equityCurve[0];
+  let maxDrawdown = 0;
+  for (const v of equityCurve) {
+    if (v > peak) peak = v;
+    const dd = (peak - v) / peak;
+    if (dd > maxDrawdown) maxDrawdown = dd;
+  }
+  return {
+    tokenId: tokenRows[0]?.tokenId ?? "",
+    totalReturn,
+    sharpeRatio,
+    maxDrawdown,
+    winRate,
+    numTrades: returns.length
+  };
+}
+async function runHistoryReplay(options = {}) {
+  const historyPath = options.historyPath ?? join13(homedir13(), ".sherwood", "agent", "signal-history.jsonl");
+  const log = options.onProgress ?? (() => {
+  });
+  const useRegime = options.useRegime ?? true;
+  log(`Loading ${historyPath}...`);
+  let allRows = await loadSignalHistory(historyPath);
+  log(`Loaded ${allRows.length} rows`);
+  if (options.lastDays !== void 0 && options.lastDays > 0) {
+    const cutoff = Date.now() - options.lastDays * 24 * 60 * 60 * 1e3;
+    const before = allRows.length;
+    allRows = allRows.filter((r) => Date.parse(r.timestamp) >= cutoff);
+    log(`Filtered to last ${options.lastDays}d: ${allRows.length} rows (dropped ${before - allRows.length})`);
+  }
+  const grouped = groupByToken(allRows);
+  let tokens = options.tokens ?? Array.from(grouped.keys());
+  const MIN_ROWS = 5;
+  tokens = tokens.filter((t) => (grouped.get(t)?.length ?? 0) >= MIN_ROWS);
+  log(`Replaying ${tokens.length} tokens (>=${MIN_ROWS} observations each)`);
+  const configs = [];
+  for (const [profileName, weights] of Object.entries(WEIGHT_PROFILES2)) {
+    for (const buyThreshold of BUY_THRESHOLDS) {
+      for (const sellThreshold of SELL_THRESHOLDS) {
+        if (buyThreshold <= sellThreshold) continue;
+        configs.push({ profileName, weights, buyThreshold, sellThreshold });
+      }
+    }
+  }
+  log(`Sweeping ${configs.length} configs across ${tokens.length} tokens`);
+  const results = configs.map((config) => ({
+    config,
+    tokenResults: [],
+    avgReturn: 0,
+    avgSharpe: 0,
+    worstDrawdown: 0,
+    totalTrades: 0
+  }));
+  let processed = 0;
+  for (const token of tokens) {
+    const rows = grouped.get(token);
+    for (let ci = 0; ci < configs.length; ci++) {
+      const cfg = configs[ci];
+      const tokenResult = replayToken(rows, cfg, useRegime);
+      results[ci].tokenResults.push(tokenResult);
+    }
+    processed++;
+    log(`  ${token}: ${rows.length} rows, ${configs.length} configs done (${processed}/${tokens.length})`);
+  }
+  for (const r of results) {
+    const tr = r.tokenResults;
+    if (tr.length === 0) continue;
+    r.avgReturn = tr.reduce((s, x) => s + x.totalReturn, 0) / tr.length;
+    r.avgSharpe = tr.reduce((s, x) => s + x.sharpeRatio, 0) / tr.length;
+    r.worstDrawdown = Math.max(...tr.map((x) => x.maxDrawdown));
+    r.totalTrades = tr.reduce((s, x) => s + x.numTrades, 0);
+  }
+  results.sort((a, b) => {
+    const aZero = a.totalTrades === 0;
+    const bZero = b.totalTrades === 0;
+    if (aZero !== bZero) return aZero ? 1 : -1;
+    if (Math.abs(b.avgSharpe - a.avgSharpe) > 1e-3) return b.avgSharpe - a.avgSharpe;
+    return b.avgReturn - a.avgReturn;
+  });
+  await saveResults2(results);
+  return results;
+}
+async function saveResults2(results) {
+  const dir = join13(homedir13(), ".sherwood", "agent");
+  await mkdir14(dir, { recursive: true });
+  const path = join13(dir, "replay-calibration-results.json");
+  const payload = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    totalConfigs: results.length,
+    source: "signal-history.jsonl replay",
+    results: results.map((r, i) => ({
+      rank: i + 1,
+      profile: r.config.profileName,
+      buyThreshold: r.config.buyThreshold,
+      sellThreshold: r.config.sellThreshold,
+      weights: r.config.weights,
+      avgReturn: r.avgReturn,
+      avgSharpe: r.avgSharpe,
+      worstDrawdown: r.worstDrawdown,
+      totalTrades: r.totalTrades,
+      tokenResults: r.tokenResults
+    }))
+  };
+  await writeFile12(path, JSON.stringify(payload, null, 2), "utf-8");
+}
+
 // src/agent/alert-formatter.ts
 var AlertFormatter = class {
   /**
@@ -6981,7 +7659,7 @@ _Generated: ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}_`);
 };
 
 // src/agent/signal-audit.ts
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 var FIRE_EPSILON = 0.05;
 var SIGNAL_TO_CATEGORY = {
   // Direct categories
@@ -7006,7 +7684,7 @@ var SIGNAL_TO_CATEGORY = {
 async function auditSignalHistory(filePath = getSignalFilePath()) {
   let raw;
   try {
-    raw = await readFile11(filePath, "utf-8");
+    raw = await readFile12(filePath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return {
@@ -7196,7 +7874,28 @@ function suggestRenormalizedWeights(currentWeights, perCategory, dropThreshold =
 }
 
 // src/commands/agent.ts
-var DEFAULT_TOKENS = ["ethereum", "bitcoin", "solana", "aave", "uniswap"];
+var DEFAULT_TOKENS = [
+  "bitcoin",
+  "ethereum",
+  "solana",
+  // majors
+  "ripple",
+  "dogecoin",
+  "avalanche-2",
+  "polkadot",
+  "near",
+  // L1s
+  "arbitrum",
+  // L2
+  "aave",
+  "uniswap",
+  "chainlink",
+  // DeFi
+  "hyperliquid",
+  "bittensor",
+  "fartcoin"
+  // HL natives / themes
+];
 function makeConfig(overrides) {
   return {
     tokens: DEFAULT_TOKENS,
@@ -7206,6 +7905,10 @@ function makeConfig(overrides) {
     maxRiskPct: 20,
     useX402: true,
     // Paid signals (Nansen + Messari) on by default — opt out with --no-x402
+    x402TopN: 3,
+    // Only run x402 on top 3 tokens by free-signal score — saves ~$1.12/run
+    smoothFastSignals: true,
+    // Rolling-window smoothing for noisy signals — prevents single-scan flicker
     ...overrides
   };
 }
@@ -7381,8 +8084,8 @@ function registerAgentCommands(program) {
     const cycle = options.cycle ?? "4h";
     let savedRiskConfig = {};
     try {
-      const configPath = join12(homedir12(), ".sherwood", "agent", "config.json");
-      const data = await readFile12(configPath, "utf-8");
+      const configPath = join14(homedir14(), ".sherwood", "agent", "config.json");
+      const data = await readFile13(configPath, "utf-8");
       const parsed = JSON.parse(data);
       for (const [k, v] of Object.entries(parsed)) {
         if (k in DEFAULT_RISK_CONFIG && typeof v === "number" && Number.isFinite(v)) {
@@ -7533,17 +8236,17 @@ function registerAgentCommands(program) {
           }
           riskConfig[key] = numVal;
           console.log(chalk8.green(`  Set ${key} = ${numVal}`));
-          const configDir = join12(homedir12(), ".sherwood", "agent");
-          const configPath = join12(configDir, "config.json");
+          const configDir = join14(homedir14(), ".sherwood", "agent");
+          const configPath = join14(configDir, "config.json");
           let existingConfig = {};
           try {
-            const data = await readFile12(configPath, "utf-8");
+            const data = await readFile13(configPath, "utf-8");
             existingConfig = JSON.parse(data);
           } catch {
           }
           existingConfig[key] = numVal;
-          await mkdir13(configDir, { recursive: true });
-          await writeFile11(configPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+          await mkdir15(configDir, { recursive: true });
+          await writeFile13(configPath, JSON.stringify(existingConfig, null, 2), "utf-8");
           console.log(chalk8.dim(`  Saved to ${configPath}`));
         } else {
           console.log(chalk8.red(`  Invalid value: ${value}`));
@@ -7646,12 +8349,80 @@ function registerAgentCommands(program) {
       }
     }
   });
+  agent.command("calibrate").description("Sweep weight profiles \xD7 BUY/SELL thresholds against historical data; ranks by Sharpe").option("--tokens <list>", "Comma-separated CoinGecko IDs (default: bitcoin,ethereum,solana,aave,uniswap,chainlink,arbitrum)").option("--days <n>", "Lookback window in days", "60").option("--capital <amount>", "Initial capital per token in USD", "10000").option("--top <n>", "Show top N configs in the ranked table", "20").option("--from-history [path]", "Replay against signal-history.jsonl (true production signal stack including HL/funding/dexFlow). Path defaults to ~/.sherwood/agent/signal-history.jsonl").option("--last <days>", "Replay only rows captured within the last N days (use after a scoring change to ignore stale captures). Replay path only.").option("--no-regime", "When using --from-history, ignore the regime field on each row (use DEFAULT_THRESHOLDS instead)").action(async (options) => {
+    const topN = parseInt(options.top, 10);
+    if (options.fromHistory) {
+      const historyPath = typeof options.fromHistory === "string" ? options.fromHistory : void 0;
+      const tokens2 = options.tokens ? options.tokens.split(",").map((t) => t.trim()).filter(Boolean) : void 0;
+      let lastDays;
+      if (options.last !== void 0) {
+        lastDays = parseFloat(options.last);
+        if (!Number.isFinite(lastDays) || lastDays <= 0) {
+          console.error(chalk8.red(`Invalid --last: ${options.last} (expected positive number of days)`));
+          process.exitCode = 1;
+          return;
+        }
+      }
+      console.log(chalk8.bold(`
+  Replaying calibration against signal-history.jsonl${lastDays ? ` (last ${lastDays}d)` : ""}...
+`));
+      try {
+        const results = await runHistoryReplay({
+          historyPath,
+          tokens: tokens2,
+          lastDays,
+          useRegime: options.regime,
+          onProgress: (msg) => console.log(chalk8.dim(`  ${msg}`))
+        });
+        console.log(formatCalibrationTable(results, topN));
+        console.log(chalk8.dim(`  Source: signal-history replay (production signal stack)`));
+        console.log(chalk8.dim(`  Saved: ~/.sherwood/agent/replay-calibration-results.json
+`));
+      } catch (err) {
+        console.error(chalk8.red(`
+  Replay calibration failed: ${err.message}
+`));
+        process.exitCode = 1;
+      }
+      return;
+    }
+    const tokens = options.tokens ? options.tokens.split(",").map((t) => t.trim()).filter(Boolean) : DEFAULT_CALIBRATION_TOKENS;
+    const days = parseInt(options.days, 10);
+    const capital = parseFloat(options.capital);
+    if (!Number.isFinite(days) || days <= 0) {
+      console.error(chalk8.red(`Invalid --days: ${options.days}`));
+      process.exitCode = 1;
+      return;
+    }
+    if (!Number.isFinite(capital) || capital <= 0) {
+      console.error(chalk8.red(`Invalid --capital: ${options.capital}`));
+      process.exitCode = 1;
+      return;
+    }
+    console.log(chalk8.bold(`
+  Calibrating ${tokens.length} tokens over ${days}d (candle-based, 200 configs per token)...
+`));
+    try {
+      const results = await runCalibration({
+        tokens,
+        days,
+        capital,
+        onProgress: (msg) => console.log(chalk8.dim(`  ${msg}`))
+      });
+      console.log(formatCalibrationTable(results, topN));
+    } catch (err) {
+      console.error(chalk8.red(`
+  Calibration failed: ${err.message}
+`));
+      process.exitCode = 1;
+    }
+  });
   agent.command("signal-audit").description("Audit signal history \u2014 which signal categories actually fire?").option("--drop-threshold <rate>", "Fire-rate below which a category is flagged for dropping", "0.1").option("--json", "Emit raw JSON instead of formatted table").option("--save <path>", "Save current audit as a baseline JSON snapshot").option("--baseline <path>", "Diff current audit against a saved baseline").action(async (options) => {
     const dropThreshold = parseFloat(options.dropThreshold ?? "0.1");
     const result = await auditSignalHistory();
     if (options.save) {
-      await mkdir13(join12(homedir12(), ".sherwood", "agent"), { recursive: true });
-      await writeFile11(options.save, JSON.stringify(result, null, 2), "utf-8");
+      await mkdir15(join14(homedir14(), ".sherwood", "agent"), { recursive: true });
+      await writeFile13(options.save, JSON.stringify(result, null, 2), "utf-8");
       console.log(chalk8.green(`  Saved baseline snapshot to ${options.save}`));
       console.log(chalk8.dim(`  ${result.totalEntries} entries, ${result.perSignal.length} signals`));
       return;
@@ -7659,7 +8430,7 @@ function registerAgentCommands(program) {
     if (options.baseline) {
       let baseline;
       try {
-        const raw = await readFile12(options.baseline, "utf-8");
+        const raw = await readFile13(options.baseline, "utf-8");
         baseline = JSON.parse(raw);
       } catch (err) {
         console.error(chalk8.red(`  Failed to load baseline: ${err.message}`));
@@ -7873,4 +8644,4 @@ function formatFearGreed(value) {
 export {
   registerAgentCommands
 };
-//# sourceMappingURL=agent-TB7VNLFH.js.map
+//# sourceMappingURL=agent-XBYSALOA.js.map