tradeblocks-mcp 3.0.2 → 3.0.3

package/src/tools/reports/discrepancies.ts

@@ -7,11 +7,7 @@
 import { z } from "zod";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { loadBlock, loadReportingLog } from "../../utils/block-loader.ts";
-import {
-  createToolOutput,
-  formatPercent,
-  formatCurrency,
-} from "../../utils/output-formatter.ts";
+import { createToolOutput, formatPercent, formatCurrency } from "../../utils/output-formatter.ts";
 import type { ReportingTrade } from "@tradeblocks/lib";
 import { pearsonCorrelation, kendallTau } from "@tradeblocks/lib";
 import {
@@ -25,10 +21,7 @@ import { withSyncedBlock } from "../middleware/sync-middleware.ts";
 /**
  * Register the analyze_discrepancies tool
  */
-export function registerDiscrepancyTool(
-  server: McpServer,
-  baseDir: string
-): void {
+export function registerDiscrepancyTool(server: McpServer, baseDir: string): void {
   server.registerTool(
     "analyze_discrepancies",
     {
@@ -36,10 +29,7 @@ export function registerDiscrepancyTool(
         "Analyze slippage patterns between backtest and actual trades. Detects systematic biases (direction, time-of-day) and correlates slippage with market conditions (VIX, gap, movement). Matches trades by date+strategy+time (minute precision). Requires both tradelog.csv (backtest) and reportinglog.csv (actual). Limitation: If multiple trades share the same date+strategy+minute, matching is order-dependent.",
       inputSchema: z.object({
         blockId: z.string().describe("Block folder name"),
-        strategy: z
-          .string()
-          .optional()
-          .describe("Filter to specific strategy name"),
+        strategy: z.string().optional().describe("Filter to specific strategy name"),
         dateRange: z
           .object({
             from: z.string().optional().describe("Start date YYYY-MM-DD"),
@@ -65,9 +55,7 @@ export function registerDiscrepancyTool(
           .min(0.5)
           .max(0.95)
           .default(0.7)
-          .describe(
-            "Threshold for detecting systematic patterns (0.7 = 70% consistency)"
-          ),
+          .describe("Threshold for detecting systematic patterns (0.7 = 70% consistency)"),
       }),
     },
     withSyncedBlock(
@@ -83,353 +71,335 @@ export function registerDiscrepancyTool(
       }) => {
         try {
           const block = await loadBlock(baseDir, blockId);
-        let backtestTrades = block.trades;
+          let backtestTrades = block.trades;
+
+          // Load reporting log (actual trades)
+          let actualTrades: ReportingTrade[];
+          try {
+            actualTrades = await loadReportingLog(baseDir, blockId);
+          } catch {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `No reportinglog.csv found in block "${blockId}". This tool requires both tradelog.csv (backtest) and reportinglog.csv (actual).`,
+                },
+              ],
+              isError: true,
+            };
+          }
 
-        // Load reporting log (actual trades)
-        let actualTrades: ReportingTrade[];
-        try {
-          actualTrades = await loadReportingLog(baseDir, blockId);
-        } catch {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `No reportinglog.csv found in block "${blockId}". This tool requires both tradelog.csv (backtest) and reportinglog.csv (actual).`,
-              },
-            ],
-            isError: true,
-          };
-        }
+          // Apply filters
+          backtestTrades = applyStrategyFilter(backtestTrades, strategy);
+          actualTrades = applyStrategyFilter(actualTrades, strategy);
+          backtestTrades = applyDateRangeFilter(backtestTrades, dateRange);
+          actualTrades = applyDateRangeFilter(actualTrades, dateRange);
+
+          if (backtestTrades.length === 0) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "No backtest trades found in tradelog.csv matching filters.",
+                },
+              ],
+              isError: true,
+            };
+          }
 
-        // Apply filters
-        backtestTrades = applyStrategyFilter(backtestTrades, strategy);
-        actualTrades = applyStrategyFilter(actualTrades, strategy);
-        backtestTrades = applyDateRangeFilter(backtestTrades, dateRange);
-        actualTrades = applyDateRangeFilter(actualTrades, dateRange);
+          if (actualTrades.length === 0) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "No actual trades found in reportinglog.csv matching filters.",
+                },
+              ],
+              isError: true,
+            };
+          }
 
-        if (backtestTrades.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "No backtest trades found in tradelog.csv matching filters.",
-              },
-            ],
-            isError: true,
-          };
-        }
+          // Match trades
+          const { matchedTrades, unmatchedBacktestCount, unmatchedActualCount } = matchTrades(
+            backtestTrades,
+            actualTrades,
+            scaling,
+          );
 
-        if (actualTrades.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "No actual trades found in reportinglog.csv matching filters.",
-              },
-            ],
-            isError: true,
+          if (matchedTrades.length === 0) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "No matching trades found between backtest and actual data. Cannot perform slippage analysis.",
+                },
+              ],
+              isError: true,
+            };
+          }
+
+          // Calculate date range from matched trades
+          const dates = matchedTrades.map((t) => t.date).sort();
+          const dateRangeResult = {
+            from: dates[0],
+            to: dates[dates.length - 1],
           };
-        }
 
-        // Match trades
-        const { matchedTrades, unmatchedBacktestCount, unmatchedActualCount } =
-          matchTrades(backtestTrades, actualTrades, scaling);
+          // Calculate summary statistics
+          const slippages = matchedTrades.map((t) => t.totalSlippage);
+          const totalSlippage = slippages.reduce((sum, s) => sum + s, 0);
+          const avgSlippagePerTrade = totalSlippage / matchedTrades.length;
 
-        if (matchedTrades.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "No matching trades found between backtest and actual data. Cannot perform slippage analysis.",
-              },
-            ],
-            isError: true,
-          };
-        }
+          // Pattern insight interface
+          interface PatternInsight {
+            pattern: string;
+            metric: string;
+            value: number;
+            sampleSize: number;
+          }
 
-        // Calculate date range from matched trades
-        const dates = matchedTrades.map((t) => t.date).sort();
-        const dateRangeResult = {
-          from: dates[0],
-          to: dates[dates.length - 1],
-        };
-
-        // Calculate summary statistics
-        const slippages = matchedTrades.map((t) => t.totalSlippage);
-        const totalSlippage = slippages.reduce((sum, s) => sum + s, 0);
-        const avgSlippagePerTrade = totalSlippage / matchedTrades.length;
-
-        // Pattern insight interface
-        interface PatternInsight {
-          pattern: string;
-          metric: string;
-          value: number;
-          sampleSize: number;
-        }
+          // Pattern detection function
+          const detectPatterns = (trades: MatchedTradeData[]): PatternInsight[] => {
+            const patterns: PatternInsight[] = [];
 
-        // Pattern detection function
-        const detectPatterns = (
-          trades: MatchedTradeData[]
-        ): PatternInsight[] => {
-          const patterns: PatternInsight[] = [];
+            if (trades.length < minSamples) {
+              return patterns;
+            }
 
-          if (trades.length < minSamples) {
-            return patterns;
-          }
+            // 1. Direction bias - if >patternThreshold of slippages are same sign
+            const tradeSlippages = trades.map((t) => t.totalSlippage);
+            const positiveCount = tradeSlippages.filter((s) => s > 0).length;
+            const negativeCount = tradeSlippages.filter((s) => s < 0).length;
+            const positiveRate = positiveCount / tradeSlippages.length;
+            const negativeRate = negativeCount / tradeSlippages.length;
 
-          // 1. Direction bias - if >patternThreshold of slippages are same sign
-          const tradeSlippages = trades.map((t) => t.totalSlippage);
-          const positiveCount = tradeSlippages.filter((s) => s > 0).length;
-          const negativeCount = tradeSlippages.filter((s) => s < 0).length;
-          const positiveRate = positiveCount / tradeSlippages.length;
-          const negativeRate = negativeCount / tradeSlippages.length;
-
-          if (positiveRate >= patternThreshold) {
-            patterns.push({
-              pattern: `Direction bias: ${formatPercent(positiveRate * 100)} of trades have positive slippage (actual > backtest)`,
-              metric: "positive_slippage_rate",
-              value: positiveRate,
-              sampleSize: tradeSlippages.length,
-            });
-          } else if (negativeRate >= patternThreshold) {
-            patterns.push({
-              pattern: `Direction bias: ${formatPercent(negativeRate * 100)} of trades have negative slippage (actual < backtest)`,
-              metric: "negative_slippage_rate",
-              value: negativeRate,
-              sampleSize: tradeSlippages.length,
-            });
-          }
+            if (positiveRate >= patternThreshold) {
+              patterns.push({
+                pattern: `Direction bias: ${formatPercent(positiveRate * 100)} of trades have positive slippage (actual > backtest)`,
+                metric: "positive_slippage_rate",
+                value: positiveRate,
+                sampleSize: tradeSlippages.length,
+              });
+            } else if (negativeRate >= patternThreshold) {
+              patterns.push({
+                pattern: `Direction bias: ${formatPercent(negativeRate * 100)} of trades have negative slippage (actual < backtest)`,
+                metric: "negative_slippage_rate",
+                value: negativeRate,
+                sampleSize: tradeSlippages.length,
+              });
+            }
 
-          // 2. Time-of-day clustering - if >patternThreshold of outlier trades occur in same time bucket
-          const tradesWithHour = trades.filter((t) => t.hourOfDay !== null);
-          if (tradesWithHour.length >= minSamples) {
-            // Define time buckets: morning (9-11), midday (11-14), afternoon (14-16)
-            const buckets = {
-              morning: tradesWithHour.filter(
-                (a) =>
-                  a.hourOfDay !== null && a.hourOfDay >= 9 && a.hourOfDay < 11
-              ),
-              midday: tradesWithHour.filter(
+            // 2. Time-of-day clustering - if >patternThreshold of outlier trades occur in same time bucket
+            const tradesWithHour = trades.filter((t) => t.hourOfDay !== null);
+            if (tradesWithHour.length >= minSamples) {
+              // Define time buckets: morning (9-11), midday (11-14), afternoon (14-16)
+              const buckets = {
+                morning: tradesWithHour.filter(
+                  (a) => a.hourOfDay !== null && a.hourOfDay >= 9 && a.hourOfDay < 11,
+                ),
+                midday: tradesWithHour.filter(
+                  (a) => a.hourOfDay !== null && a.hourOfDay >= 11 && a.hourOfDay < 14,
+                ),
+                afternoon: tradesWithHour.filter(
+                  (a) => a.hourOfDay !== null && a.hourOfDay >= 14 && a.hourOfDay <= 16,
+                ),
+              };
+
+              // Find outliers (beyond 1.5 * IQR)
+              const sorted = [...slippages].sort((a, b) => a - b);
+              const q1 = sorted[Math.floor(sorted.length * 0.25)];
+              const q3 = sorted[Math.floor(sorted.length * 0.75)];
+              const iqr = q3 - q1;
+              const outlierThresholdLow = q1 - 1.5 * iqr;
+              const outlierThresholdHigh = q3 + 1.5 * iqr;
+
+              const outlierTrades = tradesWithHour.filter(
                 (a) =>
-                  a.hourOfDay !== null && a.hourOfDay >= 11 && a.hourOfDay < 14
-              ),
-              afternoon: tradesWithHour.filter(
-                (a) =>
-                  a.hourOfDay !== null && a.hourOfDay >= 14 && a.hourOfDay <= 16
-              ),
-            };
+                  a.totalSlippage < outlierThresholdLow || a.totalSlippage > outlierThresholdHigh,
+              );
+
+              if (outlierTrades.length >= 3) {
+                for (const [bucketName, bucketTrades] of Object.entries(buckets)) {
+                  const outlierInBucket = outlierTrades.filter((o) => bucketTrades.includes(o));
+                  const bucketRate = outlierInBucket.length / outlierTrades.length;
+
+                  if (bucketRate >= patternThreshold && outlierInBucket.length >= 3) {
+                    patterns.push({
+                      pattern: `Time clustering: ${formatPercent(bucketRate * 100)} of outlier trades occur during ${bucketName} hours`,
+                      metric: "time_clustering_rate",
+                      value: bucketRate,
+                      sampleSize: outlierTrades.length,
+                    });
+                    break; // Only report strongest time pattern
+                  }
+                }
+              }
+            }
 
-            // Find outliers (beyond 1.5 * IQR)
-            const sorted = [...slippages].sort((a, b) => a - b);
-            const q1 = sorted[Math.floor(sorted.length * 0.25)];
-            const q3 = sorted[Math.floor(sorted.length * 0.75)];
-            const iqr = q3 - q1;
-            const outlierThresholdLow = q1 - 1.5 * iqr;
-            const outlierThresholdHigh = q3 + 1.5 * iqr;
-
-            const outlierTrades = tradesWithHour.filter(
-              (a) =>
-                a.totalSlippage < outlierThresholdLow ||
-                a.totalSlippage > outlierThresholdHigh
+            // 3. VIX sensitivity - correlation with openingVix if available
+            const vixTrades = trades.filter(
+              (t) => t.openingVix !== undefined && t.openingVix !== null,
             );
+            if (vixTrades.length >= minSamples) {
+              const vixValues = vixTrades.map((t) => t.openingVix!);
+              const vixSlippages = vixTrades.map((t) => t.totalSlippage);
 
-            if (outlierTrades.length >= 3) {
-              for (const [bucketName, bucketTrades] of Object.entries(
-                buckets
-              )) {
-                const outlierInBucket = outlierTrades.filter((o) =>
-                  bucketTrades.includes(o)
-                );
-                const bucketRate = outlierInBucket.length / outlierTrades.length;
-
-                if (
-                  bucketRate >= patternThreshold &&
-                  outlierInBucket.length >= 3
-                ) {
-                  patterns.push({
-                    pattern: `Time clustering: ${formatPercent(bucketRate * 100)} of outlier trades occur during ${bucketName} hours`,
-                    metric: "time_clustering_rate",
-                    value: bucketRate,
-                    sampleSize: outlierTrades.length,
-                  });
-                  break; // Only report strongest time pattern
-                }
+              const correlation =
+                correlationMethod === "pearson"
+                  ? pearsonCorrelation(vixSlippages, vixValues)
+                  : kendallTau(vixSlippages, vixValues);
+
+              const absCorr = Math.abs(correlation);
+              if (absCorr >= 0.3) {
+                // Only report if moderate or stronger
+                const direction = correlation > 0 ? "positive" : "negative";
+                patterns.push({
+                  pattern: `VIX sensitivity: ${direction} correlation (${correlation.toFixed(3)}) between slippage and opening VIX`,
+                  metric: "vix_correlation",
+                  value: correlation,
+                  sampleSize: vixTrades.length,
+                });
               }
             }
-          }
 
-          // 3. VIX sensitivity - correlation with openingVix if available
-          const vixTrades = trades.filter(
-            (t) => t.openingVix !== undefined && t.openingVix !== null
-          );
-          if (vixTrades.length >= minSamples) {
-            const vixValues = vixTrades.map((t) => t.openingVix!);
-            const vixSlippages = vixTrades.map((t) => t.totalSlippage);
-
-            const correlation =
-              correlationMethod === "pearson"
-                ? pearsonCorrelation(vixSlippages, vixValues)
-                : kendallTau(vixSlippages, vixValues);
-
-            const absCorr = Math.abs(correlation);
-            if (absCorr >= 0.3) {
-              // Only report if moderate or stronger
-              const direction = correlation > 0 ? "positive" : "negative";
-              patterns.push({
-                pattern: `VIX sensitivity: ${direction} correlation (${correlation.toFixed(3)}) between slippage and opening VIX`,
-                metric: "vix_correlation",
-                value: correlation,
-                sampleSize: vixTrades.length,
-              });
-            }
-          }
+            return patterns;
+          };
 
-          return patterns;
-        };
-
-        // Calculate correlations (only returns significant correlations with |r| >= 0.3)
-        const calculateCorrelations = (
-          trades: MatchedTradeData[]
-        ): Array<{
-          field: string;
-          coefficient: number;
-          sampleSize: number;
-        }> => {
-          const results: Array<{
+          // Calculate correlations (only returns significant correlations with |r| >= 0.3)
+          const calculateCorrelations = (
+            trades: MatchedTradeData[],
+          ): Array<{
             field: string;
             coefficient: number;
             sampleSize: number;
-          }> = [];
-
-          const correlationFields: Array<{
-            name: string;
-            getValue: (t: MatchedTradeData) => number | undefined | null;
-          }> = [
-            { name: "openingVix", getValue: (t) => t.openingVix },
-            { name: "closingVix", getValue: (t) => t.closingVix },
-            { name: "gap", getValue: (t) => t.gap },
-            { name: "movement", getValue: (t) => t.movement },
-            { name: "hourOfDay", getValue: (t) => t.hourOfDay },
-            { name: "contracts", getValue: (t) => t.contracts },
-          ];
+          }> => {
+            const results: Array<{
+              field: string;
+              coefficient: number;
+              sampleSize: number;
+            }> = [];
+
+            const correlationFields: Array<{
+              name: string;
+              getValue: (t: MatchedTradeData) => number | undefined | null;
+            }> = [
+              { name: "openingVix", getValue: (t) => t.openingVix },
+              { name: "closingVix", getValue: (t) => t.closingVix },
+              { name: "gap", getValue: (t) => t.gap },
+              { name: "movement", getValue: (t) => t.movement },
+              { name: "hourOfDay", getValue: (t) => t.hourOfDay },
+              { name: "contracts", getValue: (t) => t.contracts },
+            ];
+
+            for (const { name, getValue } of correlationFields) {
+              const validPairs: Array<{ slippage: number; field: number }> = [];
+
+              for (const trade of trades) {
+                const fieldValue = getValue(trade);
+                if (fieldValue !== undefined && fieldValue !== null && isFinite(fieldValue)) {
+                  validPairs.push({
+                    slippage: trade.totalSlippage,
+                    field: fieldValue,
+                  });
+                }
+              }
 
-          for (const { name, getValue } of correlationFields) {
-            const validPairs: Array<{ slippage: number; field: number }> = [];
-
-            for (const trade of trades) {
-              const fieldValue = getValue(trade);
-              if (
-                fieldValue !== undefined &&
-                fieldValue !== null &&
-                isFinite(fieldValue)
-              ) {
-                validPairs.push({
-                  slippage: trade.totalSlippage,
-                  field: fieldValue,
-                });
+              if (validPairs.length >= minSamples) {
+                const slippagesArr = validPairs.map((p) => p.slippage);
+                const fieldValues = validPairs.map((p) => p.field);
+
+                const coefficient =
+                  correlationMethod === "pearson"
+                    ? pearsonCorrelation(slippagesArr, fieldValues)
+                    : kendallTau(slippagesArr, fieldValues);
+
+                // Only include significant correlations (|r| >= 0.3)
+                if (Math.abs(coefficient) >= 0.3) {
+                  results.push({
+                    field: name,
+                    coefficient: Math.round(coefficient * 10000) / 10000,
+                    sampleSize: validPairs.length,
+                  });
+                }
               }
             }
 
-            if (validPairs.length >= minSamples) {
-              const slippagesArr = validPairs.map((p) => p.slippage);
-              const fieldValues = validPairs.map((p) => p.field);
+            // Sort by absolute coefficient descending
+            results.sort((a, b) => Math.abs(b.coefficient) - Math.abs(a.coefficient));
 
-              const coefficient =
-                correlationMethod === "pearson"
-                  ? pearsonCorrelation(slippagesArr, fieldValues)
-                  : kendallTau(slippagesArr, fieldValues);
-
-              // Only include significant correlations (|r| >= 0.3)
-              if (Math.abs(coefficient) >= 0.3) {
-                results.push({
-                  field: name,
-                  coefficient: Math.round(coefficient * 10000) / 10000,
-                  sampleSize: validPairs.length,
-                });
-              }
-            }
-          }
+            return results;
+          };
 
-          // Sort by absolute coefficient descending
-          results.sort(
-            (a, b) => Math.abs(b.coefficient) - Math.abs(a.coefficient)
-          );
+          // Portfolio-wide patterns and correlations
+          const portfolioPatterns = detectPatterns(matchedTrades);
+          const portfolioCorrelations = calculateCorrelations(matchedTrades);
 
-          return results;
-        };
+          // Per-strategy breakdown (always included, simplified output)
+          const byStrategy = new Map<string, MatchedTradeData[]>();
+          for (const trade of matchedTrades) {
+            const existing = byStrategy.get(trade.strategy) ?? [];
+            existing.push(trade);
+            byStrategy.set(trade.strategy, existing);
+          }
 
-        // Portfolio-wide patterns and correlations
-        const portfolioPatterns = detectPatterns(matchedTrades);
-        const portfolioCorrelations = calculateCorrelations(matchedTrades);
+          const perStrategy: Array<{
+            strategy: string;
+            tradeCount: number;
+            totalSlippage: number;
+            avgSlippage: number;
+          }> = [];
 
-        // Per-strategy breakdown (always included, simplified output)
-        const byStrategy = new Map<string, MatchedTradeData[]>();
-        for (const trade of matchedTrades) {
-          const existing = byStrategy.get(trade.strategy) ?? [];
-          existing.push(trade);
-          byStrategy.set(trade.strategy, existing);
-        }
+          for (const [strategyName, trades] of byStrategy) {
+            const stratSlippages = trades.map((t) => t.totalSlippage);
+            const stratTotal = stratSlippages.reduce((sum, s) => sum + s, 0);
+            const stratAvg = trades.length > 0 ? stratTotal / trades.length : 0;
 
-        const perStrategy: Array<{
-          strategy: string;
-          tradeCount: number;
-          totalSlippage: number;
-          avgSlippage: number;
-        }> = [];
-
-        for (const [strategyName, trades] of byStrategy) {
-          const stratSlippages = trades.map((t) => t.totalSlippage);
-          const stratTotal = stratSlippages.reduce((sum, s) => sum + s, 0);
-          const stratAvg = trades.length > 0 ? stratTotal / trades.length : 0;
-
-          perStrategy.push({
-            strategy: strategyName,
-            tradeCount: trades.length,
-            totalSlippage: stratTotal,
-            avgSlippage: stratAvg,
-          });
-        }
+            perStrategy.push({
+              strategy: strategyName,
+              tradeCount: trades.length,
+              totalSlippage: stratTotal,
+              avgSlippage: stratAvg,
+            });
+          }
 
-        // Sort by absolute total slippage descending
-        perStrategy.sort(
-          (a, b) => Math.abs(b.totalSlippage) - Math.abs(a.totalSlippage)
-        );
+          // Sort by absolute total slippage descending
+          perStrategy.sort((a, b) => Math.abs(b.totalSlippage) - Math.abs(a.totalSlippage));
 
-        // Build summary string
-        const summaryParts = [
-          `Slippage analysis: ${matchedTrades.length} matched trades`,
-          `Total slippage: ${formatCurrency(totalSlippage)}`,
-          `Avg per trade: ${formatCurrency(avgSlippagePerTrade)}`,
-        ];
+          // Build summary string
+          const summaryParts = [
+            `Slippage analysis: ${matchedTrades.length} matched trades`,
+            `Total slippage: ${formatCurrency(totalSlippage)}`,
+            `Avg per trade: ${formatCurrency(avgSlippagePerTrade)}`,
+          ];
 
-        if (portfolioPatterns.length > 0) {
-          summaryParts.push(`${portfolioPatterns.length} patterns detected`);
-        }
+          if (portfolioPatterns.length > 0) {
+            summaryParts.push(`${portfolioPatterns.length} patterns detected`);
+          }
+
+          const summary = summaryParts.join(" | ");
+
+          const structuredData = {
+            summary: {
+              matchedTrades: matchedTrades.length,
+              unmatchedBacktest: unmatchedBacktestCount,
+              unmatchedActual: unmatchedActualCount,
+              totalSlippage,
+              avgSlippagePerTrade,
+              dateRange: dateRangeResult,
+            },
+            patterns: portfolioPatterns,
+            correlations: {
+              method: correlationMethod,
+              results: portfolioCorrelations,
+              note:
+                portfolioCorrelations.length === 0
+                  ? "No significant correlations found (|r| >= 0.3)"
+                  : undefined,
+            },
+            perStrategy,
+          };
 
-        const summary = summaryParts.join(" | ");
-
-        const structuredData = {
-          summary: {
-            matchedTrades: matchedTrades.length,
-            unmatchedBacktest: unmatchedBacktestCount,
-            unmatchedActual: unmatchedActualCount,
-            totalSlippage,
-            avgSlippagePerTrade,
-            dateRange: dateRangeResult,
-          },
-          patterns: portfolioPatterns,
-          correlations: {
-            method: correlationMethod,
-            results: portfolioCorrelations,
-            note:
-              portfolioCorrelations.length === 0
-                ? "No significant correlations found (|r| >= 0.3)"
-                : undefined,
-          },
-          perStrategy,
-        };
-
-        return createToolOutput(summary, structuredData);
+          return createToolOutput(summary, structuredData);
         } catch (error) {
           return {
             content: [
@@ -441,7 +411,7 @@ export function registerDiscrepancyTool(
             isError: true,
           };
         }
-      }
-    )
+      },
+    ),
   );
 }