tradeblocks-mcp 4.2.0 → 4.3.0

package/src/tools/market-data.ts

@@ -37,8 +37,20 @@ import {
 import { checkDataAvailability } from "../utils/data-availability.ts";
 import { getProfile } from "../db/profile-schemas.ts";
 import type { MarketStores } from "../market/stores/index.ts";
-import { listDatasets, resolveTradeDatasets } from "../db/dataset-schemas.ts";
+import {
+  listDatasets,
+  resolveTradeDatasets,
+  maxMissedSessionsSchema,
+  summarizeDatasetAge,
+  datasetAgeOutput,
+} from "../db/dataset-schemas.ts";
 import { suggestFieldFilters, analyzeFieldRegimes } from "./shared/field-analysis.ts";
+import {
+  suggestionEvidence,
+  rankSuggestions,
+  objectiveOutput,
+  type SuggestionEvidence,
+} from "./shared/filter-objective.ts";
 
 // =============================================================================
 // Types
@@ -279,6 +291,7 @@ export function registerMarketDataTools(
         "Returns warnings when market data is partially missing.",
       inputSchema: z.object({
         blockId: z.string().describe("Block ID to analyze"),
+        maxMissedSessions: maxMissedSessionsSchema,
         field: z
           .string()
           .optional()
@@ -300,229 +313,240 @@ export function registerMarketDataTools(
         ticker: z.string().optional().describe("Underlying ticker symbol (default: SPX)"),
       }),
     },
-    withFullSync(baseDir, async ({ blockId, segmentBy, strategy, ticker, field, bins }) => {
-      try {
-        const block = await loadBlock(baseDir, blockId);
-        let trades = block.trades;
+    withFullSync(
+      baseDir,
+      async ({ blockId, segmentBy, strategy, ticker, field, bins, maxMissedSessions }) => {
+        try {
+          const block = await loadBlock(baseDir, blockId);
+          let trades = block.trades;
 
-        if (strategy) {
-          trades = trades.filter((t) => t.strategy.toLowerCase() === strategy.toLowerCase());
-        }
+          if (strategy) {
+            trades = trades.filter((t) => t.strategy.toLowerCase() === strategy.toLowerCase());
+          }
 
-        if (trades.length === 0) {
-          return {
-            content: [{ type: "text", text: "No trades found" }],
-            isError: true,
-          };
-        }
+          if (trades.length === 0) {
+            return {
+              content: [{ type: "text", text: "No trades found" }],
+              isError: true,
+            };
+          }
 
-        if (field) return await analyzeFieldRegimes(baseDir, blockId, trades, field, bins);
-        if (!segmentBy) throw new Error("Provide field or segmentBy");
+          if (field)
+            return await analyzeFieldRegimes(
+              baseDir,
+              blockId,
+              trades,
+              field,
+              bins,
+              maxMissedSessions,
+            );
+          if (!segmentBy) throw new Error("Provide field or segmentBy");
 
-        // Collect unique trade keys (ticker+date) and query DuckDB for market data
-        const tradeKeys = uniqueTradeLookupKeys(trades);
+          // Collect unique trade keys (ticker+date) and query DuckDB for market data
+          const tradeKeys = uniqueTradeLookupKeys(trades);
 
-        const conn = await getConnection(baseDir);
+          const conn = await getConnection(baseDir);
 
-        // Check data availability and collect warnings
-        const resolvedTicker = normalizeTicker(ticker || "") || DEFAULT_MARKET_TICKER;
-        const availability = await checkDataAvailability(stores, resolvedTicker);
+          // Check data availability and collect warnings
+          const resolvedTicker = normalizeTicker(ticker || "") || DEFAULT_MARKET_TICKER;
+          const availability = await checkDataAvailability(stores, resolvedTicker);
 
-        const { sql: lagSql, params: lagParams } = buildLookaheadFreeQuery(tradeKeys);
-        const dailyResult = await conn.runAndReadAll(lagSql, lagParams);
-        const dailyRecords = resultToRecords(dailyResult);
-        const daily = recordsByTickerDate(dailyRecords);
+          const { sql: lagSql, params: lagParams } = buildLookaheadFreeQuery(tradeKeys);
+          const dailyResult = await conn.runAndReadAll(lagSql, lagParams);
+          const dailyRecords = resultToRecords(dailyResult);
+          const daily = recordsByTickerDate(dailyRecords);
 
-        // Match trades to market data and segment
-        interface SegmentStats {
-          segment: string;
-          segmentValue: number | string;
-          trades: { pl: number; isWin: boolean }[];
-        }
+          // Match trades to market data and segment
+          interface SegmentStats {
+            segment: string;
+            segmentValue: number | string;
+            trades: { pl: number; isWin: boolean }[];
+          }
 
-        const segments = new Map<string, SegmentStats>();
-        let totalMatched = 0;
-        let totalWins = 0;
-        let totalPl = 0;
-        let lagExcluded = 0;
-        const unmatchedDates: string[] = [];
+          const segments = new Map<string, SegmentStats>();
+          let totalMatched = 0;
+          let totalWins = 0;
+          let totalPl = 0;
+          let lagExcluded = 0;
+          const unmatchedDates: string[] = [];
 
-        for (const trade of trades) {
-          const lookup = getTradeLookupKey(trade);
-          const marketData = daily.get(marketTickerDateKey(lookup.ticker, lookup.date));
+          for (const trade of trades) {
+            const lookup = getTradeLookupKey(trade);
+            const marketData = daily.get(marketTickerDateKey(lookup.ticker, lookup.date));
 
-          if (!marketData) {
-            unmatchedDates.push(`${lookup.date}|${lookup.ticker}`);
-            continue;
-          }
+            if (!marketData) {
+              unmatchedDates.push(`${lookup.date}|${lookup.ticker}`);
+              continue;
+            }
 
-          // Get segment value (must resolve before counting in totals,
-          // since lagged fields may be NaN and cause continue)
-          const isWin = trade.pl > 0;
-          let segmentKey: string;
-          let segmentLabel: string;
-          let segmentValue: number | string;
-
-          switch (segmentBy) {
-            case "volRegime": {
-              const val = getNum(marketData, "prev_Vol_Regime");
-              if (isNaN(val)) {
-                lagExcluded++;
-                continue;
+            // Get segment value (must resolve before counting in totals,
+            // since lagged fields may be NaN and cause continue)
+            const isWin = trade.pl > 0;
+            let segmentKey: string;
+            let segmentLabel: string;
+            let segmentValue: number | string;
+
+            switch (segmentBy) {
+              case "volRegime": {
+                const val = getNum(marketData, "prev_Vol_Regime");
+                if (isNaN(val)) {
+                  lagExcluded++;
+                  continue;
+                }
+                segmentValue = val;
+                segmentKey = String(val);
+                segmentLabel = getVolRegimeLabel(val);
+                break;
               }
-              segmentValue = val;
-              segmentKey = String(val);
-              segmentLabel = getVolRegimeLabel(val);
-              break;
-            }
-            case "termStructure": {
-              const val = getNum(marketData, "prev_Term_Structure_State");
-              if (isNaN(val)) {
-                lagExcluded++;
-                continue;
+              case "termStructure": {
+                const val = getNum(marketData, "prev_Term_Structure_State");
+                if (isNaN(val)) {
+                  lagExcluded++;
+                  continue;
+                }
+                segmentValue = val;
+                segmentKey = String(val);
+                segmentLabel = getTermStructureLabel(val);
+                break;
               }
-              segmentValue = val;
-              segmentKey = String(val);
-              segmentLabel = getTermStructureLabel(val);
-              break;
-            }
-            case "dayOfWeek":
-              segmentValue = getNum(marketData, "Day_of_Week");
-              segmentKey = String(segmentValue);
-              segmentLabel = getDayLabel(getNum(marketData, "Day_of_Week"));
-              break;
-            case "gapDirection": {
-              const gapPct = getNum(marketData, "Gap_Pct");
-              if (isNaN(gapPct)) {
-                lagExcluded++;
-                continue;
+              case "dayOfWeek":
+                segmentValue = getNum(marketData, "Day_of_Week");
+                segmentKey = String(segmentValue);
+                segmentLabel = getDayLabel(getNum(marketData, "Day_of_Week"));
+                break;
+              case "gapDirection": {
+                const gapPct = getNum(marketData, "Gap_Pct");
+                if (isNaN(gapPct)) {
+                  lagExcluded++;
+                  continue;
+                }
+                segmentValue = gapPct > 0.1 ? "up" : gapPct < -0.1 ? "down" : "flat";
+                segmentKey = segmentValue;
+                segmentLabel = `Gap ${segmentValue}`;
+                break;
               }
-              segmentValue = gapPct > 0.1 ? "up" : gapPct < -0.1 ? "down" : "flat";
-              segmentKey = segmentValue;
-              segmentLabel = `Gap ${segmentValue}`;
-              break;
+              default:
+                continue;
             }
-            default:
-              continue;
+
+            // Count in totals only after segment resolved (NaN-lag trades excluded)
+            totalMatched++;
+            if (isWin) totalWins++;
+            totalPl += trade.pl;
+
+            if (!segments.has(segmentKey)) {
+              segments.set(segmentKey, {
+                segment: segmentLabel,
+                segmentValue,
+                trades: [],
+              });
+            }
+
+            segments.get(segmentKey)!.trades.push({ pl: trade.pl, isWin });
           }
 
-          // Count in totals only after segment resolved (NaN-lag trades excluded)
-          totalMatched++;
-          if (isWin) totalWins++;
-          totalPl += trade.pl;
+          if (totalMatched === 0) {
+            return {
+              content: [{ type: "text", text: "No trades matched to market data" }],
+              isError: true,
+            };
+          }
 
-          if (!segments.has(segmentKey)) {
-            segments.set(segmentKey, {
-              segment: segmentLabel,
-              segmentValue,
-              trades: [],
+          // Calculate overall stats
+          const overallWinRate = (totalWins / totalMatched) * 100;
+          const overallAvgPl = totalPl / totalMatched;
+
+          // Calculate segment stats
+          const segmentStats = Array.from(segments.values())
+            .map((seg) => {
+              const wins = seg.trades.filter((t) => t.isWin).length;
+              const losses = seg.trades.length - wins;
+              const winRate = (wins / seg.trades.length) * 100;
+              const totalSegPl = seg.trades.reduce((sum, t) => sum + t.pl, 0);
+              const avgPl = totalSegPl / seg.trades.length;
+
+              const winningTrades = seg.trades.filter((t) => t.isWin);
+              const losingTrades = seg.trades.filter((t) => !t.isWin);
+              const avgWin =
+                winningTrades.length > 0
+                  ? winningTrades.reduce((sum, t) => sum + t.pl, 0) / winningTrades.length
+                  : 0;
+              const avgLoss =
+                losingTrades.length > 0
+                  ? losingTrades.reduce((sum, t) => sum + t.pl, 0) / losingTrades.length
+                  : 0;
+
+              const grossWins = winningTrades.reduce((sum, t) => sum + t.pl, 0);
+              const grossLosses = Math.abs(losingTrades.reduce((sum, t) => sum + t.pl, 0));
+              const profitFactor =
+                grossLosses > 0 ? grossWins / grossLosses : grossWins > 0 ? null : 0;
+
+              return {
+                segment: seg.segment,
+                segmentValue: seg.segmentValue,
+                tradeCount: seg.trades.length,
+                wins,
+                losses,
+                winRate: Math.round(winRate * 100) / 100,
+                totalPl: Math.round(totalSegPl * 100) / 100,
+                avgPl: Math.round(avgPl * 100) / 100,
+                avgWin: Math.round(avgWin * 100) / 100,
+                avgLoss: Math.round(avgLoss * 100) / 100,
+                profitFactor: profitFactor !== null ? Math.round(profitFactor * 100) / 100 : null,
+                vsOverallWinRate: Math.round((winRate - overallWinRate) * 100) / 100,
+                vsOverallAvgPl: Math.round((avgPl - overallAvgPl) * 100) / 100,
+              };
+            })
+            .sort((a, b) => {
+              // Sort by segment value for consistent ordering
+              if (typeof a.segmentValue === "number" && typeof b.segmentValue === "number") {
+                return a.segmentValue - b.segmentValue;
+              }
+              return String(a.segmentValue).localeCompare(String(b.segmentValue));
             });
-          }
 
-          segments.get(segmentKey)!.trades.push({ pl: trade.pl, isWin });
-        }
+          const sortedUnmatchedDates = [...new Set(unmatchedDates)].sort();
 
-        if (totalMatched === 0) {
-          return {
-            content: [{ type: "text", text: "No trades matched to market data" }],
-            isError: true,
-          };
-        }
+          const summary = `Regime analysis: ${blockId} by ${segmentBy} | ${totalMatched} trades across ${segmentStats.length} segments`;
 
-        // Calculate overall stats
-        const overallWinRate = (totalWins / totalMatched) * 100;
-        const overallAvgPl = totalPl / totalMatched;
-
-        // Calculate segment stats
-        const segmentStats = Array.from(segments.values())
-          .map((seg) => {
-            const wins = seg.trades.filter((t) => t.isWin).length;
-            const losses = seg.trades.length - wins;
-            const winRate = (wins / seg.trades.length) * 100;
-            const totalSegPl = seg.trades.reduce((sum, t) => sum + t.pl, 0);
-            const avgPl = totalSegPl / seg.trades.length;
-
-            const winningTrades = seg.trades.filter((t) => t.isWin);
-            const losingTrades = seg.trades.filter((t) => !t.isWin);
-            const avgWin =
-              winningTrades.length > 0
-                ? winningTrades.reduce((sum, t) => sum + t.pl, 0) / winningTrades.length
-                : 0;
-            const avgLoss =
-              losingTrades.length > 0
-                ? losingTrades.reduce((sum, t) => sum + t.pl, 0) / losingTrades.length
-                : 0;
-
-            const grossWins = winningTrades.reduce((sum, t) => sum + t.pl, 0);
-            const grossLosses = Math.abs(losingTrades.reduce((sum, t) => sum + t.pl, 0));
-            const profitFactor =
-              grossLosses > 0 ? grossWins / grossLosses : grossWins > 0 ? null : 0;
+          const laggedSegments = ["volRegime", "termStructure"];
+          const lagNote = laggedSegments.includes(segmentBy)
+            ? `Segmentation by ${segmentBy} uses prior trading day values (close-derived field from market.enriched_context) to prevent lookahead bias.`
+            : `Segmentation by ${segmentBy} uses same-day values (${segmentBy === "dayOfWeek" ? "static" : "open-known"} field).`;
 
-            return {
-              segment: seg.segment,
-              segmentValue: seg.segmentValue,
-              tradeCount: seg.trades.length,
-              wins,
-              losses,
-              winRate: Math.round(winRate * 100) / 100,
-              totalPl: Math.round(totalSegPl * 100) / 100,
-              avgPl: Math.round(avgPl * 100) / 100,
-              avgWin: Math.round(avgWin * 100) / 100,
-              avgLoss: Math.round(avgLoss * 100) / 100,
-              profitFactor: profitFactor !== null ? Math.round(profitFactor * 100) / 100 : null,
-              vsOverallWinRate: Math.round((winRate - overallWinRate) * 100) / 100,
-              vsOverallAvgPl: Math.round((avgPl - overallAvgPl) * 100) / 100,
-            };
-          })
-          .sort((a, b) => {
-            // Sort by segment value for consistent ordering
-            if (typeof a.segmentValue === "number" && typeof b.segmentValue === "number") {
-              return a.segmentValue - b.segmentValue;
-            }
-            return String(a.segmentValue).localeCompare(String(b.segmentValue));
-          });
+          // Future: Realized_Vol quartile and IVR/IVP regime segmentation dimensions can be added here
 
-        const sortedUnmatchedDates = [...new Set(unmatchedDates)].sort();
-
-        const summary = `Regime analysis: ${blockId} by ${segmentBy} | ${totalMatched} trades across ${segmentStats.length} segments`;
-
-        const laggedSegments = ["volRegime", "termStructure"];
-        const lagNote = laggedSegments.includes(segmentBy)
-          ? `Segmentation by ${segmentBy} uses prior trading day values (close-derived field from market.enriched_context) to prevent lookahead bias.`
-          : `Segmentation by ${segmentBy} uses same-day values (${segmentBy === "dayOfWeek" ? "static" : "open-known"} field).`;
-
-        // Future: Realized_Vol quartile and IVR/IVP regime segmentation dimensions can be added here
-
-        const responseData: Record<string, unknown> = {
-          blockId,
-          segmentBy,
-          lagNote,
-          strategy: strategy || null,
-          tradesTotal: trades.length,
-          tradesMatched: totalMatched,
-          tradesUnmatched: unmatchedDates.length,
-          tradesLagExcluded: lagExcluded,
-          unmatchedDates: sortedUnmatchedDates,
-          overall: {
-            winRate: Math.round(overallWinRate * 100) / 100,
-            avgPl: Math.round(overallAvgPl * 100) / 100,
-            totalPl: Math.round(totalPl * 100) / 100,
-          },
-          segments: segmentStats,
-        };
-
-        if (availability.warnings.length > 0) {
-          responseData.warnings = availability.warnings;
-        }
+          const responseData: Record<string, unknown> = {
+            blockId,
+            segmentBy,
+            lagNote,
+            strategy: strategy || null,
+            tradesTotal: trades.length,
+            tradesMatched: totalMatched,
+            tradesUnmatched: unmatchedDates.length,
+            tradesLagExcluded: lagExcluded,
+            unmatchedDates: sortedUnmatchedDates,
+            overall: {
+              winRate: Math.round(overallWinRate * 100) / 100,
+              avgPl: Math.round(overallAvgPl * 100) / 100,
+              totalPl: Math.round(totalPl * 100) / 100,
+            },
+            segments: segmentStats,
+          };
 
-        return createToolOutput(summary, responseData);
-      } catch (error) {
-        return {
-          content: [{ type: "text", text: `Error: ${(error as Error).message}` }],
-          isError: true,
-        };
-      }
-    }),
+          if (availability.warnings.length > 0) {
+            responseData.warnings = availability.warnings;
+          }
+
+          return createToolOutput(summary, responseData);
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error: ${(error as Error).message}` }],
+            isError: true,
+          };
+        }
+      },
+    ),
   );
 
   // ---------------------------------------------------------------------------
@@ -534,11 +558,13 @@ export function registerMarketDataTools(
       description:
         "Analyze a block's losing trades and suggest market-based filters that would have improved performance. " +
         "Returns actionable standalone filter suggestions plus composite filters where cross-field correlations are strong. " +
+        "objective defaults to totalPl: only positive P&L improvements, ranked by P&L. winRate restores win-rate ranking with P&L tie-breaks. minImprovementPct is ignored under totalPl. " +
         "Close-derived fields (VIX_Close, Vol_Regime, RSI_14, Realized_Vol_5D/20D, VIX_IVR, VIX_IVP) use prior trading day values. " +
         "Open-known fields (Gap_Pct, VIX_Open, VIX_Gap_Pct, Prior_Range_vs_ATR, Day_of_Week, Is_Opex) use same-day values. " +
         "Uses market.enriched + market.spot_daily LEFT JOIN VIX tickers + market.enriched_context. Returns warnings when market data is partially missing.",
       inputSchema: z.object({
         blockId: z.string().describe("Block ID to analyze"),
+        maxMissedSessions: maxMissedSessionsSchema,
         fields: z
           .array(z.string())
           .min(1)
@@ -547,6 +573,12 @@ export function registerMarketDataTools(
             "Sweep numeric thresholds or categorical exclusions for these built-in or dataset fields. Omit to keep default suggestions.",
           ),
         strategy: z.string().optional().describe("Filter to specific strategy"),
+        objective: z
+          .enum(["totalPl", "winRate"])
+          .default("totalPl")
+          .describe(
+            "Admission/ranking objective (default totalPl). minImprovementPct applies only to winRate.",
+          ),
         strategyName: z
           .string()
           .optional()
@@ -556,13 +588,24 @@ export function registerMarketDataTools(
         minImprovementPct: z
           .number()
           .optional()
-          .describe("Only suggest filters with >= X% win rate improvement (default: 3)"),
+          .describe(
+            "Minimum win-rate gain in percentage points under winRate (default: 3); ignored under totalPl",
+          ),
         ticker: z.string().optional().describe("Underlying ticker symbol (default: SPX)"),
       }),
     },
     withFullSync(
       baseDir,
-      async ({ blockId, strategy, strategyName, minImprovementPct = 3, ticker, fields }) => {
+      async ({
+        blockId,
+        strategy,
+        strategyName,
+        minImprovementPct,
+        ticker,
+        fields,
+        objective = "totalPl",
+        maxMissedSessions,
+      }) => {
         try {
           const block = await loadBlock(baseDir, blockId);
           let trades = block.trades;
@@ -605,7 +648,15 @@ export function registerMarketDataTools(
           }
 
           if (fields)
-            return await suggestFieldFilters(baseDir, blockId, trades, fields, minImprovementPct);
+            return await suggestFieldFilters(
+              baseDir,
+              blockId,
+              trades,
+              fields,
+              minImprovementPct,
+              objective,
+              maxMissedSessions,
+            );
 
           // Collect unique trade keys (ticker+date) and query DuckDB for market data
           const tradeKeys = uniqueTradeLookupKeys(trades);
@@ -655,7 +706,7 @@ export function registerMarketDataTools(
           const currentTotalPl = matchedTrades.reduce((sum, t) => sum + t.trade.pl, 0);
 
           // Test various filters
-          interface FilterSuggestion {
+          interface FilterSuggestion extends SuggestionEvidence {
             filter: string;
             condition: {
               field: string;
@@ -663,14 +714,12 @@ export function registerMarketDataTools(
               value: number | number[] | string;
               lagged: boolean;
             };
-            tradesRemoved: number;
             winnersRemoved: number;
             losersRemoved: number;
             newWinRate: number;
             newTotalPl: number;
             winRateDelta: number;
             plDelta: number;
-            confidence: "high" | "medium" | "low";
           }
 
           const suggestions: FilterSuggestion[] = [];
@@ -966,16 +1015,15 @@ export function registerMarketDataTools(
             const winRateDelta = newWinRate - poolWinRate;
             const plDelta = newTotalPl - poolTotalPl;
 
-            // Only include if improvement meets threshold
-            if (winRateDelta >= minImprovementPct) {
-              // Determine confidence based on sample size
-              let confidence: "high" | "medium" | "low" = "low";
-              if (removed.length >= 10 && remaining.length >= 20) {
-                confidence = "high";
-              } else if (removed.length >= 5 && remaining.length >= 10) {
-                confidence = "medium";
-              }
-
+            const evidence = suggestionEvidence(
+              objective,
+              winRateDelta,
+              plDelta,
+              remaining.length,
+              removed.length,
+              minImprovementPct ?? 3,
+            );
+            if (evidence) {
               suggestions.push({
                 filter: filterDef.name,
                 condition: {
@@ -984,35 +1032,34 @@ export function registerMarketDataTools(
                   value: filterDef.value,
                   lagged: filterDef.lagged,
                 },
-                tradesRemoved: removed.length,
+                ...evidence,
                 winnersRemoved,
                 losersRemoved,
                 newWinRate: Math.round(newWinRate * 100) / 100,
                 newTotalPl: Math.round(newTotalPl * 100) / 100,
                 winRateDelta: Math.round(winRateDelta * 100) / 100,
                 plDelta: Math.round(plDelta * 100) / 100,
-                confidence,
               });
             }
           }
 
-          // Sort by win rate improvement
-          suggestions.sort((a, b) => b.winRateDelta - a.winRateDelta);
+          suggestions.sort((a, b) => rankSuggestions(objective, a, b));
 
           // Take top 10
           const topSuggestions = suggestions.slice(0, 10);
 
           // Generate composite filter suggestions from pairs of top-performing standalone filters
-          const baseWinRate = currentWinRate;
-          const significantFilters = suggestions.filter((s) => s.winRateDelta > 3);
+          const significantFilters = topSuggestions;
 
-          interface CompositeSuggestion {
+          interface CompositeSuggestion extends SuggestionEvidence {
             name: string;
             type: "composite";
             projectedWinRate: number;
             projectedAvgPl: number;
             tradesAffected: number;
             improvement: number;
+            winRateDelta: number;
+            plDelta: number;
           }
 
           const compositeSuggestions: CompositeSuggestion[] = [];
@@ -1050,45 +1097,70 @@ export function registerMarketDataTools(
                 );
               }
 
-              // Find trades that match BOTH filters (would be skipped by both)
-              const bothMatchTrades = pool.filter((t) => {
-                const m = t.market as Record<string, unknown>;
-                return testA.test(m) && testB.test(m);
-              });
-
-              if (bothMatchTrades.length < 5) continue;
+              // Compare both standalone kept sets on the same covered pool as the composite.
+              const bothMatchTrades: EnrichedTrade[] = [];
+              let keptA = 0;
+              let winsA = 0;
+              let keptB = 0;
+              let winsB = 0;
+              for (const item of pool) {
+                const market = item.market as Record<string, unknown>;
+                const skipA = testA.test(market);
+                const skipB = testB.test(market);
+                if (skipA && skipB) bothMatchTrades.push(item);
+                if (!skipA) {
+                  keptA++;
+                  if (item.trade.pl > 0) winsA++;
+                }
+                if (!skipB) {
+                  keptB++;
+                  if (item.trade.pl > 0) winsB++;
+                }
+              }
+              if (!keptA || !keptB) continue;
 
+              const excluded = new Set(bothMatchTrades);
+              const kept = pool.filter((trade) => !excluded.has(trade));
+              if (!kept.length || !bothMatchTrades.length) continue;
               const compositeWinRate =
-                (bothMatchTrades.filter((t) => t.trade.pl > 0).length / bothMatchTrades.length) *
-                100;
-              const compositeAvgPl =
-                bothMatchTrades.reduce((sum, t) => sum + t.trade.pl, 0) / bothMatchTrades.length;
-
-              // Only surface if composite win rate is materially better than either standalone filter alone
-              const improvement =
-                compositeWinRate -
-                Math.max(filterA.winRateDelta + baseWinRate, filterB.winRateDelta + baseWinRate);
-              if (improvement > 2) {
+                (kept.filter((t) => t.trade.pl > 0).length / kept.length) * 100;
+              const improvement = compositeWinRate - Math.max(winsA / keptA, winsB / keptB) * 100;
+              const totalPl = kept.reduce((sum, t) => sum + t.trade.pl, 0);
+              const winRateDelta =
+                compositeWinRate - (pool.filter((t) => t.trade.pl > 0).length / pool.length) * 100;
+              const plDelta = totalPl - pool.reduce((sum, t) => sum + t.trade.pl, 0);
+              const evidence = suggestionEvidence(
+                objective,
+                winRateDelta,
+                plDelta,
+                kept.length,
+                bothMatchTrades.length,
+                minImprovementPct ?? 3,
+              );
+              if (evidence) {
                 compositeSuggestions.push({
                   name: `${filterA.filter} AND ${filterB.filter}`,
                   type: "composite",
                   projectedWinRate: Math.round(compositeWinRate * 100) / 100,
-                  projectedAvgPl: Math.round(compositeAvgPl * 100) / 100,
+                  projectedAvgPl: Math.round((totalPl / kept.length) * 100) / 100,
                   tradesAffected: bothMatchTrades.length,
                   improvement: Math.round(improvement * 100) / 100,
+                  winRateDelta: Math.round(winRateDelta * 100) / 100,
+                  plDelta: Math.round(plDelta * 100) / 100,
+                  ...evidence,
                 });
               }
             }
           }
 
-          // Sort composites by improvement, take top 5
-          compositeSuggestions.sort((a, b) => b.improvement - a.improvement);
+          compositeSuggestions.sort((a, b) => rankSuggestions(objective, a, b));
           const topCompositeSuggestions = compositeSuggestions.slice(0, 5);
 
-          const summary = `Filter analysis: ${blockId} | ${topSuggestions.length} standalone, ${topCompositeSuggestions.length} composite suggestions (min ${minImprovementPct}% improvement)`;
+          const summary = `Filter analysis: ${blockId} | objective ${objective} | ${topSuggestions.length} standalone, ${topCompositeSuggestions.length} composite suggestions`;
 
           const sfResponseData: Record<string, unknown> = {
             blockId,
+            ...objectiveOutput(objective, minImprovementPct),
             lagNote:
               "Close-derived fields (VIX_Close, Vol_Regime, RSI_14, Consecutive_Days, VIX_Spike_Pct, Term_Structure_State, Realized_Vol_5D, Realized_Vol_20D, VIX_IVR, VIX_IVP) use prior trading day values to prevent lookahead bias. Open-known fields (Gap_Pct, VIX_Open, VIX_Gap_Pct, Prior_Range_vs_ATR, Day_of_Week, Is_Opex) use same-day values.",
             strategy: effectiveStrategy || null,
@@ -1100,7 +1172,7 @@ export function registerMarketDataTools(
             },
             suggestedFilters: topSuggestions,
             compositeSuggestions: topCompositeSuggestions,
-            minImprovementThreshold: minImprovementPct,
+            minImprovementThreshold: objective === "winRate" ? (minImprovementPct ?? 3) : null,
           };
 
           if (availabilitySF.warnings.length > 0) {
@@ -1168,6 +1240,7 @@ export function registerMarketDataTools(
         "Returns warnings when market data is partially missing.",
       inputSchema: z.object({
         blockId: z.string().describe("Block ID to enrich"),
+        maxMissedSessions: maxMissedSessionsSchema,
         strategy: z.string().optional().describe("Filter to specific strategy (exact match)"),
         startDate: z.string().optional().describe("Start date filter (YYYY-MM-DD)"),
         endDate: z.string().optional().describe("End date filter (YYYY-MM-DD)"),
@@ -1203,6 +1276,7 @@ export function registerMarketDataTools(
         includeIntradayContext,
         limit,
         offset,
+        maxMissedSessions,
       }) => {
         try {
           const block = await loadBlock(baseDir, blockId);
@@ -1328,14 +1402,18 @@ export function registerMarketDataTools(
           const unmatchedDates: string[] = [];
           let matched = 0;
 
-          const enrichedTrades = paginated.map((trade) => {
+          const datasetMatches = paginated.map((trade) =>
+            resolveTradeDatasets(datasets, trade, maxMissedSessions),
+          );
+          const datasetAge = summarizeDatasetAge(paginated, datasetMatches);
+          const enrichedTrades = paginated.map((trade, index) => {
             const lookup = getTradeLookupKey(trade);
             const marketKey = marketTickerDateKey(lookup.ticker, lookup.date);
             const marketData = daily.get(marketKey);
 
             const commissions = trade.openingCommissionsFees + trade.closingCommissionsFees;
 
-            const datasetMatch = resolveTradeDatasets(datasets, trade);
+            const datasetMatch = datasetMatches[index];
             const baseTrade: Record<string, unknown> = {
               dateOpened: lookup.date,
               ticker: lookup.ticker,
@@ -1350,6 +1428,9 @@ export function registerMarketDataTools(
               customFields: trade.customFields ?? {},
               datasetFields: datasetMatch.values,
               datasetProvenance: datasetMatch.provenance,
+              ...(Object.keys(datasetMatch.rejected).length
+                ? { datasetRejections: datasetMatch.rejected }
+                : {}),
             };
 
             if (!marketData) {
@@ -1418,6 +1499,7 @@ export function registerMarketDataTools(
           // Build response data
           const responseData: Record<string, unknown> = {
             blockId,
+            ...datasetAgeOutput(datasetAge, Object.keys(datasetAge)),
             strategy: strategy || null,
             lagNote,
             tradesTotal: totalTrades,