@sherwoodagent/cli 0.54.3 → 0.56.1

package/dist/index.js

@@ -4187,10 +4187,10 @@ function registerProposalCommands(program2) {
       }
       if (!opts.yes) {
         process.stdout.write(chalk6.yellow("  Proceed? [y/N] "));
-        const answer = await new Promise((resolve2) => {
+        const answer = await new Promise((resolve3) => {
           process.stdin.resume();
           process.stdin.setEncoding("utf-8");
-          process.stdin.once("data", (d) => resolve2(String(d).trim().toLowerCase()));
+          process.stdin.once("data", (d) => resolve3(String(d).trim().toLowerCase()));
         });
         process.stdin.pause();
         if (answer !== "y" && answer !== "yes") {
@@ -4741,17 +4741,28 @@ import chalk14 from "chalk";
 // src/grid/loop.ts
 import chalk13 from "chalk";
 import { appendFile, mkdir as mkdir4 } from "fs/promises";
-import { join as join4 } from "path";
-import { homedir as homedir4 } from "os";
+import { dirname as dirname4 } from "path";
 
 // src/grid/manager.ts
 import chalk9 from "chalk";
 
 // src/grid/portfolio.ts
 import { readFile, writeFile, rename, mkdir } from "fs/promises";
-import { join, dirname } from "path";
+import { dirname } from "path";
+
+// src/grid/paths.ts
+import { join, resolve as resolve2 } from "path";
 import { homedir } from "os";
-var GRID_STATE_PATH = join(homedir(), ".sherwood", "grid", "portfolio.json");
+var DEFAULT_GRID_STATE_DIR = join(homedir(), ".sherwood", "grid");
+function gridStateDir(override) {
+  if (!override || override.trim().length === 0) return DEFAULT_GRID_STATE_DIR;
+  return resolve2(override);
+}
+function gridStatePath(file, override) {
+  return join(gridStateDir(override), file);
+}
+
+// src/grid/portfolio.ts
 function emptyStats() {
   return {
     totalRoundTrips: 0,
@@ -4765,10 +4776,14 @@ function emptyStats() {
 }
 var GridPortfolio = class {
   state = null;
+  statePath;
+  constructor(stateDir) {
+    this.statePath = gridStatePath("portfolio.json", stateDir);
+  }
   /** Load grid state from disk. Returns null if no grid initialized yet. */
   async load() {
     try {
-      const raw = await readFile(GRID_STATE_PATH, "utf-8");
+      const raw = await readFile(this.statePath, "utf-8");
       this.state = JSON.parse(raw);
       return this.state;
     } catch {
@@ -4778,10 +4793,10 @@ var GridPortfolio = class {
   /** Save grid state to disk (atomic write). */
   async save(state) {
     this.state = state;
-    await mkdir(dirname(GRID_STATE_PATH), { recursive: true });
-    const tmp = `${GRID_STATE_PATH}.tmp.${process.pid}`;
+    await mkdir(dirname(this.statePath), { recursive: true });
+    const tmp = `${this.statePath}.tmp.${process.pid}`;
     await writeFile(tmp, JSON.stringify(state, null, 2), "utf-8");
-    await rename(tmp, GRID_STATE_PATH);
+    await rename(tmp, this.statePath);
   }
   /**
    * Initialize the grid by carving capital from the directional portfolio.
@@ -4844,12 +4859,19 @@ var GridPortfolio = class {
       return sum + g.allocation + unrealized;
     }, 0);
     const dropPct = 1 - currentValue / state.totalAllocation;
-    if (!state.paused && dropPct >= config.pauseThresholdPct) {
+    if (!state.circuitBroken && dropPct >= config.circuitBreakerThresholdPct) {
+      state.circuitBroken = true;
+      state.circuitBrokenAt = Date.now();
+      state.paused = true;
+      state.pauseReason = `Hard circuit breaker tripped \u2014 pool dropped ${(dropPct * 100).toFixed(1)}% (>= ${(config.circuitBreakerThresholdPct * 100).toFixed(0)}%). Manual resume required: \`sherwood grid resume\`.`;
+      return true;
+    }
+    if (!state.circuitBroken && !state.paused && dropPct >= config.pauseThresholdPct) {
       state.paused = true;
       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) {
+    if (!state.circuitBroken && state.paused && dropPct <= config.unpauseRecoveryPct) {
       state.paused = false;
       state.pauseReason = "";
       return true;
@@ -4878,9 +4900,9 @@ var GridManager = class {
   fillDetector;
   closeFillDetector;
   nowProvider;
-  constructor(config, candleFetcher, fillDetector, closeFillDetector, portfolio, nowProvider) {
+  constructor(config, candleFetcher, fillDetector, closeFillDetector, portfolio, nowProvider, stateDir) {
     this.config = config;
-    this.portfolio = portfolio ?? new GridPortfolio();
+    this.portfolio = portfolio ?? new GridPortfolio(stateDir);
     this.hl = new HyperliquidProvider();
     this.candleFetcher = candleFetcher ?? ((tokenId, interval, lookbackMs) => this.hl.getCandles(tokenId, interval, lookbackMs));
     this.fillDetector = fillDetector ?? defaultFillDetector;
@@ -5154,6 +5176,21 @@ var GridManager = class {
     ));
     await this.buildGrid(grid, currentPrice);
   }
+  /** Recent market trend for hedge sizing — BTC's grid.trend (already
+   *  maintained at 56h cadence by the asymmetric-grid filter), falling back
+   *  to the median across tracked tokens if BTC is not in the universe.
+   *  Used by the trend-adaptive hedge ratio. Returns undefined if no signal
+   *  is yet available (cold start). */
+  getMarketTrend() {
+    const state = this.portfolio.getState();
+    if (!state || state.grids.length === 0) return void 0;
+    const btc = state.grids.find((g) => g.token === "bitcoin");
+    if (btc && Number.isFinite(btc.trend) && btc.lastTrendRefreshAt > 0) return btc.trend;
+    const trends = state.grids.filter((g) => Number.isFinite(g.trend) && g.lastTrendRefreshAt > 0).map((g) => g.trend);
+    if (trends.length === 0) return void 0;
+    trends.sort((a, b) => a - b);
+    return trends[Math.floor(trends.length / 2)];
+  }
   /** Get open fill exposure per token — used by the hedge manager. */
   getOpenFillExposure() {
     const state = this.portfolio.getState();
@@ -5245,6 +5282,8 @@ var DEFAULT_GRID_CONFIG = {
   // 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)
+  circuitBreakerThresholdPct: 0.3,
+  // hard halt at 30% drawdown — manual resume required. Bear-sweep: BEAR-60d went from -20% to -53% in second month; halting at -30% saves the rest.
   maintenanceMarginPct: 0.02,
   maxOpenNotionalMultiple: 2,
   downtrendBlockPct: 0.1,
@@ -5254,19 +5293,33 @@ var DEFAULT_GRID_CONFIG = {
 
 // src/grid/hedge.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join2, dirname as dirname2 } from "path";
-import { homedir as homedir2 } from "os";
+import { dirname as dirname2 } from "path";
 import chalk10 from "chalk";
-var HEDGE_RATIO = 0.3;
+var HEDGE_RATIO_DEFAULT = Number.isFinite(Number(process.env.HEDGE_RATIO)) ? Number(process.env.HEDGE_RATIO) : 0.3;
+function hedgeRatioFor(marketTrend) {
+  if (process.env.HEDGE_RATIO !== void 0 && Number.isFinite(Number(process.env.HEDGE_RATIO))) {
+    return Number(process.env.HEDGE_RATIO);
+  }
+  if (marketTrend === void 0 || !Number.isFinite(marketTrend)) {
+    return HEDGE_RATIO_DEFAULT;
+  }
+  if (marketTrend <= -0.05) return 0.7;
+  if (marketTrend <= -0.025) return 0.5;
+  if (marketTrend >= 0.025) return 0.1;
+  return HEDGE_RATIO_DEFAULT;
+}
 var MIN_FILLS_TO_HEDGE = 3;
 var ADJUSTMENT_THRESHOLD = 0.1;
-var HEDGE_STATE_PATH = join2(homedir2(), ".sherwood", "grid", "hedge.json");
 var GridHedgeManager = class {
   state = null;
+  statePath;
+  constructor(stateDir) {
+    this.statePath = gridStatePath("hedge.json", stateDir);
+  }
   async load(now = Date.now()) {
     if (this.state) return this.state;
     try {
-      const raw = await readFile2(HEDGE_STATE_PATH, "utf-8");
+      const raw = await readFile2(this.statePath, "utf-8");
       this.state = JSON.parse(raw);
     } catch {
       this.state = {
@@ -5286,26 +5339,31 @@ var GridHedgeManager = class {
   }
   async save() {
     if (!this.state) return;
-    await mkdir2(dirname2(HEDGE_STATE_PATH), { recursive: true });
-    const tmp = `${HEDGE_STATE_PATH}.tmp.${process.pid}`;
+    await mkdir2(dirname2(this.statePath), { recursive: true });
+    const tmp = `${this.statePath}.tmp.${process.pid}`;
     await writeFile2(tmp, JSON.stringify(this.state, null, 2), "utf-8");
     const { rename: rename3 } = await import("fs/promises");
-    await rename3(tmp, HEDGE_STATE_PATH);
+    await rename3(tmp, this.statePath);
   }
   /**
    * Run one hedge tick. Call after grid tick with current prices and open fill data.
    *
    * @param openFills - Per-token open fill exposure from the grid portfolio
    * @param prices - Current mark prices per token
+   * @param now - injected clock (backtester drives this)
+   * @param marketTrend - recent market trend (e.g. BTC's 56h trend) used by
+   *                     `hedgeRatioFor()` to scale hedge size by regime. Pass
+   *                     undefined to use the static default.
    */
-  async tick(openFills, prices, now = Date.now()) {
+  async tick(openFills, prices, now = Date.now(), marketTrend) {
     const state = await this.load(now);
     let adjustments = 0;
     let unrealizedPnl = 0;
+    const activeRatio = hedgeRatioFor(marketTrend);
     for (const fill of openFills) {
       const price = prices[fill.token];
       if (!price || price <= 0) continue;
-      const desiredShortQty = fill.fillCount >= MIN_FILLS_TO_HEDGE ? fill.totalQuantity * HEDGE_RATIO : 0;
+      const desiredShortQty = fill.fillCount >= MIN_FILLS_TO_HEDGE ? fill.totalQuantity * activeRatio : 0;
       const existing = state.positions.find((p) => p.token === fill.token);
       if (desiredShortQty <= 0) {
         if (existing && existing.quantity > 0) {
@@ -5331,7 +5389,7 @@ var GridHedgeManager = class {
           realizedPnl: 0
         });
         console.error(chalk10.magenta(
-          `  [hedge] OPEN ${fill.token} short ${desiredShortQty.toFixed(6)} @ $${price.toFixed(2)} (${(HEDGE_RATIO * 100).toFixed(0)}% of ${fill.fillCount} open fills)`
+          `  [hedge] OPEN ${fill.token} short ${desiredShortQty.toFixed(6)} @ $${price.toFixed(2)} (${(activeRatio * 100).toFixed(0)}% of ${fill.fillCount} open fills)`
         ));
         adjustments++;
       } else if (existing.quantity > 0) {
@@ -5461,8 +5519,7 @@ var GridExecutor = class {
 // src/grid/onchain-executor.ts
 import chalk12 from "chalk";
 import { mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3, join as join3 } from "path";
-import { homedir as homedir3 } from "os";
+import { dirname as dirname3 } from "path";
 import { encodeAbiParameters as encodeAbiParameters11, parseUnits as parseUnits6 } from "viem";
 
 // src/grid/cloid.ts
@@ -5503,7 +5560,6 @@ var HYPERLIQUID_GRID_STRATEGY_ABI = [
 ];
 
 // src/grid/onchain-executor.ts
-var ONCHAIN_STATE_PATH = join3(homedir3(), ".sherwood", "grid", "onchain-state.json");
 var UINT64_MAX = 18446744073709551615n;
 var ACTION_PLACE_GRID = 1;
 var ACTION_CANCEL_ALL = 2;
@@ -5531,8 +5587,10 @@ var OnchainGridExecutor = class {
   /** On-chain `maxOrdersPerTick`; cached at load(). Used to chunk batches so
    *  the strategy never reverts with TooManyOrders(actual, max). */
   maxOrdersPerTick = null;
+  statePath;
   constructor(cfg) {
     this.cfg = cfg;
+    this.statePath = gridStatePath("onchain-state.json", cfg.stateDir);
   }
   /** Read the strategy's per-call order cap and cache it. */
   async fetchMaxOrdersPerTick() {
@@ -5549,7 +5607,7 @@ var OnchainGridExecutor = class {
   /** Load persisted state. Call once before the first execute(). */
   async load() {
     try {
-      const raw = await readFile3(ONCHAIN_STATE_PATH, "utf-8");
+      const raw = await readFile3(this.statePath, "utf-8");
       const state = JSON.parse(raw);
       for (const [tok, n] of Object.entries(state.nonces)) this.nonces.set(tok, n);
       for (const [tok, cloids] of Object.entries(state.placedCloids)) {
@@ -5582,10 +5640,10 @@ var OnchainGridExecutor = class {
         [...this.placedCloids].map(([tok, cloids]) => [tok, cloids.map((c) => c.toString())])
       )
     };
-    await mkdir3(dirname3(ONCHAIN_STATE_PATH), { recursive: true });
-    const tmp = ONCHAIN_STATE_PATH + ".tmp";
+    await mkdir3(dirname3(this.statePath), { recursive: true });
+    const tmp = this.statePath + ".tmp";
     await writeFile3(tmp, JSON.stringify(state, null, 2));
-    await rename2(tmp, ONCHAIN_STATE_PATH);
+    await rename2(tmp, this.statePath);
   }
   /**
    * Execute the order plan: cancel stale orders for rebalanced tokens, then
@@ -5795,7 +5853,6 @@ var OnchainGridExecutor = class {
 };
 
 // src/grid/loop.ts
-var GRID_CYCLES_PATH = join4(homedir4(), ".sherwood", "grid", "cycles.jsonl");
 var GridLoop = class {
   cfg;
   gridConfig;
@@ -5806,11 +5863,21 @@ var GridLoop = class {
   running = false;
   cycleCount = 0;
   timer = null;
+  cyclesPath;
   constructor(cfg) {
     this.cfg = cfg;
     this.gridConfig = { ...DEFAULT_GRID_CONFIG, ...cfg.config };
-    this.manager = new GridManager(this.gridConfig);
-    this.hedge = new GridHedgeManager();
+    this.cyclesPath = gridStatePath("cycles.jsonl", cfg.stateDir);
+    this.manager = new GridManager(
+      this.gridConfig,
+      void 0,
+      void 0,
+      void 0,
+      new GridPortfolio(cfg.stateDir),
+      void 0,
+      cfg.stateDir
+    );
+    this.hedge = new GridHedgeManager(cfg.stateDir);
     this.hl = new HyperliquidProvider();
     if (cfg.live) {
       if (!cfg.assetIndices) {
@@ -5819,7 +5886,8 @@ var GridLoop = class {
       if (cfg.strategyAddress) {
         this.executor = new OnchainGridExecutor({
           strategyAddress: cfg.strategyAddress,
-          assetIndices: cfg.assetIndices
+          assetIndices: cfg.assetIndices,
+          stateDir: cfg.stateDir
         });
       } else {
         this.executor = new GridExecutor({ assetIndices: cfg.assetIndices });
@@ -5845,7 +5913,7 @@ var GridLoop = class {
     }
     console.error(chalk13.cyan(
       `
-  [grid-loop] Started \u2014 capital=$${this.cfg.capital.toFixed(0)} cycle=${(this.cfg.cycle / 1e3).toFixed(0)}s tokens=[${this.gridConfig.tokens.join(", ")}] leverage=${this.gridConfig.leverage}x levels=${this.gridConfig.levelsPerSide}/side
+  [grid-loop] Started \u2014 capital=$${this.cfg.capital.toFixed(0)} cycle=${(this.cfg.cycle / 1e3).toFixed(0)}s tokens=[${this.gridConfig.tokens.join(", ")}] leverage=${this.gridConfig.leverage}x levels=${this.gridConfig.levelsPerSide}/side state-dir=${gridStateDir(this.cfg.stateDir)}
 `
     ));
     while (this.running) {
@@ -5855,8 +5923,8 @@ var GridLoop = class {
         console.error(chalk13.red(`  [grid-loop] Tick error: ${err.message}`));
       }
       if (this.running) {
-        await new Promise((resolve2) => {
-          this.timer = setTimeout(resolve2, this.cfg.cycle);
+        await new Promise((resolve3) => {
+          this.timer = setTimeout(resolve3, this.cfg.cycle);
         });
       }
     }
@@ -5904,7 +5972,8 @@ var GridLoop = class {
       ));
     }
     const openExposure = this.manager.getOpenFillExposure();
-    const hedgeResult = await this.hedge.tick(openExposure, prices);
+    const marketTrend = this.manager.getMarketTrend();
+    const hedgeResult = await this.hedge.tick(openExposure, prices, Date.now(), marketTrend);
     if (hedgeResult.adjustments > 0) {
       console.error(chalk13.magenta(
         `  [hedge] ${hedgeResult.adjustments} adjustment(s), unrealized: $${hedgeResult.unrealizedPnl.toFixed(2)}, total realized: $${hedgeResult.totalRealizedPnl.toFixed(2)}`
@@ -5926,8 +5995,8 @@ var GridLoop = class {
       hedgeTotalRealizedPnl: hedgeResult.totalRealizedPnl
     };
     try {
-      await mkdir4(join4(homedir4(), ".sherwood", "grid"), { recursive: true });
-      await appendFile(GRID_CYCLES_PATH, JSON.stringify(cycleEntry) + "\n");
+      await mkdir4(dirname4(this.cyclesPath), { recursive: true });
+      await appendFile(this.cyclesPath, JSON.stringify(cycleEntry) + "\n");
     } catch {
     }
     if (this.cycleCount % 60 === 0) {
@@ -5945,8 +6014,8 @@ 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 { join as join3, dirname as dirname5 } from "path";
+import { homedir as homedir3 } from "os";
 import { createHash } from "crypto";
 
 // src/grid/backtest-portfolio.ts
@@ -5977,10 +6046,10 @@ var BacktestPortfolio = class extends GridPortfolio {
 
 // 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";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 var BINANCE_BASE = "https://api.binance.com/api/v3/klines";
-var DEFAULT_CACHE_DIR = join5(homedir5(), ".sherwood", "grid", "backtest-cache");
+var DEFAULT_CACHE_DIR = join2(homedir2(), ".sherwood", "grid", "backtest-cache");
 var FOUR_HOURS_MS = 4 * 60 * 60 * 1e3;
 var ONE_MIN_MS = 60 * 1e3;
 var ATR_PERIOD = 14;
@@ -6058,7 +6127,7 @@ var HistoricalDataLoader = class {
     await writeFile4(path, body, "utf-8");
   }
   cachePath(coin, interval, fromMs, toMs) {
-    return join5(this.cacheDir, `${coin}-${interval}-${fromMs}-${toMs}.json`);
+    return join2(this.cacheDir, `${coin}-${interval}-${fromMs}-${toMs}.json`);
   }
   /** Paginate Binance klines until we cover [fromMs, toMs]. Dedup on merge. */
   async fetchPaginated(coin, interval, fromMs, toMs) {
@@ -6140,7 +6209,7 @@ function computeAtrSeries(fourHourBars) {
   return out;
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 
 // src/grid/backtest-hedge.ts
@@ -6178,7 +6247,7 @@ var BacktestHedgeManager = class extends GridHedgeManager {
 };
 
 // src/grid/backtest.ts
-var DEFAULT_OUT_DIR = join6(homedir6(), ".sherwood", "grid", "backtests");
+var DEFAULT_OUT_DIR = join3(homedir3(), ".sherwood", "grid", "backtests");
 function shortHash(input2) {
   const h = createHash("sha256").update(JSON.stringify(input2)).digest("hex");
   return h.slice(0, 8);
@@ -6350,7 +6419,8 @@ async function runBacktest(opts) {
           hedgePrices[token] = bar.c;
         }
         const exposure = manager.getOpenFillExposure();
-        const hedgeResult = await hedge.tick(exposure, hedgePrices, t);
+        const marketTrend = manager.getMarketTrend();
+        const hedgeResult = await hedge.tick(exposure, hedgePrices, t, marketTrend);
         hedgeAdjustments += hedgeResult.adjustments;
         hedgeRealized = hedgeResult.totalRealizedPnl;
         hedgeUnrealized = hedgeResult.unrealizedPnl;
@@ -6543,8 +6613,8 @@ async function runBacktest(opts) {
     equityCurve
   };
   if (opts.outPath !== "") {
-    const outPath = opts.outPath ?? join6(DEFAULT_OUT_DIR, `${runId}.json`);
-    await mkdir6(dirname4(outPath), { recursive: true });
+    const outPath = opts.outPath ?? join3(DEFAULT_OUT_DIR, `${runId}.json`);
+    await mkdir6(dirname5(outPath), { recursive: true });
     await writeFile5(outPath, JSON.stringify(result, null, 2), "utf-8");
   }
   return result;
@@ -6552,10 +6622,10 @@ async function runBacktest(opts) {
 
 // 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 { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
 import { createHash as createHash2 } from "crypto";
-var DEFAULT_SWEEP_DIR = join7(homedir7(), ".sherwood", "grid", "sweeps");
+var DEFAULT_SWEEP_DIR = join4(homedir4(), ".sherwood", "grid", "sweeps");
 function expandSweep(sweep, base2) {
   const fields = ["leverage", "levelsPerSide", "atrMultiplier", "rebalanceDriftPct"];
   const valueLists = {
@@ -6592,7 +6662,7 @@ async function runSweep(opts) {
   const startedAt = Date.now();
   const sweepId = makeSweepId(opts);
   const outDir = opts.outDir ?? DEFAULT_SWEEP_DIR;
-  const sweepDir = join7(outDir, sweepId);
+  const sweepDir = join4(outDir, sweepId);
   let tokenSplit;
   if (opts.tokenSplit) {
     tokenSplit = opts.tokenSplit;
@@ -6619,7 +6689,7 @@ async function runSweep(opts) {
   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`);
+    const runOutPath = join4(sweepDir, `run-${i.toString().padStart(3, "0")}.json`);
     if (opts.verbose !== false) {
       process.stderr.write(`  [sweep] [${i + 1}/${combos.length}] ${JSON.stringify(combo)}
 `);
@@ -6676,7 +6746,7 @@ async function runSweep(opts) {
     feeBps: opts.feeBps ?? 5,
     runs
   };
-  const sweepJsonPath = join7(sweepDir, "sweep.json");
+  const sweepJsonPath = join4(sweepDir, "sweep.json");
   await writeFile6(sweepJsonPath, JSON.stringify(sweep, null, 2), "utf-8");
   return sweep;
 }
@@ -6798,12 +6868,13 @@ function parseTokenSplit(raw, tokens) {
 }
 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", String(DEFAULT_GRID_CONFIG.leverage)).option("--levels <n>", "Grid levels per side", String(DEFAULT_GRID_CONFIG.levelsPerSide)).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) => {
+  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", String(DEFAULT_GRID_CONFIG.leverage)).option("--levels <n>", "Grid levels per side", String(DEFAULT_GRID_CONFIG.levelsPerSide)).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.").option("--state-dir <path>", "Override directory for portfolio.json / hedge.json / cycles.jsonl / onchain-state.json. Defaults to ~/.sherwood/grid. Use a separate dir to run paper and live grids in parallel.").action(async (opts) => {
     const capital = parseFloat(opts.capital);
     const cycleMs = parseInt(opts.cycle, 10) * 1e3;
     const tokens = opts.tokens.split(",").map((t) => t.trim());
     const leverage = parseFloat(opts.leverage);
     const levels = parseInt(opts.levels, 10);
+    const stateDir = opts.stateDir;
     const live = !!opts.live;
     let assetIndices;
     if (live) {
@@ -6846,6 +6917,7 @@ function registerGridCommand(program2) {
       live,
       assetIndices,
       strategyAddress,
+      stateDir,
       config: {
         ...DEFAULT_GRID_CONFIG,
         tokens,
@@ -6856,8 +6928,8 @@ function registerGridCommand(program2) {
     });
     await loop.start();
   });
-  grid.command("status").description("Show current grid portfolio status").action(async () => {
-    const portfolio = new GridPortfolio();
+  grid.command("status").description("Show current grid portfolio status").option("--state-dir <path>", "Read state from a custom directory (defaults to ~/.sherwood/grid)").action(async (opts) => {
+    const portfolio = new GridPortfolio(opts.stateDir);
     const state = await portfolio.load();
     if (!state) {
       console.log(DIM5("\n  No grid portfolio found. Run `sherwood grid start` first.\n"));
@@ -6977,8 +7049,8 @@ function registerGridCommand(program2) {
     });
     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();
+  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").option("--state-dir <path>", "Read/write state from a custom directory (defaults to ~/.sherwood/grid)").action(async (opts) => {
+    const portfolio = new GridPortfolio(opts.stateDir);
     const state = await portfolio.load();
     if (!state) {
       console.log(DIM5("\n  No grid portfolio found. Nothing to pause.\n"));
@@ -6998,8 +7070,8 @@ function registerGridCommand(program2) {
     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();
+  grid.command("resume").description("Resume a paused grid (clears state.paused)").option("--state-dir <path>", "Read/write state from a custom directory (defaults to ~/.sherwood/grid)").action(async (opts) => {
+    const portfolio = new GridPortfolio(opts.stateDir);
     const state = await portfolio.load();
     if (!state) {
       console.log(DIM5("\n  No grid portfolio found. Nothing to resume.\n"));
@@ -7010,10 +7082,16 @@ function registerGridCommand(program2) {
       return;
     }
     const wasReason = state.pauseReason;
+    const wasCircuitBroken = state.circuitBroken === true;
     state.paused = false;
     state.pauseReason = "";
+    state.circuitBroken = false;
+    state.circuitBrokenAt = 0;
     await portfolio.save(state);
     console.log();
+    if (wasCircuitBroken) {
+      console.log(chalk14.yellow(`  Hard circuit breaker cleared.`));
+    }
     console.log(G5(`  Grid resumed. (was paused: ${wasReason || "<unknown>"})`));
     console.log();
   });