@exagent/agent 0.1.41 → 0.1.42

package/dist/cli.js

@@ -3435,16 +3435,20 @@ var TOKEN_SYMBOLS = {
 var KEY_POSITIONS = "__positions";
 var KEY_TRADE_HISTORY = "__trade_history";
 var KEY_RISK_STATE = "__risk_state";
+var KEY_SELL_FAILURES = "__sell_failures";
+var STUCK_FAILURE_THRESHOLD = 3;
 var PositionTracker = class {
   store;
   positions;
   tradeHistory;
+  sellFailures;
   maxTradeHistory;
   constructor(store, options) {
     this.store = store;
     this.maxTradeHistory = options?.maxTradeHistory ?? 50;
     this.positions = store.get(KEY_POSITIONS) || {};
     this.tradeHistory = store.get(KEY_TRADE_HISTORY) || [];
+    this.sellFailures = store.get(KEY_SELL_FAILURES) || {};
     const posCount = Object.keys(this.positions).length;
     if (posCount > 0 || this.tradeHistory.length > 0) {
       console.log(`Position tracker loaded: ${posCount} positions, ${this.tradeHistory.length} trade records`);
@@ -3480,10 +3484,10 @@ var PositionTracker = class {
         const realizedPnL = this.handleSell(tokenIn.toLowerCase(), tradeValueUSD);
         record.realizedPnL = realizedPnL;
       }
-    }
-    this.tradeHistory.unshift(record);
-    if (this.tradeHistory.length > this.maxTradeHistory) {
-      this.tradeHistory = this.tradeHistory.slice(0, this.maxTradeHistory);
+      this.tradeHistory.unshift(record);
+      if (this.tradeHistory.length > this.maxTradeHistory) {
+        this.tradeHistory = this.tradeHistory.slice(0, this.maxTradeHistory);
+      }
     }
     this.persist();
   }
@@ -3544,26 +3548,58 @@ var PositionTracker = class {
   // ============================================================
   /**
    * Sync tracked positions with on-chain balances.
-   * Updates currentAmount, detects new tokens (airdrops), removes zeroed positions.
+   * Updates currentAmount, detects new tokens (airdrops), and handles position exits.
+   *
+   * CRITICAL: When a tracked position's balance decreases without a corresponding
+   * sell trade, we infer a manual exit and record it with realized PnL calculated
+   * at current market price. This prevents PnL manipulation via off-router sells.
+   *
+   * Returns array of inferred exits for the runtime to report to Command Center.
    */
   syncBalances(balances, prices) {
     let changed = false;
+    const inferredExits = [];
     for (const [address, balance] of Object.entries(balances)) {
       const token = address.toLowerCase();
       if (BASE_ASSETS.has(token)) continue;
       const decimals = getTokenDecimals(token);
       const amount = Number(balance) / Math.pow(10, decimals);
+      const position = this.positions[token];
       if (amount > 0) {
-        if (this.positions[token]) {
-          if (this.positions[token].currentAmount !== amount) {
-            this.positions[token].currentAmount = amount;
-            this.positions[token].lastUpdateTimestamp = Date.now();
+        if (position) {
+          const previousAmount = position.currentAmount;
+          if (amount < previousAmount && position.totalAmountAcquired > 0) {
+            const exitedAmount = previousAmount - amount;
+            const currentPrice = prices[token] || position.averageEntryPrice || 0;
+            const exitValueUSD = exitedAmount * currentPrice;
+            const costBasisOfExited = exitedAmount * position.averageEntryPrice;
+            const realizedPnL = exitValueUSD - costBasisOfExited;
+            const symbol = position.symbol || TOKEN_SYMBOLS[token] || getTokenSymbol(token) || token.slice(0, 10);
+            this.recordInferredExit(token, exitedAmount, exitValueUSD, realizedPnL, symbol);
+            inferredExits.push({
+              token,
+              symbol,
+              amountExited: exitedAmount,
+              exitValueUSD,
+              realizedPnL,
+              costBasis: costBasisOfExited
+            });
+            const exitRatio = exitedAmount / position.totalAmountAcquired;
+            position.totalCostBasis = Math.max(0, position.totalCostBasis * (1 - exitRatio));
+            position.totalAmountAcquired = Math.max(0, position.totalAmountAcquired - exitedAmount);
+            console.log(
+              `Position tracker: inferred exit of ${exitedAmount.toFixed(4)} ${symbol} ($${exitValueUSD.toFixed(2)} value, PnL: $${realizedPnL >= 0 ? "+" : ""}${realizedPnL.toFixed(2)})`
+            );
+          }
+          if (position.currentAmount !== amount) {
+            position.currentAmount = amount;
+            position.lastUpdateTimestamp = Date.now();
             changed = true;
           }
-          if (!this.positions[token].symbol) {
+          if (!position.symbol) {
             const resolved = TOKEN_SYMBOLS[token] || getTokenSymbol(token);
             if (resolved) {
-              this.positions[token].symbol = resolved;
+              position.symbol = resolved;
               changed = true;
             }
           }
@@ -3586,14 +3622,60 @@ var PositionTracker = class {
           }
           changed = true;
         }
-      } else if (this.positions[token]) {
+      } else if (position) {
+        if (position.totalAmountAcquired > 0 && position.currentAmount > 0) {
+          const currentPrice = prices[token] || position.averageEntryPrice || 0;
+          const exitValueUSD = position.currentAmount * currentPrice;
+          const costBasisOfExited = position.currentAmount * position.averageEntryPrice;
+          const realizedPnL = exitValueUSD - costBasisOfExited;
+          const symbol = position.symbol || TOKEN_SYMBOLS[token] || getTokenSymbol(token) || token.slice(0, 10);
+          this.recordInferredExit(token, position.currentAmount, exitValueUSD, realizedPnL, symbol);
+          inferredExits.push({
+            token,
+            symbol,
+            amountExited: position.currentAmount,
+            exitValueUSD,
+            realizedPnL,
+            costBasis: costBasisOfExited
+          });
+          console.log(
+            `Position tracker: inferred FULL exit of ${position.currentAmount.toFixed(4)} ${symbol} ($${exitValueUSD.toFixed(2)} value, PnL: $${realizedPnL >= 0 ? "+" : ""}${realizedPnL.toFixed(2)})`
+          );
+        }
         delete this.positions[token];
+        if (this.sellFailures[token]) {
+          delete this.sellFailures[token];
+        }
         changed = true;
       }
     }
-    if (changed) {
+    if (changed || inferredExits.length > 0) {
       this.persist();
     }
+    return inferredExits;
+  }
+  /**
+   * Record an inferred exit in trade history.
+   * These are exits detected from balance changes, not from tracked sell executions.
+   */
+  recordInferredExit(token, amount, valueUSD, realizedPnL, symbol) {
+    const record = {
+      timestamp: Date.now(),
+      action: "sell",
+      tokenIn: token,
+      tokenOut: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+      // USDC (assumed exit to stablecoin)
+      amountIn: amount.toString(),
+      priceUSD: valueUSD,
+      reasoning: `Inferred exit: balance decreased without tracked sell. Exited ${amount.toFixed(4)} ${symbol} at ~$${(valueUSD / amount).toFixed(4)}/token.`,
+      realizedPnL,
+      success: true,
+      inferred: true
+    };
+    this.tradeHistory.unshift(record);
+    if (this.tradeHistory.length > this.maxTradeHistory) {
+      this.tradeHistory = this.tradeHistory.slice(0, this.maxTradeHistory);
+    }
   }
   // ============================================================
   // QUERY METHODS (for strategies)
@@ -3634,6 +3716,86 @@ var PositionTracker = class {
     return Object.values(pnl).reduce((sum, v) => sum + v, 0);
   }
   // ============================================================
+  // STUCK POSITION DETECTION
+  // ============================================================
+  /**
+   * Record a sell failure for a token. Called when a sell attempt fails
+   * due to liquidity issues, route simulation failure, or excessive price impact.
+   */
+  recordSellFailure(token, reason) {
+    const key = token.toLowerCase();
+    const existing = this.sellFailures[key];
+    if (existing) {
+      existing.consecutiveFailures += 1;
+      existing.lastFailureReason = reason;
+      existing.lastFailureTimestamp = Date.now();
+    } else {
+      this.sellFailures[key] = {
+        consecutiveFailures: 1,
+        lastFailureReason: reason,
+        lastFailureTimestamp: Date.now()
+      };
+    }
+    this.store.set(KEY_SELL_FAILURES, this.sellFailures);
+  }
+  /**
+   * Clear sell failure tracking for a token (called after successful sell).
+   */
+  clearSellFailure(token) {
+    const key = token.toLowerCase();
+    if (this.sellFailures[key]) {
+      delete this.sellFailures[key];
+      this.store.set(KEY_SELL_FAILURES, this.sellFailures);
+    }
+  }
+  /**
+   * Detect positions that are "stuck" — we've tried and failed to sell them
+   * multiple times, likely due to insufficient liquidity.
+   *
+   * Returns positions that have failed to sell >= STUCK_FAILURE_THRESHOLD times.
+   */
+  getStuckPositions(prices) {
+    const stuck = [];
+    const now = Date.now();
+    for (const [token, failure] of Object.entries(this.sellFailures)) {
+      if (failure.consecutiveFailures < STUCK_FAILURE_THRESHOLD) continue;
+      const position = this.positions[token];
+      if (!position || position.currentAmount <= 0) continue;
+      const price = prices[token] || position.averageEntryPrice || 0;
+      const estimatedValueUSD = position.currentAmount * price;
+      stuck.push({
+        token,
+        symbol: position.symbol || TOKEN_SYMBOLS[token] || token.slice(0, 10),
+        consecutiveFailures: failure.consecutiveFailures,
+        lastFailureReason: failure.lastFailureReason,
+        holdingDurationMs: now - position.entryTimestamp,
+        estimatedValueUSD
+      });
+    }
+    return stuck;
+  }
+  /**
+   * Check if a specific position is stuck.
+   */
+  isPositionStuck(token) {
+    const failure = this.sellFailures[token.toLowerCase()];
+    return !!failure && failure.consecutiveFailures >= STUCK_FAILURE_THRESHOLD;
+  }
+  /**
+   * Check if we should alert about a stuck position (rate-limited to once per 24h).
+   * Returns true if we should alert, and marks the alert as sent.
+   */
+  shouldAlertStuckPosition(token) {
+    const alertKey = `__stuck_alert_${token.toLowerCase()}`;
+    const lastAlert = this.store.get(alertKey) || 0;
+    const hoursSinceAlert = (Date.now() - lastAlert) / (1e3 * 60 * 60);
+    if (hoursSinceAlert >= 24) {
+      this.store.set(alertKey, Date.now());
+      return true;
+    }
+    return false;
+  }
+  // ============================================================
   // RISK STATE PERSISTENCE
   // ============================================================
   /** Load persisted risk state */
@@ -4132,7 +4294,9 @@ function validateConfig(config) {
     throw new Error("Endpoint required for custom LLM provider");
   }
   if (!config.agentId || Number(config.agentId) <= 0) {
-    throw new Error("Valid agent ID required");
+    throw new Error(
+      'Valid agent ID required in agent-config.json.\n\n  Register your agent at https://exagent.io first:\n    1. Connect your wallet\n    2. Click "Launch Agent" to register\n    3. Copy your agent ID into agent-config.json as "agentId"\n'
+    );
   }
 }
 var DEFAULT_RPC_URL = "https://mainnet.base.org";
@@ -5391,7 +5555,7 @@ var HyperliquidWebSocket = class {
 var import_viem5 = require("viem");
 var import_chains3 = require("viem/chains");
 var import_accounts2 = require("viem/accounts");
-var ROUTER_ADDRESS = "0x1BCFa13f677fDCf697D8b7d5120f544817F1de1A";
+var ROUTER_ADDRESS = "0x20feB3054750970773Fe7370c391732EE0559743";
 var ROUTER_ABI = [
   {
     type: "function",
@@ -6451,7 +6615,7 @@ var PredictionPositionManager = class {
 var import_viem8 = require("viem");
 var import_chains5 = require("viem/chains");
 var import_accounts4 = require("viem/accounts");
-var ROUTER_ADDRESS2 = "0x1BCFa13f677fDCf697D8b7d5120f544817F1de1A";
+var ROUTER_ADDRESS2 = "0x20feB3054750970773Fe7370c391732EE0559743";
 var ROUTER_ABI2 = [
   {
     type: "function",
@@ -7761,7 +7925,7 @@ function loadSecureEnv(basePath, passphrase) {
 }
 
 // src/index.ts
-var AGENT_VERSION = "0.1.41";
+var AGENT_VERSION = "0.1.42";
 
 // src/relay.ts
 var RelayClient = class {
@@ -8129,7 +8293,18 @@ var AgentRuntime = class {
     console.log(`Wallet: ${this.client.address}`);
     const agent = await this.client.registry.getAgent(BigInt(this.config.agentId));
     if (!agent) {
-      throw new Error(`Agent ID ${this.config.agentId} not found on-chain. Please register first.`);
+      throw new Error(
+        `Agent ID ${this.config.agentId} not found on-chain.
+
+  Register your agent at https://exagent.io first:
+    1. Connect your wallet at https://exagent.io
+    2. Click "Launch Agent" to register (sets name, risk universe, limits)
+    3. Copy your agent ID into agent-config.json
+    4. Run your agent again
+
+  The website handles the full registration flow including risk parameters.
+  Your agent ID will appear on your agent's profile page after registration.`
+      );
     }
     console.log(`Agent verified: ${agent.name}`);
     await this.ensureWalletLinked();
@@ -8653,7 +8828,7 @@ var AgentRuntime = class {
       try {
         const tokens = this.getTokensToTrack();
         const initData = await this.marketData.fetchMarketData(this.client.address, tokens);
-        this.positionTracker.syncBalances(initData.balances, initData.prices);
+        void this.positionTracker.syncBalances(initData.balances, initData.prices);
         this.lastPortfolioValue = initData.portfolioValue;
         this.lastPrices = initData.prices;
         const nativeEthBal = initData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
@@ -9505,7 +9680,31 @@ var AgentRuntime = class {
     this.lastPrices = marketData.prices;
     const nativeEthBal = marketData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
     this.lastEthBalance = (Number(nativeEthBal) / 1e18).toFixed(6);
-    this.positionTracker.syncBalances(marketData.balances, marketData.prices);
+    const inferredExits = this.positionTracker.syncBalances(marketData.balances, marketData.prices);
+    for (const exit of inferredExits) {
+      const pnlSign = exit.realizedPnL >= 0 ? "+" : "";
+      this.relay?.sendMessage(
+        "position_inferred_exit",
+        exit.realizedPnL >= 0 ? "info" : "warning",
+        `Inferred Exit: ${exit.symbol}`,
+        `Detected manual sell of ${exit.amountExited.toFixed(4)} ${exit.symbol} outside the ExagentRouter.
+
+Exit value: $${exit.exitValueUSD.toFixed(2)}
+Cost basis: $${exit.costBasis.toFixed(2)}
+Realized PnL: ${pnlSign}$${exit.realizedPnL.toFixed(2)}
+
+This exit has been recorded in your trade history and counts toward your total PnL.`,
+        {
+          token: exit.token,
+          symbol: exit.symbol,
+          amountExited: exit.amountExited,
+          exitValueUSD: exit.exitValueUSD,
+          realizedPnL: exit.realizedPnL,
+          costBasis: exit.costBasis,
+          inferred: true
+        }
+      );
+    }
     if (!isPaper) {
       const fundsOk = this.checkFundsLow(marketData);
       if (!fundsOk) {
@@ -9598,7 +9797,7 @@ var AgentRuntime = class {
           console.log(`  [PAPER] Cycle PnL: $${marketPnL.toFixed(2)} (market), -$${totalFeesUSD.toFixed(2)} (fees)`);
         }
         this.paperPortfolio.recordEquityPoint(marketData.prices);
-        this.positionTracker.syncBalances(this.paperPortfolio.getBalances(), marketData.prices);
+        void this.positionTracker.syncBalances(this.paperPortfolio.getBalances(), marketData.prices);
         this.lastPortfolioValue = postValue;
         this.paperPortfolio.save();
       } else {
@@ -9629,6 +9828,9 @@ var AgentRuntime = class {
                 tokenOut: result.signal.tokenOut
               }
             );
+            if (result.signal.action === "sell") {
+              this.positionTracker.clearSellFailure(result.signal.tokenIn);
+            }
           } else {
             console.warn(`Trade failed: ${result.error}`);
             this.relay?.sendMessage(
@@ -9638,6 +9840,41 @@ var AgentRuntime = class {
               result.error || "Unknown error",
               { action: result.signal.action }
             );
+            if (result.signal.action === "sell") {
+              const failedToken = result.signal.tokenIn.toLowerCase();
+              this.positionTracker.recordSellFailure(failedToken, result.error || "Unknown error");
+            }
+          }
+        }
+        const stuckPositions = this.positionTracker.getStuckPositions(marketData.prices);
+        for (const stuck of stuckPositions) {
+          if (this.positionTracker.shouldAlertStuckPosition(stuck.token)) {
+            const holdingDays = Math.floor(stuck.holdingDurationMs / (1e3 * 60 * 60 * 24));
+            this.relay?.sendMessage(
+              "position_stuck",
+              "warning",
+              `Position Stuck: ${stuck.symbol}`,
+              `Unable to sell ${stuck.symbol} after ${stuck.consecutiveFailures} attempts. This position has been held for ${holdingDays} days with ~$${stuck.estimatedValueUSD.toFixed(2)} value.
+
+Last error: ${stuck.lastFailureReason}
+
+MANUAL EXIT REQUIRED:
+1. Export your wallet key: npx @exagent/agent export-key
+2. Import into MetaMask or Rabby
+3. Go to Uniswap/Aerodrome and swap ${stuck.symbol} \u2192 ETH directly
+4. Use high slippage (10-20%) for illiquid tokens
+
+Note: Manual sells won't be tracked in your agent's PnL. The position will be removed from tracking once your balance is synced.
+
+See: https://exagent.io/docs/guides/manual-exit`,
+              {
+                token: stuck.token,
+                symbol: stuck.symbol,
+                consecutiveFailures: stuck.consecutiveFailures,
+                estimatedValueUSD: stuck.estimatedValueUSD,
+                holdingDurationMs: stuck.holdingDurationMs
+              }
+            );
           }
         }
         for (const result of results) {
@@ -9663,7 +9900,7 @@ var AgentRuntime = class {
         if (marketPnL !== 0) {
           console.log(`Cycle PnL: $${marketPnL.toFixed(2)} (market), -$${totalFeesUSD.toFixed(2)} (fees)`);
         }
-        this.positionTracker.syncBalances(postTradeData.balances, postTradeData.prices);
+        void this.positionTracker.syncBalances(postTradeData.balances, postTradeData.prices);
         this.lastPortfolioValue = postTradeData.portfolioValue;
         const postNativeEthBal = postTradeData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
         this.lastEthBalance = (Number(postNativeEthBal) / 1e18).toFixed(6);

package/dist/cli.mjs

@@ -29,7 +29,7 @@ import {
   results_exports,
   saveSessionResult,
   validateConfig
-} from "./chunk-34JBZQO6.mjs";
+} from "./chunk-R7LBXQH2.mjs";
 
 // src/backtest/data-loader.ts
 import * as fs from "fs";

package/dist/index.d.mts

@@ -9,6 +9,24 @@ interface RiskState {
     dailyFees: number;
     lastResetDate: string;
 }
+/** Stuck position detection result */
+interface StuckPosition {
+    token: string;
+    symbol: string;
+    consecutiveFailures: number;
+    lastFailureReason: string;
+    holdingDurationMs: number;
+    estimatedValueUSD: number;
+}
+/** Result of an inferred exit detected during balance sync */
+interface InferredExit {
+    token: string;
+    symbol: string;
+    amountExited: number;
+    exitValueUSD: number;
+    realizedPnL: number;
+    costBasis: number;
+}
 /**
  * PositionTracker — automatic position tracking with persistence.
  *
@@ -25,6 +43,7 @@ declare class PositionTracker {
     private store;
     private positions;
     private tradeHistory;
+    private sellFailures;
     private maxTradeHistory;
     constructor(store: StrategyStore, options?: {
         maxTradeHistory?: number;
@@ -55,9 +74,20 @@ declare class PositionTracker {
     private handleSell;
     /**
      * Sync tracked positions with on-chain balances.
-     * Updates currentAmount, detects new tokens (airdrops), removes zeroed positions.
+     * Updates currentAmount, detects new tokens (airdrops), and handles position exits.
+     *
+     * CRITICAL: When a tracked position's balance decreases without a corresponding
+     * sell trade, we infer a manual exit and record it with realized PnL calculated
+     * at current market price. This prevents PnL manipulation via off-router sells.
+     *
+     * Returns array of inferred exits for the runtime to report to Command Center.
      */
-    syncBalances(balances: Record<string, bigint>, prices: Record<string, number>): void;
+    syncBalances(balances: Record<string, bigint>, prices: Record<string, number>): InferredExit[];
+    /**
+     * Record an inferred exit in trade history.
+     * These are exits detected from balance changes, not from tracked sell executions.
+     */
+    private recordInferredExit;
     /** Get all tracked positions (backfills missing symbols from resolver) */
     getPositions(): TrackedPosition[];
     /** Get a single position by token address */
@@ -68,6 +98,31 @@ declare class PositionTracker {
     getUnrealizedPnL(prices: Record<string, number>): Record<string, number>;
     /** Get total unrealized PnL across all positions */
     getTotalUnrealizedPnL(prices: Record<string, number>): number;
+    /**
+     * Record a sell failure for a token. Called when a sell attempt fails
+     * due to liquidity issues, route simulation failure, or excessive price impact.
+     */
+    recordSellFailure(token: string, reason: string): void;
+    /**
+     * Clear sell failure tracking for a token (called after successful sell).
+     */
+    clearSellFailure(token: string): void;
+    /**
+     * Detect positions that are "stuck" — we've tried and failed to sell them
+     * multiple times, likely due to insufficient liquidity.
+     *
+     * Returns positions that have failed to sell >= STUCK_FAILURE_THRESHOLD times.
+     */
+    getStuckPositions(prices: Record<string, number>): StuckPosition[];
+    /**
+     * Check if a specific position is stuck.
+     */
+    isPositionStuck(token: string): boolean;
+    /**
+     * Check if we should alert about a stuck position (rate-limited to once per 24h).
+     * Returns true if we should alert, and marks the alert as sent.
+     */
+    shouldAlertStuckPosition(token: string): boolean;
     /** Load persisted risk state */
     getRiskState(): RiskState;
     /** Save risk state to persistent store */
@@ -783,6 +838,13 @@ interface TradeRecord {
     /** Realized PnL in USD (only for sells) */
     realizedPnL?: number;
     success: boolean;
+    /**
+     * True if this trade was inferred from balance changes, not from a tracked execution.
+     * Inferred exits occur when a position's balance decreases without a corresponding
+     * sell trade — typically from manual swaps outside the ExagentRouter.
+     * PnL is calculated at current market price and counts toward total realized PnL.
+     */
+    inferred?: boolean;
 }
 /**
  * Compact position summary for relay heartbeats.
@@ -936,7 +998,7 @@ interface RelayCommand {
     type: CommandType;
     params?: Record<string, unknown>;
 }
-type MessageType = 'trade_executed' | 'trade_failed' | 'paper_trade_executed' | 'paper_trade_failed' | 'perp_fill' | 'perp_liquidation_warning' | 'perp_funding' | 'prediction_fill' | 'prediction_market_resolved' | 'prediction_vault_created' | 'prediction_vault_deposit' | 'prediction_vault_withdraw' | 'funds_low' | 'risk_limit_hit' | 'vault_created' | 'config_updated' | 'llm_error' | 'command_result' | 'system';
+type MessageType = 'trade_executed' | 'trade_failed' | 'paper_trade_executed' | 'paper_trade_failed' | 'perp_fill' | 'perp_liquidation_warning' | 'perp_funding' | 'prediction_fill' | 'prediction_market_resolved' | 'prediction_vault_created' | 'prediction_vault_deposit' | 'prediction_vault_withdraw' | 'funds_low' | 'risk_limit_hit' | 'position_stuck' | 'position_inferred_exit' | 'vault_created' | 'config_updated' | 'llm_error' | 'command_result' | 'system';
 type MessageLevel = 'info' | 'warning' | 'error' | 'success';
 interface AgentStatusPayload {
     mode: AgentMode;
@@ -3283,6 +3345,6 @@ declare function decryptEnvFile(encPath: string, passphrase: string): Record<str
 declare function loadSecureEnv(basePath: string, passphrase?: string): boolean;
 
 /** @exagent/agent package version — update alongside package.json */
-declare const AGENT_VERSION = "0.1.41";
+declare const AGENT_VERSION = "0.1.42";
 
-export { AGENT_VERSION, type AccountSummary, type AgentConfig, AgentConfigSchema, type AgentMode, AgentRuntime, type AgentStatusPayload, AnthropicAdapter, BaseLLMAdapter, type BridgeResult, type BridgeStep, type CommandType, DeepSeekAdapter, FileStore, type FillCallback, type FundingCallback, type FundingPayment, GoogleAdapter, GroqAdapter, HYPERLIQUID_DOMAIN, HyperliquidClient, HyperliquidSigner, HyperliquidWebSocket, type LLMAdapter, type LLMConfig, LLMConfigSchema, type LLMMessage, type LLMMetadata, type LLMProvider, LLMProviderSchema, type LLMResponse, type LiquidationCallback, type LocalPosition, MARKET_CATEGORIES, MarketBrowser, type MarketCategory, type MarketData, MarketDataService, type MessageLevel, type MessageType, MistralAdapter, OllamaAdapter, type OnboardingStatus, OpenAIAdapter, OrderManager, type OrderResult, type PerpAction, type PerpConfig$1 as PerpConfig, PerpConfigSchema, type PerpFill, type PerpMarketData, PerpOnboarding, type PerpPosition, type PerpStrategyFunction, PerpTradeRecorder, type PerpTradeSignal, type PerpConfig as PerpTradingConfig, PolymarketClient, PositionManager, type PositionSummary, PositionTracker, type PredictionAccountSummary, type PredictionAction, type PredictionConfig$1 as PredictionConfig, PredictionConfigSchema, type PredictionFill, PredictionFunding, type PredictionFundingConfig, type PredictionMarket, PredictionOrderManager, type PredictionPosition, PredictionPositionManager, type PredictionStrategyFunction, PredictionTradeRecorder, type PredictionTradeSignal, type PredictionConfig as PredictionTradingConfig, type RecordPerpTradeParams, type RecordPredictionTradeParams, RelayClient, type RelayCommand, type RelayConfig$1 as RelayConfig, RelayConfigSchema, RiskManager, type RiskState, type RiskUniverse, RiskUniverseSchema, type RuntimeConfig, STRATEGY_TEMPLATES, type StrategyContext, type StrategyFunction, type StrategyStore, type StrategyTemplate, TogetherAdapter, type TrackedPosition, TradeExecutor, type TradeRecord, type TradeSignal, type TradingConfig, TradingConfigSchema, type VaultConfig, VaultConfigSchema, VaultManager, type VaultManagerConfig, type VaultPolicy, VaultPolicySchema, type VaultStatus, calculatePredictionFee, createLLMAdapter, createSampleConfig, decodePredictionInstrument, decryptEnvFile, encodePredictionInstrument, encryptEnvFile, fillHashToBytes32, fillOidToBytes32, getAllStrategyTemplates, getNextNonce, getStrategyTemplate, loadConfig, loadSecureEnv, loadStrategy, orderIdToBytes32, tradeIdToBytes32, validateConfig, validateStrategy };
+export { AGENT_VERSION, type AccountSummary, type AgentConfig, AgentConfigSchema, type AgentMode, AgentRuntime, type AgentStatusPayload, AnthropicAdapter, BaseLLMAdapter, type BridgeResult, type BridgeStep, type CommandType, DeepSeekAdapter, FileStore, type FillCallback, type FundingCallback, type FundingPayment, GoogleAdapter, GroqAdapter, HYPERLIQUID_DOMAIN, HyperliquidClient, HyperliquidSigner, HyperliquidWebSocket, type InferredExit, type LLMAdapter, type LLMConfig, LLMConfigSchema, type LLMMessage, type LLMMetadata, type LLMProvider, LLMProviderSchema, type LLMResponse, type LiquidationCallback, type LocalPosition, MARKET_CATEGORIES, MarketBrowser, type MarketCategory, type MarketData, MarketDataService, type MessageLevel, type MessageType, MistralAdapter, OllamaAdapter, type OnboardingStatus, OpenAIAdapter, OrderManager, type OrderResult, type PerpAction, type PerpConfig$1 as PerpConfig, PerpConfigSchema, type PerpFill, type PerpMarketData, PerpOnboarding, type PerpPosition, type PerpStrategyFunction, PerpTradeRecorder, type PerpTradeSignal, type PerpConfig as PerpTradingConfig, PolymarketClient, PositionManager, type PositionSummary, PositionTracker, type PredictionAccountSummary, type PredictionAction, type PredictionConfig$1 as PredictionConfig, PredictionConfigSchema, type PredictionFill, PredictionFunding, type PredictionFundingConfig, type PredictionMarket, PredictionOrderManager, type PredictionPosition, PredictionPositionManager, type PredictionStrategyFunction, PredictionTradeRecorder, type PredictionTradeSignal, type PredictionConfig as PredictionTradingConfig, type RecordPerpTradeParams, type RecordPredictionTradeParams, RelayClient, type RelayCommand, type RelayConfig$1 as RelayConfig, RelayConfigSchema, RiskManager, type RiskState, type RiskUniverse, RiskUniverseSchema, type RuntimeConfig, STRATEGY_TEMPLATES, type StrategyContext, type StrategyFunction, type StrategyStore, type StrategyTemplate, type StuckPosition, TogetherAdapter, type TrackedPosition, TradeExecutor, type TradeRecord, type TradeSignal, type TradingConfig, TradingConfigSchema, type VaultConfig, VaultConfigSchema, VaultManager, type VaultManagerConfig, type VaultPolicy, VaultPolicySchema, type VaultStatus, calculatePredictionFee, createLLMAdapter, createSampleConfig, decodePredictionInstrument, decryptEnvFile, encodePredictionInstrument, encryptEnvFile, fillHashToBytes32, fillOidToBytes32, getAllStrategyTemplates, getNextNonce, getStrategyTemplate, loadConfig, loadSecureEnv, loadStrategy, orderIdToBytes32, tradeIdToBytes32, validateConfig, validateStrategy };