opencandle 0.3.0 → 0.5.0

package/src/tools/options/option-chain.ts

@@ -0,0 +1,96 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { getOptionsChain } from "../../providers/yahoo-finance.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import type { OptionsChain, OptionContract } from "../../types/options.js";
+
+const params = Type.Object({
+  symbol: Type.String({ description: "Stock ticker symbol (e.g. AAPL, TSLA, SPY, MSFT)" }),
+  expiration: Type.Optional(
+    Type.String({
+      description:
+        "Expiration date as YYYY-MM-DD. If omitted, uses the nearest expiration.",
+    }),
+  ),
+  type: Type.Optional(
+    Type.Union([Type.Literal("call"), Type.Literal("put"), Type.Literal("CALL"), Type.Literal("PUT")], {
+      description: "Filter by option type. Omit for both calls and puts.",
+    }),
+  ),
+});
+
+export const optionChainTool: AgentTool<typeof params, OptionsChain> = {
+  name: "get_option_chain",
+  label: "Options Chain",
+  description:
+    "Get the full options chain for a stock with strikes, bids, asks, volume, open interest, implied volatility, and computed Greeks (Delta, Gamma, Theta, Vega, Rho via Black-Scholes). No API key required.",
+  parameters: params,
+  async execute(_toolCallId, args) {
+    const symbol = args.symbol.toUpperCase();
+    const normalizedType = args.type?.toLowerCase();
+    const expirationTs = args.expiration
+      ? Math.floor(new Date(args.expiration).getTime() / 1000)
+      : undefined;
+
+    const result = await wrapProvider("yahoo", () => getOptionsChain(symbol, expirationTs));
+    if (result.status === "unavailable") {
+      return {
+        content: [{ type: "text", text: `⚠ Options chain unavailable for ${symbol} (${result.reason}).` }],
+        details: null as any,
+      };
+    }
+    const chain = result.data;
+
+    const lines: string[] = [
+      `**${chain.symbol} Options Chain** — Expiry: ${chain.expirationDate}`,
+      `Underlying: $${chain.underlyingPrice.toFixed(2)}`,
+      `Quote status: ${chain.quoteStatus.marketSession} / ${chain.quoteStatus.bidAskState}`,
+      "Option bid/ask and last prices are quoted per share; multiply by 100 for one standard contract premium.",
+      ...(chain.quoteStatus.warning
+        ? [`⚠ ${chain.quoteStatus.warning} do not treat zero bid/ask as confirmed live illiquidity without broker verification; do not stop at the stale quote caveat. Disclose the gap, avoid naming tradable live premiums, and finish the strategy explanation with mechanics, assignment outcomes, labeled hypotheticals, and what live broker quotes would change.`]
+        : []),
+      `Available expirations: ${formatAvailableExpirations(chain.expirationDates)}`,
+      "",
+    ];
+
+    const showCalls = !normalizedType || normalizedType === "call";
+    const showPuts = !normalizedType || normalizedType === "put";
+
+    if (showCalls && chain.calls.length > 0) {
+      lines.push(`**CALLS** (${chain.calls.length} contracts, volume: ${chain.totalCallVolume.toLocaleString()})`);
+      lines.push("Strike | Bid/Ask (per share) | Last (per share) | Vol | OI | IV | Delta | Gamma | Theta | Vega | Rho");
+      const topCalls = sortByVolume(chain.calls).slice(0, 10);
+      for (const c of topCalls) {
+        lines.push(formatContract(c));
+      }
+      lines.push("");
+    }
+
+    if (showPuts && chain.puts.length > 0) {
+      lines.push(`**PUTS** (${chain.puts.length} contracts, volume: ${chain.totalPutVolume.toLocaleString()})`);
+      lines.push("Strike | Bid/Ask (per share) | Last (per share) | Vol | OI | IV | Delta | Gamma | Theta | Vega | Rho");
+      const topPuts = sortByVolume(chain.puts).slice(0, 10);
+      for (const c of topPuts) {
+        lines.push(formatContract(c));
+      }
+      lines.push("");
+    }
+
+    lines.push(`Put/Call Ratio: ${chain.putCallRatio.toFixed(2)}`);
+
+    return { content: [{ type: "text", text: lines.join("\n") }], details: chain };
+  },
+};
+
+function sortByVolume(contracts: OptionContract[]): OptionContract[] {
+  return [...contracts].sort((a, b) => b.volume - a.volume);
+}
+
+function formatAvailableExpirations(expirationDates: string[]): string {
+  return expirationDates.join(", ");
+}
+
+function formatContract(c: OptionContract): string {
+  const itm = c.inTheMoney ? "*" : " ";
+  return `${itm}$${c.strike.toFixed(2)} | $${c.bid.toFixed(2)}/$${c.ask.toFixed(2)} | $${c.lastPrice.toFixed(2)} | ${c.volume} | ${c.openInterest} | ${(c.impliedVolatility * 100).toFixed(1)}% | ${c.greeks.delta.toFixed(3)} | ${c.greeks.gamma.toFixed(3)} | ${c.greeks.theta.toFixed(3)} | ${c.greeks.vega.toFixed(3)} | ${c.greeks.rho.toFixed(3)}`;
+}

package/src/tools/portfolio/correlation.ts

@@ -0,0 +1,162 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { getHistory } from "../../providers/yahoo-finance.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import { computeDailyReturns } from "./risk-analysis.js";
+import type { OHLCV } from "../../types/market.js";
+
+export function computeCorrelation(returnsA: number[], returnsB: number[]): number {
+  const n = Math.min(returnsA.length, returnsB.length);
+  if (n === 0) return 0;
+
+  let sumA = 0, sumB = 0;
+  for (let i = 0; i < n; i++) {
+    sumA += returnsA[i];
+    sumB += returnsB[i];
+  }
+  const meanA = sumA / n;
+  const meanB = sumB / n;
+
+  let cov = 0, varA = 0, varB = 0;
+  for (let i = 0; i < n; i++) {
+    const dA = returnsA[i] - meanA;
+    const dB = returnsB[i] - meanB;
+    cov += dA * dB;
+    varA += dA * dA;
+    varB += dB * dB;
+  }
+
+  if (varA === 0 || varB === 0) return 0;
+  return cov / Math.sqrt(varA * varB);
+}
+
+const DEFAULT_MIN_OVERLAP = 20;
+
+export function alignReturnsByDate(
+  historiesBySymbol: Map<string, OHLCV[]>,
+  minOverlap: number = DEFAULT_MIN_OVERLAP,
+): Map<string, number[]> {
+  // Build date → close price maps for each symbol
+  const priceByDate = new Map<string, Map<string, number>>();
+  for (const [symbol, bars] of historiesBySymbol) {
+    const dateMap = new Map<string, number>();
+    for (const bar of bars) {
+      dateMap.set(bar.date, bar.close);
+    }
+    priceByDate.set(symbol, dateMap);
+  }
+
+  // Find common dates across all symbols
+  const symbols = [...historiesBySymbol.keys()];
+  const firstDates = priceByDate.get(symbols[0])!;
+  const commonDates = [...firstDates.keys()].filter((date) =>
+    symbols.every((s) => priceByDate.get(s)!.has(date)),
+  ).sort();
+
+  if (commonDates.length < minOverlap) {
+    throw new Error(
+      `Insufficient date overlap for correlation: ${commonDates.length} common dates (need ${minOverlap}+). Symbols may trade on different exchanges or have sparse history.`,
+    );
+  }
+
+  // Extract aligned close prices, then compute returns
+  const result = new Map<string, number[]>();
+  for (const symbol of symbols) {
+    const dateMap = priceByDate.get(symbol)!;
+    const alignedCloses = commonDates.map((d) => dateMap.get(d)!);
+    result.set(symbol, computeDailyReturns(alignedCloses));
+  }
+
+  return result;
+}
+
+const params = Type.Object({
+  symbols: Type.Array(Type.String(), {
+    description: "Array of 2+ ticker symbols to compute correlation matrix (e.g. ['AAPL','MSFT','GOOGL'])",
+    minItems: 2,
+  }),
+  period: Type.Optional(
+    Type.String({ description: "Historical period: 6mo, 1y, 2y. Default: 1y" }),
+  ),
+});
+
+export const correlationTool: AgentTool<typeof params> = {
+  name: "analyze_correlation",
+  label: "Correlation Matrix",
+  description:
+    "Compute pairwise return correlations between 2+ stocks. Identifies highly correlated positions (|r| > 0.7) as concentration risk. Useful for portfolio diversification analysis.",
+  parameters: params,
+  async execute(_toolCallId, args) {
+    const symbols = args.symbols.map((s) => s.toUpperCase());
+    const period = args.period ?? "1y";
+
+    if (symbols.length < 2) {
+      throw new Error("Need at least 2 symbols for correlation analysis.");
+    }
+
+    // Fetch history for all symbols in parallel
+    const results = await Promise.all(
+      symbols.map(async (s) => ({
+        symbol: s,
+        result: await wrapProvider("yahoo", () => getHistory(s, period, "1d")),
+      })),
+    );
+
+    const unavailable = results.filter((r) => r.result.status === "unavailable");
+    if (unavailable.length === results.length) {
+      return {
+        content: [{ type: "text", text: `⚠ Correlation analysis unavailable — could not fetch history for any symbol.` }],
+        details: null as any,
+      };
+    }
+
+    const historiesBySymbol = new Map<string, OHLCV[]>();
+    for (const { symbol: sym, result: r } of results) {
+      if (r.status === "ok") historiesBySymbol.set(sym, r.data);
+    }
+
+    const returnsBySymbol = alignReturnsByDate(historiesBySymbol);
+
+    // Build correlation matrix
+    const matrix: Record<string, Record<string, number>> = {};
+    const warnings: string[] = [];
+
+    for (const a of symbols) {
+      matrix[a] = {};
+      for (const b of symbols) {
+        if (a === b) {
+          matrix[a][b] = 1.0;
+        } else if (matrix[b]?.[a] != null) {
+          matrix[a][b] = matrix[b][a];
+        } else {
+          const r = computeCorrelation(returnsBySymbol.get(a)!, returnsBySymbol.get(b)!);
+          matrix[a][b] = r;
+          if (Math.abs(r) > 0.7 && a < b) {
+            warnings.push(`${a}/${b}: r=${r.toFixed(2)} — high correlation, concentration risk`);
+          }
+        }
+      }
+    }
+
+    // Format output
+    const header = `**Correlation Matrix** (${period} daily returns)`;
+    const colHeader = `${"".padEnd(8)} ${symbols.map((s) => s.padStart(8)).join("")}`;
+    const rows = symbols.map((a) => {
+      const cells = symbols.map((b) => matrix[a][b].toFixed(2).padStart(8));
+      return `${a.padEnd(8)} ${cells.join("")}`;
+    });
+
+    const lines = [header, "", colHeader, ...rows];
+    if (warnings.length > 0) {
+      lines.push("", "**Concentration Warnings:**");
+      for (const w of warnings) lines.push(`  - ${w}`);
+    } else {
+      lines.push("", "No high-correlation pairs detected. Portfolio appears diversified.");
+    }
+
+    return {
+      content: [{ type: "text", text: lines.join("\n") }],
+      details: { matrix, warnings },
+    };
+  },
+};

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

@@ -0,0 +1,253 @@
+import { Type } from "@sinclair/typebox";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { getQuote } from "../../providers/yahoo-finance.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import { ensureParentDir, getPredictionsPath } from "../../infra/opencandle-paths.js";
+
+export interface Prediction {
+  symbol: string;
+  direction: "bullish" | "bearish" | "neutral";
+  conviction: number; // 1-10
+  entryPrice: number;
+  targetPrice?: number;
+  date: string;
+  expiresAt: string;
+  timeframeDays: number;
+}
+
+export interface PredictionCheckResult {
+  total: number;
+  open: number;
+  correct: number;
+  wrong: number;
+  hitRate: number;
+  weightedHitRate: number;
+  details: Array<{
+    symbol: string;
+    direction: string;
+    conviction: number;
+    entryPrice: number;
+    currentPrice: number;
+    pnlPercent: number;
+    correct: boolean;
+    status: "open" | "resolved";
+  }>;
+}
+
+function loadPredictions(): Prediction[] {
+  const predictionsPath = getPredictionsPath();
+  if (!existsSync(predictionsPath)) return [];
+  try {
+    return JSON.parse(readFileSync(predictionsPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+
+function savePredictions(predictions: Prediction[]): void {
+  const predictionsPath = getPredictionsPath();
+  ensureParentDir(predictionsPath);
+  writeFileSync(predictionsPath, JSON.stringify(predictions, null, 2));
+}
+
+export function recordPrediction(params: {
+  symbol: string;
+  direction: "bullish" | "bearish" | "neutral";
+  conviction: number;
+  entryPrice: number;
+  targetPrice?: number;
+  timeframeDays: number;
+}): Prediction {
+  const predictions = loadPredictions();
+  const now = new Date();
+  const expires = new Date(now);
+  expires.setDate(expires.getDate() + params.timeframeDays);
+
+  const prediction: Prediction = {
+    symbol: params.symbol.toUpperCase(),
+    direction: params.direction,
+    conviction: params.conviction,
+    entryPrice: params.entryPrice,
+    targetPrice: params.targetPrice,
+    date: now.toISOString().split("T")[0],
+    expiresAt: expires.toISOString().split("T")[0],
+    timeframeDays: params.timeframeDays,
+  };
+
+  predictions.push(prediction);
+  savePredictions(predictions);
+  return prediction;
+}
+
+export function checkPredictions(
+  predictions: Prediction[],
+  currentPrices: Map<string, number>,
+  now: Date = new Date(),
+): PredictionCheckResult {
+  if (predictions.length === 0) {
+    return { total: 0, open: 0, correct: 0, wrong: 0, hitRate: 0, weightedHitRate: 0, details: [] };
+  }
+
+  const details: PredictionCheckResult["details"] = [];
+  let totalConviction = 0;
+  let correctConviction = 0;
+  let openCount = 0;
+
+  const nowStr = now.toISOString().split("T")[0];
+
+  for (const p of predictions) {
+    const currentPrice = currentPrices.get(p.symbol);
+    if (currentPrice == null) continue;
+
+    const isExpired = p.expiresAt <= nowStr;
+    const pnlPercent = (currentPrice - p.entryPrice) / p.entryPrice;
+
+    if (!isExpired) {
+      openCount++;
+      details.push({
+        symbol: p.symbol,
+        direction: p.direction,
+        conviction: p.conviction,
+        entryPrice: p.entryPrice,
+        currentPrice,
+        pnlPercent,
+        correct: false,
+        status: "open",
+      });
+      continue;
+    }
+
+    const correct =
+      (p.direction === "bullish" && currentPrice > p.entryPrice) ||
+      (p.direction === "bearish" && currentPrice < p.entryPrice) ||
+      (p.direction === "neutral" && Math.abs(pnlPercent) < 0.02);
+
+    details.push({
+      symbol: p.symbol,
+      direction: p.direction,
+      conviction: p.conviction,
+      entryPrice: p.entryPrice,
+      currentPrice,
+      pnlPercent,
+      correct,
+      status: "resolved",
+    });
+
+    totalConviction += p.conviction;
+    if (correct) correctConviction += p.conviction;
+  }
+
+  const resolved = details.filter((d) => d.status === "resolved");
+  const correctCount = resolved.filter((d) => d.correct).length;
+
+  return {
+    total: details.length,
+    open: openCount,
+    correct: correctCount,
+    wrong: resolved.length - correctCount,
+    hitRate: resolved.length > 0 ? correctCount / resolved.length : 0,
+    weightedHitRate: totalConviction > 0 ? correctConviction / totalConviction : 0,
+    details,
+  };
+}
+
+const params = Type.Object({
+  action: Type.Union(
+    [Type.Literal("record"), Type.Literal("check")],
+    { description: "record: save a new prediction. check: evaluate all predictions against current prices." },
+  ),
+  symbol: Type.Optional(Type.String({ description: "Ticker symbol (required for record)" })),
+  direction: Type.Optional(
+    Type.Union(
+      [Type.Literal("bullish"), Type.Literal("bearish"), Type.Literal("neutral")],
+      { description: "Predicted direction (required for record)" },
+    ),
+  ),
+  conviction: Type.Optional(
+    Type.Number({ description: "Conviction 1-10 (required for record)" }),
+  ),
+  entry_price: Type.Optional(
+    Type.Number({ description: "Entry price at time of prediction (required for record)" }),
+  ),
+  target_price: Type.Optional(
+    Type.Number({ description: "Optional target price" }),
+  ),
+  timeframe_days: Type.Optional(
+    Type.Number({ description: "Timeframe in days for the prediction (default: 30)" }),
+  ),
+});
+
+export const predictionsTool: AgentTool<typeof params> = {
+  name: "track_prediction",
+  label: "Prediction Tracker",
+  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) {
+    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.");
+      }
+
+      const prediction = recordPrediction({
+        symbol: args.symbol,
+        direction: args.direction,
+        conviction: args.conviction,
+        entryPrice: args.entry_price,
+        targetPrice: args.target_price,
+        timeframeDays: args.timeframe_days ?? 30,
+      });
+
+      return {
+        content: [{ type: "text", text: `Recorded: ${prediction.symbol} ${prediction.direction} (conviction ${prediction.conviction}/10) at $${prediction.entryPrice}. Expires ${prediction.expiresAt}.` }],
+        details: prediction,
+      };
+    }
+
+    // Check action
+    const predictions = loadPredictions();
+    if (predictions.length === 0) {
+      return {
+        content: [{ type: "text", text: "No predictions recorded yet. Use record action to track your calls." }],
+        details: null,
+      };
+    }
+
+    // Fetch current prices for all symbols
+    const symbols = [...new Set(predictions.map((p) => p.symbol))];
+    const priceMap = new Map<string, number>();
+    await Promise.all(
+      symbols.map(async (sym) => {
+        const result = await wrapProvider("yahoo", () => getQuote(sym));
+        if (result.status === "ok") {
+          priceMap.set(sym, result.data.price);
+        } else {
+          // Skip symbols that are unavailable
+        }
+      }),
+    );
+
+    const result = checkPredictions(predictions, priceMap);
+
+    const resolved = result.correct + result.wrong;
+    const lines = [
+      `**Prediction Scorecard** — ${result.total} predictions (${resolved} resolved, ${result.open} open)`,
+      ``,
+      `Hit Rate: ${(result.hitRate * 100).toFixed(0)}% (${result.correct}/${resolved})`,
+      `Weighted Hit Rate: ${(result.weightedHitRate * 100).toFixed(0)}% (by conviction)`,
+      ``,
+      ...result.details.map((d) => {
+        const icon = d.status === "open" ? "~" : d.correct ? "+" : "-";
+        const sign = d.pnlPercent >= 0 ? "+" : "";
+        const label = d.status === "open" ? " (open)" : "";
+        return `  [${icon}] ${d.symbol}: ${d.direction} (conv ${d.conviction}) → $${d.entryPrice.toFixed(2)} → $${d.currentPrice.toFixed(2)} (${sign}${(d.pnlPercent * 100).toFixed(1)}%)${label}`;
+      }),
+    ];
+
+    return {
+      content: [{ type: "text", text: lines.join("\n") }],
+      details: result,
+    };
+  },
+};