@exagent/agent 0.1.47 → 0.1.48

package/dist/cli.js

@@ -332,7 +332,7 @@ function getTokenDecimals(address) {
 function getTokenSymbol(address) {
   return _globalResolver?.getSymbol(address.toLowerCase());
 }
-var import_viem2, import_chains, NATIVE_ETH, _globalResolver, TOKEN_DECIMALS, TOKEN_TO_COINGECKO, STABLECOIN_IDS, PRICE_STALENESS_MS, MarketDataService;
+var import_viem2, import_chains, NATIVE_ETH, _globalResolver, TOKEN_DECIMALS, TOKEN_TO_COINGECKO, STABLECOIN_IDS, PRICE_STALENESS_MS, HISTORY_STALENESS_MS, MarketDataService;
 var init_market = __esm({
   "src/trading/market.ts"() {
     "use strict";
@@ -498,6 +498,7 @@ var init_market = __esm({
     };
     STABLECOIN_IDS = /* @__PURE__ */ new Set(["usd-coin", "dai", "tether"]);
     PRICE_STALENESS_MS = 6e4;
+    HISTORY_STALENESS_MS = 60 * 6e4;
     MarketDataService = class {
       rpcUrl;
       client;
@@ -510,6 +511,10 @@ var init_market = __esm({
       cachedVolume24h = {};
       /** Cached price change data */
       cachedPriceChange24h = {};
+      /** Cached 24h hourly price history per token address */
+      cachedPriceHistory = {};
+      /** Timestamp of last successful price history fetch */
+      lastHistoryFetchAt = 0;
       constructor(rpcUrl, store) {
         this.rpcUrl = rpcUrl;
         this.client = (0, import_viem2.createPublicClient)({
@@ -530,11 +535,10 @@ var init_market = __esm({
         const prices = await this.fetchPrices(tokenAddresses);
         const balances = await this.fetchBalances(walletAddress, tokenAddresses);
         const portfolioValue = this.calculatePortfolioValue(balances, prices);
-        let gasPrice;
-        try {
-          gasPrice = await this.client.getGasPrice();
-        } catch {
-        }
+        const [priceHistory, gasPrice] = await Promise.all([
+          this.fetchPriceHistory(tokenAddresses).catch(() => void 0),
+          this.client.getGasPrice().catch(() => void 0)
+        ]);
         return {
           timestamp: Date.now(),
           prices,
@@ -545,7 +549,8 @@ var init_market = __esm({
           gasPrice,
           network: {
             chainId: this.client.chain?.id ?? 8453
-          }
+          },
+          priceHistory: priceHistory && Object.keys(priceHistory).length > 0 ? priceHistory : void 0
         };
       }
       /**
@@ -718,6 +723,58 @@ var init_market = __esm({
         }
         return prices;
       }
+      /**
+       * Fetch 24h hourly price history from CoinGecko.
+       * Returns cached data if still fresh (< 60 min old).
+       * Only fetches for tokens with known CoinGecko IDs.
+       */
+      async fetchPriceHistory(tokenAddresses) {
+        if (Date.now() - this.lastHistoryFetchAt < HISTORY_STALENESS_MS && Object.keys(this.cachedPriceHistory).length > 0) {
+          return { ...this.cachedPriceHistory };
+        }
+        const history = {};
+        const idToAddrs = {};
+        for (const addr of tokenAddresses) {
+          const cgId = TOKEN_TO_COINGECKO[addr.toLowerCase()];
+          if (cgId && !STABLECOIN_IDS.has(cgId)) {
+            if (!idToAddrs[cgId]) idToAddrs[cgId] = [];
+            idToAddrs[cgId].push(addr.toLowerCase());
+          }
+        }
+        const ids = Object.keys(idToAddrs);
+        for (let i = 0; i < ids.length; i++) {
+          const cgId = ids[i];
+          try {
+            const resp = await fetch(
+              `https://api.coingecko.com/api/v3/coins/${cgId}/market_chart?vs_currency=usd&days=1`,
+              { signal: AbortSignal.timeout(5e3) }
+            );
+            if (!resp.ok) {
+              if (resp.status === 429) {
+                console.warn("CoinGecko rate limit hit during price history fetch \u2014 using partial data");
+                break;
+              }
+              continue;
+            }
+            const data = await resp.json();
+            if (data.prices && Array.isArray(data.prices)) {
+              const candles = data.prices.map(([ts, price]) => ({ timestamp: ts, price }));
+              for (const addr of idToAddrs[cgId]) {
+                history[addr] = candles;
+              }
+            }
+          } catch {
+          }
+          if (i < ids.length - 1) {
+            await new Promise((r) => setTimeout(r, 2500));
+          }
+        }
+        if (Object.keys(history).length > 0) {
+          this.cachedPriceHistory = { ...this.cachedPriceHistory, ...history };
+          this.lastHistoryFetchAt = Date.now();
+        }
+        return { ...this.cachedPriceHistory };
+      }
       /**
        * Fetch real on-chain balances: native ETH + ERC-20 tokens.
        * Uses Multicall3 to batch all balanceOf calls into a single RPC request.
@@ -1643,6 +1700,10 @@ var init_executor = __esm({
        * Validate a signal against config limits and token restrictions
        */
       validateSignal(signal) {
+        if (signal.amountIn <= 0n) {
+          console.warn(`Signal amountIn is ${signal.amountIn} \u2014 skipping (must be positive)`);
+          return false;
+        }
         if (signal.confidence < 0.5) {
           console.warn(`Signal confidence ${signal.confidence} below threshold (0.5)`);
           return false;
@@ -2587,6 +2648,33 @@ function formatSessionReport(result) {
     }
     lines.push("");
   }
+  if (result.trades.length > 0) {
+    lines.push(`  ${thinDivider}`);
+    lines.push("  TRADE LOG");
+    lines.push(`  ${thinDivider}`);
+    lines.push("");
+    const recentTrades = result.trades.slice(-50);
+    for (const t of recentTrades) {
+      const time = new Date(t.timestamp).toLocaleString(void 0, {
+        month: "short",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit"
+      });
+      const tag = t.action === "buy" ? "BUY " : "SELL";
+      const tokenIn = t.tokenIn.slice(0, 6) + "\u2026";
+      const tokenOut = t.tokenOut.slice(0, 6) + "\u2026";
+      const value = `$${t.valueInUSD.toFixed(2)}`;
+      const pnl = t.valueOutUSD - t.valueInUSD - t.feeUSD - t.gasUSD;
+      const pnlStr = pnl >= 0 ? `+$${pnl.toFixed(2)}` : `-$${Math.abs(pnl).toFixed(2)}`;
+      const reason = t.reasoning ? `  "${t.reasoning.slice(0, 60)}"` : "";
+      lines.push(`  ${time}  ${tag}  ${tokenIn}\u2192${tokenOut}  ${value}  ${pnlStr}${reason}`);
+    }
+    if (result.trades.length > 50) {
+      lines.push(`  ... and ${result.trades.length - 50} earlier trades`);
+    }
+    lines.push("");
+  }
   if (result.equityCurve.length >= 3) {
     lines.push(`  ${thinDivider}`);
     lines.push("  EQUITY CURVE");
@@ -3920,7 +4008,7 @@ var STRATEGY_TEMPLATES = [
   {
     id: "momentum",
     name: "Momentum Trader",
-    description: "Follows price trends and momentum indicators. Buys assets with strong upward momentum.",
+    description: "Follows price trends and momentum indicators. Buys assets with strong upward momentum, sells when momentum fades.",
     riskLevel: "medium",
     riskWarnings: [
       "Momentum strategies can suffer significant losses during trend reversals",
@@ -3928,60 +4016,248 @@ var STRATEGY_TEMPLATES = [
       "Past performance does not guarantee future results",
       "This strategy may underperform in sideways markets"
     ],
-    systemPrompt: `You are an AI trading analyst specializing in momentum trading strategies.
+    systemPrompt: `You are an AI trading analyst specializing in momentum trading on Base network.
 
-Your role is to analyze market data and identify momentum-based trading opportunities.
+Analyze the provided market data and identify momentum-based trading opportunities.
 
-IMPORTANT CONSTRAINTS:
+RULES:
 - Only recommend trades when there is clear momentum evidence
-- Always consider risk/reward ratios
-- Never recommend more than the configured position size limits
-- Be conservative with confidence scores
+- Use priceTrends (1h, 4h, 12h, 24h changes) as your primary momentum signal
+- Fall back to priceChange24h if priceTrends is not available
+- Be conservative with confidence \u2014 only use > 0.6 for strong signals
+- Never recommend buying a token you already hold significant amounts of
+- Always consider selling positions that have lost momentum
+- Return "hold" signals when uncertain \u2014 doing nothing is often the best trade
 
-When analyzing data, look for:
-1. Price trends (higher highs, higher lows for uptrends)
-2. Volume confirmation (increasing volume on moves)
-3. Relative strength vs market benchmarks
+ANALYZE:
+1. Multi-timeframe momentum: use priceTrends (1h, 4h, 12h, 24h) to confirm trend direction
+2. Strong momentum = positive across all timeframes. Divergence (e.g., 1h negative, 12h positive) = weakening
+3. Volume confirmation: prefer tokens with > $10K daily volume
+4. Portfolio concentration: avoid putting > 20% in any single token
+5. Exit signals: sell when short-term trend (1h, 4h) turns negative on a held position
 
-Respond with JSON in this format:
+Respond with ONLY valid JSON (no markdown, no code fences):
 {
-  "analysis": "Brief market analysis",
+  "analysis": "Brief market analysis (1-2 sentences)",
   "signals": [
     {
       "action": "buy" | "sell" | "hold",
-      "tokenIn": "0x...",
-      "tokenOut": "0x...",
-      "percentage": 0-100,
-      "confidence": 0-1,
-      "reasoning": "Why this trade"
+      "token": "0x... (token address to buy/sell)",
+      "percentage": 5-25,
+      "confidence": 0.0-1.0,
+      "reasoning": "Why this trade (1 sentence)"
     }
   ]
-}`,
-    exampleCode: `import { StrategyFunction, MarketData, TradeSignal, LLMAdapter, AgentConfig } from '@exagent/agent';
+}
+
+If no good opportunities exist, return: { "analysis": "No clear momentum signals", "signals": [] }`,
+    exampleCode: `import type { StrategyFunction, MarketData, TradeSignal, LLMAdapter, AgentConfig, StrategyContext } from '@exagent/agent';
+
+// Well-known token addresses on Base
+const WETH = '0x4200000000000000000000000000000000000006';
+const USDC = '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913';
+
+// Token decimals lookup (extend as needed)
+const DECIMALS: Record<string, number> = {
+  [WETH]: 18,
+  [USDC]: 6,
+};
+
+/**
+ * Format balances for LLM consumption (human-readable amounts)
+ */
+function formatBalances(balances: Record<string, bigint>, prices: Record<string, number>): Record<string, { amount: string; usdValue: string }> {
+  const result: Record<string, { amount: string; usdValue: string }> = {};
+  for (const [token, balance] of Object.entries(balances)) {
+    if (balance === 0n) continue;
+    const decimals = DECIMALS[token.toLowerCase()] ?? 18;
+    const amount = Number(balance) / (10 ** decimals);
+    const price = prices[token.toLowerCase()] ?? 0;
+    result[token] = {
+      amount: amount.toFixed(decimals <= 8 ? decimals : 6),
+      usdValue: (amount * price).toFixed(2),
+    };
+  }
+  return result;
+}
+
+/**
+ * Convert LLM percentage signal to a TradeSignal with bigint amountIn
+ *
+ * The LLM says "buy token X with 10% of my ETH" \u2014 this function converts
+ * that percentage into the actual wei amount to trade.
+ */
+function toTradeSignal(
+  signal: { action: string; token: string; percentage: number; confidence: number; reasoning?: string },
+  balances: Record<string, bigint>,
+): TradeSignal | null {
+  const { action, token, percentage, confidence, reasoning } = signal;
+
+  // Skip hold signals and low confidence
+  if (action === 'hold' || confidence < 0.5) return null;
+
+  // Clamp percentage to 1-50 range for safety
+  const pct = Math.max(1, Math.min(50, percentage));
+
+  if (action === 'buy') {
+    // Buying: spend ETH (or USDC) to acquire the target token
+    // Use ETH balance as the source
+    const ethBalance = balances[WETH] ?? 0n;
+    if (ethBalance === 0n) return null;
+    const amountIn = (ethBalance * BigInt(Math.round(pct * 100))) / 10000n;
+    if (amountIn === 0n) return null;
+    return { action: 'buy', tokenIn: WETH, tokenOut: token, amountIn, confidence, reasoning };
+  }
 
+  if (action === 'sell') {
+    // Selling: sell the target token for ETH
+    const tokenBalance = balances[token.toLowerCase()] ?? balances[token] ?? 0n;
+    if (tokenBalance === 0n) return null;
+    const amountIn = (tokenBalance * BigInt(Math.round(pct * 100))) / 10000n;
+    if (amountIn === 0n) return null;
+    return { action: 'sell', tokenIn: token, tokenOut: WETH, amountIn, confidence, reasoning };
+  }
+
+  return null;
+}
+
+/**
+ * Momentum Trading Strategy
+ *
+ * Sends market data to the LLM, parses the response, and converts
+ * percentage-based signals into executable TradeSignal objects.
+ */
 export const generateSignals: StrategyFunction = async (
   marketData: MarketData,
   llm: LLMAdapter,
-  config: AgentConfig
+  config: AgentConfig,
+  context?: StrategyContext,
 ): Promise<TradeSignal[]> => {
+  // Summarize price history into compact trend data for the LLM
+  // Instead of sending 24 raw candles per token, compute useful signals:
+  // - 1h, 4h, 12h, 24h price changes (momentum at different timeframes)
+  const priceTrends: Record<string, { '1h': string; '4h': string; '12h': string; '24h': string }> = {};
+  if (marketData.priceHistory) {
+    for (const [addr, candles] of Object.entries(marketData.priceHistory)) {
+      if (candles.length < 2) continue;
+      const latest = candles[candles.length - 1].price;
+      const getChangeAt = (hoursAgo: number): string => {
+        const target = Date.now() - hoursAgo * 3600_000;
+        // Find the candle closest to the target time
+        let closest = candles[0];
+        for (const c of candles) {
+          if (Math.abs(c.timestamp - target) < Math.abs(closest.timestamp - target)) closest = c;
+        }
+        if (closest.price === 0) return '0.0%';
+        const pct = ((latest - closest.price) / closest.price) * 100;
+        return (pct >= 0 ? '+' : '') + pct.toFixed(1) + '%';
+      };
+      priceTrends[addr] = {
+        '1h': getChangeAt(1),
+        '4h': getChangeAt(4),
+        '12h': getChangeAt(12),
+        '24h': getChangeAt(24),
+      };
+    }
+  }
+
+  // Build the data payload for the LLM
+  const payload: Record<string, unknown> = {
+    prices: marketData.prices,
+    balances: formatBalances(marketData.balances, marketData.prices),
+    portfolioValueUSD: marketData.portfolioValue.toFixed(2),
+    priceChange24h: marketData.priceChange24h ?? {},
+    volume24h: marketData.volume24h ?? {},
+    recentTrades: (context?.tradeHistory ?? []).slice(0, 5).map(t => ({
+      action: t.action,
+      token: t.action === 'buy' ? t.tokenOut : t.tokenIn,
+      reasoning: t.reasoning,
+      timestamp: new Date(t.timestamp).toISOString(),
+    })),
+  };
+
+  // Include price trends if available (more useful than raw candles for LLM)
+  if (Object.keys(priceTrends).length > 0) {
+    payload.priceTrends = priceTrends;
+  }
+
+  // Call the LLM
   const response = await llm.chat([
-    { role: 'system', content: MOMENTUM_SYSTEM_PROMPT },
-    { role: 'user', content: JSON.stringify({
-      prices: marketData.prices,
-      balances: formatBalances(marketData.balances),
-      portfolioValue: marketData.portfolioValue,
-    })}
+    { role: 'system', content: config.strategyPrompt ?? MOMENTUM_SYSTEM_PROMPT },
+    { role: 'user', content: JSON.stringify(payload) },
   ]);
 
-  // Parse LLM response and convert to TradeSignals
-  const parsed = JSON.parse(response.content);
-  return parsed.signals.map(convertToTradeSignal);
-};`
+  // Parse the response \u2014 handle markdown code fences if the LLM wraps its output
+  let content = response.content.trim();
+  if (content.startsWith('\`\`\`')) {
+    content = content.replace(/^\`\`\`(?:json)?\\n?/, '').replace(/\\n?\`\`\`$/, '').trim();
+  }
+
+  let parsed: { signals?: Array<{ action: string; token: string; percentage: number; confidence: number; reasoning?: string }> };
+  try {
+    parsed = JSON.parse(content);
+  } catch (e) {
+    console.error('[strategy] Failed to parse LLM response:', (e as Error).message);
+    console.error('[strategy] Raw response:', content.slice(0, 200));
+    return []; // Safe fallback: no trades
+  }
+
+  if (!parsed.signals || !Array.isArray(parsed.signals)) {
+    return [];
+  }
+
+  // Convert each signal to a TradeSignal with proper bigint amountIn
+  const signals: TradeSignal[] = [];
+  for (const raw of parsed.signals) {
+    const signal = toTradeSignal(raw, marketData.balances);
+    if (signal) signals.push(signal);
+  }
+
+  return signals;
+};
+
+// Default system prompt \u2014 used when config.strategyPrompt is not set
+const MOMENTUM_SYSTEM_PROMPT = \`You are an AI trading analyst specializing in momentum trading on Base network.
+
+Analyze the provided market data and identify momentum-based trading opportunities.
+
+RULES:
+- Only recommend trades when there is clear momentum evidence
+- Use priceTrends (1h, 4h, 12h, 24h changes) as your primary momentum signal
+- Fall back to priceChange24h if priceTrends is not available
+- Be conservative with confidence \u2014 only use > 0.6 for strong signals
+- Never recommend buying a token you already hold significant amounts of
+- Always consider selling positions that have lost momentum
+- Return "hold" signals when uncertain \u2014 doing nothing is often the best trade
+
+ANALYZE:
+1. Multi-timeframe momentum: use priceTrends (1h, 4h, 12h, 24h) to confirm trend direction
+2. Strong momentum = positive across all timeframes. Divergence (e.g., 1h negative, 12h positive) = weakening
+3. Volume confirmation: prefer tokens with > $10K daily volume
+4. Portfolio concentration: avoid putting > 20% in any single token
+5. Exit signals: sell when short-term trend (1h, 4h) turns negative on a held position
+
+Respond with ONLY valid JSON (no markdown, no code fences):
+{
+  "analysis": "Brief market analysis (1-2 sentences)",
+  "signals": [
+    {
+      "action": "buy" | "sell" | "hold",
+      "token": "0x... (token address to buy/sell)",
+      "percentage": 5-25,
+      "confidence": 0.0-1.0,
+      "reasoning": "Why this trade (1 sentence)"
+    }
+  ]
+}
+
+If no good opportunities exist, return: { "analysis": "No clear momentum signals", "signals": [] }\`;
+`
   },
   {
     id: "value",
     name: "Value Investor",
-    description: "Looks for undervalued assets based on fundamentals. Takes long-term positions.",
+    description: "Looks for undervalued assets based on fundamentals. Takes long-term positions with lower turnover.",
     riskLevel: "low",
     riskWarnings: [
       "Value traps can result in prolonged losses",
@@ -3989,47 +4265,135 @@ export const generateSignals: StrategyFunction = async (
       "Fundamental analysis may not apply well to all crypto assets",
       "Market sentiment can override fundamentals for long periods"
     ],
-    systemPrompt: `You are an AI trading analyst specializing in value investing.
+    systemPrompt: `You are an AI trading analyst specializing in value investing on Base network.
 
 Your role is to identify undervalued assets with strong fundamentals.
 
-IMPORTANT CONSTRAINTS:
+RULES:
 - Focus on long-term value, not short-term price movements
 - Only recommend assets with clear value propositions
 - Consider protocol revenue, TVL, active users, developer activity
-- Be very selective - quality over quantity
+- Be very selective \u2014 quality over quantity
+- Prefer established tokens (AERO, WELL, MORPHO, COMP, CRV) over memecoins
+- Hold positions for days/weeks, not hours
 
-When analyzing, consider:
-1. Protocol fundamentals (revenue, TVL, user growth)
-2. Token economics (supply schedule, utility)
-3. Competitive positioning
-4. Valuation relative to peers
-
-Respond with JSON in this format:
+Respond with ONLY valid JSON:
 {
   "analysis": "Brief fundamental analysis",
   "signals": [
     {
       "action": "buy" | "sell" | "hold",
-      "tokenIn": "0x...",
-      "tokenOut": "0x...",
-      "percentage": 0-100,
-      "confidence": 0-1,
+      "token": "0x... (token address)",
+      "percentage": 5-20,
+      "confidence": 0.0-1.0,
       "reasoning": "Fundamental thesis"
     }
   ]
 }`,
-    exampleCode: `import { StrategyFunction } from '@exagent/agent';
+    exampleCode: `import type { StrategyFunction, MarketData, TradeSignal, LLMAdapter, AgentConfig, StrategyContext } from '@exagent/agent';
+
+const WETH = '0x4200000000000000000000000000000000000006';
+const USDC = '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913';
+const DECIMALS: Record<string, number> = { [WETH]: 18, [USDC]: 6 };
+
+function formatBalances(balances: Record<string, bigint>, prices: Record<string, number>): Record<string, { amount: string; usdValue: string }> {
+  const result: Record<string, { amount: string; usdValue: string }> = {};
+  for (const [token, balance] of Object.entries(balances)) {
+    if (balance === 0n) continue;
+    const decimals = DECIMALS[token.toLowerCase()] ?? 18;
+    const amount = Number(balance) / (10 ** decimals);
+    const price = prices[token.toLowerCase()] ?? 0;
+    result[token] = { amount: amount.toFixed(6), usdValue: (amount * price).toFixed(2) };
+  }
+  return result;
+}
+
+function toTradeSignal(
+  signal: { action: string; token: string; percentage: number; confidence: number; reasoning?: string },
+  balances: Record<string, bigint>,
+): TradeSignal | null {
+  if (signal.action === 'hold' || signal.confidence < 0.5) return null;
+  const pct = Math.max(1, Math.min(50, signal.percentage));
+  if (signal.action === 'buy') {
+    const ethBalance = balances[WETH] ?? 0n;
+    if (ethBalance === 0n) return null;
+    const amountIn = (ethBalance * BigInt(Math.round(pct * 100))) / 10000n;
+    if (amountIn === 0n) return null;
+    return { action: 'buy', tokenIn: WETH, tokenOut: signal.token, amountIn, confidence: signal.confidence, reasoning: signal.reasoning };
+  }
+  if (signal.action === 'sell') {
+    const tokenBalance = balances[signal.token.toLowerCase()] ?? balances[signal.token] ?? 0n;
+    if (tokenBalance === 0n) return null;
+    const amountIn = (tokenBalance * BigInt(Math.round(pct * 100))) / 10000n;
+    if (amountIn === 0n) return null;
+    return { action: 'sell', tokenIn: signal.token, tokenOut: WETH, amountIn, confidence: signal.confidence, reasoning: signal.reasoning };
+  }
+  return null;
+}
+
+export const generateSignals: StrategyFunction = async (
+  marketData: MarketData,
+  llm: LLMAdapter,
+  config: AgentConfig,
+  context?: StrategyContext,
+): Promise<TradeSignal[]> => {
+  const payload = {
+    prices: marketData.prices,
+    balances: formatBalances(marketData.balances, marketData.prices),
+    portfolioValueUSD: marketData.portfolioValue.toFixed(2),
+    priceChange24h: marketData.priceChange24h ?? {},
+    positions: (context?.positions ?? []).map(p => ({
+      token: p.tokenAddress,
+      entryPrice: p.averageEntryPrice,
+      currentAmount: p.currentAmount.toString(),
+    })),
+  };
 
-export const generateSignals: StrategyFunction = async (marketData, llm, config) => {
-  // Value strategy runs less frequently
   const response = await llm.chat([
-    { role: 'system', content: VALUE_SYSTEM_PROMPT },
-    { role: 'user', content: JSON.stringify(marketData) }
+    { role: 'system', content: config.strategyPrompt ?? VALUE_SYSTEM_PROMPT },
+    { role: 'user', content: JSON.stringify(payload) },
   ]);
 
-  return parseSignals(response.content);
-};`
+  let content = response.content.trim();
+  if (content.startsWith('\\\`\\\`\\\`')) {
+    content = content.replace(/^\\\`\\\`\\\`(?:json)?\\n?/, '').replace(/\\n?\\\`\\\`\\\`$/, '').trim();
+  }
+
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed.signals || !Array.isArray(parsed.signals)) return [];
+    return parsed.signals.map((s: any) => toTradeSignal(s, marketData.balances)).filter(Boolean) as TradeSignal[];
+  } catch (e) {
+    console.error('[strategy] Failed to parse LLM response:', (e as Error).message);
+    return [];
+  }
+};
+
+const VALUE_SYSTEM_PROMPT = \`You are an AI trading analyst specializing in value investing on Base network.
+
+Your role is to identify undervalued assets with strong fundamentals.
+
+RULES:
+- Focus on long-term value, not short-term price movements
+- Only recommend assets with clear value propositions
+- Be very selective \u2014 quality over quantity
+- Prefer established tokens over memecoins
+- Hold positions for days/weeks, not hours
+
+Respond with ONLY valid JSON:
+{
+  "analysis": "Brief fundamental analysis",
+  "signals": [
+    {
+      "action": "buy" | "sell" | "hold",
+      "token": "0x... (token address)",
+      "percentage": 5-20,
+      "confidence": 0.0-1.0,
+      "reasoning": "Fundamental thesis"
+    }
+  ]
+}\`;
+`
   },
   {
     id: "arbitrage",
@@ -4069,7 +4433,7 @@ Respond with JSON in this format:
     exampleCode: `// Note: Pure arbitrage requires specialized infrastructure
 // This template is for educational purposes
 
-import { StrategyFunction } from '@exagent/agent';
+import type { StrategyFunction } from '@exagent/agent';
 
 export const generateSignals: StrategyFunction = async (marketData, llm, config) => {
   // Arbitrage requires real-time price feeds from multiple sources
@@ -4101,18 +4465,21 @@ Respond with JSON:
 {
   "signals": []
 }`,
-    exampleCode: `import { StrategyFunction, MarketData, TradeSignal, LLMAdapter, AgentConfig } from '@exagent/agent';
+    exampleCode: `import type { StrategyFunction, MarketData, TradeSignal, LLMAdapter, AgentConfig, StrategyContext } from '@exagent/agent';
+
+const WETH = '0x4200000000000000000000000000000000000006';
 
 /**
  * Custom Strategy Template
  *
  * Customize this file with your own trading logic and prompts.
- * Your prompts are YOUR intellectual property - we don't store them.
+ * Your prompts are YOUR intellectual property \u2014 we don't store them.
  */
 export const generateSignals: StrategyFunction = async (
   marketData: MarketData,
   llm: LLMAdapter,
-  config: AgentConfig
+  config: AgentConfig,
+  context?: StrategyContext,
 ): Promise<TradeSignal[]> => {
   // Your custom system prompt (this is your secret sauce)
   const systemPrompt = \`
@@ -4122,13 +4489,26 @@ export const generateSignals: StrategyFunction = async (
   // Call the LLM with your prompt
   const response = await llm.chat([
     { role: 'system', content: systemPrompt },
-    { role: 'user', content: JSON.stringify(marketData) }
+    { role: 'user', content: JSON.stringify({
+      prices: marketData.prices,
+      balances: Object.fromEntries(
+        Object.entries(marketData.balances)
+          .filter(([, v]) => v > 0n)
+          .map(([k, v]) => [k, v.toString()])
+      ),
+      portfolioValue: marketData.portfolioValue,
+    })},
   ]);
 
   // Parse and return signals
   // IMPORTANT: Validate LLM output before using
+  let content = response.content.trim();
+  if (content.startsWith('\\\`\\\`\\\`')) {
+    content = content.replace(/^\\\`\\\`\\\`(?:json)?\\n?/, '').replace(/\\n?\\\`\\\`\\\`$/, '').trim();
+  }
+
   try {
-    const parsed = JSON.parse(response.content);
+    const parsed = JSON.parse(content);
     return parsed.signals || [];
   } catch (e) {
     console.error('Failed to parse LLM response:', e);
@@ -4137,6 +4517,9 @@ export const generateSignals: StrategyFunction = async (
 };`
   }
 ];
+function getStrategyTemplate(id) {
+  return STRATEGY_TEMPLATES.find((t) => t.id === id);
+}
 function getAllStrategyTemplates() {
   return STRATEGY_TEMPLATES;
 }
@@ -4284,6 +4667,8 @@ var AgentConfigSchema = import_zod.z.object({
   perp: PerpConfigSchema,
   // Prediction market configuration (Polymarket)
   prediction: PredictionConfigSchema,
+  // Custom strategy system prompt (overrides built-in template prompt)
+  strategyPrompt: import_zod.z.string().optional(),
   // Allowed tokens (addresses)
   allowedTokens: import_zod.z.array(import_zod.z.string()).optional()
 });
@@ -8071,7 +8456,7 @@ function loadSecureEnv(basePath, passphrase) {
 }
 
 // src/index.ts
-var AGENT_VERSION = "0.1.47";
+var AGENT_VERSION = "0.1.48";
 
 // src/relay.ts
 var RelayClient = class {
@@ -10788,6 +11173,95 @@ ${llmEnvVar}EXAGENT_LLM_MODEL=${config.llm?.model || ""}
     (0, import_dotenv2.config)({ path: envPath, override: true });
   }
 }
+program.command("init").description("Scaffold a new agent project with strategy template and config").option("-t, --template <template>", "Strategy template (momentum, value, arbitrage, custom)", "momentum").option("--force", "Overwrite existing files without prompting").action(async (options) => {
+  try {
+    const templateId = options.template;
+    const template = getStrategyTemplate(templateId);
+    if (!template) {
+      const templates = getAllStrategyTemplates();
+      console.error(`Unknown template: ${templateId}`);
+      console.error(`Available templates: ${templates.map((t) => t.id).join(", ")}`);
+      process.exit(1);
+    }
+    console.log("");
+    console.log("=".repeat(50));
+    console.log("  EXAGENT INIT");
+    console.log("=".repeat(50));
+    console.log("");
+    console.log(`  Template: ${template.name}`);
+    console.log(`  Risk:     ${template.riskLevel}`);
+    console.log("");
+    const cwd = process.cwd();
+    const strategyPath = path7.join(cwd, "strategy.ts");
+    const configPath = path7.join(cwd, "agent-config.json");
+    const existingFiles = [];
+    if (fs6.existsSync(strategyPath)) existingFiles.push("strategy.ts");
+    if (fs6.existsSync(configPath)) existingFiles.push("agent-config.json");
+    if (existingFiles.length > 0 && !options.force) {
+      console.log(`  Files already exist: ${existingFiles.join(", ")}`);
+      const answer = await prompt("  Overwrite? (y/n): ");
+      if (answer.toLowerCase() !== "y") {
+        console.log("  Aborted.");
+        process.exit(0);
+      }
+      console.log("");
+    }
+    fs6.writeFileSync(strategyPath, template.exampleCode.trim() + "\n");
+    console.log("  Created: strategy.ts");
+    const defaultConfig = {
+      agentId: 0,
+      name: "my-agent",
+      network: "mainnet",
+      llm: {
+        provider: "openai",
+        model: "gpt-4o",
+        temperature: 0.7,
+        maxTokens: 4096
+      },
+      riskUniverse: "established",
+      trading: {
+        timeHorizon: "swing",
+        maxPositionSizeBps: 1e3,
+        maxDailyLossBps: 500,
+        maxConcurrentPositions: 5,
+        tradingIntervalMs: 6e4,
+        maxSlippageBps: 100,
+        minTradeValueUSD: 1
+      },
+      wallet: {
+        setup: "generate"
+      },
+      relay: {
+        enabled: true,
+        apiUrl: "https://exagent-api.onrender.com"
+      }
+    };
+    if (!fs6.existsSync(configPath) || options.force || existingFiles.includes("agent-config.json")) {
+      fs6.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + "\n");
+      console.log("  Created: agent-config.json");
+    }
+    console.log("");
+    console.log("=".repeat(50));
+    console.log("  NEXT STEPS");
+    console.log("=".repeat(50));
+    console.log("");
+    console.log("  1. Register your agent at https://exagent.io/deploy");
+    console.log("  2. Copy your agent ID into agent-config.json");
+    console.log("  3. Update agent-config.json with your name and LLM provider");
+    console.log("  4. Run: npx @exagent/agent paper");
+    console.log("     (paper trade first to validate your strategy)");
+    console.log("");
+    console.log("  5. When ready for real trading:");
+    console.log("     npx @exagent/agent run");
+    console.log("");
+    console.log("=".repeat(50));
+    console.log("");
+    process.exit(0);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
 program.command("run").description("Start the trading agent").option("-c, --config <path>", "Path to agent-config.json", "agent-config.json").option("-p, --passphrase <passphrase>", "Passphrase to decrypt .env.enc").action(async (options) => {
   try {
     await checkFirstRunSetup(options.config);