tradeblocks-mcp 3.0.2 → 3.3.1

package/src/tools/market-data.ts

@@ -15,10 +15,7 @@
 import { z } from "zod";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { loadBlock } from "../utils/block-loader.ts";
-import {
-  createToolOutput,
-  formatPercent,
-} from "../utils/output-formatter.ts";
+import { createToolOutput, formatPercent } from "../utils/output-formatter.ts";
 import type { Trade } from "@tradeblocks/lib";
 import { getConnection } from "../db/connection.ts";
 import { withFullSync } from "./middleware/sync-middleware.ts";
@@ -147,7 +144,11 @@ function formatTradeDate(date: Date | string): string {
  * Convert DuckDB query result to an array of Record objects.
  * Handles BigInt to Number conversion for JSON compatibility.
  */
-function resultToRecords(result: { columnCount: number; columnName(i: number): string; getRows(): Iterable<unknown[]> }): Record<string, unknown>[] {
+function resultToRecords(result: {
+  columnCount: number;
+  columnName(i: number): string;
+  getRows(): Iterable<unknown[]>;
+}): Record<string, unknown>[] {
   const columnCount = result.columnCount;
   const colNames: string[] = [];
   for (let i = 0; i < columnCount; i++) {
@@ -193,7 +194,7 @@ function uniqueTradeLookupKeys(trades: Trade[]): MarketLookupKey[] {
 }
 
 function recordsByTickerDate(
-  records: Record<string, unknown>[]
+  records: Record<string, unknown>[],
 ): Map<string, Record<string, unknown>> {
   const mapped = new Map<string, Record<string, unknown>>();
   for (const record of records) {
@@ -275,12 +276,9 @@ export function registerMarketDataTools(
         "Returns warnings when market data is partially missing.",
       inputSchema: z.object({
         blockId: z.string().describe("Block ID to analyze"),
-        segmentBy: z.enum([
-          "volRegime",
-          "termStructure",
-          "dayOfWeek",
-          "gapDirection",
-        ]).describe("Market dimension to segment by"),
+        segmentBy: z
+          .enum(["volRegime", "termStructure", "dayOfWeek", "gapDirection"])
+          .describe("Market dimension to segment by"),
         strategy: z.string().optional().describe("Filter to specific strategy"),
         ticker: z.string().optional().describe("Underlying ticker symbol (default: SPX)"),
       }),
@@ -291,9 +289,7 @@ export function registerMarketDataTools(
         let trades = block.trades;
 
         if (strategy) {
-          trades = trades.filter(
-            (t) => t.strategy.toLowerCase() === strategy.toLowerCase()
-          );
+          trades = trades.filter((t) => t.strategy.toLowerCase() === strategy.toLowerCase());
         }
 
         if (trades.length === 0) {
@@ -309,7 +305,7 @@ export function registerMarketDataTools(
         const conn = await getConnection(baseDir);
 
         // Check data availability and collect warnings
-        const resolvedTicker = normalizeTicker(ticker || '') || DEFAULT_MARKET_TICKER;
+        const resolvedTicker = normalizeTicker(ticker || "") || DEFAULT_MARKET_TICKER;
         const availability = await checkDataAvailability(stores, resolvedTicker);
 
         const { sql: lagSql, params: lagParams } = buildLookaheadFreeQuery(tradeKeys);
@@ -350,7 +346,10 @@ export function registerMarketDataTools(
           switch (segmentBy) {
             case "volRegime": {
               const val = getNum(marketData, "prev_Vol_Regime");
-              if (isNaN(val)) { lagExcluded++; continue; }
+              if (isNaN(val)) {
+                lagExcluded++;
+                continue;
+              }
               segmentValue = val;
               segmentKey = String(val);
               segmentLabel = getVolRegimeLabel(val);
@@ -358,7 +357,10 @@ export function registerMarketDataTools(
             }
             case "termStructure": {
               const val = getNum(marketData, "prev_Term_Structure_State");
-              if (isNaN(val)) { lagExcluded++; continue; }
+              if (isNaN(val)) {
+                lagExcluded++;
+                continue;
+              }
               segmentValue = val;
               segmentKey = String(val);
               segmentLabel = getTermStructureLabel(val);
@@ -371,7 +373,10 @@ export function registerMarketDataTools(
               break;
             case "gapDirection": {
               const gapPct = getNum(marketData, "Gap_Pct");
-              if (isNaN(gapPct)) { lagExcluded++; continue; }
+              if (isNaN(gapPct)) {
+                lagExcluded++;
+                continue;
+              }
               segmentValue = gapPct > 0.1 ? "up" : gapPct < -0.1 ? "down" : "flat";
               segmentKey = segmentValue;
               segmentLabel = `Gap ${segmentValue}`;
@@ -419,16 +424,19 @@ export function registerMarketDataTools(
 
             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 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 profitFactor =
+              grossLosses > 0 ? grossWins / grossLosses : grossWins > 0 ? null : 0;
 
             return {
               segment: seg.segment,
@@ -494,7 +502,7 @@ export function registerMarketDataTools(
           isError: true,
         };
       }
-    })
+    }),
   );
 
   // ---------------------------------------------------------------------------
@@ -512,371 +520,606 @@ export function registerMarketDataTools(
       inputSchema: z.object({
         blockId: z.string().describe("Block ID to analyze"),
         strategy: z.string().optional().describe("Filter to specific strategy"),
-        strategyName: z.string().optional().describe("Strategy profile name. When provided, auto-filters to that strategy's trades and cross-references suggestions against profile's entry_filters."),
-        minImprovementPct: z.number().optional().describe("Only suggest filters with >= X% win rate improvement (default: 3)"),
+        strategyName: z
+          .string()
+          .optional()
+          .describe(
+            "Strategy profile name. When provided, auto-filters to that strategy's trades and cross-references suggestions against profile's entry_filters.",
+          ),
+        minImprovementPct: z
+          .number()
+          .optional()
+          .describe("Only suggest filters with >= X% win rate improvement (default: 3)"),
         ticker: z.string().optional().describe("Underlying ticker symbol (default: SPX)"),
       }),
     },
-    withFullSync(baseDir, async ({ blockId, strategy, strategyName, minImprovementPct = 3, ticker }) => {
-      try {
-        const block = await loadBlock(baseDir, blockId);
-        let trades = block.trades;
-
-        // If strategyName provided, use it to filter trades (takes precedence over strategy)
-        const effectiveStrategy = strategyName || strategy;
-        if (effectiveStrategy) {
-          trades = filterByStrategy(trades, effectiveStrategy);
-          // Single-strategy fallback: profile strategyName may differ from CSV strategy label
-          if (trades.length === 0 && block.trades.length > 0) {
-            const uniqueStrategies = new Set(block.trades.map((t) => t.strategy));
-            if (uniqueStrategies.size === 1) {
-              trades = block.trades;
+    withFullSync(
+      baseDir,
+      async ({ blockId, strategy, strategyName, minImprovementPct = 3, ticker }) => {
+        try {
+          const block = await loadBlock(baseDir, blockId);
+          let trades = block.trades;
+
+          // If strategyName provided, use it to filter trades (takes precedence over strategy)
+          const effectiveStrategy = strategyName || strategy;
+          if (effectiveStrategy) {
+            trades = filterByStrategy(trades, effectiveStrategy);
+            // Single-strategy fallback: profile strategyName may differ from CSV strategy label
+            if (trades.length === 0 && block.trades.length > 0) {
+              const uniqueStrategies = new Set(block.trades.map((t) => t.strategy));
+              if (uniqueStrategies.size === 1) {
+                trades = block.trades;
+              }
             }
           }
-        }
 
-        // Load profile for cross-referencing if strategyName provided
-        let profileEntryFilters: Array<{ field: string; operator: string; value: unknown; description?: string }> | null = null;
-        if (strategyName) {
-          const conn = await getConnection(baseDir);
-          const profile = await getProfile(conn, blockId, strategyName, baseDir);
-          if (profile) {
-            profileEntryFilters = profile.entryFilters;
+          // Load profile for cross-referencing if strategyName provided
+          let profileEntryFilters: Array<{
+            field: string;
+            operator: string;
+            value: unknown;
+            description?: string;
+          }> | null = null;
+          if (strategyName) {
+            const conn = await getConnection(baseDir);
+            const profile = await getProfile(conn, blockId, strategyName, baseDir);
+            if (profile) {
+              profileEntryFilters = profile.entryFilters;
+            }
           }
-        }
 
-        // Note: strategy filtering is now handled above via effectiveStrategy
+          // Note: strategy filtering is now handled above via effectiveStrategy
 
-        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,
+            };
+          }
 
-        // 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 resolvedTickerSF = normalizeTicker(ticker || '') || DEFAULT_MARKET_TICKER;
-        const availabilitySF = await checkDataAvailability(stores, resolvedTickerSF);
+          // Check data availability and collect warnings
+          const resolvedTickerSF = normalizeTicker(ticker || "") || DEFAULT_MARKET_TICKER;
+          const availabilitySF = await checkDataAvailability(stores, resolvedTickerSF);
 
-        const { sql, params } = buildLookaheadFreeQuery(tradeKeys);
-        const dailyResult = await conn.runAndReadAll(sql, params);
-        const dailyRecords = resultToRecords(dailyResult);
-        const daily = recordsByTickerDate(dailyRecords);
+          const { sql, params } = buildLookaheadFreeQuery(tradeKeys);
+          const dailyResult = await conn.runAndReadAll(sql, params);
+          const dailyRecords = resultToRecords(dailyResult);
+          const daily = recordsByTickerDate(dailyRecords);
 
-        // Match trades to market data
-        interface EnrichedTrade {
-          trade: Trade;
-          market: Record<string, unknown> | null;
-        }
+          // Match trades to market data
+          interface EnrichedTrade {
+            trade: Trade;
+            market: Record<string, unknown> | null;
+          }
 
-        const enrichedTrades: EnrichedTrade[] = trades.map((trade) => {
-          const lookup = getTradeLookupKey(trade);
-          return {
-            trade,
-            market:
-              daily.get(marketTickerDateKey(lookup.ticker, lookup.date)) || null,
-          };
-        });
+          const enrichedTrades: EnrichedTrade[] = trades.map((trade) => {
+            const lookup = getTradeLookupKey(trade);
+            return {
+              trade,
+              market: daily.get(marketTickerDateKey(lookup.ticker, lookup.date)) || null,
+            };
+          });
 
-        const matchedTrades = enrichedTrades.filter((t) => t.market !== null);
+          const matchedTrades = enrichedTrades.filter((t) => t.market !== null);
 
-        if (matchedTrades.length < 10) {
-          return {
-            content: [{ type: "text", text: "Not enough trades matched to market data for analysis (need at least 10)" }],
-            isError: true,
-          };
-        }
+          if (matchedTrades.length < 10) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "Not enough trades matched to market data for analysis (need at least 10)",
+                },
+              ],
+              isError: true,
+            };
+          }
 
-        // Calculate current stats
-        const currentWins = matchedTrades.filter((t) => t.trade.pl > 0).length;
-        const currentWinRate = (currentWins / matchedTrades.length) * 100;
-        const currentTotalPl = matchedTrades.reduce((sum, t) => sum + t.trade.pl, 0);
+          // Calculate current stats
+          const currentWins = matchedTrades.filter((t) => t.trade.pl > 0).length;
+          const currentWinRate = (currentWins / matchedTrades.length) * 100;
+          const currentTotalPl = matchedTrades.reduce((sum, t) => sum + t.trade.pl, 0);
+
+          // Test various filters
+          interface FilterSuggestion {
+            filter: string;
+            condition: {
+              field: string;
+              operator: string;
+              value: number | number[] | string;
+              lagged: boolean;
+            };
+            tradesRemoved: number;
+            winnersRemoved: number;
+            losersRemoved: number;
+            newWinRate: number;
+            newTotalPl: number;
+            winRateDelta: number;
+            plDelta: number;
+            confidence: "high" | "medium" | "low";
+          }
 
-        // Test various filters
-        interface FilterSuggestion {
-          filter: string;
-          condition: {
+          const suggestions: FilterSuggestion[] = [];
+
+          // Test filter functions
+          const testFilters: Array<{
+            name: string;
             field: string;
             operator: string;
             value: number | number[] | string;
+            test: (m: Record<string, unknown>) => boolean;
             lagged: boolean;
-          };
-          tradesRemoved: number;
-          winnersRemoved: number;
-          losersRemoved: number;
-          newWinRate: number;
-          newTotalPl: number;
-          winRateDelta: number;
-          plDelta: number;
-          confidence: "high" | "medium" | "low";
-        }
+          }> = [
+            // Open-known filters (same-day values)
+            // Gap filters
+            {
+              name: "Skip when |Gap_Pct| > 0.5%",
+              field: "Gap_Pct",
+              operator: ">",
+              value: 0.5,
+              test: (m) => Math.abs(getNum(m, "Gap_Pct")) > 0.5,
+              lagged: false,
+            },
+            {
+              name: "Skip when |Gap_Pct| > 0.8%",
+              field: "Gap_Pct",
+              operator: ">",
+              value: 0.8,
+              test: (m) => Math.abs(getNum(m, "Gap_Pct")) > 0.8,
+              lagged: false,
+            },
+            {
+              name: "Skip when |Gap_Pct| > 1.0%",
+              field: "Gap_Pct",
+              operator: ">",
+              value: 1.0,
+              test: (m) => Math.abs(getNum(m, "Gap_Pct")) > 1.0,
+              lagged: false,
+            },
+            // Day of week
+            {
+              name: "Skip Fridays",
+              field: "Day_of_Week",
+              operator: "==",
+              value: 6,
+              test: (m) => getNum(m, "Day_of_Week") === 6,
+              lagged: false,
+            },
+            {
+              name: "Skip Mondays",
+              field: "Day_of_Week",
+              operator: "==",
+              value: 2,
+              test: (m) => getNum(m, "Day_of_Week") === 2,
+              lagged: false,
+            },
+            // OPEX
+            {
+              name: "Skip OPEX days",
+              field: "Is_Opex",
+              operator: "==",
+              value: 1,
+              test: (m) => getNum(m, "Is_Opex") === 1,
+              lagged: false,
+            },
+            // VIX_Open filters (open-known)
+            {
+              name: "Skip when VIX_Open > 25",
+              field: "VIX_Open",
+              operator: ">",
+              value: 25,
+              test: (m) => getNum(m, "VIX_Open") > 25,
+              lagged: false,
+            },
+            {
+              name: "Skip when VIX_Open > 30",
+              field: "VIX_Open",
+              operator: ">",
+              value: 30,
+              test: (m) => getNum(m, "VIX_Open") > 30,
+              lagged: false,
+            },
+            // VIX_Gap_Pct filters (open-known)
+            {
+              name: "Skip when |VIX_Gap_Pct| > 10%",
+              field: "VIX_Gap_Pct",
+              operator: ">",
+              value: 10,
+              test: (m) => Math.abs(getNum(m, "VIX_Gap_Pct")) > 10,
+              lagged: false,
+            },
+            {
+              name: "Skip when |VIX_Gap_Pct| > 15%",
+              field: "VIX_Gap_Pct",
+              operator: ">",
+              value: 15,
+              test: (m) => Math.abs(getNum(m, "VIX_Gap_Pct")) > 15,
+              lagged: false,
+            },
+
+            // Close-derived filters (prior trading day values via LAG CTE)
+            // VIX (close-derived)
+            {
+              name: "Skip when prior-day VIX > 25",
+              field: "VIX_Close",
+              operator: ">",
+              value: 25,
+              test: (m) => getNum(m, "prev_VIX_Close") > 25,
+              lagged: true,
+            },
+            {
+              name: "Skip when prior-day VIX > 30",
+              field: "VIX_Close",
+              operator: ">",
+              value: 30,
+              test: (m) => getNum(m, "prev_VIX_Close") > 30,
+              lagged: true,
+            },
+            {
+              name: "Skip when prior-day VIX < 14",
+              field: "VIX_Close",
+              operator: "<",
+              value: 14,
+              test: (m) => getNum(m, "prev_VIX_Close") < 14,
+              lagged: true,
+            },
+            // VIX spike (close-derived)
+            {
+              name: "Skip when prior-day VIX_Spike > 5%",
+              field: "VIX_Spike_Pct",
+              operator: ">",
+              value: 5,
+              test: (m) => getNum(m, "prev_VIX_Spike_Pct") > 5,
+              lagged: true,
+            },
+            {
+              name: "Skip when prior-day VIX_Spike > 8%",
+              field: "VIX_Spike_Pct",
+              operator: ">",
+              value: 8,
+              test: (m) => getNum(m, "prev_VIX_Spike_Pct") > 8,
+              lagged: true,
+            },
+            // Term structure (close-derived)
+            {
+              name: "Skip prior-day backwardation",
+              field: "Term_Structure_State",
+              operator: "==",
+              value: -1,
+              test: (m) => getNum(m, "prev_Term_Structure_State") === -1,
+              lagged: true,
+            },
+            // Vol regime (close-derived)
+            {
+              name: "Skip prior-day Vol Regime 5-6 (High/Extreme)",
+              field: "Vol_Regime",
+              operator: "in",
+              value: [5, 6],
+              test: (m) => getNum(m, "prev_Vol_Regime") >= 5,
+              lagged: true,
+            },
+            {
+              name: "Skip prior-day Vol Regime 1 (Very Low)",
+              field: "Vol_Regime",
+              operator: "==",
+              value: 1,
+              test: (m) => getNum(m, "prev_Vol_Regime") === 1,
+              lagged: true,
+            },
+            // Consecutive days (close-derived)
+            {
+              name: "Skip after prior-day 4+ consecutive up",
+              field: "Consecutive_Days",
+              operator: ">=",
+              value: 4,
+              test: (m) => getNum(m, "prev_Consecutive_Days") >= 4,
+              lagged: true,
+            },
+            {
+              name: "Skip after prior-day 4+ consecutive down",
+              field: "Consecutive_Days",
+              operator: "<=",
+              value: -4,
+              test: (m) => getNum(m, "prev_Consecutive_Days") <= -4,
+              lagged: true,
+            },
+            // RSI (close-derived)
+            {
+              name: "Skip when prior-day RSI > 70",
+              field: "RSI_14",
+              operator: ">",
+              value: 70,
+              test: (m) => getNum(m, "prev_RSI_14") > 70,
+              lagged: true,
+            },
+            {
+              name: "Skip when prior-day RSI < 30",
+              field: "RSI_14",
+              operator: "<",
+              value: 30,
+              test: (m) => getNum(m, "prev_RSI_14") < 30,
+              lagged: true,
+            },
+
+            // Realized Vol filters (close-derived, from market.enriched)
+            {
+              name: "Skip when prior-day 5D realized vol > 1.5%",
+              field: "Realized_Vol_5D",
+              operator: ">",
+              value: 1.5,
+              test: (m) => getNum(m, "prev_Realized_Vol_5D") > 1.5,
+              lagged: true,
+            },
+            {
+              name: "Skip when prior-day 20D realized vol > 1.2%",
+              field: "Realized_Vol_20D",
+              operator: ">",
+              value: 1.2,
+              test: (m) => getNum(m, "prev_Realized_Vol_20D") > 1.2,
+              lagged: true,
+            },
+
+            // IVP filters (close-derived, from market.enriched ivr/ivp columns)
+            {
+              name: "Skip when prior-day VIX_IVP > 80 (top 20% historically elevated vol)",
+              field: "VIX_IVP",
+              operator: ">",
+              value: 80,
+              test: (m) => getNum(m, "prev_VIX_IVP") > 80,
+              lagged: true,
+            },
+            {
+              name: "Skip when prior-day VIX_IVP < 20 (bottom 20% historically suppressed vol)",
+              field: "VIX_IVP",
+              operator: "<",
+              value: 20,
+              test: (m) => getNum(m, "prev_VIX_IVP") < 20,
+              lagged: true,
+            },
+
+            // Prior_Range_vs_ATR filter (open-known, from market.enriched — same-day value)
+            {
+              name: "Skip when Prior_Range_vs_ATR > 1.5 (prior day had outsized range)",
+              field: "Prior_Range_vs_ATR",
+              operator: ">",
+              value: 1.5,
+              test: (m) => getNum(m, "Prior_Range_vs_ATR") > 1.5,
+              lagged: false,
+            },
+            {
+              name: "Skip when Prior_Range_vs_ATR < 0.5 (prior day had compressed range)",
+              field: "Prior_Range_vs_ATR",
+              operator: "<",
+              value: 0.5,
+              test: (m) => getNum(m, "Prior_Range_vs_ATR") < 0.5,
+              lagged: false,
+            },
+          ];
+
+          for (const filterDef of testFilters) {
+            // For lagged filters, exclude trades with NaN lag values from evaluation
+            // (prevents NaN comparisons from silently passing all tests and biasing results)
+            let pool = matchedTrades;
+            if (filterDef.lagged) {
+              const prevField = `prev_${filterDef.field}`;
+              pool = matchedTrades.filter((t) => {
+                const val = getNum(t.market as Record<string, unknown>, prevField);
+                return !isNaN(val);
+              });
+            }
 
-        const suggestions: FilterSuggestion[] = [];
-
-        // Test filter functions
-        const testFilters: Array<{
-          name: string;
-          field: string;
-          operator: string;
-          value: number | number[] | string;
-          test: (m: Record<string, unknown>) => boolean;
-          lagged: boolean;
-        }> = [
-          // Open-known filters (same-day values)
-          // Gap filters
-          { name: "Skip when |Gap_Pct| > 0.5%", field: "Gap_Pct", operator: ">", value: 0.5, test: (m) => Math.abs(getNum(m, "Gap_Pct")) > 0.5, lagged: false },
-          { name: "Skip when |Gap_Pct| > 0.8%", field: "Gap_Pct", operator: ">", value: 0.8, test: (m) => Math.abs(getNum(m, "Gap_Pct")) > 0.8, lagged: false },
-          { name: "Skip when |Gap_Pct| > 1.0%", field: "Gap_Pct", operator: ">", value: 1.0, test: (m) => Math.abs(getNum(m, "Gap_Pct")) > 1.0, lagged: false },
-          // Day of week
-          { name: "Skip Fridays", field: "Day_of_Week", operator: "==", value: 6, test: (m) => getNum(m, "Day_of_Week") === 6, lagged: false },
-          { name: "Skip Mondays", field: "Day_of_Week", operator: "==", value: 2, test: (m) => getNum(m, "Day_of_Week") === 2, lagged: false },
-          // OPEX
-          { name: "Skip OPEX days", field: "Is_Opex", operator: "==", value: 1, test: (m) => getNum(m, "Is_Opex") === 1, lagged: false },
-          // VIX_Open filters (open-known)
-          { name: "Skip when VIX_Open > 25", field: "VIX_Open", operator: ">", value: 25, test: (m) => getNum(m, "VIX_Open") > 25, lagged: false },
-          { name: "Skip when VIX_Open > 30", field: "VIX_Open", operator: ">", value: 30, test: (m) => getNum(m, "VIX_Open") > 30, lagged: false },
-          // VIX_Gap_Pct filters (open-known)
-          { name: "Skip when |VIX_Gap_Pct| > 10%", field: "VIX_Gap_Pct", operator: ">", value: 10, test: (m) => Math.abs(getNum(m, "VIX_Gap_Pct")) > 10, lagged: false },
-          { name: "Skip when |VIX_Gap_Pct| > 15%", field: "VIX_Gap_Pct", operator: ">", value: 15, test: (m) => Math.abs(getNum(m, "VIX_Gap_Pct")) > 15, lagged: false },
-
-          // Close-derived filters (prior trading day values via LAG CTE)
-          // VIX (close-derived)
-          { name: "Skip when prior-day VIX > 25", field: "VIX_Close", operator: ">", value: 25, test: (m) => getNum(m, "prev_VIX_Close") > 25, lagged: true },
-          { name: "Skip when prior-day VIX > 30", field: "VIX_Close", operator: ">", value: 30, test: (m) => getNum(m, "prev_VIX_Close") > 30, lagged: true },
-          { name: "Skip when prior-day VIX < 14", field: "VIX_Close", operator: "<", value: 14, test: (m) => getNum(m, "prev_VIX_Close") < 14, lagged: true },
-          // VIX spike (close-derived)
-          { name: "Skip when prior-day VIX_Spike > 5%", field: "VIX_Spike_Pct", operator: ">", value: 5, test: (m) => getNum(m, "prev_VIX_Spike_Pct") > 5, lagged: true },
-          { name: "Skip when prior-day VIX_Spike > 8%", field: "VIX_Spike_Pct", operator: ">", value: 8, test: (m) => getNum(m, "prev_VIX_Spike_Pct") > 8, lagged: true },
-          // Term structure (close-derived)
-          { name: "Skip prior-day backwardation", field: "Term_Structure_State", operator: "==", value: -1, test: (m) => getNum(m, "prev_Term_Structure_State") === -1, lagged: true },
-          // Vol regime (close-derived)
-          { name: "Skip prior-day Vol Regime 5-6 (High/Extreme)", field: "Vol_Regime", operator: "in", value: [5, 6], test: (m) => getNum(m, "prev_Vol_Regime") >= 5, lagged: true },
-          { name: "Skip prior-day Vol Regime 1 (Very Low)", field: "Vol_Regime", operator: "==", value: 1, test: (m) => getNum(m, "prev_Vol_Regime") === 1, lagged: true },
-          // Consecutive days (close-derived)
-          { name: "Skip after prior-day 4+ consecutive up", field: "Consecutive_Days", operator: ">=", value: 4, test: (m) => getNum(m, "prev_Consecutive_Days") >= 4, lagged: true },
-          { name: "Skip after prior-day 4+ consecutive down", field: "Consecutive_Days", operator: "<=", value: -4, test: (m) => getNum(m, "prev_Consecutive_Days") <= -4, lagged: true },
-          // RSI (close-derived)
-          { name: "Skip when prior-day RSI > 70", field: "RSI_14", operator: ">", value: 70, test: (m) => getNum(m, "prev_RSI_14") > 70, lagged: true },
-          { name: "Skip when prior-day RSI < 30", field: "RSI_14", operator: "<", value: 30, test: (m) => getNum(m, "prev_RSI_14") < 30, lagged: true },
-
-          // Realized Vol filters (close-derived, from market.enriched)
-          { name: "Skip when prior-day 5D realized vol > 1.5%", field: "Realized_Vol_5D", operator: ">", value: 1.5, test: (m) => getNum(m, "prev_Realized_Vol_5D") > 1.5, lagged: true },
-          { name: "Skip when prior-day 20D realized vol > 1.2%", field: "Realized_Vol_20D", operator: ">", value: 1.2, test: (m) => getNum(m, "prev_Realized_Vol_20D") > 1.2, lagged: true },
-
-          // IVP filters (close-derived, from market.enriched ivr/ivp columns)
-          { name: "Skip when prior-day VIX_IVP > 80 (top 20% historically elevated vol)", field: "VIX_IVP", operator: ">", value: 80, test: (m) => getNum(m, "prev_VIX_IVP") > 80, lagged: true },
-          { name: "Skip when prior-day VIX_IVP < 20 (bottom 20% historically suppressed vol)", field: "VIX_IVP", operator: "<", value: 20, test: (m) => getNum(m, "prev_VIX_IVP") < 20, lagged: true },
-
-          // Prior_Range_vs_ATR filter (open-known, from market.enriched — same-day value)
-          { name: "Skip when Prior_Range_vs_ATR > 1.5 (prior day had outsized range)", field: "Prior_Range_vs_ATR", operator: ">", value: 1.5, test: (m) => getNum(m, "Prior_Range_vs_ATR") > 1.5, lagged: false },
-          { name: "Skip when Prior_Range_vs_ATR < 0.5 (prior day had compressed range)", field: "Prior_Range_vs_ATR", operator: "<", value: 0.5, test: (m) => getNum(m, "Prior_Range_vs_ATR") < 0.5, lagged: false },
-        ];
-
-        for (const filterDef of testFilters) {
-          // For lagged filters, exclude trades with NaN lag values from evaluation
-          // (prevents NaN comparisons from silently passing all tests and biasing results)
-          let pool = matchedTrades;
-          if (filterDef.lagged) {
-            const prevField = `prev_${filterDef.field}`;
-            pool = matchedTrades.filter((t) => {
-              const val = getNum(t.market as Record<string, unknown>, prevField);
-              return !isNaN(val);
-            });
-          }
+            if (pool.length < 10) continue;
 
-          if (pool.length < 10) continue;
+            // Identify trades that would be removed
+            const removed = pool.filter((t) => filterDef.test(t.market as Record<string, unknown>));
+            const remaining = pool.filter(
+              (t) => !filterDef.test(t.market as Record<string, unknown>),
+            );
 
-          // Identify trades that would be removed
-          const removed = pool.filter((t) => filterDef.test(t.market as Record<string, unknown>));
-          const remaining = pool.filter((t) => !filterDef.test(t.market as Record<string, unknown>));
+            if (removed.length === 0 || remaining.length < 5) continue;
 
-          if (removed.length === 0 || remaining.length < 5) continue;
+            const poolWins = pool.filter((t) => t.trade.pl > 0).length;
+            const poolWinRate = (poolWins / pool.length) * 100;
+            const poolTotalPl = pool.reduce((sum, t) => sum + t.trade.pl, 0);
 
-          const poolWins = pool.filter((t) => t.trade.pl > 0).length;
-          const poolWinRate = (poolWins / pool.length) * 100;
-          const poolTotalPl = pool.reduce((sum, t) => sum + t.trade.pl, 0);
+            const winnersRemoved = removed.filter((t) => t.trade.pl > 0).length;
+            const losersRemoved = removed.length - winnersRemoved;
 
-          const winnersRemoved = removed.filter((t) => t.trade.pl > 0).length;
-          const losersRemoved = removed.length - winnersRemoved;
+            const newWins = remaining.filter((t) => t.trade.pl > 0).length;
+            const newWinRate = (newWins / remaining.length) * 100;
+            const newTotalPl = remaining.reduce((sum, t) => sum + t.trade.pl, 0);
 
-          const newWins = remaining.filter((t) => t.trade.pl > 0).length;
-          const newWinRate = (newWins / remaining.length) * 100;
-          const newTotalPl = remaining.reduce((sum, t) => sum + t.trade.pl, 0);
+            const winRateDelta = newWinRate - poolWinRate;
+            const plDelta = newTotalPl - poolTotalPl;
 
-          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";
+              }
 
-          // 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";
+              suggestions.push({
+                filter: filterDef.name,
+                condition: {
+                  field: filterDef.field,
+                  operator: filterDef.operator,
+                  value: filterDef.value,
+                  lagged: filterDef.lagged,
+                },
+                tradesRemoved: removed.length,
+                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,
+              });
             }
-
-            suggestions.push({
-              filter: filterDef.name,
-              condition: {
-                field: filterDef.field,
-                operator: filterDef.operator,
-                value: filterDef.value,
-                lagged: filterDef.lagged,
-              },
-              tradesRemoved: removed.length,
-              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);
+          // Sort by win rate improvement
+          suggestions.sort((a, b) => b.winRateDelta - a.winRateDelta);
 
-        // Take top 10
-        const topSuggestions = suggestions.slice(0, 10);
+          // 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);
-
-        interface CompositeSuggestion {
-          name: string;
-          type: "composite";
-          projectedWinRate: number;
-          projectedAvgPl: number;
-          tradesAffected: number;
-          improvement: number;
-        }
+          // Generate composite filter suggestions from pairs of top-performing standalone filters
+          const baseWinRate = currentWinRate;
+          const significantFilters = suggestions.filter((s) => s.winRateDelta > 3);
 
-        const compositeSuggestions: CompositeSuggestion[] = [];
-
-        // Build a map from filter name to the original test function and lagged flag
-        const filterTestMap = new Map<string, { test: (m: Record<string, unknown>) => boolean; lagged: boolean; field: string }>();
-        for (const fd of testFilters) {
-          filterTestMap.set(fd.name, { test: fd.test, lagged: fd.lagged, field: fd.field });
-        }
-
-        for (let i = 0; i < significantFilters.length; i++) {
-          for (let j = i + 1; j < significantFilters.length; j++) {
-            const filterA = significantFilters[i];
-            const filterB = significantFilters[j];
+          interface CompositeSuggestion {
+            name: string;
+            type: "composite";
+            projectedWinRate: number;
+            projectedAvgPl: number;
+            tradesAffected: number;
+            improvement: number;
+          }
 
-            const testA = filterTestMap.get(filterA.filter);
-            const testB = filterTestMap.get(filterB.filter);
-            if (!testA || !testB) continue;
+          const compositeSuggestions: CompositeSuggestion[] = [];
 
-            // Build pool: exclude NaN-lag trades for lagged fields in either filter
-            let pool = matchedTrades;
-            if (testA.lagged) {
-              const prevField = `prev_${testA.field}`;
-              pool = pool.filter((t) => !isNaN(getNum(t.market as Record<string, unknown>, prevField)));
-            }
-            if (testB.lagged) {
-              const prevField = `prev_${testB.field}`;
-              pool = pool.filter((t) => !isNaN(getNum(t.market as Record<string, unknown>, prevField)));
-            }
+          // Build a map from filter name to the original test function and lagged flag
+          const filterTestMap = new Map<
+            string,
+            { test: (m: Record<string, unknown>) => boolean; lagged: boolean; field: string }
+          >();
+          for (const fd of testFilters) {
+            filterTestMap.set(fd.name, { test: fd.test, lagged: fd.lagged, field: fd.field });
+          }
 
-            // 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);
-            });
+          for (let i = 0; i < significantFilters.length; i++) {
+            for (let j = i + 1; j < significantFilters.length; j++) {
+              const filterA = significantFilters[i];
+              const filterB = significantFilters[j];
+
+              const testA = filterTestMap.get(filterA.filter);
+              const testB = filterTestMap.get(filterB.filter);
+              if (!testA || !testB) continue;
+
+              // Build pool: exclude NaN-lag trades for lagged fields in either filter
+              let pool = matchedTrades;
+              if (testA.lagged) {
+                const prevField = `prev_${testA.field}`;
+                pool = pool.filter(
+                  (t) => !isNaN(getNum(t.market as Record<string, unknown>, prevField)),
+                );
+              }
+              if (testB.lagged) {
+                const prevField = `prev_${testB.field}`;
+                pool = pool.filter(
+                  (t) => !isNaN(getNum(t.market as Record<string, unknown>, prevField)),
+                );
+              }
 
-            if (bothMatchTrades.length < 5) 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) {
-              compositeSuggestions.push({
-                name: `${filterA.filter} AND ${filterB.filter}`,
-                type: "composite",
-                projectedWinRate: Math.round(compositeWinRate * 100) / 100,
-                projectedAvgPl: Math.round(compositeAvgPl * 100) / 100,
-                tradesAffected: bothMatchTrades.length,
-                improvement: Math.round(improvement * 100) / 100,
+              // 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;
+
+              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) {
+                compositeSuggestions.push({
+                  name: `${filterA.filter} AND ${filterB.filter}`,
+                  type: "composite",
+                  projectedWinRate: Math.round(compositeWinRate * 100) / 100,
+                  projectedAvgPl: Math.round(compositeAvgPl * 100) / 100,
+                  tradesAffected: bothMatchTrades.length,
+                  improvement: Math.round(improvement * 100) / 100,
+                });
+              }
             }
           }
-        }
-
-        // Sort composites by improvement, take top 5
-        compositeSuggestions.sort((a, b) => b.improvement - a.improvement);
-        const topCompositeSuggestions = compositeSuggestions.slice(0, 5);
 
-        const summary = `Filter analysis: ${blockId} | ${topSuggestions.length} standalone, ${topCompositeSuggestions.length} composite suggestions (min ${minImprovementPct}% improvement)`;
-
-        const sfResponseData: Record<string, unknown> = {
-          blockId,
-          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,
-          strategyName: strategyName || null,
-          currentStats: {
-            trades: matchedTrades.length,
-            winRate: Math.round(currentWinRate * 100) / 100,
-            totalPl: Math.round(currentTotalPl * 100) / 100,
-          },
-          suggestedFilters: topSuggestions,
-          compositeSuggestions: topCompositeSuggestions,
-          minImprovementThreshold: minImprovementPct,
-        };
+          // Sort composites by improvement, take top 5
+          compositeSuggestions.sort((a, b) => b.improvement - a.improvement);
+          const topCompositeSuggestions = compositeSuggestions.slice(0, 5);
+
+          const summary = `Filter analysis: ${blockId} | ${topSuggestions.length} standalone, ${topCompositeSuggestions.length} composite suggestions (min ${minImprovementPct}% improvement)`;
+
+          const sfResponseData: Record<string, unknown> = {
+            blockId,
+            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,
+            strategyName: strategyName || null,
+            currentStats: {
+              trades: matchedTrades.length,
+              winRate: Math.round(currentWinRate * 100) / 100,
+              totalPl: Math.round(currentTotalPl * 100) / 100,
+            },
+            suggestedFilters: topSuggestions,
+            compositeSuggestions: topCompositeSuggestions,
+            minImprovementThreshold: minImprovementPct,
+          };
 
-        if (availabilitySF.warnings.length > 0) {
-          sfResponseData.warnings = availabilitySF.warnings;
-        }
+          if (availabilitySF.warnings.length > 0) {
+            sfResponseData.warnings = availabilitySF.warnings;
+          }
 
-        // Cross-reference suggestions with profile entry_filters when strategyName provided
-        if (profileEntryFilters && profileEntryFilters.length > 0) {
-          const profileContext: Array<{
-            suggestion: string;
-            field: string;
-            status: "already_in_profile" | "new_suggestion";
-            matchedFilter?: { field: string; operator: string; value: unknown };
-          }> = [];
+          // Cross-reference suggestions with profile entry_filters when strategyName provided
+          if (profileEntryFilters && profileEntryFilters.length > 0) {
+            const profileContext: Array<{
+              suggestion: string;
+              field: string;
+              status: "already_in_profile" | "new_suggestion";
+              matchedFilter?: { field: string; operator: string; value: unknown };
+            }> = [];
+
+            for (const suggestion of topSuggestions) {
+              const matchedFilter = profileEntryFilters.find(
+                (f) => f.field === suggestion.condition.field,
+              );
+              profileContext.push({
+                suggestion: suggestion.filter,
+                field: suggestion.condition.field,
+                status: matchedFilter ? "already_in_profile" : "new_suggestion",
+                matchedFilter: matchedFilter
+                  ? {
+                      field: matchedFilter.field,
+                      operator: matchedFilter.operator,
+                      value: matchedFilter.value,
+                    }
+                  : undefined,
+              });
+            }
 
-          for (const suggestion of topSuggestions) {
-            const matchedFilter = profileEntryFilters.find(
-              (f) => f.field === suggestion.condition.field
-            );
-            profileContext.push({
-              suggestion: suggestion.filter,
-              field: suggestion.condition.field,
-              status: matchedFilter ? "already_in_profile" : "new_suggestion",
-              matchedFilter: matchedFilter
-                ? { field: matchedFilter.field, operator: matchedFilter.operator, value: matchedFilter.value }
-                : undefined,
-            });
+            sfResponseData.profile_context = {
+              strategyName,
+              existingFilters: profileEntryFilters.length,
+              crossReference: profileContext,
+            };
           }
 
-          sfResponseData.profile_context = {
-            strategyName,
-            existingFilters: profileEntryFilters.length,
-            crossReference: profileContext,
+          return createToolOutput(summary, sfResponseData);
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error: ${(error as Error).message}` }],
+            isError: true,
           };
         }
-
-        return createToolOutput(summary, sfResponseData);
-      } catch (error) {
-        return {
-          content: [{ type: "text", text: `Error: ${(error as Error).message}` }],
-          isError: true,
-        };
-      }
-    })
+      },
+    ),
   );
 
   // ---------------------------------------------------------------------------
@@ -899,239 +1142,278 @@ export function registerMarketDataTools(
         startDate: z.string().optional().describe("Start date filter (YYYY-MM-DD)"),
         endDate: z.string().optional().describe("End date filter (YYYY-MM-DD)"),
         ticker: z.string().optional().describe("Underlying ticker symbol (default: SPX)"),
-        includeOutcomeFields: z.boolean().default(false).describe("Include same-day close values (lookahead). Defaults to false for safety."),
-        includeIntradayContext: z.boolean().default(false).describe(
-          "Include raw intraday bars from market.spot (intradayBars array with time/open/high/low/close per bar). Requires 1 additional DuckDB query."
-        ),
-        limit: z.number().min(1).max(500).default(50).describe("Max trades to return (default: 50, max: 500)"),
+        includeOutcomeFields: z
+          .boolean()
+          .default(false)
+          .describe("Include same-day close values (lookahead). Defaults to false for safety."),
+        includeIntradayContext: z
+          .boolean()
+          .default(false)
+          .describe(
+            "Include raw intraday bars from market.spot (intradayBars array with time/open/high/low/close per bar). Requires 1 additional DuckDB query.",
+          ),
+        limit: z
+          .number()
+          .min(1)
+          .max(500)
+          .default(50)
+          .describe("Max trades to return (default: 50, max: 500)"),
         offset: z.number().min(0).default(0).describe("Pagination offset (default: 0)"),
       }),
     },
-    withFullSync(baseDir, async ({ blockId, strategy, startDate, endDate, ticker, includeOutcomeFields, includeIntradayContext, limit, offset }) => {
-      try {
-        const block = await loadBlock(baseDir, blockId);
-        let trades = block.trades;
+    withFullSync(
+      baseDir,
+      async ({
+        blockId,
+        strategy,
+        startDate,
+        endDate,
+        ticker,
+        includeOutcomeFields,
+        includeIntradayContext,
+        limit,
+        offset,
+      }) => {
+        try {
+          const block = await loadBlock(baseDir, blockId);
+          let trades = block.trades;
+
+          // Filter before paginate
+          trades = filterByStrategy(trades, strategy);
+          trades = filterByDateRange(trades, startDate, endDate);
+
+          if (trades.length === 0) {
+            return {
+              content: [{ type: "text", text: "No trades found matching filters" }],
+              isError: true,
+            };
+          }
 
-        // Filter before paginate
-        trades = filterByStrategy(trades, strategy);
-        trades = filterByDateRange(trades, startDate, endDate);
+          const totalTrades = trades.length;
+          const paginated = trades.slice(offset, offset + limit);
+
+          // Short-circuit if offset is past the end (empty page)
+          if (paginated.length === 0) {
+            return createToolOutput(
+              `Enriched trades: ${blockId} | 0/0 matched | offset ${offset}, limit ${limit}`,
+              {
+                blockId,
+                strategy: strategy || null,
+                lagNote: "",
+                tradesTotal: totalTrades,
+                returned: 0,
+                offset,
+                hasMore: false,
+                tradesMatched: 0,
+                unmatchedDates: [],
+                trades: [],
+              },
+            );
+          }
 
-        if (trades.length === 0) {
-          return {
-            content: [{ type: "text", text: "No trades found matching filters" }],
-            isError: true,
-          };
-        }
+          // Collect unique ticker+date keys from paginated trades only.
+          const tradeKeys = uniqueTradeLookupKeys(paginated);
 
-        const totalTrades = trades.length;
-        const paginated = trades.slice(offset, offset + limit);
+          // Query DuckDB for lookahead-free market data
+          const conn = await getConnection(baseDir);
 
-        // Short-circuit if offset is past the end (empty page)
-        if (paginated.length === 0) {
-          return createToolOutput(
-            `Enriched trades: ${blockId} | 0/0 matched | offset ${offset}, limit ${limit}`,
-            {
-              blockId,
-              strategy: strategy || null,
-              lagNote: "",
-              tradesTotal: totalTrades,
-              returned: 0,
-              offset,
-              hasMore: false,
-              tradesMatched: 0,
-              unmatchedDates: [],
-              trades: [],
-            }
-          );
-        }
+          // Check data availability and collect warnings
+          const resolvedTickerET = normalizeTicker(ticker || "") || DEFAULT_MARKET_TICKER;
+          const availabilityET = await checkDataAvailability(stores, resolvedTickerET, {
+            checkIntraday: includeIntradayContext,
+          });
 
-        // Collect unique ticker+date keys from paginated trades only.
-        const tradeKeys = uniqueTradeLookupKeys(paginated);
+          const { sql: lagSql, params: lagParams } = buildLookaheadFreeQuery(tradeKeys);
+          const dailyResult = await conn.runAndReadAll(lagSql, lagParams);
+          const dailyRecords = resultToRecords(dailyResult);
+          const daily = recordsByTickerDate(dailyRecords);
+
+          // Optionally query outcome (same-day close) data
+          let outcomeMap: Map<string, Record<string, unknown>> | null = null;
+          if (includeOutcomeFields) {
+            const { sql: outcomeSql, params: outcomeParams } = buildOutcomeQuery(tradeKeys);
+            const outcomeResult = await conn.runAndReadAll(outcomeSql, outcomeParams);
+            const outcomeRecords = resultToRecords(outcomeResult);
+            outcomeMap = recordsByTickerDate(outcomeRecords);
+          }
 
-        // Query DuckDB for lookahead-free market data
-        const conn = await getConnection(baseDir);
+          // Optionally query intraday bar data
+          let intradayBarsByKey: Map<
+            string,
+            Array<{ time: string; open: number; high: number; low: number; close: number }>
+          > | null = null;
+
+          if (includeIntradayContext) {
+            // Read intraday bars per (ticker, date) via SpotStore. The store
+            // returns BarRow[] in (date, time) order; we group by ticker+date
+            // so the downstream consumer can index by trade key.
+            intradayBarsByKey = new Map<
+              string,
+              Array<{ time: string; open: number; high: number; low: number; close: number }>
+            >();
+            for (const key of tradeKeys) {
+              const bars = await stores.spot.readBars(key.ticker, key.date, key.date);
+              if (bars.length === 0) continue;
+              const mapKey = marketTickerDateKey(key.ticker, key.date);
+              const list = intradayBarsByKey.get(mapKey) ?? [];
+              for (const bar of bars) {
+                // Defense-in-depth: skip underlying bars with zero/null OHLC
+                // (provider gaps from the spot ingest). Raw bars are left
+                // unfiltered upstream so option tickers can keep legitimate
+                // "no trade" zeros; underlyings always have a real price, so
+                // a zero is a bug that would corrupt downstream high/low/range
+                // computations.
+                if (
+                  !Number.isFinite(bar.open) ||
+                  bar.open <= 0 ||
+                  !Number.isFinite(bar.high) ||
+                  bar.high <= 0 ||
+                  !Number.isFinite(bar.low) ||
+                  bar.low <= 0 ||
+                  !Number.isFinite(bar.close) ||
+                  bar.close <= 0
+                )
+                  continue;
+                list.push({
+                  time: String(bar.time),
+                  open: Number(bar.open),
+                  high: Number(bar.high),
+                  low: Number(bar.low),
+                  close: Number(bar.close),
+                });
+              }
+              intradayBarsByKey.set(mapKey, list);
+            }
+          }
 
-        // Check data availability and collect warnings
-        const resolvedTickerET = normalizeTicker(ticker || '') || DEFAULT_MARKET_TICKER;
-        const availabilityET = await checkDataAvailability(stores, resolvedTickerET, { checkIntraday: includeIntradayContext });
+          // Helper: clean numeric value (BigInt -> Number, NaN -> null)
+          const cleanVal = (val: unknown): unknown => {
+            if (typeof val === "bigint") return Number(val);
+            if (typeof val === "number" && isNaN(val)) return null;
+            return val === undefined ? null : val;
+          };
 
-        const { sql: lagSql, params: lagParams } = buildLookaheadFreeQuery(tradeKeys);
-        const dailyResult = await conn.runAndReadAll(lagSql, lagParams);
-        const dailyRecords = resultToRecords(dailyResult);
-        const daily = recordsByTickerDate(dailyRecords);
+          // Build enriched trades
+          const unmatchedDates: string[] = [];
+          let matched = 0;
+
+          const enrichedTrades = paginated.map((trade) => {
+            const lookup = getTradeLookupKey(trade);
+            const marketKey = marketTickerDateKey(lookup.ticker, lookup.date);
+            const marketData = daily.get(marketKey);
+
+            const commissions = trade.openingCommissionsFees + trade.closingCommissionsFees;
+
+            const baseTrade: Record<string, unknown> = {
+              dateOpened: lookup.date,
+              ticker: lookup.ticker,
+              timeOpened: trade.timeOpened,
+              strategy: trade.strategy,
+              legs: trade.legs,
+              pl: trade.pl,
+              numContracts: trade.numContracts,
+              premium: trade.premium,
+              reasonForClose: trade.reasonForClose || null,
+              commissions,
+            };
 
-        // Optionally query outcome (same-day close) data
-        let outcomeMap: Map<string, Record<string, unknown>> | null = null;
-        if (includeOutcomeFields) {
-          const { sql: outcomeSql, params: outcomeParams } = buildOutcomeQuery(tradeKeys);
-          const outcomeResult = await conn.runAndReadAll(outcomeSql, outcomeParams);
-          const outcomeRecords = resultToRecords(outcomeResult);
-          outcomeMap = recordsByTickerDate(outcomeRecords);
-        }
+            if (!marketData) {
+              unmatchedDates.push(`${lookup.date}|${lookup.ticker}`);
+              baseTrade.entryContext = null;
+              return baseTrade;
+            }
 
-        // Optionally query intraday bar data
-        let intradayBarsByKey: Map<string, Array<{time: string, open: number, high: number, low: number, close: number}>> | null = null;
-
-        if (includeIntradayContext) {
-          // Read intraday bars per (ticker, date) via SpotStore. The store
-          // returns BarRow[] in (date, time) order; we group by ticker+date
-          // so the downstream consumer can index by trade key.
-          intradayBarsByKey = new Map<string, Array<{time: string, open: number, high: number, low: number, close: number}>>();
-          for (const key of tradeKeys) {
-            const bars = await stores.spot.readBars(key.ticker, key.date, key.date);
-            if (bars.length === 0) continue;
-            const mapKey = marketTickerDateKey(key.ticker, key.date);
-            const list = intradayBarsByKey.get(mapKey) ?? [];
-            for (const bar of bars) {
-              // Defense-in-depth: skip underlying bars with zero/null OHLC
-              // (provider gaps from the spot ingest). Raw bars are left
-              // unfiltered upstream so option tickers can keep legitimate
-              // "no trade" zeros; underlyings always have a real price, so
-              // a zero is a bug that would corrupt downstream high/low/range
-              // computations.
-              if (
-                !Number.isFinite(bar.open)  || bar.open  <= 0 ||
-                !Number.isFinite(bar.high)  || bar.high  <= 0 ||
-                !Number.isFinite(bar.low)   || bar.low   <= 0 ||
-                !Number.isFinite(bar.close) || bar.close <= 0
-              ) continue;
-              list.push({
-                time: String(bar.time),
-                open: Number(bar.open),
-                high: Number(bar.high),
-                low: Number(bar.low),
-                close: Number(bar.close),
-              });
+            matched++;
+
+            // Build sameDay: open-known + static fields
+            const sameDay: Record<string, unknown> = {};
+            for (const field of OPEN_KNOWN_FIELDS) {
+              sameDay[field] = cleanVal(marketData[field]);
+            }
+            for (const field of STATIC_FIELDS) {
+              sameDay[field] = cleanVal(marketData[field]);
             }
-            intradayBarsByKey.set(mapKey, list);
-          }
-        }
 
-        // Helper: clean numeric value (BigInt -> Number, NaN -> null)
-        const cleanVal = (val: unknown): unknown => {
-          if (typeof val === "bigint") return Number(val);
-          if (typeof val === "number" && isNaN(val)) return null;
-          return val === undefined ? null : val;
-        };
+            // Build priorDay: close-derived fields (read prev_* columns)
+            const priorDay: Record<string, unknown> = {};
+            for (const field of CLOSE_KNOWN_FIELDS) {
+              priorDay[field] = cleanVal(marketData[`prev_${field}`]);
+            }
 
-        // Build enriched trades
-        const unmatchedDates: string[] = [];
-        let matched = 0;
+            baseTrade.entryContext = { sameDay, priorDay };
+
+            // Outcome fields (opt-in, same-day close values)
+            if (includeOutcomeFields && outcomeMap) {
+              const outcomeData = outcomeMap.get(marketKey);
+              if (outcomeData) {
+                const outcomeFields: Record<string, unknown> = {};
+                for (const field of CLOSE_KNOWN_FIELDS) {
+                  outcomeFields[field] = cleanVal(outcomeData[field]);
+                }
+                baseTrade.outcomeFields = outcomeFields;
+              }
+            }
 
-        const enrichedTrades = paginated.map(trade => {
-          const lookup = getTradeLookupKey(trade);
-          const marketKey = marketTickerDateKey(lookup.ticker, lookup.date);
-          const marketData = daily.get(marketKey);
-
-          const commissions = trade.openingCommissionsFees + trade.closingCommissionsFees;
-
-          const baseTrade: Record<string, unknown> = {
-            dateOpened: lookup.date,
-            ticker: lookup.ticker,
-            timeOpened: trade.timeOpened,
-            strategy: trade.strategy,
-            legs: trade.legs,
-            pl: trade.pl,
-            numContracts: trade.numContracts,
-            premium: trade.premium,
-            reasonForClose: trade.reasonForClose || null,
-            commissions,
-          };
+            // Intraday bars (opt-in, raw bar arrays per ticker+date)
+            if (includeIntradayContext && intradayBarsByKey) {
+              const bars = intradayBarsByKey.get(marketKey) || null;
+              baseTrade.intradayBars = bars;
+            }
 
-          if (!marketData) {
-            unmatchedDates.push(`${lookup.date}|${lookup.ticker}`);
-            baseTrade.entryContext = null;
             return baseTrade;
-          }
-
-          matched++;
+          });
 
-          // Build sameDay: open-known + static fields
-          const sameDay: Record<string, unknown> = {};
-          for (const field of OPEN_KNOWN_FIELDS) {
-            sameDay[field] = cleanVal(marketData[field]);
+          const sortedUnmatchedDates = [...new Set(unmatchedDates)].sort();
+
+          // Build lagNote
+          let lagNote =
+            "Entry context uses lookahead-free temporal joins on ticker+date via market.enriched + market.spot_daily LEFT JOIN VIX tickers + market.enriched_context. " +
+            "Same-day (open-known) fields: Gap_Pct, VIX_Open, VIX_Gap_Pct, Prior_Range_vs_ATR, Day_of_Week, Month, Is_Opex. " +
+            "Prior-day (close-derived) fields: VIX_Close, RSI_14, Vol_Regime, Realized_Vol_5D, Realized_Vol_20D, VIX_IVR, VIX_IVP, Term_Structure_State, etc. — " +
+            "use the previous trading day's close-derived values to prevent lookahead bias.";
+          if (includeOutcomeFields) {
+            lagNote +=
+              " Outcome fields contain same-day close-derived values and represent information NOT available at trade entry time.";
           }
-          for (const field of STATIC_FIELDS) {
-            sameDay[field] = cleanVal(marketData[field]);
-          }
-
-          // Build priorDay: close-derived fields (read prev_* columns)
-          const priorDay: Record<string, unknown> = {};
-          for (const field of CLOSE_KNOWN_FIELDS) {
-            priorDay[field] = cleanVal(marketData[`prev_${field}`]);
+          if (includeIntradayContext) {
+            lagNote +=
+              " intradayBars contains raw OHLC bar arrays from market.spot keyed by ticker+date.";
           }
 
-          baseTrade.entryContext = { sameDay, priorDay };
+          // Build response data
+          const responseData: Record<string, unknown> = {
+            blockId,
+            strategy: strategy || null,
+            lagNote,
+            tradesTotal: totalTrades,
+            returned: paginated.length,
+            offset,
+            hasMore: offset + limit < totalTrades,
+            tradesMatched: matched,
+            unmatchedDates: sortedUnmatchedDates,
+            trades: enrichedTrades,
+          };
 
-          // Outcome fields (opt-in, same-day close values)
-          if (includeOutcomeFields && outcomeMap) {
-            const outcomeData = outcomeMap.get(marketKey);
-            if (outcomeData) {
-              const outcomeFields: Record<string, unknown> = {};
-              for (const field of CLOSE_KNOWN_FIELDS) {
-                outcomeFields[field] = cleanVal(outcomeData[field]);
-              }
-              baseTrade.outcomeFields = outcomeFields;
-            }
+          if (includeOutcomeFields) {
+            responseData.lookaheadWarning =
+              "WARNING: outcomeFields contain same-day close-derived values that were NOT available at trade entry time. Do not use these for entry signal analysis.";
           }
 
-          // Intraday bars (opt-in, raw bar arrays per ticker+date)
-          if (includeIntradayContext && intradayBarsByKey) {
-            const bars = intradayBarsByKey.get(marketKey) || null;
-            baseTrade.intradayBars = bars;
+          if (availabilityET.warnings.length > 0) {
+            responseData.warnings = availabilityET.warnings;
           }
 
-          return baseTrade;
-        });
-
-        const sortedUnmatchedDates = [...new Set(unmatchedDates)].sort();
-
-        // Build lagNote
-        let lagNote =
-          "Entry context uses lookahead-free temporal joins on ticker+date via market.enriched + market.spot_daily LEFT JOIN VIX tickers + market.enriched_context. " +
-          "Same-day (open-known) fields: Gap_Pct, VIX_Open, VIX_Gap_Pct, Prior_Range_vs_ATR, Day_of_Week, Month, Is_Opex. " +
-          "Prior-day (close-derived) fields: VIX_Close, RSI_14, Vol_Regime, Realized_Vol_5D, Realized_Vol_20D, VIX_IVR, VIX_IVP, Term_Structure_State, etc. — " +
-          "use the previous trading day's close-derived values to prevent lookahead bias.";
-        if (includeOutcomeFields) {
-          lagNote += " Outcome fields contain same-day close-derived values and represent information NOT available at trade entry time.";
-        }
-        if (includeIntradayContext) {
-          lagNote += " intradayBars contains raw OHLC bar arrays from market.spot keyed by ticker+date.";
-        }
-
-        // Build response data
-        const responseData: Record<string, unknown> = {
-          blockId,
-          strategy: strategy || null,
-          lagNote,
-          tradesTotal: totalTrades,
-          returned: paginated.length,
-          offset,
-          hasMore: offset + limit < totalTrades,
-          tradesMatched: matched,
-          unmatchedDates: sortedUnmatchedDates,
-          trades: enrichedTrades,
-        };
-
-        if (includeOutcomeFields) {
-          responseData.lookaheadWarning =
-            "WARNING: outcomeFields contain same-day close-derived values that were NOT available at trade entry time. Do not use these for entry signal analysis.";
-        }
+          const summary = `Enriched trades: ${blockId} | ${matched}/${paginated.length} matched | offset ${offset}, limit ${limit}`;
 
-        if (availabilityET.warnings.length > 0) {
-          responseData.warnings = availabilityET.warnings;
+          return createToolOutput(summary, responseData);
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error: ${(error as Error).message}` }],
+            isError: true,
+          };
         }
-
-        const summary = `Enriched trades: ${blockId} | ${matched}/${paginated.length} matched | offset ${offset}, limit ${limit}`;
-
-        return createToolOutput(summary, responseData);
-      } catch (error) {
-        return {
-          content: [{ type: "text", text: `Error: ${(error as Error).message}` }],
-          isError: true,
-        };
-      }
-    })
+      },
+    ),
   );
 
   // ---------------------------------------------------------------------------
@@ -1161,245 +1443,273 @@ export function registerMarketDataTools(
         ticker: z.string().default("SPX").describe("Ticker symbol (default: SPX)"),
         startDate: z.string().describe("Start date (YYYY-MM-DD)"),
         endDate: z.string().optional().describe("End date (YYYY-MM-DD, defaults to today)"),
-        startTime: z.string().default("0930").describe("ORB window start in HHMM format (default: '0930')"),
-        endTime: z.string().default("1000").describe("ORB window end in HHMM format (default: '1000')"),
-        useHighLow: z.boolean().default(true).describe("Use high/low for range (true) or close prices (false)"),
-        barResolution: z.string().optional().describe("Expected bar resolution in minutes (e.g., '15'). Auto-detected if omitted."),
+        startTime: z
+          .string()
+          .default("0930")
+          .describe("ORB window start in HHMM format (default: '0930')"),
+        endTime: z
+          .string()
+          .default("1000")
+          .describe("ORB window end in HHMM format (default: '1000')"),
+        useHighLow: z
+          .boolean()
+          .default(true)
+          .describe("Use high/low for range (true) or close prices (false)"),
+        barResolution: z
+          .string()
+          .optional()
+          .describe("Expected bar resolution in minutes (e.g., '15'). Auto-detected if omitted."),
         limit: z.number().min(1).max(500).default(100).describe("Max days to return"),
       }),
     },
-    withFullSync(baseDir, async ({ ticker, startDate, endDate, startTime, endTime, useHighLow, barResolution, limit }) => {
-      try {
-        const normalizedTicker = normalizeTicker(ticker) || "SPX";
-        const end = endDate || new Date().toISOString().split("T")[0];
-
-        // Convert HHMM to HH:MM for SQL comparison
-        const sqlStartTime = hhmmToSqlTime(startTime);
-        const sqlEndTime = hhmmToSqlTime(endTime);
-
-        // Check data availability
-        const availability = await checkDataAvailability(stores, normalizedTicker, { checkIntraday: true });
-
-        // Data availability + bar reads flow through SpotStore; the window
-        // aggregation and breakout-detection logic runs in TypeScript over
-        // the BarRow[] returned by readBars.
-
-        // Quick check: is there any spot data for this ticker over the requested range?
-        // Use a wide bracket so the "no data at all" case is distinguishable from
-        // "no data in the requested range" (the latter is handled below by an empty
-        // `byDate` map).
-        const wideCoverage = await stores.spot.getCoverage(
-          normalizedTicker,
-          "2000-01-01",
-          new Date().toISOString().split("T")[0],
-        );
-        if (wideCoverage.totalDates === 0) {
-          return createToolOutput(
-            `ORB (${normalizedTicker}): No intraday data available`,
-            {
+    withFullSync(
+      baseDir,
+      async ({
+        ticker,
+        startDate,
+        endDate,
+        startTime,
+        endTime,
+        useHighLow,
+        barResolution,
+        limit,
+      }) => {
+        try {
+          const normalizedTicker = normalizeTicker(ticker) || "SPX";
+          const end = endDate || new Date().toISOString().split("T")[0];
+
+          // Convert HHMM to HH:MM for SQL comparison
+          const sqlStartTime = hhmmToSqlTime(startTime);
+          const sqlEndTime = hhmmToSqlTime(endTime);
+
+          // Check data availability
+          const availability = await checkDataAvailability(stores, normalizedTicker, {
+            checkIntraday: true,
+          });
+
+          // Data availability + bar reads flow through SpotStore; the window
+          // aggregation and breakout-detection logic runs in TypeScript over
+          // the BarRow[] returned by readBars.
+
+          // Quick check: is there any spot data for this ticker over the requested range?
+          // Use a wide bracket so the "no data at all" case is distinguishable from
+          // "no data in the requested range" (the latter is handled below by an empty
+          // `byDate` map).
+          const wideCoverage = await stores.spot.getCoverage(
+            normalizedTicker,
+            "2000-01-01",
+            new Date().toISOString().split("T")[0],
+          );
+          if (wideCoverage.totalDates === 0) {
+            return createToolOutput(`ORB (${normalizedTicker}): No intraday data available`, {
               query: { ticker: normalizedTicker, startTime, endTime, startDate, endDate: end },
               warnings: availability.warnings,
               days: [],
               stats: { totalDays: 0 },
-            }
-          );
-        }
-
-        // Determine bar resolution: use provided value or auto-detect from first available date
-        let resolvedBarResolution: number | null = null;
-        if (barResolution !== undefined && barResolution !== null) {
-          const parsed = parseInt(barResolution, 10);
-          if (!isNaN(parsed) && parsed > 0) {
-            resolvedBarResolution = parsed;
+            });
           }
-        } else if (wideCoverage.earliest) {
-          // Auto-detect: read the first available date's bars, compute the gap
-          // between the first two distinct times. SpotStore returns rows ordered
-          // by (date, time) so we can scan in order.
-          try {
-            const sampleBars = await stores.spot.readBars(
-              normalizedTicker,
-              wideCoverage.earliest,
-              wideCoverage.earliest,
-            );
-            const distinctTimes: string[] = [];
-            for (const bar of sampleBars) {
-              const t = String(bar.time);
-              if (distinctTimes.length === 0 || distinctTimes[distinctTimes.length - 1] !== t) {
-                distinctTimes.push(t);
-                if (distinctTimes.length === 10) break;
-              }
+
+          // Determine bar resolution: use provided value or auto-detect from first available date
+          let resolvedBarResolution: number | null = null;
+          if (barResolution !== undefined && barResolution !== null) {
+            const parsed = parseInt(barResolution, 10);
+            if (!isNaN(parsed) && parsed > 0) {
+              resolvedBarResolution = parsed;
             }
-            if (distinctTimes.length >= 2) {
-              const t1 = distinctTimes[0];
-              const t2 = distinctTimes[1];
-              const [h1, m1] = t1.split(":").map(Number);
-              const [h2, m2] = t2.split(":").map(Number);
-              const gap = (h2 * 60 + m2) - (h1 * 60 + m1);
-              if (gap > 0) {
-                resolvedBarResolution = gap;
+          } else if (wideCoverage.earliest) {
+            // Auto-detect: read the first available date's bars, compute the gap
+            // between the first two distinct times. SpotStore returns rows ordered
+            // by (date, time) so we can scan in order.
+            try {
+              const sampleBars = await stores.spot.readBars(
+                normalizedTicker,
+                wideCoverage.earliest,
+                wideCoverage.earliest,
+              );
+              const distinctTimes: string[] = [];
+              for (const bar of sampleBars) {
+                const t = String(bar.time);
+                if (distinctTimes.length === 0 || distinctTimes[distinctTimes.length - 1] !== t) {
+                  distinctTimes.push(t);
+                  if (distinctTimes.length === 10) break;
+                }
               }
+              if (distinctTimes.length >= 2) {
+                const t1 = distinctTimes[0];
+                const t2 = distinctTimes[1];
+                const [h1, m1] = t1.split(":").map(Number);
+                const [h2, m2] = t2.split(":").map(Number);
+                const gap = h2 * 60 + m2 - (h1 * 60 + m1);
+                if (gap > 0) {
+                  resolvedBarResolution = gap;
+                }
+              }
+            } catch {
+              // If auto-detection fails, proceed without resolution filtering
             }
-          } catch {
-            // If auto-detection fails, proceed without resolution filtering
           }
-        }
-
-        // Read all in-range bars and group by date for ORB computation. The
-        // `useHighLow` toggle picks raw high/low vs close-of-bar high/low.
-        const allBars = await stores.spot.readBars(normalizedTicker, startDate, end);
-
-        // Group by date, preserving (time)-ascending order from readBars.
-        // Defense-in-depth: skip underlying bars with zero/null OHLC (provider
-        // gaps from the spot ingest). Without this, a zero-low minute in the
-        // opening window would corrupt ORB_Low and the breakout/range output.
-        const barsByDate = new Map<string, typeof allBars>();
-        for (const bar of allBars) {
-          if (
-            !Number.isFinite(bar.open)  || bar.open  <= 0 ||
-            !Number.isFinite(bar.high)  || bar.high  <= 0 ||
-            !Number.isFinite(bar.low)   || bar.low   <= 0 ||
-            !Number.isFinite(bar.close) || bar.close <= 0
-          ) continue;
-          const arr = barsByDate.get(bar.date);
-          if (arr) arr.push(bar);
-          else barsByDate.set(bar.date, [bar]);
-        }
 
-        type BreakoutCondition = "HighFirst" | "LowFirst" | "HighOnly" | "LowOnly" | "NoBreakout";
-
-        interface OrbDayResult {
-          date: string;
-          ORB_High: number;
-          ORB_Low: number;
-          ORB_Range: number;
-          ORB_Range_Pct: number;
-          ORB_Open: number | null;
-          breakout_condition: BreakoutCondition;
-          breakout_up_time: string | null;
-          breakout_down_time: string | null;
-          entry_triggered: boolean;
-        }
-
-        // Compute ORB window + breakouts per date in TypeScript over the
-        // grouped bars.
-        const days: OrbDayResult[] = [];
-        const sortedDates = [...barsByDate.keys()].sort();
-        for (const date of sortedDates) {
-          const dayBars = barsByDate.get(date)!;
-          // ORB window: time in [sqlStartTime, sqlEndTime]
-          const windowBars = dayBars.filter(
-            (b) => String(b.time) >= sqlStartTime && String(b.time) <= sqlEndTime,
-          );
-          if (windowBars.length === 0) continue;
-
-          let orbHigh = -Infinity;
-          let orbLow = Infinity;
-          let orbOpen: number | null = null;
-          for (const b of windowBars) {
-            const hi = useHighLow ? Number(b.high) : Number(b.close);
-            const lo = useHighLow ? Number(b.low) : Number(b.close);
-            if (hi > orbHigh) orbHigh = hi;
-            if (lo < orbLow) orbLow = lo;
-            if (String(b.time) === sqlStartTime && orbOpen === null) {
-              orbOpen = Number(b.open);
-            }
-          }
-          const orbRange = orbHigh - orbLow;
-          const orbRangePct = orbLow > 0 ? (orbRange / orbLow) * 100 : 0;
-
-          // Breakout window: time strictly > sqlEndTime
-          let breakoutUpTime: string | null = null;
-          let breakoutDownTime: string | null = null;
-          for (const b of dayBars) {
-            const t = String(b.time);
-            if (t <= sqlEndTime) continue;
-            const upHit = useHighLow ? Number(b.high) > orbHigh : Number(b.close) > orbHigh;
-            const downHit = useHighLow ? Number(b.low) < orbLow : Number(b.close) < orbLow;
-            if (upHit && breakoutUpTime === null) breakoutUpTime = t;
-            if (downHit && breakoutDownTime === null) breakoutDownTime = t;
-            if (breakoutUpTime !== null && breakoutDownTime !== null) break;
+          // Read all in-range bars and group by date for ORB computation. The
+          // `useHighLow` toggle picks raw high/low vs close-of-bar high/low.
+          const allBars = await stores.spot.readBars(normalizedTicker, startDate, end);
+
+          // Group by date, preserving (time)-ascending order from readBars.
+          // Defense-in-depth: skip underlying bars with zero/null OHLC (provider
+          // gaps from the spot ingest). Without this, a zero-low minute in the
+          // opening window would corrupt ORB_Low and the breakout/range output.
+          const barsByDate = new Map<string, typeof allBars>();
+          for (const bar of allBars) {
+            if (
+              !Number.isFinite(bar.open) ||
+              bar.open <= 0 ||
+              !Number.isFinite(bar.high) ||
+              bar.high <= 0 ||
+              !Number.isFinite(bar.low) ||
+              bar.low <= 0 ||
+              !Number.isFinite(bar.close) ||
+              bar.close <= 0
+            )
+              continue;
+            const arr = barsByDate.get(bar.date);
+            if (arr) arr.push(bar);
+            else barsByDate.set(bar.date, [bar]);
           }
 
-          let breakoutCondition: BreakoutCondition;
-          if (breakoutUpTime !== null && breakoutDownTime !== null) {
-            breakoutCondition = breakoutUpTime < breakoutDownTime ? "HighFirst" : "LowFirst";
-          } else if (breakoutUpTime !== null) {
-            breakoutCondition = "HighOnly";
-          } else if (breakoutDownTime !== null) {
-            breakoutCondition = "LowOnly";
-          } else {
-            breakoutCondition = "NoBreakout";
+          type BreakoutCondition = "HighFirst" | "LowFirst" | "HighOnly" | "LowOnly" | "NoBreakout";
+
+          interface OrbDayResult {
+            date: string;
+            ORB_High: number;
+            ORB_Low: number;
+            ORB_Range: number;
+            ORB_Range_Pct: number;
+            ORB_Open: number | null;
+            breakout_condition: BreakoutCondition;
+            breakout_up_time: string | null;
+            breakout_down_time: string | null;
+            entry_triggered: boolean;
           }
 
-          days.push({
-            date,
-            ORB_High: Math.round(orbHigh * 100) / 100,
-            ORB_Low: Math.round(orbLow * 100) / 100,
-            ORB_Range: Math.round(orbRange * 100) / 100,
-            ORB_Range_Pct: Math.round(orbRangePct * 10000) / 10000,
-            ORB_Open: orbOpen !== null ? Math.round(orbOpen * 100) / 100 : null,
-            breakout_condition: breakoutCondition,
-            breakout_up_time: breakoutUpTime,
-            breakout_down_time: breakoutDownTime,
-            entry_triggered: breakoutCondition !== "NoBreakout",
-          });
-        }
+          // Compute ORB window + breakouts per date in TypeScript over the
+          // grouped bars.
+          const days: OrbDayResult[] = [];
+          const sortedDates = [...barsByDate.keys()].sort();
+          for (const date of sortedDates) {
+            const dayBars = barsByDate.get(date)!;
+            // ORB window: time in [sqlStartTime, sqlEndTime]
+            const windowBars = dayBars.filter(
+              (b) => String(b.time) >= sqlStartTime && String(b.time) <= sqlEndTime,
+            );
+            if (windowBars.length === 0) continue;
+
+            let orbHigh = -Infinity;
+            let orbLow = Infinity;
+            let orbOpen: number | null = null;
+            for (const b of windowBars) {
+              const hi = useHighLow ? Number(b.high) : Number(b.close);
+              const lo = useHighLow ? Number(b.low) : Number(b.close);
+              if (hi > orbHigh) orbHigh = hi;
+              if (lo < orbLow) orbLow = lo;
+              if (String(b.time) === sqlStartTime && orbOpen === null) {
+                orbOpen = Number(b.open);
+              }
+            }
+            const orbRange = orbHigh - orbLow;
+            const orbRangePct = orbLow > 0 ? (orbRange / orbLow) * 100 : 0;
+
+            // Breakout window: time strictly > sqlEndTime
+            let breakoutUpTime: string | null = null;
+            let breakoutDownTime: string | null = null;
+            for (const b of dayBars) {
+              const t = String(b.time);
+              if (t <= sqlEndTime) continue;
+              const upHit = useHighLow ? Number(b.high) > orbHigh : Number(b.close) > orbHigh;
+              const downHit = useHighLow ? Number(b.low) < orbLow : Number(b.close) < orbLow;
+              if (upHit && breakoutUpTime === null) breakoutUpTime = t;
+              if (downHit && breakoutDownTime === null) breakoutDownTime = t;
+              if (breakoutUpTime !== null && breakoutDownTime !== null) break;
+            }
 
-        const totalDays = days.length;
+            let breakoutCondition: BreakoutCondition;
+            if (breakoutUpTime !== null && breakoutDownTime !== null) {
+              breakoutCondition = breakoutUpTime < breakoutDownTime ? "HighFirst" : "LowFirst";
+            } else if (breakoutUpTime !== null) {
+              breakoutCondition = "HighOnly";
+            } else if (breakoutDownTime !== null) {
+              breakoutCondition = "LowOnly";
+            } else {
+              breakoutCondition = "NoBreakout";
+            }
 
-        // Compute aggregate stats
-        const avgOrbRangePct = totalDays > 0
-          ? days.reduce((sum, d) => sum + d.ORB_Range_Pct, 0) / totalDays
-          : 0;
+            days.push({
+              date,
+              ORB_High: Math.round(orbHigh * 100) / 100,
+              ORB_Low: Math.round(orbLow * 100) / 100,
+              ORB_Range: Math.round(orbRange * 100) / 100,
+              ORB_Range_Pct: Math.round(orbRangePct * 10000) / 10000,
+              ORB_Open: orbOpen !== null ? Math.round(orbOpen * 100) / 100 : null,
+              breakout_condition: breakoutCondition,
+              breakout_up_time: breakoutUpTime,
+              breakout_down_time: breakoutDownTime,
+              entry_triggered: breakoutCondition !== "NoBreakout",
+            });
+          }
 
-        const breakdownByCondition = {
-          HighFirst: days.filter((d) => d.breakout_condition === "HighFirst").length,
-          LowFirst: days.filter((d) => d.breakout_condition === "LowFirst").length,
-          HighOnly: days.filter((d) => d.breakout_condition === "HighOnly").length,
-          LowOnly: days.filter((d) => d.breakout_condition === "LowOnly").length,
-          NoBreakout: days.filter((d) => d.breakout_condition === "NoBreakout").length,
-        };
+          const totalDays = days.length;
 
-        // Apply limit
-        const limitedDays = days.slice(0, limit);
+          // Compute aggregate stats
+          const avgOrbRangePct =
+            totalDays > 0 ? days.reduce((sum, d) => sum + d.ORB_Range_Pct, 0) / totalDays : 0;
 
-        const summary =
-          `ORB (${normalizedTicker}, ${startTime}-${endTime}): ${startDate} to ${end} | ` +
-          `${totalDays} days, avg range ${formatPercent(avgOrbRangePct)}`;
+          const breakdownByCondition = {
+            HighFirst: days.filter((d) => d.breakout_condition === "HighFirst").length,
+            LowFirst: days.filter((d) => d.breakout_condition === "LowFirst").length,
+            HighOnly: days.filter((d) => d.breakout_condition === "HighOnly").length,
+            LowOnly: days.filter((d) => d.breakout_condition === "LowOnly").length,
+            NoBreakout: days.filter((d) => d.breakout_condition === "NoBreakout").length,
+          };
 
-        const responseData: Record<string, unknown> = {
-          query: {
-            ticker: normalizedTicker,
-            startTime,
-            endTime,
-            sqlStartTime,
-            sqlEndTime,
-            startDate,
-            endDate: end,
-            useHighLow,
-            barResolution: resolvedBarResolution !== null ? String(resolvedBarResolution) : "auto",
-          },
-          stats: {
-            totalDays,
-            avgOrbRangePct: Math.round(avgOrbRangePct * 10000) / 10000,
-            breakdownByCondition,
-          },
-          returned: limitedDays.length,
-          days: limitedDays,
-        };
+          // Apply limit
+          const limitedDays = days.slice(0, limit);
+
+          const summary =
+            `ORB (${normalizedTicker}, ${startTime}-${endTime}): ${startDate} to ${end} | ` +
+            `${totalDays} days, avg range ${formatPercent(avgOrbRangePct)}`;
+
+          const responseData: Record<string, unknown> = {
+            query: {
+              ticker: normalizedTicker,
+              startTime,
+              endTime,
+              sqlStartTime,
+              sqlEndTime,
+              startDate,
+              endDate: end,
+              useHighLow,
+              barResolution:
+                resolvedBarResolution !== null ? String(resolvedBarResolution) : "auto",
+            },
+            stats: {
+              totalDays,
+              avgOrbRangePct: Math.round(avgOrbRangePct * 10000) / 10000,
+              breakdownByCondition,
+            },
+            returned: limitedDays.length,
+            days: limitedDays,
+          };
 
-        if (availability.warnings.length > 0) {
-          responseData.warnings = availability.warnings;
-        }
+          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,
-        };
-      }
-    })
+          return createToolOutput(summary, responseData);
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error: ${(error as Error).message}` }],
+            isError: true,
+          };
+        }
+      },
+    ),
   );
 }