@sherwoodagent/cli 0.52.0 → 0.53.2

package/dist/index.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 import {
   HyperliquidProvider,
+  TOKEN_TO_COIN,
+  calculateATR,
   getLatestSignals,
   hlCancelAllOrders,
   hlGetMeta,
   hlPlaceLimitOrder,
   resolveHLCoin
-} from "./chunk-OMW47WOO.js";
+} from "./chunk-DBOINZYU.js";
 import {
   UniswapProvider,
   applySlippage,
@@ -93,7 +95,7 @@ import {
   setVotingPeriod,
   settleProposal,
   vote
-} from "./chunk-JY46LEIS.js";
+} from "./chunk-4VXAOLRC.js";
 import {
   AERODROME,
   AGENT_REGISTRY,
@@ -1536,9 +1538,9 @@ function registerStrategyTemplateCommands(strategy2) {
       console.error(chalk.red("Missing --name, --performance-fee, or --duration. Use --write-calls to skip proposal submission."));
       process.exit(1);
     }
-    const { propose: propose2 } = await import("./governor-CQG4LA43.js");
+    const { propose: propose2 } = await import("./governor-HZW5TEP2.js");
     const { pinJSON } = await import("./ipfs-IGXLLJCF.js");
-    const { parseDuration: parseDuration2 } = await import("./governor-CQG4LA43.js");
+    const { parseDuration: parseDuration2 } = await import("./governor-HZW5TEP2.js");
     const performanceFeeBps = BigInt(opts.performanceFee);
     if (performanceFeeBps < 0n || performanceFeeBps > 10000n) {
       console.error(chalk.red("--performance-fee must be 0-10000 (basis points)"));
@@ -4762,7 +4764,9 @@ var GridPortfolio = class {
       allocation: allocation * (config.tokenSplit[token] ?? 1 / config.tokens.length),
       stats: emptyStats(),
       centerPrice: 0,
-      atr: 0
+      atr: 0,
+      trend: 0,
+      lastTrendRefreshAt: 0
     }));
     const state = {
       totalAllocation: allocation,
@@ -4778,10 +4782,10 @@ var GridPortfolio = class {
   getState() {
     return this.state;
   }
-  /** Reset daily counters if UTC day boundary crossed. */
-  resetDailyStats(state) {
-    const now = Date.now();
-    const todayMidnight = /* @__PURE__ */ new Date();
+  /** Reset daily counters if UTC day boundary crossed. `now` is injectable
+   *  so the backtester can drive resets off backtest time, not wall-clock. */
+  resetDailyStats(state, now = Date.now()) {
+    const todayMidnight = new Date(now);
     todayMidnight.setUTCHours(0, 0, 0, 0);
     const todayMs = todayMidnight.getTime();
     let changed = false;
@@ -4795,16 +4799,25 @@ var GridPortfolio = class {
     }
     return changed;
   }
-  /** Check if grid should be paused (pool dropped below threshold). */
-  checkPauseThreshold(state, config) {
+  /** Check if grid should be paused or resumed (pool equity dropped/recovered).
+   *  `prices` is required to mark open buys to market. Hysteresis: pause at
+   *  `pauseThresholdPct` drop, resume only when drop recovers below
+   *  `unpauseRecoveryPct`. Returns true iff state.paused was changed. */
+  checkPauseThreshold(state, config, prices) {
     const currentValue = state.grids.reduce((sum, g) => {
-      const openFillValue = g.openFills.filter((f) => !f.closed).reduce((s, f) => s + f.quantity * f.buyPrice, 0);
-      return sum + g.allocation + openFillValue;
+      const price = prices[g.token];
+      const unrealized = price && price > 0 ? g.openFills.filter((f) => !f.closed).reduce((s, f) => s + (price - f.buyPrice) * f.quantity, 0) : 0;
+      return sum + g.allocation + unrealized;
     }, 0);
     const dropPct = 1 - currentValue / state.totalAllocation;
-    if (dropPct >= config.pauseThresholdPct) {
+    if (!state.paused && dropPct >= config.pauseThresholdPct) {
       state.paused = true;
-      state.pauseReason = `Grid pool dropped ${(dropPct * 100).toFixed(1)}% (threshold: ${(config.pauseThresholdPct * 100).toFixed(0)}%)`;
+      state.pauseReason = `Grid pool dropped ${(dropPct * 100).toFixed(1)}% (pause threshold: ${(config.pauseThresholdPct * 100).toFixed(0)}%, resume when \u2264 ${(config.unpauseRecoveryPct * 100).toFixed(0)}%)`;
+      return true;
+    }
+    if (state.paused && dropPct <= config.unpauseRecoveryPct) {
+      state.paused = false;
+      state.pauseReason = "";
       return true;
     }
     return false;
@@ -4821,14 +4834,24 @@ var GridPortfolio = class {
 };
 
 // src/grid/manager.ts
+var defaultFillDetector = (level, currentPrice) => level.side === "buy" ? currentPrice <= level.price : currentPrice >= level.price;
+var defaultCloseFillDetector = (openFill, currentPrice) => currentPrice >= openFill.targetSellPrice;
 var GridManager = class {
   config;
   portfolio;
   hl;
-  constructor(config) {
+  candleFetcher;
+  fillDetector;
+  closeFillDetector;
+  nowProvider;
+  constructor(config, candleFetcher, fillDetector, closeFillDetector, portfolio, nowProvider) {
     this.config = config;
-    this.portfolio = new GridPortfolio();
+    this.portfolio = portfolio ?? new GridPortfolio();
     this.hl = new HyperliquidProvider();
+    this.candleFetcher = candleFetcher ?? ((tokenId, interval, lookbackMs) => this.hl.getCandles(tokenId, interval, lookbackMs));
+    this.fillDetector = fillDetector ?? defaultFillDetector;
+    this.closeFillDetector = closeFillDetector ?? defaultCloseFillDetector;
+    this.nowProvider = nowProvider ?? (() => Date.now());
   }
   /** Load or initialize grid state.
    *  Also syncs new tokens added to config after initial grid setup. */
@@ -4850,7 +4873,9 @@ var GridManager = class {
           allocation: alloc,
           stats: { totalRoundTrips: 0, totalPnlUsd: 0, todayPnlUsd: 0, totalFills: 0, todayFills: 0, lastDailyReset: 0, lastRebalanceAt: 0 },
           centerPrice: 0,
-          atr: 0
+          atr: 0,
+          trend: 0,
+          lastTrendRefreshAt: 0
         });
         addedAllocation += alloc;
         console.error(`  [grid] Added new token grid: ${token} ($${alloc.toFixed(0)} allocation)`);
@@ -4871,8 +4896,15 @@ var GridManager = class {
    */
   async tick(prices, regime) {
     const state = await this.portfolio.load();
-    if (!state || state.paused || !this.config.enabled) {
-      return { fills: 0, roundTrips: 0, pnlUsd: 0, paused: state?.paused ?? false };
+    if (!state || !this.config.enabled) {
+      return { fills: 0, roundTrips: 0, pnlUsd: 0, paused: false };
+    }
+    if (state.paused) {
+      const resumed = this.portfolio.checkPauseThreshold(state, this.config, prices);
+      if (resumed) {
+        await this.portfolio.save(state);
+      }
+      return { fills: 0, roundTrips: 0, pnlUsd: 0, paused: state.paused };
     }
     if (regime === "high-volatility") {
       console.error(chalk9.dim(`  [grid] Paused: high-volatility regime \u2014 too risky for grid`));
@@ -4885,6 +4917,7 @@ var GridManager = class {
     for (const grid of state.grids) {
       const price = prices[grid.token];
       if (!price || price <= 0) continue;
+      await this.maybeRefreshTrend(grid);
       if (grid.levels.length === 0 || this.needsFullRebuild(grid)) {
         await this.buildGrid(grid, price);
       }
@@ -4896,13 +4929,29 @@ var GridManager = class {
         await this.shiftGrid(grid, price);
       }
     }
-    this.portfolio.checkPauseThreshold(state, this.config);
+    this.portfolio.checkPauseThreshold(state, this.config, prices);
     await this.portfolio.save(state);
     return { fills: totalFills, roundTrips: totalRoundTrips, pnlUsd: totalPnl, paused: false };
   }
+  /** Hourly refresh of `grid.trend` from recent 4h candles. Called from
+   *  tick() so the downtrend filter sees fresh data between buildGrid runs. */
+  async maybeRefreshTrend(grid) {
+    const now = this.nowProvider();
+    const ONE_HOUR = 60 * 60 * 1e3;
+    if (now - grid.lastTrendRefreshAt < ONE_HOUR) return;
+    const candles = await this.candleFetcher(grid.token, "4h", 14 * 4 * 60 * 60 * 1e3);
+    if (!candles || candles.length < 2) return;
+    const TREND_LOOKBACK_BARS = 14;
+    const sliceStart = Math.max(0, candles.length - TREND_LOOKBACK_BARS);
+    const first = candles[sliceStart].close;
+    const last = candles[candles.length - 1].close;
+    if (first <= 0) return;
+    grid.trend = (last - first) / first;
+    grid.lastTrendRefreshAt = now;
+  }
   /** Build a fresh grid centered on the current price using ATR. */
   async buildGrid(grid, currentPrice) {
-    const candles = await this.hl.getCandles(grid.token, "4h", 14 * 24 * 60 * 60 * 1e3);
+    const candles = await this.candleFetcher(grid.token, "4h", 14 * 24 * 60 * 60 * 1e3);
     if (!candles || candles.length < this.config.atrPeriod) {
       console.error(chalk9.dim(`  [grid] Cannot build grid for ${grid.token}: insufficient candle data`));
       return;
@@ -4913,12 +4962,24 @@ var GridManager = class {
       console.error(chalk9.dim(`  [grid] Cannot build grid for ${grid.token}: invalid ATR (${atr})`));
       return;
     }
+    const TREND_LOOKBACK_BARS = 14;
+    let trend = 0;
+    if (candles.length >= 2) {
+      const sliceStart = Math.max(0, candles.length - TREND_LOOKBACK_BARS);
+      const first = candles[sliceStart].close;
+      const last = candles[candles.length - 1].close;
+      if (first > 0) {
+        trend = (last - first) / first;
+      }
+    }
     const range = atr * this.config.atrMultiplier;
     const spacing = range / this.config.levelsPerSide;
     const effectiveCapital = grid.allocation * this.config.leverage;
     const quantity = effectiveCapital / (this.config.levelsPerSide * currentPrice);
     const levels = [];
-    for (let i = 1; i <= this.config.levelsPerSide; i++) {
+    const inDowntrend = this.config.downtrendBlockPct > 0 && trend < -this.config.downtrendBlockPct;
+    const buyCount = inDowntrend ? 1 : this.config.levelsPerSide;
+    for (let i = 1; i <= buyCount; i++) {
       levels.push({
         price: currentPrice - spacing * i,
         side: "buy",
@@ -4939,9 +5000,10 @@ var GridManager = class {
     grid.levels = levels;
     grid.centerPrice = currentPrice;
     grid.atr = atr;
+    grid.trend = trend;
     grid.stats.lastRebalanceAt = Date.now();
     console.error(chalk9.dim(
-      `  [grid] Built ${grid.token} grid: center=$${currentPrice.toFixed(2)} ATR=$${atr.toFixed(2)} range=$${(currentPrice - range).toFixed(2)}-$${(currentPrice + range).toFixed(2)} spacing=$${spacing.toFixed(2)} qty=${quantity.toFixed(6)}`
+      `  [grid] Built ${grid.token} grid: center=$${currentPrice.toFixed(2)} ATR=$${atr.toFixed(2)} range=$${(currentPrice - range).toFixed(2)}-$${(currentPrice + range).toFixed(2)} spacing=$${spacing.toFixed(2)} qty=${quantity.toFixed(6)} trend=${(trend * 100).toFixed(1)}%${inDowntrend ? " [DOWNTREND: 1 buy / " + this.config.levelsPerSide + " sells]" : ""}`
     ));
   }
   /** Simulate order fills against the current price. */
@@ -4952,9 +5014,19 @@ var GridManager = class {
     const now = Date.now();
     const spacing = grid.atr > 0 ? grid.atr * this.config.atrMultiplier / this.config.levelsPerSide : 0;
     if (spacing <= 0) return { fills: 0, roundTrips: 0, pnlUsd: 0 };
+    const exposureCap = grid.allocation * this.config.leverage * this.config.maxOpenNotionalMultiple;
+    const currentOpenNotional = grid.openFills.filter((f) => !f.closed).reduce((s, f) => s + f.quantity * f.buyPrice, 0);
+    const buyExposureFull = currentOpenNotional >= exposureCap;
+    const inDowntrend = this.config.downtrendBlockPct > 0 && grid.trend < -this.config.downtrendBlockPct;
     for (const level of grid.levels) {
       if (level.filled) continue;
-      if (level.side === "buy" && currentPrice <= level.price) {
+      if (level.side === "buy" && this.fillDetector(level, currentPrice)) {
+        if (buyExposureFull) {
+          continue;
+        }
+        if (inDowntrend) {
+          continue;
+        }
         level.filled = true;
         level.filledAt = now;
         fills++;
@@ -4974,7 +5046,7 @@ var GridManager = class {
           `  [grid] BUY fill ${grid.token} @ $${level.price.toFixed(2)} qty=${level.quantity.toFixed(6)}`
         ));
       }
-      if (level.side === "sell" && currentPrice >= level.price) {
+      if (level.side === "sell" && this.fillDetector(level, currentPrice)) {
         level.filled = true;
         level.filledAt = now;
         fills++;
@@ -4987,8 +5059,8 @@ var GridManager = class {
     }
     for (const openFill of grid.openFills) {
       if (openFill.closed) continue;
-      if (currentPrice >= openFill.targetSellPrice) {
-        const profit = (currentPrice - openFill.buyPrice) * openFill.quantity * this.config.leverage;
+      if (this.closeFillDetector(openFill, currentPrice)) {
+        const profit = (currentPrice - openFill.buyPrice) * openFill.quantity;
         if (profit >= this.config.minProfitPerFillUsd) {
           openFill.closed = true;
           openFill.pnlUsd = profit;
@@ -5005,6 +5077,25 @@ var GridManager = class {
         }
       }
     }
+    if (this.config.stopLossPct > 0) {
+      for (const openFill of grid.openFills) {
+        if (openFill.closed) continue;
+        const stopPrice = openFill.buyPrice * (1 - this.config.stopLossPct);
+        if (currentPrice <= stopPrice) {
+          const realizedLoss = (currentPrice - openFill.buyPrice) * openFill.quantity;
+          openFill.closed = true;
+          openFill.pnlUsd = realizedLoss;
+          openFill.closedAt = now;
+          pnlUsd += realizedLoss;
+          grid.stats.totalPnlUsd += realizedLoss;
+          grid.stats.todayPnlUsd += realizedLoss;
+          grid.allocation += realizedLoss;
+          console.error(chalk9.red(
+            `  [grid] STOP-LOSS ${grid.token}: buy $${openFill.buyPrice.toFixed(2)} \u2192 close $${currentPrice.toFixed(2)} = $${realizedLoss.toFixed(2)}`
+          ));
+        }
+      }
+    }
     const pruneThreshold = now - 24 * 60 * 60 * 1e3;
     grid.openFills = grid.openFills.filter((f) => !f.closed || f.closedAt > pruneThreshold);
     return { fills, roundTrips, pnlUsd };
@@ -5114,7 +5205,15 @@ var DEFAULT_GRID_CONFIG = {
   // 12h
   tokenSplit: { bitcoin: 0.45, ethereum: 0.3, solana: 0.25 },
   minProfitPerFillUsd: 0.5,
-  pauseThresholdPct: 0.2
+  pauseThresholdPct: 0.2,
+  // post leverage-fix calibration: fires at ~4% adverse move on 5x (real dollar terms); old 0.40 required ~8% which essentially never fired before liquidation
+  unpauseRecoveryPct: 0.05,
+  // hysteresis: resume when pool recovers to within 5% of initial (half of pause threshold to avoid ping-pong)
+  maintenanceMarginPct: 0.02,
+  maxOpenNotionalMultiple: 2,
+  downtrendBlockPct: 0.1,
+  stopLossPct: 0.1
+  // empirical Nov-May: 10% saves the strategy (-4%); 30% lets liquidations through (-37%)
 };
 
 // src/grid/hedge.ts
@@ -5128,7 +5227,7 @@ var ADJUSTMENT_THRESHOLD = 0.1;
 var HEDGE_STATE_PATH = join2(homedir2(), ".sherwood", "grid", "hedge.json");
 var GridHedgeManager = class {
   state = null;
-  async load() {
+  async load(now = Date.now()) {
     if (this.state) return this.state;
     try {
       const raw = await readFile2(HEDGE_STATE_PATH, "utf-8");
@@ -5138,14 +5237,14 @@ var GridHedgeManager = class {
         positions: [],
         totalRealizedPnl: 0,
         todayRealizedPnl: 0,
-        lastDailyReset: Date.now()
+        lastDailyReset: now
       };
     }
-    const todayMidnight = /* @__PURE__ */ new Date();
+    const todayMidnight = new Date(now);
     todayMidnight.setUTCHours(0, 0, 0, 0);
     if (this.state.lastDailyReset < todayMidnight.getTime()) {
       this.state.todayRealizedPnl = 0;
-      this.state.lastDailyReset = Date.now();
+      this.state.lastDailyReset = now;
     }
     return this.state;
   }
@@ -5163,8 +5262,8 @@ var GridHedgeManager = class {
    * @param openFills - Per-token open fill exposure from the grid portfolio
    * @param prices - Current mark prices per token
    */
-  async tick(openFills, prices) {
-    const state = await this.load();
+  async tick(openFills, prices, now = Date.now()) {
+    const state = await this.load(now);
     let adjustments = 0;
     let unrealizedPnl = 0;
     for (const fill of openFills) {
@@ -5357,6 +5456,13 @@ var HYPERLIQUID_GRID_STRATEGY_ABI = [
     inputs: [{ name: "data", type: "bytes" }],
     outputs: [],
     stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "maxOrdersPerTick",
+    inputs: [],
+    outputs: [{ type: "uint32" }],
+    stateMutability: "view"
   }
 ];
 
@@ -5366,6 +5472,13 @@ var UINT64_MAX = 18446744073709551615n;
 var ACTION_PLACE_GRID = 1;
 var ACTION_CANCEL_ALL = 2;
 var ACTION_CANCEL_AND_PLACE = 3;
+function chunkArray(arr, size2) {
+  if (size2 <= 0) throw new Error(`chunk size must be > 0 (got ${size2})`);
+  if (arr.length === 0) return [];
+  const out = [];
+  for (let i = 0; i < arr.length; i += size2) out.push(arr.slice(i, i + size2));
+  return out;
+}
 var GRID_ORDER_COMPONENTS = [
   { name: "assetIndex", type: "uint32" },
   { name: "isBuy", type: "bool" },
@@ -5379,9 +5492,24 @@ var OnchainGridExecutor = class {
   placedCloids = /* @__PURE__ */ new Map();
   meta = null;
   busy = false;
+  /** On-chain `maxOrdersPerTick`; cached at load(). Used to chunk batches so
+   *  the strategy never reverts with TooManyOrders(actual, max). */
+  maxOrdersPerTick = null;
   constructor(cfg) {
     this.cfg = cfg;
   }
+  /** Read the strategy's per-call order cap and cache it. */
+  async fetchMaxOrdersPerTick() {
+    if (this.maxOrdersPerTick !== null) return this.maxOrdersPerTick;
+    const pub = getPublicClient();
+    const value = await pub.readContract({
+      address: this.cfg.strategyAddress,
+      abi: HYPERLIQUID_GRID_STRATEGY_ABI,
+      functionName: "maxOrdersPerTick"
+    });
+    this.maxOrdersPerTick = Number(value);
+    return this.maxOrdersPerTick;
+  }
   /** Load persisted state. Call once before the first execute(). */
   async load() {
     try {
@@ -5404,6 +5532,7 @@ var OnchainGridExecutor = class {
       }
     }
     if (!this.meta) this.meta = await hlGetMeta();
+    await this.fetchMaxOrdersPerTick();
   }
   /**
    * Atomic save: write to .tmp, then POSIX-rename. A crash mid-write leaves
@@ -5469,8 +5598,8 @@ var OnchainGridExecutor = class {
         const wantPlace = orders.length > 0;
         try {
           if (wantCancel && wantPlace) {
-            const tx = await this.cancelAndPlace(token, assetIndex, orders, meta);
-            txs.push(tx);
+            const txArr = await this.cancelAndPlace(token, assetIndex, orders, meta);
+            txs.push(...txArr);
             cancelled += 1;
             placed += orders.length;
           } else if (wantCancel) {
@@ -5478,8 +5607,8 @@ var OnchainGridExecutor = class {
             txs.push(tx);
             cancelled += 1;
           } else if (wantPlace) {
-            const tx = await this.placeGrid(token, assetIndex, orders, meta);
-            txs.push(tx);
+            const txArr = await this.placeGrid(token, assetIndex, orders, meta);
+            txs.push(...txArr);
             placed += orders.length;
           }
           await this.save();
@@ -5523,16 +5652,31 @@ var OnchainGridExecutor = class {
     });
     return { encoded, cloids };
   }
+  /**
+   * Place orders, chunking into batches of ≤ maxOrdersPerTick per tx.
+   * Each chunk uses its own nonce so CLOIDs stay unique across chunks.
+   * placedCloids is committed once after the last chunk lands; if any
+   * chunk reverts, the partial cloids stay tracked via the per-chunk save.
+   */
   async placeGrid(token, assetIndex, orders, meta) {
-    const nonce = this.bumpNonce(token);
-    const { encoded, cloids } = this.encodeOrders(assetIndex, orders, meta, nonce);
-    const data = encodeAbiParameters11(
-      [{ type: "uint8" }, { type: "tuple[]", components: [...GRID_ORDER_COMPONENTS] }],
-      [ACTION_PLACE_GRID, encoded]
-    );
-    const tx = await this.send(data);
-    this.placedCloids.set(token, cloids);
-    return tx;
+    const max = await this.fetchMaxOrdersPerTick();
+    const chunks = chunkArray(orders, max);
+    const txs = [];
+    const allCloids = [...this.placedCloids.get(token) ?? []];
+    for (const chunk of chunks) {
+      const nonce = this.bumpNonce(token);
+      const { encoded, cloids } = this.encodeOrders(assetIndex, chunk, meta, nonce);
+      const data = encodeAbiParameters11(
+        [{ type: "uint8" }, { type: "tuple[]", components: [...GRID_ORDER_COMPONENTS] }],
+        [ACTION_PLACE_GRID, encoded]
+      );
+      const tx = await this.send(data);
+      txs.push(tx);
+      allCloids.push(...cloids);
+      this.placedCloids.set(token, allCloids);
+      await this.save();
+    }
+    return txs;
   }
   async cancelAll(token, assetIndex) {
     const cloids = this.placedCloids.get(token) ?? [];
@@ -5549,22 +5693,48 @@ var OnchainGridExecutor = class {
     this.bumpNonce(token);
     return tx;
   }
+  /**
+   * Atomic cancel-old + place-new on rebalance. When `orders` exceeds
+   * maxOrdersPerTick, the first chunk uses ACTION_CANCEL_AND_PLACE (so the
+   * old orders are cleared in the same tx as the first wave of new orders);
+   * subsequent chunks use ACTION_PLACE_GRID. Atomicity holds for chunk #1;
+   * after that there's a brief window where some new orders are live before
+   * the rest are placed — acceptable for a 60s rebuild cycle.
+   */
   async cancelAndPlace(token, assetIndex, orders, meta) {
+    const max = await this.fetchMaxOrdersPerTick();
+    const chunks = chunkArray(orders, max);
     const oldCloids = this.placedCloids.get(token) ?? [];
-    const newNonce = this.bumpNonce(token);
-    const { encoded, cloids: newCloids } = this.encodeOrders(assetIndex, orders, meta, newNonce);
-    const data = encodeAbiParameters11(
-      [
-        { type: "uint8" },
-        { type: "uint32" },
-        { type: "uint128[]" },
-        { type: "tuple[]", components: [...GRID_ORDER_COMPONENTS] }
-      ],
-      [ACTION_CANCEL_AND_PLACE, assetIndex, oldCloids, encoded]
-    );
-    const tx = await this.send(data);
-    this.placedCloids.set(token, newCloids);
-    return tx;
+    const txs = [];
+    const allNewCloids = [];
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const newNonce = this.bumpNonce(token);
+      const { encoded, cloids } = this.encodeOrders(assetIndex, chunk, meta, newNonce);
+      let data;
+      if (i === 0) {
+        data = encodeAbiParameters11(
+          [
+            { type: "uint8" },
+            { type: "uint32" },
+            { type: "uint128[]" },
+            { type: "tuple[]", components: [...GRID_ORDER_COMPONENTS] }
+          ],
+          [ACTION_CANCEL_AND_PLACE, assetIndex, oldCloids, encoded]
+        );
+      } else {
+        data = encodeAbiParameters11(
+          [{ type: "uint8" }, { type: "tuple[]", components: [...GRID_ORDER_COMPONENTS] }],
+          [ACTION_PLACE_GRID, encoded]
+        );
+      }
+      const tx = await this.send(data);
+      txs.push(tx);
+      allNewCloids.push(...cloids);
+      this.placedCloids.set(token, [...allNewCloids]);
+      await this.save();
+    }
+    return txs;
   }
   /**
    * Submit and wait for receipt. Throwing here surfaces to the per-token
@@ -5737,15 +5907,862 @@ var GridLoop = class {
   }
 };
 
+// src/grid/backtest.ts
+import { writeFile as writeFile5, mkdir as mkdir6 } from "fs/promises";
+import { join as join6, dirname as dirname4 } from "path";
+import { homedir as homedir6 } from "os";
+import { createHash } from "crypto";
+
+// src/grid/backtest-portfolio.ts
+var BacktestPortfolio = class extends GridPortfolio {
+  nowProvider;
+  inMemoryState = null;
+  constructor(nowProvider) {
+    super();
+    this.nowProvider = nowProvider;
+  }
+  /** Override: never read from disk. Returns the in-memory state. */
+  async load() {
+    return this.inMemoryState;
+  }
+  /** Override: never write to disk. Stores the state in memory. */
+  async save(state) {
+    this.inMemoryState = state;
+  }
+  /** Override: read in-memory state instead of parent's private field. */
+  getState() {
+    return this.inMemoryState;
+  }
+  /** Override: use the injected clock instead of Date.now(). */
+  resetDailyStats(state) {
+    return super.resetDailyStats(state, this.nowProvider());
+  }
+};
+
+// src/grid/historical-data-loader.ts
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir5 } from "fs/promises";
+import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
+var BINANCE_BASE = "https://api.binance.com/api/v3/klines";
+var DEFAULT_CACHE_DIR = join5(homedir5(), ".sherwood", "grid", "backtest-cache");
+var FOUR_HOURS_MS = 4 * 60 * 60 * 1e3;
+var ONE_MIN_MS = 60 * 1e3;
+var ATR_PERIOD = 14;
+var ATR_WARMUP_MS = ATR_PERIOD * FOUR_HOURS_MS;
+var MAX_BARS_PER_REQUEST = 1e3;
+var COIN_TO_BINANCE_SYMBOL = {
+  BTC: "BTCUSDT",
+  ETH: "ETHUSDT",
+  SOL: "SOLUSDT",
+  ARB: "ARBUSDT",
+  LINK: "LINKUSDT",
+  AAVE: "AAVEUSDT",
+  UNI: "UNIUSDT",
+  DOGE: "DOGEUSDT"
+};
+var HistoricalDataLoader = class {
+  cacheDir;
+  noCache;
+  fetchImpl;
+  constructor(opts = {}) {
+    this.cacheDir = opts.cacheDir ?? DEFAULT_CACHE_DIR;
+    this.noCache = opts.noCache ?? false;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+  }
+  /**
+   * Load 1-minute bars and an aligned ATR(14) series for `coinTokenId`
+   * (CoinGecko ID; resolved internally to HL coin symbol).
+   *
+   * The 4-hour series is fetched with ATR_WARMUP_MS extra prefix so ATR
+   * is well-defined at fromMs.
+   */
+  async load(coinTokenId, fromMs, toMs) {
+    const coin = TOKEN_TO_COIN[coinTokenId];
+    if (!coin) throw new Error(`Unknown token: ${coinTokenId}`);
+    const minutes = await this.loadInterval(coin, "1m", fromMs, toMs);
+    if (minutes.length === 0) {
+      throw new Error(`no data for ${coinTokenId} in window \u2014 check symbol mapping or date range`);
+    }
+    const fourHour = await this.loadInterval(coin, "4h", fromMs - ATR_WARMUP_MS, toMs);
+    const atrSeries = computeAtrSeries(fourHour);
+    return { minutes, fourHour, atrSeries };
+  }
+  /** Fetch + cache one interval. Public for unit testing. */
+  async loadInterval(coin, interval, fromMs, toMs) {
+    if (!this.noCache) {
+      const cached = await this.tryReadCache(coin, interval, fromMs, toMs);
+      if (cached) return cached;
+    }
+    const fresh = await this.fetchPaginated(coin, interval, fromMs, toMs);
+    if (!this.noCache && fresh.length > 0) {
+      await this.writeCache(coin, interval, fromMs, toMs, fresh);
+    }
+    return fresh;
+  }
+  async tryReadCache(coin, interval, fromMs, toMs) {
+    const path = this.cachePath(coin, interval, fromMs, toMs);
+    try {
+      const raw = await readFile4(path, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed.bars)) return null;
+      return parsed.bars;
+    } catch {
+      return null;
+    }
+  }
+  async writeCache(coin, interval, fromMs, toMs, bars) {
+    await mkdir5(this.cacheDir, { recursive: true });
+    const path = this.cachePath(coin, interval, fromMs, toMs);
+    const body = JSON.stringify({
+      coin,
+      interval,
+      fetchedAt: Date.now(),
+      bars
+    });
+    await writeFile4(path, body, "utf-8");
+  }
+  cachePath(coin, interval, fromMs, toMs) {
+    return join5(this.cacheDir, `${coin}-${interval}-${fromMs}-${toMs}.json`);
+  }
+  /** Paginate Binance klines until we cover [fromMs, toMs]. Dedup on merge. */
+  async fetchPaginated(coin, interval, fromMs, toMs) {
+    const intervalMs = interval === "1m" ? ONE_MIN_MS : FOUR_HOURS_MS;
+    const pageSpanMs = MAX_BARS_PER_REQUEST * intervalMs;
+    const seen = /* @__PURE__ */ new Set();
+    const all = [];
+    let cursor = fromMs;
+    while (cursor < toMs) {
+      const pageEnd = Math.min(cursor + pageSpanMs, toMs);
+      const page = await this.fetchPageWithRetry(coin, interval, cursor, pageEnd);
+      if (page.length === 0) break;
+      for (const bar of page) {
+        if (!seen.has(bar.t)) {
+          seen.add(bar.t);
+          all.push(bar);
+        }
+      }
+      const last = page[page.length - 1];
+      const next = last.t + intervalMs;
+      if (next <= cursor) break;
+      cursor = next;
+    }
+    all.sort((a, b) => a.t - b.t);
+    return all;
+  }
+  async fetchPageWithRetry(coin, interval, startTime, endTime) {
+    const delays = [1e3, 2e3, 4e3];
+    let lastErr = null;
+    for (let attempt = 0; attempt < delays.length + 1; attempt++) {
+      try {
+        return await this.fetchPage(coin, interval, startTime, endTime);
+      } catch (err) {
+        lastErr = err;
+        if (attempt < delays.length) {
+          await sleep(delays[attempt]);
+        }
+      }
+    }
+    throw lastErr ?? new Error("fetchPage failed");
+  }
+  async fetchPage(coin, interval, startTime, endTime) {
+    const symbol = COIN_TO_BINANCE_SYMBOL[coin];
+    if (!symbol) throw new Error(`No Binance symbol for coin: ${coin}`);
+    const url = `${BINANCE_BASE}?symbol=${symbol}&interval=${interval}&startTime=${startTime}&endTime=${endTime}&limit=${MAX_BARS_PER_REQUEST}`;
+    const res = await this.fetchImpl(url);
+    if (!res.ok) throw new Error(`Binance ${res.status}: ${await res.text()}`);
+    const raw = await res.json();
+    if (!Array.isArray(raw)) return [];
+    return raw.map((c) => ({
+      t: c[0],
+      o: Number(c[1]),
+      h: Number(c[2]),
+      l: Number(c[3]),
+      c: Number(c[4]),
+      v: Number(c[5])
+    })).filter(
+      (b) => Number.isFinite(b.o) && Number.isFinite(b.h) && Number.isFinite(b.l) && Number.isFinite(b.c)
+    );
+  }
+};
+function computeAtrSeries(fourHourBars) {
+  if (fourHourBars.length < ATR_PERIOD) return [];
+  const candles = fourHourBars.map((b) => ({
+    timestamp: b.t,
+    open: b.o,
+    high: b.h,
+    low: b.l,
+    close: b.c,
+    volume: b.v
+  }));
+  const atrArr = calculateATR(candles, ATR_PERIOD);
+  const out = [];
+  for (let i = 0; i < atrArr.length; i++) {
+    if (Number.isFinite(atrArr[i])) {
+      out.push({ ts: fourHourBars[i].t, atr: atrArr[i] });
+    }
+  }
+  return out;
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/grid/backtest-hedge.ts
+var BacktestHedgeManager = class extends GridHedgeManager {
+  nowProvider;
+  inMemoryState = null;
+  constructor(nowProvider) {
+    super();
+    this.nowProvider = nowProvider;
+  }
+  async load(_now) {
+    if (this.inMemoryState) {
+      const now2 = this.nowProvider();
+      const todayMidnight = new Date(now2);
+      todayMidnight.setUTCHours(0, 0, 0, 0);
+      if (this.inMemoryState.lastDailyReset < todayMidnight.getTime()) {
+        this.inMemoryState.todayRealizedPnl = 0;
+        this.inMemoryState.lastDailyReset = now2;
+      }
+      this.state = this.inMemoryState;
+      return this.inMemoryState;
+    }
+    const now = this.nowProvider();
+    this.inMemoryState = {
+      positions: [],
+      totalRealizedPnl: 0,
+      todayRealizedPnl: 0,
+      lastDailyReset: now
+    };
+    this.state = this.inMemoryState;
+    return this.inMemoryState;
+  }
+  async save() {
+  }
+};
+
+// src/grid/backtest.ts
+var DEFAULT_OUT_DIR = join6(homedir6(), ".sherwood", "grid", "backtests");
+function shortHash(input2) {
+  const h = createHash("sha256").update(JSON.stringify(input2)).digest("hex");
+  return h.slice(0, 8);
+}
+function computeDrawdown(curve) {
+  if (curve.length === 0) {
+    return { maxUsd: 0, maxPct: 0, peakAt: 0, troughAt: 0 };
+  }
+  const equityAt = (p) => p.totalAllocation + p.totalPnl;
+  let peak = equityAt(curve[0]);
+  let peakAt = curve[0].t;
+  let maxDrop = 0;
+  let dropPeakAt = peakAt;
+  let dropTroughAt = peakAt;
+  for (const point of curve) {
+    const eq = equityAt(point);
+    if (eq > peak) {
+      peak = eq;
+      peakAt = point.t;
+    }
+    const drop = peak - eq;
+    if (drop > maxDrop) {
+      maxDrop = drop;
+      dropPeakAt = peakAt;
+      dropTroughAt = point.t;
+    }
+  }
+  const peakPoint = curve.find((p) => p.t === dropPeakAt);
+  const peakValue = peakPoint ? equityAt(peakPoint) : 0;
+  return {
+    maxUsd: maxDrop,
+    maxPct: peakValue > 0 ? maxDrop / peakValue : 0,
+    peakAt: dropPeakAt,
+    troughAt: dropTroughAt
+  };
+}
+function isoToYmdHms(ms) {
+  const d = new Date(ms);
+  const pad = (n) => n.toString().padStart(2, "0");
+  return `${d.getUTCFullYear()}${pad(d.getUTCMonth() + 1)}${pad(d.getUTCDate())}-${pad(d.getUTCHours())}${pad(d.getUTCMinutes())}${pad(d.getUTCSeconds())}`;
+}
+function makeRunId(fromMs, toMs, config) {
+  return `bt-${isoToYmdHms(Date.now())}-${shortHash({ fromMs, toMs, config })}`;
+}
+async function runBacktest(opts) {
+  const startedAt = Date.now();
+  if (opts.fromMs >= opts.toMs) throw new Error("--from must be before --to");
+  const FIFTY_SIX_HOURS = 56 * 60 * 60 * 1e3;
+  if (opts.toMs - opts.fromMs < FIFTY_SIX_HOURS) {
+    throw new Error("window too short \u2014 need \u2265 56h for ATR(14) warmup");
+  }
+  const splitSum = Object.values(opts.config.tokenSplit).reduce((a, b) => a + b, 0);
+  if (Math.abs(splitSum - 1) > 1e-6) {
+    throw new Error(`tokenSplit must sum to 1.0, got ${splitSum.toFixed(6)}`);
+  }
+  const loader = opts.loader ?? new HistoricalDataLoader({ noCache: opts.noCache });
+  const snapshotEvery = opts.snapshotEveryMinutes ?? 60;
+  const seriesByToken = {};
+  await Promise.all(opts.config.tokens.map(async (token) => {
+    seriesByToken[token] = await loader.load(token, opts.fromMs, opts.toMs);
+  }));
+  const minuteSets = opts.config.tokens.map((t) => new Set(seriesByToken[t].minutes.map((b) => b.t)));
+  const masterMinutes = seriesByToken[opts.config.tokens[0]].minutes;
+  const sharedTimestamps = [];
+  let skippedSteps = 0;
+  for (const bar of masterMinutes) {
+    if (bar.t < opts.fromMs || bar.t >= opts.toMs) continue;
+    if (minuteSets.every((s) => s.has(bar.t))) {
+      sharedTimestamps.push(bar.t);
+    } else {
+      skippedSteps++;
+    }
+  }
+  if (sharedTimestamps.length === 0) {
+    throw new Error("no overlapping bars across requested tokens");
+  }
+  const barIndex = {};
+  for (const token of opts.config.tokens) {
+    const m = /* @__PURE__ */ new Map();
+    for (const bar of seriesByToken[token].minutes) m.set(bar.t, bar);
+    barIndex[token] = m;
+  }
+  let currentT = sharedTimestamps[0];
+  const nowProvider = () => currentT;
+  const candleFetcher = async (tokenId, interval, lookbackMs) => {
+    if (interval !== "4h") return null;
+    const series = seriesByToken[tokenId];
+    if (!series) return null;
+    const cutoff = currentT - lookbackMs;
+    return series.fourHour.filter((b) => b.t <= currentT && b.t >= cutoff).map((b) => ({
+      timestamp: b.t,
+      open: b.o,
+      high: b.h,
+      low: b.l,
+      close: b.c,
+      volume: b.v
+    }));
+  };
+  const portfolio = new BacktestPortfolio(nowProvider);
+  const manager = new GridManager(opts.config, candleFetcher, void 0, void 0, portfolio, nowProvider);
+  await manager.init(opts.capital);
+  const initialAllocations = {};
+  {
+    const initState = portfolio.getState();
+    if (initState) {
+      for (const grid of initState.grids) {
+        initialAllocations[grid.token] = grid.allocation;
+      }
+    }
+  }
+  const feeBps = opts.feeBps ?? 5;
+  const notionalPerFillByToken = {};
+  for (const token of opts.config.tokens) {
+    const tokenInitial = initialAllocations[token] ?? 0;
+    notionalPerFillByToken[token] = tokenInitial * opts.config.leverage / opts.config.levelsPerSide;
+  }
+  const feesByToken = {};
+  for (const token of opts.config.tokens) feesByToken[token] = 0;
+  const lastSeenFills = {};
+  for (const token of opts.config.tokens) lastSeenFills[token] = 0;
+  const hedgeEnabled = opts.hedge ?? true;
+  const hedge = new BacktestHedgeManager(nowProvider);
+  let hedgeAdjustments = 0;
+  let hedgeRealized = 0;
+  let hedgeUnrealized = 0;
+  let totalRebuilds = 0;
+  const lastRebalanceAt = {};
+  for (const t of opts.config.tokens) lastRebalanceAt[t] = 0;
+  const liquidatedTokens = /* @__PURE__ */ new Set();
+  const liquidationEvents = [];
+  let haltedAt = null;
+  const equityCurve = [];
+  let pausedSteps = 0;
+  const originalConsoleError = console.error;
+  if (!opts.verbose) {
+    console.error = () => {
+    };
+  }
+  try {
+    let cycleCount = 0;
+    const totalSteps = sharedTimestamps.length;
+    const decileSize = Math.max(1, Math.floor(totalSteps / 10));
+    for (const t of sharedTimestamps) {
+      currentT = t;
+      const passAPrices = {};
+      const passBPrices = {};
+      for (const token of opts.config.tokens) {
+        const bar = barIndex[token].get(t);
+        const isGreen = bar.c >= bar.o;
+        passAPrices[token] = isGreen ? bar.l : bar.h;
+        passBPrices[token] = isGreen ? bar.h : bar.l;
+      }
+      const r1 = await manager.tick(passAPrices);
+      const r2 = await manager.tick(passBPrices);
+      const stateAfter = portfolio.getState();
+      if (stateAfter) {
+        for (const grid of stateAfter.grids) {
+          if (grid.stats.lastRebalanceAt > lastRebalanceAt[grid.token]) {
+            totalRebuilds++;
+            lastRebalanceAt[grid.token] = grid.stats.lastRebalanceAt;
+          }
+        }
+      }
+      if (r1.paused || r2.paused) pausedSteps++;
+      if (hedgeEnabled) {
+        const hedgePrices = {};
+        for (const token of opts.config.tokens) {
+          const bar = barIndex[token].get(t);
+          hedgePrices[token] = bar.c;
+        }
+        const exposure = manager.getOpenFillExposure();
+        const hedgeResult = await hedge.tick(exposure, hedgePrices, t);
+        hedgeAdjustments += hedgeResult.adjustments;
+        hedgeRealized = hedgeResult.totalRealizedPnl;
+        hedgeUnrealized = hedgeResult.unrealizedPnl;
+      }
+      if (stateAfter) {
+        for (const grid of stateAfter.grids) {
+          const newFills = grid.stats.totalFills - lastSeenFills[grid.token];
+          if (newFills > 0) {
+            feesByToken[grid.token] += newFills * (notionalPerFillByToken[grid.token] ?? 0) * feeBps / 1e4;
+            lastSeenFills[grid.token] = grid.stats.totalFills;
+          }
+        }
+      }
+      const stateLiq = portfolio.getState();
+      if (stateLiq && haltedAt === null) {
+        const lev = opts.config.leverage;
+        const maint = opts.config.maintenanceMarginPct;
+        const liquidationCoefficient = 1 - lev * maint;
+        for (const grid of stateLiq.grids) {
+          if (liquidatedTokens.has(grid.token)) continue;
+          const close = barIndex[grid.token]?.get(t)?.c;
+          if (close === void 0) continue;
+          let unrealized = 0;
+          for (const f of grid.openFills) {
+            if (f.closed) continue;
+            unrealized += (close - f.buyPrice) * f.quantity;
+          }
+          const tokenAlloc = initialAllocations[grid.token] ?? 0;
+          const threshold = -tokenAlloc * liquidationCoefficient;
+          if (tokenAlloc > 0 && unrealized <= threshold) {
+            grid.stats.totalPnlUsd += unrealized;
+            grid.stats.todayPnlUsd += unrealized;
+            grid.allocation += unrealized;
+            for (const f of grid.openFills) {
+              if (!f.closed) {
+                f.closed = true;
+                f.closedAt = t;
+                f.pnlUsd = (close - f.buyPrice) * f.quantity;
+              }
+            }
+            grid.levels = [];
+            liquidatedTokens.add(grid.token);
+            liquidationEvents.push({
+              token: grid.token,
+              timestamp: t,
+              tokenAllocation: tokenAlloc,
+              unrealizedPnlAtLiquidation: unrealized,
+              thresholdUsd: threshold
+            });
+            process.stderr.write(
+              `  [backtest] LIQUIDATED ${grid.token} at t=${new Date(t).toISOString()}: unrealized=$${unrealized.toFixed(0)} (threshold=$${threshold.toFixed(0)})
+`
+            );
+          }
+        }
+        if (liquidatedTokens.size === opts.config.tokens.length) {
+          haltedAt = t;
+          process.stderr.write(`  [backtest] All tokens liquidated; halting run at t=${new Date(t).toISOString()}
+`);
+        }
+      }
+      if (haltedAt !== null) {
+        const sFinal = portfolio.getState();
+        if (sFinal) {
+          const aggFinal = portfolio.aggregateStats(sFinal);
+          const ofcFinal = sFinal.grids.reduce((sum, g) => sum + g.openFills.filter((f) => !f.closed).length, 0);
+          const runningFeesFinal = Object.values(feesByToken).reduce((a, b) => a + b, 0);
+          equityCurve.push({
+            t,
+            totalAllocation: sFinal.totalAllocation,
+            totalPnl: aggFinal.totalPnlUsd - runningFeesFinal + hedgeRealized + hedgeUnrealized,
+            totalRoundTrips: aggFinal.totalRoundTrips,
+            openFillCount: ofcFinal,
+            paused: sFinal.paused
+          });
+        }
+        break;
+      }
+      cycleCount++;
+      if (cycleCount % snapshotEvery === 0 || cycleCount === totalSteps) {
+        const s = portfolio.getState();
+        if (s) {
+          const agg2 = portfolio.aggregateStats(s);
+          const openFillCount = s.grids.reduce(
+            (sum, g) => sum + g.openFills.filter((f) => !f.closed).length,
+            0
+          );
+          let unrealizedPnl = 0;
+          for (const grid of s.grids) {
+            const close = barIndex[grid.token]?.get(t)?.c;
+            if (close === void 0) continue;
+            for (const f of grid.openFills) {
+              if (f.closed) continue;
+              unrealizedPnl += (close - f.buyPrice) * f.quantity;
+            }
+          }
+          const runningFees = Object.values(feesByToken).reduce((a, b) => a + b, 0);
+          equityCurve.push({
+            t,
+            totalAllocation: s.totalAllocation,
+            totalPnl: agg2.totalPnlUsd + unrealizedPnl - runningFees + hedgeRealized + hedgeUnrealized,
+            totalRoundTrips: agg2.totalRoundTrips,
+            openFillCount,
+            paused: s.paused
+          });
+        }
+      }
+      if (cycleCount % decileSize === 0) {
+        if (opts.verbose) {
+          originalConsoleError(`  [backtest] ${Math.round(cycleCount / totalSteps * 100)}%  step ${cycleCount}/${totalSteps}`);
+        } else {
+          process.stderr.write(`  [backtest] ${Math.round(cycleCount / totalSteps * 100)}%  step ${cycleCount}/${totalSteps}
+`);
+        }
+      }
+    }
+  } finally {
+    console.error = originalConsoleError;
+  }
+  const finalState = portfolio.getState();
+  const agg = portfolio.aggregateStats(finalState);
+  const finishedAt = Date.now();
+  const runId = makeRunId(opts.fromMs, opts.toMs, opts.config);
+  const initialPerToken = {};
+  for (const token of opts.config.tokens) {
+    initialPerToken[token] = opts.capital * (opts.config.tokenSplit[token] ?? 0);
+  }
+  const totalFeesUsd = Object.values(feesByToken).reduce((a, b) => a + b, 0);
+  const totalFills = finalState.grids.reduce((s, g) => s + g.stats.totalFills, 0);
+  const avgFeePerFill = totalFills > 0 ? totalFeesUsd / totalFills : 0;
+  const grossPnl = agg.totalPnlUsd;
+  const netPnl = grossPnl - totalFeesUsd;
+  const hedgeStatus = hedgeEnabled ? hedge.getStatus() : null;
+  const hedgePnl = hedgeRealized + hedgeUnrealized;
+  const finalNetPnl = netPnl + hedgePnl;
+  const perToken = finalState.grids.map((g) => ({
+    token: g.token,
+    allocation: { initial: initialPerToken[g.token] ?? 0, final: g.allocation },
+    roundTrips: g.stats.totalRoundTrips,
+    fills: g.stats.totalFills,
+    pnlUsd: g.stats.totalPnlUsd,
+    rebuilds: 0
+  }));
+  const result = {
+    runId,
+    startedAt,
+    finishedAt,
+    durationMs: finishedAt - startedAt,
+    window: {
+      fromMs: opts.fromMs,
+      toMs: opts.toMs,
+      fromIso: new Date(opts.fromMs).toISOString(),
+      toIso: new Date(opts.toMs).toISOString(),
+      days: (opts.toMs - opts.fromMs) / (24 * 60 * 60 * 1e3)
+    },
+    config: opts.config,
+    capital: {
+      initialUsd: opts.capital,
+      finalUsd: opts.capital + finalNetPnl,
+      pnlUsd: finalNetPnl,
+      pnlPct: finalNetPnl / opts.capital,
+      grossPnlUsd: grossPnl
+    },
+    fees: {
+      bps: feeBps,
+      totalUsd: totalFeesUsd,
+      perFill: avgFeePerFill
+    },
+    hedge: {
+      enabled: hedgeEnabled,
+      realizedPnlUsd: hedgeRealized,
+      unrealizedPnlUsd: hedgeUnrealized,
+      adjustments: hedgeAdjustments,
+      finalOpenPositions: hedgeStatus ? hedgeStatus.positions.length : 0
+    },
+    liquidations: {
+      events: liquidationEvents,
+      haltedAt
+    },
+    totals: {
+      roundTrips: agg.totalRoundTrips,
+      fills: finalState.grids.reduce((s, g) => s + g.stats.totalFills, 0),
+      rebuilds: totalRebuilds,
+      pausedSteps,
+      skippedSteps,
+      totalSteps: sharedTimestamps.length
+    },
+    perToken,
+    drawdown: computeDrawdown(equityCurve),
+    equityCurve
+  };
+  if (opts.outPath !== "") {
+    const outPath = opts.outPath ?? join6(DEFAULT_OUT_DIR, `${runId}.json`);
+    await mkdir6(dirname4(outPath), { recursive: true });
+    await writeFile5(outPath, JSON.stringify(result, null, 2), "utf-8");
+  }
+  return result;
+}
+
+// src/grid/sweep.ts
+import { writeFile as writeFile6, mkdir as mkdir7 } from "fs/promises";
+import { join as join7 } from "path";
+import { homedir as homedir7 } from "os";
+import { createHash as createHash2 } from "crypto";
+var DEFAULT_SWEEP_DIR = join7(homedir7(), ".sherwood", "grid", "sweeps");
+function expandSweep(sweep, base2) {
+  const fields = ["leverage", "levelsPerSide", "atrMultiplier", "rebalanceDriftPct"];
+  const valueLists = {
+    leverage: sweep.leverage && sweep.leverage.length > 0 ? sweep.leverage : [base2.leverage],
+    levelsPerSide: sweep.levelsPerSide && sweep.levelsPerSide.length > 0 ? sweep.levelsPerSide : [base2.levelsPerSide],
+    atrMultiplier: sweep.atrMultiplier && sweep.atrMultiplier.length > 0 ? sweep.atrMultiplier : [base2.atrMultiplier],
+    rebalanceDriftPct: sweep.rebalanceDriftPct && sweep.rebalanceDriftPct.length > 0 ? sweep.rebalanceDriftPct : [base2.rebalanceDriftPct]
+  };
+  let combos = [{}];
+  for (const field of fields) {
+    const next = [];
+    for (const combo of combos) {
+      for (const value of valueLists[field]) {
+        next.push({ ...combo, [field]: value });
+      }
+    }
+    combos = next;
+  }
+  return combos;
+}
+function makeSweepId(opts) {
+  const d = /* @__PURE__ */ new Date();
+  const pad = (n) => n.toString().padStart(2, "0");
+  const stamp = `${d.getUTCFullYear()}${pad(d.getUTCMonth() + 1)}${pad(d.getUTCDate())}-${pad(d.getUTCHours())}${pad(d.getUTCMinutes())}${pad(d.getUTCSeconds())}`;
+  const hash = createHash2("sha256").update(JSON.stringify({
+    fromMs: opts.fromMs,
+    toMs: opts.toMs,
+    sweep: opts.sweep,
+    tokens: opts.tokens
+  })).digest("hex").slice(0, 8);
+  return `sw-${stamp}-${hash}`;
+}
+async function runSweep(opts) {
+  const startedAt = Date.now();
+  const sweepId = makeSweepId(opts);
+  const outDir = opts.outDir ?? DEFAULT_SWEEP_DIR;
+  const sweepDir = join7(outDir, sweepId);
+  let tokenSplit;
+  if (opts.tokenSplit) {
+    tokenSplit = opts.tokenSplit;
+  } else {
+    const weight = 1 / opts.tokens.length;
+    tokenSplit = {};
+    for (const t of opts.tokens) tokenSplit[t] = weight;
+  }
+  const base2 = {
+    ...DEFAULT_GRID_CONFIG,
+    ...opts.baseConfig,
+    tokens: opts.tokens,
+    tokenSplit
+  };
+  const combos = expandSweep(opts.sweep, base2);
+  if (combos.length === 0) throw new Error("sweep produced no combinations");
+  const loader = new HistoricalDataLoader({ noCache: opts.noCache });
+  if (opts.verbose !== false) {
+    process.stderr.write(`  [sweep] ${sweepId}: running ${combos.length} backtests\u2026
+`);
+  }
+  await mkdir7(sweepDir, { recursive: true });
+  const runs = [];
+  for (let i = 0; i < combos.length; i++) {
+    const combo = combos[i];
+    const config = { ...base2, ...combo };
+    const runOutPath = join7(sweepDir, `run-${i.toString().padStart(3, "0")}.json`);
+    if (opts.verbose !== false) {
+      process.stderr.write(`  [sweep] [${i + 1}/${combos.length}] ${JSON.stringify(combo)}
+`);
+    }
+    const result = await runBacktest({
+      fromMs: opts.fromMs,
+      toMs: opts.toMs,
+      capital: opts.capital,
+      config,
+      loader,
+      noCache: opts.noCache,
+      feeBps: opts.feeBps,
+      outPath: runOutPath
+    });
+    const ddPct = Math.abs(result.drawdown.maxPct * 100);
+    const pnlPct = result.capital.pnlPct * 100;
+    const riskAdjusted = pnlPct / Math.max(ddPct, 1);
+    const survived = result.liquidations.haltedAt === null;
+    runs.push({
+      index: i,
+      config: combo,
+      runId: result.runId,
+      resultPath: runOutPath,
+      capital: result.capital,
+      fees: { bps: result.fees.bps, totalUsd: result.fees.totalUsd },
+      totals: {
+        roundTrips: result.totals.roundTrips,
+        fills: result.totals.fills,
+        pausedSteps: result.totals.pausedSteps
+      },
+      drawdown: result.drawdown,
+      riskAdjusted,
+      survived,
+      durationMs: result.durationMs
+    });
+  }
+  runs.sort((a, b) => {
+    if (a.survived !== b.survived) return a.survived ? -1 : 1;
+    return b.riskAdjusted - a.riskAdjusted;
+  });
+  const finishedAt = Date.now();
+  const sweep = {
+    sweepId,
+    startedAt,
+    finishedAt,
+    durationMs: finishedAt - startedAt,
+    window: {
+      fromMs: opts.fromMs,
+      toMs: opts.toMs,
+      days: (opts.toMs - opts.fromMs) / (24 * 60 * 60 * 1e3)
+    },
+    tokens: opts.tokens,
+    capital: opts.capital,
+    feeBps: opts.feeBps ?? 5,
+    runs
+  };
+  const sweepJsonPath = join7(sweepDir, "sweep.json");
+  await writeFile6(sweepJsonPath, JSON.stringify(sweep, null, 2), "utf-8");
+  return sweep;
+}
+
 // src/commands/grid.ts
 var DIM5 = chalk14.gray;
 var G5 = chalk14.green;
 var BOLD5 = chalk14.white.bold;
 var W5 = chalk14.white;
 var SEP5 = () => console.log(DIM5("\u2500".repeat(60)));
+function printSummary(r) {
+  const dd = r.drawdown;
+  const days = r.window.days;
+  const rtPerDay = (r.totals.roundTrips / Math.max(days, 1)).toFixed(1);
+  const fillPerDay = (r.totals.fills / Math.max(days, 1)).toFixed(1);
+  const pnlSign = r.capital.pnlUsd >= 0 ? "+" : "-";
+  const pnlAbs = Math.abs(r.capital.pnlUsd).toFixed(2);
+  const pnlPctStr = (r.capital.pnlPct * 100).toFixed(2);
+  console.log();
+  console.log(G5.bold(`  Grid Backtest \u2014 ${r.runId}`));
+  console.log(DIM5("\u2500".repeat(64)));
+  console.log(W5(`  Window:        ${r.window.fromIso.slice(0, 10)} \u2192 ${r.window.toIso.slice(0, 10)}  (${days.toFixed(0)} days)`));
+  console.log(W5(`  Capital:       $${r.capital.initialUsd.toLocaleString()} \u2192 $${r.capital.finalUsd.toFixed(2)}  (${pnlSign}$${pnlAbs}, ${pnlSign}${pnlPctStr}%)`));
+  console.log(W5(`  Gross PnL:     $${r.capital.grossPnlUsd.toFixed(2)} (before fees)`));
+  console.log(W5(`  Fees (${r.fees.bps}bps): -$${r.fees.totalUsd.toFixed(2)}  ($${r.fees.perFill.toFixed(4)}/fill)`));
+  if (r.hedge.enabled) {
+    const hedgeNet = r.hedge.realizedPnlUsd + r.hedge.unrealizedPnlUsd;
+    const hedgeSign = hedgeNet >= 0 ? "+" : "-";
+    const hedgeAbs = Math.abs(hedgeNet).toFixed(2);
+    console.log(W5(`  Hedge:         ${hedgeSign}$${hedgeAbs} (realized $${r.hedge.realizedPnlUsd.toFixed(2)} + unrealized $${r.hedge.unrealizedPnlUsd.toFixed(2)}, ${r.hedge.adjustments} adj)`));
+  } else {
+    console.log(W5(`  Hedge:         disabled`));
+  }
+  console.log(W5(`  Round trips:   ${r.totals.roundTrips}  (${rtPerDay}/day)`));
+  console.log(W5(`  Fills:         ${r.totals.fills}  (${fillPerDay}/day)`));
+  console.log(W5(`  Rebuilds:      ${r.totals.rebuilds}`));
+  console.log(W5(`  Max drawdown:  -$${dd.maxUsd.toFixed(2)} (-${(dd.maxPct * 100).toFixed(2)}%)`));
+  console.log(W5(`  Paused:        ${r.totals.pausedSteps} steps (${(r.totals.pausedSteps / Math.max(r.totals.totalSteps, 1) * 100).toFixed(1)}%)`));
+  console.log(W5(`  Skipped:       ${r.totals.skippedSteps} steps`));
+  console.log();
+  console.log(BOLD5("  Per token:"));
+  for (const t of r.perToken) {
+    const tokPnl = t.pnlUsd >= 0 ? G5(`+$${t.pnlUsd.toFixed(2)}`) : chalk14.red(`-$${Math.abs(t.pnlUsd).toFixed(2)}`);
+    console.log(W5(`    ${t.token.padEnd(10)} $${t.allocation.initial.toFixed(0).padStart(6)} \u2192 $${t.allocation.final.toFixed(0).padStart(6)}  ${tokPnl}  RTs=${t.roundTrips}  fills=${t.fills}`));
+  }
+  if (r.liquidations.events.length > 0) {
+    console.log();
+    console.log(BOLD5("  Liquidations:"));
+    for (const ev of r.liquidations.events) {
+      const date = new Date(ev.timestamp).toISOString().slice(0, 10);
+      console.log(W5(`    ${ev.token.padEnd(10)} ${date}  unrealized=$${ev.unrealizedPnlAtLiquidation.toFixed(0)}  threshold=$${ev.thresholdUsd.toFixed(0)}`));
+    }
+    if (r.liquidations.haltedAt !== null) {
+      const haltDate = new Date(r.liquidations.haltedAt).toISOString().slice(0, 10);
+      console.log(chalk14.red.bold(`    RUN HALTED on ${haltDate} \u2014 all tokens liquidated.`));
+    }
+  }
+  console.log();
+  console.log(W5(`  Wall time:     ${(r.durationMs / 1e3).toFixed(1)}s`));
+  console.log(DIM5("\u2500".repeat(64)));
+}
+function printSweepSummary(s) {
+  const days = s.window.days;
+  console.log();
+  console.log(G5.bold(`  Grid Sweep \u2014 ${s.sweepId}`));
+  console.log(DIM5("\u2500".repeat(96)));
+  console.log(W5(`  Window:    ${new Date(s.window.fromMs).toISOString().slice(0, 10)} \u2192 ${new Date(s.window.toMs).toISOString().slice(0, 10)}  (${days.toFixed(0)} days)`));
+  console.log(W5(`  Tokens:    ${s.tokens.join(", ")}`));
+  console.log(W5(`  Capital:   $${s.capital.toLocaleString()}`));
+  console.log(W5(`  Fees:      ${s.feeBps} bps/fill`));
+  console.log(W5(`  Runs:      ${s.runs.length}`));
+  console.log(W5(`  Wall:      ${(s.durationMs / 1e3).toFixed(1)}s`));
+  console.log(DIM5("\u2500".repeat(96)));
+  console.log();
+  console.log(BOLD5("  Rank  Surv  Lev  Levels  ATR\xD7  Drift  RTs    NetPnL$       NetPnL%   DD%      Risk-Adj"));
+  console.log(DIM5("  " + "\u2500".repeat(102)));
+  for (let i = 0; i < s.runs.length; i++) {
+    const r = s.runs[i];
+    const rank = String(i + 1).padStart(4);
+    const surv = r.survived ? G5(" \u2713 ") : chalk14.red(" \u2717 ");
+    const lev = String(r.config.leverage ?? "").padStart(3);
+    const lvls = String(r.config.levelsPerSide ?? "").padStart(6);
+    const atr = String(r.config.atrMultiplier ?? "").padStart(4);
+    const drift = String(r.config.rebalanceDriftPct ?? "").padStart(5);
+    const rts = String(r.totals.roundTrips).padStart(5);
+    const netPnl = `$${r.capital.pnlUsd.toFixed(0)}`.padStart(11);
+    const netPct = `${(r.capital.pnlPct * 100).toFixed(1)}%`.padStart(8);
+    const ddPct = `${(r.drawdown.maxPct * 100).toFixed(1)}%`.padStart(8);
+    const ra = r.riskAdjusted.toFixed(2).padStart(8);
+    const pnlColor = r.capital.pnlUsd >= 0 ? G5 : chalk14.red;
+    console.log(`  ${rank}  ${surv}  ${lev}  ${lvls}  ${atr}  ${drift}  ${rts}  ${pnlColor(netPnl)}  ${pnlColor(netPct)}  ${ddPct}  ${ra}`);
+  }
+  console.log(DIM5("  " + "\u2500".repeat(102)));
+  console.log();
+  console.log(W5(`  Saved: ${s.sweepId}/sweep.json + per-run JSONs in ~/.sherwood/grid/sweeps/`));
+  console.log();
+}
+function parseTokenSplit(raw, tokens) {
+  const split = {};
+  for (const pair of raw.split(",")) {
+    const [tok, w] = pair.split("=");
+    if (!tok || !w) throw new Error(`Bad token-split pair: '${pair}' (expected token=weight)`);
+    const weight = Number(w.trim());
+    if (!Number.isFinite(weight) || weight < 0) {
+      throw new Error(`Bad token-split weight for '${tok}': '${w}'`);
+    }
+    split[tok.trim()] = weight;
+  }
+  for (const t of tokens) {
+    if (!(t in split)) {
+      throw new Error(`--token-split missing weight for '${t}'`);
+    }
+  }
+  const sum = Object.values(split).reduce((a, b) => a + b, 0);
+  if (Math.abs(sum - 1) > 1e-6) {
+    throw new Error(`--token-split weights must sum to 1.0, got ${sum.toFixed(6)}`);
+  }
+  return split;
+}
 function registerGridCommand(program2) {
   const grid = program2.command("grid").description("Grid trading strategy \u2014 ATR-based grid on BTC/ETH/SOL");
-  grid.command("start").description("Start the grid trading loop").option("--capital <usd>", "Starting capital in USD", "5000").option("--cycle <seconds>", "Cycle interval in seconds", "60").option("--tokens <list>", "Comma-separated token list", "bitcoin,ethereum,solana").option("--leverage <n>", "Leverage multiplier", "5").option("--levels <n>", "Grid levels per side", "15").option("--live", "enable live execution (places real orders on Hyperliquid)").option("--asset-indices <pairs>", "comma-separated token=index pairs (e.g. bitcoin=3,ethereum=4,solana=5)").option("--strategy <address>", "on-chain strategy contract address (enables on-chain executor)").action(async (opts) => {
+  grid.command("start").description("Start the grid trading loop").option("--capital <usd>", "Starting capital in USD", "5000").option("--cycle <seconds>", "Cycle interval in seconds", "60").option("--tokens <list>", "Comma-separated token list", "bitcoin,ethereum,solana").option("--leverage <n>", "Leverage multiplier", "5").option("--levels <n>", "Grid levels per side", "15").option("--live", "enable live execution (places real orders on Hyperliquid)").option("--asset-indices <pairs>", "comma-separated token=index pairs (e.g. bitcoin=3,ethereum=4,solana=5)").option("--strategy <address>", "on-chain strategy contract address (enables on-chain executor)").option("--token-split <pairs>", "Comma-separated token=weight pairs (must sum to 1.0). Default: equal-weight.").action(async (opts) => {
     const capital = parseFloat(opts.capital);
     const cycleMs = parseInt(opts.cycle, 10) * 1e3;
     const tokens = opts.tokens.split(",").map((t) => t.trim());
@@ -5768,10 +6785,15 @@ function registerGridCommand(program2) {
     if (strategyAddress && !live) {
       throw new Error("--strategy requires --live");
     }
-    const weight = 1 / tokens.length;
-    const tokenSplit = {};
-    for (const t of tokens) {
-      tokenSplit[t] = weight;
+    let tokenSplit;
+    if (opts.tokenSplit) {
+      tokenSplit = parseTokenSplit(opts.tokenSplit, tokens);
+    } else {
+      const weight = 1 / tokens.length;
+      tokenSplit = {};
+      for (const t of tokens) {
+        tokenSplit[t] = weight;
+      }
     }
     console.log();
     console.log(G5.bold("  Grid Strategy"));
@@ -5834,6 +6856,131 @@ function registerGridCommand(program2) {
     console.log(`  ${BOLD5("TOTAL".padEnd(13))}  ${`$${state.totalAllocation.toFixed(0)}`.padStart(8)}  ${String(agg.totalRoundTrips).padStart(6)}  ${totalPnlColor(`$${agg.totalPnlUsd.toFixed(2)}`.padStart(10))}  ${todayTotalColor(`$${agg.todayPnlUsd.toFixed(2)}`.padStart(10))}  ${String(agg.todayFills).padStart(6)}`);
     console.log();
   });
+  grid.command("backtest").description("Replay historical Hyperliquid prices through the grid strategy").option("--from <iso>", "Window start (ISO date). Default: 30d ago.").option("--to <iso>", "Window end (ISO date). Default: now.").option("--capital <usd>", "Starting capital in USD", "5000").option("--tokens <list>", "Comma-separated token list", "bitcoin,ethereum,solana").option("--leverage <n>", "Override leverage").option("--levels <n>", "Override levels per side").option("--atr-multiplier <n>", "Override ATR multiplier").option("--rebalance-drift <n>", "Override rebalanceDriftPct").option("--snapshot-every <min>", "Equity-curve snapshot cadence (minutes)", "60").option("--verbose", "Print manager fill logs during replay").option("--no-cache", "Skip cache; always fetch fresh data").option("--out <path>", "Override output path").option("--fee-bps <n>", "Trading fee in basis points per fill (default 5 = 0.05%)", "5").option("--no-hedge", "Disable hedge simulation (hedge is ON by default to match live grid)").option("--maintenance-pct <n>", "Per-token maintenance margin fraction (default 0.02 = 2%, typical Hyperliquid)", "0.02").option("--pause-threshold <n>", "Pool drop fraction that triggers pause (default 0.40, may be too lenient post leverage-fix)").option("--unpause-recovery <n>", "Pool drop fraction below which paused grid resumes (default 0.10)").option("--token-split <pairs>", "Comma-separated token=weight pairs (must sum to 1.0). Default: equal-weight or 0.45/0.30/0.25 for BTC/ETH/SOL.").option("--stop-loss <n>", "Per-fill stop-loss fraction (default 0.10 = 10%, 0 disables)").action(async (opts) => {
+    const now = Date.now();
+    const toMs = opts.to ? Date.parse(opts.to) : now;
+    const fromMs = opts.from ? Date.parse(opts.from) : now - 30 * 24 * 36e5;
+    if (Number.isNaN(toMs) || Number.isNaN(fromMs)) {
+      throw new Error("--from / --to must be ISO dates (e.g. 2026-04-01)");
+    }
+    const tokens = opts.tokens.split(",").map((t) => t.trim());
+    let tokenSplit;
+    if (opts.tokenSplit) {
+      tokenSplit = parseTokenSplit(opts.tokenSplit, tokens);
+    } else {
+      const weight = 1 / tokens.length;
+      tokenSplit = {};
+      for (const t of tokens) tokenSplit[t] = weight;
+    }
+    const config = {
+      ...DEFAULT_GRID_CONFIG,
+      tokens,
+      tokenSplit,
+      leverage: opts.leverage ? Number(opts.leverage) : DEFAULT_GRID_CONFIG.leverage,
+      levelsPerSide: opts.levels ? Number(opts.levels) : DEFAULT_GRID_CONFIG.levelsPerSide,
+      atrMultiplier: opts.atrMultiplier ? Number(opts.atrMultiplier) : DEFAULT_GRID_CONFIG.atrMultiplier,
+      rebalanceDriftPct: opts.rebalanceDrift ? Number(opts.rebalanceDrift) : DEFAULT_GRID_CONFIG.rebalanceDriftPct,
+      maintenanceMarginPct: opts.maintenancePct ? Number(opts.maintenancePct) : DEFAULT_GRID_CONFIG.maintenanceMarginPct,
+      pauseThresholdPct: opts.pauseThreshold ? Number(opts.pauseThreshold) : DEFAULT_GRID_CONFIG.pauseThresholdPct,
+      unpauseRecoveryPct: opts.unpauseRecovery ? Number(opts.unpauseRecovery) : DEFAULT_GRID_CONFIG.unpauseRecoveryPct,
+      stopLossPct: opts.stopLoss !== void 0 ? Number(opts.stopLoss) : DEFAULT_GRID_CONFIG.stopLossPct
+    };
+    const capital = Number(opts.capital);
+    const snapshotEveryMinutes = Number(opts.snapshotEvery);
+    console.log();
+    console.log(G5.bold("  Grid Backtest"));
+    SEP5();
+    console.log(W5(`  Window:    ${new Date(fromMs).toISOString().slice(0, 10)} \u2192 ${new Date(toMs).toISOString().slice(0, 10)}`));
+    console.log(W5(`  Capital:   $${capital.toLocaleString()}`));
+    console.log(W5(`  Tokens:    ${tokens.join(", ")}`));
+    console.log(W5(`  Leverage:  ${config.leverage}x`));
+    console.log(W5(`  Levels:    ${config.levelsPerSide}/side`));
+    SEP5();
+    const result = await runBacktest({
+      fromMs,
+      toMs,
+      capital,
+      config,
+      snapshotEveryMinutes,
+      verbose: !!opts.verbose,
+      noCache: opts.cache === false,
+      outPath: opts.out,
+      feeBps: Number(opts.feeBps),
+      hedge: opts.hedge !== false
+    });
+    printSummary(result);
+  });
+  grid.command("sweep").description("Run a parameter sweep over multiple grid configurations").option("--from <iso>", "Window start (ISO date). Default: 30d ago.").option("--to <iso>", "Window end (ISO date). Default: now.").option("--capital <usd>", "Starting capital in USD", "5000").option("--tokens <list>", "Comma-separated token list", "bitcoin,ethereum,solana").option("--leverage <list>", "Comma-separated leverage values to sweep").option("--levels <list>", "Comma-separated levels-per-side values to sweep").option("--atr-multiplier <list>", "Comma-separated ATR multiplier values to sweep").option("--rebalance-drift <list>", "Comma-separated rebalance drift values to sweep").option("--fee-bps <n>", "Trading fee in basis points per fill (default 5)", "5").option("--no-cache", "Skip cache; always fetch fresh data").option("--token-split <pairs>", "Comma-separated token=weight pairs (must sum to 1.0). Default: equal-weight or 0.45/0.30/0.25 for BTC/ETH/SOL.").action(async (opts) => {
+    const now = Date.now();
+    const toMs = opts.to ? Date.parse(opts.to) : now;
+    const fromMs = opts.from ? Date.parse(opts.from) : now - 30 * 24 * 36e5;
+    if (Number.isNaN(toMs) || Number.isNaN(fromMs)) {
+      throw new Error("--from / --to must be ISO dates (e.g. 2026-04-01)");
+    }
+    const tokens = opts.tokens.split(",").map((t) => t.trim());
+    const parseList = (s) => {
+      if (!s) return void 0;
+      return s.split(",").map((v) => Number(v.trim())).filter((n) => Number.isFinite(n));
+    };
+    const sweep = {
+      leverage: parseList(opts.leverage),
+      levelsPerSide: parseList(opts.levels),
+      atrMultiplier: parseList(opts.atrMultiplier),
+      rebalanceDriftPct: parseList(opts.rebalanceDrift)
+    };
+    const tokenSplit = opts.tokenSplit ? parseTokenSplit(opts.tokenSplit, tokens) : void 0;
+    const result = await runSweep({
+      fromMs,
+      toMs,
+      capital: Number(opts.capital),
+      tokens,
+      tokenSplit,
+      sweep,
+      feeBps: Number(opts.feeBps),
+      noCache: opts.cache === false
+    });
+    printSweepSummary(result);
+  });
+  grid.command("pause").description("Manually pause the live grid (sets state.paused=true)").option("--reason <text>", "Reason for the pause (shown in status output)", "Manually paused by operator").action(async (opts) => {
+    const portfolio = new GridPortfolio();
+    const state = await portfolio.load();
+    if (!state) {
+      console.log(DIM5("\n  No grid portfolio found. Nothing to pause.\n"));
+      return;
+    }
+    if (state.paused) {
+      console.log(DIM5(`
+  Grid already paused: ${state.pauseReason}
+`));
+      return;
+    }
+    state.paused = true;
+    state.pauseReason = opts.reason;
+    await portfolio.save(state);
+    console.log();
+    console.log(chalk14.yellow(`  Grid paused. Reason: ${state.pauseReason}`));
+    console.log(DIM5("  Next manager.tick will be a no-op until you run `sherwood grid resume`."));
+    console.log();
+  });
+  grid.command("resume").description("Resume a paused grid (clears state.paused)").action(async () => {
+    const portfolio = new GridPortfolio();
+    const state = await portfolio.load();
+    if (!state) {
+      console.log(DIM5("\n  No grid portfolio found. Nothing to resume.\n"));
+      return;
+    }
+    if (!state.paused) {
+      console.log(DIM5("\n  Grid is not paused. Nothing to do.\n"));
+      return;
+    }
+    const wasReason = state.pauseReason;
+    state.paused = false;
+    state.pauseReason = "";
+    await portfolio.save(state);
+    console.log();
+    console.log(G5(`  Grid resumed. (was paused: ${wasReason || "<unknown>"})`));
+    console.log();
+  });
 }
 
 // src/index.ts
@@ -7004,7 +8151,7 @@ try {
     process.exit(1);
   });
 }
-var { registerSessionCommands } = await import("./session-ZMEKZRWL.js");
+var { registerSessionCommands } = await import("./session-3QAL5VEV.js");
 registerSessionCommands(program);
 registerVeniceCommands(program);
 registerAllowanceCommands(program);
@@ -7014,7 +8161,7 @@ registerGovernorCommands(program);
 registerGuardianCommands(program);
 var { registerResearchCommands } = await import("./research-2GOILSS7.js");
 registerResearchCommands(program);
-var { registerAgentCommands } = await import("./agent-E5GHURKJ.js");
+var { registerAgentCommands } = await import("./agent-ER5GYBVQ.js");
 registerAgentCommands(program);
 var { registerTradeCommands } = await import("./trade-UXQOCNLJ.js");
 registerTradeCommands(program);