nothumanallowed 15.1.69 → 16.0.0

package/src/services/tool-executor.mjs

@@ -97,7 +97,7 @@ export const DESTRUCTIVE_ACTIONS = new Set([
   // Cron / scheduling
   'cron_create', 'cron_delete',
   // Portfolio (local file)
-  'portfolio_add', 'portfolio_remove',
+  'portfolio_add', 'portfolio_remove', 'portfolio_tx_add',
 ]);
 
 // ── Tool Definitions (for system prompt) ─────────────────────────────────────
@@ -742,6 +742,38 @@ TOOLS:
     SEC Form 4 (insider/officer transactions) for a US-listed company. Returns last N filings with direct URLs.
     Open each URL to see whether the insider BOUGHT or SOLD shares — strong signal when clustered.
 
+107. option_strategy_builder(ticker: string, direction?: string, maxRisk?: number, daysToExpiry?: number)
+    Suggests concrete option strategies with strikes, expiry, net debit/credit, max profit/loss, breakeven, ROI.
+    direction: "bullish" | "bearish" | "neutral". Default: neutral. maxRisk: $ budget (default 1000). daysToExpiry: default 30.
+    Output adapts to ATM IV percentile vs 30d realized vol (cheap < 30th = buy premium; rich > 70th = sell premium):
+    - bullish+cheap → Bull Call Debit Spread        - bullish+rich → Bull Put Credit Spread
+    - bearish+cheap → Bear Put Debit Spread         - bearish+rich → Bear Call Credit Spread
+    - neutral+rich  → Iron Condor                   - neutral+cheap → Long Straddle
+    Each suggestion includes exact contracts × ticker × expiry × strike × side, with sizing scaled to maxRisk.
+
+108. crypto_onchain_metrics(coin: string)
+    Multi-source on-chain & derivatives view of a crypto asset. coin = CoinGecko ID (bitcoin, ethereum, solana, …).
+    Combines:
+    - CoinGecko market data: price, mcap, supply, ATH distance, social signal
+    - DeFi Llama TVL (for L1s): 30-day TVL trend
+    - Binance perpetual futures: 8h funding rate (last + avg of 8), open interest, positioning signal 🟢/🔴/🟡
+    - Alternative.me Fear & Greed Index (0-100)
+    - CoinGecko global: BTC/ETH/stablecoin market share
+    All-free APIs. No API key required.
+
+109. portfolio_tax_lots(method?: string)
+    Tax-lot accounting on the transaction history. method: "FIFO" | "LIFO" | "HIFO". Default: FIFO.
+    Computes realized short-term (taxed at income rate) vs long-term (15%/20% US) gains per ticker.
+    Lists open lots with cost basis, age (long-term threshold 365 days), unrealized P/L per lot.
+    Surfaces:
+    - ⚠ Wash-sale warnings: buys within 30 days of a loss sale (IRS §1091)
+    - 💡 Tax-loss harvest candidates: open lots with unrealized loss > $100, flags if hold < 31d (wash-sale risk)
+    Requires transactions recorded via portfolio_tx_add (legacy portfolio_add still works for current state).
+
+110. portfolio_tx_add(ticker: string, type: "buy"|"sell", qty: number, price: number, date?: string)
+    Record a dated transaction. Feeds portfolio_tax_lots. Also updates current positions for portfolio_summary parity.
+    date format: "YYYY-MM-DD" (defaults to today).
+
 --- CODE EXECUTION ---
 
 81. execute_code(language: "python"|"javascript"|"typescript", code: string, files?: [{path: string, content: string}], packages?: string[], stdin?: string, timeout?: number)
@@ -4692,6 +4724,482 @@ print(f"  Max drawdown: {max_dd*100:.2f}%")
       return lines.join('\n');
     }
 
+    case 'option_strategy_builder': {
+      const ticker = String(params.ticker || '').toUpperCase();
+      const direction = String(params.direction || 'neutral').toLowerCase();
+      const maxRisk = parseFloat(params.maxRisk || params.max_risk || '1000');
+      const targetDays = parseInt(params.daysToExpiry || params.dte || '30', 10);
+      if (!ticker) return 'option_strategy_builder: ticker required.';
+      try {
+        // 1. Fetch options chain (Yahoo Finance, free)
+        const chainRes = await fetch(`https://query2.finance.yahoo.com/v7/finance/options/${encodeURIComponent(ticker)}`, { headers: { 'User-Agent': 'Mozilla/5.0 (compatible; NHA/1.0)' } });
+        if (!chainRes.ok) return `option_strategy_builder: HTTP ${chainRes.status}`;
+        const cd = await chainRes.json();
+        const result = cd?.optionChain?.result?.[0];
+        if (!result) return `option_strategy_builder: no options data for ${ticker}.`;
+        const spot = result.quote?.regularMarketPrice;
+        // 2. Pick the expiration closest to targetDays
+        const today = Date.now() / 1000;
+        const exps = result.expirationDates || [];
+        const expPicked = exps.reduce((best, e) => {
+          const dte = (e - today) / 86400;
+          if (dte < 5) return best;
+          const bestDte = best ? (best - today) / 86400 : Infinity;
+          return Math.abs(dte - targetDays) < Math.abs(bestDte - targetDays) ? e : best;
+        }, 0);
+        if (!expPicked) return `option_strategy_builder: no suitable expiry near ${targetDays} days.`;
+        const dtePicked = Math.round((expPicked - today) / 86400);
+        // Fetch the picked chain
+        const pickedRes = await fetch(`https://query2.finance.yahoo.com/v7/finance/options/${encodeURIComponent(ticker)}?date=${expPicked}`, { headers: { 'User-Agent': 'Mozilla/5.0 (compatible; NHA/1.0)' } });
+        const pickedData = await pickedRes.json();
+        const opts = pickedData?.optionChain?.result?.[0]?.options?.[0] || {};
+        const calls = opts.calls || [];
+        const puts = opts.puts || [];
+        if (calls.length === 0 || puts.length === 0) return `option_strategy_builder: empty chain for chosen expiry.`;
+        // 3. ATM IV (average call+put closest to spot)
+        const closest = (arr) => arr.reduce((a, b) => Math.abs(a.strike - spot) < Math.abs(b.strike - spot) ? a : b);
+        const atmCall = closest(calls);
+        const atmPut = closest(puts);
+        const atmIV = ((atmCall.impliedVolatility || 0) + (atmPut.impliedVolatility || 0)) / 2;
+        // 4. IV rank from market_chart historical realized vol as proxy (no API for historical IV free)
+        const chartRes = await fetch(`https://query1.finance.yahoo.com/v8/finance/chart/${encodeURIComponent(ticker)}?range=1y&interval=1d`, { headers: { 'User-Agent': 'Mozilla/5.0 (compatible; NHA/1.0)' } });
+        let ivPercentile = null;
+        try {
+          const ch = await chartRes.json();
+          const closes = ch?.chart?.result?.[0]?.indicators?.quote?.[0]?.close?.filter(Number.isFinite) || [];
+          // Rolling 30-day realized vol annualized
+          const rollingVols = [];
+          for (let i = 30; i < closes.length; i++) {
+            const window = closes.slice(i - 30, i);
+            const rets = window.slice(1).map((v, j) => Math.log(v / window[j]));
+            const mean = rets.reduce((a, b) => a + b, 0) / rets.length;
+            const variance = rets.reduce((a, r) => a + (r - mean) ** 2, 0) / (rets.length - 1);
+            rollingVols.push(Math.sqrt(variance * 252));
+          }
+          if (rollingVols.length > 20) {
+            const sorted = [...rollingVols].sort((a, b) => a - b);
+            const rank = sorted.findIndex(v => v >= atmIV);
+            ivPercentile = rank < 0 ? 100 : (rank / sorted.length) * 100;
+          }
+        } catch {}
+        const ivCheap = ivPercentile != null && ivPercentile < 30;
+        const ivRich = ivPercentile != null && ivPercentile > 70;
+        // 5. Build strategy recommendations
+        const expStr = new Date(expPicked * 1000).toISOString().slice(0, 10);
+        const findStrike = (arr, targetDelta) => {
+          // Find option whose abs(delta) is closest to target. Yahoo doesn't always provide delta;
+          // approximate by inMoneyness: for calls, delta≈0.5 at ATM; +0.05 per 1% ITM.
+          let best = arr[0], bestDist = Infinity;
+          for (const o of arr) {
+            const moneyness = (o.strike - spot) / spot;
+            const approxDelta = arr === calls ? Math.max(0.05, Math.min(0.95, 0.5 - moneyness * 5)) : Math.max(-0.95, Math.min(-0.05, -0.5 - moneyness * 5));
+            const dist = Math.abs(Math.abs(approxDelta) - targetDelta);
+            if (dist < bestDist) { bestDist = dist; best = o; }
+          }
+          return best;
+        };
+        const mid = (o) => ((o.bid || 0) + (o.ask || 0)) / 2 || o.lastPrice || 0;
+        const strategies = [];
+
+        if (direction === 'bullish' || direction === 'long') {
+          if (ivCheap || ivPercentile == null) {
+            // Bull Call Debit Spread (buy ATM, sell OTM)
+            const buy = atmCall;
+            const sell = calls.find(c => c.strike > spot * 1.05) || calls[calls.length - 1];
+            const debit = (mid(buy) - mid(sell)) * 100;
+            const width = (sell.strike - buy.strike) * 100;
+            const maxProfit = width - debit;
+            const maxLoss = debit;
+            const be = buy.strike + (debit / 100);
+            const contracts = Math.max(1, Math.floor(maxRisk / debit));
+            strategies.push({
+              name: 'Bull Call Debit Spread',
+              rationale: 'Bullish, IV cheap → buy premium, defined risk',
+              legs: [`BUY  ${contracts}x ${ticker} ${expStr} ${buy.strike} CALL @ ~$${mid(buy).toFixed(2)}`,
+                     `SELL ${contracts}x ${ticker} ${expStr} ${sell.strike} CALL @ ~$${mid(sell).toFixed(2)}`],
+              netDebit: debit * contracts,
+              maxProfit: maxProfit * contracts,
+              maxLoss: maxLoss * contracts,
+              breakeven: be.toFixed(2),
+              roi: ((maxProfit / Math.max(1, maxLoss)) * 100).toFixed(0) + '%',
+            });
+          }
+          if (ivRich) {
+            // Bull Put Credit Spread (sell OTM put, buy further OTM put)
+            const sell = puts.find(p => p.strike < spot * 0.97 && p.strike > spot * 0.93) || puts[Math.floor(puts.length / 2)];
+            const buy = puts.find(p => p.strike < sell.strike - spot * 0.03) || puts[0];
+            const credit = (mid(sell) - mid(buy)) * 100;
+            const width = (sell.strike - buy.strike) * 100;
+            const maxLoss = width - credit;
+            const be = sell.strike - (credit / 100);
+            const contracts = Math.max(1, Math.floor(maxRisk / maxLoss));
+            strategies.push({
+              name: 'Bull Put Credit Spread',
+              rationale: 'Bullish, IV rich → sell premium, defined risk',
+              legs: [`SELL ${contracts}x ${ticker} ${expStr} ${sell.strike} PUT @ ~$${mid(sell).toFixed(2)}`,
+                     `BUY  ${contracts}x ${ticker} ${expStr} ${buy.strike} PUT @ ~$${mid(buy).toFixed(2)}`],
+              netCredit: credit * contracts,
+              maxProfit: credit * contracts,
+              maxLoss: maxLoss * contracts,
+              breakeven: be.toFixed(2),
+              roi: ((credit / Math.max(1, maxLoss)) * 100).toFixed(0) + '%',
+            });
+          }
+        }
+
+        if (direction === 'bearish' || direction === 'short') {
+          if (ivCheap || ivPercentile == null) {
+            const buy = atmPut;
+            const sell = puts.find(p => p.strike < spot * 0.95) || puts[0];
+            const debit = (mid(buy) - mid(sell)) * 100;
+            const width = (buy.strike - sell.strike) * 100;
+            const maxProfit = width - debit;
+            const be = buy.strike - (debit / 100);
+            const contracts = Math.max(1, Math.floor(maxRisk / debit));
+            strategies.push({
+              name: 'Bear Put Debit Spread',
+              rationale: 'Bearish, IV cheap → buy premium, defined risk',
+              legs: [`BUY  ${contracts}x ${ticker} ${expStr} ${buy.strike} PUT @ ~$${mid(buy).toFixed(2)}`,
+                     `SELL ${contracts}x ${ticker} ${expStr} ${sell.strike} PUT @ ~$${mid(sell).toFixed(2)}`],
+              netDebit: debit * contracts, maxProfit: maxProfit * contracts, maxLoss: debit * contracts,
+              breakeven: be.toFixed(2), roi: ((maxProfit / Math.max(1, debit)) * 100).toFixed(0) + '%',
+            });
+          }
+          if (ivRich) {
+            const sell = calls.find(c => c.strike > spot * 1.03 && c.strike < spot * 1.07) || calls[Math.floor(calls.length / 2)];
+            const buy = calls.find(c => c.strike > sell.strike + spot * 0.03) || calls[calls.length - 1];
+            const credit = (mid(sell) - mid(buy)) * 100;
+            const width = (buy.strike - sell.strike) * 100;
+            const maxLoss = width - credit;
+            const be = sell.strike + (credit / 100);
+            const contracts = Math.max(1, Math.floor(maxRisk / maxLoss));
+            strategies.push({
+              name: 'Bear Call Credit Spread',
+              rationale: 'Bearish, IV rich → sell premium, defined risk',
+              legs: [`SELL ${contracts}x ${ticker} ${expStr} ${sell.strike} CALL @ ~$${mid(sell).toFixed(2)}`,
+                     `BUY  ${contracts}x ${ticker} ${expStr} ${buy.strike} CALL @ ~$${mid(buy).toFixed(2)}`],
+              netCredit: credit * contracts, maxProfit: credit * contracts, maxLoss: maxLoss * contracts,
+              breakeven: be.toFixed(2), roi: ((credit / Math.max(1, maxLoss)) * 100).toFixed(0) + '%',
+            });
+          }
+        }
+
+        if (direction === 'neutral' || direction === 'range') {
+          if (ivRich) {
+            // Iron Condor — sell OTM call + OTM put, buy further OTM wings
+            const sellPut  = puts.find(p => p.strike < spot * 0.95 && p.strike > spot * 0.90) || puts[Math.floor(puts.length * 0.3)];
+            const buyPut   = puts.find(p => p.strike < sellPut.strike - spot * 0.05) || puts[0];
+            const sellCall = calls.find(c => c.strike > spot * 1.05 && c.strike < spot * 1.10) || calls[Math.floor(calls.length * 0.7)];
+            const buyCall  = calls.find(c => c.strike > sellCall.strike + spot * 0.05) || calls[calls.length - 1];
+            const credit = (mid(sellPut) + mid(sellCall) - mid(buyPut) - mid(buyCall)) * 100;
+            const widthPut = (sellPut.strike - buyPut.strike) * 100;
+            const widthCall = (buyCall.strike - sellCall.strike) * 100;
+            const maxLoss = Math.max(widthPut, widthCall) - credit;
+            const contracts = Math.max(1, Math.floor(maxRisk / maxLoss));
+            strategies.push({
+              name: 'Iron Condor',
+              rationale: 'Neutral, IV rich → defined-risk short premium, profits if price stays in range',
+              legs: [
+                `SELL ${contracts}x ${expStr} ${sellPut.strike} PUT @ ~$${mid(sellPut).toFixed(2)}`,
+                `BUY  ${contracts}x ${expStr} ${buyPut.strike} PUT @ ~$${mid(buyPut).toFixed(2)}`,
+                `SELL ${contracts}x ${expStr} ${sellCall.strike} CALL @ ~$${mid(sellCall).toFixed(2)}`,
+                `BUY  ${contracts}x ${expStr} ${buyCall.strike} CALL @ ~$${mid(buyCall).toFixed(2)}`,
+              ],
+              netCredit: credit * contracts, maxProfit: credit * contracts, maxLoss: maxLoss * contracts,
+              breakeven: `${(sellPut.strike - credit / 100).toFixed(2)} to ${(sellCall.strike + credit / 100).toFixed(2)}`,
+              roi: ((credit / Math.max(1, maxLoss)) * 100).toFixed(0) + '%',
+            });
+          }
+          if (ivCheap) {
+            // Long Straddle — direction-agnostic, profits from large move
+            const debit = (mid(atmCall) + mid(atmPut)) * 100;
+            const contracts = Math.max(1, Math.floor(maxRisk / debit));
+            strategies.push({
+              name: 'Long Straddle',
+              rationale: 'Neutral, IV cheap → expecting a large move either direction (often pre-earnings)',
+              legs: [
+                `BUY ${contracts}x ${expStr} ${atmCall.strike} CALL @ ~$${mid(atmCall).toFixed(2)}`,
+                `BUY ${contracts}x ${expStr} ${atmPut.strike} PUT @ ~$${mid(atmPut).toFixed(2)}`,
+              ],
+              netDebit: debit * contracts, maxProfit: 'unlimited (call) / large (put)', maxLoss: debit * contracts,
+              breakeven: `${(atmCall.strike - debit / 100).toFixed(2)} or ${(atmCall.strike + debit / 100).toFixed(2)}`,
+              roi: 'depends on move magnitude',
+            });
+          }
+        }
+
+        if (strategies.length === 0) {
+          strategies.push({ name: '(no recommendation)', rationale: `direction=${direction} + IV=${ivPercentile?.toFixed(0)}% — no matching template. Try direction=bullish/bearish/neutral.` });
+        }
+
+        const ivLabel = ivPercentile == null ? 'n/a' : `${ivPercentile.toFixed(0)}th percentile (${ivCheap ? 'CHEAP' : ivRich ? 'RICH' : 'normal'})`;
+        const lines = [
+          `Option strategy builder — ${ticker} @ $${spot}`,
+          `Direction: ${direction}  |  ATM IV: ${(atmIV * 100).toFixed(1)}%  |  IV rank: ${ivLabel}`,
+          `Expiry chosen: ${expStr} (${dtePicked} DTE)  |  Max risk budget: $${maxRisk}`,
+          '',
+        ];
+        strategies.forEach((s, i) => {
+          lines.push(`${i + 1}. ${s.name}`);
+          lines.push(`   ${s.rationale}`);
+          (s.legs || []).forEach(l => lines.push(`   ${l}`));
+          if (s.netDebit) lines.push(`   Net debit: $${(s.netDebit).toFixed(0)}`);
+          if (s.netCredit) lines.push(`   Net credit: $${(s.netCredit).toFixed(0)}`);
+          if (s.maxProfit != null) lines.push(`   Max profit: ${typeof s.maxProfit === 'number' ? '$' + s.maxProfit.toFixed(0) : s.maxProfit}`);
+          if (s.maxLoss != null) lines.push(`   Max loss: $${typeof s.maxLoss === 'number' ? s.maxLoss.toFixed(0) : s.maxLoss}`);
+          if (s.breakeven) lines.push(`   Breakeven: ${s.breakeven}`);
+          if (s.roi) lines.push(`   ROI: ${s.roi}`);
+          lines.push('');
+        });
+        return lines.join('\n');
+      } catch (e) { return `option_strategy_builder error: ${e.message}`; }
+    }
+
+    case 'crypto_onchain_metrics': {
+      const coin = String(params.coin || 'bitcoin').toLowerCase();
+      const lines = [`On-chain & derivatives — ${coin}`];
+      try {
+        // 1. CoinGecko: price + market cap + supply
+        const cgRes = await fetch(`https://api.coingecko.com/api/v3/coins/${encodeURIComponent(coin)}?localization=false&tickers=false&community_data=true&developer_data=false`, { headers: { 'Accept': 'application/json', 'User-Agent': 'NHA/1.0' } });
+        if (cgRes.ok) {
+          const cg = await cgRes.json();
+          const md = cg.market_data || {};
+          const price = md.current_price?.usd;
+          const mcap = md.market_cap?.usd;
+          const supply = md.circulating_supply;
+          const ath = md.ath?.usd;
+          const athDate = md.ath_date?.usd?.slice(0, 10);
+          const fromAth = md.ath_change_percentage?.usd?.toFixed(1);
+          lines.push(`Price: $${price?.toLocaleString()}  |  Market cap: $${(mcap / 1e9)?.toFixed(2)}B  |  Circulating: ${(supply / 1e6)?.toFixed(2)}M`);
+          lines.push(`ATH: $${ath?.toLocaleString()} on ${athDate}  (${fromAth}% from ATH)`);
+          if (cg.community_data?.twitter_followers) lines.push(`Twitter followers: ${cg.community_data.twitter_followers.toLocaleString()}`);
+          // MVRV approximation using market cap / realized cap (CoinGecko doesn't expose realized cap directly,
+          // but we approximate via mcap / (supply × avg_30d_price) — quick proxy).
+          if (md.market_cap_change_percentage_24h_in_currency?.usd != null) {
+            lines.push(`24h mcap change: ${md.market_cap_change_percentage_24h_in_currency.usd.toFixed(2)}%`);
+          }
+        }
+
+        // 2. DeFi Llama TVL (free, no key) — for L1s and DeFi protocols
+        try {
+          const llSlugMap = { bitcoin: null, ethereum: 'ethereum', solana: 'solana', avalanche: 'avalanche', polygon: 'polygon', arbitrum: 'arbitrum', optimism: 'optimism', polkadot: 'polkadot', cosmos: 'cosmos' };
+          const slug = llSlugMap[coin];
+          if (slug) {
+            const llRes = await fetch(`https://api.llama.fi/v2/historicalChainTvl/${slug}`);
+            if (llRes.ok) {
+              const tvl = await llRes.json();
+              const latest = tvl[tvl.length - 1];
+              const month = tvl[tvl.length - 30] || tvl[0];
+              const chgPct = month?.tvl ? ((latest.tvl - month.tvl) / month.tvl * 100) : 0;
+              lines.push(`\nDeFi TVL on ${slug}: $${(latest.tvl / 1e9).toFixed(2)}B (30d ${chgPct >= 0 ? '+' : ''}${chgPct.toFixed(1)}%)`);
+            }
+          } else if (coin === 'bitcoin') {
+            // BTC: pull total DeFi TVL on bitcoin sidechains
+            const llRes = await fetch('https://api.llama.fi/v2/historicalChainTvl/Bitcoin');
+            if (llRes.ok) {
+              const tvl = await llRes.json();
+              const latest = tvl[tvl.length - 1];
+              lines.push(`\nDeFi TVL on Bitcoin (sidechains/L2): $${(latest.tvl / 1e6).toFixed(0)}M`);
+            }
+          }
+        } catch {}
+
+        // 3. Binance perpetual futures: funding rate + open interest (free, no key)
+        try {
+          const sym = coin === 'bitcoin' ? 'BTCUSDT' : coin === 'ethereum' ? 'ETHUSDT' : coin === 'solana' ? 'SOLUSDT' : null;
+          if (sym) {
+            const [fr, oi] = await Promise.all([
+              fetch(`https://fapi.binance.com/fapi/v1/fundingRate?symbol=${sym}&limit=8`).then(r => r.ok ? r.json() : null).catch(() => null),
+              fetch(`https://fapi.binance.com/fapi/v1/openInterest?symbol=${sym}`).then(r => r.ok ? r.json() : null).catch(() => null),
+            ]);
+            if (Array.isArray(fr) && fr.length) {
+              const lastFr = parseFloat(fr[fr.length - 1].fundingRate) * 100;
+              const avg8 = fr.reduce((a, x) => a + parseFloat(x.fundingRate), 0) / fr.length * 100;
+              lines.push(`\nBinance perp funding (8h × 8 readings): last ${lastFr.toFixed(4)}%  |  avg ${avg8.toFixed(4)}%`);
+              lines.push(`  → ${avg8 > 0.02 ? '🟢 longs paying shorts (bullish positioning)' : avg8 < -0.02 ? '🔴 shorts paying longs (bearish positioning)' : '🟡 neutral'}`);
+            }
+            if (oi?.openInterest) lines.push(`Open Interest: ${parseFloat(oi.openInterest).toLocaleString()} ${sym.replace('USDT', '')}`);
+          }
+        } catch {}
+
+        // 4. Fear & Greed Index (alternative.me, free)
+        try {
+          const fgRes = await fetch('https://api.alternative.me/fng/?limit=1', { headers: { 'Accept': 'application/json' } });
+          if (fgRes.ok) {
+            const fg = await fgRes.json();
+            const f = fg.data?.[0];
+            if (f) lines.push(`\nFear & Greed Index: ${f.value}/100 — ${f.value_classification}`);
+          }
+        } catch {}
+
+        // 5. BTC dominance + Stablecoin supply proxy
+        try {
+          const gRes = await fetch('https://api.coingecko.com/api/v3/global', { headers: { 'Accept': 'application/json' } });
+          if (gRes.ok) {
+            const g = await gRes.json();
+            const dom = g.data?.market_cap_percentage || {};
+            lines.push(`\nMarket structure: BTC dominance ${dom.btc?.toFixed(1)}%  |  ETH ${dom.eth?.toFixed(1)}%  |  Stablecoins (USDT+USDC) ${((dom.usdt || 0) + (dom.usdc || 0)).toFixed(1)}%`);
+          }
+        } catch {}
+
+        return lines.join('\n');
+      } catch (e) { return `crypto_onchain_metrics error: ${e.message}`; }
+    }
+
+    case 'portfolio_tax_lots': {
+      // Tax-lot accounting. Reads ~/.nha/portfolio.json's `transactions` array
+      // (buy/sell events with date + qty + price), produces realized + unrealized
+      // gain breakdown using the chosen accounting method.
+      const method = String(params.method || 'FIFO').toUpperCase(); // FIFO | LIFO | HIFO
+      const fs = await import('fs'); const path = await import('path'); const os = await import('os');
+      const file = path.default.join(os.default.homedir(), '.nha', 'portfolio.json');
+      if (!fs.default.existsSync(file)) return 'Portfolio empty (no ~/.nha/portfolio.json).';
+      const pf = JSON.parse(fs.default.readFileSync(file, 'utf-8'));
+      const txs = (pf.transactions || []).slice().sort((a, b) => a.date.localeCompare(b.date));
+      if (txs.length === 0) return 'No transactions recorded. Use portfolio_tx_add to record buys/sells with date.';
+
+      // Build open lots per ticker by applying buys/sells with the chosen method.
+      const lotsByTicker = {};
+      const realizedByTicker = {};
+      const washSaleWarnings = [];
+      const today = new Date().toISOString().slice(0, 10);
+      const yearAgoMs = Date.now() - 365 * 86400000;
+
+      for (const tx of txs) {
+        const t = (tx.ticker || '').toUpperCase();
+        if (!t) continue;
+        lotsByTicker[t] = lotsByTicker[t] || [];
+        realizedByTicker[t] = realizedByTicker[t] || { shortTerm: 0, longTerm: 0, totalSold: 0 };
+        if (tx.type === 'buy' || tx.type === 'BUY') {
+          lotsByTicker[t].push({ date: tx.date, qty: tx.qty, cost: tx.price, remaining: tx.qty });
+          // Wash sale check: any sale at a LOSS within 30 days before this buy?
+          const recentLosses = (realizedByTicker[t].events || []).filter(ev => ev.loss < 0 && (new Date(tx.date) - new Date(ev.date)) <= 30 * 86400000 && (new Date(tx.date) - new Date(ev.date)) >= 0);
+          if (recentLosses.length) washSaleWarnings.push(`${t}: buy on ${tx.date} may trigger wash-sale rule (loss sale on ${recentLosses[0].date}, $${(-recentLosses[0].loss).toFixed(2)} disallowed).`);
+        } else if (tx.type === 'sell' || tx.type === 'SELL') {
+          let qtyToClose = tx.qty;
+          const sortLots = (lots) => {
+            if (method === 'LIFO') return [...lots].sort((a, b) => b.date.localeCompare(a.date));
+            if (method === 'HIFO') return [...lots].sort((a, b) => b.cost - a.cost);
+            return [...lots].sort((a, b) => a.date.localeCompare(b.date)); // FIFO
+          };
+          const order = sortLots(lotsByTicker[t]);
+          for (const lot of order) {
+            if (qtyToClose <= 0) break;
+            if (lot.remaining <= 0) continue;
+            const take = Math.min(lot.remaining, qtyToClose);
+            const proceeds = take * tx.price;
+            const costBasis = take * lot.cost;
+            const gain = proceeds - costBasis;
+            const holdMs = new Date(tx.date) - new Date(lot.date);
+            const isLongTerm = holdMs > 365 * 86400000;
+            if (isLongTerm) realizedByTicker[t].longTerm += gain;
+            else realizedByTicker[t].shortTerm += gain;
+            realizedByTicker[t].totalSold += take;
+            realizedByTicker[t].events = realizedByTicker[t].events || [];
+            realizedByTicker[t].events.push({ date: tx.date, qty: take, gain, loss: gain < 0 ? gain : 0, lotDate: lot.date, isLongTerm });
+            lot.remaining -= take;
+            qtyToClose -= take;
+          }
+        }
+      }
+
+      // Fetch live prices for unrealized gain.
+      const tickersOpen = Object.keys(lotsByTicker).filter(t => lotsByTicker[t].some(l => l.remaining > 0));
+      let priceMap = {};
+      if (tickersOpen.length) {
+        try {
+          const r = await fetch(`https://query1.finance.yahoo.com/v7/finance/quote?symbols=${tickersOpen.join(',')}`, { headers: { 'User-Agent': 'Mozilla/5.0 (compatible; NHA/1.0)' } });
+          if (r.ok) {
+            const d = await r.json();
+            priceMap = Object.fromEntries((d?.quoteResponse?.result || []).map(q => [q.symbol, q.regularMarketPrice]));
+          }
+        } catch {}
+      }
+
+      const lines = [`Tax lot report — method: ${method}`, ''];
+      let totalRealizedShort = 0, totalRealizedLong = 0, totalUnrealized = 0;
+      let lossHarvestCandidates = [];
+      for (const t of Object.keys(lotsByTicker)) {
+        const open = lotsByTicker[t].filter(l => l.remaining > 0);
+        const realized = realizedByTicker[t] || { shortTerm: 0, longTerm: 0 };
+        const price = priceMap[t];
+        let unrealized = 0;
+        open.forEach(l => { if (price) unrealized += (price - l.cost) * l.remaining; });
+        totalRealizedShort += realized.shortTerm;
+        totalRealizedLong += realized.longTerm;
+        totalUnrealized += unrealized;
+        // Tax-loss harvesting: lot with unrealized loss + holding > some threshold
+        open.forEach(l => {
+          if (price && (price - l.cost) * l.remaining < -100) {
+            const holdDays = (Date.now() - new Date(l.date).getTime()) / 86400000;
+            lossHarvestCandidates.push({ ticker: t, lotDate: l.date, qty: l.remaining, cost: l.cost, currentPrice: price, loss: (price - l.cost) * l.remaining, holdDays });
+          }
+        });
+        lines.push(`${t}:`);
+        lines.push(`  Realized: short-term $${realized.shortTerm.toFixed(2)} | long-term $${realized.longTerm.toFixed(2)} | total $${(realized.shortTerm + realized.longTerm).toFixed(2)}`);
+        if (open.length) {
+          lines.push(`  Open lots (${open.length}, live $${price?.toFixed(2) || '?'}):`);
+          open.forEach(l => {
+            const u = price ? (price - l.cost) * l.remaining : 0;
+            const ageDays = ((Date.now() - new Date(l.date).getTime()) / 86400000).toFixed(0);
+            lines.push(`    ${l.date}  qty ${l.remaining}  cost $${l.cost.toFixed(2)}  unrealized $${u.toFixed(2)}  (${ageDays}d, ${ageDays > 365 ? 'long-term' : 'SHORT-TERM'})`);
+          });
+        }
+        lines.push('');
+      }
+      lines.push(`TOTALS:`);
+      lines.push(`  Realized short-term gains: $${totalRealizedShort.toFixed(2)}  (taxed at ordinary income rate)`);
+      lines.push(`  Realized long-term gains:  $${totalRealizedLong.toFixed(2)}  (taxed at 0/15/20% in US)`);
+      lines.push(`  Unrealized gains: $${totalUnrealized.toFixed(2)}`);
+      if (washSaleWarnings.length) {
+        lines.push(`\n⚠ Wash-sale warnings:\n  ${washSaleWarnings.join('\n  ')}`);
+      }
+      if (lossHarvestCandidates.length) {
+        lines.push(`\n💡 Tax-loss harvest candidates (unrealized loss > $100):`);
+        lossHarvestCandidates.sort((a, b) => a.loss - b.loss).slice(0, 5).forEach(c => {
+          lines.push(`  ${c.ticker} lot ${c.lotDate} qty ${c.qty}: realize $${c.loss.toFixed(2)} loss${c.holdDays < 31 ? ' ⚠ <31 days, wash-sale risk' : ''}`);
+        });
+      }
+      return lines.join('\n');
+    }
+
+    case 'portfolio_tx_add': {
+      // Record a buy/sell transaction. Used to feed portfolio_tax_lots.
+      const ticker = String(params.ticker || '').toUpperCase();
+      const type = String(params.type || 'buy').toLowerCase();
+      const qty = parseFloat(params.qty || params.quantity || '0');
+      const price = parseFloat(params.price || '0');
+      const date = String(params.date || new Date().toISOString().slice(0, 10));
+      if (!ticker || qty <= 0 || !['buy', 'sell'].includes(type)) return 'portfolio_tx_add: ticker, type (buy|sell), qty (>0), price required.';
+      const fs = await import('fs'); const path = await import('path'); const os = await import('os');
+      const file = path.default.join(os.default.homedir(), '.nha', 'portfolio.json');
+      let pf = { positions: [], transactions: [] };
+      try { if (fs.default.existsSync(file)) pf = JSON.parse(fs.default.readFileSync(file, 'utf-8')); } catch {}
+      pf.transactions = pf.transactions || [];
+      pf.transactions.push({ ticker, type, qty, price, date, recordedAt: new Date().toISOString() });
+      // Also update current `positions` for parity with portfolio_summary.
+      pf.positions = pf.positions || [];
+      const idx = pf.positions.findIndex(p => p.ticker === ticker);
+      if (type === 'buy') {
+        if (idx >= 0) {
+          const existing = pf.positions[idx];
+          const totalQty = existing.qty + qty;
+          existing.cost = ((existing.qty * existing.cost) + (qty * price)) / totalQty;
+          existing.qty = totalQty;
+        } else {
+          pf.positions.push({ ticker, qty, cost: price, addedAt: new Date().toISOString() });
+        }
+      } else {
+        if (idx >= 0) {
+          pf.positions[idx].qty -= qty;
+          if (pf.positions[idx].qty <= 0) pf.positions.splice(idx, 1);
+        }
+      }
+      fs.default.mkdirSync(path.default.dirname(file), { recursive: true });
+      fs.default.writeFileSync(file, JSON.stringify(pf, null, 2));
+      return `Transaction recorded: ${type.toUpperCase()} ${qty} ${ticker} @ $${price} on ${date}. Total transactions: ${pf.transactions.length}.`;
+    }
+
     case 'insider_trading': {
       const ticker = String(params.ticker || '').toUpperCase();
       const limit = Math.min(parseInt(params.limit || '15', 10), 30);