opencandle 0.4.0 → 0.5.0

package/src/tools/portfolio/holdings-overlap.ts

@@ -0,0 +1,123 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { getFundHoldings } from "../../providers/yahoo-finance.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import type {
+  FundHolding,
+  FundHoldings,
+  FundHoldingsOverlap,
+  FundOverlapPair,
+  SharedFundHolding,
+} from "../../types/portfolio.js";
+
+const params = Type.Object({
+  symbols: Type.Array(Type.String(), {
+    description: "Array of 2+ ETF or fund ticker symbols to compare holdings overlap, e.g. ['VOO','QQQ']",
+    minItems: 2,
+  }),
+});
+
+export const holdingsOverlapTool: AgentTool<typeof params, FundHoldingsOverlap | null> = {
+  name: "analyze_holdings_overlap",
+  label: "ETF Holdings Overlap",
+  description:
+    "Fetch top fund/ETF holdings and compute pairwise overlap by weight. Useful for ETF diversification and hidden concentration checks.",
+  parameters: params,
+  async execute(_toolCallId, args) {
+    const symbols = [...new Set(args.symbols.map((symbol) => symbol.toUpperCase()))];
+    if (symbols.length < 2) {
+      throw new Error("Need at least 2 symbols for holdings overlap analysis.");
+    }
+
+    const results = await Promise.all(symbols.map(async (symbol) => ({
+      symbol,
+      result: await wrapProvider("yahoo", () => getFundHoldings(symbol)),
+    })));
+    const unavailable = results.flatMap((entry) =>
+      entry.result.status === "unavailable"
+        ? [{ symbol: entry.symbol, reason: entry.result.reason }]
+        : []
+    );
+    if (unavailable.length > 0) {
+      const missing = unavailable.map((entry) => `${entry.symbol}: ${entry.reason}`).join("; ");
+      return {
+        content: [{ type: "text", text: `⚠ Holdings overlap unavailable for one or more funds (${missing}).` }],
+        details: null,
+      };
+    }
+
+    const funds = results.flatMap((entry) => entry.result.status === "ok" ? [entry.result.data] : []);
+    const overlap = computeHoldingsOverlap(funds);
+    return {
+      content: [{ type: "text", text: formatOverlap(overlap) }],
+      details: overlap,
+    };
+  },
+};
+
+export function computeHoldingsOverlap(funds: FundHoldings[]): FundHoldingsOverlap {
+  const pairs: FundOverlapPair[] = [];
+  for (let i = 0; i < funds.length; i += 1) {
+    for (let j = i + 1; j < funds.length; j += 1) {
+      pairs.push(computePairOverlap(funds[i], funds[j]));
+    }
+  }
+  return { funds, pairs };
+}
+
+function computePairOverlap(a: FundHoldings, b: FundHoldings): FundOverlapPair {
+  const aBySymbol = new Map(a.holdings.map((holding) => [holding.symbol, holding]));
+  const sharedHoldings: SharedFundHolding[] = [];
+  for (const bHolding of b.holdings) {
+    const aHolding = aBySymbol.get(bHolding.symbol);
+    if (!aHolding) continue;
+    const overlapWeight = roundWeight(Math.min(aHolding.weight, bHolding.weight));
+    sharedHoldings.push({
+      symbol: bHolding.symbol,
+      name: commonHoldingName(aHolding, bHolding),
+      weights: {
+        [a.symbol]: aHolding.weight,
+        [b.symbol]: bHolding.weight,
+      },
+      overlapWeight,
+    });
+  }
+  sharedHoldings.sort((left, right) => right.overlapWeight - left.overlapWeight);
+  return {
+    symbols: [a.symbol, b.symbol],
+    overlapWeight: roundWeight(sharedHoldings.reduce((sum, holding) => sum + holding.overlapWeight, 0)),
+    sharedHoldings,
+  };
+}
+
+function formatOverlap(overlap: FundHoldingsOverlap): string {
+  const lines: string[] = ["**ETF/Fund Holdings Overlap**", ""];
+  for (const pair of overlap.pairs) {
+    lines.push(`${pair.symbols.join("/")} holdings overlap: ${formatPercent(pair.overlapWeight)}`);
+    const topShared = pair.sharedHoldings.slice(0, 5);
+    if (topShared.length > 0) {
+      lines.push(`Top shared holdings: ${topShared.map((holding) =>
+        `${holding.symbol} (${formatPercent(holding.overlapWeight)} overlap)`
+      ).join(", ")}`);
+    } else {
+      lines.push("No shared top holdings found in provider coverage.");
+    }
+    lines.push("");
+  }
+  lines.push("Provider note: overlap uses provider top-holdings coverage, not full portfolio look-through unless the provider returns all holdings.");
+  return lines.join("\n").trimEnd();
+}
+
+function commonHoldingName(a: FundHolding, b: FundHolding): string {
+  if (a.name && a.name !== a.symbol) return a.name;
+  if (b.name && b.name !== b.symbol) return b.name;
+  return a.symbol;
+}
+
+function formatPercent(value: number): string {
+  return `${(value * 100).toFixed(1)}%`;
+}
+
+function roundWeight(value: number): number {
+  return Math.round(value * 10_000) / 10_000;
+}

package/src/tools/portfolio/predictions.ts

@@ -184,7 +184,7 @@ export const predictionsTool: AgentTool<typeof params> = {
   description:
     "Track your analysis predictions and measure accuracy over time. Record: save a directional prediction with conviction. Check: evaluate all predictions against current prices, compute hit rate and conviction-weighted accuracy. Inspired by ATLAS's Darwinian scoring approach.",
   parameters: params,
-  async execute(toolCallId, args) {
+  async execute(_toolCallId, args) {
     if (args.action === "record") {
       if (!args.symbol || !args.direction || !args.conviction || !args.entry_price) {
         throw new Error("symbol, direction, conviction, and entry_price are required for record action.");

package/src/tools/portfolio/risk-analysis.ts

@@ -17,7 +17,7 @@ export const riskAnalysisTool: AgentTool<typeof params, RiskMetrics> = {
   description:
     "Compute risk metrics for a stock: annualized return, volatility, Sharpe ratio, max drawdown, and Value at Risk (95%). All computed locally from historical data.",
   parameters: params,
-  async execute(toolCallId, args) {
+  async execute(_toolCallId, args) {
     const symbol = args.symbol.toUpperCase();
     const period = args.period ?? "1y";
     const result = await wrapProvider("yahoo", () => getHistory(symbol, period, "1d"));

package/src/tools/portfolio/tracker.ts

@@ -51,7 +51,7 @@ export const portfolioTrackerTool: AgentTool<typeof params, PortfolioSummary | n
   description:
     "Track your portfolio of stocks and crypto. Add/remove positions with cost basis, or view current holdings with live P&L. For stocks use standard tickers (AAPL, MSFT). For crypto use the -USD suffix (BTC-USD, ETH-USD, SOL-USD). Use search_ticker first if you're unsure of the exact ticker. Data persisted to ~/.opencandle/portfolio.json.",
   parameters: params,
-  async execute(toolCallId, args) {
+  async execute(_toolCallId, args) {
     const positions = loadPortfolio();
 
     if (args.action === "add") {

package/src/tools/portfolio/watchlist.ts

@@ -54,7 +54,7 @@ export const watchlistTool: AgentTool<typeof params> = {
   description:
     "Manage your watchlist of stocks and crypto. Add symbols with optional target and stop prices, remove symbols, or check current prices against your alert levels. Data persisted to ~/.opencandle/watchlist.json.",
   parameters: params,
-  async execute(toolCallId, args) {
+  async execute(_toolCallId, args) {
     const items = loadWatchlist();
 
     if (args.action === "add") {
@@ -118,17 +118,22 @@ export const watchlistTool: AgentTool<typeof params> = {
       items.map(async (item) => {
         const result = await wrapProvider("yahoo", () => getQuote(item.symbol));
         if (result.status === "unavailable") {
-          return { ...item, currentPrice: 0, alerts: [`UNAVAILABLE: ${result.reason}`] };
+          return { ...item, currentPrice: 0, alerts: [`UNAVAILABLE: ${result.reason}`], statuses: [] };
         }
         const quote = result.data;
         const alerts: string[] = [];
+        const statuses: string[] = [];
         if (item.targetPrice && quote.price >= item.targetPrice) {
           alerts.push(`TARGET HIT: $${quote.price.toFixed(2)} >= $${item.targetPrice}`);
+        } else if (item.targetPrice) {
+          statuses.push(`Target pending: $${quote.price.toFixed(2)} < $${item.targetPrice}`);
         }
         if (item.stopPrice && quote.price <= item.stopPrice) {
           alerts.push(`STOP ALERT: $${quote.price.toFixed(2)} fell below $${item.stopPrice}`);
+        } else if (item.stopPrice) {
+          statuses.push(`Stop OK: $${quote.price.toFixed(2)} > $${item.stopPrice}`);
         }
-        return { ...item, currentPrice: quote.price, alerts };
+        return { ...item, currentPrice: quote.price, alerts, statuses };
       }),
     );
 
@@ -140,9 +145,10 @@ export const watchlistTool: AgentTool<typeof params> = {
 
     for (const c of checks) {
       const alertStr = c.alerts.length > 0 ? ` ** ${c.alerts.join(" | ")} **` : "";
+      const statusStr = c.statuses.length > 0 ? ` | ${c.statuses.join(" | ")}` : "";
       const targetStr = c.targetPrice ? ` | Target: $${c.targetPrice}` : "";
       const stopStr = c.stopPrice ? ` | Stop: $${c.stopPrice}` : "";
-      lines.push(`  ${c.symbol}: $${c.currentPrice.toFixed(2)}${targetStr}${stopStr}${alertStr}`);
+      lines.push(`  ${c.symbol}: $${c.currentPrice.toFixed(2)}${targetStr}${stopStr}${statusStr}${alertStr}`);
     }
 
     return {

package/src/tools/sentiment/reddit-sentiment.ts

@@ -36,7 +36,7 @@ export const redditSentimentTool: AgentTool<typeof params, RedditSentimentResult
   description:
     "Analyze sentiment from financial Reddit communities. Supports single subreddit, multi-subreddit, and topic filtering. Returns scored posts with comment analysis and trend context.",
   parameters: params,
-  async execute(toolCallId, args) {
+  async execute(_toolCallId, args) {
     const limit = Math.min(args.limit ?? 25, 100);
     const config = getConfig();
 

package/src/tools/sentiment/sentiment-summary.ts

@@ -4,6 +4,7 @@ import { getSubredditPosts, getPostComments } from "../../providers/reddit.js";
 import { getTwitterSentiment } from "../../providers/twitter.js";
 import { searchWeb } from "../../providers/web-search.js";
 import { getCompanyNews, finnhubDateRange } from "../../providers/finnhub.js";
+import { getQuote } from "../../providers/yahoo-finance.js";
 import { wrapProvider } from "../../providers/wrap-provider.js";
 import { getConfig } from "../../config.js";
 import { TwitterAdapter } from "../../sentiment/adapters/twitter.js";
@@ -28,14 +29,13 @@ export const sentimentSummaryTool: AgentTool<typeof params> = {
   description:
     "Cross-source sentiment summary combining Twitter, Reddit, and web/news. Returns per-source scores, aggregate sentiment, and divergence detection.",
   parameters: params,
-  async execute(toolCallId, args) {
+  async execute(_toolCallId, args) {
     const hours = args.hours ?? 24;
     const config = getConfig();
     const warnings: string[] = [];
     const allRecords: SentinelRecord[] = [];
 
     const twitterAdapter = new TwitterAdapter();
-    const redditAdapter = new RedditAdapter();
     const webAdapter = new WebAdapter();
     const finnhubAdapter = new FinnhubAdapter();
 
@@ -171,6 +171,15 @@ export const sentimentSummaryTool: AgentTool<typeof params> = {
     lines.push("");
     lines.push(`**Aggregate:** ${aggregate >= 0 ? "+" : ""}${aggregate.toFixed(2)} (${sentimentLabel(aggregate)})`);
 
+    const priceContext = await buildPriceContext(candidateTickers[0], aggregate);
+    if (priceContext) {
+      lines.push("");
+      lines.push(priceContext);
+    }
+
+    lines.push("");
+    lines.push("Source-coverage risk: sentiment can be noisy and missing sources can skew the signal; treat this as supporting evidence, not a standalone buy/sell input.");
+
     // Divergence
     if (result.divergence && result.divergence.detected) {
       lines.push("");
@@ -197,6 +206,57 @@ export const sentimentSummaryTool: AgentTool<typeof params> = {
   },
 };
 
+async function buildPriceContext(symbol: string | undefined, aggregateSentiment: number): Promise<string | null> {
+  if (!symbol) return null;
+  try {
+    const quote = await getQuote(symbol);
+    const sign = quote.changePercent >= 0 ? "+" : "";
+    const direction = quote.changePercent > 0 ? "positive" : quote.changePercent < 0 ? "negative" : "flat";
+    const sentimentDirection = aggregateSentiment > 0 ? "positive" : aggregateSentiment < 0 ? "negative" : "neutral";
+    const relationship = sentimentDirection === "neutral" || direction === "flat" || sentimentDirection === direction
+      ? "roughly aligns with price action"
+      : "diverges from price action";
+    const freshnessNote = formatQuoteFreshnessNote(quote.timestamp);
+    return `Price context: ${quote.symbol}: $${quote.price.toFixed(2)} (${sign}${quote.changePercent.toFixed(2)}%).${freshnessNote} The ${sentimentDirection} sentiment signal ${relationship}.`;
+  } catch {
+    return null;
+  }
+}
+
+function formatQuoteFreshnessNote(timestamp: number | undefined): string {
+  if (!timestamp) return "";
+  const quoteDate = new Date(timestamp);
+  if (Number.isNaN(quoteDate.getTime())) return "";
+
+  const now = new Date();
+  const quoteDay = quoteDate.toLocaleDateString("en-US", { timeZone: "America/New_York" });
+  const currentDay = now.toLocaleDateString("en-US", { timeZone: "America/New_York" });
+  const quoteStamp = quoteDate.toLocaleString("en-US", {
+    dateStyle: "medium",
+    timeStyle: "short",
+    timeZone: "America/New_York",
+  });
+
+  const weekday = new Intl.DateTimeFormat("en-US", {
+    weekday: "long",
+    timeZone: "America/New_York",
+  }).format(now);
+  const isWeekend = weekday === "Saturday" || weekday === "Sunday";
+
+  if (quoteDay === currentDay) {
+    const marketClosedNote = isWeekend
+      ? " U.S. markets are closed today, so treat this as delayed or last available price context, not active intraday trading."
+      : "";
+    return ` Quote timestamp: ${quoteStamp} ET.${marketClosedNote}`;
+  }
+
+  const marketClosedNote = isWeekend
+    ? " U.S. markets are closed today, so treat this as last trading-session price action."
+    : "";
+
+  return ` Last available quote timestamp: ${quoteStamp} ET.${marketClosedNote}`;
+}
+
 async function fetchRedditCrossSubreddit(
   query: string,
   subreddits: string[],

package/src/tools/sentiment/twitter-sentiment.ts

@@ -24,7 +24,7 @@ export const twitterSentimentTool: AgentTool<typeof params, TwitterSentimentResu
   description:
     "Fetch recent tweets for a stock ticker or search query and compute engagement-weighted sentiment. Returns tweet data, sentiment score, and co-mentioned tickers. Requires a Twitter session via trigger_twitter_login.",
   parameters: params,
-  async execute(toolCallId, args) {
+  async execute(_toolCallId, args) {
     const limit = Math.min(args.limit ?? 50, 200);
     const hours = args.hours ?? 24;
 

package/src/tools/sentiment/web-search.ts

@@ -79,6 +79,33 @@ function buildSoftDegradedPrefix(data: WebSearchEnvelope): string {
   return tags.length === 0 ? "" : `${tags.join("\n")}\n\n`;
 }
 
+function buildOfficialSourceGapPrefix(query: string, data: WebSearchEnvelope): string {
+  if (!hasOfficialFedSourceGap(query, data)) return "";
+
+  return [
+    "[OPENCANDLE_SOURCE_GAP source=fed_official evidence=missing remediation=\"verify against federalreserve.gov/FOMC before stating Fed announcements\"]",
+    "Hard source gap: no official Fed/FOMC source was returned. Do not present meeting announcements, votes, quotes, appointments, leadership changes, or named policy rationales as verified; treat results as market commentary only.",
+    "",
+  ].join("\n");
+}
+
+function hasOfficialFedSourceGap(query: string, data: WebSearchEnvelope): boolean {
+  return isFedAnnouncementQuery(query) &&
+    !data.results.some((result) => isOfficialFedSource(result.source) || isOfficialFedSource(result.url));
+}
+
+function isFedAnnouncementQuery(query: string): boolean {
+  const lower = query.toLowerCase();
+  const mentionsFed = /\b(?:fed|fomc|federal reserve)\b/.test(lower);
+  const asksOfficialFact = /\b(?:announcement|meeting|minutes|statement|decision|vote|chair|governor|appointment|leadership)\b/.test(lower);
+  return mentionsFed && asksOfficialFact;
+}
+
+function isOfficialFedSource(value: string): boolean {
+  const lower = value.toLowerCase();
+  return lower.includes("federalreserve.gov") || lower.includes("fomc.gov");
+}
+
 export const webSearchTool: AgentTool<typeof params, WebSearchEnvelope> = {
   name: "search_web",
   label: "Web Search",
@@ -87,7 +114,7 @@ export const webSearchTool: AgentTool<typeof params, WebSearchEnvelope> = {
     "NOT for real-time prices, historical data, fundamentals, macro data, SEC filings, or social sentiment — those have dedicated tools.",
   parameters: params,
 
-  async execute(toolCallId, args) {
+  async execute(_toolCallId, args) {
     const query = args.query?.trim();
     if (!query) {
       return {
@@ -114,11 +141,12 @@ export const webSearchTool: AgentTool<typeof params, WebSearchEnvelope> = {
 
     if (data.resultCount === 0) {
       const zeroPrefix = buildSoftDegradedPrefix(data);
+      const sourceGapPrefix = buildOfficialSourceGapPrefix(query, data);
       return {
         content: [
           {
             type: "text",
-            text: `${zeroPrefix}No results found for "${query}" (${category}, past ${freshness}).`,
+            text: `${zeroPrefix}${sourceGapPrefix}No results found for "${query}" (${category}, past ${freshness}).`,
           },
         ],
         details: data,
@@ -130,6 +158,8 @@ export const webSearchTool: AgentTool<typeof params, WebSearchEnvelope> = {
       : "";
 
     const softDegradedPrefix = buildSoftDegradedPrefix(data);
+    const sourceGapPrefix = buildOfficialSourceGapPrefix(query, data);
+    const shouldOmitResults = hasOfficialFedSourceGap(query, data);
 
     const header = `**Web Search** — ${data.resultCount} results for "${query}" (${category}, past ${freshness}, via ${data.provider})`;
     const items = data.results.map((r) => {
@@ -139,8 +169,11 @@ export const webSearchTool: AgentTool<typeof params, WebSearchEnvelope> = {
       const pub = r.published ? `Published: ${r.published}` : "Published: unknown";
       return `• [${title}](${url}) — ${r.source}\n  ${snippet}\n  ${pub}`;
     });
+    const body = shouldOmitResults
+      ? "Non-official results were omitted from assistant-visible evidence for this Fed/FOMC announcement query. Verify against an official Federal Reserve or FOMC source before naming announcements or personnel changes."
+      : items.join("\n\n");
 
-    const text = `${softDegradedPrefix}${stalePrefix}${header}\n\n${items.join("\n\n")}`;
+    const text = `${softDegradedPrefix}${sourceGapPrefix}${stalePrefix}${header}\n\n${body}`;
 
     return {
       content: [{ type: "text", text }],

package/src/tools/sentiment/web-sentiment.ts

@@ -22,7 +22,7 @@ export const webSentimentTool: AgentTool<typeof params> = {
   description:
     "Analyze sentiment from web and news search results for a ticker or topic. Returns scored results with aggregate sentiment.",
   parameters: params,
-  async execute(toolCallId, args) {
+  async execute(_toolCallId, args) {
     const freshness = args.freshness ?? "day";
     const limit = Math.min(args.limit ?? 10, 20);
 

package/src/tools/technical/backtest.ts

@@ -5,7 +5,7 @@ import { wrapProvider } from "../../providers/wrap-provider.js";
 import { computeSMA, computeRSI } from "./indicators.js";
 import type { OHLCV } from "../../types/market.js";
 
-export type Strategy = "sma_crossover" | "rsi_mean_reversion";
+export type Strategy = "sma_crossover" | "sma_50_200_crossover" | "rsi_mean_reversion";
 
 export interface BacktestResult {
   strategy: string;
@@ -20,28 +20,32 @@ export interface BacktestResult {
 
 export function runBacktest(bars: OHLCV[], strategy: Strategy): BacktestResult {
   const closes = bars.map((b) => b.close);
-  const buyAndHoldReturn = closes.length > 1
-    ? (closes[closes.length - 1] - closes[0]) / closes[0]
-    : 0;
 
   if (strategy === "sma_crossover") {
-    return backtestSMACrossover(bars, closes);
+    return backtestSMACrossover(bars, closes, 20, 50, strategy);
+  }
+  if (strategy === "sma_50_200_crossover") {
+    return backtestSMACrossover(bars, closes, 50, 200, strategy);
   }
   return backtestRSIMeanReversion(bars, closes);
 }
 
-function backtestSMACrossover(bars: OHLCV[], closes: number[]): BacktestResult {
-  const sma20 = computeSMA(closes, 20);
-  const sma50 = computeSMA(closes, 50);
+function backtestSMACrossover(
+  bars: OHLCV[],
+  closes: number[],
+  shortWindow: number,
+  longWindow: number,
+  strategyName: Strategy,
+): BacktestResult {
+  const shortSma = computeSMA(closes, shortWindow);
+  const longSma = computeSMA(closes, longWindow);
 
-  if (sma50.length === 0) {
-    return emptyResult("sma_crossover", closes);
+  if (longSma.length === 0) {
+    return emptyResult(strategyName, closes);
   }
 
-  // Align: SMA(20) starts at index 19, SMA(50) at index 49
-  // sma20[i] corresponds to closes[i + 19], sma50[i] to closes[i + 49]
-  const offset20 = 19;
-  const offset50 = 49;
+  const shortOffset = shortWindow - 1;
+  const longOffset = longWindow - 1;
 
   let position = false;
   let entryPrice = 0;
@@ -50,19 +54,19 @@ function backtestSMACrossover(bars: OHLCV[], closes: number[]): BacktestResult {
   let peak = 1.0;
   let maxDd = 0;
 
-  for (let i = 0; i < sma50.length; i++) {
-    const barIdx = i + offset50;
-    const sma20Idx = i + (offset50 - offset20);
-    const s20 = sma20[sma20Idx];
-    const s50 = sma50[i];
+  for (let i = 0; i < longSma.length; i++) {
+    const barIdx = i + longOffset;
+    const shortSmaIdx = i + (longOffset - shortOffset);
+    const sShort = shortSma[shortSmaIdx];
+    const sLong = longSma[i];
     const price = closes[barIdx];
 
-    if (!position && s20 > s50) {
+    if (!position && sShort > sLong) {
       // Buy signal
       position = true;
       entryPrice = price;
       tradeLog.push({ type: "buy", date: bars[barIdx].date, price });
-    } else if (position && s20 < s50) {
+    } else if (position && sShort < sLong) {
       // Sell signal
       const pnl = (price - entryPrice) / entryPrice;
       equity *= 1 + pnl;
@@ -87,7 +91,7 @@ function backtestSMACrossover(bars: OHLCV[], closes: number[]): BacktestResult {
     tradeLog.push({ type: "sell", date: bars[bars.length - 1].date, price: lastPrice, pnl });
   }
 
-  return buildResult("sma_crossover", equity - 1, closes, tradeLog, maxDd);
+  return buildResult(strategyName, equity - 1, closes, tradeLog, maxDd);
 }
 
 function backtestRSIMeanReversion(bars: OHLCV[], closes: number[]): BacktestResult {
@@ -187,8 +191,8 @@ function emptyResult(strategy: string, closes: number[]): BacktestResult {
 const params = Type.Object({
   symbol: Type.String({ description: "Stock ticker symbol (e.g. AAPL, MSFT, SPY)" }),
   strategy: Type.Union(
-    [Type.Literal("sma_crossover"), Type.Literal("rsi_mean_reversion")],
-    { description: "Strategy: sma_crossover (buy when SMA20 > SMA50, sell on reverse) or rsi_mean_reversion (buy when RSI < 30, sell when RSI > 70)" },
+    [Type.Literal("sma_crossover"), Type.Literal("sma_50_200_crossover"), Type.Literal("rsi_mean_reversion")],
+    { description: "Strategy: sma_crossover (buy when SMA20 > SMA50, sell on reverse), sma_50_200_crossover (buy when SMA50 > SMA200, sell on reverse), or rsi_mean_reversion (buy when RSI < 30, sell when RSI > 70)" },
   ),
   period: Type.Optional(
     Type.String({ description: "Historical period to backtest: 1y, 2y, 5y. Default: 2y" }),
@@ -199,9 +203,9 @@ export const backtestTool: AgentTool<typeof params> = {
   name: "backtest_strategy",
   label: "Backtest Strategy",
   description:
-    "Backtest a simple trading strategy against historical data. Supported strategies: SMA crossover (SMA20/SMA50) and RSI mean-reversion (buy <30, sell >70). Returns total return, win rate, max drawdown, and comparison to buy-and-hold.",
+    "Backtest a simple trading strategy against historical data. Supported strategies: SMA crossover (SMA20/SMA50), standard long-term SMA crossover (SMA50/SMA200), and RSI mean-reversion (buy <30, sell >70). Returns total return, win rate, max drawdown, and comparison to buy-and-hold.",
   parameters: params,
-  async execute(toolCallId, args) {
+  async execute(_toolCallId, args) {
     const symbol = args.symbol.toUpperCase();
     const period = args.period ?? "2y";
     const historyResult = await wrapProvider("yahoo", () => getHistory(symbol, period, "1d"));
@@ -213,9 +217,10 @@ export const backtestTool: AgentTool<typeof params> = {
     }
     const bars = historyResult.data;
 
-    if (bars.length < 60) {
+    const minBars = requiredBarsForStrategy(args.strategy);
+    if (bars.length < minBars) {
       return {
-        content: [{ type: "text", text: `Insufficient data for backtesting ${symbol} (need 60+ days, got ${bars.length})` }],
+        content: [{ type: "text", text: `Insufficient data for backtesting ${symbol} (need ${minBars}+ days, got ${bars.length})` }],
         details: null,
       };
     }
@@ -224,7 +229,7 @@ export const backtestTool: AgentTool<typeof params> = {
 
     const outperformance = result.totalReturn - result.buyAndHoldReturn;
     const lines = [
-      `**${symbol} Backtest: ${args.strategy}** (${bars[0].date} to ${bars[bars.length - 1].date}, ${bars.length} days)`,
+      `**${symbol} Backtest: ${strategyLabel(args.strategy)}** (${bars[0].date} to ${bars[bars.length - 1].date}, ${bars.length} days)`,
       ``,
       `Strategy Return: ${(result.totalReturn * 100).toFixed(2)}%`,
       `Buy & Hold Return: ${(result.buyAndHoldReturn * 100).toFixed(2)}%`,
@@ -244,3 +249,19 @@ export const backtestTool: AgentTool<typeof params> = {
     };
   },
 };
+
+function requiredBarsForStrategy(strategy: Strategy): number {
+  if (strategy === "sma_50_200_crossover") return 200;
+  return 60;
+}
+
+function strategyLabel(strategy: Strategy): string {
+  switch (strategy) {
+    case "sma_crossover":
+      return "SMA 20/50 Crossover";
+    case "sma_50_200_crossover":
+      return "SMA 50/200 Crossover";
+    case "rsi_mean_reversion":
+      return "RSI Mean Reversion";
+  }
+}

package/src/tools/technical/indicators.ts

@@ -46,7 +46,7 @@ export const technicalIndicatorsTool: AgentTool<typeof params> = {
   description:
     "Compute technical indicators (SMA, EMA, RSI, MACD, Bollinger Bands) from historical price data. All computed locally — no API dependency.",
   parameters: params,
-  async execute(toolCallId, args) {
+  async execute(_toolCallId, args) {
     const symbol = args.symbol.toUpperCase();
     const range = args.range ?? "1y";
     const result = await wrapProvider("yahoo", () => getHistory(symbol, range, "1d"));
@@ -68,8 +68,6 @@ export const technicalIndicatorsTool: AgentTool<typeof params> = {
 
     const sma20 = computeSMA(closes, 20);
     const sma50 = computeSMA(closes, 50);
-    const ema12 = computeEMA(closes, 12);
-    const ema26 = computeEMA(closes, 26);
     const rsi = computeRSI(closes, 14);
     const macd = computeMACD(closes);
     const bb = computeBollingerBands(closes, 20, 2);

package/src/types/options.ts

@@ -21,6 +21,22 @@ export interface OptionContract {
   greeks: Greeks;
 }
 
+export type OptionsMarketSession = "pre_market" | "regular" | "after_hours" | "closed";
+
+export type OptionsBidAskState =
+  | "live_quotes"
+  | "closed_market_or_stale_quotes"
+  | "live_zero_bid_ask"
+  | "mixed_or_unknown";
+
+export interface OptionsQuoteStatus {
+  marketSession: OptionsMarketSession;
+  bidAskState: OptionsBidAskState;
+  zeroBidAskContracts: number;
+  totalContracts: number;
+  warning?: string;
+}
+
 export interface OptionsChain {
   symbol: string;
   underlyingPrice: number;
@@ -31,5 +47,6 @@ export interface OptionsChain {
   totalCallVolume: number;
   totalPutVolume: number;
   putCallRatio: number;
+  quoteStatus: OptionsQuoteStatus;
   fetchedAt: string;
 }

package/src/types/portfolio.ts

@@ -30,6 +30,38 @@ export interface RiskMetrics {
   var95: number; // 95% Value at Risk (daily)
 }
 
+export interface FundHolding {
+  symbol: string;
+  name: string;
+  weight: number;
+}
+
+export interface FundHoldings {
+  symbol: string;
+  name?: string;
+  provider: string;
+  holdings: FundHolding[];
+  sectorWeights?: Record<string, number>;
+}
+
+export interface SharedFundHolding {
+  symbol: string;
+  name: string;
+  weights: Record<string, number>;
+  overlapWeight: number;
+}
+
+export interface FundOverlapPair {
+  symbols: [string, string];
+  overlapWeight: number;
+  sharedHoldings: SharedFundHolding[];
+}
+
+export interface FundHoldingsOverlap {
+  funds: FundHoldings[];
+  pairs: FundOverlapPair[];
+}
+
 export interface TechnicalIndicators {
   symbol: string;
   period: string;