@sherwoodagent/cli 0.29.1 → 0.38.3

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

@@ -1,21 +1,21 @@
 import {
   getResearchProvider
-} from "./chunk-EYI6JORK.js";
+} from "./chunk-B4AH26UI.js";
 import {
   BASE_STRATEGY_ABI
-} from "./chunk-PQ5ZX6ZT.js";
-import "./chunk-N2547R2L.js";
+} from "./chunk-OQUGUIYM.js";
+import "./chunk-OFR3LCYE.js";
 import {
   hyperevm,
   hyperevmTestnet
-} from "./chunk-H32QA3NV.js";
-import "./chunk-RGOTBJIN.js";
+} from "./chunk-IJG4CTOI.js";
+import "./chunk-WCBG44IQ.js";
 
 // src/commands/agent.ts
 import chalk8 from "chalk";
-import { readFile as readFile10, writeFile as writeFile10, mkdir as mkdir11 } from "fs/promises";
-import { join as join11 } from "path";
-import { homedir as homedir11 } from "os";
+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 ora from "ora";
 
 // src/agent/index.ts
@@ -696,6 +696,40 @@ var DEFAULT_WEIGHTS = {
   fundamental: 0.1,
   event: 0.1
 };
+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 }
+};
+var MAJORS_TOKEN_IDS = /* @__PURE__ */ new Set(["bitcoin", "ethereum", "solana"]);
+function profileForToken(tokenId, userProfile) {
+  if (userProfile && WEIGHT_PROFILES[userProfile]) {
+    return WEIGHT_PROFILES[userProfile];
+  }
+  if (MAJORS_TOKEN_IDS.has(tokenId.toLowerCase())) {
+    return WEIGHT_PROFILES["majors"];
+  }
+  return DEFAULT_WEIGHTS;
+}
+var DEFAULT_THRESHOLDS = {
+  strongBuy: 0.6,
+  buy: 0.3,
+  sell: -0.3,
+  strongSell: -0.6
+};
+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 },
+  "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 }
+};
+function thresholdsForRegime(regime) {
+  if (!regime) return DEFAULT_THRESHOLDS;
+  return REGIME_THRESHOLDS[regime] ?? DEFAULT_THRESHOLDS;
+}
 function scoreTechnical(signals) {
   let value = 0;
   const details = [];
@@ -949,8 +983,9 @@ function scoreEvent(data) {
     details: details.join("; ")
   };
 }
-function computeTradeDecision(signals, weights, regimeAdjustments, correlationCheck) {
+function computeTradeDecision(signals, weights, regimeAdjustments, correlationCheck, regime) {
   const w = weights ?? DEFAULT_WEIGHTS;
+  const thresholds = thresholdsForRegime(regime);
   const weightMap = {
     technical: w.technical,
     sentiment: w.sentiment,
@@ -1001,11 +1036,11 @@ function computeTradeDecision(signals, weights, regimeAdjustments, correlationCh
     score = Math.max(-1, Math.min(1, score));
   }
   let action;
-  if (score > 0.6) action = "STRONG_BUY";
-  else if (score > 0.3) action = "BUY";
-  else if (score > -0.3) action = "HOLD";
-  else if (score > -0.6) action = "SELL";
-  else action = "STRONG_SELL";
+  if (score >= thresholds.strongBuy) action = "STRONG_BUY";
+  else if (score >= thresholds.buy) action = "BUY";
+  else if (score <= thresholds.strongSell) action = "STRONG_SELL";
+  else if (score <= thresholds.sell) action = "SELL";
+  else action = "HOLD";
   const reasoning = signals.map((s) => `[${s.source}] ${s.details}`).join("\n");
   return {
     action,
@@ -1013,7 +1048,8 @@ function computeTradeDecision(signals, weights, regimeAdjustments, correlationCh
     signals,
     reasoning,
     confidence,
-    timestamp: Date.now()
+    timestamp: Date.now(),
+    thresholds
   };
 }
 
@@ -1522,29 +1558,29 @@ var FundingRateStrategy = class {
     const details = [];
     let value = 0;
     let confidence = 0.5;
-    if (rate > 5e-4) {
+    if (rate > 2e-4) {
       value = -0.5;
       confidence = 0.6;
       details.push(
         `High positive funding ${ratePct}% (annualized ${annualizedPct}%): overleveraged longs \u2014 bearish contrarian on ${fundingData.exchange}`
       );
-    } else if (rate > 2e-4) {
+    } else if (rate > 5e-5) {
       value = -0.3;
       confidence = 0.4;
       details.push(
-        `Mild positive funding ${ratePct}% (annualized ${annualizedPct}%): longs paying shorts \u2014 mildly bearish`
+        `Mild positive funding ${ratePct}% (annualized ${annualizedPct}%): longs paying shorts \u2014 mildly bearish on ${fundingData.exchange}`
       );
-    } else if (rate < -5e-4) {
+    } else if (rate < -2e-4) {
       value = 0.5;
       confidence = 0.6;
       details.push(
         `High negative funding ${ratePct}% (annualized ${annualizedPct}%): overleveraged shorts \u2014 bullish contrarian on ${fundingData.exchange}`
       );
-    } else if (rate < -2e-4) {
+    } else if (rate < -5e-5) {
       value = 0.3;
       confidence = 0.4;
       details.push(
-        `Mild negative funding ${ratePct}% (annualized ${annualizedPct}%): shorts paying longs \u2014 mildly bullish`
+        `Mild negative funding ${ratePct}% (annualized ${annualizedPct}%): shorts paying longs \u2014 mildly bullish on ${fundingData.exchange}`
       );
     } else {
       value = 0;
@@ -1895,146 +1931,6 @@ var MeanReversionStrategy = class {
   }
 };
 
-// src/agent/strategies/twitter-sentiment.ts
-var TwitterSentimentStrategy = class {
-  name = "twitterSentiment";
-  description = "Analyzes Twitter sentiment and mention volume for trading signals";
-  requiredData = ["twitterData"];
-  async analyze(ctx) {
-    const twitterData = ctx.twitterData;
-    if (!twitterData) {
-      return {
-        name: this.name,
-        value: 0,
-        confidence: 0,
-        source: "Twitter Sentiment",
-        details: "No Twitter sentiment data available \u2014 requires Twitter API credentials"
-      };
-    }
-    const {
-      mentionVolume,
-      sentimentScore,
-      engagementWeightedSentiment,
-      volumeSpike,
-      tweetCount,
-      llmSentiment,
-      llmConfidence,
-      llmBullishPercent,
-      llmBearishPercent
-    } = twitterData;
-    let value = 0;
-    const details = [];
-    let confidence = this.calculateConfidence(tweetCount, volumeSpike, llmConfidence);
-    const volumeSignal = this.analyzeVolumeSpike(volumeSpike, sentimentScore);
-    value += volumeSignal.value * 0.4;
-    if (volumeSignal.details) details.push(volumeSignal.details);
-    const sentimentSignal = this.analyzeSentiment(engagementWeightedSentiment, llmSentiment, llmBullishPercent, llmBearishPercent);
-    value += sentimentSignal.value * 0.4;
-    details.push(sentimentSignal.details);
-    const contrarianSignal = this.analyzeContrarian(sentimentScore, volumeSpike);
-    value += contrarianSignal.value * 0.2;
-    if (contrarianSignal.details) details.push(contrarianSignal.details);
-    details.push(`${tweetCount} tweets analyzed, ${volumeSpike.toFixed(2)}x volume spike`);
-    return {
-      name: this.name,
-      value: clamp(value),
-      confidence,
-      source: "Twitter Sentiment",
-      details: details.join("; ")
-    };
-  }
-  /** Analyze volume spike patterns. */
-  analyzeVolumeSpike(volumeSpike, sentimentScore) {
-    if (volumeSpike > 5) {
-      const signal = sentimentScore > 0 ? 0.5 : -0.5;
-      return {
-        value: signal,
-        details: `Extreme attention (${volumeSpike.toFixed(1)}x volume): ${signal > 0 ? "bullish momentum" : "bearish momentum"}`
-      };
-    } else if (volumeSpike > 3) {
-      const signal = sentimentScore > 0 ? 0.3 : -0.3;
-      return {
-        value: signal,
-        details: `High attention (${volumeSpike.toFixed(1)}x volume): ${signal > 0 ? "positive buzz" : "negative buzz"}`
-      };
-    } else if (volumeSpike > 1.5) {
-      const signal = sentimentScore > 0 ? 0.1 : -0.1;
-      return {
-        value: signal,
-        details: `Moderate buzz (${volumeSpike.toFixed(1)}x volume)`
-      };
-    }
-    return { value: 0 };
-  }
-  /** Analyze engagement-weighted sentiment. */
-  analyzeSentiment(engagementWeightedSentiment, llmSentiment, llmBullishPercent, llmBearishPercent) {
-    let finalSentiment;
-    let analysisMethod;
-    if (llmSentiment !== void 0) {
-      finalSentiment = llmSentiment * 0.6 + engagementWeightedSentiment * 0.4;
-      analysisMethod = "[LLM]";
-    } else {
-      finalSentiment = engagementWeightedSentiment;
-      analysisMethod = "";
-    }
-    const sentimentValue = finalSentiment * 0.4;
-    let description;
-    if (Math.abs(finalSentiment) < 0.1) {
-      description = "neutral sentiment";
-    } else if (finalSentiment > 0.7) {
-      description = "very bullish sentiment";
-    } else if (finalSentiment > 0.3) {
-      description = "bullish sentiment";
-    } else if (finalSentiment < -0.7) {
-      description = "very bearish sentiment";
-    } else if (finalSentiment < -0.3) {
-      description = "bearish sentiment";
-    } else {
-      description = finalSentiment > 0 ? "mildly bullish" : "mildly bearish";
-    }
-    let details = `${analysisMethod} Engagement-weighted ${description} (${finalSentiment > 0 ? "+" : ""}${finalSentiment.toFixed(2)})`;
-    if (llmBullishPercent !== void 0 && llmBearishPercent !== void 0) {
-      details += ` \u2014 ${llmBullishPercent.toFixed(0)}% bullish, ${llmBearishPercent.toFixed(0)}% bearish`;
-    }
-    return {
-      value: sentimentValue,
-      details
-    };
-  }
-  /** Apply contrarian analysis for extreme sentiment + high volume. */
-  analyzeContrarian(sentimentScore, volumeSpike) {
-    if (volumeSpike > 3) {
-      if (sentimentScore > 0.7) {
-        return {
-          value: -0.2,
-          details: "Contrarian warning: extreme bullishness may indicate local top"
-        };
-      } else if (sentimentScore < -0.7) {
-        return {
-          value: 0.2,
-          details: "Contrarian opportunity: extreme bearishness may indicate capitulation"
-        };
-      }
-    }
-    return { value: 0 };
-  }
-  /** Calculate confidence based on tweet count and volume spike. */
-  calculateConfidence(tweetCount, volumeSpike, llmConfidence) {
-    let confidence = 0.3;
-    if (tweetCount >= 100 && volumeSpike > 2) {
-      confidence = 0.8;
-    } else if (tweetCount >= 50) {
-      confidence = 0.7;
-    } else if (tweetCount >= 20) {
-      confidence = 0.5;
-    }
-    if (llmConfidence !== void 0 && llmConfidence > 70) {
-      confidence = Math.min(0.9, confidence + 0.2);
-    }
-    return confidence;
-  }
-};
-
 // src/agent/strategies/hyperliquid-flow.ts
 var HyperliquidFlowStrategy = class {
   name = "hyperliquidFlow";
@@ -2379,7 +2275,10 @@ var DEFAULT_STRATEGIES = [
   new FundingRateStrategy(),
   new DexFlowStrategy(),
   new MeanReversionStrategy(),
-  new TwitterSentimentStrategy(),
+  // 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.
   new HyperliquidFlowStrategy(),
   new MultiTimeframeStrategy()
 ];
@@ -2685,20 +2584,30 @@ var TwitterSentimentProvider = class {
         text: tweet.text,
         engagement: tweet.public_metrics.like_count + tweet.public_metrics.retweet_count + tweet.public_metrics.reply_count
       }));
+      const llmTweets = [...tweetsWithEngagement].sort((a, b) => b.engagement - a.engagement).slice(0, 40);
+      if (llmTweets.length === 0) {
+        return null;
+      }
       const batchSize = 20;
       const batches = [];
-      for (let i = 0; i < tweetsWithEngagement.length; i += batchSize) {
-        batches.push(tweetsWithEngagement.slice(i, i + batchSize));
+      for (let i = 0; i < llmTweets.length; i += batchSize) {
+        batches.push(llmTweets.slice(i, i + batchSize));
       }
       const allResults = [];
+      let consecutiveBatchFailures = 0;
+      const MAX_CONSECUTIVE_BATCH_FAILURES = 2;
       for (const batch of batches) {
         const sanitizeTweet = (text) => {
           return text.replace(/[\x00-\x1f\x7f]/g, "").replace(/[\u200B-\u200D\u202A-\u202E\u2066-\u2069\u00AD\uFEFF]/g, "").replace(/\n/g, " ").replace(/["\\]/g, (c) => `\\${c}`).slice(0, 280);
         };
         const tweetTexts = batch.map((tweet, idx) => `${idx + 1}. "${sanitizeTweet(tweet.text)}"`).join("\n");
-        const systemPrompt = `You are a crypto market sentiment analyzer. For each tweet, classify sentiment as BULLISH, BEARISH, or NEUTRAL with confidence 0-100. Consider sarcasm, irony, CT slang. Respond ONLY as a JSON array: [{"sentiment": "BULLISH", "confidence": 85}, ...]`;
+        const systemPrompt = `You are a crypto market sentiment analyzer. For each tweet, classify sentiment as BULLISH, BEARISH, or NEUTRAL with confidence 0-100. Consider sarcasm, irony, and CT slang.
+Return ONLY valid JSON with this exact shape:
+{"results":[{"sentiment":"BULLISH|BEARISH|NEUTRAL","confidence":0-100}]}`;
         const userPrompt = `Analyze these ${batch.length} tweets:
 ${tweetTexts}`;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 1e4);
         const response = await fetch("https://api.openai.com/v1/chat/completions", {
           method: "POST",
           headers: {
@@ -2711,18 +2620,25 @@ ${tweetTexts}`;
               { role: "system", content: systemPrompt },
               { role: "user", content: userPrompt }
             ],
+            response_format: { type: "json_object" },
             temperature: 0
-          })
+          }),
+          signal: controller.signal
         });
+        clearTimeout(timeout);
         if (!response.ok) {
           console.warn(`OpenAI API error: ${response.status} ${response.statusText}`);
-          return null;
+          consecutiveBatchFailures++;
+          if (consecutiveBatchFailures >= MAX_CONSECUTIVE_BATCH_FAILURES) return null;
+          continue;
         }
         const data = await response.json();
         const content = data.choices?.[0]?.message?.content;
         if (!content) {
           console.warn("OpenAI API returned no content");
-          return null;
+          consecutiveBatchFailures++;
+          if (consecutiveBatchFailures >= MAX_CONSECUTIVE_BATCH_FAILURES) return null;
+          continue;
         }
         let batchResults;
         try {
@@ -2730,10 +2646,47 @@ ${tweetTexts}`;
           if (jsonStr.startsWith("```")) {
             jsonStr = jsonStr.replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "");
           }
-          batchResults = JSON.parse(jsonStr);
-          if (!Array.isArray(batchResults) || batchResults.length !== batch.length) {
-            console.warn("OpenAI response format mismatch");
-            return null;
+          const parsed = JSON.parse(jsonStr);
+          let parsedResults = null;
+          if (Array.isArray(parsed)) {
+            parsedResults = parsed;
+          } else if (parsed && typeof parsed === "object") {
+            const obj = parsed;
+            if (Array.isArray(obj.results)) {
+              parsedResults = obj.results;
+            } else if (Array.isArray(obj.tweets)) {
+              parsedResults = obj.tweets;
+            } else if (Array.isArray(obj.sentiments)) {
+              parsedResults = obj.sentiments;
+            }
+          }
+          if (!parsedResults) {
+            const arrMatch = jsonStr.match(/\[[\s\S]*\]/);
+            if (arrMatch) {
+              const recovered = JSON.parse(arrMatch[0]);
+              if (Array.isArray(recovered)) {
+                parsedResults = recovered;
+              }
+            }
+          }
+          if (!parsedResults) {
+            throw new Error("No parseable sentiment array");
+          }
+          batchResults = parsedResults.map((item) => {
+            const row = item && typeof item === "object" ? item : {};
+            const sentimentRaw = String(row.sentiment ?? row.label ?? row.classification ?? "NEUTRAL").toUpperCase();
+            const confidenceRaw = Number(row.confidence ?? row.score ?? 50);
+            return {
+              sentiment: sentimentRaw,
+              confidence: confidenceRaw
+            };
+          });
+          if (batchResults.length > batch.length) {
+            batchResults = batchResults.slice(0, batch.length);
+          } else if (batchResults.length < batch.length) {
+            while (batchResults.length < batch.length) {
+              batchResults.push({ sentiment: "NEUTRAL", confidence: 50 });
+            }
           }
           const VALID_SENTIMENTS = /* @__PURE__ */ new Set(["BULLISH", "BEARISH", "NEUTRAL"]);
           for (const r of batchResults) {
@@ -2741,9 +2694,12 @@ ${tweetTexts}`;
             if (typeof r.confidence !== "number" || !Number.isFinite(r.confidence)) r.confidence = 50;
             r.confidence = Math.max(0, Math.min(100, r.confidence));
           }
+          consecutiveBatchFailures = 0;
         } catch (parseErr) {
           console.warn(`Failed to parse OpenAI response: ${parseErr}`);
-          return null;
+          consecutiveBatchFailures++;
+          if (consecutiveBatchFailures >= MAX_CONSECUTIVE_BATCH_FAILURES) return null;
+          batchResults = batch.map(() => ({ sentiment: "NEUTRAL", confidence: 50 }));
         }
         for (let i = 0; i < batchResults.length; i++) {
           allResults.push({
@@ -2881,10 +2837,201 @@ ${tweetTexts}`;
   }
 };
 
-// src/providers/data/hyperliquid.ts
-import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+// src/agent/signal-logger.ts
+import { appendFile, stat, rename, mkdir as mkdir4 } from "fs/promises";
 import { join as join4 } from "path";
 import { homedir as homedir4 } from "os";
+var SIGNAL_DIR = join4(homedir4(), ".sherwood", "agent");
+var SIGNAL_FILE = join4(SIGNAL_DIR, "signal-history.jsonl");
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+function logSignal(analysis, price, weights) {
+  _writeSignal(analysis, price, weights).catch((err) => {
+    console.error(`[signal-logger] Warning: failed to log signal: ${err.message}`);
+  });
+}
+async function _writeSignal(analysis, price, weights) {
+  await mkdir4(SIGNAL_DIR, { recursive: true });
+  try {
+    const stats = await stat(SIGNAL_FILE);
+    if (stats.size > MAX_FILE_SIZE) {
+      const dateStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const rotatedName = join4(SIGNAL_DIR, `signal-history-${dateStr}.jsonl`);
+      await rename(SIGNAL_FILE, rotatedName);
+    }
+  } catch {
+  }
+  const entry = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    tokenId: analysis.token,
+    tokenSymbol: analysis.token.toUpperCase().slice(0, 6),
+    price,
+    decision: analysis.decision.action,
+    score: analysis.decision.score,
+    confidence: analysis.decision.confidence,
+    signals: analysis.decision.signals.map((s) => ({
+      name: s.name,
+      value: s.value,
+      confidence: s.confidence
+    })),
+    regime: analysis.regime?.regime ?? "unknown",
+    btcCorrelation: analysis.correlation?.btcScore ?? 0,
+    weights: {
+      smartMoney: weights.smartMoney,
+      technical: weights.technical,
+      sentiment: weights.sentiment,
+      onchain: weights.onchain,
+      fundamental: weights.fundamental,
+      event: weights.event
+    }
+  };
+  const line = JSON.stringify(entry) + "\n";
+  await appendFile(SIGNAL_FILE, line, "utf-8");
+}
+function getSignalFilePath() {
+  return SIGNAL_FILE;
+}
+
+// src/agent/signal-smoother.ts
+import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { dirname } from "path";
+var FAST_SIGNAL_NAMES = /* @__PURE__ */ new Set([
+  "hyperliquidFlow",
+  "smartMoney",
+  "onchain",
+  // legacy direct on-chain signal name
+  "dexFlow",
+  "fundingRate"
+]);
+var DEFAULT_SMOOTHER_CONFIG = {
+  windowSize: 3,
+  maxAgeMs: 6 * 60 * 60 * 1e3,
+  // 6 hours — drop stale readings
+  agreementBoost: 1,
+  maxConfidencePenalty: 0.5
+};
+var FileSmootherStorage = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  async load() {
+    try {
+      const raw = await readFile4(this.filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch (err) {
+      if (err.code === "ENOENT") return {};
+      throw err;
+    }
+  }
+  async save(cache) {
+    await mkdir5(dirname(this.filePath), { recursive: true });
+    const tmp = this.filePath + ".tmp";
+    await writeFile4(tmp, JSON.stringify(cache), "utf-8");
+    const { rename: rename3 } = await import("fs/promises");
+    await rename3(tmp, this.filePath);
+  }
+};
+var MemorySmootherStorage = class {
+  cache = {};
+  async load() {
+    return this.cache;
+  }
+  async save(cache) {
+    this.cache = cache;
+  }
+};
+var SignalSmoother = class {
+  constructor(storage, config = DEFAULT_SMOOTHER_CONFIG) {
+    this.storage = storage;
+    this.config = config;
+  }
+  /** In-process mutex chain — serializes load→mutate→save across tokens in
+   *  the same process. Does NOT protect against multiple processes racing
+   *  the same file; for that, the disk storage does atomic replace and
+   *  re-reads the freshest cache inside the mutex. See README / H1 below. */
+  writeLock = Promise.resolve();
+  /**
+   * Smooth the given signals for a token. Fast signals get rolling-window
+   * averages with confidence penalties for disagreement. Slow signals
+   * pass through unchanged. Side effect: appends current readings to the
+   * cache and persists.
+   *
+   * Serialized via writeLock: concurrent calls from within the same
+   * process (e.g. parallel per-token smooths) queue on the shared mutex
+   * so each sees the freshest cache. Cross-process concurrency (two agent
+   * processes on the same host) is NOT fully safe — the second-to-save
+   * wins. Document: run one agent per host, or use MemorySmootherStorage
+   * in contexts with multiple simulation runs.
+   */
+  async smooth(tokenId, signals, nowMs = Date.now()) {
+    const prev = this.writeLock;
+    let release = () => {
+    };
+    this.writeLock = new Promise((resolve) => {
+      release = resolve;
+    });
+    await prev;
+    try {
+      return await this.smoothUnlocked(tokenId, signals, nowMs);
+    } finally {
+      release();
+    }
+  }
+  async smoothUnlocked(tokenId, signals, nowMs) {
+    const cache = await this.storage.load();
+    const cutoff = nowMs - this.config.maxAgeMs;
+    for (const t of Object.keys(cache)) {
+      if (t === tokenId) continue;
+      const buffers = cache[t];
+      if (!buffers) continue;
+      const bufferList = Object.values(buffers);
+      const anyFresh = bufferList.some((b) => b.length > 0 && b[b.length - 1].ts >= cutoff);
+      if (!anyFresh) {
+        delete cache[t];
+      }
+    }
+    if (!cache[tokenId]) cache[tokenId] = {};
+    const out = [];
+    for (const sig of signals) {
+      if (!FAST_SIGNAL_NAMES.has(sig.name)) {
+        out.push(sig);
+        continue;
+      }
+      const buffer = cache[tokenId][sig.name] ?? [];
+      buffer.push({ ts: nowMs, value: sig.value, confidence: sig.confidence });
+      const cutoff2 = nowMs - this.config.maxAgeMs;
+      const fresh = buffer.filter((r) => r.ts >= cutoff2);
+      const trimmed = fresh.slice(-this.config.windowSize);
+      cache[tokenId][sig.name] = trimmed;
+      const values = trimmed.map((r) => r.value);
+      const meanValue = values.reduce((a, b) => a + b, 0) / values.length;
+      const meanConfidence = trimmed.reduce((a, r) => a + r.confidence, 0) / trimmed.length;
+      let smoothedConfidence = meanConfidence;
+      if (trimmed.length > 1) {
+        const variance = values.reduce((sum, v) => sum + (v - meanValue) ** 2, 0) / values.length;
+        const stdDev = Math.sqrt(variance);
+        const penalty = Math.min(this.config.maxConfidencePenalty, stdDev);
+        smoothedConfidence = Math.max(0.05, meanConfidence * (1 - penalty));
+      }
+      out.push({
+        ...sig,
+        value: meanValue,
+        confidence: smoothedConfidence,
+        details: `${sig.details} [smoothed n=${trimmed.length}, raw=${sig.value.toFixed(2)}]`
+      });
+    }
+    await this.storage.save(cache);
+    return out;
+  }
+};
+
+// src/agent/index.ts
+import { join as joinPath } from "path";
+import { homedir as getHomedir } from "os";
+
+// src/providers/data/hyperliquid.ts
+import { mkdir as mkdir6, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
 var HYPERLIQUID_BASE = "https://api.hyperliquid.xyz/info";
 var TOKEN_TO_COIN = {
   bitcoin: "BTC",
@@ -2920,7 +3067,7 @@ var HyperliquidProvider = class {
   oiCache = /* @__PURE__ */ new Map();
   // For tracking OI changes
   constructor() {
-    this.cacheDir = join4(homedir4(), ".sherwood", "agent", "cache");
+    this.cacheDir = join5(homedir5(), ".sherwood", "agent", "cache");
   }
   /** Get comprehensive Hyperliquid data for a token. Returns null if token not supported or API failure. */
   async getHyperliquidData(tokenId) {
@@ -3043,8 +3190,8 @@ var HyperliquidProvider = class {
   /** Read cached Hyperliquid data. */
   async readCache(tokenId) {
     try {
-      const cacheFile = join4(this.cacheDir, `hl-${tokenId}.json`);
-      const raw = await readFile4(cacheFile, "utf-8");
+      const cacheFile = join5(this.cacheDir, `hl-${tokenId}.json`);
+      const raw = await readFile5(cacheFile, "utf-8");
       const cached = JSON.parse(raw);
       if (Date.now() - cached.ts < this.cacheTTL) {
         return cached.data;
@@ -3056,24 +3203,24 @@ var HyperliquidProvider = class {
   /** Write Hyperliquid data to cache. */
   async writeCache(tokenId, data) {
     try {
-      await mkdir4(this.cacheDir, { recursive: true });
-      const cacheFile = join4(this.cacheDir, `hl-${tokenId}.json`);
-      await writeFile4(cacheFile, JSON.stringify({ ts: Date.now(), data }), "utf-8");
+      await mkdir6(this.cacheDir, { recursive: true });
+      const cacheFile = join5(this.cacheDir, `hl-${tokenId}.json`);
+      await writeFile5(cacheFile, JSON.stringify({ ts: Date.now(), data }), "utf-8");
     } catch {
     }
   }
 };
 
 // src/agent/regime.ts
-import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
-import { join as join5 } from "path";
-import { homedir as homedir5 } from "os";
-var MarketRegimeDetector = class {
+import { readFile as readFile6, writeFile as writeFile6, mkdir as mkdir7 } from "fs/promises";
+import { join as join6 } from "path";
+import { homedir as homedir6 } from "os";
+var MarketRegimeDetector = class _MarketRegimeDetector {
   cacheDir;
   cacheFile;
   constructor() {
-    this.cacheDir = join5(homedir5(), ".sherwood", "agent", "cache");
-    this.cacheFile = join5(this.cacheDir, "regime.json");
+    this.cacheDir = join6(homedir6(), ".sherwood", "agent", "cache");
+    this.cacheFile = join6(this.cacheDir, "regime.json");
   }
   /**
    * Detect current market regime using BTC candles.
@@ -3097,6 +3244,84 @@ var MarketRegimeDetector = class {
     }
     return analysis;
   }
+  /**
+   * Pure regime classification from a candle window — no network calls,
+   * no cache, no BTC dominance lookup. Use this from the backtester to
+   * compute regime per-candle without look-ahead bias or external IO.
+   */
+  static classifyFromCandles(candles) {
+    const detector = new _MarketRegimeDetector();
+    return detector.classifySync(candles);
+  }
+  /** Synchronous candle-only analysis — same logic as analyzeBtc minus dominance/IO. */
+  classifySync(candles) {
+    if (candles.length < 200) {
+      return this.fallbackAnalysis("Insufficient BTC data for regime analysis");
+    }
+    const closes = candles.map((c) => c.close);
+    const currentPrice = closes[closes.length - 1];
+    const ema50 = calculateEMA(closes, 50);
+    const ema200 = calculateEMA(closes, 200);
+    const currentEma50 = this.getLastValidValue(ema50);
+    const currentEma200 = this.getLastValidValue(ema200);
+    const bb = calculateBollingerBands(candles, 20, 2);
+    const currentBbWidth = this.getLastValidValue(bb.width);
+    const atr = calculateATR(candles, 14);
+    const currentAtr = this.getLastValidValue(atr);
+    const atrRatio = currentAtr / currentPrice;
+    const adx = this.calculateADX(candles, 14);
+    const currentAdx = this.getLastValidValue(adx);
+    let btcTrend = "neutral";
+    if (!isNaN(currentEma50) && !isNaN(currentEma200)) {
+      if (currentPrice > currentEma50 && currentEma50 > currentEma200) {
+        btcTrend = "up";
+      } else if (currentPrice < currentEma50 && currentEma50 < currentEma200) {
+        btcTrend = "down";
+      }
+    }
+    let volatilityLevel = "normal";
+    if (!isNaN(currentBbWidth)) {
+      if (currentBbWidth < 0.04) volatilityLevel = "low";
+      else if (currentBbWidth > 0.2) volatilityLevel = "extreme";
+      else if (currentBbWidth > 0.1) volatilityLevel = "high";
+    }
+    let regime;
+    let confidence;
+    let details;
+    if (volatilityLevel === "extreme") {
+      regime = "high-volatility";
+      confidence = 0.9;
+      details = `Extreme volatility (BB ${currentBbWidth.toFixed(3)}, ATR ${atrRatio.toFixed(3)})`;
+    } else if (volatilityLevel === "low" && currentAdx < 20) {
+      regime = "low-volatility";
+      confidence = 0.8;
+      details = `Low volatility (BB ${currentBbWidth.toFixed(3)}, ADX ${currentAdx.toFixed(1)})`;
+    } else {
+      if (currentAdx > 25 && btcTrend !== "neutral") {
+        if (btcTrend === "up") {
+          regime = "trending-up";
+          confidence = Math.min(0.9, 0.6 + (currentAdx - 25) * 0.01);
+          details = `Strong uptrend (ADX ${currentAdx.toFixed(1)})`;
+        } else {
+          regime = "trending-down";
+          confidence = Math.min(0.9, 0.6 + (currentAdx - 25) * 0.01);
+          details = `Strong downtrend (ADX ${currentAdx.toFixed(1)})`;
+        }
+      } else {
+        regime = "ranging";
+        confidence = currentAdx < 20 ? 0.7 : 0.5;
+        details = `Ranging (ADX ${currentAdx.toFixed(1)})`;
+      }
+    }
+    return {
+      regime,
+      confidence,
+      btcTrend,
+      volatilityLevel,
+      details,
+      strategyAdjustments: this.getStrategyAdjustments(regime)
+    };
+  }
   async analyzeBtc(candles) {
     if (candles.length < 200) {
       return this.fallbackAnalysis("Insufficient BTC data for regime analysis");
@@ -3333,30 +3558,30 @@ var MarketRegimeDetector = class {
     };
   }
   async loadCache() {
-    const data = await readFile5(this.cacheFile, "utf-8");
+    const data = await readFile6(this.cacheFile, "utf-8");
     return JSON.parse(data);
   }
   async saveCache(analysis) {
-    await mkdir5(this.cacheDir, { recursive: true });
+    await mkdir7(this.cacheDir, { recursive: true });
     const cache = {
       timestamp: Date.now(),
       analysis
     };
-    await writeFile5(this.cacheFile, JSON.stringify(cache, null, 2), "utf-8");
+    await writeFile6(this.cacheFile, JSON.stringify(cache, null, 2), "utf-8");
   }
 };
 
 // src/agent/correlation.ts
-import { readFile as readFile6, writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
-import { join as join6 } from "path";
-import { homedir as homedir6 } from "os";
+import { readFile as readFile7, writeFile as writeFile7, mkdir as mkdir8 } from "fs/promises";
+import { join as join7 } from "path";
+import { homedir as homedir7 } from "os";
 var CorrelationGuard = class {
   cacheDir;
   cacheFile;
   coingecko;
   constructor() {
-    this.cacheDir = join6(homedir6(), ".sherwood", "agent", "cache");
-    this.cacheFile = join6(this.cacheDir, "btc-correlation.json");
+    this.cacheDir = join7(homedir7(), ".sherwood", "agent", "cache");
+    this.cacheFile = join7(this.cacheDir, "btc-correlation.json");
     this.coingecko = new CoinGeckoProvider();
   }
   /**
@@ -3561,23 +3786,23 @@ var CorrelationGuard = class {
     return NaN;
   }
   async loadCache() {
-    const data = await readFile6(this.cacheFile, "utf-8");
+    const data = await readFile7(this.cacheFile, "utf-8");
     return JSON.parse(data);
   }
   async saveCache(btcStructure) {
-    await mkdir6(this.cacheDir, { recursive: true });
+    await mkdir8(this.cacheDir, { recursive: true });
     const cache = {
       timestamp: Date.now(),
       btcStructure
     };
-    await writeFile6(this.cacheFile, JSON.stringify(cache, null, 2), "utf-8");
+    await writeFile7(this.cacheFile, JSON.stringify(cache, null, 2), "utf-8");
   }
 };
 
 // src/agent/alerts.ts
-import { readFile as readFile7, writeFile as writeFile7, mkdir as mkdir7 } from "fs/promises";
-import { join as join7 } from "path";
-import { homedir as homedir7 } from "os";
+import { readFile as readFile8, writeFile as writeFile8, mkdir as mkdir9 } from "fs/promises";
+import { join as join8 } from "path";
+import { homedir as homedir8 } from "os";
 import { createHash as createHash2 } from "crypto";
 var DEFAULT_CONFIG = {
   enableRegimeAlerts: true,
@@ -3591,9 +3816,9 @@ var AlertSystem = class {
   configFile;
   config;
   constructor() {
-    this.stateDir = join7(homedir7(), ".sherwood", "agent");
-    this.stateFile = join7(this.stateDir, "alerts-state.json");
-    this.configFile = join7(this.stateDir, "alerts-config.json");
+    this.stateDir = join8(homedir8(), ".sherwood", "agent");
+    this.stateFile = join8(this.stateDir, "alerts-state.json");
+    this.configFile = join8(this.stateDir, "alerts-config.json");
     this.config = DEFAULT_CONFIG;
   }
   /**
@@ -3840,7 +4065,7 @@ var AlertSystem = class {
    */
   async loadState() {
     try {
-      const data = await readFile7(this.stateFile, "utf-8");
+      const data = await readFile8(this.stateFile, "utf-8");
       return JSON.parse(data);
     } catch {
       return {
@@ -3857,8 +4082,8 @@ var AlertSystem = class {
    */
   async saveState(state) {
     try {
-      await mkdir7(this.stateDir, { recursive: true });
-      await writeFile7(this.stateFile, JSON.stringify(state, null, 2), "utf-8");
+      await mkdir9(this.stateDir, { recursive: true });
+      await writeFile8(this.stateFile, JSON.stringify(state, null, 2), "utf-8");
     } catch (err) {
       console.error(`Failed to save alert state: ${err.message}`);
     }
@@ -3930,6 +4155,7 @@ var TradingAgent = class {
   regimeDetector;
   correlationGuard;
   alertSystem;
+  smoother = null;
   constructor(config) {
     this.config = config;
     this.defillama = new DefiLlamaProvider();
@@ -4100,7 +4326,7 @@ var TradingAgent = class {
     }
     let marketData = void 0;
     try {
-      const [symbolResult, fundingRateResult, unlockResult, twitterResult] = await Promise.allSettled([
+      const [symbolResult, fundingRateResult, unlockResult] = await Promise.allSettled([
         // Resolve token symbol + get market data for strategies
         this.coingecko.getCoinDetails(tokenId).then(async (coinDetails) => {
           const symbol = coinDetails?.symbol?.toUpperCase();
@@ -4110,9 +4336,7 @@ var TradingAgent = class {
         // Fetch funding rate data (free, from Binance)
         this.fundingRate.getFundingRate(tokenId),
         // Fetch token unlock estimates (free, from DefiLlama FDV)
-        this.tokenUnlocks.getUnlocks(tokenId),
-        // Fetch Twitter sentiment data (free tier with auth)
-        this.twitter.getSentiment(tokenId)
+        this.tokenUnlocks.getUnlocks(tokenId)
       ]);
       let tokenSymbol;
       if (symbolResult.status === "fulfilled" && symbolResult.value) {
@@ -4120,7 +4344,12 @@ var TradingAgent = class {
         marketData = symbolResult.value.marketData;
       }
       let fundingRateData = void 0;
-      if (fundingRateResult.status === "fulfilled" && fundingRateResult.value) {
+      if (hyperliquidData && typeof hyperliquidData.fundingRate === "number" && Number.isFinite(hyperliquidData.fundingRate)) {
+        const rate1h = hyperliquidData.fundingRate;
+        const rate8h = rate1h * 8;
+        const annualizedRate = rate1h * 24 * 365;
+        fundingRateData = { rate8h, annualizedRate, exchange: "hyperliquid" };
+      } else if (fundingRateResult.status === "fulfilled" && fundingRateResult.value) {
         const fr = fundingRateResult.value;
         fundingRateData = { rate8h: fr.rate8h, annualizedRate: fr.annualizedRate, exchange: fr.exchange };
       }
@@ -4128,12 +4357,7 @@ var TradingAgent = class {
       if (unlockResult.status === "fulfilled" && unlockResult.value) {
         unlockData = unlockResult.value;
       }
-      let twitterData = void 0;
-      if (twitterResult.status === "fulfilled" && twitterResult.value) {
-        twitterData = twitterResult.value;
-      } else if (twitterResult.status === "rejected") {
-        console.error(chalk.dim(`  Twitter sentiment failed: ${twitterResult.reason}`));
-      }
+      const twitterData = void 0;
       const stratCtx = {
         tokenId,
         candles,
@@ -4161,7 +4385,20 @@ var TradingAgent = class {
         tokenSymbol
         // from phase 3
       };
-      const strategySignals = await runStrategies(stratCtx, this.config.strategyConfigs);
+      let strategySignals = await runStrategies(stratCtx, this.config.strategyConfigs);
+      if (this.config.smoothFastSignals) {
+        if (!this.smoother) {
+          this.smoother = new SignalSmoother(
+            new FileSmootherStorage(joinPath(getHomedir(), ".sherwood", "agent", "signal-cache.json")),
+            DEFAULT_SMOOTHER_CONFIG
+          );
+        }
+        try {
+          strategySignals = await this.smoother.smooth(tokenId, strategySignals);
+        } catch (err) {
+          console.error(chalk.dim(`  Signal smoothing failed (using raw): ${err.message}`));
+        }
+      }
       for (const sig of strategySignals) {
         if (sig.confidence > 0.05) {
           signals.push(sig);
@@ -4199,19 +4436,24 @@ var TradingAgent = class {
     } catch (err) {
       console.error(chalk.dim(`  Correlation check failed: ${err.message}`));
     }
+    const resolvedWeights = this.config.weights ?? profileForToken(tokenId, this.config.weightProfile);
     const decision = computeTradeDecision(
       signals,
-      this.config.weights ?? DEFAULT_WEIGHTS,
+      resolvedWeights,
       regimeAnalysis?.strategyAdjustments,
-      correlationCheck
+      correlationCheck,
+      regimeAnalysis?.regime
     );
-    return {
+    const result = {
       token: tokenId,
       decision,
       data: { technicalSignals, fearAndGreed: fearAndGreedValue, tvl },
       regime: regimeAnalysis,
       correlation: correlationCheck
     };
+    const currentPrice = hyperliquidData?.markPrice ?? (candles && candles.length > 0 ? candles[candles.length - 1].close : 0);
+    logSignal(result, currentPrice, resolvedWeights);
+    return result;
   }
   /** Update the token watchlist without recreating the agent (preserves caches). */
   updateTokens(tokens) {
@@ -4323,9 +4565,9 @@ var TradingAgent = class {
 };
 
 // src/agent/token-selector.ts
-import { mkdir as mkdir8, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
-import { join as join8 } from "path";
-import { homedir as homedir8 } from "os";
+import { mkdir as mkdir10, readFile as readFile9, writeFile as writeFile9 } from "fs/promises";
+import { join as join9 } from "path";
+import { homedir as homedir9 } from "os";
 var HYPERLIQUID_BASE2 = "https://api.hyperliquid.xyz/info";
 var HYPERLIQUID_TO_COINGECKO = {
   BTC: "bitcoin",
@@ -4459,7 +4701,7 @@ var DynamicTokenSelector = class {
   cacheTTL = 30 * 60 * 1e3;
   // 30 minutes
   constructor() {
-    this.cacheDir = join8(homedir8(), ".sherwood", "agent", "cache");
+    this.cacheDir = join9(homedir9(), ".sherwood", "agent", "cache");
   }
   /** Get dynamic token selection based on Hyperliquid market data. */
   async selectTokens(criteria) {
@@ -4591,8 +4833,8 @@ var DynamicTokenSelector = class {
   /** Read cached token selection. */
   async readCache() {
     try {
-      const cacheFile = join8(this.cacheDir, "token-selection.json");
-      const raw = await readFile8(cacheFile, "utf-8");
+      const cacheFile = join9(this.cacheDir, "token-selection.json");
+      const raw = await readFile9(cacheFile, "utf-8");
       const cached = JSON.parse(raw);
       if (Date.now() - cached.timestamp < this.cacheTTL) {
         return cached;
@@ -4604,9 +4846,9 @@ var DynamicTokenSelector = class {
   /** Write token selection to cache. */
   async writeCache(selection) {
     try {
-      await mkdir8(this.cacheDir, { recursive: true });
-      const cacheFile = join8(this.cacheDir, "token-selection.json");
-      await writeFile8(cacheFile, JSON.stringify(selection, null, 2), "utf-8");
+      await mkdir10(this.cacheDir, { recursive: true });
+      const cacheFile = join9(this.cacheDir, "token-selection.json");
+      await writeFile9(cacheFile, JSON.stringify(selection, null, 2), "utf-8");
     } catch {
     }
   }
@@ -4651,9 +4893,9 @@ var DynamicTokenSelector = class {
 
 // src/agent/loop.ts
 import chalk6 from "chalk";
-import { mkdir as mkdir10, appendFile } from "fs/promises";
-import { join as join10 } from "path";
-import { homedir as homedir10 } from "os";
+import { mkdir as mkdir12, appendFile as appendFile2 } from "fs/promises";
+import { join as join11 } from "path";
+import { homedir as homedir11 } from "os";
 
 // src/agent/executor.ts
 import chalk2 from "chalk";
@@ -4919,9 +5161,9 @@ async function getSzDecimals(assetIndex) {
 }
 
 // src/agent/portfolio.ts
-import { mkdir as mkdir9, readFile as readFile9, writeFile as writeFile9, rename } from "fs/promises";
-import { dirname, join as join9 } from "path";
-import { homedir as homedir9 } from "os";
+import { mkdir as mkdir11, readFile as readFile10, writeFile as writeFile10, rename as rename2 } from "fs/promises";
+import { dirname as dirname2, join as join10 } from "path";
+import { homedir as homedir10 } from "os";
 import chalk3 from "chalk";
 function resetPnlCounters(state) {
   const now = Date.now();
@@ -4966,15 +5208,15 @@ var PortfolioTracker = class {
   historyPath;
   state;
   constructor() {
-    const base = join9(homedir9(), ".sherwood", "agent");
-    this.statePath = join9(base, "portfolio.json");
-    this.historyPath = join9(base, "trades.json");
+    const base = join10(homedir10(), ".sherwood", "agent");
+    this.statePath = join10(base, "portfolio.json");
+    this.historyPath = join10(base, "trades.json");
     this.state = { ...DEFAULT_PORTFOLIO };
   }
   /** Load portfolio state from disk with validation */
   async load() {
     try {
-      const data = await readFile9(this.statePath, "utf-8");
+      const data = await readFile10(this.statePath, "utf-8");
       const parsed = JSON.parse(data);
       if (!Number.isFinite(parsed.totalValue) || parsed.totalValue < 0 || !Number.isFinite(parsed.cash) || parsed.cash < 0 || !Number.isFinite(parsed.dailyPnl) || !Number.isFinite(parsed.weeklyPnl) || !Number.isFinite(parsed.monthlyPnl) || !Array.isArray(parsed.positions)) {
         console.error("Portfolio file has invalid data \u2014 resetting to defaults");
@@ -4997,10 +5239,10 @@ var PortfolioTracker = class {
   /** Save portfolio state to disk (atomic write to prevent corruption) */
   async save(state) {
     this.state = state;
-    await mkdir9(dirname(this.statePath), { recursive: true });
+    await mkdir11(dirname2(this.statePath), { recursive: true });
     const tmpPath = this.statePath + ".tmp";
-    await writeFile9(tmpPath, JSON.stringify(state, null, 2), "utf-8");
-    await rename(tmpPath, this.statePath);
+    await writeFile10(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+    await rename2(tmpPath, this.statePath);
   }
   /** Open a new position */
   async openPosition(position) {
@@ -5086,7 +5328,7 @@ var PortfolioTracker = class {
   async getHistory(days) {
     let records = [];
     try {
-      const data = await readFile9(this.historyPath, "utf-8");
+      const data = await readFile10(this.historyPath, "utf-8");
       records = JSON.parse(data);
     } catch {
       return [];
@@ -5204,15 +5446,15 @@ var PortfolioTracker = class {
   async appendTradeRecord(record) {
     let records = [];
     try {
-      const data = await readFile9(this.historyPath, "utf-8");
+      const data = await readFile10(this.historyPath, "utf-8");
       records = JSON.parse(data);
     } catch {
     }
     records.push(record);
-    await mkdir9(dirname(this.historyPath), { recursive: true });
+    await mkdir11(dirname2(this.historyPath), { recursive: true });
     const tmpPath = this.historyPath + ".tmp";
-    await writeFile9(tmpPath, JSON.stringify(records, null, 2), "utf-8");
-    await rename(tmpPath, this.historyPath);
+    await writeFile10(tmpPath, JSON.stringify(records, null, 2), "utf-8");
+    await rename2(tmpPath, this.historyPath);
   }
 };
 
@@ -5225,6 +5467,12 @@ var DEFAULT_RISK_CONFIG = {
   maxConcurrentTrades: 8,
   hardStopPercent: 0.12,
   trailingStopAtr: 1.5,
+  trailingStopPct: 0,
+  // OFF — opt in via config
+  breakevenTriggerPct: 0,
+  // OFF — opt in via config
+  profitLockSteps: [],
+  // OFF — opt in via config
   dailyLossLimit: 0.05,
   weeklyLossLimit: 0.1,
   monthlyLossLimit: 0.15,
@@ -5386,6 +5634,53 @@ var RiskManager = class {
     }
     return { paused: false, level: null, message: "Within limits" };
   }
+  /**
+   * Ratchet stop-losses upward each cycle based on current prices.
+   * Applies three independent mechanisms, whichever gives the highest stop:
+   *
+   *   1. Breakeven: if PnL% crosses +breakevenTriggerPct, move stop to entryPrice.
+   *      Locks in "no loss" once the trade is meaningfully in the money.
+   *
+   *   2. Profit-lock ratchet: stepped table (e.g. after +5% gain, lock in +2%).
+   *      Each triggered step moves stop to entryPrice × (1 + lock).
+   *      Prevents giving back earned profit on mean reversion.
+   *
+   *   3. Percent-trail: stop = max(currentStop, currentPrice × (1 - trailingStopPct)).
+   *      Continuous trail — tracks new highs as price runs.
+   *
+   * All mechanisms respect the "stops never move down" invariant.
+   * Returns an array of updated positions (pure — does not mutate input).
+   *
+   * No ATR needed — works from price alone, so it can run every loop cycle
+   * without re-computing technicals. Use updateStopLosses() when ATR is
+   * already available (keeps tighter trails on volatile assets).
+   */
+  updateTrailingStops(positions) {
+    return positions.map((pos) => {
+      if (pos.currentPrice <= 0 || pos.entryPrice <= 0) return pos;
+      const pnlPct = (pos.currentPrice - pos.entryPrice) / pos.entryPrice;
+      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) {
+        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 };
+      }
+      return pos;
+    });
+  }
   /** Update trailing stop losses using ATR values */
   updateStopLosses(positions, atrValues) {
     return positions.map((pos) => {
@@ -5616,8 +5911,8 @@ var AgentLoop = class {
   /** Start the autonomous loop */
   async start() {
     this.running = true;
-    const stateDir = join10(homedir10(), ".sherwood", "agent");
-    await mkdir10(stateDir, { recursive: true });
+    const stateDir = join11(homedir11(), ".sherwood", "agent");
+    await mkdir12(stateDir, { recursive: true });
     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"));
@@ -5685,7 +5980,26 @@ var AgentLoop = class {
           }
         }
         if (Object.keys(currentPrices).length > 0) {
-          await this.portfolio.updatePrices(currentPrices);
+          const priceState = await this.portfolio.updatePrices(currentPrices);
+          const tightened = this.riskManager.updateTrailingStops(priceState.positions);
+          const anyChanged = tightened.some(
+            (p, i) => p.stopLoss !== priceState.positions[i].stopLoss
+          );
+          if (anyChanged) {
+            for (let i = 0; i < tightened.length; i++) {
+              const before = priceState.positions[i];
+              const after = tightened[i];
+              if (after.stopLoss > before.stopLoss) {
+                console.log(
+                  chalk6.dim(
+                    `  Stop tightened: ${after.symbol} $${before.stopLoss.toFixed(4)} \u2192 $${after.stopLoss.toFixed(4)}`
+                  )
+                );
+              }
+            }
+            priceState.positions = tightened;
+            await this.portfolio.save(priceState);
+          }
           const exits = await this.executor.processExits(currentPrices);
           exitsProcessed = exits.length;
           for (const exit of exits) {
@@ -5766,10 +6080,10 @@ var AgentLoop = class {
   }
   /** Log cycle result to a JSONL file */
   async logCycle(result) {
-    const logPath = this.config.logPath ?? join10(homedir10(), ".sherwood", "agent", "cycles.jsonl");
+    const logPath = this.config.logPath ?? join11(homedir11(), ".sherwood", "agent", "cycles.jsonl");
     try {
-      await mkdir10(join10(homedir10(), ".sherwood", "agent"), { recursive: true });
-      await appendFile(logPath, JSON.stringify(result) + "\n", "utf-8");
+      await mkdir12(join11(homedir11(), ".sherwood", "agent"), { recursive: true });
+      await appendFile2(logPath, JSON.stringify(result) + "\n", "utf-8");
     } catch (err) {
       console.error(chalk6.dim(`  Failed to write cycle log: ${err.message}`));
     }
@@ -5824,6 +6138,15 @@ var Backtester = class _Backtester {
   }
   /** Run backtest using historical data from CoinGecko. */
   async run() {
+    const data = await this.fetchData();
+    return this.simulate(data.candles, data.fearAndGreedData);
+  }
+  /**
+   * Fetch historical OHLC + Fear & Greed data for the configured token/date range.
+   * Extracted so callers (e.g. the calibrator) can fetch once and replay many
+   * configurations against the same dataset without re-hitting CoinGecko.
+   */
+  async fetchData() {
     const startMs = new Date(this.config.startDate).getTime();
     const endMs = new Date(this.config.endDate).getTime();
     const totalDays = Math.ceil((endMs - startMs) / (24 * 60 * 60 * 1e3));
@@ -5881,10 +6204,19 @@ var Backtester = class _Backtester {
         console.log(chalk7.yellow(`  Warning: Could not fetch Fear & Greed data: ${error.message}`));
       }
     }
+    return { candles: allCandles, fearAndGreedData };
+  }
+  /**
+   * 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.
+   */
+  async simulate(allCandles, fearAndGreedData) {
     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;
     let position = null;
+    const smoother = this.config.smoothFastSignals ? new SignalSmoother(new MemorySmootherStorage(), DEFAULT_SMOOTHER_CONFIG) : null;
     const trades = [];
     const equityCurve = [];
     const returns = [];
@@ -5925,7 +6257,10 @@ var Backtester = class _Backtester {
           technicals,
           fearAndGreed
         };
-        const signals = await runStrategies(ctx);
+        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(
@@ -5934,13 +6269,42 @@ var Backtester = class _Backtester {
         } else {
           filtered = signals.filter((s) => CANDLE_BASED_STRATEGIES.includes(s.name) || fearAndGreed && s.name === "sentimentContrarian");
         }
-        decision = computeTradeDecision(filtered.length > 0 ? filtered : signals);
+        let regime;
+        if (this.config.useRegime) {
+          regime = MarketRegimeDetector.classifyFromCandles(windowCandles).regime;
+        }
+        decision = computeTradeDecision(
+          filtered.length > 0 ? filtered : signals,
+          this.config.customWeights,
+          void 0,
+          void 0,
+          regime
+        );
+        if (this.config.buyThreshold !== void 0 || this.config.sellThreshold !== void 0) {
+          const buy = this.config.buyThreshold ?? decision.thresholds?.buy ?? 0.3;
+          const sell = this.config.sellThreshold ?? decision.thresholds?.sell ?? -0.3;
+          if (buy <= sell) {
+            throw new Error(
+              `Invalid threshold override: buyThreshold (${buy}) must be strictly greater than sellThreshold (${sell}). Collision would produce ambiguous actions at score == threshold.`
+            );
+          }
+          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, thresholds: { strongBuy, buy, sell, strongSell } };
+        }
         if (this.config.verbose) {
           const activeSignals = filtered.filter((s) => Math.abs(s.value) > 0.01);
           const signalSummary = activeSignals.map(
             (s) => `${s.name}:${s.value >= 0 ? "+" : ""}${s.value.toFixed(2)}`
           ).join(" ");
-          console.log(`${currentDate}: score=${decision.score.toFixed(2)} ${decision.action} (${signalSummary || "no signals"})`);
+          const regimeTag = regime ? ` [${regime}]` : "";
+          console.log(`${currentDate}: score=${decision.score.toFixed(2)} ${decision.action}${regimeTag} (${signalSummary || "no signals"})`);
         }
       } catch {
         continue;
@@ -5949,21 +6313,30 @@ var Backtester = class _Backtester {
         position = {
           entryPrice: currentPrice,
           entryDate: currentDate,
-          signal: decision.action
+          signal: decision.action,
+          highWaterMark: currentPrice
         };
-      } else if (position && (decision.action === "SELL" || decision.action === "STRONG_SELL")) {
-        const pnlPercent = (currentPrice - position.entryPrice) / position.entryPrice;
-        capital *= 1 + pnlPercent;
-        returns.push(pnlPercent);
-        trades.push({
-          entryDate: position.entryDate,
-          exitDate: currentDate,
-          entryPrice: position.entryPrice,
-          exitPrice: currentPrice,
-          pnlPercent,
-          signal: `${position.signal} \u2192 ${decision.action}`
-        });
-        position = null;
+      } else if (position) {
+        if (currentPrice > position.highWaterMark) {
+          position.highWaterMark = 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;
+          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}`
+          });
+          position = null;
+        }
       }
     }
     if (position && allCandles.length > 0) {
@@ -6042,8 +6415,11 @@ var Backtester = class _Backtester {
           initialCapital: config.capital,
           strategies: config.strategies,
           cycle: "1d",
-          verbose: false
+          verbose: false,
           // Don't spam verbose output during walk-forward
+          useRegime: config.useRegime,
+          trailingStopPct: config.trailingStopPct,
+          smoothFastSignals: config.smoothFastSignals
         });
         const trainResult = await trainBacktester.run();
         const testBacktester = new _Backtester({
@@ -6053,8 +6429,11 @@ var Backtester = class _Backtester {
           initialCapital: config.capital,
           strategies: config.strategies,
           cycle: "1d",
-          verbose: false
+          verbose: false,
           // Don't spam verbose output during walk-forward
+          useRegime: config.useRegime,
+          trailingStopPct: config.trailingStopPct,
+          smoothFastSignals: config.smoothFastSignals
         });
         const testResult = await testBacktester.run();
         const fold = {
@@ -6434,19 +6813,44 @@ ${alertText}`);
 };
 
 // src/agent/execution-pipeline.ts
+var DEFAULT_SCALED_SIZING = {
+  enabled: false,
+  floor: 0.3,
+  ceiling: 0.6,
+  minRiskPct: 5e-3,
+  maxRiskPct: 0.02
+};
 var ExecutionPipeline = class {
   /**
    * Generate trade proposals from analysis results.
-   * Only creates proposals for high-confidence opportunities (score > 0.4, confidence > 50%).
+   * Only creates proposals for high-confidence opportunities — uses the
+   * regime-conditional BUY/SELL threshold from the decision (defaults to
+   * ±0.4 if the decision lacks regime context).
+   *
+   * Optional ProposalOptions.scaledSizing enables score-weighted sizing.
+   * Previously this was a mutable static field — fixed per code review
+   * to eliminate cross-invocation leakage in long-lived processes.
    */
-  static generateProposals(analyses, portfolioValueUsd = 1e4) {
+  static generateProposals(analyses, portfolioValueOrOpts = 1e4, optsArg) {
+    const opts = typeof portfolioValueOrOpts === "number" ? { portfolioValueUsd: portfolioValueOrOpts, ...optsArg ?? {} } : portfolioValueOrOpts ?? {};
+    const portfolioValueUsd = opts.portfolioValueUsd ?? 1e4;
+    const scaledSizing = opts.scaledSizing ?? DEFAULT_SCALED_SIZING;
     const proposals = [];
     for (const analysis of analyses) {
       const { decision, token, data } = analysis;
-      if (Math.abs(decision.score) <= 0.4 || decision.confidence <= 0.5) {
+      if (decision.action === "HOLD") {
         continue;
       }
-      if (decision.action === "HOLD") {
+      const baseBuyFloor = decision.thresholds?.buy ?? 0.4;
+      const baseSellFloor = decision.thresholds?.sell ?? -0.4;
+      const buyFloor = scaledSizing.enabled ? Math.min(baseBuyFloor, scaledSizing.floor) : baseBuyFloor;
+      const sellFloor = scaledSizing.enabled ? Math.max(baseSellFloor, -scaledSizing.floor) : baseSellFloor;
+      const clearsBuy = decision.score >= buyFloor;
+      const clearsSell = decision.score <= sellFloor;
+      if (!clearsBuy && !clearsSell) {
+        continue;
+      }
+      if (decision.confidence <= 0.5) {
         continue;
       }
       const isLong = decision.score > 0;
@@ -6458,7 +6862,15 @@ var ExecutionPipeline = class {
       const stopLoss = isLong ? entryPrice - 2 * atr : entryPrice + 2 * atr;
       const riskAmount = Math.abs(entryPrice - stopLoss);
       const takeProfit = isLong ? entryPrice + 2.5 * riskAmount : entryPrice - 2.5 * riskAmount;
-      const riskPercentage = 0.02;
+      let riskPercentage;
+      if (scaledSizing.enabled) {
+        const cfg = scaledSizing;
+        const absScore = Math.abs(decision.score);
+        const t = Math.min(1, Math.max(0, (absScore - cfg.floor) / (cfg.ceiling - cfg.floor)));
+        riskPercentage = cfg.minRiskPct + t * (cfg.maxRiskPct - cfg.minRiskPct);
+      } else {
+        riskPercentage = 0.02;
+      }
       const positionSizeUsd = portfolioValueUsd * riskPercentage / (Math.abs(entryPrice - stopLoss) / entryPrice);
       const maxAllocation = portfolioValueUsd * 0.1;
       const leverage = Math.min(5, positionSizeUsd / maxAllocation);
@@ -6568,6 +6980,221 @@ _Generated: ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}_`);
   }
 };
 
+// src/agent/signal-audit.ts
+import { readFile as readFile11 } from "fs/promises";
+var FIRE_EPSILON = 0.05;
+var SIGNAL_TO_CATEGORY = {
+  // Direct categories
+  technical: "technical",
+  sentiment: "sentiment",
+  onchain: "onchain",
+  fundamental: "fundamental",
+  event: "event",
+  smartMoney: "smartMoney",
+  // Strategy-level signals mapped to their category
+  breakoutOnChain: "technical",
+  meanReversion: "technical",
+  multiTimeframe: "technical",
+  dexFlow: "onchain",
+  fundingRate: "fundamental",
+  tvlMomentum: "fundamental",
+  sentimentContrarian: "sentiment",
+  twitterSentiment: "sentiment",
+  tokenUnlock: "event",
+  hyperliquidFlow: "onchain"
+};
+async function auditSignalHistory(filePath = getSignalFilePath()) {
+  let raw;
+  try {
+    raw = await readFile11(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return {
+        filePath,
+        totalEntries: 0,
+        dateRange: null,
+        perSignal: [],
+        perCategory: []
+      };
+    }
+    throw err;
+  }
+  const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+  const entries = [];
+  for (const line of lines) {
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  if (entries.length === 0) {
+    return {
+      filePath,
+      totalEntries: 0,
+      dateRange: null,
+      perSignal: [],
+      perCategory: []
+    };
+  }
+  const bySignal = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const sig of entry.signals) {
+      if (!bySignal.has(sig.name)) {
+        bySignal.set(sig.name, { values: [], confidences: [] });
+      }
+      const bucket = bySignal.get(sig.name);
+      bucket.values.push(sig.value);
+      bucket.confidences.push(sig.confidence);
+    }
+  }
+  const perSignal = [];
+  for (const [name, bucket] of bySignal) {
+    const obs = bucket.values.length;
+    const fires = bucket.values.filter((v) => Math.abs(v) > FIRE_EPSILON).length;
+    const meanAbsValue = bucket.values.reduce((a, v) => a + Math.abs(v), 0) / obs;
+    const meanConfidence = bucket.confidences.reduce((a, c) => a + c, 0) / obs;
+    const directionalBias = bucket.values.reduce((a, v) => a + v, 0) / obs;
+    perSignal.push({
+      name,
+      category: SIGNAL_TO_CATEGORY[name] ?? "unknown",
+      observations: obs,
+      fireRate: fires / obs,
+      meanAbsValue,
+      meanConfidence,
+      directionalBias
+    });
+  }
+  perSignal.sort((a, b) => b.fireRate - a.fireRate);
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const sig of perSignal) {
+    if (!byCategory.has(sig.category)) {
+      byCategory.set(sig.category, {
+        signals: /* @__PURE__ */ new Set(),
+        obs: 0,
+        fires: 0,
+        absSum: 0
+      });
+    }
+    const bucket = byCategory.get(sig.category);
+    bucket.signals.add(sig.name);
+    bucket.obs += sig.observations;
+    bucket.fires += sig.fireRate * sig.observations;
+    bucket.absSum += sig.meanAbsValue * sig.observations;
+  }
+  const perCategory = [];
+  for (const [category, bucket] of byCategory) {
+    const fireRate = bucket.obs > 0 ? bucket.fires / bucket.obs : 0;
+    const meanAbsValue = bucket.obs > 0 ? bucket.absSum / bucket.obs : 0;
+    let recommendation;
+    if (fireRate >= 0.4) recommendation = "keep";
+    else if (fireRate < 0.1) recommendation = "drop";
+    else recommendation = "review";
+    perCategory.push({
+      category,
+      signalNames: [...bucket.signals],
+      observations: bucket.obs,
+      fireRate,
+      meanAbsValue,
+      recommendation
+    });
+  }
+  perCategory.sort((a, b) => b.fireRate - a.fireRate);
+  const timestamps = entries.map((e) => e.timestamp).sort();
+  return {
+    filePath,
+    totalEntries: entries.length,
+    dateRange: {
+      from: timestamps[0],
+      to: timestamps[timestamps.length - 1]
+    },
+    perSignal,
+    perCategory
+  };
+}
+var DELTA_EPSILON = 0.05;
+function classifyStatus(baselineRate, currentRate) {
+  if (baselineRate === null) return "new";
+  if (currentRate === null) return "removed";
+  const delta = currentRate - baselineRate;
+  if (Math.abs(delta) < DELTA_EPSILON) return "stable";
+  return delta > 0 ? "improved" : "regressed";
+}
+function diffAudits(baseline, current) {
+  const baseSignals = new Map(baseline.perSignal.map((s) => [s.name, s]));
+  const currSignals = new Map(current.perSignal.map((s) => [s.name, s]));
+  const allSignalNames = /* @__PURE__ */ new Set([...baseSignals.keys(), ...currSignals.keys()]);
+  const perSignal = [];
+  for (const name of allSignalNames) {
+    const b = baseSignals.get(name);
+    const c = currSignals.get(name);
+    perSignal.push({
+      name,
+      category: (c ?? b)?.category ?? "unknown",
+      baseline: {
+        fireRate: b?.fireRate ?? 0,
+        meanAbsValue: b?.meanAbsValue ?? 0,
+        observations: b?.observations ?? 0
+      },
+      current: {
+        fireRate: c?.fireRate ?? 0,
+        meanAbsValue: c?.meanAbsValue ?? 0,
+        observations: c?.observations ?? 0
+      },
+      fireRateDelta: (c?.fireRate ?? 0) - (b?.fireRate ?? 0),
+      meanAbsValueDelta: (c?.meanAbsValue ?? 0) - (b?.meanAbsValue ?? 0),
+      status: classifyStatus(b?.fireRate ?? null, c?.fireRate ?? null)
+    });
+  }
+  perSignal.sort((a, b) => Math.abs(b.fireRateDelta) - Math.abs(a.fireRateDelta));
+  const baseCats = new Map(baseline.perCategory.map((c) => [c.category, c]));
+  const currCats = new Map(current.perCategory.map((c) => [c.category, c]));
+  const allCats = /* @__PURE__ */ new Set([...baseCats.keys(), ...currCats.keys()]);
+  const perCategory = [];
+  for (const cat of allCats) {
+    const b = baseCats.get(cat);
+    const c = currCats.get(cat);
+    perCategory.push({
+      name: cat,
+      category: cat,
+      baseline: {
+        fireRate: b?.fireRate ?? 0,
+        meanAbsValue: b?.meanAbsValue ?? 0,
+        observations: b?.observations ?? 0
+      },
+      current: {
+        fireRate: c?.fireRate ?? 0,
+        meanAbsValue: c?.meanAbsValue ?? 0,
+        observations: c?.observations ?? 0
+      },
+      fireRateDelta: (c?.fireRate ?? 0) - (b?.fireRate ?? 0),
+      meanAbsValueDelta: (c?.meanAbsValue ?? 0) - (b?.meanAbsValue ?? 0),
+      status: classifyStatus(b?.fireRate ?? null, c?.fireRate ?? null)
+    });
+  }
+  perCategory.sort((a, b) => Math.abs(b.fireRateDelta) - Math.abs(a.fireRateDelta));
+  return {
+    baselineDateRange: baseline.dateRange,
+    currentDateRange: current.dateRange,
+    perSignal,
+    perCategory
+  };
+}
+function suggestRenormalizedWeights(currentWeights, perCategory, dropThreshold = 0.1) {
+  const keepCategories = new Set(
+    perCategory.filter((c) => c.fireRate >= dropThreshold && c.category !== "unknown").map((c) => c.category)
+  );
+  let retainedSum = 0;
+  for (const [cat, w] of Object.entries(currentWeights)) {
+    if (keepCategories.has(cat)) retainedSum += w;
+  }
+  if (retainedSum === 0) return currentWeights;
+  const out = {};
+  for (const [cat, w] of Object.entries(currentWeights)) {
+    out[cat] = keepCategories.has(cat) ? w / retainedSum : 0;
+  }
+  return out;
+}
+
 // src/commands/agent.ts
 var DEFAULT_TOKENS = ["ethereum", "bitcoin", "solana", "aave", "uniswap"];
 function makeConfig(overrides) {
@@ -6577,12 +7204,14 @@ function makeConfig(overrides) {
     dryRun: true,
     maxPositionPct: 5,
     maxRiskPct: 20,
+    useX402: true,
+    // Paid signals (Nansen + Messari) on by default — opt out with --no-x402
     ...overrides
   };
 }
 function registerAgentCommands(program) {
   const agent = program.command("agent").description("Autonomous trading agent");
-  agent.command("analyze").description("Analyze token(s) using multi-signal scoring").argument("[tokens...]", "Token IDs to analyze (e.g., ethereum bitcoin)").option("--all", "Analyze full watchlist").option("--auto", "Use dynamic token selection from Hyperliquid market data").option("--json", "Output as JSON").option("--x402", "Include paid x402 data (Nansen smart-money, Messari fundamentals)").option("--telegram", "Output formatted summary for Telegram").option("--proposals", "Generate trade proposals for high-confidence opportunities").action(async (tokens, options) => {
+  agent.command("analyze").description("Analyze token(s) using multi-signal scoring").argument("[tokens...]", "Token IDs to analyze (e.g., ethereum bitcoin)").option("--all", "Analyze full watchlist").option("--auto", "Use dynamic token selection from Hyperliquid market data").option("--json", "Output as JSON").option("--no-x402", "Skip paid x402 data (Nansen smart-money, Messari fundamentals) \u2014 on by default").option("--telegram", "Output formatted summary for Telegram").option("--proposals", "Generate trade proposals for high-confidence opportunities").option("--weight-profile <name>", "Weight profile: default | majors | altcoin | sentHeavy | techHeavy (auto: majors for BTC/ETH/SOL)").option("--scaled-sizing", "Score-weighted position sizing (smaller positions for marginal scores)").option("--smooth", "Smooth fast signals with rolling 3-reading window").action(async (tokens, options) => {
     let tokenList;
     let selectionSummary;
     if (options.auto) {
@@ -6604,7 +7233,8 @@ function registerAgentCommands(program) {
     } else {
       tokenList = options.all ? DEFAULT_TOKENS : tokens.length > 0 ? tokens : DEFAULT_TOKENS;
     }
-    const config = makeConfig({ tokens: tokenList, useX402: options.x402 ?? false });
+    const scaledSizing = options.scaledSizing ? { ...DEFAULT_SCALED_SIZING, enabled: true } : void 0;
+    const config = makeConfig({ tokens: tokenList, useX402: options.x402, weightProfile: options.weightProfile, smoothFastSignals: options.smooth });
     const tradingAgent = new TradingAgent(config);
     const spinner = ora("Analyzing tokens...").start();
     try {
@@ -6618,7 +7248,7 @@ function registerAgentCommands(program) {
         return;
       }
       if (options.proposals) {
-        const proposals = ExecutionPipeline.generateProposals(results);
+        const proposals = ExecutionPipeline.generateProposals(results, { scaledSizing });
         const formatted = ExecutionPipeline.formatProposals(proposals);
         console.log(formatted);
         return;
@@ -6740,7 +7370,7 @@ function registerAgentCommands(program) {
       process.exitCode = 1;
     }
   });
-  agent.command("start").description("Start autonomous trading loop").option("--cycle <interval>", "Cycle interval (15m, 1h, 4h)", "4h").option("--dry-run", "Paper trading mode", true).option("--tokens <tokens>", "Comma-separated token list").option("--auto", "Use dynamic token selection from Hyperliquid market data").option("--log <path>", "Path to write cycle logs").option("--mode <mode>", "Execution mode: dry-run (default), hyperliquid-perp", "dry-run").option("--strategy-clone <address>", "Strategy clone address on HyperEVM (required for hyperliquid-perp)").option("--chain <chain>", "Chain for live execution (hyperevm, hyperevm-testnet)", "ethereum").option("--asset-index <n>", "HyperCore perp asset index (default: 3 = ETH)").option("--x402", "Include paid x402 data (Nansen smart-money, Messari fundamentals)").action(async (options) => {
+  agent.command("start").description("Start autonomous trading loop").option("--cycle <interval>", "Cycle interval (15m, 1h, 4h)", "4h").option("--dry-run", "Paper trading mode", true).option("--tokens <tokens>", "Comma-separated token list").option("--auto", "Use dynamic token selection from Hyperliquid market data").option("--log <path>", "Path to write cycle logs").option("--mode <mode>", "Execution mode: dry-run (default), hyperliquid-perp", "dry-run").option("--strategy-clone <address>", "Strategy clone address on HyperEVM (required for hyperliquid-perp)").option("--chain <chain>", "Chain for live execution (hyperevm, hyperevm-testnet)", "ethereum").option("--asset-index <n>", "HyperCore perp asset index (default: 3 = ETH)").option("--no-x402", "Skip paid x402 data (Nansen smart-money, Messari fundamentals) \u2014 on by default").option("--weight-profile <name>", "Weight profile: default | majors | altcoin | sentHeavy | techHeavy (auto: majors for BTC/ETH/SOL)").option("--scaled-sizing", "Score-weighted position sizing (smaller positions for marginal scores)").option("--smooth", "Smooth fast signals with rolling 3-reading window").action(async (options) => {
     let tokenList;
     if (options.auto) {
       console.log(chalk8.dim("  Using dynamic token selection from Hyperliquid (refreshes every 30 min)"));
@@ -6751,8 +7381,8 @@ function registerAgentCommands(program) {
     const cycle = options.cycle ?? "4h";
     let savedRiskConfig = {};
     try {
-      const configPath = join11(homedir11(), ".sherwood", "agent", "config.json");
-      const data = await readFile10(configPath, "utf-8");
+      const configPath = join12(homedir12(), ".sherwood", "agent", "config.json");
+      const data = await readFile12(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)) {
@@ -6777,7 +7407,7 @@ function registerAgentCommands(program) {
       return;
     }
     const loopConfig = {
-      agent: makeConfig({ tokens: tokenList, cycle, dryRun: !isLive, useX402: options.x402 ?? false }),
+      agent: makeConfig({ tokens: tokenList, cycle, dryRun: !isLive, useX402: options.x402, weightProfile: options.weightProfile, smoothFastSignals: options.smooth }),
       execution: {
         dryRun: !isLive,
         mode: options.mode ?? "dry-run",
@@ -6903,17 +7533,17 @@ function registerAgentCommands(program) {
           }
           riskConfig[key] = numVal;
           console.log(chalk8.green(`  Set ${key} = ${numVal}`));
-          const configDir = join11(homedir11(), ".sherwood", "agent");
-          const configPath = join11(configDir, "config.json");
+          const configDir = join12(homedir12(), ".sherwood", "agent");
+          const configPath = join12(configDir, "config.json");
           let existingConfig = {};
           try {
-            const data = await readFile10(configPath, "utf-8");
+            const data = await readFile12(configPath, "utf-8");
             existingConfig = JSON.parse(data);
           } catch {
           }
           existingConfig[key] = numVal;
-          await mkdir11(configDir, { recursive: true });
-          await writeFile10(configPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+          await mkdir13(configDir, { recursive: true });
+          await writeFile11(configPath, JSON.stringify(existingConfig, null, 2), "utf-8");
           console.log(chalk8.dim(`  Saved to ${configPath}`));
         } else {
           console.log(chalk8.red(`  Invalid value: ${value}`));
@@ -6944,9 +7574,15 @@ function registerAgentCommands(program) {
     console.log(`  Max Slippage (small):    ${(riskConfig.maxSlippage.small * 100).toFixed(1)}%`);
     console.log("");
   });
-  agent.command("backtest").description("Backtest strategies on historical data").argument("<token>", "Token ID (e.g., bitcoin, ethereum)").option("--from <date>", "Start date (YYYY-MM-DD)", "2024-01-01").option("--to <date>", "End date (YYYY-MM-DD)", "2024-12-31").option("--strategies <list>", "Comma-separated strategy names", "").option("--capital <amount>", "Initial capital in USD", "10000").option("--cycle <interval>", "Candle interval (1h, 4h, 1d)", "1d").option("--walk-forward", "Enable walk-forward optimization").option("--train <days>", "Training window in days for walk-forward", "90").option("--test <days>", "Test window in days for walk-forward", "30").option("--verbose", "Show detailed decision logs for each candle").action(async (token, options) => {
+  agent.command("backtest").description("Backtest strategies on historical data").argument("<token>", "Token ID (e.g., bitcoin, ethereum)").option("--from <date>", "Start date (YYYY-MM-DD)", "2024-01-01").option("--to <date>", "End date (YYYY-MM-DD)", "2024-12-31").option("--strategies <list>", "Comma-separated strategy names", "").option("--capital <amount>", "Initial capital in USD", "10000").option("--cycle <interval>", "Candle interval (1h, 4h, 1d)", "1d").option("--walk-forward", "Enable walk-forward optimization").option("--train <days>", "Training window in days for walk-forward", "90").option("--test <days>", "Test window in days for walk-forward", "30").option("--verbose", "Show detailed decision logs for each candle").option("--regime", "Apply regime-conditional thresholds per-candle (matches live behavior)").option("--trailing-stop <pct>", "Trailing stop as decimal (e.g. 0.05 = 5%) \u2014 exits if price drops X% from high-water mark").option("--scaled-sizing", "Score-weighted position sizing (smaller positions for marginal scores)").option("--weight-profile <name>", "Named weight profile: default | majors | altcoin | sentHeavy | techHeavy").option("--smooth", "Smooth fast signals (HL flow, smartMoney, dexFlow, fundingRate) with rolling 3-reading window").action(async (token, options) => {
     const capital = parseFloat(options.capital);
     const strategies = options.strategies ? options.strategies.split(",").map((s) => s.trim()) : [];
+    const trailingStopPct = options.trailingStop ? parseFloat(options.trailingStop) : void 0;
+    if (trailingStopPct !== void 0 && (!Number.isFinite(trailingStopPct) || trailingStopPct <= 0 || trailingStopPct > 0.5)) {
+      console.error(chalk8.red("--trailing-stop must be between 0 and 0.5 (e.g. 0.05 = 5%)"));
+      process.exitCode = 1;
+      return;
+    }
     if (options.walkForward) {
       const trainWindow = parseInt(options.train, 10);
       const testWindow = parseInt(options.test, 10);
@@ -6959,7 +7595,10 @@ function registerAgentCommands(program) {
         testWindow,
         stepSize,
         capital,
-        strategies
+        strategies,
+        useRegime: options.regime,
+        trailingStopPct,
+        smoothFastSignals: options.smooth
       };
       const spinner = ora(`Walk-forward testing ${token} (${trainWindow}d train, ${testWindow}d test)...`).start();
       try {
@@ -6970,7 +7609,10 @@ function registerAgentCommands(program) {
           initialCapital: capital,
           strategies,
           cycle: options.cycle || "1d",
-          verbose: options.verbose
+          verbose: options.verbose,
+          useRegime: options.regime,
+          trailingStopPct,
+          smoothFastSignals: options.smooth
         });
         const result = await backtester.walkForwardTest(walkConfig);
         spinner.stop();
@@ -6987,7 +7629,10 @@ function registerAgentCommands(program) {
         initialCapital: capital,
         strategies,
         cycle: options.cycle || "1d",
-        verbose: options.verbose
+        verbose: options.verbose,
+        useRegime: options.regime,
+        trailingStopPct,
+        smoothFastSignals: options.smooth
       };
       const spinner = ora(`Backtesting ${token} from ${config.startDate} to ${config.endDate}...`).start();
       try {
@@ -7001,6 +7646,150 @@ function registerAgentCommands(program) {
       }
     }
   });
+  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");
+      console.log(chalk8.green(`  Saved baseline snapshot to ${options.save}`));
+      console.log(chalk8.dim(`  ${result.totalEntries} entries, ${result.perSignal.length} signals`));
+      return;
+    }
+    if (options.baseline) {
+      let baseline;
+      try {
+        const raw = await readFile12(options.baseline, "utf-8");
+        baseline = JSON.parse(raw);
+      } catch (err) {
+        console.error(chalk8.red(`  Failed to load baseline: ${err.message}`));
+        process.exitCode = 1;
+        return;
+      }
+      const diff = diffAudits(baseline, result);
+      if (options.json) {
+        console.log(JSON.stringify(diff, null, 2));
+        return;
+      }
+      console.log("");
+      console.log(chalk8.bold("  Signal Audit Diff"));
+      console.log(chalk8.dim("  " + "\u2550".repeat(72)));
+      if (baseline.dateRange && result.dateRange) {
+        console.log(chalk8.dim(`  Baseline: ${baseline.dateRange.from.slice(0, 10)} \u2192 ${baseline.dateRange.to.slice(0, 10)} (${baseline.totalEntries} entries)`));
+        console.log(chalk8.dim(`  Current:  ${result.dateRange.from.slice(0, 10)} \u2192 ${result.dateRange.to.slice(0, 10)} (${result.totalEntries} entries)`));
+      }
+      console.log("");
+      console.log(chalk8.bold("  Per Category"));
+      console.log(chalk8.dim(`  ${"Category".padEnd(14)} ${"Was".padEnd(7)} ${"Now".padEnd(7)} ${"\u0394".padEnd(8)} Status`));
+      console.log(chalk8.dim("  " + "\u2500".repeat(72)));
+      for (const c of diff.perCategory) {
+        const arrow = c.status === "improved" ? chalk8.green("\u2191") : c.status === "regressed" ? chalk8.red("\u2193") : c.status === "new" ? chalk8.cyan("\u2726") : c.status === "removed" ? chalk8.red("\u2717") : chalk8.dim("=");
+        const deltaStr = (c.fireRateDelta >= 0 ? "+" : "") + (c.fireRateDelta * 100).toFixed(0) + "pp";
+        const deltaColor = c.status === "improved" ? chalk8.green : c.status === "regressed" ? chalk8.red : chalk8.dim;
+        console.log(
+          `  ${c.category.padEnd(14)} ${(c.baseline.fireRate * 100).toFixed(0).padStart(5)}%  ${(c.current.fireRate * 100).toFixed(0).padStart(5)}%  ${deltaColor(deltaStr.padEnd(7))} ${arrow} ${c.status}`
+        );
+      }
+      const changedSignals = diff.perSignal.filter((s) => s.status !== "stable");
+      if (changedSignals.length > 0) {
+        console.log("");
+        console.log(chalk8.bold("  Changed Signals"));
+        console.log(chalk8.dim(`  ${"Signal".padEnd(22)} ${"Was".padEnd(7)} ${"Now".padEnd(7)} ${"\u0394".padEnd(8)} Status`));
+        console.log(chalk8.dim("  " + "\u2500".repeat(72)));
+        for (const s of changedSignals) {
+          const arrow = s.status === "improved" ? chalk8.green("\u2191") : s.status === "regressed" ? chalk8.red("\u2193") : s.status === "new" ? chalk8.cyan("\u2726") : s.status === "removed" ? chalk8.red("\u2717") : chalk8.dim("=");
+          const deltaStr = (s.fireRateDelta >= 0 ? "+" : "") + (s.fireRateDelta * 100).toFixed(0) + "pp";
+          const deltaColor = s.status === "improved" ? chalk8.green : s.status === "regressed" ? chalk8.red : chalk8.dim;
+          console.log(
+            `  ${s.name.padEnd(22)} ${(s.baseline.fireRate * 100).toFixed(0).padStart(5)}%  ${(s.current.fireRate * 100).toFixed(0).padStart(5)}%  ${deltaColor(deltaStr.padEnd(7))} ${arrow} ${s.status}`
+          );
+        }
+      } else {
+        console.log("");
+        console.log(chalk8.dim("  No per-signal changes above 5pp threshold."));
+      }
+      console.log("");
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(chalk8.bold("  Signal Activity Audit"));
+    console.log(chalk8.dim("  " + "\u2550".repeat(72)));
+    if (result.totalEntries === 0) {
+      console.log(chalk8.dim(`  No signal history yet at ${result.filePath}`));
+      console.log(chalk8.dim("  Run 'sherwood agent analyze' a few times to populate it."));
+      console.log("");
+      return;
+    }
+    console.log(chalk8.dim(`  Source:  ${result.filePath}`));
+    console.log(chalk8.dim(`  Entries: ${result.totalEntries}`));
+    if (result.dateRange) {
+      console.log(
+        chalk8.dim(
+          `  Range:   ${result.dateRange.from.slice(0, 10)} \u2192 ${result.dateRange.to.slice(0, 10)}`
+        )
+      );
+    }
+    console.log("");
+    console.log(chalk8.bold("  Per Category"));
+    console.log(
+      chalk8.dim(
+        `  ${"Category".padEnd(14)} ${"Fire%".padEnd(7)} ${"Obs".padEnd(6)} ${"Mean|v|".padEnd(9)} Signals`
+      )
+    );
+    console.log(chalk8.dim("  " + "\u2500".repeat(72)));
+    for (const c of result.perCategory) {
+      const color = c.recommendation === "keep" ? chalk8.green : c.recommendation === "drop" ? chalk8.red : chalk8.yellow;
+      const rec = `[${c.recommendation.toUpperCase()}]`;
+      console.log(
+        `  ${c.category.padEnd(14)} ${(c.fireRate * 100).toFixed(0).padStart(5)}%  ${String(c.observations).padEnd(6)} ${c.meanAbsValue.toFixed(3).padEnd(9)} ${c.signalNames.join(", ")} ${color(rec)}`
+      );
+    }
+    console.log("");
+    console.log(chalk8.bold("  Per Signal"));
+    console.log(
+      chalk8.dim(
+        `  ${"Signal".padEnd(22)} ${"Category".padEnd(12)} ${"Fire%".padEnd(7)} ${"Obs".padEnd(6)} ${"Mean|v|".padEnd(9)} ${"Bias".padEnd(8)} Conf`
+      )
+    );
+    console.log(chalk8.dim("  " + "\u2500".repeat(72)));
+    for (const s of result.perSignal) {
+      const biasColor = s.directionalBias >= 0 ? chalk8.green : chalk8.red;
+      console.log(
+        `  ${s.name.padEnd(22)} ${s.category.padEnd(12)} ${(s.fireRate * 100).toFixed(0).padStart(5)}%  ${String(s.observations).padEnd(6)} ${s.meanAbsValue.toFixed(3).padEnd(9)} ${biasColor((s.directionalBias >= 0 ? "+" : "") + s.directionalBias.toFixed(3)).padEnd(17)} ${s.meanConfidence.toFixed(2)}`
+      );
+    }
+    const current = DEFAULT_WEIGHTS;
+    const suggested = suggestRenormalizedWeights(current, result.perCategory, dropThreshold);
+    const changed = Object.keys(current).some(
+      (k) => Math.abs((suggested[k] ?? 0) - (current[k] ?? 0)) > 1e-3
+    );
+    if (changed) {
+      console.log("");
+      console.log(chalk8.bold("  Suggested Weight Renormalization"));
+      console.log(chalk8.dim(`  (Dropping categories below ${(dropThreshold * 100).toFixed(0)}% fire rate)`));
+      console.log(chalk8.dim("  " + "\u2500".repeat(72)));
+      console.log(
+        chalk8.dim(
+          `  ${"Category".padEnd(14)} ${"Current".padEnd(10)} ${"Suggested"}`
+        )
+      );
+      for (const [cat, w] of Object.entries(current)) {
+        const newW = suggested[cat] ?? 0;
+        const tag = newW === 0 ? chalk8.red(" \u2190 drop") : newW > w ? chalk8.green(" \u2190 boost") : "";
+        console.log(
+          `  ${cat.padEnd(14)} ${w.toFixed(3).padEnd(10)} ${newW.toFixed(3)}${tag}`
+        );
+      }
+    } else {
+      console.log("");
+      console.log(chalk8.dim("  All categories above drop threshold \u2014 no renormalization suggested."));
+    }
+    console.log("");
+  });
   const alerts = agent.command("alerts").description("Manage trading alerts");
   alerts.command("list").alias("").description("Show recent alerts").option("--hours <n>", "Look back N hours", "24").action(async (options) => {
     try {
@@ -7084,4 +7873,4 @@ function formatFearGreed(value) {
 export {
   registerAgentCommands
 };
-//# sourceMappingURL=agent-U6OFXITU.js.map
+//# sourceMappingURL=agent-TB7VNLFH.js.map