@sherwoodagent/cli 0.42.0 → 0.51.0

package/dist/index.js

@@ -1,15 +1,25 @@
 #!/usr/bin/env node
+import {
+  HyperliquidProvider,
+  getLatestSignals,
+  hlCancelAllOrders,
+  hlGetMeta,
+  hlPlaceLimitOrder,
+  resolveHLCoin
+} from "./chunk-OMW47WOO.js";
 import {
   UniswapProvider,
   applySlippage,
-  chatCompletion,
-  checkApiKeyValid,
   encodeSwapPath,
   getMultiHopQuote,
-  getQuote,
+  getQuote
+} from "./chunk-WMZEOR5W.js";
+import {
+  chatCompletion,
+  checkApiKeyValid,
   listModels,
   provisionApiKey
-} from "./chunk-6U3A6ZJ2.js";
+} from "./chunk-7HJXZ4NM.js";
 import {
   createApproval,
   createJoinRequest,
@@ -20,14 +30,14 @@ import {
   queryJoinRequests,
   revokeJoinRequest,
   stripReferrerPrefix
-} from "./chunk-JNDEZFXW.js";
+} from "./chunk-E6LH2FJ6.js";
 import {
   createSyndicate,
   getActiveSyndicates,
   getSyndicate,
   subdomainExists,
   updateMetadata
-} from "./chunk-4OAZ7TP5.js";
+} from "./chunk-IS2CLLUT.js";
 import {
   approveDepositor,
   deposit,
@@ -51,7 +61,7 @@ import {
   searchSyndicateAcrossChains,
   setTextRecord,
   setVaultAddress
-} from "./chunk-5Q3VT6NQ.js";
+} from "./chunk-R7X33D2S.js";
 import {
   PROPOSAL_STATE,
   PROPOSAL_STATES,
@@ -83,7 +93,7 @@ import {
   setVotingPeriod,
   settleProposal,
   vote
-} from "./chunk-T2IA6CCW.js";
+} from "./chunk-KJ35EF7N.js";
 import {
   AERODROME,
   AGENT_REGISTRY,
@@ -95,7 +105,7 @@ import {
   TOKENS,
   UNISWAP,
   VENICE
-} from "./chunk-XAUMJZU2.js";
+} from "./chunk-FWC57PT7.js";
 import {
   formatContractError,
   getAccount,
@@ -104,7 +114,7 @@ import {
   sendTxWithRetry,
   waitForReceipt,
   writeContractWithRetry
-} from "./chunk-SWKHSKDH.js";
+} from "./chunk-XDBRKW7I.js";
 import {
   CHAIN_REGISTRY,
   VALID_NETWORKS,
@@ -115,7 +125,7 @@ import {
   isTestnet,
   setNetwork,
   withNetwork
-} from "./chunk-FOOZC4AM.js";
+} from "./chunk-2LRC7I33.js";
 import {
   addSyndicate,
   cacheGroupId,
@@ -131,6 +141,7 @@ import {
   getVeniceApiKey,
   loadConfig,
   setAgentId,
+  setAnthropicApiKey,
   setChainContract,
   setConfigRpcUrl,
   setNotifyTo,
@@ -138,7 +149,7 @@ import {
   setPrivateKey,
   setUniswapApiKey,
   setVeniceApiKey
-} from "./chunk-4EHI4SKM.js";
+} from "./chunk-2W4KGGPU.js";
 import {
   BASE_STRATEGY_ABI,
   ERC20_ABI,
@@ -157,8 +168,8 @@ import {
 import { config as loadDotenv } from "dotenv";
 import { createRequire } from "module";
 import { Command, Option } from "commander";
-import { parseUnits as parseUnits6, formatUnits as formatUnits5, isAddress as isAddress6 } from "viem";
-import chalk9 from "chalk";
+import { parseUnits as parseUnits7, formatUnits as formatUnits5, isAddress as isAddress6 } from "viem";
+import chalk15 from "chalk";
 import ora8 from "ora";
 import { input, confirm, select } from "@inquirer/prompts";
 
@@ -1447,9 +1458,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-KH7RNH2E.js");
+    const { propose: propose2 } = await import("./governor-MG5VVSU4.js");
     const { pinJSON } = await import("./ipfs-IGXLLJCF.js");
-    const { parseDuration: parseDuration2 } = await import("./governor-KH7RNH2E.js");
+    const { parseDuration: parseDuration2 } = await import("./governor-MG5VVSU4.js");
     const performanceFeeBps = BigInt(opts.performanceFee);
     if (performanceFeeBps < 0n || performanceFeeBps > 10000n) {
       console.error(chalk.red("--performance-fee must be 0-10000 (basis points)"));
@@ -1556,7 +1567,7 @@ function registerStrategyTemplateCommands(strategy2) {
       let prices = [];
       let priceSource = null;
       try {
-        const { getTokenPricesInAsset } = await import("./price-TTQWI672.js");
+        const { getTokenPricesInAsset } = await import("./price-WCCXWPDM.js");
         prices = await getTokenPricesInAsset({
           tokens: allocations.map((a, i) => ({
             token: a.token,
@@ -1986,7 +1997,7 @@ function registerVeniceCommands(program2) {
       console.log(chalk2.dim(`  Key: ${apiKey.slice(0, 8)}...${apiKey.slice(-4)}`));
       console.log(chalk2.dim("  Saved to ~/.sherwood/config.json"));
       try {
-        const { createVeniceProvisionAttestation, getEasScanUrl: getEasScanUrl2 } = await import("./eas-KBU2BAOD.js");
+        const { createVeniceProvisionAttestation, getEasScanUrl: getEasScanUrl2 } = await import("./eas-PEEWGSAO.js");
         const { uid } = await createVeniceProvisionAttestation(account.address);
         if (uid !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
           console.log(chalk2.dim(`  Attested: ${getEasScanUrl2(uid)}`));
@@ -2342,12 +2353,12 @@ ${opts.prompt}`;
         console.log(chalk2.dim(`Model: ${result.model} | Tokens: ${result.usage.promptTokens} in, ${result.usage.completionTokens} out, ${result.usage.totalTokens} total`));
       }
       try {
-        const { createVeniceInferenceAttestation, getEasScanUrl: getEasScanUrl2 } = await import("./eas-KBU2BAOD.js");
-        const { keccak256, toHex, isAddress: isAddr } = await import("viem");
-        const { getChainContracts: getChainContracts2 } = await import("./config-YRERDZSL.js");
-        const { getChain: getActiveChain } = await import("./network-3HB46JMQ.js");
+        const { createVeniceInferenceAttestation, getEasScanUrl: getEasScanUrl2 } = await import("./eas-PEEWGSAO.js");
+        const { keccak256: keccak2562, toHex, isAddress: isAddr } = await import("viem");
+        const { getChainContracts: getChainContracts2 } = await import("./config-REASKDIK.js");
+        const { getChain: getActiveChain } = await import("./network-3ZU7UBDU.js");
         const vaultRecipient = opts.vault && isAddr(opts.vault) ? opts.vault : getChainContracts2(getActiveChain().id).vault;
-        const promptHash = keccak256(toHex(userContent)).slice(0, 18);
+        const promptHash = keccak2562(toHex(userContent)).slice(0, 18);
         const { uid } = await createVeniceInferenceAttestation(
           result.model,
           result.usage.promptTokens,
@@ -3518,8 +3529,8 @@ function printSimulationResult(result, callType) {
 }
 async function sendSimulationAlert(subdomain, proposalId, vault, execResult, settleResult) {
   try {
-    const xmtp = await import("./xmtp-JO7W6RFK.js");
-    const { getAccount: getAccount2 } = await import("./client-DRVUILER.js");
+    const xmtp = await import("./xmtp-ACB2W573.js");
+    const { getAccount: getAccount2 } = await import("./client-UHHCB6EZ.js");
     const group = await xmtp.getGroup("", subdomain);
     const allRisks = [...execResult.risks, ...settleResult?.risks ?? []];
     const criticals = allRisks.filter((r) => r.level === "critical");
@@ -4610,6 +4621,1143 @@ function registerGuardianCommands(program2) {
   });
 }
 
+// src/commands/grid.ts
+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";
+
+// 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 { homedir } from "os";
+var GRID_STATE_PATH = join(homedir(), ".sherwood", "grid", "portfolio.json");
+function emptyStats() {
+  return {
+    totalRoundTrips: 0,
+    totalPnlUsd: 0,
+    todayPnlUsd: 0,
+    totalFills: 0,
+    todayFills: 0,
+    lastDailyReset: 0,
+    lastRebalanceAt: 0
+  };
+}
+var GridPortfolio = class {
+  state = null;
+  /** Load grid state from disk. Returns null if no grid initialized yet. */
+  async load() {
+    try {
+      const raw = await readFile(GRID_STATE_PATH, "utf-8");
+      this.state = JSON.parse(raw);
+      return this.state;
+    } catch {
+      return null;
+    }
+  }
+  /** 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 writeFile(tmp, JSON.stringify(state, null, 2), "utf-8");
+    await rename(tmp, GRID_STATE_PATH);
+  }
+  /**
+   * Initialize the grid by carving capital from the directional portfolio.
+   * Called once on first startup when grid-portfolio.json doesn't exist.
+   *
+   * Returns the USD amount carved out (caller must deduct from directional portfolio).
+   */
+  async initialize(capital, config) {
+    const allocation = capital;
+    const grids = config.tokens.map((token) => ({
+      token,
+      levels: [],
+      openFills: [],
+      allocation: allocation * (config.tokenSplit[token] ?? 1 / config.tokens.length),
+      stats: emptyStats(),
+      centerPrice: 0,
+      atr: 0
+    }));
+    const state = {
+      totalAllocation: allocation,
+      grids,
+      paused: false,
+      pauseReason: "",
+      initializedAt: Date.now()
+    };
+    await this.save(state);
+    this.state = state;
+  }
+  /** Get current state (must load() first). */
+  getState() {
+    return this.state;
+  }
+  /** Reset daily counters if UTC day boundary crossed. */
+  resetDailyStats(state) {
+    const now = Date.now();
+    const todayMidnight = /* @__PURE__ */ new Date();
+    todayMidnight.setUTCHours(0, 0, 0, 0);
+    const todayMs = todayMidnight.getTime();
+    let changed = false;
+    for (const grid of state.grids) {
+      if (!grid.stats.lastDailyReset || grid.stats.lastDailyReset < todayMs) {
+        grid.stats.todayPnlUsd = 0;
+        grid.stats.todayFills = 0;
+        grid.stats.lastDailyReset = now;
+        changed = true;
+      }
+    }
+    return changed;
+  }
+  /** Check if grid should be paused (pool dropped below threshold). */
+  checkPauseThreshold(state, config) {
+    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;
+    }, 0);
+    const dropPct = 1 - currentValue / state.totalAllocation;
+    if (dropPct >= config.pauseThresholdPct) {
+      state.paused = true;
+      state.pauseReason = `Grid pool dropped ${(dropPct * 100).toFixed(1)}% (threshold: ${(config.pauseThresholdPct * 100).toFixed(0)}%)`;
+      return true;
+    }
+    return false;
+  }
+  /** Aggregate stats across all token grids. */
+  aggregateStats(state) {
+    return {
+      totalPnlUsd: state.grids.reduce((s, g) => s + g.stats.totalPnlUsd, 0),
+      todayPnlUsd: state.grids.reduce((s, g) => s + g.stats.todayPnlUsd, 0),
+      todayFills: state.grids.reduce((s, g) => s + g.stats.todayFills, 0),
+      totalRoundTrips: state.grids.reduce((s, g) => s + g.stats.totalRoundTrips, 0)
+    };
+  }
+};
+
+// src/grid/manager.ts
+var GridManager = class {
+  config;
+  portfolio;
+  hl;
+  constructor(config) {
+    this.config = config;
+    this.portfolio = new GridPortfolio();
+    this.hl = new HyperliquidProvider();
+  }
+  /** Load or initialize grid state.
+   *  Also syncs new tokens added to config after initial grid setup. */
+  async init(totalPortfolioValue) {
+    const existing = await this.portfolio.load();
+    if (!existing) {
+      await this.portfolio.initialize(totalPortfolioValue, this.config);
+      return;
+    }
+    let addedAllocation = 0;
+    for (const token of this.config.tokens) {
+      if (!existing.grids.find((g) => g.token === token)) {
+        const split = this.config.tokenSplit[token] ?? 1 / this.config.tokens.length;
+        const alloc = existing.totalAllocation * split;
+        existing.grids.push({
+          token,
+          levels: [],
+          openFills: [],
+          allocation: alloc,
+          stats: { totalRoundTrips: 0, totalPnlUsd: 0, todayPnlUsd: 0, totalFills: 0, todayFills: 0, lastDailyReset: 0, lastRebalanceAt: 0 },
+          centerPrice: 0,
+          atr: 0
+        });
+        addedAllocation += alloc;
+        console.error(`  [grid] Added new token grid: ${token} ($${alloc.toFixed(0)} allocation)`);
+      }
+    }
+    if (addedAllocation > 0) {
+      await this.portfolio.save(existing);
+    }
+  }
+  /**
+   * Run one grid tick — called every cycle from the agent loop.
+   *
+   * 1. Load state + reset daily counters
+   * 2. For each token grid: fetch price, simulate fills, check rebalance
+   * 3. Persist state
+   *
+   * Returns a summary for the cycle log.
+   */
+  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 (regime === "high-volatility") {
+      console.error(chalk9.dim(`  [grid] Paused: high-volatility regime \u2014 too risky for grid`));
+      return { fills: 0, roundTrips: 0, pnlUsd: 0, paused: false };
+    }
+    this.portfolio.resetDailyStats(state);
+    let totalFills = 0;
+    let totalRoundTrips = 0;
+    let totalPnl = 0;
+    for (const grid of state.grids) {
+      const price = prices[grid.token];
+      if (!price || price <= 0) continue;
+      if (grid.levels.length === 0 || this.needsFullRebuild(grid)) {
+        await this.buildGrid(grid, price);
+      }
+      const { fills, roundTrips, pnlUsd } = this.simulateFills(grid, price);
+      totalFills += fills;
+      totalRoundTrips += roundTrips;
+      totalPnl += pnlUsd;
+      if (this.needsShift(grid, price)) {
+        await this.shiftGrid(grid, price);
+      }
+    }
+    this.portfolio.checkPauseThreshold(state, this.config);
+    await this.portfolio.save(state);
+    return { fills: totalFills, roundTrips: totalRoundTrips, pnlUsd: totalPnl, paused: false };
+  }
+  /** 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);
+    if (!candles || candles.length < this.config.atrPeriod) {
+      console.error(chalk9.dim(`  [grid] Cannot build grid for ${grid.token}: insufficient candle data`));
+      return;
+    }
+    const signals = getLatestSignals(candles);
+    const atr = signals.atr;
+    if (!Number.isFinite(atr) || atr <= 0) {
+      console.error(chalk9.dim(`  [grid] Cannot build grid for ${grid.token}: invalid ATR (${atr})`));
+      return;
+    }
+    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++) {
+      levels.push({
+        price: currentPrice - spacing * i,
+        side: "buy",
+        quantity,
+        filled: false,
+        filledAt: 0
+      });
+    }
+    for (let i = 1; i <= this.config.levelsPerSide; i++) {
+      levels.push({
+        price: currentPrice + spacing * i,
+        side: "sell",
+        quantity,
+        filled: false,
+        filledAt: 0
+      });
+    }
+    grid.levels = levels;
+    grid.centerPrice = currentPrice;
+    grid.atr = atr;
+    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)}`
+    ));
+  }
+  /** Simulate order fills against the current price. */
+  simulateFills(grid, currentPrice) {
+    let fills = 0;
+    let roundTrips = 0;
+    let pnlUsd = 0;
+    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 };
+    for (const level of grid.levels) {
+      if (level.filled) continue;
+      if (level.side === "buy" && currentPrice <= level.price) {
+        level.filled = true;
+        level.filledAt = now;
+        fills++;
+        grid.stats.totalFills++;
+        grid.stats.todayFills++;
+        grid.openFills.push({
+          token: grid.token,
+          buyPrice: level.price,
+          targetSellPrice: level.price + spacing,
+          quantity: level.quantity,
+          filledAt: now,
+          closed: false,
+          pnlUsd: 0,
+          closedAt: 0
+        });
+        console.error(chalk9.dim(
+          `  [grid] BUY fill ${grid.token} @ $${level.price.toFixed(2)} qty=${level.quantity.toFixed(6)}`
+        ));
+      }
+      if (level.side === "sell" && currentPrice >= level.price) {
+        level.filled = true;
+        level.filledAt = now;
+        fills++;
+        grid.stats.totalFills++;
+        grid.stats.todayFills++;
+        console.error(chalk9.dim(
+          `  [grid] SELL level ${grid.token} @ $${level.price.toFixed(2)} qty=${level.quantity.toFixed(6)}`
+        ));
+      }
+    }
+    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 (profit >= this.config.minProfitPerFillUsd) {
+          openFill.closed = true;
+          openFill.pnlUsd = profit;
+          openFill.closedAt = now;
+          pnlUsd += profit;
+          roundTrips++;
+          grid.stats.totalRoundTrips++;
+          grid.stats.totalPnlUsd += profit;
+          grid.stats.todayPnlUsd += profit;
+          grid.allocation += profit;
+          console.error(chalk9.green(
+            `  [grid] ROUND-TRIP ${grid.token}: buy $${openFill.buyPrice.toFixed(2)} \u2192 sell $${currentPrice.toFixed(2)} = +$${profit.toFixed(2)}`
+          ));
+        }
+      }
+    }
+    const pruneThreshold = now - 24 * 60 * 60 * 1e3;
+    grid.openFills = grid.openFills.filter((f) => !f.closed || f.closedAt > pruneThreshold);
+    return { fills, roundTrips, pnlUsd };
+  }
+  /** Check if the grid needs a full rebuild. */
+  needsFullRebuild(grid) {
+    if (grid.levels.length === 0) return true;
+    const elapsed = Date.now() - grid.stats.lastRebalanceAt;
+    return elapsed >= this.config.fullRebuildIntervalMs;
+  }
+  /** Check if price has drifted enough to warrant shifting the grid. */
+  needsShift(grid, currentPrice) {
+    if (grid.centerPrice <= 0 || grid.atr <= 0) return false;
+    const range = grid.atr * this.config.atrMultiplier;
+    const distFromCenter = Math.abs(currentPrice - grid.centerPrice);
+    return distFromCenter / range >= this.config.rebalanceDriftPct;
+  }
+  /** Shift the grid to re-center on the current price. */
+  async shiftGrid(grid, currentPrice) {
+    console.error(chalk9.dim(
+      `  [grid] Shifting ${grid.token} grid: center $${grid.centerPrice.toFixed(2)} \u2192 $${currentPrice.toFixed(2)}`
+    ));
+    await this.buildGrid(grid, currentPrice);
+  }
+  /** Get open fill exposure per token — used by the hedge manager. */
+  getOpenFillExposure() {
+    const state = this.portfolio.getState();
+    if (!state) return [];
+    return state.grids.map((g) => {
+      const opens = g.openFills.filter((f) => !f.closed);
+      const totalQty = opens.reduce((s, f) => s + f.quantity, 0);
+      const totalNotional = opens.reduce((s, f) => s + f.quantity * f.buyPrice, 0);
+      return {
+        token: g.token,
+        totalQuantity: totalQty,
+        totalNotional,
+        avgEntryPrice: totalQty > 0 ? totalNotional / totalQty : 0,
+        fillCount: opens.length
+      };
+    }).filter((e) => e.fillCount > 0);
+  }
+  /**
+   * Compute the orders that should be placed for the current grid state,
+   * without simulating fills. Used by the live executor.
+   *
+   * Returns:
+   *   - ordersToPlace: all current grid levels that haven't been filled
+   *   - assetsToCancel: tokens whose grid was rebalanced (need cancel-and-place)
+   *   - needsRebalance: whether any grid was rebuilt this tick
+   */
+  computeOrders(prices) {
+    const state = this.portfolio.getState();
+    if (!state || state.paused || !this.config.enabled) {
+      return { ordersToPlace: [], assetsToCancel: [], needsRebalance: false };
+    }
+    const ordersToPlace = [];
+    const assetsToCancel = [];
+    let needsRebalance = false;
+    for (const grid of state.grids) {
+      const price = prices[grid.token];
+      if (!price || price <= 0) continue;
+      const wasEmpty = grid.levels.length === 0;
+      const fullRebuild = wasEmpty || this.needsFullRebuild(grid);
+      const shift = !fullRebuild && grid.centerPrice > 0 && this.needsShift(grid, price);
+      if (fullRebuild || shift) {
+        needsRebalance = true;
+        if (!wasEmpty) assetsToCancel.push(grid.token);
+      }
+      for (const level of grid.levels) {
+        if (level.filled) continue;
+        ordersToPlace.push({
+          token: grid.token,
+          isBuy: level.side === "buy",
+          price: level.price,
+          quantity: level.quantity
+        });
+      }
+    }
+    return { ordersToPlace, assetsToCancel, needsRebalance };
+  }
+  /** Get aggregate stats for display. */
+  getStats() {
+    const state = this.portfolio.getState();
+    if (!state) return null;
+    const agg = this.portfolio.aggregateStats(state);
+    return {
+      ...agg,
+      allocation: state.totalAllocation,
+      paused: state.paused
+    };
+  }
+};
+
+// src/grid/config.ts
+var DEFAULT_GRID_CONFIG = {
+  enabled: true,
+  tokens: ["bitcoin", "ethereum", "solana"],
+  allocationPct: 0.5,
+  leverage: 5,
+  // was 4 — +25% profit per RT
+  levelsPerSide: 15,
+  atrMultiplier: 2,
+  atrPeriod: 14,
+  rebalanceDriftPct: 0.4,
+  // was 0.55 — rebalance faster, keep levels near price
+  fullRebuildIntervalMs: 12 * 60 * 60 * 1e3,
+  // 12h
+  tokenSplit: { bitcoin: 0.45, ethereum: 0.3, solana: 0.25 },
+  minProfitPerFillUsd: 0.5,
+  pauseThresholdPct: 0.2
+};
+
+// 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 chalk10 from "chalk";
+var HEDGE_RATIO = 0.3;
+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;
+  async load() {
+    if (this.state) return this.state;
+    try {
+      const raw = await readFile2(HEDGE_STATE_PATH, "utf-8");
+      this.state = JSON.parse(raw);
+    } catch {
+      this.state = {
+        positions: [],
+        totalRealizedPnl: 0,
+        todayRealizedPnl: 0,
+        lastDailyReset: Date.now()
+      };
+    }
+    const todayMidnight = /* @__PURE__ */ new Date();
+    todayMidnight.setUTCHours(0, 0, 0, 0);
+    if (this.state.lastDailyReset < todayMidnight.getTime()) {
+      this.state.todayRealizedPnl = 0;
+      this.state.lastDailyReset = Date.now();
+    }
+    return this.state;
+  }
+  async save() {
+    if (!this.state) return;
+    await mkdir2(dirname2(HEDGE_STATE_PATH), { recursive: true });
+    const tmp = `${HEDGE_STATE_PATH}.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);
+  }
+  /**
+   * 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
+   */
+  async tick(openFills, prices) {
+    const state = await this.load();
+    let adjustments = 0;
+    let unrealizedPnl = 0;
+    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 existing = state.positions.find((p) => p.token === fill.token);
+      if (desiredShortQty <= 0) {
+        if (existing && existing.quantity > 0) {
+          const closePnl = (existing.entryPrice - price) * existing.quantity;
+          state.totalRealizedPnl += closePnl;
+          state.todayRealizedPnl += closePnl;
+          existing.realizedPnl += closePnl;
+          console.error(chalk10.yellow(
+            `  [hedge] CLOSE ${fill.token} short ${existing.quantity.toFixed(6)} @ $${price.toFixed(2)} PnL: $${closePnl.toFixed(2)}`
+          ));
+          existing.quantity = 0;
+          existing.entryPrice = 0;
+          adjustments++;
+        }
+        continue;
+      }
+      if (!existing) {
+        state.positions.push({
+          token: fill.token,
+          entryPrice: price,
+          quantity: desiredShortQty,
+          lastAdjustedAt: Date.now(),
+          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)`
+        ));
+        adjustments++;
+      } else if (existing.quantity > 0) {
+        const diff = Math.abs(desiredShortQty - existing.quantity) / existing.quantity;
+        if (diff > ADJUSTMENT_THRESHOLD) {
+          if (desiredShortQty > existing.quantity) {
+            const addQty = desiredShortQty - existing.quantity;
+            const newAvgEntry = (existing.entryPrice * existing.quantity + price * addQty) / desiredShortQty;
+            existing.entryPrice = newAvgEntry;
+            existing.quantity = desiredShortQty;
+            existing.lastAdjustedAt = Date.now();
+            console.error(chalk10.magenta(
+              `  [hedge] INCREASE ${fill.token} short to ${desiredShortQty.toFixed(6)} @ avg $${newAvgEntry.toFixed(2)}`
+            ));
+            adjustments++;
+          } else {
+            const closeQty = existing.quantity - desiredShortQty;
+            const closePnl = (existing.entryPrice - price) * closeQty;
+            state.totalRealizedPnl += closePnl;
+            state.todayRealizedPnl += closePnl;
+            existing.realizedPnl += closePnl;
+            existing.quantity = desiredShortQty;
+            existing.lastAdjustedAt = Date.now();
+            console.error(chalk10.magenta(
+              `  [hedge] DECREASE ${fill.token} short to ${desiredShortQty.toFixed(6)}, closed ${closeQty.toFixed(6)} PnL: $${closePnl.toFixed(2)}`
+            ));
+            adjustments++;
+          }
+        }
+        const uPnl = (existing.entryPrice - price) * existing.quantity;
+        unrealizedPnl += uPnl;
+      } else {
+        existing.entryPrice = price;
+        existing.quantity = desiredShortQty;
+        existing.lastAdjustedAt = Date.now();
+        console.error(chalk10.magenta(
+          `  [hedge] REOPEN ${fill.token} short ${desiredShortQty.toFixed(6)} @ $${price.toFixed(2)}`
+        ));
+        adjustments++;
+      }
+    }
+    for (const pos of state.positions) {
+      if (pos.quantity <= 0) continue;
+      if (!openFills.find((f) => f.token === pos.token)) {
+        const price = prices[pos.token];
+        if (price) {
+          const closePnl = (pos.entryPrice - price) * pos.quantity;
+          state.totalRealizedPnl += closePnl;
+          state.todayRealizedPnl += closePnl;
+          pos.realizedPnl += closePnl;
+          console.error(chalk10.yellow(
+            `  [hedge] CLOSE orphaned ${pos.token} short, PnL: $${closePnl.toFixed(2)}`
+          ));
+          pos.quantity = 0;
+          adjustments++;
+        }
+      }
+    }
+    await this.save();
+    return {
+      adjustments,
+      unrealizedPnl,
+      totalRealizedPnl: state.totalRealizedPnl
+    };
+  }
+  /** Get current hedge status for display. */
+  getStatus() {
+    if (!this.state) return null;
+    return {
+      positions: this.state.positions.filter((p) => p.quantity > 0),
+      totalRealizedPnl: this.state.totalRealizedPnl,
+      todayRealizedPnl: this.state.todayRealizedPnl
+    };
+  }
+};
+
+// src/grid/executor.ts
+import chalk11 from "chalk";
+var GridExecutor = class {
+  cfg;
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  /**
+   * Execute the order plan against Hyperliquid.
+   * Cancels stale orders for rebalanced tokens, then places new orders.
+   */
+  async execute(plan) {
+    const errors = [];
+    let cancelled = 0;
+    let placed = 0;
+    for (const token of plan.assetsToCancel) {
+      const coin = resolveHLCoin(token);
+      if (!coin) {
+        errors.push(`No HL ticker for ${token}`);
+        continue;
+      }
+      try {
+        await hlCancelAllOrders(coin);
+        cancelled++;
+        console.error(chalk11.dim(`  [grid-exec] Cancelled all orders for ${coin}`));
+      } catch (e) {
+        errors.push(`Cancel ${coin} failed: ${e.message}`);
+      }
+    }
+    for (const order of plan.ordersToPlace) {
+      const coin = resolveHLCoin(order.token);
+      if (!coin) {
+        errors.push(`No HL ticker for ${order.token}`);
+        continue;
+      }
+      try {
+        const res = await hlPlaceLimitOrder(coin, order.isBuy, order.quantity, order.price);
+        if (res.success) {
+          placed++;
+        } else {
+          errors.push(`Place ${coin} ${order.isBuy ? "buy" : "sell"} @${order.price}: ${res.error}`);
+        }
+      } catch (e) {
+        errors.push(`Place ${coin} threw: ${e.message}`);
+      }
+    }
+    return { placed, cancelled, errors };
+  }
+};
+
+// 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 { encodeAbiParameters as encodeAbiParameters10, parseUnits as parseUnits6 } from "viem";
+
+// src/grid/cloid.ts
+import { keccak256, encodeAbiParameters as encodeAbiParameters9 } from "viem";
+function gridCloid(strategy2, assetIndex, isBuy, levelIndex, nonce) {
+  const hash = keccak256(
+    encodeAbiParameters9(
+      [
+        { type: "address" },
+        { type: "uint32" },
+        { type: "bool" },
+        { type: "uint32" },
+        { type: "uint32" }
+      ],
+      [strategy2, assetIndex, isBuy, levelIndex, nonce]
+    )
+  );
+  const top16 = hash.slice(0, 2 + 32);
+  return BigInt(top16);
+}
+
+// src/grid/strategy-abi.ts
+var HYPERLIQUID_GRID_STRATEGY_ABI = [
+  {
+    type: "function",
+    name: "updateParams",
+    inputs: [{ name: "data", type: "bytes" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
+
+// 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;
+var ACTION_CANCEL_AND_PLACE = 3;
+var GRID_ORDER_COMPONENTS = [
+  { name: "assetIndex", type: "uint32" },
+  { name: "isBuy", type: "bool" },
+  { name: "limitPx", type: "uint64" },
+  { name: "sz", type: "uint64" },
+  { name: "cloid", type: "uint128" }
+];
+var OnchainGridExecutor = class {
+  cfg;
+  nonces = /* @__PURE__ */ new Map();
+  placedCloids = /* @__PURE__ */ new Map();
+  meta = null;
+  busy = false;
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  /** Load persisted state. Call once before the first execute(). */
+  async load() {
+    try {
+      const raw = await readFile3(ONCHAIN_STATE_PATH, "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)) {
+        this.placedCloids.set(tok, cloids.map((s) => BigInt(s)));
+      }
+      console.error(chalk12.dim(`  [grid-onchain] Loaded state: ${this.nonces.size} tokens`));
+    } catch (e) {
+      const code = e.code;
+      if (code === "ENOENT") {
+      } else {
+        console.error(
+          chalk12.yellow(
+            `  [grid-onchain] Failed to load state (${e.message}) \u2014 starting fresh. Existing on-chain orders may be orphaned.`
+          )
+        );
+      }
+    }
+    if (!this.meta) this.meta = await hlGetMeta();
+  }
+  /**
+   * Atomic save: write to .tmp, then POSIX-rename. A crash mid-write leaves
+   * either the old file intact or the new file fully written — never a
+   * partial JSON that would crash load() on restart.
+   */
+  async save() {
+    const state = {
+      nonces: Object.fromEntries(this.nonces),
+      placedCloids: Object.fromEntries(
+        [...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 writeFile3(tmp, JSON.stringify(state, null, 2));
+    await rename2(tmp, ONCHAIN_STATE_PATH);
+  }
+  /**
+   * Execute the order plan: cancel stale orders for rebalanced tokens, then
+   * place new orders. Each (token) is one tx. Persists state after each tx
+   * so a crash mid-execution still leaves a recoverable on-disk record.
+   *
+   * Concurrency-guarded: a second concurrent call returns immediately rather
+   * than racing tx submission against another in-flight execute().
+   */
+  async execute(plan) {
+    if (this.busy) {
+      return { placed: 0, cancelled: 0, txs: [], errors: ["execute() already in flight \u2014 skipping"] };
+    }
+    this.busy = true;
+    try {
+      if (!this.meta) await this.load();
+      const errors = [];
+      const txs = [];
+      let placed = 0;
+      let cancelled = 0;
+      const ordersByToken = /* @__PURE__ */ new Map();
+      for (const o of plan.ordersToPlace) {
+        if (!ordersByToken.has(o.token)) ordersByToken.set(o.token, []);
+        ordersByToken.get(o.token).push(o);
+      }
+      const cancelSet = new Set(plan.assetsToCancel);
+      const allTokens = /* @__PURE__ */ new Set([...ordersByToken.keys(), ...cancelSet]);
+      for (const token of allTokens) {
+        const assetIndex = this.cfg.assetIndices[token];
+        if (assetIndex === void 0) {
+          errors.push(`No asset index for ${token}`);
+          continue;
+        }
+        const coin = resolveHLCoin(token);
+        if (!coin) {
+          errors.push(`No HL ticker for ${token}`);
+          continue;
+        }
+        const meta = this.meta.get(coin);
+        if (!meta) {
+          errors.push(`No HL meta for ${coin} (run \`sherwood grid status\` to refresh)`);
+          continue;
+        }
+        const wantCancel = cancelSet.has(token);
+        const orders = ordersByToken.get(token) ?? [];
+        const wantPlace = orders.length > 0;
+        try {
+          if (wantCancel && wantPlace) {
+            const tx = await this.cancelAndPlace(token, assetIndex, orders, meta);
+            txs.push(tx);
+            cancelled += 1;
+            placed += orders.length;
+          } else if (wantCancel) {
+            const tx = await this.cancelAll(token, assetIndex);
+            txs.push(tx);
+            cancelled += 1;
+          } else if (wantPlace) {
+            const tx = await this.placeGrid(token, assetIndex, orders, meta);
+            txs.push(tx);
+            placed += orders.length;
+          }
+          await this.save();
+        } catch (e) {
+          errors.push(`${token}: ${e.message}`);
+        }
+      }
+      return { placed, cancelled, txs, errors };
+    } finally {
+      this.busy = false;
+    }
+  }
+  currentNonce(token) {
+    return this.nonces.get(token) ?? 0;
+  }
+  bumpNonce(token) {
+    const next = this.currentNonce(token) + 1;
+    this.nonces.set(token, next);
+    return next;
+  }
+  /**
+   * Pure encoding — does NOT mutate placedCloids. Caller commits CLOIDs
+   * only after the on-chain tx confirms successfully.
+   *
+   * Uses viem's `parseUnits` for decimal scaling instead of float math so
+   * high-szDecimals tokens (BTC=5, ETH=4) keep full precision on small sizes.
+   */
+  encodeOrders(assetIndex, orders, meta, nonce) {
+    const cloids = [];
+    const encoded = orders.map((o, i) => {
+      const cloid = gridCloid(this.cfg.strategyAddress, assetIndex, o.isBuy, i, nonce);
+      cloids.push(cloid);
+      const limitPx = parseUnits6(o.price.toFixed(meta.pxDecimals), meta.pxDecimals);
+      const sz = parseUnits6(o.quantity.toFixed(meta.szDecimals), meta.szDecimals);
+      if (limitPx > UINT64_MAX || sz > UINT64_MAX) {
+        throw new Error(
+          `Order exceeds uint64: token=${o.token} px=${limitPx} sz=${sz}`
+        );
+      }
+      return { assetIndex, isBuy: o.isBuy, limitPx, sz, cloid };
+    });
+    return { encoded, cloids };
+  }
+  async placeGrid(token, assetIndex, orders, meta) {
+    const nonce = this.bumpNonce(token);
+    const { encoded, cloids } = this.encodeOrders(assetIndex, orders, meta, nonce);
+    const data = encodeAbiParameters10(
+      [{ 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;
+  }
+  async cancelAll(token, assetIndex) {
+    const cloids = this.placedCloids.get(token) ?? [];
+    if (cloids.length === 0) {
+      this.bumpNonce(token);
+      return "0x";
+    }
+    const data = encodeAbiParameters10(
+      [{ type: "uint8" }, { type: "uint32" }, { type: "uint128[]" }],
+      [ACTION_CANCEL_ALL, assetIndex, cloids]
+    );
+    const tx = await this.send(data);
+    this.placedCloids.set(token, []);
+    this.bumpNonce(token);
+    return tx;
+  }
+  async cancelAndPlace(token, assetIndex, orders, meta) {
+    const oldCloids = this.placedCloids.get(token) ?? [];
+    const newNonce = this.bumpNonce(token);
+    const { encoded, cloids: newCloids } = this.encodeOrders(assetIndex, orders, meta, newNonce);
+    const data = encodeAbiParameters10(
+      [
+        { 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;
+  }
+  /**
+   * Submit and wait for receipt. Throwing here surfaces to the per-token
+   * try/catch in execute(), recording the error and skipping the save() so
+   * placedCloids never reflects orders that didn't land.
+   */
+  async send(data) {
+    const tx = await writeContractWithRetry({
+      address: this.cfg.strategyAddress,
+      abi: HYPERLIQUID_GRID_STRATEGY_ABI,
+      functionName: "updateParams",
+      args: [data]
+    });
+    const pub = getPublicClient();
+    const receipt = await pub.waitForTransactionReceipt({ hash: tx, timeout: 3e4 });
+    if (receipt.status !== "success") {
+      throw new Error(`Tx ${tx} reverted on-chain`);
+    }
+    console.error(chalk12.dim(`  [grid-onchain] tx ${tx.slice(0, 10)}... confirmed`));
+    return tx;
+  }
+};
+
+// src/grid/loop.ts
+var GRID_CYCLES_PATH = join4(homedir4(), ".sherwood", "grid", "cycles.jsonl");
+var GridLoop = class {
+  cfg;
+  gridConfig;
+  manager;
+  hedge;
+  hl;
+  executor = null;
+  running = false;
+  cycleCount = 0;
+  timer = null;
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.gridConfig = { ...DEFAULT_GRID_CONFIG, ...cfg.config };
+    this.manager = new GridManager(this.gridConfig);
+    this.hedge = new GridHedgeManager();
+    this.hl = new HyperliquidProvider();
+    if (cfg.live) {
+      if (!cfg.assetIndices) {
+        throw new Error("assetIndices required when live=true");
+      }
+      if (cfg.strategyAddress) {
+        this.executor = new OnchainGridExecutor({
+          strategyAddress: cfg.strategyAddress,
+          assetIndices: cfg.assetIndices
+        });
+      } else {
+        this.executor = new GridExecutor({ assetIndices: cfg.assetIndices });
+      }
+    }
+  }
+  /** Start the grid loop. Resolves when shut down via SIGINT/SIGTERM. */
+  async start() {
+    this.running = true;
+    const shutdown = () => {
+      console.error(chalk13.yellow("\n  [grid-loop] Shutting down\u2026"));
+      this.running = false;
+      if (this.timer) {
+        clearTimeout(this.timer);
+        this.timer = null;
+      }
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await this.manager.init(this.cfg.capital);
+    if (this.executor instanceof OnchainGridExecutor) {
+      await this.executor.load();
+    }
+    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
+`
+    ));
+    while (this.running) {
+      try {
+        await this.tick();
+      } catch (err) {
+        console.error(chalk13.red(`  [grid-loop] Tick error: ${err.message}`));
+      }
+      if (this.running) {
+        await new Promise((resolve2) => {
+          this.timer = setTimeout(resolve2, this.cfg.cycle);
+        });
+      }
+    }
+    process.off("SIGINT", shutdown);
+    process.off("SIGTERM", shutdown);
+    console.error(chalk13.yellow("  [grid-loop] Stopped."));
+  }
+  /** Execute one grid cycle. */
+  async tick() {
+    this.cycleCount++;
+    const start = Date.now();
+    const prices = {};
+    for (const token of this.gridConfig.tokens) {
+      const data = await this.hl.getHyperliquidData(token);
+      if (data?.markPrice && data.markPrice > 0) {
+        prices[token] = data.markPrice;
+      }
+    }
+    if (Object.keys(prices).length === 0) {
+      console.error(chalk13.dim(`  [grid-loop] #${this.cycleCount} \u2014 no prices, skipping`));
+      return;
+    }
+    const result = await this.manager.tick(prices);
+    const elapsed = Date.now() - start;
+    if (this.executor) {
+      const plan = this.manager.computeOrders(prices);
+      if (plan.ordersToPlace.length > 0 || plan.assetsToCancel.length > 0) {
+        const res = await this.executor.execute(plan);
+        if (res.errors.length > 0) {
+          console.error(chalk13.yellow(`  [grid-loop] Executor errors: ${res.errors.join("; ")}`));
+        }
+        if (res.placed > 0 || res.cancelled > 0) {
+          console.error(chalk13.cyan(`  [grid-loop] Live: placed=${res.placed} cancelled=${res.cancelled}`));
+        }
+      }
+    }
+    if (result.roundTrips > 0) {
+      console.error(chalk13.green(
+        `  [grid-loop] #${this.cycleCount} \u2014 ${result.roundTrips} RT(s), +$${result.pnlUsd.toFixed(2)} PnL, ${result.fills} fill(s) [${elapsed}ms]`
+      ));
+    }
+    if (result.fills > 0 && result.roundTrips === 0) {
+      console.error(chalk13.dim(
+        `  [grid-loop] #${this.cycleCount} \u2014 ${result.fills} fill(s), 0 RTs [${elapsed}ms]`
+      ));
+    }
+    const openExposure = this.manager.getOpenFillExposure();
+    const hedgeResult = await this.hedge.tick(openExposure, prices);
+    if (hedgeResult.adjustments > 0) {
+      console.error(chalk13.magenta(
+        `  [hedge] ${hedgeResult.adjustments} adjustment(s), unrealized: $${hedgeResult.unrealizedPnl.toFixed(2)}, total realized: $${hedgeResult.totalRealizedPnl.toFixed(2)}`
+      ));
+    }
+    const stats = this.manager.getStats();
+    const cycleEntry = {
+      cycleNumber: this.cycleCount,
+      timestamp: Date.now(),
+      gridFills: result.fills,
+      gridRoundTrips: result.roundTrips,
+      gridPnlUsd: result.pnlUsd,
+      totalPnlUsd: stats?.totalPnlUsd ?? 0,
+      todayPnlUsd: stats?.todayPnlUsd ?? 0,
+      totalRoundTrips: stats?.totalRoundTrips ?? 0,
+      allocation: stats?.allocation ?? 0,
+      paused: stats?.paused ?? false,
+      hedgeUnrealizedPnl: hedgeResult.unrealizedPnl,
+      hedgeTotalRealizedPnl: hedgeResult.totalRealizedPnl
+    };
+    try {
+      await mkdir4(join4(homedir4(), ".sherwood", "grid"), { recursive: true });
+      await appendFile(GRID_CYCLES_PATH, JSON.stringify(cycleEntry) + "\n");
+    } catch {
+    }
+    if (this.cycleCount % 60 === 0) {
+      const stats2 = this.manager.getStats();
+      if (stats2) {
+        const hedgeStatus = this.hedge.getStatus();
+        const hedgeInfo = hedgeStatus && hedgeStatus.positions.length > 0 ? ` hedge=$${hedgeResult.unrealizedPnl.toFixed(2)}unr/$${hedgeStatus.totalRealizedPnl.toFixed(2)}real` : "";
+        console.error(chalk13.cyan(
+          `  [grid-loop] Status #${this.cycleCount} \u2014 totalPnL=$${stats2.totalPnlUsd.toFixed(2)} todayPnL=$${stats2.todayPnlUsd.toFixed(2)} RTs=${stats2.totalRoundTrips} alloc=$${stats2.allocation.toFixed(0)}${hedgeInfo}${stats2.paused ? " (PAUSED)" : ""}`
+        ));
+      }
+    }
+  }
+};
+
+// 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 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) => {
+    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 live = !!opts.live;
+    let assetIndices;
+    if (live) {
+      if (!opts.assetIndices) {
+        throw new Error("--asset-indices required when --live (e.g. --asset-indices bitcoin=3,ethereum=4,solana=5)");
+      }
+      assetIndices = {};
+      for (const pair of opts.assetIndices.split(",")) {
+        const [tok, idx] = pair.split("=");
+        if (!tok || !idx) throw new Error(`Bad asset-indices pair: ${pair}`);
+        assetIndices[tok.trim()] = Number(idx);
+      }
+    }
+    const strategyAddress = opts.strategy;
+    if (strategyAddress && !live) {
+      throw new Error("--strategy requires --live");
+    }
+    const weight = 1 / tokens.length;
+    const tokenSplit = {};
+    for (const t of tokens) {
+      tokenSplit[t] = weight;
+    }
+    console.log();
+    console.log(G5.bold("  Grid Strategy"));
+    SEP5();
+    console.log(W5(`  Capital:   $${capital.toLocaleString()}`));
+    console.log(W5(`  Cycle:     ${opts.cycle}s`));
+    console.log(W5(`  Tokens:    ${tokens.join(", ")}`));
+    console.log(W5(`  Leverage:  ${leverage}x`));
+    console.log(W5(`  Levels:    ${levels}/side`));
+    SEP5();
+    const loop = new GridLoop({
+      capital,
+      cycle: cycleMs,
+      live,
+      assetIndices,
+      strategyAddress,
+      config: {
+        ...DEFAULT_GRID_CONFIG,
+        tokens,
+        leverage,
+        levelsPerSide: levels,
+        tokenSplit
+      }
+    });
+    await loop.start();
+  });
+  grid.command("status").description("Show current grid portfolio status").action(async () => {
+    const portfolio = new GridPortfolio();
+    const state = await portfolio.load();
+    if (!state) {
+      console.log(DIM5("\n  No grid portfolio found. Run `sherwood grid start` first.\n"));
+      return;
+    }
+    portfolio.resetDailyStats(state);
+    const agg = portfolio.aggregateStats(state);
+    console.log();
+    console.log(G5.bold("  Grid Portfolio"));
+    SEP5();
+    console.log(W5(`  Allocation:    $${state.totalAllocation.toLocaleString()}`));
+    console.log(W5(`  Status:        ${state.paused ? chalk14.red("PAUSED \u2014 " + state.pauseReason) : G5("Active")}`));
+    console.log(W5(`  Initialized:   ${new Date(state.initializedAt).toLocaleString()}`));
+    SEP5();
+    console.log();
+    console.log(BOLD5("  Token          Alloc       RTs    PnL         Today PnL   Fills"));
+    console.log(DIM5("  " + "\u2500".repeat(72)));
+    for (const g of state.grids) {
+      const name = g.token.padEnd(13);
+      const alloc = `$${g.allocation.toFixed(0)}`.padStart(8);
+      const rts = String(g.stats.totalRoundTrips).padStart(6);
+      const pnl = `$${g.stats.totalPnlUsd.toFixed(2)}`.padStart(10);
+      const todayPnl = `$${g.stats.todayPnlUsd.toFixed(2)}`.padStart(10);
+      const fills = String(g.stats.totalFills).padStart(6);
+      const pnlColor = g.stats.totalPnlUsd >= 0 ? G5 : chalk14.red;
+      const todayColor = g.stats.todayPnlUsd >= 0 ? G5 : chalk14.red;
+      console.log(`  ${W5(name)}  ${alloc}  ${rts}  ${pnlColor(pnl)}  ${todayColor(todayPnl)}  ${fills}`);
+    }
+    console.log(DIM5("  " + "\u2500".repeat(72)));
+    const totalPnlColor = agg.totalPnlUsd >= 0 ? G5 : chalk14.red;
+    const todayTotalColor = agg.todayPnlUsd >= 0 ? G5 : chalk14.red;
+    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();
+  });
+}
+
 // src/index.ts
 try {
   loadDotenv();
@@ -4618,20 +5766,20 @@ try {
 var require2 = createRequire(import.meta.url);
 var { version: CLI_VERSION } = require2("../package.json");
 async function loadXmtp() {
-  return import("./xmtp-JO7W6RFK.js");
+  return import("./xmtp-ACB2W573.js");
 }
 async function loadCron() {
   return import("./cron-EOULYO3R.js");
 }
-var G5 = chalk9.green;
-var W5 = chalk9.white;
-var DIM5 = chalk9.gray;
-var BOLD5 = chalk9.white.bold;
-var LABEL5 = chalk9.green.bold;
-var SEP5 = () => console.log(DIM5("\u2500".repeat(60)));
+var G6 = chalk15.green;
+var W6 = chalk15.white;
+var DIM6 = chalk15.gray;
+var BOLD6 = chalk15.white.bold;
+var LABEL5 = chalk15.green.bold;
+var SEP6 = () => console.log(DIM6("\u2500".repeat(60)));
 function validateAddress(value, name) {
   if (!isAddress6(value)) {
-    console.error(chalk9.red(`Invalid ${name} address: ${value}`));
+    console.error(chalk15.red(`Invalid ${name} address: ${value}`));
     process.exit(1);
   }
   return value;
@@ -4651,7 +5799,7 @@ program.name("sherwood").description("CLI for agent-managed investment syndicate
     process.env.ENABLE_TESTNET = "true";
     if (network !== "base") {
       console.warn(
-        chalk9.yellow("[warn] --testnet ignored, --chain takes precedence")
+        chalk15.yellow("[warn] --testnet ignored, --chain takes precedence")
       );
     } else {
       network = "base-sepolia";
@@ -4659,7 +5807,7 @@ program.name("sherwood").description("CLI for agent-managed investment syndicate
   }
   setNetwork(network);
   if (getNetwork() !== "base") {
-    console.log(chalk9.yellow(`[${getNetwork()}]`));
+    console.log(chalk15.yellow(`[${getNetwork()}]`));
   }
 });
 var syndicate = program.command("syndicate");
@@ -4667,31 +5815,31 @@ syndicate.command("create").description("Create a new syndicate via the factory
   try {
     console.log();
     console.log(LABEL5("  \u25C6 Create Syndicate"));
-    SEP5();
+    SEP6();
     const wallet = getAccount();
-    console.log(DIM5(`  Wallet:  ${wallet.address}`));
-    console.log(DIM5(`  Network: ${getChain().name}`));
-    SEP5();
+    console.log(DIM6(`  Wallet:  ${wallet.address}`));
+    console.log(DIM6(`  Network: ${getChain().name}`));
+    SEP6();
     const savedAgentId = getAgentId();
     const nonInteractive = opts.yes;
     const name = opts.name || (nonInteractive ? (() => {
       throw new Error("--name is required in non-interactive mode (-y)");
     })() : await input({
-      message: G5("Syndicate name"),
+      message: G6("Syndicate name"),
       validate: (v) => v.length > 0 || "Name is required"
     }));
     const subdomain = opts.subdomain || (nonInteractive ? name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "") : await input({
-      message: G5("ENS subdomain"),
+      message: G6("ENS subdomain"),
       default: name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, ""),
       validate: (v) => v.length >= 3 || "Must be at least 3 characters"
     }));
     const description = opts.description || (nonInteractive ? `${name} \u2014 a Sherwood syndicate` : await input({
-      message: G5("Description"),
+      message: G6("Description"),
       default: `${name} \u2014 a Sherwood syndicate`
     }));
-    const agentIdStr = opts.agentId || (savedAgentId ? nonInteractive ? String(savedAgentId) : await input({ message: G5("Agent ID (ERC-8004)"), default: String(savedAgentId) }) : nonInteractive ? "0" : await input({ message: G5("Agent ID (ERC-8004)"), validate: (v) => /^\d+$/.test(v) || "Must be a number" }));
+    const agentIdStr = opts.agentId || (savedAgentId ? nonInteractive ? String(savedAgentId) : await input({ message: G6("Agent ID (ERC-8004)"), default: String(savedAgentId) }) : nonInteractive ? "0" : await input({ message: G6("Agent ID (ERC-8004)"), validate: (v) => /^\d+$/.test(v) || "Must be a number" }));
     const openDeposits = opts.openDeposits !== void 0 ? opts.openDeposits : nonInteractive ? true : await confirm({
-      message: G5("Open deposits? (anyone can deposit)"),
+      message: G6("Open deposits? (anyone can deposit)"),
       default: true
     });
     const ASSET_SYMBOLS = {
@@ -4707,14 +5855,14 @@ syndicate.command("create").description("Create a new syndicate via the factory
         asset = opts.asset;
       } else {
         const supported = Object.keys(ASSET_SYMBOLS).join(", ");
-        console.error(chalk9.red(`  Unknown asset "${opts.asset}". Use a symbol (${supported}) or a 0x address.`));
+        console.error(chalk15.red(`  Unknown asset "${opts.asset}". Use a symbol (${supported}) or a 0x address.`));
         process.exit(1);
       }
     } else if (nonInteractive) {
       asset = TOKENS().USDC !== "0x0000000000000000000000000000000000000000" ? ASSET_SYMBOLS.USDC : ASSET_SYMBOLS.WETH;
     } else {
       const assetChoice = await select({
-        message: G5("Vault asset (what token do depositors provide?)"),
+        message: G6("Vault asset (what token do depositors provide?)"),
         choices: [
           { name: "USDC", value: "USDC", description: "USD Coin (6 decimals)" },
           { name: "WETH", value: "WETH", description: "Wrapped Ether (18 decimals)" }
@@ -4730,25 +5878,25 @@ syndicate.command("create").description("Create a new syndicate via the factory
     const symbol = `sw${assetSymbol}`;
     console.log();
     console.log(LABEL5("  \u25C6 Review"));
-    SEP5();
-    console.log(W5(`  Name:         ${BOLD5(name)}`));
-    console.log(W5(`  ENS:          ${G5(`${subdomain}.sherwoodagent.eth`)}`));
-    console.log(W5(`  Description:  ${DIM5(description)}`));
-    console.log(W5(`  Agent ID:     #${agentIdStr}`));
-    console.log(W5(`  Asset:        ${assetSymbol} (${asset.slice(0, 10)}...)`));
-    console.log(W5(`  Share token:  ${symbol}`));
-    console.log(W5(`  Open deposits: ${openDeposits ? G5("yes") : chalk9.red("no (whitelist)")}`));
-    SEP5();
+    SEP6();
+    console.log(W6(`  Name:         ${BOLD6(name)}`));
+    console.log(W6(`  ENS:          ${G6(`${subdomain}.sherwoodagent.eth`)}`));
+    console.log(W6(`  Description:  ${DIM6(description)}`));
+    console.log(W6(`  Agent ID:     #${agentIdStr}`));
+    console.log(W6(`  Asset:        ${assetSymbol} (${asset.slice(0, 10)}...)`));
+    console.log(W6(`  Share token:  ${symbol}`));
+    console.log(W6(`  Open deposits: ${openDeposits ? G6("yes") : chalk15.red("no (whitelist)")}`));
+    SEP6();
     if (!nonInteractive) {
-      const go = await confirm({ message: G5("Deploy syndicate?"), default: true });
+      const go = await confirm({ message: G6("Deploy syndicate?"), default: true });
       if (!go) {
-        console.log(DIM5("  Cancelled."));
+        console.log(DIM6("  Cancelled."));
         return;
       }
     }
     let metadataURI = opts.metadataUri || "";
     if (!metadataURI) {
-      const spinner2 = ora8({ text: W5("Uploading metadata to IPFS..."), color: "green" }).start();
+      const spinner2 = ora8({ text: W6("Uploading metadata to IPFS..."), color: "green" }).start();
       try {
         const metadata = {
           schema: "sherwood/syndicate/v1",
@@ -4762,9 +5910,9 @@ syndicate.command("create").description("Create a new syndicate via the factory
           links: {}
         };
         metadataURI = await uploadMetadata(metadata);
-        spinner2.succeed(G5(`Metadata pinned: ${DIM5(metadataURI)}`));
+        spinner2.succeed(G6(`Metadata pinned: ${DIM6(metadataURI)}`));
       } catch (err) {
-        spinner2.warn(chalk9.yellow(`IPFS upload failed \u2014 using inline metadata`));
+        spinner2.warn(chalk15.yellow(`IPFS upload failed \u2014 using inline metadata`));
         const json = JSON.stringify({ name, description, subdomain, asset: assetSymbol, openDeposits, createdBy: "@sherwoodagent/cli" });
         metadataURI = `data:application/json;base64,${Buffer.from(json).toString("base64")}`;
       }
@@ -4774,43 +5922,43 @@ syndicate.command("create").description("Create a new syndicate via the factory
       const existingInfo = await getSyndicate(existingId);
       const callerAddress = getAccount().address.toLowerCase();
       if (existingInfo.creator.toLowerCase() !== callerAddress) {
-        console.error(chalk9.red(`
+        console.error(chalk15.red(`
   \u2716 Subdomain '${subdomain}' is already taken by another syndicate.
 `));
         process.exit(1);
       }
-      console.log(chalk9.yellow(`
+      console.log(chalk15.yellow(`
   \u26A0 Syndicate '${subdomain}' already exists \u2014 resuming setup...
 `));
-      const spinner2 = ora8({ text: W5("Resuming setup..."), color: "green" }).start();
+      const spinner2 = ora8({ text: W6("Resuming setup..."), color: "green" }).start();
       const chainId2 = getChain().id;
       setChainContract(chainId2, "vault", existingInfo.vault);
       addSyndicate(chainId2, { subdomain, vault: existingInfo.vault, role: "creator" });
       setPrimarySyndicate(chainId2, subdomain);
-      spinner2.text = W5("Checking agent registration...");
+      spinner2.text = W6("Checking agent registration...");
       try {
         setVaultAddress(existingInfo.vault);
         const isAlreadyAgent = await isAgent(getAccount().address);
         if (!isAlreadyAgent) {
-          spinner2.text = W5("Registering creator as agent...");
+          spinner2.text = W6("Registering creator as agent...");
           await registerAgent(BigInt(agentIdStr), getAccount().address);
         }
       } catch {
       }
-      spinner2.text = W5("Checking chat group...");
+      spinner2.text = W6("Checking chat group...");
       try {
         const xmtp = await loadXmtp();
         const xmtpClient = await xmtp.getXmtpClient();
         try {
           await xmtp.getGroup(xmtpClient, subdomain);
         } catch {
-          spinner2.text = W5("Creating chat group...");
+          spinner2.text = W6("Creating chat group...");
           const groupId = await xmtp.createSyndicateGroup(xmtpClient, subdomain, opts.publicChat);
           await setTextRecord(subdomain, "xmtpGroupId", groupId, existingInfo.vault);
           cacheGroupId(subdomain, groupId);
         }
       } catch {
-        console.warn(chalk9.yellow("\n  \u26A0 Could not set up XMTP chat group"));
+        console.warn(chalk15.yellow("\n  \u26A0 Could not set up XMTP chat group"));
       }
       try {
         const cron = await loadCron();
@@ -4820,19 +5968,19 @@ syndicate.command("create").description("Create a new syndicate via the factory
       spinner2.stop();
       console.log();
       console.log(LABEL5("  \u25C6 Syndicate Setup Resumed"));
-      SEP5();
-      console.log(W5(`  ID:       ${G5(`#${existingId}`)}`));
-      console.log(W5(`  Vault:    ${G5(existingInfo.vault)}`));
-      console.log(W5(`  ENS:      ${G5(`${subdomain}.sherwoodagent.eth`)}`));
-      console.log(W5(`  Chat:     ${DIM5(`sherwood chat ${subdomain}`)}`));
+      SEP6();
+      console.log(W6(`  ID:       ${G6(`#${existingId}`)}`));
+      console.log(W6(`  Vault:    ${G6(existingInfo.vault)}`));
+      console.log(W6(`  ENS:      ${G6(`${subdomain}.sherwoodagent.eth`)}`));
+      console.log(W6(`  Chat:     ${DIM6(`sherwood chat ${subdomain}`)}`));
       const refParam2 = getAgentId() ? `?ref=${getAgentId()}` : "";
-      console.log(W5(`  Share:    ${G5(`https://sherwood.sh/syndicate/${subdomain}${refParam2}`)}`));
-      SEP5();
-      console.log(G5("  \u2713 Syndicate saved to ~/.sherwood/config.json (set as primary)"));
+      console.log(W6(`  Share:    ${G6(`https://sherwood.sh/syndicate/${subdomain}${refParam2}`)}`));
+      SEP6();
+      console.log(G6("  \u2713 Syndicate saved to ~/.sherwood/config.json (set as primary)"));
       console.log();
       return;
     }
-    const spinner = ora8({ text: W5("Deploying vault via factory..."), color: "green" }).start();
+    const spinner = ora8({ text: W6("Deploying vault via factory..."), color: "green" }).start();
     const result = await createSyndicate({
       creatorAgentId: BigInt(agentIdStr),
       metadataURI,
@@ -4847,7 +5995,7 @@ syndicate.command("create").description("Create a new syndicate via the factory
     addSyndicate(chainId, { subdomain, vault: result.vault, role: "creator" });
     setPrimarySyndicate(chainId, subdomain);
     await new Promise((r) => setTimeout(r, 2e3));
-    spinner.text = W5("Registering creator as agent...");
+    spinner.text = W6("Registering creator as agent...");
     try {
       setVaultAddress(result.vault);
       const creatorAddress = getAccount().address;
@@ -4857,9 +6005,9 @@ syndicate.command("create").description("Create a new syndicate via the factory
         // agentAddress = creator EOA (direct execution)
       );
     } catch (regErr) {
-      console.warn(chalk9.yellow("\n  \u26A0 Could not auto-register creator as agent \u2014 register manually with `syndicate add`"));
+      console.warn(chalk15.yellow("\n  \u26A0 Could not auto-register creator as agent \u2014 register manually with `syndicate add`"));
     }
-    spinner.text = W5("Setting up chat...");
+    spinner.text = W6("Setting up chat...");
     try {
       const xmtp = await loadXmtp();
       const xmtpClient = await xmtp.getXmtpClient();
@@ -4870,36 +6018,36 @@ syndicate.command("create").description("Create a new syndicate via the factory
       } catch {
       }
     } catch {
-      console.warn(chalk9.yellow("\n  \u26A0 Could not create XMTP chat group"));
-      console.warn(chalk9.dim(`    Recover later with: sherwood chat ${subdomain} init`));
+      console.warn(chalk15.yellow("\n  \u26A0 Could not create XMTP chat group"));
+      console.warn(chalk15.dim(`    Recover later with: sherwood chat ${subdomain} init`));
     }
     try {
       const cron = await loadCron();
       const cronResult = cron.registerSyndicateCrons(subdomain, isTestnet(), getNotifyTo());
       if (cronResult.isOpenClaw && cronResult.registered) {
-        console.log(G5("  \u2713 Participation crons registered (15m check + hourly summary)"));
+        console.log(G6("  \u2713 Participation crons registered (15m check + hourly summary)"));
       } else if (!cronResult.isOpenClaw) {
-        console.log(DIM5("  Tip: Set up a scheduled process to run `sherwood session check " + subdomain + "` periodically"));
+        console.log(DIM6("  Tip: Set up a scheduled process to run `sherwood session check " + subdomain + "` periodically"));
       }
     } catch {
     }
     spinner.stop();
     console.log();
     console.log(LABEL5("  \u25C6 Syndicate Created"));
-    SEP5();
-    console.log(W5(`  ID:       ${G5(`#${result.syndicateId}`)}`));
-    console.log(W5(`  Vault:    ${G5(result.vault)}`));
-    console.log(W5(`  ENS:      ${G5(`${subdomain}.sherwoodagent.eth`)}`));
-    console.log(W5(`  Metadata: ${DIM5(metadataURI.length > 50 ? metadataURI.slice(0, 50) + "..." : metadataURI)}`));
-    console.log(W5(`  Explorer: ${DIM5(getExplorerUrl(result.hash))}`));
-    console.log(W5(`  Chat:     ${DIM5(`sherwood chat ${subdomain}`)}`));
+    SEP6();
+    console.log(W6(`  ID:       ${G6(`#${result.syndicateId}`)}`));
+    console.log(W6(`  Vault:    ${G6(result.vault)}`));
+    console.log(W6(`  ENS:      ${G6(`${subdomain}.sherwoodagent.eth`)}`));
+    console.log(W6(`  Metadata: ${DIM6(metadataURI.length > 50 ? metadataURI.slice(0, 50) + "..." : metadataURI)}`));
+    console.log(W6(`  Explorer: ${DIM6(getExplorerUrl(result.hash))}`));
+    console.log(W6(`  Chat:     ${DIM6(`sherwood chat ${subdomain}`)}`));
     const refParam = getAgentId() ? `?ref=${getAgentId()}` : "";
-    console.log(W5(`  Share:    ${G5(`https://sherwood.sh/syndicate/${subdomain}${refParam}`)}`));
-    SEP5();
-    console.log(G5("  \u2713 Syndicate saved to ~/.sherwood/config.json (set as primary)"));
+    console.log(W6(`  Share:    ${G6(`https://sherwood.sh/syndicate/${subdomain}${refParam}`)}`));
+    SEP6();
+    console.log(G6("  \u2713 Syndicate saved to ~/.sherwood/config.json (set as primary)"));
     console.log();
   } catch (err) {
-    console.error(chalk9.red(`
+    console.error(chalk15.red(`
   \u2716 ${formatContractError(err)}`));
     process.exit(1);
   }
@@ -4949,38 +6097,38 @@ syndicate.command("list").description("List active syndicates (queries subgraph,
     }
     spinner.stop();
     if (syndicates.length === 0) {
-      console.log(chalk9.dim("No active syndicates found."));
+      console.log(chalk15.dim("No active syndicates found."));
       return;
     }
     console.log();
-    console.log(chalk9.bold(`Active Syndicates (${syndicates.length})`));
+    console.log(chalk15.bold(`Active Syndicates (${syndicates.length})`));
     if (!process.env.SUBGRAPH_URL && !opts.allChains) {
-      console.log(chalk9.dim("  (Set SUBGRAPH_URL for faster indexed queries)"));
+      console.log(chalk15.dim("  (Set SUBGRAPH_URL for faster indexed queries)"));
     }
     if (opts.allChains) {
-      console.log(chalk9.dim("  (Aggregated across chains via on-chain factory calls; SUBGRAPH_URL is single-chain only)"));
+      console.log(chalk15.dim("  (Aggregated across chains via on-chain factory calls; SUBGRAPH_URL is single-chain only)"));
     }
-    console.log(chalk9.dim("\u2500".repeat(70)));
+    console.log(chalk15.dim("\u2500".repeat(70)));
     for (const s of syndicates) {
       const ts = typeof s.createdAt === "string" ? Number(s.createdAt) : Number(s.createdAt);
       const date = new Date(ts * 1e3).toLocaleDateString();
       const ensName = s.subdomain ? `${s.subdomain}.sherwoodagent.eth` : "";
-      const chainTag = s.chain ? chalk9.dim(`[${s.chain}]  `) : "";
-      console.log(`  ${chainTag}#${s.id}  ${chalk9.bold(ensName || String(s.vault))}`);
-      if (ensName) console.log(`    Vault:   ${chalk9.cyan(String(s.vault))}`);
+      const chainTag = s.chain ? chalk15.dim(`[${s.chain}]  `) : "";
+      console.log(`  ${chainTag}#${s.id}  ${chalk15.bold(ensName || String(s.vault))}`);
+      if (ensName) console.log(`    Vault:   ${chalk15.cyan(String(s.vault))}`);
       console.log(`    Creator: ${s.creator}`);
       console.log(`    Created: ${date}`);
       if (s.totalDeposits) {
         console.log(`    Deposits: ${s.totalDeposits} USDC`);
       }
       if (s.metadataURI) {
-        console.log(`    Metadata: ${chalk9.dim(s.metadataURI)}`);
+        console.log(`    Metadata: ${chalk15.dim(s.metadataURI)}`);
       }
       console.log();
     }
   } catch (err) {
     spinner.fail("Failed to load syndicates");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
@@ -5020,38 +6168,38 @@ syndicate.command("info").description("Display syndicate details by ID or subdom
     spinner.stop();
     if (crossChainHint) {
       const others = crossChainHint.others.length > 0 ? ` (also on: ${crossChainHint.others.join(", ")})` : "";
-      console.log(chalk9.yellow(`  Found on chain: ${chalk9.bold(crossChainHint.network)}${others}`));
-      console.log(chalk9.dim(`  Re-run with --chain ${crossChainHint.network} to interact with this syndicate.`));
+      console.log(chalk15.yellow(`  Found on chain: ${chalk15.bold(crossChainHint.network)}${others}`));
+      console.log(chalk15.dim(`  Re-run with --chain ${crossChainHint.network} to interact with this syndicate.`));
       console.log();
     }
     if (!info.vault || info.vault === "0x0000000000000000000000000000000000000000") {
-      console.log(chalk9.red(`Syndicate #${id} not found.`));
+      console.log(chalk15.red(`Syndicate #${id} not found.`));
       process.exit(1);
     }
     const date = new Date(Number(info.createdAt) * 1e3).toLocaleDateString();
     console.log();
-    console.log(chalk9.bold(`Syndicate #${info.id}`));
-    console.log(chalk9.dim("\u2500".repeat(40)));
+    console.log(chalk15.bold(`Syndicate #${info.id}`));
+    console.log(chalk15.dim("\u2500".repeat(40)));
     if (info.subdomain) {
-      console.log(`  ENS:        ${chalk9.bold(`${info.subdomain}.sherwoodagent.eth`)}`);
+      console.log(`  ENS:        ${chalk15.bold(`${info.subdomain}.sherwoodagent.eth`)}`);
     }
-    console.log(`  Vault:      ${chalk9.cyan(info.vault)}`);
+    console.log(`  Vault:      ${chalk15.cyan(info.vault)}`);
     console.log(`  Creator:    ${info.creator}`);
     console.log(`  Created:    ${date}`);
-    console.log(`  Active:     ${info.active ? chalk9.green("yes") : chalk9.red("no")}`);
+    console.log(`  Active:     ${info.active ? chalk15.green("yes") : chalk15.red("no")}`);
     if (info.metadataURI) {
-      console.log(`  Metadata:   ${chalk9.dim(info.metadataURI)}`);
+      console.log(`  Metadata:   ${chalk15.dim(info.metadataURI)}`);
     }
     if (info.subdomain) {
       const xmtpGroupId = getCachedGroupId(info.subdomain);
       if (xmtpGroupId) {
-        console.log(`  XMTP Group: ${chalk9.cyan(xmtpGroupId)}`);
+        console.log(`  XMTP Group: ${chalk15.cyan(xmtpGroupId)}`);
       }
     }
     setVaultAddress(info.vault);
     const vaultInfo = crossChainHint ? await withNetwork(crossChainHint.network, () => getVaultInfo()) : await getVaultInfo();
     console.log();
-    console.log(chalk9.bold("  Vault Stats"));
+    console.log(chalk15.bold("  Vault Stats"));
     console.log(`    Total Assets:       ${vaultInfo.totalAssets}`);
     console.log(`    Agent Count:        ${vaultInfo.agentCount}`);
     console.log(`    Redemptions Locked: ${vaultInfo.redemptionsLocked}`);
@@ -5059,12 +6207,12 @@ syndicate.command("info").description("Display syndicate details by ID or subdom
     console.log();
   } catch (err) {
     spinner.fail("Failed to load syndicate info");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
 syndicate.command("update-metadata").description("Update syndicate metadata (creator only)").requiredOption("--id <id>", "Syndicate ID").option("--name <name>", "Syndicate name").option("--description <text>", "Short description").option("--uri <uri>", "Direct metadata URI (skips IPFS upload)").action(async (opts) => {
-  const spinner = ora8({ text: W5("Loading syndicate..."), color: "green" }).start();
+  const spinner = ora8({ text: W6("Loading syndicate..."), color: "green" }).start();
   try {
     const syndicateId = BigInt(opts.id);
     let metadataURI = opts.uri;
@@ -5076,7 +6224,7 @@ syndicate.command("update-metadata").description("Update syndicate metadata (cre
       }
       const name = opts.name || info.subdomain;
       const description = opts.description || `${name} \u2014 a Sherwood syndicate on ${info.subdomain}.sherwoodagent.eth`;
-      spinner.text = W5("Uploading metadata to IPFS...");
+      spinner.text = W6("Uploading metadata to IPFS...");
       const metadata = {
         schema: "sherwood/syndicate/v1",
         name,
@@ -5087,15 +6235,15 @@ syndicate.command("update-metadata").description("Update syndicate metadata (cre
         links: {}
       };
       metadataURI = await uploadMetadata(metadata);
-      spinner.text = W5("Updating on-chain metadata...");
+      spinner.text = W6("Updating on-chain metadata...");
     }
     const hash = await updateMetadata(syndicateId, metadataURI);
-    spinner.succeed(G5(`Metadata updated`));
-    console.log(DIM5(`  IPFS: ${metadataURI}`));
-    console.log(DIM5(`  ${getExplorerUrl(hash)}`));
+    spinner.succeed(G6(`Metadata updated`));
+    console.log(DIM6(`  IPFS: ${metadataURI}`));
+    console.log(DIM6(`  ${getExplorerUrl(hash)}`));
   } catch (err) {
     spinner.fail("Metadata update failed");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
@@ -5106,10 +6254,10 @@ syndicate.command("approve-depositor").description("Approve an address to deposi
     const depositor = validateAddress(opts.depositor, "depositor");
     const hash = await approveDepositor(depositor);
     spinner.succeed(`Depositor approved: ${hash}`);
-    console.log(chalk9.dim(`  ${getExplorerUrl(hash)}`));
+    console.log(chalk15.dim(`  ${getExplorerUrl(hash)}`));
   } catch (err) {
     spinner.fail("Approval failed");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
@@ -5120,10 +6268,10 @@ syndicate.command("remove-depositor").description("Remove an address from the de
     const depositor = validateAddress(opts.depositor, "depositor");
     const hash = await removeDepositor(depositor);
     spinner.succeed(`Depositor removed: ${hash}`);
-    console.log(chalk9.dim(`  ${getExplorerUrl(hash)}`));
+    console.log(chalk15.dim(`  ${getExplorerUrl(hash)}`));
   } catch (err) {
     spinner.fail("Removal failed");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
@@ -5143,7 +6291,7 @@ syndicate.command("add").description("Register an agent on a syndicate vault (cr
     if (opts.agentId) {
       agentId = BigInt(opts.agentId);
     } else {
-      const { AGENT_REGISTRY: AGENT_REGISTRY2 } = await import("./addresses-DCQMJJFI.js");
+      const { AGENT_REGISTRY: AGENT_REGISTRY2 } = await import("./addresses-DOWLGXGE.js");
       const registry2 = AGENT_REGISTRY2().IDENTITY_REGISTRY;
       if (registry2 === "0x0000000000000000000000000000000000000000") {
         agentId = 0n;
@@ -5164,7 +6312,7 @@ syndicate.command("add").description("Register an agent on a syndicate vault (cr
         });
         if (balance === 0n) {
           spinner.fail("Agent wallet does not own an ERC-8004 identity NFT");
-          console.error(chalk9.dim("  Mint one first: sherwood identity mint --name <name>"));
+          console.error(chalk15.dim("  Mint one first: sherwood identity mint --name <name>"));
           process.exit(1);
         }
         const tokenId = await client.readContract({
@@ -5180,13 +6328,13 @@ syndicate.command("add").description("Register an agent on a syndicate vault (cr
           args: [agentWallet, 0n]
         });
         agentId = tokenId;
-        console.log(chalk9.dim(`  Resolved agent ID: #${agentId}`));
+        console.log(chalk15.dim(`  Resolved agent ID: #${agentId}`));
       }
     }
     spinner.text = "Registering agent...";
     const hash = await registerAgent(agentId, agentWallet);
     spinner.succeed(`Agent registered: ${hash}`);
-    console.log(chalk9.dim(`  ${getExplorerUrl(hash)}`));
+    console.log(chalk15.dim(`  ${getExplorerUrl(hash)}`));
     try {
       const xmtp = await loadXmtp();
       const xmtpClient = await xmtp.getXmtpClient();
@@ -5198,14 +6346,14 @@ syndicate.command("add").description("Register an agent on a syndicate vault (cr
         syndicate: subdomain,
         timestamp: Math.floor(Date.now() / 1e3)
       });
-      console.log(chalk9.dim(`  Added to chat: ${subdomain}`));
+      console.log(chalk15.dim(`  Added to chat: ${subdomain}`));
     } catch {
-      console.warn(chalk9.yellow("  \u26A0 Could not add agent to chat group"));
-      console.warn(chalk9.dim(`    If no group exists, run: sherwood chat ${subdomain} init`));
+      console.warn(chalk15.yellow("  \u26A0 Could not add agent to chat group"));
+      console.warn(chalk15.dim(`    If no group exists, run: sherwood chat ${subdomain} init`));
     }
   } catch (err) {
     spinner.fail("Registration failed");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
@@ -5213,7 +6361,7 @@ syndicate.command("share").description("Print the shareable dashboard URL for yo
   try {
     const subdomain = opts.subdomain || getPrimarySyndicate(getChain().id)?.subdomain;
     if (!subdomain) {
-      console.error(chalk9.red("  No syndicate configured. Pass --subdomain <name> or run 'syndicate create/join' first."));
+      console.error(chalk15.red("  No syndicate configured. Pass --subdomain <name> or run 'syndicate create/join' first."));
       process.exit(1);
     }
     const syndicateInfo = await resolveSyndicate(subdomain);
@@ -5222,12 +6370,12 @@ syndicate.command("share").description("Print the shareable dashboard URL for yo
     const dashboardUrl = `https://sherwood.sh/syndicate/${subdomain}${refParam}`;
     console.log();
     console.log(LABEL5("  \u25C6 Share Your Syndicate"));
-    SEP5();
-    console.log(W5(`  Dashboard:  ${G5(dashboardUrl)}`));
-    console.log(W5(`  ENS:        ${DIM5(`${subdomain}.sherwoodagent.eth`)}`));
-    console.log(W5(`  Vault:      ${DIM5(syndicateInfo.vault)}`));
-    console.log(W5(`  Join CLI:   ${DIM5(`sherwood syndicate join --subdomain ${subdomain}`)}`));
-    SEP5();
+    SEP6();
+    console.log(W6(`  Dashboard:  ${G6(dashboardUrl)}`));
+    console.log(W6(`  ENS:        ${DIM6(`${subdomain}.sherwoodagent.eth`)}`));
+    console.log(W6(`  Vault:      ${DIM6(syndicateInfo.vault)}`));
+    console.log(W6(`  Join CLI:   ${DIM6(`sherwood syndicate join --subdomain ${subdomain}`)}`));
+    SEP6();
     try {
       const { exec } = await import("child_process");
       const platform = (await import("os")).platform();
@@ -5235,12 +6383,12 @@ syndicate.command("share").description("Print the shareable dashboard URL for yo
       const proc = exec(cmd);
       proc.stdin?.write(dashboardUrl);
       proc.stdin?.end();
-      console.log(G5("  \u2713 Dashboard URL copied to clipboard"));
+      console.log(G6("  \u2713 Dashboard URL copied to clipboard"));
     } catch {
     }
     console.log();
   } catch (err) {
-    console.error(chalk9.red(`  \u2716 ${formatContractError(err)}`));
+    console.error(chalk15.red(`  \u2716 ${formatContractError(err)}`));
     process.exit(1);
   }
 });
@@ -5265,14 +6413,14 @@ syndicate.command("join").description("Request to join a syndicate (creates an E
       const hits = await searchSyndicateAcrossChains(subdomain);
       spinner.fail(`Syndicate "${subdomain}" not found on ${getNetwork()}`);
       if (hits.length === 0) {
-        console.error(chalk9.red(`  Not found on any supported chain.`));
+        console.error(chalk15.red(`  Not found on any supported chain.`));
       } else if (hits.length === 1) {
-        console.error(chalk9.yellow(`  Found on chain: ${chalk9.bold(hits[0].network)}`));
-        console.error(chalk9.dim(`  Re-run: sherwood --chain ${hits[0].network} syndicate join --subdomain ${subdomain}`));
+        console.error(chalk15.yellow(`  Found on chain: ${chalk15.bold(hits[0].network)}`));
+        console.error(chalk15.dim(`  Re-run: sherwood --chain ${hits[0].network} syndicate join --subdomain ${subdomain}`));
       } else {
         const chains = hits.map((h) => h.network).join(", ");
-        console.error(chalk9.yellow(`  Found on chains: ${chalk9.bold(chains)}`));
-        console.error(chalk9.dim(`  Specify which chain to join with --chain <network>.`));
+        console.error(chalk15.yellow(`  Found on chains: ${chalk15.bold(chains)}`));
+        console.error(chalk15.dim(`  Specify which chain to join with --chain <network>.`));
       }
       process.exit(1);
     }
@@ -5285,17 +6433,17 @@ syndicate.command("join").description("Request to join a syndicate (creates an E
       try {
         const xmtp = await loadXmtp();
         await xmtp.getXmtpClient();
-        console.log(chalk9.dim("  XMTP identity ready"));
+        console.log(chalk15.dim("  XMTP identity ready"));
       } catch {
-        console.warn(chalk9.yellow("  \u26A0 Could not initialize XMTP identity"));
+        console.warn(chalk15.yellow("  \u26A0 Could not initialize XMTP identity"));
       }
       try {
         const cron = await loadCron();
         const cronResult = cron.registerSyndicateCrons(subdomain, isTestnet(), getNotifyTo());
         if (cronResult.isOpenClaw && cronResult.registered) {
-          console.log(chalk9.green("  \u2713 Participation crons registered"));
+          console.log(chalk15.green("  \u2713 Participation crons registered"));
         } else if (!cronResult.isOpenClaw) {
-          console.log(chalk9.dim("  Tip: Set up a scheduled process to run `sherwood session check " + subdomain + "` periodically"));
+          console.log(chalk15.dim("  Tip: Set up a scheduled process to run `sherwood session check " + subdomain + "` periodically"));
         }
       } catch {
       }
@@ -5308,14 +6456,14 @@ syndicate.command("join").description("Request to join a syndicate (creates an E
     );
     if (existingRequest) {
       spinner.succeed("You already have a pending join request for this syndicate");
-      console.log(chalk9.dim(`  Attestation: ${existingRequest.uid}`));
-      console.log(chalk9.dim(`  Submitted:   ${new Date(existingRequest.time * 1e3).toLocaleString()}`));
+      console.log(chalk15.dim(`  Attestation: ${existingRequest.uid}`));
+      console.log(chalk15.dim(`  Submitted:   ${new Date(existingRequest.time * 1e3).toLocaleString()}`));
       try {
         const xmtp = await loadXmtp();
         await xmtp.getXmtpClient();
-        console.log(chalk9.dim("  XMTP identity ready"));
+        console.log(chalk15.dim("  XMTP identity ready"));
       } catch {
-        console.warn(chalk9.yellow("  \u26A0 Could not initialize XMTP identity"));
+        console.warn(chalk15.yellow("  \u26A0 Could not initialize XMTP identity"));
       }
       return;
     }
@@ -5336,7 +6484,7 @@ syndicate.command("join").description("Request to join a syndicate (creates an E
       spinner.succeed("Join request created (XMTP identity ready)");
     } catch {
       spinner.succeed("Join request created");
-      console.warn(chalk9.yellow("  \u26A0 Could not initialize XMTP identity \u2014 creator may not be able to auto-add you to chat"));
+      console.warn(chalk15.yellow("  \u26A0 Could not initialize XMTP identity \u2014 creator may not be able to auto-add you to chat"));
     }
     addSyndicate(getChain().id, { subdomain, vault: syndicate2.vault, role: "agent" });
     setPrimarySyndicate(getChain().id, subdomain);
@@ -5344,29 +6492,29 @@ syndicate.command("join").description("Request to join a syndicate (creates an E
       const cron = await loadCron();
       const cronResult = cron.registerSyndicateCrons(subdomain, isTestnet(), getNotifyTo());
       if (cronResult.isOpenClaw && cronResult.registered) {
-        console.log(G5("  \u2713 Participation crons registered (will activate after approval)"));
+        console.log(G6("  \u2713 Participation crons registered (will activate after approval)"));
       } else if (!cronResult.isOpenClaw) {
-        console.log(DIM5("  Tip: Set up a scheduled process to run `sherwood session check " + subdomain + "` periodically"));
+        console.log(DIM6("  Tip: Set up a scheduled process to run `sherwood session check " + subdomain + "` periodically"));
       }
     } catch {
     }
     console.log();
     console.log(LABEL5("  \u25C6 Join Request Submitted"));
-    SEP5();
-    console.log(W5(`  Syndicate:    ${G5(`${subdomain}.sherwoodagent.eth`)}`));
-    console.log(W5(`  Agent ID:     #${agentId}`));
-    console.log(W5(`  Creator:      ${DIM5(syndicate2.creator)}`));
-    console.log(W5(`  Attestation:  ${DIM5(uid)}`));
-    console.log(W5(`  EAS Scan:     ${DIM5(getEasScanUrl(uid))}`));
-    console.log(W5(`  Explorer:     ${DIM5(getEasExplorerUrl(hash))}`));
-    SEP5();
-    console.log(G5("  \u2713 Syndicate saved to ~/.sherwood/config.json (set as primary)"));
-    console.log(G5("  \u2713 The creator can review with:"));
-    console.log(DIM5(`    sherwood syndicate requests --subdomain ${subdomain}`));
+    SEP6();
+    console.log(W6(`  Syndicate:    ${G6(`${subdomain}.sherwoodagent.eth`)}`));
+    console.log(W6(`  Agent ID:     #${agentId}`));
+    console.log(W6(`  Creator:      ${DIM6(syndicate2.creator)}`));
+    console.log(W6(`  Attestation:  ${DIM6(uid)}`));
+    console.log(W6(`  EAS Scan:     ${DIM6(getEasScanUrl(uid))}`));
+    console.log(W6(`  Explorer:     ${DIM6(getEasExplorerUrl(hash))}`));
+    SEP6();
+    console.log(G6("  \u2713 Syndicate saved to ~/.sherwood/config.json (set as primary)"));
+    console.log(G6("  \u2713 The creator can review with:"));
+    console.log(DIM6(`    sherwood syndicate requests --subdomain ${subdomain}`));
     console.log();
   } catch (err) {
     spinner.fail("Join request failed");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
@@ -5407,34 +6555,34 @@ syndicate.command("requests").description("View pending join requests for a synd
     );
     spinner.stop();
     if (requests.length === 0) {
-      console.log(DIM5("\n  No pending join requests.\n"));
+      console.log(DIM6("\n  No pending join requests.\n"));
       return;
     }
     console.log();
     console.log(LABEL5(`  \u25C6 Pending Join Requests (${requests.length})`));
-    SEP5();
+    SEP6();
     for (let i = 0; i < requests.length; i++) {
       const req = requests[i];
       const date = new Date(req.time * 1e3).toLocaleString();
       const referrer = parseReferrer(req.decoded.message);
       const cleanMessage = stripReferrerPrefix(req.decoded.message);
-      console.log(W5(`  ${i + 1}. Agent #${req.decoded.agentId} ${DIM5(`(${req.attester})`)}`));
-      console.log(DIM5(`     Message:     "${cleanMessage}"`));
+      console.log(W6(`  ${i + 1}. Agent #${req.decoded.agentId} ${DIM6(`(${req.attester})`)}`));
+      console.log(DIM6(`     Message:     "${cleanMessage}"`));
       if (referrer !== null) {
-        console.log(G5(`     Referred by: Agent #${referrer}`));
+        console.log(G6(`     Referred by: Agent #${referrer}`));
       }
-      console.log(DIM5(`     Requested:   ${date}`));
-      console.log(DIM5(`     Attestation: ${req.uid}`));
+      console.log(DIM6(`     Requested:   ${date}`));
+      console.log(DIM6(`     Attestation: ${req.uid}`));
       console.log();
     }
-    console.log(G5("  To approve:"));
-    console.log(DIM5(`    sherwood syndicate approve --agent-id <id> --wallet <addr>`));
-    console.log(G5("  To reject:"));
-    console.log(DIM5(`    sherwood syndicate reject --attestation <uid>`));
+    console.log(G6("  To approve:"));
+    console.log(DIM6(`    sherwood syndicate approve --agent-id <id> --wallet <addr>`));
+    console.log(G6("  To reject:"));
+    console.log(DIM6(`    sherwood syndicate reject --attestation <uid>`));
     console.log();
   } catch (err) {
     spinner.fail("Failed to load requests");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
@@ -5464,11 +6612,11 @@ syndicate.command("approve").description("Approve an agent join request (registe
         agentWallet
       );
       agentWasRegistered = true;
-      console.log(DIM5(`  Agent registered: ${getExplorerUrl(regHash)}`));
+      console.log(DIM6(`  Agent registered: ${getExplorerUrl(regHash)}`));
     } catch (regErr) {
       const msg = regErr instanceof Error ? regErr.message : String(regErr);
       if (msg.includes("0xe098d3ee") || msg.includes("AgentAlreadyRegistered")) {
-        console.log(DIM5("  Agent already registered on vault \u2014 skipping"));
+        console.log(DIM6("  Agent already registered on vault \u2014 skipping"));
       } else {
         throw regErr;
       }
@@ -5484,7 +6632,7 @@ syndicate.command("approve").description("Approve an agent join request (registe
     let approvalUid;
     if (alreadyApproved) {
       approvalUid = alreadyApproved.uid;
-      console.log(DIM5(`  Approval attestation already exists \u2014 skipping`));
+      console.log(DIM6(`  Approval attestation already exists \u2014 skipping`));
     } else {
       spinner.text = "Creating approval attestation...";
       const result = await createApproval(
@@ -5507,23 +6655,23 @@ syndicate.command("approve").description("Approve an agent join request (registe
         syndicate: subdomain,
         timestamp: Math.floor(Date.now() / 1e3)
       });
-      console.log(DIM5(`  Added to chat: ${subdomain}`));
+      console.log(DIM6(`  Added to chat: ${subdomain}`));
     } catch {
-      console.warn(chalk9.yellow("  \u26A0 Could not add agent to chat group"));
-      console.warn(chalk9.dim(`    If no group exists, run: sherwood chat ${subdomain} init`));
+      console.warn(chalk15.yellow("  \u26A0 Could not add agent to chat group"));
+      console.warn(chalk15.dim(`    If no group exists, run: sherwood chat ${subdomain} init`));
     }
     spinner.succeed("Agent approved and registered");
     console.log();
     console.log(LABEL5("  \u25C6 Agent Approved"));
-    SEP5();
-    console.log(W5(`  Agent ID:     #${opts.agentId}`));
-    console.log(W5(`  Wallet:       ${G5(opts.wallet)}`));
-    console.log(W5(`  Approval:     ${DIM5(approvalUid)}`));
-    console.log(W5(`  EAS Scan:     ${DIM5(getEasScanUrl(approvalUid))}`));
-    SEP5();
+    SEP6();
+    console.log(W6(`  Agent ID:     #${opts.agentId}`));
+    console.log(W6(`  Wallet:       ${G6(opts.wallet)}`));
+    console.log(W6(`  Approval:     ${DIM6(approvalUid)}`));
+    console.log(W6(`  EAS Scan:     ${DIM6(getEasScanUrl(approvalUid))}`));
+    SEP6();
   } catch (err) {
     spinner.fail("Approval failed");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
@@ -5532,17 +6680,17 @@ syndicate.command("reject").description("Reject a join request by revoking its a
   try {
     const hash = await revokeJoinRequest(opts.attestation);
     spinner.succeed("Join request rejected");
-    console.log(DIM5(`  ${getEasExplorerUrl(hash)}`));
+    console.log(DIM6(`  ${getEasExplorerUrl(hash)}`));
   } catch (err) {
     spinner.fail("Rejection failed");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
 syndicate.command("leave").description("Leave a syndicate \u2014 removes participation crons and session state").option("--subdomain <name>", "Syndicate subdomain to leave").action(async (opts) => {
   const subdomain = opts.subdomain || getPrimarySyndicate(getChain().id)?.subdomain;
   if (!subdomain) {
-    console.error(chalk9.red("  No syndicate configured. Pass --subdomain <name>."));
+    console.error(chalk15.red("  No syndicate configured. Pass --subdomain <name>."));
     process.exit(1);
   }
   const spinner = ora8("Cleaning up...").start();
@@ -5558,17 +6706,17 @@ syndicate.command("leave").description("Leave a syndicate \u2014 removes partici
     resetSession(subdomain);
     spinner.succeed("Left syndicate");
     if (cronsRemoved) {
-      console.log(G5("  \u2713 Participation crons removed"));
+      console.log(G6("  \u2713 Participation crons removed"));
     }
-    console.log(G5("  \u2713 Session state cleared"));
+    console.log(G6("  \u2713 Session state cleared"));
     console.log();
-    console.log(chalk9.dim("  Note: This does not remove you on-chain. To exit your position:"));
-    console.log(chalk9.dim("    sherwood vault balance   \u2014 check your LP share balance"));
-    console.log(chalk9.dim("    Redeem shares via the vault contract or dashboard"));
+    console.log(chalk15.dim("  Note: This does not remove you on-chain. To exit your position:"));
+    console.log(chalk15.dim("    sherwood vault balance   \u2014 check your LP share balance"));
+    console.log(chalk15.dim("    Redeem shares via the vault contract or dashboard"));
     console.log();
   } catch (err) {
     spinner.fail("Leave failed");
-    console.error(chalk9.red(err instanceof Error ? err.message : String(err)));
+    console.error(chalk15.red(err instanceof Error ? err.message : String(err)));
     process.exit(1);
   }
 });
@@ -5579,21 +6727,21 @@ syndicate.command("set-primary").description("Set the active syndicate for CLI c
     if (!opts.subdomain && !opts.vault) {
       const primary = getPrimarySyndicate(chainId);
       if (memberships.length === 0) {
-        console.log(DIM5("\n  No syndicates saved. Create or join one first.\n"));
+        console.log(DIM6("\n  No syndicates saved. Create or join one first.\n"));
         return;
       }
       console.log();
       console.log(LABEL5("  \u25C6 Your Syndicates"));
-      SEP5();
+      SEP6();
       for (const m of memberships) {
         const isPrimary = primary?.subdomain === m.subdomain;
-        const marker = isPrimary ? G5(" \u2605") : "";
-        console.log(W5(`  ${m.subdomain}.sherwoodagent.eth${marker}  ${DIM5(`(${m.role})`)}`));
-        console.log(DIM5(`    vault: ${m.vault}`));
+        const marker = isPrimary ? G6(" \u2605") : "";
+        console.log(W6(`  ${m.subdomain}.sherwoodagent.eth${marker}  ${DIM6(`(${m.role})`)}`));
+        console.log(DIM6(`    vault: ${m.vault}`));
       }
-      SEP5();
+      SEP6();
       if (memberships.length > 1) {
-        console.log(DIM5("  Switch with: sherwood syndicate set-primary --subdomain <name>"));
+        console.log(DIM6("  Switch with: sherwood syndicate set-primary --subdomain <name>"));
       }
       console.log();
       return;
@@ -5619,15 +6767,15 @@ syndicate.command("set-primary").description("Set the active syndicate for CLI c
       }
     }
     if (!target) {
-      console.error(chalk9.red("  Could not resolve syndicate. Pass --subdomain or --vault."));
+      console.error(chalk15.red("  Could not resolve syndicate. Pass --subdomain or --vault."));
       process.exit(1);
     }
     setPrimarySyndicate(chainId, target);
-    console.log(G5(`
+    console.log(G6(`
   \u2713 Primary syndicate set to ${target}.sherwoodagent.eth
 `));
   } catch (err) {
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
@@ -5635,13 +6783,13 @@ var vaultCmd = program.command("vault");
 vaultCmd.command("deposit").description("Deposit into a vault").option("--vault <address>", "Vault address (default: from config)").requiredOption("--amount <amount>", "Amount to deposit (in asset units)").option("--use-eth", "Auto-wrap ETH \u2192 WETH before depositing (for WETH vaults)").action(async (opts) => {
   resolveVault(opts);
   const decimals = await getAssetDecimals();
-  const amount = parseUnits6(opts.amount, decimals);
+  const amount = parseUnits7(opts.amount, decimals);
   try {
     if (!opts.useEth) {
       await preflightDeposit(amount);
     }
   } catch (err) {
-    console.error(chalk9.red(`
+    console.error(chalk15.red(`
   \u2716 ${err instanceof Error ? err.message : String(err)}
 `));
     process.exit(1);
@@ -5656,10 +6804,10 @@ vaultCmd.command("deposit").description("Deposit into a vault").option("--vault
       hash = await deposit(amount);
     }
     spinner.succeed(`Deposited: ${hash}`);
-    console.log(chalk9.dim(`  ${getExplorerUrl(hash)}`));
+    console.log(chalk15.dim(`  ${getExplorerUrl(hash)}`));
   } catch (err) {
     spinner.fail("Deposit failed");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
@@ -5670,8 +6818,8 @@ vaultCmd.command("info").description("Display vault state").option("--vault <add
     const info = await getVaultInfo();
     spinner.stop();
     console.log();
-    console.log(chalk9.bold("Vault Info"));
-    console.log(chalk9.dim("\u2500".repeat(40)));
+    console.log(chalk15.bold("Vault Info"));
+    console.log(chalk15.dim("\u2500".repeat(40)));
     console.log(`  Address:            ${info.address}`);
     console.log(`  Total Assets:       ${info.totalAssets}`);
     console.log(`  Agent Count:        ${info.agentCount}`);
@@ -5680,7 +6828,7 @@ vaultCmd.command("info").description("Display vault state").option("--vault <add
     console.log();
   } catch (err) {
     spinner.fail("Failed to load vault info");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
@@ -5691,15 +6839,15 @@ vaultCmd.command("balance").description("Show LP share balance and asset value")
     const balance = await getBalance(opts.address);
     spinner.stop();
     console.log();
-    console.log(chalk9.bold("LP Position"));
-    console.log(chalk9.dim("\u2500".repeat(40)));
+    console.log(chalk15.bold("LP Position"));
+    console.log(chalk15.dim("\u2500".repeat(40)));
     console.log(`  Shares:       ${balance.shares.toString()}`);
     console.log(`  Asset Value:  ${balance.assetsValue}`);
     console.log(`  % of Vault:   ${balance.percentOfVault}`);
     console.log();
   } catch (err) {
     spinner.fail("Failed to load balance");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
@@ -5710,22 +6858,22 @@ vaultCmd.command("redeem").description("Redeem vault shares for the underlying a
   let shares;
   try {
     if (opts.shares) {
-      shares = parseUnits6(opts.shares, shareDecimals);
+      shares = parseUnits7(opts.shares, shareDecimals);
     } else {
       shares = await getShareBalance();
       if (shares === 0n) {
-        console.error(chalk9.red("\n  \u2716 No shares to redeem.\n"));
+        console.error(chalk15.red("\n  \u2716 No shares to redeem.\n"));
         process.exit(1);
       }
     }
   } catch (err) {
-    console.error(chalk9.red(`
+    console.error(chalk15.red(`
   \u2716 ${err instanceof Error ? err.message : String(err)}
 `));
     process.exit(1);
   }
   if (opts.receiver && !isAddress6(opts.receiver)) {
-    console.error(chalk9.red(`
+    console.error(chalk15.red(`
   \u2716 Invalid receiver address: ${opts.receiver}
 `));
     process.exit(1);
@@ -5733,7 +6881,7 @@ vaultCmd.command("redeem").description("Redeem vault shares for the underlying a
   try {
     await preflightRedeem(shares);
   } catch (err) {
-    console.error(chalk9.red(`
+    console.error(chalk15.red(`
   \u2716 ${err instanceof Error ? err.message : String(err)}
 `));
     process.exit(1);
@@ -5746,18 +6894,18 @@ vaultCmd.command("redeem").description("Redeem vault shares for the underlying a
       opts.receiver
     );
     spinner.succeed(`Redeemed: ${hash}`);
-    console.log(chalk9.dim(`  ${getExplorerUrl(hash)}`));
+    console.log(chalk15.dim(`  ${getExplorerUrl(hash)}`));
     console.log(`  Assets received: ${formatUnits5(assetsOut, assetDecimals)}`);
   } catch (err) {
     spinner.fail("Redeem failed");
-    console.error(chalk9.red(formatContractError(err)));
+    console.error(chalk15.red(formatContractError(err)));
     process.exit(1);
   }
 });
 var strategy = program.command("strategy").description("Strategy templates \u2014 list, clone, propose");
 registerStrategyTemplateCommands(strategy);
 program.command("providers").description("List available DeFi providers").action(async () => {
-  const { MessariProvider, NansenProvider } = await import("./research-NR4VC5LN.js");
+  const { MessariProvider, NansenProvider } = await import("./research-YJWSQS2A.js");
   const providers = [new MoonwellProvider(), new UniswapProvider(), new MessariProvider(), new NansenProvider()];
   for (const p of providers) {
     const info = p.info();
@@ -5768,17 +6916,17 @@ ${info.name} (${info.type})`);
   }
 });
 try {
-  const { registerChatCommands } = await import("./chat-UWJ6JBFE.js");
+  const { registerChatCommands } = await import("./chat-MRTPUZ3X.js");
   registerChatCommands(program);
 } catch {
   program.command("chat <name> [action] [actionArgs...]").description("Syndicate chat (XMTP) \u2014 requires @xmtp/cli").action(() => {
-    console.error(chalk9.red("XMTP CLI not available."));
-    console.error(chalk9.dim("Install with:  npm install -g @xmtp/cli"));
-    console.error(chalk9.dim("Or reinstall:  npm i -g @sherwoodagent/cli"));
+    console.error(chalk15.red("XMTP CLI not available."));
+    console.error(chalk15.dim("Install with:  npm install -g @xmtp/cli"));
+    console.error(chalk15.dim("Or reinstall:  npm i -g @sherwoodagent/cli"));
     process.exit(1);
   });
 }
-var { registerSessionCommands } = await import("./session-NUPHC6ZN.js");
+var { registerSessionCommands } = await import("./session-FPCPCVQX.js");
 registerSessionCommands(program);
 registerVeniceCommands(program);
 registerAllowanceCommands(program);
@@ -5786,65 +6934,71 @@ registerIdentityCommands(program);
 registerProposalCommands(program);
 registerGovernorCommands(program);
 registerGuardianCommands(program);
-var { registerResearchCommands } = await import("./research-J3HYU3N6.js");
+var { registerResearchCommands } = await import("./research-QBKISW2M.js");
 registerResearchCommands(program);
-var { registerAgentCommands } = await import("./agent-5YEJ6W6W.js");
+var { registerAgentCommands } = await import("./agent-ZPAZTJG3.js");
 registerAgentCommands(program);
-var { registerTradeCommands } = await import("./trade-VGECC4QZ.js");
+var { registerTradeCommands } = await import("./trade-NO6CNWCA.js");
 registerTradeCommands(program);
+registerGridCommand(program);
 var configCmd = program.command("config");
-configCmd.command("set").description("Save settings to ~/.sherwood/config.json (persists across sessions)").option("--private-key <key>", "Wallet private key (0x-prefixed)").option("--vault <address>", "Default SyndicateVault address").option("--rpc <url>", "Custom RPC URL for the active --chain network").option("--notify-to <id>", "Destination for cron summaries (Telegram chat ID, phone, etc.)").option("--uniswap-api-key <key>", "Uniswap Trading API key (from developers.uniswap.org)").option("--venice-api-key <key>", "Venice AI inference API key").option("--xmtp-group <subdomain:groupId>", "Cache an XMTP group ID for a syndicate (e.g. my-fund:abc123)").action((opts) => {
+configCmd.command("set").description("Save settings to ~/.sherwood/config.json (persists across sessions)").option("--private-key <key>", "Wallet private key (0x-prefixed)").option("--vault <address>", "Default SyndicateVault address").option("--rpc <url>", "Custom RPC URL for the active --chain network").option("--notify-to <id>", "Destination for cron summaries (Telegram chat ID, phone, etc.)").option("--uniswap-api-key <key>", "Uniswap Trading API key (from developers.uniswap.org)").option("--venice-api-key <key>", "Venice AI inference API key").option("--anthropic-api-key <key>", "Anthropic Claude API key (for LLM judge)").option("--xmtp-group <subdomain:groupId>", "Cache an XMTP group ID for a syndicate (e.g. my-fund:abc123)").action((opts) => {
   let saved = false;
   if (opts.privateKey) {
     setPrivateKey(opts.privateKey);
     const account = getAccount();
-    console.log(chalk9.green("Private key saved to ~/.sherwood/config.json"));
-    console.log(chalk9.dim(`  Wallet: ${account.address}`));
+    console.log(chalk15.green("Private key saved to ~/.sherwood/config.json"));
+    console.log(chalk15.dim(`  Wallet: ${account.address}`));
     saved = true;
   }
   if (opts.vault) {
     const chainId = getChain().id;
     setChainContract(chainId, "vault", opts.vault);
-    console.log(chalk9.green(`Vault saved to ~/.sherwood/config.json (chain ${chainId})`));
-    console.log(chalk9.dim(`  Vault: ${opts.vault}`));
+    console.log(chalk15.green(`Vault saved to ~/.sherwood/config.json (chain ${chainId})`));
+    console.log(chalk15.dim(`  Vault: ${opts.vault}`));
     saved = true;
   }
   if (opts.rpc) {
     const network = getNetwork();
     setConfigRpcUrl(network, opts.rpc);
-    console.log(chalk9.green(`RPC URL saved for ${network}`));
-    console.log(chalk9.dim(`  RPC: ${opts.rpc}`));
+    console.log(chalk15.green(`RPC URL saved for ${network}`));
+    console.log(chalk15.dim(`  RPC: ${opts.rpc}`));
     saved = true;
   }
   if (opts.notifyTo) {
     setNotifyTo(opts.notifyTo);
-    console.log(chalk9.green("Notify destination saved to ~/.sherwood/config.json"));
-    console.log(chalk9.dim(`  Notify to: ${opts.notifyTo}`));
+    console.log(chalk15.green("Notify destination saved to ~/.sherwood/config.json"));
+    console.log(chalk15.dim(`  Notify to: ${opts.notifyTo}`));
     saved = true;
   }
   if (opts.uniswapApiKey) {
     setUniswapApiKey(opts.uniswapApiKey);
-    console.log(chalk9.green("Uniswap API key saved to ~/.sherwood/config.json"));
+    console.log(chalk15.green("Uniswap API key saved to ~/.sherwood/config.json"));
     saved = true;
   }
   if (opts.veniceApiKey) {
     setVeniceApiKey(opts.veniceApiKey);
-    console.log(chalk9.green("Venice API key saved to ~/.sherwood/config.json"));
+    console.log(chalk15.green("Venice API key saved to ~/.sherwood/config.json"));
+    saved = true;
+  }
+  if (opts.anthropicApiKey) {
+    setAnthropicApiKey(opts.anthropicApiKey);
+    console.log(chalk15.green("Anthropic API key saved to ~/.sherwood/config.json"));
     saved = true;
   }
   if (opts.xmtpGroup) {
     const parts = opts.xmtpGroup.split(":");
     if (parts.length !== 2 || !parts[0] || !parts[1]) {
-      console.log(chalk9.red("Format: --xmtp-group <subdomain>:<groupId>"));
+      console.log(chalk15.red("Format: --xmtp-group <subdomain>:<groupId>"));
       process.exit(1);
     }
     cacheGroupId(parts[0], parts[1]);
-    console.log(chalk9.green(`XMTP group ID cached for ${parts[0]}`));
-    console.log(chalk9.dim(`  Group ID: ${parts[1]}`));
+    console.log(chalk15.green(`XMTP group ID cached for ${parts[0]}`));
+    console.log(chalk15.dim(`  Group ID: ${parts[1]}`));
     saved = true;
   }
   if (!saved) {
-    console.log(chalk9.red("Provide at least one of: --private-key, --vault, --rpc, --notify-to, --uniswap-api-key, --venice-api-key, --xmtp-group"));
+    console.log(chalk15.red("Provide at least one of: --private-key, --vault, --rpc, --notify-to, --uniswap-api-key, --venice-api-key, --anthropic-api-key, --xmtp-group"));
     process.exit(1);
   }
 });
@@ -5855,25 +7009,25 @@ configCmd.command("show").description("Display current config for the active net
   const config = loadConfig();
   const customRpc = config.rpc?.[network];
   console.log();
-  console.log(chalk9.bold(`Sherwood Config`));
-  console.log(chalk9.dim("\u2500".repeat(50)));
-  console.log(`  Network:    ${chalk9.cyan(network)} (chain ${chainId})`);
-  console.log(`  RPC:        ${customRpc ? chalk9.green(customRpc) : chalk9.dim("default")}`);
-  console.log(`  Wallet:     ${config.privateKey ? chalk9.green("configured") : chalk9.dim("not set")}`);
-  console.log(`  Agent ID:   ${config.agentId ?? chalk9.dim("not set")}`);
-  console.log(`  Vault:      ${contracts.vault ?? chalk9.dim("not set")}`);
-  console.log(`  Uniswap:    ${getUniswapApiKey() ? chalk9.green("API key configured") : chalk9.dim("not set")}`);
-  console.log(`  Venice:     ${getVeniceApiKey() ? chalk9.green("API key configured") : chalk9.dim("not set")}`);
+  console.log(chalk15.bold(`Sherwood Config`));
+  console.log(chalk15.dim("\u2500".repeat(50)));
+  console.log(`  Network:    ${chalk15.cyan(network)} (chain ${chainId})`);
+  console.log(`  RPC:        ${customRpc ? chalk15.green(customRpc) : chalk15.dim("default")}`);
+  console.log(`  Wallet:     ${config.privateKey ? chalk15.green("configured") : chalk15.dim("not set")}`);
+  console.log(`  Agent ID:   ${config.agentId ?? chalk15.dim("not set")}`);
+  console.log(`  Vault:      ${contracts.vault ?? chalk15.dim("not set")}`);
+  console.log(`  Uniswap:    ${getUniswapApiKey() ? chalk15.green("API key configured") : chalk15.dim("not set")}`);
+  console.log(`  Venice:     ${getVeniceApiKey() ? chalk15.green("API key configured") : chalk15.dim("not set")}`);
   const groupEntries = Object.entries(config.groupCache || {}).filter(([, v]) => v);
   if (groupEntries.length > 0) {
     console.log();
-    console.log(chalk9.bold("  XMTP Groups"));
+    console.log(chalk15.bold("  XMTP Groups"));
     for (const [sub, gid] of groupEntries) {
-      console.log(`    ${sub}: ${chalk9.cyan(gid)}`);
+      console.log(`    ${sub}: ${chalk15.cyan(gid)}`);
     }
   }
   console.log();
-  console.log(chalk9.dim("  Config file: ~/.sherwood/config.json"));
+  console.log(chalk15.dim("  Config file: ~/.sherwood/config.json"));
   console.log();
 });
 program.parse();