tradeblocks-mcp 3.0.2 → 3.0.3

package/server/index.js

@@ -40,7 +40,7 @@ import {
   writeParquetAtomic,
   writeQuoteMinutesPartition,
   writeSpotPartition
-} from "./chunk-NZO6PT64.js";
+} from "./chunk-4P7D7YZP.js";
 import {
   BACHELIER_DTE_THRESHOLD,
   MassiveProvider,
@@ -54,7 +54,7 @@ import {
   getProvider,
   markPrice,
   parseLegsString
-} from "./chunk-PNKG7RY7.js";
+} from "./chunk-ZBJCF4ZG.js";
 import {
   PortfolioStatsCalculator,
   REPORT_FIELDS,
@@ -87,12 +87,12 @@ import {
   segmentByPeriod,
   synthesizeEdgeDecay,
   truncateTimeToMinute
-} from "./chunk-72GKJE2U.js";
-import "./chunk-CSDVJPBB.js";
-import "./chunk-WA5AAPCH.js";
-import "./chunk-5EBXHT6C.js";
-import "./chunk-NRFXAJF7.js";
-import "./chunk-FBNDMCT5.js";
+} from "./chunk-BOPHW5M6.js";
+import "./chunk-YUCOAJ4Z.js";
+import "./chunk-GH2552SE.js";
+import "./chunk-OBYKFW2B.js";
+import "./chunk-W5E7FHC4.js";
+import "./chunk-T66KH2XH.js";
 import "./chunk-UT3JLF3M.js";
 
 // src/index.ts
@@ -143,9 +143,7 @@ function formatRatio(value, decimals = 2) {
 // src/tools/shared/filters.ts
 function filterByStrategy(trades, strategy) {
   if (!strategy) return trades;
-  return trades.filter(
-    (t) => t.strategy.toLowerCase() === strategy.toLowerCase()
-  );
+  return trades.filter((t) => t.strategy.toLowerCase() === strategy.toLowerCase());
 }
 var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 function validateDateParam(date) {
@@ -338,13 +336,9 @@ function registerCoreBlockTools(server, baseDir) {
       inputSchema: z.object({
         sortBy: z.enum(["name", "tradeCount", "netPl", "dateRange"]).default("name").describe("Sort results by field (default: name)"),
         sortOrder: z.enum(["asc", "desc"]).default("asc").describe("Sort direction (default: asc)"),
-        containsStrategy: z.string().optional().describe(
-          "Filter to blocks containing this strategy name (case-insensitive)"
-        ),
+        containsStrategy: z.string().optional().describe("Filter to blocks containing this strategy name (case-insensitive)"),
         minTrades: z.number().min(1).optional().describe("Filter to blocks with at least this many trades"),
-        hasDailyLog: z.boolean().optional().describe(
-          "Filter to blocks with (true) or without (false) daily log data"
-        ),
+        hasDailyLog: z.boolean().optional().describe("Filter to blocks with (true) or without (false) daily log data"),
         hasReportingLog: z.boolean().optional().describe(
           "Filter to blocks with (true) or without (false) reporting log data (actual trade execution)"
         ),
@@ -353,15 +347,7 @@ function registerCoreBlockTools(server, baseDir) {
     },
     withFullSync(
       baseDir,
-      async ({
-        sortBy,
-        sortOrder,
-        containsStrategy,
-        minTrades,
-        hasDailyLog,
-        hasReportingLog,
-        limit
-      }, { blockSyncResult: syncResult }) => {
+      async ({ sortBy, sortOrder, containsStrategy, minTrades, hasDailyLog, hasReportingLog, limit }, { blockSyncResult: syncResult }) => {
         try {
           let blocks = await listBlocks(baseDir);
           if (containsStrategy) {
@@ -400,9 +386,7 @@ function registerCoreBlockTools(server, baseDir) {
           if (limit !== void 0 && limit < blocks.length) {
             blocks = blocks.slice(0, limit);
           }
-          const blocksWithReporting = blocks.filter(
-            (b) => b.hasReportingLog
-          ).length;
+          const blocksWithReporting = blocks.filter((b) => b.hasReportingLog).length;
           const summary = `Found ${blocks.length} block(s)${totalBeforeLimit > blocks.length ? ` (showing ${blocks.length} of ${totalBeforeLimit})` : ""}${blocksWithReporting > 0 ? `, ${blocksWithReporting} with reporting logs` : ""}`;
           const syncErrors = [...syncResult.errors];
           const structuredData = {
@@ -470,9 +454,7 @@ function registerCoreBlockTools(server, baseDir) {
         const block = await loadBlock(baseDir, blockId);
         const trades = block.trades;
         const dailyLogs = block.dailyLogs;
-        const strategies = Array.from(
-          new Set(trades.map((t) => t.strategy))
-        ).sort();
+        const strategies = Array.from(new Set(trades.map((t) => t.strategy))).sort();
         const dates = trades.map((t) => new Date(t.dateOpened).getTime());
         const dateRange = {
           start: dates.length > 0 ? new Date(Math.min(...dates)) : null,
@@ -549,10 +531,7 @@ function registerCoreBlockTools(server, baseDir) {
           const winRate = tradeCount > 0 ? winningTrades / tradeCount : 0;
           const totalPL2 = strategyTradeList.reduce((sum, t) => sum + t.pl, 0);
           const avgPL = tradeCount > 0 ? totalPL2 / tradeCount : 0;
-          const contractCount = strategyTradeList.reduce(
-            (sum, t) => sum + t.numContracts,
-            0
-          );
+          const contractCount = strategyTradeList.reduce((sum, t) => sum + t.numContracts, 0);
           byStrategy[strategy] = { tradeCount, winRate, totalPL: totalPL2, avgPL, contractCount };
         }
         const totalPL = trades.reduce((sum, t) => sum + t.pl, 0);
@@ -596,9 +575,7 @@ function registerCoreBlockTools(server, baseDir) {
       inputSchema: z.object({
         blockId: z.string().describe("Block ID from list_blocks (e.g., 'main-port')"),
         strategy: z.string().optional().describe("Filter by strategy name (case-insensitive)"),
-        tickerFilter: z.string().optional().describe(
-          "Filter trades by underlying ticker symbol (e.g., 'SPY', 'AAPL')"
-        ),
+        tickerFilter: z.string().optional().describe("Filter trades by underlying ticker symbol (e.g., 'SPY', 'AAPL')"),
         startDate: z.string().optional().describe("Start date filter (YYYY-MM-DD)"),
         endDate: z.string().optional().describe("End date filter (YYYY-MM-DD)")
       })
@@ -614,9 +591,7 @@ function registerCoreBlockTools(server, baseDir) {
           trades = filterByDateRange(trades, startDate, endDate);
           if (tickerFilter) {
             const tickerLower = tickerFilter.toLowerCase();
-            trades = trades.filter(
-              (t) => resolveTradeTicker(t).toLowerCase() === tickerLower
-            );
+            trades = trades.filter((t) => resolveTradeTicker(t).toLowerCase() === tickerLower);
           }
           if (trades.length === 0) {
             return {
@@ -717,9 +692,7 @@ function registerComparisonBlockTools(server, baseDir) {
         endDate: z2.string().optional().describe("End date filter (YYYY-MM-DD)"),
         tickerFilter: z2.string().optional().describe("Filter trades by underlying ticker symbol"),
         minTrades: z2.number().min(1).optional().describe("Minimum trades per strategy to include in comparison"),
-        sortBy: z2.enum(["netPl", "pl", "winRate", "trades", "profitFactor", "name"]).default("netPl").describe(
-          "Sort strategies by metric (default: netPl). 'pl' is an alias for 'netPl'."
-        ),
+        sortBy: z2.enum(["netPl", "pl", "winRate", "trades", "profitFactor", "name"]).default("netPl").describe("Sort strategies by metric (default: netPl). 'pl' is an alias for 'netPl'."),
         sortOrder: z2.enum(["asc", "desc"]).default("desc").describe("Sort direction (default: desc for highest first)"),
         limit: z2.number().min(1).optional().describe("Limit number of strategies shown")
       })
@@ -742,15 +715,11 @@ function registerComparisonBlockTools(server, baseDir) {
           trades = filterByDateRange(trades, startDate, endDate);
           if (tickerFilter) {
             const tickerLower = tickerFilter.toLowerCase();
-            trades = trades.filter(
-              (t) => resolveTradeTicker(t).toLowerCase() === tickerLower
-            );
+            trades = trades.filter((t) => resolveTradeTicker(t).toLowerCase() === tickerLower);
           }
           if (trades.length === 0) {
             return {
-              content: [
-                { type: "text", text: "No trades found matching the filters." }
-              ]
+              content: [{ type: "text", text: "No trades found matching the filters." }]
             };
           }
           const strategyStats = calculator.calculateStrategyStats(trades);
@@ -852,116 +821,104 @@ function registerComparisonBlockTools(server, baseDir) {
         sortOrder: z2.enum(["asc", "desc"]).default("asc").describe("Sort direction (default: asc)")
       })
     },
-    withSyncedBlocks(
-      baseDir,
-      async ({ blockIds, metrics, sortBy, sortOrder }) => {
-        try {
-          const blockStats = [];
-          for (const blockId of blockIds) {
-            try {
-              const block = await loadBlock(baseDir, blockId);
-              const stats = calculator.calculatePortfolioStats(
-                block.trades,
-                block.dailyLogs
-              );
-              blockStats.push({ blockId, stats });
-            } catch (error) {
-              console.error(`Failed to load block ${blockId}:`, error);
-            }
-          }
-          if (blockStats.length === 0) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Failed to load any of the specified blocks: ${blockIds.join(", ")}`
-                }
-              ],
-              isError: true
-            };
+    withSyncedBlocks(baseDir, async ({ blockIds, metrics, sortBy, sortOrder }) => {
+      try {
+        const blockStats = [];
+        for (const blockId of blockIds) {
+          try {
+            const block = await loadBlock(baseDir, blockId);
+            const stats = calculator.calculatePortfolioStats(block.trades, block.dailyLogs);
+            blockStats.push({ blockId, stats });
+          } catch (error) {
+            console.error(`Failed to load block ${blockId}:`, error);
           }
-          const multiplier = sortOrder === "asc" ? 1 : -1;
-          blockStats.sort((a, b) => {
-            switch (sortBy) {
-              case "totalTrades":
-                return (a.stats.totalTrades - b.stats.totalTrades) * multiplier;
-              case "winRate":
-                return ((a.stats.winRate ?? 0) - (b.stats.winRate ?? 0)) * multiplier;
-              case "netPl":
-                return ((a.stats.netPl ?? 0) - (b.stats.netPl ?? 0)) * multiplier;
-              case "sharpeRatio":
-                return ((a.stats.sharpeRatio ?? 0) - (b.stats.sharpeRatio ?? 0)) * multiplier;
-              case "sortinoRatio":
-                return ((a.stats.sortinoRatio ?? 0) - (b.stats.sortinoRatio ?? 0)) * multiplier;
-              case "maxDrawdown":
-                return ((a.stats.maxDrawdown ?? 0) - (b.stats.maxDrawdown ?? 0)) * multiplier;
-              case "profitFactor":
-                return ((a.stats.profitFactor ?? 0) - (b.stats.profitFactor ?? 0)) * multiplier;
-              case "calmarRatio":
-                return ((a.stats.calmarRatio ?? 0) - (b.stats.calmarRatio ?? 0)) * multiplier;
-              case "name":
-              default:
-                return a.blockId.localeCompare(b.blockId) * multiplier;
-            }
-          });
-          const loadedIds = blockStats.map((b) => b.blockId);
-          const failedIds = blockIds.filter((id) => !loadedIds.includes(id));
-          const summary = `Block Comparison: ${blockStats.length} blocks loaded${failedIds.length > 0 ? ` (${failedIds.length} failed)` : ""} | Sorted by ${sortBy}`;
-          const allMetrics = {
-            totalTrades: true,
-            winRate: true,
-            netPl: true,
-            sharpeRatio: true,
-            sortinoRatio: true,
-            maxDrawdown: true,
-            profitFactor: true,
-            calmarRatio: true
-          };
-          const requestedMetrics = metrics ? Object.fromEntries(metrics.map((m) => [m, true])) : allMetrics;
-          const structuredData = {
-            options: {
-              metrics: metrics ?? null,
-              sortBy,
-              sortOrder
-            },
-            comparisons: blockStats.map(({ blockId, stats }) => {
-              const filteredStats = {};
-              if (requestedMetrics.totalTrades)
-                filteredStats.totalTrades = stats.totalTrades;
-              if (requestedMetrics.winRate)
-                filteredStats.winRate = stats.winRate;
-              if (requestedMetrics.netPl) filteredStats.netPl = stats.netPl;
-              if (requestedMetrics.sharpeRatio)
-                filteredStats.sharpeRatio = stats.sharpeRatio ?? null;
-              if (requestedMetrics.sortinoRatio)
-                filteredStats.sortinoRatio = stats.sortinoRatio ?? null;
-              if (requestedMetrics.maxDrawdown)
-                filteredStats.maxDrawdown = stats.maxDrawdown;
-              if (requestedMetrics.profitFactor)
-                filteredStats.profitFactor = stats.profitFactor;
-              if (requestedMetrics.calmarRatio)
-                filteredStats.calmarRatio = stats.calmarRatio ?? null;
-              return {
-                blockId,
-                stats: filteredStats
-              };
-            }),
-            failedBlocks: failedIds
-          };
-          return createToolOutput(summary, structuredData);
-        } catch (error) {
+        }
+        if (blockStats.length === 0) {
           return {
             content: [
               {
                 type: "text",
-                text: `Error comparing blocks: ${error.message}`
+                text: `Failed to load any of the specified blocks: ${blockIds.join(", ")}`
               }
             ],
             isError: true
           };
         }
+        const multiplier = sortOrder === "asc" ? 1 : -1;
+        blockStats.sort((a, b) => {
+          switch (sortBy) {
+            case "totalTrades":
+              return (a.stats.totalTrades - b.stats.totalTrades) * multiplier;
+            case "winRate":
+              return ((a.stats.winRate ?? 0) - (b.stats.winRate ?? 0)) * multiplier;
+            case "netPl":
+              return ((a.stats.netPl ?? 0) - (b.stats.netPl ?? 0)) * multiplier;
+            case "sharpeRatio":
+              return ((a.stats.sharpeRatio ?? 0) - (b.stats.sharpeRatio ?? 0)) * multiplier;
+            case "sortinoRatio":
+              return ((a.stats.sortinoRatio ?? 0) - (b.stats.sortinoRatio ?? 0)) * multiplier;
+            case "maxDrawdown":
+              return ((a.stats.maxDrawdown ?? 0) - (b.stats.maxDrawdown ?? 0)) * multiplier;
+            case "profitFactor":
+              return ((a.stats.profitFactor ?? 0) - (b.stats.profitFactor ?? 0)) * multiplier;
+            case "calmarRatio":
+              return ((a.stats.calmarRatio ?? 0) - (b.stats.calmarRatio ?? 0)) * multiplier;
+            case "name":
+            default:
+              return a.blockId.localeCompare(b.blockId) * multiplier;
+          }
+        });
+        const loadedIds = blockStats.map((b) => b.blockId);
+        const failedIds = blockIds.filter((id) => !loadedIds.includes(id));
+        const summary = `Block Comparison: ${blockStats.length} blocks loaded${failedIds.length > 0 ? ` (${failedIds.length} failed)` : ""} | Sorted by ${sortBy}`;
+        const allMetrics = {
+          totalTrades: true,
+          winRate: true,
+          netPl: true,
+          sharpeRatio: true,
+          sortinoRatio: true,
+          maxDrawdown: true,
+          profitFactor: true,
+          calmarRatio: true
+        };
+        const requestedMetrics = metrics ? Object.fromEntries(metrics.map((m) => [m, true])) : allMetrics;
+        const structuredData = {
+          options: {
+            metrics: metrics ?? null,
+            sortBy,
+            sortOrder
+          },
+          comparisons: blockStats.map(({ blockId, stats }) => {
+            const filteredStats = {};
+            if (requestedMetrics.totalTrades) filteredStats.totalTrades = stats.totalTrades;
+            if (requestedMetrics.winRate) filteredStats.winRate = stats.winRate;
+            if (requestedMetrics.netPl) filteredStats.netPl = stats.netPl;
+            if (requestedMetrics.sharpeRatio) filteredStats.sharpeRatio = stats.sharpeRatio ?? null;
+            if (requestedMetrics.sortinoRatio)
+              filteredStats.sortinoRatio = stats.sortinoRatio ?? null;
+            if (requestedMetrics.maxDrawdown) filteredStats.maxDrawdown = stats.maxDrawdown;
+            if (requestedMetrics.profitFactor) filteredStats.profitFactor = stats.profitFactor;
+            if (requestedMetrics.calmarRatio) filteredStats.calmarRatio = stats.calmarRatio ?? null;
+            return {
+              blockId,
+              stats: filteredStats
+            };
+          }),
+          failedBlocks: failedIds
+        };
+        return createToolOutput(summary, structuredData);
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error comparing blocks: ${error.message}`
+            }
+          ],
+          isError: true
+        };
       }
-    )
+    })
   );
   server.registerTool(
     "block_diff",
@@ -1017,10 +974,7 @@ function registerComparisonBlockTools(server, baseDir) {
           shared.sort();
           uniqueToA.sort();
           uniqueToB.sort();
-          const totalUniqueStrategies = (/* @__PURE__ */ new Set([
-            ...strategiesA,
-            ...strategiesB
-          ])).size;
+          const totalUniqueStrategies = (/* @__PURE__ */ new Set([...strategiesA, ...strategiesB])).size;
           const overlapPercent = totalUniqueStrategies > 0 ? shared.length / totalUniqueStrategies * 100 : 0;
           const statsA = calculator.calculateStrategyStats(tradesA);
           const statsB = calculator.calculateStrategyStats(tradesB);
@@ -1067,21 +1021,15 @@ function registerComparisonBlockTools(server, baseDir) {
             dailyLogsB && dailyLogsB.length > 0 ? dailyLogsB : void 0
           );
           const allMetrics = !metricsToCompare || metricsToCompare.length === 0;
-          const includeMetric = (m) => allMetrics || metricsToCompare?.includes(
-            m
-          );
+          const includeMetric = (m) => allMetrics || metricsToCompare?.includes(m);
           const buildPortfolioEntry = (stats) => {
             const entry = {};
             if (includeMetric("trades")) entry.totalTrades = stats.totalTrades;
-            if (includeMetric("pl") || includeMetric("netPl"))
-              entry.netPl = stats.netPl;
+            if (includeMetric("pl") || includeMetric("netPl")) entry.netPl = stats.netPl;
             if (includeMetric("winRate")) entry.winRate = stats.winRate;
-            if (includeMetric("profitFactor"))
-              entry.profitFactor = stats.profitFactor;
-            if (includeMetric("sharpeRatio"))
-              entry.sharpeRatio = stats.sharpeRatio ?? null;
-            if (includeMetric("maxDrawdown"))
-              entry.maxDrawdown = stats.maxDrawdown;
+            if (includeMetric("profitFactor")) entry.profitFactor = stats.profitFactor;
+            if (includeMetric("sharpeRatio")) entry.sharpeRatio = stats.sharpeRatio ?? null;
+            if (includeMetric("maxDrawdown")) entry.maxDrawdown = stats.maxDrawdown;
             return entry;
           };
           const portfolioA = buildPortfolioEntry(portfolioStatsA);
@@ -1227,166 +1175,157 @@ function registerAnalysisBlockTools(server, baseDir) {
         )
       })
     },
-    withSyncedBlock(
-      baseDir,
-      async ({ blockId, scenarios, customScenarios, includeEmpty }) => {
-        try {
-          const block = await loadBlock(baseDir, blockId);
-          const trades = block.trades;
-          const sortedTrades = [...trades].sort(
-            (a, b) => new Date(a.dateOpened).getTime() - new Date(b.dateOpened).getTime()
-          );
-          const portfolioStartDate = sortedTrades[0]?.dateOpened ? new Date(sortedTrades[0].dateOpened).toISOString().split("T")[0] : null;
-          const lastTrade = sortedTrades[sortedTrades.length - 1];
-          const portfolioEndDate = lastTrade?.dateClosed ? new Date(lastTrade.dateClosed).toISOString().split("T")[0] : null;
-          const scenariosToRun = [];
-          const preFilteredScenarioNames = [];
-          if (scenarios && scenarios.length > 0) {
-            const invalidScenarios = scenarios.filter(
-              (s) => !STRESS_SCENARIOS[s]
-            );
-            if (invalidScenarios.length > 0) {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Unknown scenario(s): ${invalidScenarios.join(", ")}. Available: ${Object.keys(STRESS_SCENARIOS).join(", ")}`
-                  }
-                ],
-                isError: true
-              };
-            }
-            for (const scenarioName of scenarios) {
-              const scenario = STRESS_SCENARIOS[scenarioName];
+    withSyncedBlock(baseDir, async ({ blockId, scenarios, customScenarios, includeEmpty }) => {
+      try {
+        const block = await loadBlock(baseDir, blockId);
+        const trades = block.trades;
+        const sortedTrades = [...trades].sort(
+          (a, b) => new Date(a.dateOpened).getTime() - new Date(b.dateOpened).getTime()
+        );
+        const portfolioStartDate = sortedTrades[0]?.dateOpened ? new Date(sortedTrades[0].dateOpened).toISOString().split("T")[0] : null;
+        const lastTrade = sortedTrades[sortedTrades.length - 1];
+        const portfolioEndDate = lastTrade?.dateClosed ? new Date(lastTrade.dateClosed).toISOString().split("T")[0] : null;
+        const scenariosToRun = [];
+        const preFilteredScenarioNames = [];
+        if (scenarios && scenarios.length > 0) {
+          const invalidScenarios = scenarios.filter((s) => !STRESS_SCENARIOS[s]);
+          if (invalidScenarios.length > 0) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Unknown scenario(s): ${invalidScenarios.join(", ")}. Available: ${Object.keys(STRESS_SCENARIOS).join(", ")}`
+                }
+              ],
+              isError: true
+            };
+          }
+          for (const scenarioName of scenarios) {
+            const scenario = STRESS_SCENARIOS[scenarioName];
+            scenariosToRun.push({
+              name: scenarioName,
+              startDate: scenario.startDate,
+              endDate: scenario.endDate,
+              description: scenario.description,
+              isCustom: false
+            });
+          }
+        } else {
+          for (const [name, scenario] of Object.entries(STRESS_SCENARIOS)) {
+            const hasOverlap = portfolioStartDate !== null && portfolioEndDate !== null && scenario.endDate >= portfolioStartDate && scenario.startDate <= portfolioEndDate;
+            if (hasOverlap) {
               scenariosToRun.push({
-                name: scenarioName,
+                name,
                 startDate: scenario.startDate,
                 endDate: scenario.endDate,
                 description: scenario.description,
                 isCustom: false
               });
-            }
-          } else {
-            for (const [name, scenario] of Object.entries(STRESS_SCENARIOS)) {
-              const hasOverlap = portfolioStartDate !== null && portfolioEndDate !== null && scenario.endDate >= portfolioStartDate && scenario.startDate <= portfolioEndDate;
-              if (hasOverlap) {
-                scenariosToRun.push({
-                  name,
-                  startDate: scenario.startDate,
-                  endDate: scenario.endDate,
-                  description: scenario.description,
-                  isCustom: false
-                });
-              } else {
-                preFilteredScenarioNames.push(name);
-              }
+            } else {
+              preFilteredScenarioNames.push(name);
             }
           }
-          if (customScenarios && customScenarios.length > 0) {
-            for (const custom of customScenarios) {
-              scenariosToRun.push({
-                name: custom.name,
-                startDate: custom.startDate,
-                endDate: custom.endDate,
-                description: `Custom scenario: ${custom.startDate} to ${custom.endDate}`,
-                isCustom: true
-              });
-            }
+        }
+        if (customScenarios && customScenarios.length > 0) {
+          for (const custom of customScenarios) {
+            scenariosToRun.push({
+              name: custom.name,
+              startDate: custom.startDate,
+              endDate: custom.endDate,
+              description: `Custom scenario: ${custom.startDate} to ${custom.endDate}`,
+              isCustom: true
+            });
           }
-          const scenarioResults = [];
-          let worstScenario = null;
-          let bestScenario = null;
-          let scenariosWithTrades = 0;
-          let scenariosSkipped = 0;
-          const skippedScenarioNames = [];
-          for (const scenario of scenariosToRun) {
-            const scenarioTrades = filterByDateRange(
-              trades,
-              scenario.startDate,
-              scenario.endDate
-            );
-            if (scenarioTrades.length === 0) {
-              scenariosSkipped++;
-              skippedScenarioNames.push(scenario.name);
-              if (includeEmpty) {
-                scenarioResults.push({
-                  name: scenario.name,
-                  description: scenario.description,
-                  dateRange: { start: scenario.startDate, end: scenario.endDate },
-                  tradeCount: 0,
-                  stats: null,
-                  isCustom: scenario.isCustom,
-                  noCoverage: true
-                });
-              }
-            } else {
-              const stats = calculator.calculatePortfolioStats(
-                scenarioTrades,
-                void 0,
-                // No daily logs
-                true
-                // Force trade-based calculations
-              );
+        }
+        const scenarioResults = [];
+        let worstScenario = null;
+        let bestScenario = null;
+        let scenariosWithTrades = 0;
+        let scenariosSkipped = 0;
+        const skippedScenarioNames = [];
+        for (const scenario of scenariosToRun) {
+          const scenarioTrades = filterByDateRange(trades, scenario.startDate, scenario.endDate);
+          if (scenarioTrades.length === 0) {
+            scenariosSkipped++;
+            skippedScenarioNames.push(scenario.name);
+            if (includeEmpty) {
               scenarioResults.push({
                 name: scenario.name,
                 description: scenario.description,
                 dateRange: { start: scenario.startDate, end: scenario.endDate },
-                tradeCount: scenarioTrades.length,
-                stats: {
-                  netPl: stats.netPl,
-                  winRate: stats.winRate,
-                  maxDrawdown: stats.maxDrawdown,
-                  profitFactor: stats.profitFactor,
-                  avgWin: stats.avgWin,
-                  avgLoss: stats.avgLoss
-                },
-                isCustom: scenario.isCustom
+                tradeCount: 0,
+                stats: null,
+                isCustom: scenario.isCustom,
+                noCoverage: true
               });
-              scenariosWithTrades++;
-              if (worstScenario === null || stats.netPl < worstScenario.netPl) {
-                worstScenario = { name: scenario.name, netPl: stats.netPl };
-              }
-              if (bestScenario === null || stats.netPl > bestScenario.netPl) {
-                bestScenario = { name: scenario.name, netPl: stats.netPl };
-              }
             }
-          }
-          const summaryData = {
-            totalScenariosTested: scenariosToRun.length,
-            scenariosWithTrades,
-            scenariosSkipped,
-            ...skippedScenarioNames.length > 0 ? { skippedScenarios: skippedScenarioNames } : {},
-            ...preFilteredScenarioNames.length > 0 ? { preFilteredScenarios: preFilteredScenarioNames } : {},
-            worstScenario: worstScenario?.name ?? null,
-            bestScenario: bestScenario?.name ?? null,
-            portfolioDateRange: {
-              start: portfolioStartDate,
-              end: portfolioEndDate
+          } else {
+            const stats = calculator.calculatePortfolioStats(
+              scenarioTrades,
+              void 0,
+              // No daily logs
+              true
+              // Force trade-based calculations
+            );
+            scenarioResults.push({
+              name: scenario.name,
+              description: scenario.description,
+              dateRange: { start: scenario.startDate, end: scenario.endDate },
+              tradeCount: scenarioTrades.length,
+              stats: {
+                netPl: stats.netPl,
+                winRate: stats.winRate,
+                maxDrawdown: stats.maxDrawdown,
+                profitFactor: stats.profitFactor,
+                avgWin: stats.avgWin,
+                avgLoss: stats.avgLoss
+              },
+              isCustom: scenario.isCustom
+            });
+            scenariosWithTrades++;
+            if (worstScenario === null || stats.netPl < worstScenario.netPl) {
+              worstScenario = { name: scenario.name, netPl: stats.netPl };
             }
-          };
-          const skippedNote = scenariosSkipped > 0 ? ` (${scenariosSkipped} skipped - no data coverage)` : "";
-          const preFilterNote = preFilteredScenarioNames.length > 0 ? ` (${preFilteredScenarioNames.length} excluded - outside portfolio date range)` : "";
-          const summary = `Stress Test: ${blockId} | ${scenariosWithTrades} scenarios with trades${skippedNote}${preFilterNote} | Worst: ${worstScenario?.name ?? "N/A"} (${worstScenario ? formatCurrency(worstScenario.netPl) : "N/A"}) | Best: ${bestScenario?.name ?? "N/A"} (${bestScenario ? formatCurrency(bestScenario.netPl) : "N/A"})`;
-          const structuredData = {
-            blockId,
-            scenarios: scenarioResults,
-            summary: summaryData,
-            availableBuiltInScenarios: Object.keys(STRESS_SCENARIOS)
-          };
-          return createToolOutput(summary, structuredData);
-        } catch (error) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error running stress test: ${error.message}`
-              }
-            ],
-            isError: true
-          };
+            if (bestScenario === null || stats.netPl > bestScenario.netPl) {
+              bestScenario = { name: scenario.name, netPl: stats.netPl };
+            }
+          }
         }
+        const summaryData = {
+          totalScenariosTested: scenariosToRun.length,
+          scenariosWithTrades,
+          scenariosSkipped,
+          ...skippedScenarioNames.length > 0 ? { skippedScenarios: skippedScenarioNames } : {},
+          ...preFilteredScenarioNames.length > 0 ? { preFilteredScenarios: preFilteredScenarioNames } : {},
+          worstScenario: worstScenario?.name ?? null,
+          bestScenario: bestScenario?.name ?? null,
+          portfolioDateRange: {
+            start: portfolioStartDate,
+            end: portfolioEndDate
+          }
+        };
+        const skippedNote = scenariosSkipped > 0 ? ` (${scenariosSkipped} skipped - no data coverage)` : "";
+        const preFilterNote = preFilteredScenarioNames.length > 0 ? ` (${preFilteredScenarioNames.length} excluded - outside portfolio date range)` : "";
+        const summary = `Stress Test: ${blockId} | ${scenariosWithTrades} scenarios with trades${skippedNote}${preFilterNote} | Worst: ${worstScenario?.name ?? "N/A"} (${worstScenario ? formatCurrency(worstScenario.netPl) : "N/A"}) | Best: ${bestScenario?.name ?? "N/A"} (${bestScenario ? formatCurrency(bestScenario.netPl) : "N/A"})`;
+        const structuredData = {
+          blockId,
+          scenarios: scenarioResults,
+          summary: summaryData,
+          availableBuiltInScenarios: Object.keys(STRESS_SCENARIOS)
+        };
+        return createToolOutput(summary, structuredData);
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error running stress test: ${error.message}`
+            }
+          ],
+          isError: true
+        };
       }
-    )
+    })
   );
   server.registerTool(
     "drawdown_attribution",
@@ -1394,9 +1333,7 @@ function registerAnalysisBlockTools(server, baseDir) {
       description: "Identify which strategies contributed most to losses during the portfolio's maximum drawdown period. Shows drawdown period (peak to trough) and per-strategy P/L attribution.",
       inputSchema: z3.object({
         blockId: z3.string().describe("Block folder name"),
-        strategy: z3.string().optional().describe(
-          "Optional: Filter to specific strategy before calculating drawdown"
-        ),
+        strategy: z3.string().optional().describe("Optional: Filter to specific strategy before calculating drawdown"),
         topN: z3.number().int().min(1).max(50).default(5).describe("Number of top contributors to return (default: 5)")
       })
     },
@@ -1429,9 +1366,7 @@ function registerAnalysisBlockTools(server, baseDir) {
         const initialCapital = (firstTrade.fundsAtClose ?? 1e4) - firstTrade.pl;
         let equity = initialCapital;
         let peakEquity = initialCapital;
-        let peakDate = new Date(
-          firstTrade.dateClosed ?? firstTrade.dateOpened
-        );
+        let peakDate = new Date(firstTrade.dateClosed ?? firstTrade.dateOpened);
         let maxDrawdown = 0;
         let maxDrawdownPct = 0;
         let troughDate = null;
@@ -1565,9 +1500,7 @@ function registerAnalysisBlockTools(server, baseDir) {
             ]
           };
         }
-        const strategies = Array.from(
-          new Set(trades.map((t) => t.strategy))
-        ).sort();
+        const strategies = Array.from(new Set(trades.map((t) => t.strategy))).sort();
         if (targetStrategy) {
           const matchedStrategy = strategies.find(
             (s) => s.toLowerCase() === targetStrategy.toLowerCase()
@@ -1586,10 +1519,7 @@ function registerAnalysisBlockTools(server, baseDir) {
         }
         if (strategies.length === 1) {
           const dailyLogs2 = block.dailyLogs && block.dailyLogs.length > 0 ? block.dailyLogs : void 0;
-          const baselineStats2 = calculator.calculatePortfolioStats(
-            trades,
-            dailyLogs2
-          );
+          const baselineStats2 = calculator.calculatePortfolioStats(trades, dailyLogs2);
           const summary2 = `Marginal Contribution: ${blockId} | Single strategy portfolio - cannot calculate marginal contribution`;
           const structuredData2 = {
             blockId,
@@ -1617,13 +1547,8 @@ function registerAnalysisBlockTools(server, baseDir) {
           return createToolOutput(summary2, structuredData2);
         }
         const dailyLogs = block.dailyLogs && block.dailyLogs.length > 0 ? block.dailyLogs : void 0;
-        const baselineStats = calculator.calculatePortfolioStats(
-          trades,
-          dailyLogs
-        );
-        const strategiesToAnalyze = targetStrategy ? strategies.filter(
-          (s) => s.toLowerCase() === targetStrategy.toLowerCase()
-        ) : strategies;
+        const baselineStats = calculator.calculatePortfolioStats(trades, dailyLogs);
+        const strategiesToAnalyze = targetStrategy ? strategies.filter((s) => s.toLowerCase() === targetStrategy.toLowerCase()) : strategies;
         const contributions = [];
         for (const strategy of strategiesToAnalyze) {
           const tradesWithout = trades.filter(
@@ -1666,21 +1591,20 @@ function registerAnalysisBlockTools(server, baseDir) {
         });
         const limitedContributions = targetStrategy ? contributions : contributions.slice(0, topN);
         const validContributions = contributions.filter((c) => c.marginalSharpe !== null);
-        const mostBeneficial = validContributions.length > 0 ? { strategy: validContributions[0].strategy, sharpe: validContributions[0].marginalSharpe } : null;
+        const mostBeneficial = validContributions.length > 0 ? {
+          strategy: validContributions[0].strategy,
+          sharpe: validContributions[0].marginalSharpe
+        } : null;
         const lastValid = validContributions[validContributions.length - 1];
         const leastBeneficial = validContributions.length > 0 ? { strategy: lastValid.strategy, sharpe: lastValid.marginalSharpe } : null;
         const summaryParts = [`Marginal Contribution: ${blockId}`];
         if (mostBeneficial && mostBeneficial.sharpe !== null) {
           const sharpeStr = mostBeneficial.sharpe >= 0 ? `+${formatRatio(mostBeneficial.sharpe)}` : formatRatio(mostBeneficial.sharpe);
-          summaryParts.push(
-            `Top: ${mostBeneficial.strategy} (Sharpe ${sharpeStr})`
-          );
+          summaryParts.push(`Top: ${mostBeneficial.strategy} (Sharpe ${sharpeStr})`);
         }
         if (leastBeneficial && leastBeneficial.sharpe !== null && leastBeneficial.strategy !== mostBeneficial?.strategy) {
           const sharpeStr = leastBeneficial.sharpe >= 0 ? `+${formatRatio(leastBeneficial.sharpe)}` : formatRatio(leastBeneficial.sharpe);
-          summaryParts.push(
-            `Worst: ${leastBeneficial.strategy} (Sharpe ${sharpeStr})`
-          );
+          summaryParts.push(`Worst: ${leastBeneficial.strategy} (Sharpe ${sharpeStr})`);
         }
         const summary = summaryParts.join(" | ");
         const structuredData = {
@@ -1774,9 +1698,7 @@ function registerSimilarityBlockTools(server, baseDir) {
               ]
             };
           }
-          const strategies = Array.from(
-            new Set(trades.map((t) => t.strategy))
-          ).sort();
+          const strategies = Array.from(new Set(trades.map((t) => t.strategy))).sort();
           if (strategies.length < 2) {
             return {
               content: [
@@ -1868,8 +1790,7 @@ function registerSimilarityBlockTools(server, baseDir) {
             }
           }
           pairs.sort((a, b) => {
-            if (a.compositeSimilarity === null && b.compositeSimilarity === null)
-              return 0;
+            if (a.compositeSimilarity === null && b.compositeSimilarity === null) return 0;
             if (a.compositeSimilarity === null) return 1;
             if (b.compositeSimilarity === null) return -1;
             return b.compositeSimilarity - a.compositeSimilarity;
@@ -1915,23 +1836,40 @@ function registerSimilarityBlockTools(server, baseDir) {
     {
       description: "Explore strategy weight combinations within a portfolio. Answer 'what if I scaled strategy X to 0.5x?' questions. Shows before/after comparison with per-strategy breakdown. Profile-aware: uses backtest block data, enforces maxContractsPerTrade ceilings, flags ignoreMarginReq. Multi-strategy mode combines trades from multiple blocks.",
       inputSchema: z4.object({
-        blockId: z4.string().describe("Block folder name (required for single-strategy mode, optional default for multi-strategy mode)"),
+        blockId: z4.string().describe(
+          "Block folder name (required for single-strategy mode, optional default for multi-strategy mode)"
+        ),
         strategyWeights: z4.record(z4.string(), z4.number().min(0).max(2)).optional().describe(
           'Weight per strategy, e.g., {"5/7 17\u0394": 0.5}. Unspecified strategies default to 1.0. Weight 0 = exclude strategy entirely. Max weight: 2.0. Ignored when strategies array is provided.'
         ),
-        strategies: z4.array(z4.object({
-          strategyName: z4.string().describe("Strategy name matching a stored profile"),
-          blockId: z4.string().describe("Block ID to source trades from (overrides top-level blockId for this strategy)"),
-          scaleFactor: z4.number().min(0).max(5).describe("Scale factor for this strategy (1.0 = current allocation)")
-        })).optional().describe("Multi-strategy mode: array of strategies with per-strategy block source and scale. When provided, ignores strategyWeights."),
-        showUncapped: z4.boolean().optional().default(false).describe("When true, also run without maxContractsPerTrade ceiling for side-by-side comparison"),
+        strategies: z4.array(
+          z4.object({
+            strategyName: z4.string().describe("Strategy name matching a stored profile"),
+            blockId: z4.string().describe(
+              "Block ID to source trades from (overrides top-level blockId for this strategy)"
+            ),
+            scaleFactor: z4.number().min(0).max(5).describe("Scale factor for this strategy (1.0 = current allocation)")
+          })
+        ).optional().describe(
+          "Multi-strategy mode: array of strategies with per-strategy block source and scale. When provided, ignores strategyWeights."
+        ),
+        showUncapped: z4.boolean().optional().default(false).describe(
+          "When true, also run without maxContractsPerTrade ceiling for side-by-side comparison"
+        ),
         startDate: z4.string().optional().describe("Start date filter (YYYY-MM-DD)"),
         endDate: z4.string().optional().describe("End date filter (YYYY-MM-DD)")
       })
     },
     withSyncedBlock(
       baseDir,
-      async ({ blockId, strategyWeights, strategies: strategiesInput, showUncapped, startDate, endDate }) => {
+      async ({
+        blockId,
+        strategyWeights,
+        strategies: strategiesInput,
+        showUncapped,
+        startDate,
+        endDate
+      }) => {
         try {
           let filterTradesByStrategy2 = function(allTrades, strategyName) {
             const matched = allTrades.filter(
@@ -2024,7 +1962,10 @@ function registerSimilarityBlockTools(server, baseDir) {
             const dataAvailability = [];
             for (const entry of strategiesInput) {
               const sourceBlockId = entry.blockId || blockId;
-              const { profile, status: profileStatus } = await tryGetProfile(sourceBlockId, entry.strategyName);
+              const { profile, status: profileStatus } = await tryGetProfile(
+                sourceBlockId,
+                entry.strategyName
+              );
               let tradeSourceBlockId = sourceBlockId;
               let dataSource = "multi_strategy_input";
               if (profile && profile.blockId !== sourceBlockId) {
@@ -2153,7 +2094,11 @@ function registerSimilarityBlockTools(server, baseDir) {
               }
               if (uncappedScaled.length > 0) {
                 const uncappedModified = buildModifiedTrades2(uncappedScaled, allOriginalTrades);
-                const uncappedStats = calculator.calculatePortfolioStats(uncappedModified, void 0, true);
+                const uncappedStats = calculator.calculatePortfolioStats(
+                  uncappedModified,
+                  void 0,
+                  true
+                );
                 uncappedComparison2 = {
                   sharpeRatio: uncappedStats.sharpeRatio,
                   sortinoRatio: uncappedStats.sortinoRatio,
@@ -2197,9 +2142,7 @@ function registerSimilarityBlockTools(server, baseDir) {
               isError: true
             };
           }
-          const allStrategies = Array.from(
-            new Set(trades.map((t) => t.strategy))
-          ).sort();
+          const allStrategies = Array.from(new Set(trades.map((t) => t.strategy))).sort();
           const appliedWeights = {};
           const unknownStrategies = [];
           for (const strategy of allStrategies) {
@@ -2217,9 +2160,7 @@ function registerSimilarityBlockTools(server, baseDir) {
               }
             }
           }
-          const allZeroWeight = Object.values(appliedWeights).every(
-            (w) => w === 0
-          );
+          const allZeroWeight = Object.values(appliedWeights).every((w) => w === 0);
           if (allZeroWeight) {
             return {
               content: [
@@ -2278,22 +2219,31 @@ function registerSimilarityBlockTools(server, baseDir) {
             hasCeilings ? maxContractsCeilings : void 0
           );
           const modifiedTrades = buildModifiedTrades2(scaledTrades, trades);
-          const scaledStats = calculator.calculatePortfolioStats(
-            modifiedTrades,
-            void 0,
-            true
-          );
+          const scaledStats = calculator.calculatePortfolioStats(modifiedTrades, void 0, true);
           let uncappedComparison;
           if (doShowUncapped && cappedStrategies.size > 0) {
             const { scaledTrades: uncappedScaled } = buildScaledTrades2(tradesToUse, appliedWeights);
             const uncappedModified = buildModifiedTrades2(uncappedScaled, trades);
-            const uncappedStats = calculator.calculatePortfolioStats(uncappedModified, void 0, true);
+            const uncappedStats = calculator.calculatePortfolioStats(
+              uncappedModified,
+              void 0,
+              true
+            );
             uncappedComparison = {
-              sharpeRatio: calcDelta2(baselineStats.sharpeRatio ?? null, uncappedStats.sharpeRatio ?? null),
-              sortinoRatio: calcDelta2(baselineStats.sortinoRatio ?? null, uncappedStats.sortinoRatio ?? null),
+              sharpeRatio: calcDelta2(
+                baselineStats.sharpeRatio ?? null,
+                uncappedStats.sharpeRatio ?? null
+              ),
+              sortinoRatio: calcDelta2(
+                baselineStats.sortinoRatio ?? null,
+                uncappedStats.sortinoRatio ?? null
+              ),
               maxDrawdown: calcDelta2(baselineStats.maxDrawdown, uncappedStats.maxDrawdown),
               netPl: calcDelta2(baselineStats.netPl, uncappedStats.netPl),
-              totalTrades: { original: baselineStats.totalTrades, scaled: uncappedStats.totalTrades }
+              totalTrades: {
+                original: baselineStats.totalTrades,
+                scaled: uncappedStats.totalTrades
+              }
             };
           }
           const comparison = {
@@ -2305,10 +2255,7 @@ function registerSimilarityBlockTools(server, baseDir) {
               baselineStats.sortinoRatio ?? null,
               scaledStats.sortinoRatio ?? null
             ),
-            maxDrawdown: calcDelta2(
-              baselineStats.maxDrawdown,
-              scaledStats.maxDrawdown
-            ),
+            maxDrawdown: calcDelta2(baselineStats.maxDrawdown, scaledStats.maxDrawdown),
             netPl: calcDelta2(baselineStats.netPl, scaledStats.netPl),
             totalTrades: {
               original: baselineStats.totalTrades,
@@ -2338,10 +2285,9 @@ function registerSimilarityBlockTools(server, baseDir) {
             scaledByStrategy[st.strategy].netPl += netPl;
             totalScaledPl += netPl;
           }
-          const allStrategyNames = Array.from(/* @__PURE__ */ new Set([
-            ...allStrategies,
-            ...Object.keys(originalByStrategy)
-          ])).sort();
+          const allStrategyNames = Array.from(
+            /* @__PURE__ */ new Set([...allStrategies, ...Object.keys(originalByStrategy)])
+          ).sort();
           for (const strategy of allStrategyNames) {
             const weight = appliedWeights[strategy] ?? 1;
             const orig = originalByStrategy[strategy] ?? { trades: 0, netPl: 0 };
@@ -2400,12 +2346,14 @@ function registerSimilarityBlockTools(server, baseDir) {
           };
           const anyProfileFound = Object.values(profileLookups).some((l) => l.status === "found");
           if (anyProfileFound) {
-            structuredData.dataAvailability = Object.entries(profileLookups).map(([strategy, lookup]) => ({
-              strategy,
-              profileStatus: lookup.status,
-              profileBlockId: lookup.profile?.blockId,
-              dataSource: dataSourceMap[strategy]
-            }));
+            structuredData.dataAvailability = Object.entries(profileLookups).map(
+              ([strategy, lookup]) => ({
+                strategy,
+                profileStatus: lookup.status,
+                profileBlockId: lookup.profile?.blockId,
+                dataSource: dataSourceMap[strategy]
+              })
+            );
           }
           if (backtestSubstitutions.length > 0) {
             structuredData.backtestSubstitutions = backtestSubstitutions;
@@ -3363,10 +3311,22 @@ var VIX_OHLCV_MAPPINGS = [
   { alias: "VIX_Low", tableAlias: "vix", sourceCol: "low", ticker: "VIX", timing: "close" },
   // VIX9D
   { alias: "VIX9D_Open", tableAlias: "vix9d", sourceCol: "open", ticker: "VIX9D", timing: "open" },
-  { alias: "VIX9D_Close", tableAlias: "vix9d", sourceCol: "close", ticker: "VIX9D", timing: "close" },
+  {
+    alias: "VIX9D_Close",
+    tableAlias: "vix9d",
+    sourceCol: "close",
+    ticker: "VIX9D",
+    timing: "close"
+  },
   // VIX3M
   { alias: "VIX3M_Open", tableAlias: "vix3m", sourceCol: "open", ticker: "VIX3M", timing: "open" },
-  { alias: "VIX3M_Close", tableAlias: "vix3m", sourceCol: "close", ticker: "VIX3M", timing: "close" }
+  {
+    alias: "VIX3M_Close",
+    tableAlias: "vix3m",
+    sourceCol: "close",
+    ticker: "VIX3M",
+    timing: "close"
+  }
 ];
 var VIX_ENRICHED_MAPPINGS = [
   { alias: "VIX_IVR", tableAlias: "evix", sourceCol: "ivr", ticker: "VIX", timing: "close" },
@@ -3376,10 +3336,7 @@ var VIX_ENRICHED_MAPPINGS = [
   { alias: "VIX3M_IVR", tableAlias: "evix3m", sourceCol: "ivr", ticker: "VIX3M", timing: "close" },
   { alias: "VIX3M_IVP", tableAlias: "evix3m", sourceCol: "ivp", ticker: "VIX3M", timing: "close" }
 ];
-var VIX_ALL_MAPPINGS = [
-  ...VIX_OHLCV_MAPPINGS,
-  ...VIX_ENRICHED_MAPPINGS
-];
+var VIX_ALL_MAPPINGS = [...VIX_OHLCV_MAPPINGS, ...VIX_ENRICHED_MAPPINGS];
 var VIX_TICKER_ALIASES = [...new Set(VIX_OHLCV_MAPPINGS.map((m) => m.tableAlias))];
 var VIX_TICKER_FOR_ALIAS = Object.fromEntries([
   ...VIX_OHLCV_MAPPINGS.map((m) => [m.tableAlias, m.ticker]),
@@ -3416,9 +3373,7 @@ var CLOSE_KNOWN_FIELDS = /* @__PURE__ */ new Set([
   ...DAILY_CLOSE_FIELDS,
   ...CONTEXT_CLOSE_FIELDS
 ]);
-var STATIC_FIELDS = /* @__PURE__ */ new Set([
-  ...DAILY_STATIC_FIELDS
-]);
+var STATIC_FIELDS = /* @__PURE__ */ new Set([...DAILY_STATIC_FIELDS]);
 function buildVixJoinClause(tickerAliases, baseAlias = "d") {
   return tickerAliases.flatMap((alias) => {
     const ticker = VIX_TICKER_FOR_ALIAS[alias];
@@ -3543,7 +3498,11 @@ function buildOutcomeQuery(tradeDatesOrKeys) {
   if (typeof tradeDatesOrKeys[0] === "string") {
     return buildOutcomeQueryForDates(tradeDatesOrKeys, vixCloseCols, derivedCloseCols);
   }
-  return buildOutcomeQueryForKeys(tradeDatesOrKeys, vixCloseCols, derivedCloseCols);
+  return buildOutcomeQueryForKeys(
+    tradeDatesOrKeys,
+    vixCloseCols,
+    derivedCloseCols
+  );
 }
 function buildTargetCloseCols(eAlias, sAlias) {
   return [...DAILY_CLOSE_FIELDS].map((f) => `${OHLCV_COLS.has(f) ? sAlias : eAlias}."${f}"`).join(", ");
@@ -3892,8 +3851,14 @@ function buildConcentrationSection(profiles) {
     else if (concentratedDimensions === 2) grade = "C";
     else grade = "F";
   }
-  for (const [dim, groups] of Object.entries({ structure: byStructure, underlying: byUnderlying, dte: byDte })) {
-    const topCategory = Object.entries(groups).sort((a, b) => b[1].allocationPct - a[1].allocationPct)[0];
+  for (const [dim, groups] of Object.entries({
+    structure: byStructure,
+    underlying: byUnderlying,
+    dte: byDte
+  })) {
+    const topCategory = Object.entries(groups).sort(
+      (a, b) => b[1].allocationPct - a[1].allocationPct
+    )[0];
     if (topCategory) {
       flags.push({
         type: "info",
@@ -3923,11 +3888,13 @@ function buildCorrelationRiskSection(profiles) {
   if (profiles.length < 2) {
     return {
       grade: null,
-      flags: [{
-        type: "info",
-        dimension: "correlationRisk",
-        message: "Skipped: need at least 2 profiles for correlation risk analysis"
-      }],
+      flags: [
+        {
+          type: "info",
+          dimension: "correlationRisk",
+          message: "Skipped: need at least 2 profiles for correlation risk analysis"
+        }
+      ],
       data: {},
       keyNumbers: {}
     };
@@ -4161,9 +4128,7 @@ function registerHealthBlockTools(server, baseDir) {
               isError: true
             };
           }
-          const strategies = Array.from(
-            new Set(trades.map((t) => t.strategy))
-          ).sort();
+          const strategies = Array.from(new Set(trades.map((t) => t.strategy))).sort();
           if (strategies.length < 2) {
             return {
               content: [
@@ -4317,9 +4282,7 @@ function registerHealthBlockTools(server, baseDir) {
             });
           }
           const corrStrategyIndex = /* @__PURE__ */ new Map();
-          correlationMatrix.strategies.forEach(
-            (s, i) => corrStrategyIndex.set(s, i)
-          );
+          correlationMatrix.strategies.forEach((s, i) => corrStrategyIndex.set(s, i));
           const highTailPairs = [];
           for (let i = 0; i < tailRisk.strategies.length; i++) {
             for (let j = i + 1; j < tailRisk.strategies.length; j++) {
@@ -4546,15 +4509,11 @@ function registerHealthBlockTools(server, baseDir) {
             oneLineSummary = "Portfolio shows strong diversification, controlled tail risk, and consistent Monte Carlo outcomes.";
           } else if (flagCount <= 2) {
             verdict = "MODERATE_CONCERNS";
-            const concernDimensions = [
-              ...new Set(warningFlags.map((f) => f.dimension))
-            ];
+            const concernDimensions = [...new Set(warningFlags.map((f) => f.dimension))];
             oneLineSummary = `Portfolio has ${flagCount} warning(s) in ${concernDimensions.join(", ")} - review flagged items.`;
           } else {
             verdict = "ISSUES_DETECTED";
-            const concernDimensions = [
-              ...new Set(warningFlags.map((f) => f.dimension))
-            ];
+            const concernDimensions = [...new Set(warningFlags.map((f) => f.dimension))];
             oneLineSummary = `Portfolio has ${flagCount} warnings across ${concernDimensions.join(", ")} - significant review recommended.`;
           }
           const keyNumbers = {
@@ -4643,9 +4602,7 @@ function registerBlockTools(server, baseDir) {
 import { z as z6 } from "zod";
 function filterByStrategy2(trades, strategy) {
   if (!strategy) return trades;
-  return trades.filter(
-    (t) => t.strategy.toLowerCase() === strategy.toLowerCase()
-  );
+  return trades.filter((t) => t.strategy.toLowerCase() === strategy.toLowerCase());
 }
 function registerAnalysisTools(server, baseDir) {
   server.registerTool(
@@ -4669,9 +4626,7 @@ function registerAnalysisTools(server, baseDir) {
         outOfSampleDays: z6.number().min(1).optional().describe(
           "Explicit out-of-sample period in days. Overrides oosWindowCount calculation if provided."
         ),
-        stepSizeDays: z6.number().min(1).optional().describe(
-          "Days to slide forward each period. If not provided, equals outOfSampleDays."
-        ),
+        stepSizeDays: z6.number().min(1).optional().describe("Days to slide forward each period. If not provided, equals outOfSampleDays."),
         // Optimization settings
         optimizationTarget: z6.enum([
           "netPl",
@@ -4691,26 +4646,43 @@ function registerAnalysisTools(server, baseDir) {
         selectedStrategies: z6.array(z6.string()).optional().describe("Filter to specific strategies only (default: all strategies)"),
         // Additional filters
         tickerFilter: z6.string().optional().describe("Filter trades by underlying ticker symbol (e.g., 'SPY', 'AAPL')"),
-        dateRangeFrom: z6.string().optional().describe("Start date for analysis (ISO format: YYYY-MM-DD). Only include trades on or after this date."),
-        dateRangeTo: z6.string().optional().describe("End date for analysis (ISO format: YYYY-MM-DD). Only include trades on or before this date."),
+        dateRangeFrom: z6.string().optional().describe(
+          "Start date for analysis (ISO format: YYYY-MM-DD). Only include trades on or after this date."
+        ),
+        dateRangeTo: z6.string().optional().describe(
+          "End date for analysis (ISO format: YYYY-MM-DD). Only include trades on or before this date."
+        ),
         // Performance floor constraints (reject parameter combinations that don't meet minimums)
-        minSharpeRatio: z6.number().optional().describe("Minimum Sharpe ratio required during in-sample optimization. Combinations below this are rejected."),
-        minProfitFactor: z6.number().min(0).optional().describe("Minimum profit factor required during in-sample optimization. Combinations below this are rejected."),
-        requirePositiveNetPl: z6.boolean().default(false).describe("Require positive net P&L during in-sample optimization. Reject combinations with losses."),
+        minSharpeRatio: z6.number().optional().describe(
+          "Minimum Sharpe ratio required during in-sample optimization. Combinations below this are rejected."
+        ),
+        minProfitFactor: z6.number().min(0).optional().describe(
+          "Minimum profit factor required during in-sample optimization. Combinations below this are rejected."
+        ),
+        requirePositiveNetPl: z6.boolean().default(false).describe(
+          "Require positive net P&L during in-sample optimization. Reject combinations with losses."
+        ),
         // Diversification constraints
-        enableCorrelationConstraint: z6.boolean().default(false).describe("Enable correlation constraint to reject highly correlated strategy combinations during optimization."),
-        maxCorrelationThreshold: z6.number().min(0).max(1).default(0.7).describe("Maximum allowed correlation between any strategy pair (default: 0.7). Only used if enableCorrelationConstraint is true."),
+        enableCorrelationConstraint: z6.boolean().default(false).describe(
+          "Enable correlation constraint to reject highly correlated strategy combinations during optimization."
+        ),
+        maxCorrelationThreshold: z6.number().min(0).max(1).default(0.7).describe(
+          "Maximum allowed correlation between any strategy pair (default: 0.7). Only used if enableCorrelationConstraint is true."
+        ),
         correlationMethod: z6.enum(["kendall", "spearman", "pearson"]).default("kendall").describe("Correlation method for diversification constraint (default: kendall)."),
-        enableTailRiskConstraint: z6.boolean().default(false).describe("Enable tail risk constraint to reject combinations with high joint tail dependence."),
-        maxTailDependenceThreshold: z6.number().min(0).max(1).default(0.5).describe("Maximum allowed tail dependence between any strategy pair (default: 0.5). Only used if enableTailRiskConstraint is true."),
-        tailThreshold: z6.number().min(0.01).max(0.5).default(0.1).describe("Percentile threshold for tail definition (default: 0.1 = worst 10%). Only used if enableTailRiskConstraint is true."),
+        enableTailRiskConstraint: z6.boolean().default(false).describe(
+          "Enable tail risk constraint to reject combinations with high joint tail dependence."
+        ),
+        maxTailDependenceThreshold: z6.number().min(0).max(1).default(0.5).describe(
+          "Maximum allowed tail dependence between any strategy pair (default: 0.5). Only used if enableTailRiskConstraint is true."
+        ),
+        tailThreshold: z6.number().min(0.01).max(0.5).default(0.1).describe(
+          "Percentile threshold for tail definition (default: 0.1 = worst 10%). Only used if enableTailRiskConstraint is true."
+        ),
         diversificationNormalization: z6.enum(["raw", "margin", "notional"]).default("raw").describe("How to normalize returns for diversification calculations (default: raw)."),
         diversificationDateBasis: z6.enum(["opened", "closed"]).default("opened").describe("Which trade date to use for diversification calculations (default: opened)."),
         // Parameter ranges for position sizing sweeps
-        parameterRanges: z6.record(
-          z6.string(),
-          z6.array(z6.number()).min(3).max(3)
-        ).optional().describe(
+        parameterRanges: z6.record(z6.string(), z6.array(z6.number()).min(3).max(3)).optional().describe(
           `Parameter ranges for optimization sweep. Format: {paramName: [min, max, step]}. POSITION SIZING: 'kellyMultiplier' scales P&L by multiplier (e.g., {"kellyMultiplier": [0.25, 1.0, 0.25]} tests quarter/half/3-quarter/full Kelly); 'fixedFractionPct' scales relative to 2% baseline (e.g., [1, 4, 1] tests 1-4%); 'fixedContracts' scales relative to avg contracts (e.g., [1, 5, 1] tests 1-5 contracts). RISK CONSTRAINTS (reject combinations exceeding threshold): 'maxDrawdownPct' max drawdown % (e.g., [15, 25, 5] allows 15-25%); 'maxDailyLossPct' max single-day loss %; 'consecutiveLossLimit' max consecutive losing trades. STRATEGY WEIGHTS: 'strategy:StrategyName' weight multiplier per strategy (e.g., {"strategy:IronCondor": [0, 1, 0.5], "strategy:Straddle": [0, 1, 0.5]} tests include/exclude combinations). Multiple parameters create a grid search across all combinations.`
         )
       })
@@ -4750,18 +4722,12 @@ function registerAnalysisTools(server, baseDir) {
         trades = filterByStrategy2(trades, strategy);
         if (tickerFilter) {
           const tickerLower = tickerFilter.toLowerCase();
-          trades = trades.filter(
-            (t) => resolveTradeTicker(t).toLowerCase() === tickerLower
-          );
+          trades = trades.filter((t) => resolveTradeTicker(t).toLowerCase() === tickerLower);
         }
         trades = filterByDateRange(trades, dateRangeFrom, dateRangeTo);
         if (selectedStrategies && selectedStrategies.length > 0) {
-          const strategySet = new Set(
-            selectedStrategies.map((s) => s.toLowerCase())
-          );
-          trades = trades.filter(
-            (t) => strategySet.has(t.strategy.toLowerCase())
-          );
+          const strategySet = new Set(selectedStrategies.map((s) => s.toLowerCase()));
+          trades = trades.filter((t) => strategySet.has(t.strategy.toLowerCase()));
         }
         if (trades.length < 20) {
           return {
@@ -4778,9 +4744,7 @@ function registerAnalysisTools(server, baseDir) {
           (a, b) => new Date(a.dateOpened).getTime() - new Date(b.dateOpened).getTime()
         );
         const firstDate = new Date(sortedTrades[0].dateOpened);
-        const lastDate = new Date(
-          sortedTrades[sortedTrades.length - 1].dateOpened
-        );
+        const lastDate = new Date(sortedTrades[sortedTrades.length - 1].dateOpened);
         const totalDays = Math.ceil(
           (lastDate.getTime() - firstDate.getTime()) / (24 * 60 * 60 * 1e3)
         );
@@ -5114,9 +5078,15 @@ function registerAnalysisTools(server, baseDir) {
         minSamples: z6.number().min(2).default(10).describe("Minimum shared trading periods required for valid correlation (default: 10)"),
         strategyFilter: z6.array(z6.string()).optional().describe("Filter to specific strategies only (default: all strategies)"),
         tickerFilter: z6.string().optional().describe("Filter trades by underlying ticker symbol (e.g., 'SPY', 'AAPL')"),
-        dateRangeFrom: z6.string().optional().describe("Start date for analysis (ISO format: YYYY-MM-DD). Only include trades on or after this date."),
-        dateRangeTo: z6.string().optional().describe("End date for analysis (ISO format: YYYY-MM-DD). Only include trades on or before this date."),
-        highlightThreshold: z6.number().min(0).max(1).default(0.7).describe("Threshold for highlighting highly correlated pairs (default: 0.7 = |r| > 0.7)")
+        dateRangeFrom: z6.string().optional().describe(
+          "Start date for analysis (ISO format: YYYY-MM-DD). Only include trades on or after this date."
+        ),
+        dateRangeTo: z6.string().optional().describe(
+          "End date for analysis (ISO format: YYYY-MM-DD). Only include trades on or before this date."
+        ),
+        highlightThreshold: z6.number().min(0).max(1).default(0.7).describe(
+          "Threshold for highlighting highly correlated pairs (default: 0.7 = |r| > 0.7)"
+        )
       })
     },
     async ({
@@ -5138,18 +5108,14 @@ function registerAnalysisTools(server, baseDir) {
         let trades = block.trades;
         if (tickerFilter) {
           const tickerLower = tickerFilter.toLowerCase();
-          trades = trades.filter(
-            (t) => resolveTradeTicker(t).toLowerCase() === tickerLower
-          );
+          trades = trades.filter((t) => resolveTradeTicker(t).toLowerCase() === tickerLower);
         }
         trades = filterByDateRange(trades, dateRangeFrom, dateRangeTo);
         if (strategyFilter && strategyFilter.length > 0) {
           const strategySet = new Set(strategyFilter.map((s) => s.toLowerCase()));
           trades = trades.filter((t) => strategySet.has(t.strategy.toLowerCase()));
         }
-        const strategies = Array.from(
-          new Set(trades.map((t) => t.strategy))
-        ).filter(Boolean);
+        const strategies = Array.from(new Set(trades.map((t) => t.strategy))).filter(Boolean);
         if (strategies.length < 2) {
           return {
             content: [
@@ -5251,8 +5217,12 @@ function registerAnalysisTools(server, baseDir) {
         dateBasis: z6.enum(["opened", "closed"]).default("opened").describe("Which trade date to use for grouping"),
         strategyFilter: z6.array(z6.string()).optional().describe("Filter to specific strategies only (default: all strategies)"),
         tickerFilter: z6.string().optional().describe("Filter trades by underlying ticker symbol (e.g., 'SPY', 'AAPL')"),
-        dateRangeFrom: z6.string().optional().describe("Start date for analysis (ISO format: YYYY-MM-DD). Only include trades on or after this date."),
-        dateRangeTo: z6.string().optional().describe("End date for analysis (ISO format: YYYY-MM-DD). Only include trades on or before this date."),
+        dateRangeFrom: z6.string().optional().describe(
+          "Start date for analysis (ISO format: YYYY-MM-DD). Only include trades on or after this date."
+        ),
+        dateRangeTo: z6.string().optional().describe(
+          "End date for analysis (ISO format: YYYY-MM-DD). Only include trades on or before this date."
+        ),
         varianceThreshold: z6.number().min(0.5).max(0.99).default(0.8).describe(
           "Variance threshold for determining effective factors (0.8 = 80% variance explained)"
         )
@@ -5273,9 +5243,7 @@ function registerAnalysisTools(server, baseDir) {
       try {
         const block = await loadBlock(baseDir, blockId);
         const trades = block.trades;
-        const strategies = Array.from(
-          new Set(trades.map((t) => t.strategy))
-        ).filter(Boolean);
+        const strategies = Array.from(new Set(trades.map((t) => t.strategy))).filter(Boolean);
         if (strategies.length < 2) {
           return {
             content: [
@@ -5355,7 +5323,9 @@ function registerAnalysisTools(server, baseDir) {
       inputSchema: z6.object({
         blockId: z6.string().describe("Block folder name"),
         capitalBase: z6.number().positive().describe("Starting capital in dollars"),
-        strategy: z6.string().optional().describe("Filter to a specific strategy name (case-insensitive). If provided, only calculates Kelly for that strategy."),
+        strategy: z6.string().optional().describe(
+          "Filter to a specific strategy name (case-insensitive). If provided, only calculates Kelly for that strategy."
+        ),
         kellyFraction: z6.enum(["full", "half", "quarter"]).default("half").describe(
           "Kelly fraction to use: 'full' (100%), 'half' (50%, recommended), 'quarter' (25%, conservative)"
         ),
@@ -5366,8 +5336,12 @@ function registerAnalysisTools(server, baseDir) {
         useMarginReturns: z6.boolean().default(false).describe(
           "Prefer percentage returns based on margin requirement instead of absolute P&L. More appropriate for compounding strategies with variable position sizes."
         ),
-        minTrades: z6.number().min(1).default(10).describe("Minimum trades required per strategy for valid Kelly calculation (default: 10)"),
-        sortBy: z6.enum(["name", "kelly", "winRate", "payoffRatio", "allocation"]).default("kelly").describe("Sort strategies by: 'name', 'kelly' percentage, 'winRate', 'payoffRatio', or 'allocation' amount"),
+        minTrades: z6.number().min(1).default(10).describe(
+          "Minimum trades required per strategy for valid Kelly calculation (default: 10)"
+        ),
+        sortBy: z6.enum(["name", "kelly", "winRate", "payoffRatio", "allocation"]).default("kelly").describe(
+          "Sort strategies by: 'name', 'kelly' percentage, 'winRate', 'payoffRatio', or 'allocation' amount"
+        ),
         sortOrder: z6.enum(["asc", "desc"]).default("desc").describe("Sort direction: 'asc' (ascending) or 'desc' (descending)")
       })
     },
@@ -5472,7 +5446,12 @@ function registerAnalysisTools(server, baseDir) {
           }
         }
         const kellyDisplay = portfolioKelly.hasValidKelly ? formatPercent(portfolioKelly.percent) : "N/A";
-        const allocDisplay = portfolioKelly.hasValidKelly ? formatCurrency(capitalBase * Math.max(0, Math.min(portfolioKelly.fraction * kellyMultiplier, maxAllocationFraction))) : "N/A";
+        const allocDisplay = portfolioKelly.hasValidKelly ? formatCurrency(
+          capitalBase * Math.max(
+            0,
+            Math.min(portfolioKelly.fraction * kellyMultiplier, maxAllocationFraction)
+          )
+        ) : "N/A";
         const summary = `Position Sizing: ${blockId}${strategy ? ` (${strategy})` : ""} | Kelly: ${kellyDisplay} | ${kellyFraction} allocation: ${allocDisplay} | ${strategyResults.length} strategies`;
         const structuredData = {
           blockId,
@@ -5498,7 +5477,10 @@ function registerAnalysisTools(server, baseDir) {
             rawKellyPercent: portfolioKelly.percent,
             hasValidKelly: portfolioKelly.hasValidKelly,
             adjustedKellyFraction: portfolioKelly.hasValidKelly ? Math.min(portfolioKelly.fraction * kellyMultiplier, maxAllocationFraction) : null,
-            recommendedAllocation: portfolioKelly.hasValidKelly ? capitalBase * Math.max(0, Math.min(portfolioKelly.fraction * kellyMultiplier, maxAllocationFraction)) : null,
+            recommendedAllocation: portfolioKelly.hasValidKelly ? capitalBase * Math.max(
+              0,
+              Math.min(portfolioKelly.fraction * kellyMultiplier, maxAllocationFraction)
+            ) : null,
             fullKelly: portfolioKelly.hasValidKelly ? Math.min(portfolioKelly.fraction, maxAllocationFraction) : null,
             halfKelly: portfolioKelly.hasValidKelly ? Math.min(portfolioKelly.fraction / 2, maxAllocationFraction) : null,
             quarterKelly: portfolioKelly.hasValidKelly ? Math.min(portfolioKelly.fraction / 4, maxAllocationFraction) : null,
@@ -5509,25 +5491,27 @@ function registerAnalysisTools(server, baseDir) {
             calculationMethod: portfolioKelly.calculationMethod ?? null,
             hasUnrealisticValues: portfolioKelly.hasUnrealisticValues ?? false
           },
-          strategies: strategyResults.map(({ name, kelly, rawAllocation, adjustedAllocation, tradeCount }) => ({
-            name,
-            tradeCount,
-            winRate: kelly.winRate,
-            avgWin: kelly.avgWin,
-            avgLoss: kelly.avgLoss,
-            payoffRatio: kelly.payoffRatio,
-            rawKellyFraction: kelly.fraction,
-            rawKellyPercent: kelly.percent,
-            hasValidKelly: kelly.hasValidKelly,
-            rawAllocation,
-            adjustedAllocation,
-            // Margin-based metrics
-            avgWinPct: kelly.avgWinPct ?? null,
-            avgLossPct: kelly.avgLossPct ?? null,
-            normalizedKellyPct: kelly.normalizedKellyPct ?? null,
-            calculationMethod: kelly.calculationMethod ?? null,
-            hasUnrealisticValues: kelly.hasUnrealisticValues ?? false
-          })),
+          strategies: strategyResults.map(
+            ({ name, kelly, rawAllocation, adjustedAllocation, tradeCount }) => ({
+              name,
+              tradeCount,
+              winRate: kelly.winRate,
+              avgWin: kelly.avgWin,
+              avgLoss: kelly.avgLoss,
+              payoffRatio: kelly.payoffRatio,
+              rawKellyFraction: kelly.fraction,
+              rawKellyPercent: kelly.percent,
+              hasValidKelly: kelly.hasValidKelly,
+              rawAllocation,
+              adjustedAllocation,
+              // Margin-based metrics
+              avgWinPct: kelly.avgWinPct ?? null,
+              avgLossPct: kelly.avgLossPct ?? null,
+              normalizedKellyPct: kelly.normalizedKellyPct ?? null,
+              calculationMethod: kelly.calculationMethod ?? null,
+              hasUnrealisticValues: kelly.hasUnrealisticValues ?? false
+            })
+          ),
           skippedStrategies,
           warnings
         };
@@ -5651,14 +5635,10 @@ function createExcursionDistribution(dataPoints, bucketSize = 10) {
 }
 function filterByStrategy3(trades, strategy) {
   if (!strategy) return trades;
-  return trades.filter(
-    (t) => t.strategy.toLowerCase() === strategy.toLowerCase()
-  );
+  return trades.filter((t) => t.strategy.toLowerCase() === strategy.toLowerCase());
 }
 function getISOWeekNumber(date) {
-  const d = new Date(
-    Date.UTC(date.getFullYear(), date.getMonth(), date.getDate())
-  );
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
   const dayNum = d.getUTCDay() || 7;
   d.setUTCDate(d.getUTCDate() + 4 - dayNum);
   const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
@@ -5749,15 +5729,7 @@ function buildReturnDistribution(trades, bucketCount = 20) {
   return buckets;
 }
 function buildDayOfWeekData(trades) {
-  const dayNames = [
-    "Monday",
-    "Tuesday",
-    "Wednesday",
-    "Thursday",
-    "Friday",
-    "Saturday",
-    "Sunday"
-  ];
+  const dayNames = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
   const dayData = {};
   trades.forEach((trade) => {
     const date = new Date(trade.dateOpened);
@@ -6200,15 +6172,9 @@ function registerPerformanceTools(server, baseDir) {
         normalizeTo1Lot: z7.boolean().default(false).describe(
           "Normalize all trades to 1 contract for fair comparison across different position sizes"
         ),
-        bucketCount: z7.number().min(5).max(100).default(20).describe(
-          "Number of histogram buckets for return_distribution (default: 20)"
-        ),
-        rollingWindowSize: z7.number().min(10).max(100).default(30).describe(
-          "Window size for rolling_metrics calculation (default: 30 trades)"
-        ),
-        mfeMaeBucketSize: z7.number().min(1).max(50).default(10).describe(
-          "Bucket size (in %) for MFE/MAE distribution histogram (default: 10%)"
-        ),
+        bucketCount: z7.number().min(5).max(100).default(20).describe("Number of histogram buckets for return_distribution (default: 20)"),
+        rollingWindowSize: z7.number().min(10).max(100).default(30).describe("Window size for rolling_metrics calculation (default: 30 trades)"),
+        mfeMaeBucketSize: z7.number().min(1).max(50).default(10).describe("Bucket size (in %) for MFE/MAE distribution histogram (default: 10%)"),
         maxDataPoints: z7.number().min(50).max(1e4).default(500).describe(
           "Maximum data points for per-trade chart types (volatility_regimes, mfe_mae, trade_sequence, holding_periods, premium_efficiency, margin_utilization, rom_timeline). When exceeded, data is truncated with a flag. Default: 500."
         )
@@ -6229,7 +6195,11 @@ function registerPerformanceTools(server, baseDir) {
         let truncateArray2 = function(arr) {
           if (arr.length <= maxDataPoints) return arr;
           anyTruncated = true;
-          return { data: arr.slice(0, maxDataPoints), truncated: true, totalPoints: arr.length };
+          return {
+            data: arr.slice(0, maxDataPoints),
+            truncated: true,
+            totalPoints: arr.length
+          };
         }, outputLength2 = function(result) {
           return Array.isArray(result) ? result.length : result.data.length;
         };
@@ -6285,10 +6255,7 @@ function registerPerformanceTools(server, baseDir) {
           }
         }
         if (charts.includes("return_distribution")) {
-          chartData.returnDistribution = buildReturnDistribution(
-            trades,
-            bucketCount
-          );
+          chartData.returnDistribution = buildReturnDistribution(trades, bucketCount);
           dataPoints += chartData.returnDistribution.length;
         }
         if (charts.includes("day_of_week")) {
@@ -6312,10 +6279,7 @@ function registerPerformanceTools(server, baseDir) {
           dataPoints += outputLength2(result);
         }
         if (charts.includes("rolling_metrics")) {
-          chartData.rollingMetrics = buildRollingMetrics(
-            trades,
-            rollingWindowSize
-          );
+          chartData.rollingMetrics = buildRollingMetrics(trades, rollingWindowSize);
           dataPoints += chartData.rollingMetrics.length;
         }
         if (charts.includes("exit_reason_breakdown")) {
@@ -6370,7 +6334,11 @@ function registerPerformanceTools(server, baseDir) {
           let mfeOutputCount;
           if (simplifiedData.length > maxDataPoints) {
             anyTruncated = true;
-            mfeDataPointsOutput = { data: simplifiedData.slice(0, maxDataPoints), truncated: true, totalPoints: simplifiedData.length };
+            mfeDataPointsOutput = {
+              data: simplifiedData.slice(0, maxDataPoints),
+              truncated: true,
+              totalPoints: simplifiedData.length
+            };
             mfeOutputCount = maxDataPoints;
           } else {
             mfeDataPointsOutput = simplifiedData;
@@ -6414,9 +6382,7 @@ function registerPerformanceTools(server, baseDir) {
         const filters = [];
         if (strategy) filters.push(`strategy=${strategy}`);
         if (dateRange?.from || dateRange?.to) {
-          filters.push(
-            `date=${dateRange.from ?? "start"} to ${dateRange.to ?? "end"}`
-          );
+          filters.push(`date=${dateRange.from ?? "start"} to ${dateRange.to ?? "end"}`);
         }
         if (normalizeTo1Lot) filters.push("normalized");
         const filterStr = filters.length > 0 ? ` (${filters.join(", ")})` : "";
@@ -6462,9 +6428,7 @@ function registerPerformanceTools(server, baseDir) {
           from: z7.string().optional().describe("Start date YYYY-MM-DD (inclusive)"),
           to: z7.string().optional().describe("End date YYYY-MM-DD (inclusive)")
         }).optional().describe("Filter trades to date range (takes precedence over year)"),
-        normalizeTo1Lot: z7.boolean().default(false).describe(
-          "Normalize all trades to 1 contract for fair comparison"
-        )
+        normalizeTo1Lot: z7.boolean().default(false).describe("Normalize all trades to 1 contract for fair comparison")
       })
     },
     async ({ blockId, strategy, period, year, dateRange, normalizeTo1Lot }) => {
@@ -6475,9 +6439,7 @@ function registerPerformanceTools(server, baseDir) {
         if (dateRange) {
           trades = filterByDateRange2(trades, dateRange.from, dateRange.to);
         } else if (year !== void 0) {
-          trades = trades.filter(
-            (t) => new Date(t.dateOpened).getFullYear() === year
-          );
+          trades = trades.filter((t) => new Date(t.dateOpened).getFullYear() === year);
         }
         if (normalizeTo1Lot) {
           trades = normalizeToOneLot(trades);
@@ -6534,9 +6496,7 @@ function registerPerformanceTools(server, baseDir) {
         const filters = [];
         if (strategy) filters.push(`strategy=${strategy}`);
         if (dateRange?.from || dateRange?.to) {
-          filters.push(
-            `date=${dateRange.from ?? "start"} to ${dateRange.to ?? "end"}`
-          );
+          filters.push(`date=${dateRange.from ?? "start"} to ${dateRange.to ?? "end"}`);
         } else if (year !== void 0) {
           filters.push(`year=${year}`);
         }
@@ -6591,18 +6551,24 @@ function registerPerformanceTools(server, baseDir) {
         detailLevel: z7.enum(["summary", "trades"]).default("summary").describe(
           "'summary' (default): aggregate by date+strategy. 'trades': individual trade comparison with field-by-field differences"
         ),
-        outliersOnly: z7.boolean().default(false).describe(
-          "Only return high-slippage outliers (trades exceeding z-score threshold)"
-        ),
-        outliersThreshold: z7.number().default(2).describe(
-          "Z-score threshold for outlier detection (default: 2 = ~95% confidence)"
-        ),
+        outliersOnly: z7.boolean().default(false).describe("Only return high-slippage outliers (trades exceeding z-score threshold)"),
+        outliersThreshold: z7.number().default(2).describe("Z-score threshold for outlier detection (default: 2 = ~95% confidence)"),
         groupBy: z7.enum(["none", "strategy", "date", "week", "month"]).default("none").describe(
           "Group results: 'none' (flat list), 'strategy', 'date' (daily), 'week', 'month'"
         )
       })
     },
-    async ({ blockId, strategy, scaling, dateRange, matchedOnly, detailLevel, outliersOnly, outliersThreshold, groupBy }) => {
+    async ({
+      blockId,
+      strategy,
+      scaling,
+      dateRange,
+      matchedOnly,
+      detailLevel,
+      outliersOnly,
+      outliersThreshold,
+      groupBy
+    }) => {
       try {
         const block = await loadBlock(baseDir, blockId);
         let backtestTrades = block.trades;
@@ -6966,10 +6932,7 @@ function registerPerformanceTools(server, baseDir) {
         const slippageValues = matchedComparisons.map((c) => c.slippage);
         if (slippageValues.length >= 3) {
           const meanSlippage = slippageValues.reduce((sum, v) => sum + v, 0) / slippageValues.length;
-          const variance = slippageValues.reduce(
-            (sum, v) => sum + Math.pow(v - meanSlippage, 2),
-            0
-          ) / slippageValues.length;
+          const variance = slippageValues.reduce((sum, v) => sum + Math.pow(v - meanSlippage, 2), 0) / slippageValues.length;
           const stdDevSlippage = Math.sqrt(variance);
           if (stdDevSlippage >= 1e-10) {
             for (const comparison of comparisons) {
@@ -6989,10 +6952,7 @@ function registerPerformanceTools(server, baseDir) {
               }
             }
             const outliers = comparisons.filter((c) => c.isOutlier);
-            const outlierTotalSlippage = outliers.reduce(
-              (sum, c) => sum + c.slippage,
-              0
-            );
+            const outlierTotalSlippage = outliers.reduce((sum, c) => sum + c.slippage, 0);
             outlierStats = {
               meanSlippage,
               stdDevSlippage,
@@ -7007,9 +6967,7 @@ function registerPerformanceTools(server, baseDir) {
         const unmatchedBacktestEntries = comparisons.filter(
           (c) => !c.matched && c.backtestPl !== 0
         );
-        const unmatchedActualEntries = comparisons.filter(
-          (c) => !c.matched && c.actualPl !== 0
-        );
+        const unmatchedActualEntries = comparisons.filter((c) => !c.matched && c.actualPl !== 0);
         const unmatchedBacktestSummary = unmatchedBacktestEntries.length > 0 ? {
           count: unmatchedBacktestEntries.length,
           dateRange: {
@@ -7017,7 +6975,9 @@ function registerPerformanceTools(server, baseDir) {
             to: unmatchedBacktestEntries.reduce((a, b) => a.date > b.date ? a : b).date
           },
           totalPl: unmatchedBacktestEntries.reduce((sum, c) => sum + c.backtestPl, 0),
-          strategies: Array.from(new Set(unmatchedBacktestEntries.map((c) => c.strategy))).sort()
+          strategies: Array.from(
+            new Set(unmatchedBacktestEntries.map((c) => c.strategy))
+          ).sort()
         } : null;
         const unmatchedActualSummary = unmatchedActualEntries.length > 0 ? {
           count: unmatchedActualEntries.length,
@@ -7026,15 +6986,15 @@ function registerPerformanceTools(server, baseDir) {
             to: unmatchedActualEntries.reduce((a, b) => a.date > b.date ? a : b).date
           },
           totalPl: unmatchedActualEntries.reduce((sum, c) => sum + c.actualPl, 0),
-          strategies: Array.from(new Set(unmatchedActualEntries.map((c) => c.strategy))).sort()
+          strategies: Array.from(
+            new Set(unmatchedActualEntries.map((c) => c.strategy))
+          ).sort()
         } : null;
         let outputComparisons = matchedOnly ? comparisons.filter((c) => c.matched) : [...comparisons];
         if (outliersOnly) {
           outputComparisons = outputComparisons.filter((c) => c.isOutlier);
         }
-        outputComparisons.sort(
-          (a, b) => Math.abs(b.slippage) - Math.abs(a.slippage)
-        );
+        outputComparisons.sort((a, b) => Math.abs(b.slippage) - Math.abs(a.slippage));
         let groups = null;
         if (groupBy !== "none") {
           const groupMap = /* @__PURE__ */ new Map();
@@ -7046,13 +7006,8 @@ function registerPerformanceTools(server, baseDir) {
           }
           groups = Array.from(groupMap.entries()).map(([groupKey, groupComparisons]) => {
             const matchedInGroup = groupComparisons.filter((c) => c.matched);
-            const totalSlippage2 = groupComparisons.reduce(
-              (sum, c) => sum + c.slippage,
-              0
-            );
-            const outlierCount = groupComparisons.filter(
-              (c) => c.isOutlier
-            ).length;
+            const totalSlippage2 = groupComparisons.reduce((sum, c) => sum + c.slippage, 0);
+            const outlierCount = groupComparisons.filter((c) => c.isOutlier).length;
             return {
               groupKey,
               count: groupComparisons.length,
@@ -7080,15 +7035,11 @@ function registerPerformanceTools(server, baseDir) {
         const backtestStrategies = Array.from(
           new Set(backtestTrades.map((t) => t.strategy))
         ).sort();
-        const actualStrategies = Array.from(
-          new Set(actualTrades.map((t) => t.strategy))
-        ).sort();
+        const actualStrategies = Array.from(new Set(actualTrades.map((t) => t.strategy))).sort();
         const filters = [];
         if (strategy) filters.push(`strategy=${strategy}`);
         if (dateRange?.from || dateRange?.to) {
-          filters.push(
-            `date=${dateRange.from ?? "start"} to ${dateRange.to ?? "end"}`
-          );
+          filters.push(`date=${dateRange.from ?? "start"} to ${dateRange.to ?? "end"}`);
         }
         if (autoFilterApplied) filters.push("auto-date-overlap");
         if (matchedOnly) filters.push("matched-only");
@@ -7196,9 +7147,7 @@ function getISOWeekNumber2(date) {
   const dayNum = d.getDay() || 7;
   d.setDate(d.getDate() + 4 - dayNum);
   const yearStart = new Date(d.getFullYear(), 0, 1);
-  const weekNo = Math.ceil(
-    ((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7
-  );
+  const weekNo = Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
   return weekNo;
 }
 function enrichTrades(trades) {
@@ -7317,10 +7266,7 @@ function generateHistogram(values, bucketCount = 10) {
     buckets.push({ min: bucketMin, max: bucketMax, count: 0 });
   }
   for (const value of values) {
-    const bucketIndex = Math.min(
-      Math.floor((value - min) / bucketSize),
-      bucketCount - 1
-    );
+    const bucketIndex = Math.min(Math.floor((value - min) / bucketSize), bucketCount - 1);
     if (bucketIndex >= 0 && bucketIndex < buckets.length) {
       buckets[bucketIndex].count++;
     }
@@ -7336,9 +7282,7 @@ function registerFieldTools(server, baseDir) {
       description: "Get detailed statistics for a specific field including min/max/avg/median/stdDev, percentiles, and histogram",
       inputSchema: z8.object({
         blockId: z8.string().describe("Block folder name"),
-        field: z8.string().describe(
-          "Field name to analyze (e.g., 'openingVix', 'pl', 'rom', 'mfePercent')"
-        ),
+        field: z8.string().describe("Field name to analyze (e.g., 'openingVix', 'pl', 'rom', 'mfePercent')"),
         strategy: z8.string().optional().describe("Filter by strategy name (case-insensitive)"),
         startDate: z8.string().optional().describe("Filter by start date (YYYY-MM-DD)"),
         endDate: z8.string().optional().describe("Filter by end date (YYYY-MM-DD)"),
@@ -7347,14 +7291,7 @@ function registerFieldTools(server, baseDir) {
     },
     withSyncedBlock(
       baseDir,
-      async ({
-        blockId,
-        field,
-        strategy,
-        startDate,
-        endDate,
-        histogramBuckets
-      }) => {
+      async ({ blockId, field, strategy, startDate, endDate, histogramBuckets }) => {
         try {
           const block = await loadBlock(baseDir, blockId);
           let trades = block.trades;
@@ -7453,7 +7390,9 @@ function registerPredictiveTools(server, baseDir) {
       inputSchema: z9.object({
         blockId: z9.string().describe("Block folder name"),
         strategy: z9.string().optional().describe("Pre-filter by strategy name (case-insensitive)"),
-        strategyName: z9.string().optional().describe("Strategy profile name. When provided, auto-filters to that strategy's trades and adds profile context to output."),
+        strategyName: z9.string().optional().describe(
+          "Strategy profile name. When provided, auto-filters to that strategy's trades and adds profile context to output."
+        ),
         startDate: z9.string().optional().describe("Pre-filter by start date (YYYY-MM-DD)"),
         endDate: z9.string().optional().describe("Pre-filter by end date (YYYY-MM-DD)"),
         targetField: z9.string().default("pl").describe("Field to correlate against (default: 'pl' for profit/loss)"),
@@ -7599,9 +7538,7 @@ function registerPredictiveTools(server, baseDir) {
               const conn = await getConnection(baseDir);
               const profile = await getProfile(conn, blockId, strategyName, baseDir);
               if (profile && profile.entryFilters.length > 0) {
-                const profileFilterFields = new Set(
-                  profile.entryFilters.map((f) => f.field)
-                );
+                const profileFilterFields = new Set(profile.entryFilters.map((f) => f.field));
                 const alignedFields = rankedFields.filter((rf) => profileFilterFields.has(rf.field)).map((rf) => ({
                   field: rf.field,
                   correlation: rf.correlation,
@@ -7639,9 +7576,7 @@ function registerPredictiveTools(server, baseDir) {
       description: "Sweep filter thresholds for a field and show performance at each threshold. Use after find_predictive_fields to determine optimal filter values. Returns outcome curves and identifies sweet spots where filtering improves performance.",
       inputSchema: z9.object({
         blockId: z9.string().describe("Block folder name"),
-        field: z9.string().describe(
-          "Field to sweep thresholds on (e.g., 'openingVix', 'durationHours')"
-        ),
+        field: z9.string().describe("Field to sweep thresholds on (e.g., 'openingVix', 'durationHours')"),
         mode: z9.enum(["lt", "gt", "both"]).default("both").describe(
           "Direction of filter: 'lt' (field < threshold), 'gt' (field > threshold), 'both' (show both directions)"
         ),
@@ -7739,9 +7674,7 @@ function registerPredictiveTools(server, baseDir) {
           const baselinePls = tradesWithField.map((t) => t.pl);
           const baselineTotalPl = baselinePls.reduce((a, b) => a + b, 0);
           const baselineAvgPl = baselineTotalPl / tradesWithField.length;
-          const baselineWinners = tradesWithField.filter(
-            (t) => t.pl > 0
-          ).length;
+          const baselineWinners = tradesWithField.filter((t) => t.pl > 0).length;
           const baselineWinRate = baselineWinners / tradesWithField.length;
           const baseline = {
             count: tradesWithField.length,
@@ -7871,9 +7804,7 @@ function registerDiscrepancyTool(server, baseDir) {
         scaling: z10.enum(["raw", "perContract", "toReported"]).default("toReported").describe("Scaling mode for P/L comparison (default: toReported)"),
         correlationMethod: z10.enum(["pearson", "kendall"]).default("pearson").describe("Correlation method for market condition analysis"),
         minSamples: z10.number().min(5).default(10).describe("Minimum samples required for pattern detection"),
-        patternThreshold: z10.number().min(0.5).max(0.95).default(0.7).describe(
-          "Threshold for detecting systematic patterns (0.7 = 70% consistency)"
-        )
+        patternThreshold: z10.number().min(0.5).max(0.95).default(0.7).describe("Threshold for detecting systematic patterns (0.7 = 70% consistency)")
       })
     },
     withSyncedBlock(
@@ -7930,7 +7861,11 @@ function registerDiscrepancyTool(server, baseDir) {
               isError: true
             };
           }
-          const { matchedTrades, unmatchedBacktestCount, unmatchedActualCount } = matchTrades(backtestTrades, actualTrades, scaling);
+          const { matchedTrades, unmatchedBacktestCount, unmatchedActualCount } = matchTrades(
+            backtestTrades,
+            actualTrades,
+            scaling
+          );
           if (matchedTrades.length === 0) {
             return {
               content: [
@@ -7998,12 +7933,8 @@ function registerDiscrepancyTool(server, baseDir) {
                 (a) => a.totalSlippage < outlierThresholdLow || a.totalSlippage > outlierThresholdHigh
               );
               if (outlierTrades.length >= 3) {
-                for (const [bucketName, bucketTrades] of Object.entries(
-                  buckets
-                )) {
-                  const outlierInBucket = outlierTrades.filter(
-                    (o) => bucketTrades.includes(o)
-                  );
+                for (const [bucketName, bucketTrades] of Object.entries(buckets)) {
+                  const outlierInBucket = outlierTrades.filter((o) => bucketTrades.includes(o));
                   const bucketRate = outlierInBucket.length / outlierTrades.length;
                   if (bucketRate >= patternThreshold && outlierInBucket.length >= 3) {
                     patterns.push({
@@ -8071,9 +8002,7 @@ function registerDiscrepancyTool(server, baseDir) {
                 }
               }
             }
-            results.sort(
-              (a, b) => Math.abs(b.coefficient) - Math.abs(a.coefficient)
-            );
+            results.sort((a, b) => Math.abs(b.coefficient) - Math.abs(a.coefficient));
             return results;
           };
           const portfolioPatterns = detectPatterns(matchedTrades);
@@ -8096,9 +8025,7 @@ function registerDiscrepancyTool(server, baseDir) {
               avgSlippage: stratAvg
             });
           }
-          perStrategy.sort(
-            (a, b) => Math.abs(b.totalSlippage) - Math.abs(a.totalSlippage)
-          );
+          perStrategy.sort((a, b) => Math.abs(b.totalSlippage) - Math.abs(a.totalSlippage));
           const summaryParts = [
             `Slippage analysis: ${matchedTrades.length} matched trades`,
             `Total slippage: ${formatCurrency(totalSlippage)}`,
@@ -8156,15 +8083,9 @@ function registerStrategyMatchesTool(server, baseDir) {
           to: z11.string().optional().describe("End date YYYY-MM-DD")
         }).optional().describe("Filter trades to date range"),
         correlationMethod: z11.enum(["pearson", "spearman", "kendall"]).default("pearson").describe("Correlation method (default: pearson)"),
-        minOverlapDays: z11.number().min(2).default(5).describe(
-          "Minimum overlapping trading days required for correlation (default: 5)"
-        ),
-        minCorrelation: z11.number().min(-1).max(1).optional().describe(
-          "Minimum correlation to include in suggestions (default: show all)"
-        ),
-        includeUnmatched: z11.boolean().default(true).describe(
-          "Include strategies with no potential matches (default: true)"
-        )
+        minOverlapDays: z11.number().min(2).default(5).describe("Minimum overlapping trading days required for correlation (default: 5)"),
+        minCorrelation: z11.number().min(-1).max(1).optional().describe("Minimum correlation to include in suggestions (default: show all)"),
+        includeUnmatched: z11.boolean().default(true).describe("Include strategies with no potential matches (default: true)")
       })
     },
     withSyncedBlock(
@@ -8218,9 +8139,7 @@ function registerStrategyMatchesTool(server, baseDir) {
               isError: true
             };
           }
-          const backtestStrategies = new Set(
-            backtestTrades.map((t) => t.strategy)
-          );
+          const backtestStrategies = new Set(backtestTrades.map((t) => t.strategy));
           const actualStrategies = new Set(actualTrades.map((t) => t.strategy));
           const normalizeStrategyName = (name) => name.toLowerCase().trim();
           const backtestStrategyMap = /* @__PURE__ */ new Map();
@@ -8264,14 +8183,8 @@ function registerStrategyMatchesTool(server, baseDir) {
             }
             return result;
           };
-          const backtestDaily = buildDailyPlSeries(
-            backtestTrades,
-            backtestWithExactMatch
-          );
-          const actualDaily = buildDailyPlSeries(
-            actualTrades,
-            actualWithExactMatch
-          );
+          const backtestDaily = buildDailyPlSeries(backtestTrades, backtestWithExactMatch);
+          const actualDaily = buildDailyPlSeries(actualTrades, actualWithExactMatch);
           const getNormalizedDailyPl = (dailyMap) => {
             const result = /* @__PURE__ */ new Map();
             for (const [date, data] of dailyMap) {
@@ -8340,10 +8253,7 @@ function registerStrategyMatchesTool(server, baseDir) {
                 actualNormalized,
                 correlationMethod
               );
-              const timingOverlap = calculateTimingOverlap(
-                btRawDaily,
-                actualRawDaily
-              );
+              const timingOverlap = calculateTimingOverlap(btRawDaily, actualRawDaily);
               rowCorrelations.push(isNaN(correlation) ? 0 : correlation);
               rowSampleSizes.push(overlapDays);
               btResults.set(actualStrategy, {
@@ -8402,10 +8312,7 @@ function registerStrategyMatchesTool(server, baseDir) {
                 }
                 const meanDiff = differences.reduce((a, b) => a + b, 0) / differences.length;
                 const stdDiff = Math.sqrt(
-                  differences.reduce(
-                    (sum, d) => sum + Math.pow(d - meanDiff, 2),
-                    0
-                  ) / differences.length
+                  differences.reduce((sum, d) => sum + Math.pow(d - meanDiff, 2), 0) / differences.length
                 );
                 const bias = stdDiff > 0 ? Math.abs(meanDiff) / stdDiff : 0;
                 if (bias > SYSTEMATIC_BIAS_THRESHOLD) {
@@ -8533,9 +8440,7 @@ function registerSlippageTrendsTool(server, baseDir) {
         }).optional().describe("Filter trades to date range"),
         scaling: z12.enum(["raw", "perContract", "toReported"]).default("toReported").describe("Scaling mode for P/L comparison (default: toReported)"),
         granularity: z12.enum(["daily", "weekly", "monthly"]).default("weekly").describe("Time period granularity for trend analysis"),
-        includeTimeSeries: z12.boolean().default(false).describe(
-          "Include raw time series data points in output (for charting)"
-        ),
+        includeTimeSeries: z12.boolean().default(false).describe("Include raw time series data points in output (for charting)"),
         correlationMethod: z12.enum(["pearson", "kendall"]).default("pearson").describe("Correlation method for external factor analysis"),
         minSamples: z12.number().min(5).default(10).describe("Minimum samples required for reliable statistics")
       })
@@ -8595,11 +8500,7 @@ function registerSlippageTrendsTool(server, baseDir) {
               isError: true
             };
           }
-          const { matchedTrades } = matchTrades(
-            backtestTrades,
-            actualTrades,
-            scaling
-          );
+          const { matchedTrades } = matchTrades(backtestTrades, actualTrades, scaling);
           if (matchedTrades.length === 0) {
             return {
               content: [
@@ -8659,10 +8560,7 @@ function registerSlippageTrendsTool(server, baseDir) {
             const slope = sumX2 > 0 ? sumXY / sumX2 : 0;
             const intercept = meanY - slope * meanX;
             const predicted = x.map((xi) => slope * xi + intercept);
-            const ssRes = y.reduce(
-              (sum, yi, i) => sum + (yi - predicted[i]) ** 2,
-              0
-            );
+            const ssRes = y.reduce((sum, yi, i) => sum + (yi - predicted[i]) ** 2, 0);
             const ssTot = y.reduce((sum, yi) => sum + (yi - meanY) ** 2, 0);
             const rSquared = ssTot > 0 ? 1 - ssRes / ssTot : 0;
             const mse = n > 2 ? ssRes / (n - 2) : 0;
@@ -8683,10 +8581,7 @@ function registerSlippageTrendsTool(server, baseDir) {
             from: dates[0],
             to: dates[dates.length - 1]
           };
-          const totalSlippage = matchedTrades.reduce(
-            (sum, t) => sum + t.totalSlippage,
-            0
-          );
+          const totalSlippage = matchedTrades.reduce((sum, t) => sum + t.totalSlippage, 0);
           const avgSlippagePerTrade = totalSlippage / matchedTrades.length;
           const avgSlippagePerPeriod = periodSlippages.length > 0 ? periodSlippages.reduce((sum, p) => sum + p.totalSlippage, 0) / periodSlippages.length : 0;
           const periodAvgSlippages = periodSlippages.map((p) => p.avgSlippage);
@@ -8719,9 +8614,7 @@ function registerSlippageTrendsTool(server, baseDir) {
               trend: strategyTrend
             });
           }
-          perStrategy.sort(
-            (a, b) => Math.abs(b.totalSlippage) - Math.abs(a.totalSlippage)
-          );
+          perStrategy.sort((a, b) => Math.abs(b.totalSlippage) - Math.abs(a.totalSlippage));
           let externalFactors;
           const vixTrades = matchedTrades.filter(
             (t) => t.openingVix !== void 0 && t.openingVix !== null
@@ -9060,12 +8953,7 @@ function registerMarketDataTools(server, baseDir, stores) {
       description: "Break down a block's trade performance by market regime using market.enriched + market.spot_daily (including VIX tickers) and market.enriched_context. Identifies which market conditions favor or hurt the strategy. Close-derived fields (volRegime, termStructure) use prior trading day values to prevent lookahead bias. Vol_Regime and Term_Structure_State come from market.enriched_context via JOIN. Returns warnings when market data is partially missing.",
       inputSchema: z14.object({
         blockId: z14.string().describe("Block ID to analyze"),
-        segmentBy: z14.enum([
-          "volRegime",
-          "termStructure",
-          "dayOfWeek",
-          "gapDirection"
-        ]).describe("Market dimension to segment by"),
+        segmentBy: z14.enum(["volRegime", "termStructure", "dayOfWeek", "gapDirection"]).describe("Market dimension to segment by"),
         strategy: z14.string().optional().describe("Filter to specific strategy"),
         ticker: z14.string().optional().describe("Underlying ticker symbol (default: SPX)")
       })
@@ -9075,9 +8963,7 @@ function registerMarketDataTools(server, baseDir, stores) {
         const block = await loadBlock(baseDir, blockId);
         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) {
           return {
@@ -9246,252 +9132,468 @@ function registerMarketDataTools(server, baseDir, stores) {
       inputSchema: z14.object({
         blockId: z14.string().describe("Block ID to analyze"),
         strategy: z14.string().optional().describe("Filter to specific strategy"),
-        strategyName: z14.string().optional().describe("Strategy profile name. When provided, auto-filters to that strategy's trades and cross-references suggestions against profile's entry_filters."),
+        strategyName: z14.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: z14.number().optional().describe("Only suggest filters with >= X% win rate improvement (default: 3)"),
         ticker: z14.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;
-        const effectiveStrategy = strategyName || strategy;
-        if (effectiveStrategy) {
-          trades = filterByStrategy(trades, effectiveStrategy);
-          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;
+          const effectiveStrategy = strategyName || strategy;
+          if (effectiveStrategy) {
+            trades = filterByStrategy(trades, effectiveStrategy);
+            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;
+              }
             }
           }
-        }
-        let profileEntryFilters = null;
-        if (strategyName) {
-          const conn2 = await getConnection(baseDir);
-          const profile = await getProfile(conn2, blockId, strategyName, baseDir);
-          if (profile) {
-            profileEntryFilters = profile.entryFilters;
+          let profileEntryFilters = null;
+          if (strategyName) {
+            const conn2 = await getConnection(baseDir);
+            const profile = await getProfile(conn2, blockId, strategyName, baseDir);
+            if (profile) {
+              profileEntryFilters = profile.entryFilters;
+            }
           }
-        }
-        if (trades.length === 0) {
-          return {
-            content: [{ type: "text", text: "No trades found" }],
-            isError: true
-          };
-        }
-        const tradeKeys = uniqueTradeLookupKeys2(trades);
-        const conn = await getConnection(baseDir);
-        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 = resultToRecords2(dailyResult);
-        const daily = recordsByTickerDate2(dailyRecords);
-        const enrichedTrades = trades.map((trade) => {
-          const lookup = getTradeLookupKey2(trade);
-          return {
-            trade,
-            market: daily.get(marketTickerDateKey(lookup.ticker, lookup.date)) || 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
-          };
-        }
-        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);
-        const suggestions = [];
-        const testFilters = [
-          // 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(getNum2(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(getNum2(m, "Gap_Pct")) > 0.8, lagged: false },
-          { name: "Skip when |Gap_Pct| > 1.0%", field: "Gap_Pct", operator: ">", value: 1, test: (m) => Math.abs(getNum2(m, "Gap_Pct")) > 1, lagged: false },
-          // Day of week
-          { name: "Skip Fridays", field: "Day_of_Week", operator: "==", value: 6, test: (m) => getNum2(m, "Day_of_Week") === 6, lagged: false },
-          { name: "Skip Mondays", field: "Day_of_Week", operator: "==", value: 2, test: (m) => getNum2(m, "Day_of_Week") === 2, lagged: false },
-          // OPEX
-          { name: "Skip OPEX days", field: "Is_Opex", operator: "==", value: 1, test: (m) => getNum2(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) => getNum2(m, "VIX_Open") > 25, lagged: false },
-          { name: "Skip when VIX_Open > 30", field: "VIX_Open", operator: ">", value: 30, test: (m) => getNum2(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(getNum2(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(getNum2(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) => getNum2(m, "prev_VIX_Close") > 25, lagged: true },
-          { name: "Skip when prior-day VIX > 30", field: "VIX_Close", operator: ">", value: 30, test: (m) => getNum2(m, "prev_VIX_Close") > 30, lagged: true },
-          { name: "Skip when prior-day VIX < 14", field: "VIX_Close", operator: "<", value: 14, test: (m) => getNum2(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) => getNum2(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) => getNum2(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) => getNum2(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) => getNum2(m, "prev_Vol_Regime") >= 5, lagged: true },
-          { name: "Skip prior-day Vol Regime 1 (Very Low)", field: "Vol_Regime", operator: "==", value: 1, test: (m) => getNum2(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) => getNum2(m, "prev_Consecutive_Days") >= 4, lagged: true },
-          { name: "Skip after prior-day 4+ consecutive down", field: "Consecutive_Days", operator: "<=", value: -4, test: (m) => getNum2(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) => getNum2(m, "prev_RSI_14") > 70, lagged: true },
-          { name: "Skip when prior-day RSI < 30", field: "RSI_14", operator: "<", value: 30, test: (m) => getNum2(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) => getNum2(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) => getNum2(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) => getNum2(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) => getNum2(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) => getNum2(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) => getNum2(m, "Prior_Range_vs_ATR") < 0.5, lagged: false }
-        ];
-        for (const filterDef of testFilters) {
-          let pool = matchedTrades;
-          if (filterDef.lagged) {
-            const prevField = `prev_${filterDef.field}`;
-            pool = matchedTrades.filter((t) => {
-              const val = getNum2(t.market, prevField);
-              return !isNaN(val);
-            });
+          if (trades.length === 0) {
+            return {
+              content: [{ type: "text", text: "No trades found" }],
+              isError: true
+            };
           }
-          if (pool.length < 10) continue;
-          const removed = pool.filter((t) => filterDef.test(t.market));
-          const remaining = pool.filter((t) => !filterDef.test(t.market));
-          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 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 winRateDelta = newWinRate - poolWinRate;
-          const plDelta = newTotalPl - poolTotalPl;
-          if (winRateDelta >= minImprovementPct) {
-            let confidence = "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
-            });
+          const tradeKeys = uniqueTradeLookupKeys2(trades);
+          const conn = await getConnection(baseDir);
+          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 = resultToRecords2(dailyResult);
+          const daily = recordsByTickerDate2(dailyRecords);
+          const enrichedTrades = trades.map((trade) => {
+            const lookup = getTradeLookupKey2(trade);
+            return {
+              trade,
+              market: daily.get(marketTickerDateKey(lookup.ticker, lookup.date)) || 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
+            };
           }
-        }
-        suggestions.sort((a, b) => b.winRateDelta - a.winRateDelta);
-        const topSuggestions = suggestions.slice(0, 10);
-        const baseWinRate = currentWinRate;
-        const significantFilters = suggestions.filter((s) => s.winRateDelta > 3);
-        const compositeSuggestions = [];
-        const filterTestMap = /* @__PURE__ */ new Map();
-        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];
-            const testA = filterTestMap.get(filterA.filter);
-            const testB = filterTestMap.get(filterB.filter);
-            if (!testA || !testB) continue;
+          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);
+          const suggestions = [];
+          const testFilters = [
+            // 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(getNum2(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(getNum2(m, "Gap_Pct")) > 0.8,
+              lagged: false
+            },
+            {
+              name: "Skip when |Gap_Pct| > 1.0%",
+              field: "Gap_Pct",
+              operator: ">",
+              value: 1,
+              test: (m) => Math.abs(getNum2(m, "Gap_Pct")) > 1,
+              lagged: false
+            },
+            // Day of week
+            {
+              name: "Skip Fridays",
+              field: "Day_of_Week",
+              operator: "==",
+              value: 6,
+              test: (m) => getNum2(m, "Day_of_Week") === 6,
+              lagged: false
+            },
+            {
+              name: "Skip Mondays",
+              field: "Day_of_Week",
+              operator: "==",
+              value: 2,
+              test: (m) => getNum2(m, "Day_of_Week") === 2,
+              lagged: false
+            },
+            // OPEX
+            {
+              name: "Skip OPEX days",
+              field: "Is_Opex",
+              operator: "==",
+              value: 1,
+              test: (m) => getNum2(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) => getNum2(m, "VIX_Open") > 25,
+              lagged: false
+            },
+            {
+              name: "Skip when VIX_Open > 30",
+              field: "VIX_Open",
+              operator: ">",
+              value: 30,
+              test: (m) => getNum2(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(getNum2(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(getNum2(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) => getNum2(m, "prev_VIX_Close") > 25,
+              lagged: true
+            },
+            {
+              name: "Skip when prior-day VIX > 30",
+              field: "VIX_Close",
+              operator: ">",
+              value: 30,
+              test: (m) => getNum2(m, "prev_VIX_Close") > 30,
+              lagged: true
+            },
+            {
+              name: "Skip when prior-day VIX < 14",
+              field: "VIX_Close",
+              operator: "<",
+              value: 14,
+              test: (m) => getNum2(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) => getNum2(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) => getNum2(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) => getNum2(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) => getNum2(m, "prev_Vol_Regime") >= 5,
+              lagged: true
+            },
+            {
+              name: "Skip prior-day Vol Regime 1 (Very Low)",
+              field: "Vol_Regime",
+              operator: "==",
+              value: 1,
+              test: (m) => getNum2(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) => getNum2(m, "prev_Consecutive_Days") >= 4,
+              lagged: true
+            },
+            {
+              name: "Skip after prior-day 4+ consecutive down",
+              field: "Consecutive_Days",
+              operator: "<=",
+              value: -4,
+              test: (m) => getNum2(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) => getNum2(m, "prev_RSI_14") > 70,
+              lagged: true
+            },
+            {
+              name: "Skip when prior-day RSI < 30",
+              field: "RSI_14",
+              operator: "<",
+              value: 30,
+              test: (m) => getNum2(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) => getNum2(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) => getNum2(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) => getNum2(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) => getNum2(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) => getNum2(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) => getNum2(m, "Prior_Range_vs_ATR") < 0.5,
+              lagged: false
+            }
+          ];
+          for (const filterDef of testFilters) {
             let pool = matchedTrades;
-            if (testA.lagged) {
-              const prevField = `prev_${testA.field}`;
-              pool = pool.filter((t) => !isNaN(getNum2(t.market, prevField)));
+            if (filterDef.lagged) {
+              const prevField = `prev_${filterDef.field}`;
+              pool = matchedTrades.filter((t) => {
+                const val = getNum2(t.market, prevField);
+                return !isNaN(val);
+              });
             }
-            if (testB.lagged) {
-              const prevField = `prev_${testB.field}`;
-              pool = pool.filter((t) => !isNaN(getNum2(t.market, prevField)));
+            if (pool.length < 10) continue;
+            const removed = pool.filter((t) => filterDef.test(t.market));
+            const remaining = pool.filter(
+              (t) => !filterDef.test(t.market)
+            );
+            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 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 winRateDelta = newWinRate - poolWinRate;
+            const plDelta = newTotalPl - poolTotalPl;
+            if (winRateDelta >= minImprovementPct) {
+              let confidence = "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
+              });
             }
-            const bothMatchTrades = pool.filter((t) => {
-              const m = t.market;
-              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;
-            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
+          }
+          suggestions.sort((a, b) => b.winRateDelta - a.winRateDelta);
+          const topSuggestions = suggestions.slice(0, 10);
+          const baseWinRate = currentWinRate;
+          const significantFilters = suggestions.filter((s) => s.winRateDelta > 3);
+          const compositeSuggestions = [];
+          const filterTestMap = /* @__PURE__ */ new Map();
+          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];
+              const testA = filterTestMap.get(filterA.filter);
+              const testB = filterTestMap.get(filterB.filter);
+              if (!testA || !testB) continue;
+              let pool = matchedTrades;
+              if (testA.lagged) {
+                const prevField = `prev_${testA.field}`;
+                pool = pool.filter(
+                  (t) => !isNaN(getNum2(t.market, prevField))
+                );
+              }
+              if (testB.lagged) {
+                const prevField = `prev_${testB.field}`;
+                pool = pool.filter(
+                  (t) => !isNaN(getNum2(t.market, prevField))
+                );
+              }
+              const bothMatchTrades = pool.filter((t) => {
+                const m = t.market;
+                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;
+              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
+                });
+              }
             }
           }
-        }
-        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 = {
-          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 (profileEntryFilters && profileEntryFilters.length > 0) {
-          const profileContext = [];
-          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 } : void 0
-            });
+          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 = {
+            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;
           }
-          sfResponseData.profile_context = {
-            strategyName,
-            existingFilters: profileEntryFilters.length,
-            crossReference: profileContext
+          if (profileEntryFilters && profileEntryFilters.length > 0) {
+            const profileContext = [];
+            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
+                } : void 0
+              });
+            }
+            sfResponseData.profile_context = {
+              strategyName,
+              existingFilters: profileEntryFilters.length,
+              crossReference: profileContext
+            };
+          }
+          return createToolOutput(summary, sfResponseData);
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error: ${error.message}` }],
+            isError: true
           };
         }
-        return createToolOutput(summary, sfResponseData);
-      } catch (error) {
-        return {
-          content: [{ type: "text", text: `Error: ${error.message}` }],
-          isError: true
-        };
       }
-    })
+    )
   );
   server.registerTool(
     "enrich_trades",
@@ -9511,166 +9613,182 @@ function registerMarketDataTools(server, baseDir, stores) {
         offset: z14.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;
-        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
-          };
-        }
-        const totalTrades = trades.length;
-        const paginated = trades.slice(offset, offset + limit);
-        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: []
-            }
-          );
-        }
-        const tradeKeys = uniqueTradeLookupKeys2(paginated);
-        const conn = await getConnection(baseDir);
-        const resolvedTickerET = normalizeTicker(ticker || "") || DEFAULT_MARKET_TICKER;
-        const availabilityET = await checkDataAvailability(stores, resolvedTickerET, { checkIntraday: includeIntradayContext });
-        const { sql: lagSql, params: lagParams } = buildLookaheadFreeQuery(tradeKeys);
-        const dailyResult = await conn.runAndReadAll(lagSql, lagParams);
-        const dailyRecords = resultToRecords2(dailyResult);
-        const daily = recordsByTickerDate2(dailyRecords);
-        let outcomeMap = null;
-        if (includeOutcomeFields) {
-          const { sql: outcomeSql, params: outcomeParams } = buildOutcomeQuery(tradeKeys);
-          const outcomeResult = await conn.runAndReadAll(outcomeSql, outcomeParams);
-          const outcomeRecords = resultToRecords2(outcomeResult);
-          outcomeMap = recordsByTickerDate2(outcomeRecords);
-        }
-        let intradayBarsByKey = null;
-        if (includeIntradayContext) {
-          intradayBarsByKey = /* @__PURE__ */ new Map();
-          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) {
-              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);
-          }
-        }
-        const cleanVal = (val) => {
-          if (typeof val === "bigint") return Number(val);
-          if (typeof val === "number" && isNaN(val)) return null;
-          return val === void 0 ? null : val;
-        };
-        const unmatchedDates = [];
-        let matched = 0;
-        const enrichedTrades = paginated.map((trade) => {
-          const lookup = getTradeLookupKey2(trade);
-          const marketKey = marketTickerDateKey(lookup.ticker, lookup.date);
-          const marketData = daily.get(marketKey);
-          const commissions = trade.openingCommissionsFees + trade.closingCommissionsFees;
-          const baseTrade = {
-            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
-          };
-          if (!marketData) {
-            unmatchedDates.push(`${lookup.date}|${lookup.ticker}`);
-            baseTrade.entryContext = null;
-            return baseTrade;
+    withFullSync(
+      baseDir,
+      async ({
+        blockId,
+        strategy,
+        startDate,
+        endDate,
+        ticker,
+        includeOutcomeFields,
+        includeIntradayContext,
+        limit,
+        offset
+      }) => {
+        try {
+          const block = await loadBlock(baseDir, blockId);
+          let trades = block.trades;
+          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
+            };
           }
-          matched++;
-          const sameDay = {};
-          for (const field of OPEN_KNOWN_FIELDS) {
-            sameDay[field] = cleanVal(marketData[field]);
+          const totalTrades = trades.length;
+          const paginated = trades.slice(offset, offset + limit);
+          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: []
+              }
+            );
           }
-          for (const field of STATIC_FIELDS) {
-            sameDay[field] = cleanVal(marketData[field]);
+          const tradeKeys = uniqueTradeLookupKeys2(paginated);
+          const conn = await getConnection(baseDir);
+          const resolvedTickerET = normalizeTicker(ticker || "") || DEFAULT_MARKET_TICKER;
+          const availabilityET = await checkDataAvailability(stores, resolvedTickerET, {
+            checkIntraday: includeIntradayContext
+          });
+          const { sql: lagSql, params: lagParams } = buildLookaheadFreeQuery(tradeKeys);
+          const dailyResult = await conn.runAndReadAll(lagSql, lagParams);
+          const dailyRecords = resultToRecords2(dailyResult);
+          const daily = recordsByTickerDate2(dailyRecords);
+          let outcomeMap = null;
+          if (includeOutcomeFields) {
+            const { sql: outcomeSql, params: outcomeParams } = buildOutcomeQuery(tradeKeys);
+            const outcomeResult = await conn.runAndReadAll(outcomeSql, outcomeParams);
+            const outcomeRecords = resultToRecords2(outcomeResult);
+            outcomeMap = recordsByTickerDate2(outcomeRecords);
           }
-          const priorDay = {};
-          for (const field of CLOSE_KNOWN_FIELDS) {
-            priorDay[field] = cleanVal(marketData[`prev_${field}`]);
+          let intradayBarsByKey = null;
+          if (includeIntradayContext) {
+            intradayBarsByKey = /* @__PURE__ */ new Map();
+            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) {
+                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);
+            }
           }
-          baseTrade.entryContext = { sameDay, priorDay };
-          if (includeOutcomeFields && outcomeMap) {
-            const outcomeData = outcomeMap.get(marketKey);
-            if (outcomeData) {
-              const outcomeFields = {};
-              for (const field of CLOSE_KNOWN_FIELDS) {
-                outcomeFields[field] = cleanVal(outcomeData[field]);
+          const cleanVal = (val) => {
+            if (typeof val === "bigint") return Number(val);
+            if (typeof val === "number" && isNaN(val)) return null;
+            return val === void 0 ? null : val;
+          };
+          const unmatchedDates = [];
+          let matched = 0;
+          const enrichedTrades = paginated.map((trade) => {
+            const lookup = getTradeLookupKey2(trade);
+            const marketKey = marketTickerDateKey(lookup.ticker, lookup.date);
+            const marketData = daily.get(marketKey);
+            const commissions = trade.openingCommissionsFees + trade.closingCommissionsFees;
+            const baseTrade = {
+              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
+            };
+            if (!marketData) {
+              unmatchedDates.push(`${lookup.date}|${lookup.ticker}`);
+              baseTrade.entryContext = null;
+              return baseTrade;
+            }
+            matched++;
+            const sameDay = {};
+            for (const field of OPEN_KNOWN_FIELDS) {
+              sameDay[field] = cleanVal(marketData[field]);
+            }
+            for (const field of STATIC_FIELDS) {
+              sameDay[field] = cleanVal(marketData[field]);
+            }
+            const priorDay = {};
+            for (const field of CLOSE_KNOWN_FIELDS) {
+              priorDay[field] = cleanVal(marketData[`prev_${field}`]);
+            }
+            baseTrade.entryContext = { sameDay, priorDay };
+            if (includeOutcomeFields && outcomeMap) {
+              const outcomeData = outcomeMap.get(marketKey);
+              if (outcomeData) {
+                const outcomeFields = {};
+                for (const field of CLOSE_KNOWN_FIELDS) {
+                  outcomeFields[field] = cleanVal(outcomeData[field]);
+                }
+                baseTrade.outcomeFields = outcomeFields;
               }
-              baseTrade.outcomeFields = outcomeFields;
             }
+            if (includeIntradayContext && intradayBarsByKey) {
+              const bars = intradayBarsByKey.get(marketKey) || null;
+              baseTrade.intradayBars = bars;
+            }
+            return baseTrade;
+          });
+          const sortedUnmatchedDates = [...new Set(unmatchedDates)].sort();
+          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. \u2014 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 && intradayBarsByKey) {
-            const bars = intradayBarsByKey.get(marketKey) || null;
-            baseTrade.intradayBars = bars;
+          if (includeIntradayContext) {
+            lagNote += " intradayBars contains raw OHLC bar arrays from market.spot keyed by ticker+date.";
           }
-          return baseTrade;
-        });
-        const sortedUnmatchedDates = [...new Set(unmatchedDates)].sort();
-        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. \u2014 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.";
-        }
-        const responseData = {
-          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.";
-        }
-        if (availabilityET.warnings.length > 0) {
-          responseData.warnings = availabilityET.warnings;
+          const responseData = {
+            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.";
+          }
+          if (availabilityET.warnings.length > 0) {
+            responseData.warnings = availabilityET.warnings;
+          }
+          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.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.message}` }],
-          isError: true
-        };
       }
-    })
+    )
   );
   function hhmmToSqlTime(hhmm) {
     if (!/^\d{4}$/.test(hhmm)) {
@@ -9693,169 +9811,181 @@ function registerMarketDataTools(server, baseDir, stores) {
         limit: z14.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 || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-        const sqlStartTime = hhmmToSqlTime(startTime);
-        const sqlEndTime = hhmmToSqlTime(endTime);
-        const availability = await checkDataAvailability(stores, normalizedTicker, { checkIntraday: true });
-        const wideCoverage = await stores.spot.getCoverage(
-          normalizedTicker,
-          "2000-01-01",
-          (/* @__PURE__ */ 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 || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+          const sqlStartTime = hhmmToSqlTime(startTime);
+          const sqlEndTime = hhmmToSqlTime(endTime);
+          const availability = await checkDataAvailability(stores, normalizedTicker, {
+            checkIntraday: true
+          });
+          const wideCoverage = await stores.spot.getCoverage(
+            normalizedTicker,
+            "2000-01-01",
+            (/* @__PURE__ */ 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 }
+            });
+          }
+          let resolvedBarResolution = null;
+          if (barResolution !== void 0 && barResolution !== null) {
+            const parsed = parseInt(barResolution, 10);
+            if (!isNaN(parsed) && parsed > 0) {
+              resolvedBarResolution = parsed;
+            }
+          } else if (wideCoverage.earliest) {
+            try {
+              const sampleBars = await stores.spot.readBars(
+                normalizedTicker,
+                wideCoverage.earliest,
+                wideCoverage.earliest
+              );
+              const distinctTimes = [];
+              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 {
             }
-          );
-        }
-        let resolvedBarResolution = null;
-        if (barResolution !== void 0 && barResolution !== null) {
-          const parsed = parseInt(barResolution, 10);
-          if (!isNaN(parsed) && parsed > 0) {
-            resolvedBarResolution = parsed;
           }
-        } else if (wideCoverage.earliest) {
-          try {
-            const sampleBars = await stores.spot.readBars(
-              normalizedTicker,
-              wideCoverage.earliest,
-              wideCoverage.earliest
+          const allBars = await stores.spot.readBars(normalizedTicker, startDate, end);
+          const barsByDate = /* @__PURE__ */ new Map();
+          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]);
+          }
+          const days = [];
+          const sortedDates = [...barsByDate.keys()].sort();
+          for (const date of sortedDates) {
+            const dayBars = barsByDate.get(date);
+            const windowBars = dayBars.filter(
+              (b) => String(b.time) >= sqlStartTime && String(b.time) <= sqlEndTime
             );
-            const distinctTimes = [];
-            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 (windowBars.length === 0) continue;
+            let orbHigh = -Infinity;
+            let orbLow = Infinity;
+            let orbOpen = 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);
               }
             }
-            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;
-              }
+            const orbRange = orbHigh - orbLow;
+            const orbRangePct = orbLow > 0 ? orbRange / orbLow * 100 : 0;
+            let breakoutUpTime = null;
+            let breakoutDownTime = 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;
             }
-          } catch {
-          }
-        }
-        const allBars = await stores.spot.readBars(normalizedTicker, startDate, end);
-        const barsByDate = /* @__PURE__ */ new Map();
-        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]);
-        }
-        const days = [];
-        const sortedDates = [...barsByDate.keys()].sort();
-        for (const date of sortedDates) {
-          const dayBars = barsByDate.get(date);
-          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 = 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);
+            let 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";
             }
+            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 * 1e4) / 1e4,
+              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 orbRange = orbHigh - orbLow;
-          const orbRangePct = orbLow > 0 ? orbRange / orbLow * 100 : 0;
-          let breakoutUpTime = null;
-          let breakoutDownTime = 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;
-          }
-          let 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";
+          const totalDays = days.length;
+          const avgOrbRangePct = totalDays > 0 ? days.reduce((sum, d) => sum + d.ORB_Range_Pct, 0) / totalDays : 0;
+          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 limitedDays = days.slice(0, limit);
+          const summary = `ORB (${normalizedTicker}, ${startTime}-${endTime}): ${startDate} to ${end} | ${totalDays} days, avg range ${formatPercent(avgOrbRangePct)}`;
+          const responseData = {
+            query: {
+              ticker: normalizedTicker,
+              startTime,
+              endTime,
+              sqlStartTime,
+              sqlEndTime,
+              startDate,
+              endDate: end,
+              useHighLow,
+              barResolution: resolvedBarResolution !== null ? String(resolvedBarResolution) : "auto"
+            },
+            stats: {
+              totalDays,
+              avgOrbRangePct: Math.round(avgOrbRangePct * 1e4) / 1e4,
+              breakdownByCondition
+            },
+            returned: limitedDays.length,
+            days: limitedDays
+          };
+          if (availability.warnings.length > 0) {
+            responseData.warnings = availability.warnings;
           }
-          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 * 1e4) / 1e4,
-            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 totalDays = days.length;
-        const avgOrbRangePct = totalDays > 0 ? days.reduce((sum, d) => sum + d.ORB_Range_Pct, 0) / totalDays : 0;
-        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 limitedDays = days.slice(0, limit);
-        const summary = `ORB (${normalizedTicker}, ${startTime}-${endTime}): ${startDate} to ${end} | ${totalDays} days, avg range ${formatPercent(avgOrbRangePct)}`;
-        const responseData = {
-          query: {
-            ticker: normalizedTicker,
-            startTime,
-            endTime,
-            sqlStartTime,
-            sqlEndTime,
-            startDate,
-            endDate: end,
-            useHighLow,
-            barResolution: resolvedBarResolution !== null ? String(resolvedBarResolution) : "auto"
-          },
-          stats: {
-            totalDays,
-            avgOrbRangePct: Math.round(avgOrbRangePct * 1e4) / 1e4,
-            breakdownByCondition
-          },
-          returned: limitedDays.length,
-          days: limitedDays
-        };
-        if (availability.warnings.length > 0) {
-          responseData.warnings = availability.warnings;
+          return createToolOutput(summary, responseData);
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: `Error: ${error.message}` }],
+            isError: true
+          };
         }
-        return createToolOutput(summary, responseData);
-      } catch (error) {
-        return {
-          content: [{ type: "text", text: `Error: ${error.message}` }],
-          isError: true
-        };
       }
-    })
+    )
   );
 }
 
@@ -9945,7 +10075,9 @@ function applyColumnMapping(rows, columnMapping, ticker) {
     if (hasNullDate) continue;
     if (!("date" in mapped)) continue;
     if (!("time" in mapped)) {
-      const dateSourceCol = Object.entries(columnMapping).find(([, schema]) => schema === "date")?.[0];
+      const dateSourceCol = Object.entries(columnMapping).find(
+        ([, schema]) => schema === "date"
+      )?.[0];
       if (dateSourceCol) {
         const rawDateValue = row[dateSourceCol] ?? "";
         const numericDate = Number(rawDateValue);
@@ -10436,9 +10568,7 @@ async function executeWithTimeout(conn, sql, limit, timeoutMs = DEFAULT_TIMEOUT_
   const timeoutPromise = new Promise((_, reject) => {
     setTimeout(() => {
       reject(
-        new Error(
-          "Query exceeded 30s timeout. Consider adding LIMIT or filtering by block_id."
-        )
+        new Error("Query exceeded 30s timeout. Consider adding LIMIT or filtering by block_id.")
       );
     }, timeoutMs);
   });
@@ -10495,7 +10625,9 @@ function registerSQLTools(server, baseDir) {
       inputSchema: z17.object({
         query: z17.string().describe("SQL query to execute"),
         limit: z17.number().min(1).max(MAX_ROWS).default(100).describe(`Maximum rows to return (default: 100, max: ${MAX_ROWS})`),
-        confirm: z17.boolean().default(false).describe("Required for all mutating operations (DELETE, UPDATE, INSERT, CREATE, ALTER, DROP, TRUNCATE). Without it, returns a preview or prompt.")
+        confirm: z17.boolean().default(false).describe(
+          "Required for all mutating operations (DELETE, UPDATE, INSERT, CREATE, ALTER, DROP, TRUNCATE). Without it, returns a preview or prompt."
+        )
       })
     },
     withFullSync(baseDir, async ({ query, limit, confirm }) => {
@@ -10525,10 +10657,11 @@ function registerSQLTools(server, baseDir) {
             );
           }
         }
-        return createToolOutput(
-          `\u26A0\uFE0F ${operation} requires confirm=true to execute.`,
-          { operation, query, preview: true }
-        );
+        return createToolOutput(`\u26A0\uFE0F ${operation} requires confirm=true to execute.`, {
+          operation,
+          query,
+          preview: true
+        });
       }
       try {
         const conn = await getConnection(baseDir);
@@ -10538,10 +10671,10 @@ function registerSQLTools(server, baseDir) {
             const rwConn = await getConnection(baseDir);
             const result2 = await rwConn.run(query);
             const changed = Number(result2.rowsChanged);
-            return createToolOutput(
-              `${operation} completed: ${changed} row(s) affected.`,
-              { operation, rowsAffected: changed }
-            );
+            return createToolOutput(`${operation} completed: ${changed} row(s) affected.`, {
+              operation,
+              rowsAffected: changed
+            });
           } finally {
             await downgradeToReadOnly(baseDir);
           }
@@ -10688,19 +10821,17 @@ function registerSchemaTools(server, baseDir) {
         totalRows += rowCount;
         const schemaDesc = SCHEMA_DESCRIPTIONS[schemaName];
         const tableDesc = schemaDesc?.tables?.[tableName];
-        const columns = columnsData.map(
-          ([columnName, dataType, isNullable]) => {
-            const colDesc = tableDesc?.columns?.[columnName];
-            return {
-              name: columnName,
-              type: dataType,
-              description: colDesc?.description || "",
-              nullable: isNullable,
-              hypothesis: colDesc?.hypothesis || false,
-              timing: colDesc?.timing
-            };
-          }
-        );
+        const columns = columnsData.map(([columnName, dataType, isNullable]) => {
+          const colDesc = tableDesc?.columns?.[columnName];
+          return {
+            name: columnName,
+            type: dataType,
+            description: colDesc?.description || "",
+            nullable: isNullable,
+            hypothesis: colDesc?.hypothesis || false,
+            timing: colDesc?.timing
+          };
+        });
         const tableInfo = {
           description: tableDesc?.description || `${tableName} table`,
           keyColumns: tableDesc?.keyColumns || [],
@@ -10773,16 +10904,12 @@ function registerSchemaTools(server, baseDir) {
       }
       try {
         const fullTableName = `market.${table}`;
-        const countResult = await conn.runAndReadAll(
-          `SELECT COUNT(*) FROM ${fullTableName}`
-        );
+        const countResult = await conn.runAndReadAll(`SELECT COUNT(*) FROM ${fullTableName}`);
         const rowsBefore = Number(countResult.getRows()[0][0]);
         try {
           await conn.run(`BEGIN TRANSACTION`);
           await conn.run(`DELETE FROM ${fullTableName}`);
-          await conn.run(
-            `DELETE FROM market._sync_metadata WHERE target_table = '${table}'`
-          );
+          await conn.run(`DELETE FROM market._sync_metadata WHERE target_table = '${table}'`);
           await conn.run(`COMMIT`);
         } catch (e) {
           await conn.run(`ROLLBACK`).catch(() => {
@@ -10877,12 +11004,8 @@ Worst losing streak: ${worstDesc}`;
         windowSize: z19.number().min(5).optional().describe(
           "Rolling window size in trades (default: auto-calculated based on trade count)"
         ),
-        recentWindowSize: z19.number().min(10).optional().describe(
-          "Recent window size in trades for comparison (default: auto-calculated)"
-        ),
-        recentWindowDays: z19.number().min(7).optional().describe(
-          "Override: recent window as calendar days instead of trade count"
-        ),
+        recentWindowSize: z19.number().min(10).optional().describe("Recent window size in trades for comparison (default: auto-calculated)"),
+        recentWindowDays: z19.number().min(7).optional().describe("Override: recent window as calendar days instead of trade count"),
         includeSeries: z19.boolean().optional().default(false).describe(
           "Include full rolling series data points in output (default: false, saves tokens)"
         )
@@ -10967,9 +11090,7 @@ Recent vs historical: win rate ${fmtPct(recentWR)} vs ${fmtPct(histWR)}, PF ${fm
         recentWindowSize: z19.number().min(20).optional().describe(
           "Number of recent trades for the recent window simulation (default: auto-calculated, typically max(20% of trades, 200))"
         ),
-        numSimulations: z19.number().min(50).max(1e4).optional().describe(
-          "Number of Monte Carlo simulation paths (default: 1000)"
-        ),
+        numSimulations: z19.number().min(50).max(1e4).optional().describe("Number of Monte Carlo simulation paths (default: 1000)"),
         simulationLength: z19.number().min(10).optional().describe(
           "Number of trades to project forward per simulation (default: recentWindowSize)"
         ),
@@ -11010,7 +11131,9 @@ Recent vs historical: win rate ${fmtPct(recentWR)} vs ${fmtPct(histWR)}, PF ${fm
             // Already filtered above
           });
           const fullPProfit = (result.fullHistory.statistics.probabilityOfProfit * 100).toFixed(1);
-          const recentPProfit = (result.recentWindow.statistics.probabilityOfProfit * 100).toFixed(1);
+          const recentPProfit = (result.recentWindow.statistics.probabilityOfProfit * 100).toFixed(
+            1
+          );
           const fullSharpe = result.fullHistory.statistics.meanSharpeRatio.toFixed(2);
           const recentSharpe = result.recentWindow.statistics.meanSharpeRatio.toFixed(2);
           const score = result.divergence.compositeScore.toFixed(2);
@@ -11070,19 +11193,11 @@ Divergence: score ${score}`;
       inputSchema: z19.object({
         blockId: z19.string().describe("Block folder name"),
         strategy: z19.string().optional().describe("Filter by strategy name (case-insensitive)"),
-        inSampleDays: z19.number().min(30).optional().describe(
-          "In-sample window in calendar days (default: 365)"
-        ),
-        outOfSampleDays: z19.number().min(7).optional().describe(
-          "Out-of-sample window in calendar days (default: 90)"
-        ),
+        inSampleDays: z19.number().min(30).optional().describe("In-sample window in calendar days (default: 365)"),
+        outOfSampleDays: z19.number().min(7).optional().describe("Out-of-sample window in calendar days (default: 90)"),
         stepSizeDays: z19.number().min(7).optional().describe("Step size in calendar days (default: 90)"),
-        minTradesPerPeriod: z19.number().min(1).optional().describe(
-          "Minimum trades for a period to be considered sufficient (default: 10)"
-        ),
-        recentPeriodCount: z19.number().min(1).optional().describe(
-          "Number of recent WF periods for comparison (default: 3)"
-        )
+        minTradesPerPeriod: z19.number().min(1).optional().describe("Minimum trades for a period to be considered sufficient (default: 10)"),
+        recentPeriodCount: z19.number().min(1).optional().describe("Number of recent WF periods for comparison (default: 3)")
       })
     },
     withSyncedBlock(
@@ -11199,15 +11314,12 @@ Divergence: score ${score}`;
           scaling: scaling ?? "perContract"
         });
         if (!output.available) {
-          return createToolOutput(
-            `Live alignment for ${blockId}: skipped (${output.reason})`,
-            {
-              blockId,
-              strategy: strategy ?? null,
-              available: false,
-              reason: output.reason
-            }
-          );
+          return createToolOutput(`Live alignment for ${blockId}: skipped (${output.reason})`, {
+            blockId,
+            strategy: strategy ?? null,
+            available: false,
+            reason: output.reason
+          });
         }
         const result = output;
         const da = result.directionAgreement;
@@ -11257,69 +11369,66 @@ Divergence: score ${score}`;
         )
       })
     },
-    withSyncedBlock(
-      baseDir,
-      async ({ blockId, strategy, recentWindow }) => {
-        try {
-          const block = await loadBlock(baseDir, blockId);
-          const trades = applyStrategyFilter(block.trades, strategy);
-          if (trades.length === 0) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: strategy ? `No trades found for strategy "${strategy}" in block "${blockId}".` : `No trades found in block "${blockId}".`
-                }
-              ],
-              isError: true
-            };
-          }
-          let actualTrades;
-          try {
-            const raw = await loadReportingLog(baseDir, blockId);
-            actualTrades = applyStrategyFilter(raw, strategy);
-          } catch {
-            actualTrades = void 0;
-          }
-          const result = synthesizeEdgeDecay(trades, actualTrades, {
-            recentWindow
-          });
-          const s = result.summary;
-          const fmtPct = (v) => v !== null ? (v * 100).toFixed(1) + "%" : "N/A";
-          const fmtRatio = (v) => v !== null ? v.toFixed(2) : "N/A";
-          const lines = [
-            `Edge decay analysis for ${blockId}${strategy ? ` (${strategy})` : ""}: ${s.totalTrades} trades, recent window=${s.recentWindow}`,
-            `Win rate: ${fmtPct(s.recentWinRate)} recent vs ${fmtPct(s.historicalWinRate)} historical`,
-            `Profit factor: ${fmtRatio(s.recentProfitFactor)} recent vs ${fmtRatio(s.historicalProfitFactor)} historical`,
-            `Sharpe: ${fmtRatio(s.recentSharpe)} recent vs ${fmtRatio(s.historicalSharpe)} historical`,
-            `Signals: ${result.metadata.signalsRun} run, ${result.metadata.signalsSkipped} skipped`,
-            `Observations: ${s.observationCount} notable (${s.structuralFlagCount} structural flags)`
-          ];
-          if (s.mcProbabilityOfProfit) {
-            lines.push(
-              `MC P(Profit): ${(s.mcProbabilityOfProfit.full * 100).toFixed(1)}% full vs ${(s.mcProbabilityOfProfit.recent * 100).toFixed(1)}% recent`
-            );
-          }
-          if (s.liveDirectionAgreement !== null) {
-            lines.push(
-              `Live alignment: ${fmtPct(s.liveDirectionAgreement)} direction agreement, ${fmtRatio(s.liveExecutionEfficiency)} efficiency`
-            );
-          }
-          const summaryText = lines.join("\n");
-          return createToolOutput(summaryText, result);
-        } catch (error) {
+    withSyncedBlock(baseDir, async ({ blockId, strategy, recentWindow }) => {
+      try {
+        const block = await loadBlock(baseDir, blockId);
+        const trades = applyStrategyFilter(block.trades, strategy);
+        if (trades.length === 0) {
           return {
             content: [
               {
                 type: "text",
-                text: `Error analyzing edge decay: ${error.message}`
+                text: strategy ? `No trades found for strategy "${strategy}" in block "${blockId}".` : `No trades found in block "${blockId}".`
               }
             ],
             isError: true
           };
         }
+        let actualTrades;
+        try {
+          const raw = await loadReportingLog(baseDir, blockId);
+          actualTrades = applyStrategyFilter(raw, strategy);
+        } catch {
+          actualTrades = void 0;
+        }
+        const result = synthesizeEdgeDecay(trades, actualTrades, {
+          recentWindow
+        });
+        const s = result.summary;
+        const fmtPct = (v) => v !== null ? (v * 100).toFixed(1) + "%" : "N/A";
+        const fmtRatio = (v) => v !== null ? v.toFixed(2) : "N/A";
+        const lines = [
+          `Edge decay analysis for ${blockId}${strategy ? ` (${strategy})` : ""}: ${s.totalTrades} trades, recent window=${s.recentWindow}`,
+          `Win rate: ${fmtPct(s.recentWinRate)} recent vs ${fmtPct(s.historicalWinRate)} historical`,
+          `Profit factor: ${fmtRatio(s.recentProfitFactor)} recent vs ${fmtRatio(s.historicalProfitFactor)} historical`,
+          `Sharpe: ${fmtRatio(s.recentSharpe)} recent vs ${fmtRatio(s.historicalSharpe)} historical`,
+          `Signals: ${result.metadata.signalsRun} run, ${result.metadata.signalsSkipped} skipped`,
+          `Observations: ${s.observationCount} notable (${s.structuralFlagCount} structural flags)`
+        ];
+        if (s.mcProbabilityOfProfit) {
+          lines.push(
+            `MC P(Profit): ${(s.mcProbabilityOfProfit.full * 100).toFixed(1)}% full vs ${(s.mcProbabilityOfProfit.recent * 100).toFixed(1)}% recent`
+          );
+        }
+        if (s.liveDirectionAgreement !== null) {
+          lines.push(
+            `Live alignment: ${fmtPct(s.liveDirectionAgreement)} direction agreement, ${fmtRatio(s.liveExecutionEfficiency)} efficiency`
+          );
+        }
+        const summaryText = lines.join("\n");
+        return createToolOutput(summaryText, result);
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error analyzing edge decay: ${error.message}`
+            }
+          ],
+          isError: true
+        };
       }
-    )
+    })
   );
 }
 
@@ -11651,9 +11760,7 @@ function registerGuideTools(server) {
       if (subtopic) {
         const keyword = subtopic.toLowerCase();
         const sections = content.split(/\n(?=## )/);
-        const matched = sections.filter(
-          (s) => s.toLowerCase().includes(keyword)
-        );
+        const matched = sections.filter((s) => s.toLowerCase().includes(keyword));
         if (matched.length > 0) {
           content = matched.join("\n\n");
         }
@@ -11695,9 +11802,13 @@ var profileStrategySchema = z21.object({
       operator: z21.string().describe("Comparison operator: >, <, >=, <=, ==, between, in"),
       value: z21.union([z21.string(), z21.number(), z21.array(z21.union([z21.string(), z21.number()]))]).describe("Filter value or array for between/in operators"),
       description: z21.string().optional().describe("Human-readable description of this filter"),
-      source: z21.enum(["market", "execution"]).optional().describe("Filter source: 'market' = testable against market data columns, 'execution' = platform-level (time windows, leg ratios). Defaults to 'market'. Execution filters are documented but skipped during validate_entry_filters analysis.")
+      source: z21.enum(["market", "execution"]).optional().describe(
+        "Filter source: 'market' = testable against market data columns, 'execution' = platform-level (time windows, leg ratios). Defaults to 'market'. Execution filters are documented but skipped during validate_entry_filters analysis."
+      )
     })
-  ).default([]).describe("Entry condition filters. Tag each with source: 'market' (testable in analysis) or 'execution' (OO/platform-level, skipped in analysis)."),
+  ).default([]).describe(
+    "Entry condition filters. Tag each with source: 'market' (testable in analysis) or 'execution' (OO/platform-level, skipped in analysis)."
+  ),
   exitRules: z21.array(
     z21.object({
       type: z21.string().describe("Rule type: stop_loss, profit_target, time_exit, conditional"),
@@ -11712,7 +11823,9 @@ var profileStrategySchema = z21.object({
       slippage: z21.number().optional().describe("Per-rule slippage override")
     })
   ).default([]).describe("Exit rules and triggers"),
-  expectedRegimes: z21.array(z21.enum(["very_low", "low", "below_avg", "above_avg", "high", "extreme"])).default([]).describe("VIX-based vol regimes this strategy targets. very_low=VIX<13, low=13-16, below_avg=16-20, above_avg=20-25, high=25-30, extreme=30+"),
+  expectedRegimes: z21.array(z21.enum(["very_low", "low", "below_avg", "above_avg", "high", "extreme"])).default([]).describe(
+    "VIX-based vol regimes this strategy targets. very_low=VIX<13, low=13-16, below_avg=16-20, above_avg=20-25, high=25-30, extreme=30+"
+  ),
   keyMetrics: z21.object({
     expectedWinRate: z21.number().optional().describe("Expected win rate (0-1)"),
     targetPremium: z21.number().optional().describe("Target premium collected ($)"),
@@ -11729,7 +11842,9 @@ var profileStrategySchema = z21.object({
     backtestAllocationPct: z21.number().optional().describe("Allocation % used in backtest"),
     liveAllocationPct: z21.number().optional().describe("Allocation % used in live portfolio"),
     maxContractsPerTrade: z21.number().optional().describe("Per-entry contract cap (distinct from maxContracts hard cap)")
-  }).optional().describe("Position sizing rules. Per-block \u2014 same strategy in backtest vs portfolio may have different sizing."),
+  }).optional().describe(
+    "Position sizing rules. Per-block \u2014 same strategy in backtest vs portfolio may have different sizing."
+  ),
   underlying: z21.string().optional().describe("Underlying symbol: SPX, QQQ, etc."),
   reEntry: z21.boolean().optional().describe("Strategy supports re-entry on same day"),
   capProfits: z21.boolean().optional().describe("Profits are capped by structure"),
@@ -11753,30 +11868,33 @@ async function handleProfileStrategy(input, baseDir) {
   await upgradeToReadWrite(baseDir);
   try {
     const conn = await getConnection(baseDir);
-    const stored = await upsertProfile(conn, {
-      blockId: input.blockId,
-      strategyName: input.strategyName,
-      structureType: input.structureType,
-      greeksBias: input.greeksBias,
-      thesis: input.thesis,
-      legs: input.legs,
-      entryFilters: input.entryFilters,
-      exitRules: input.exitRules,
-      expectedRegimes: input.expectedRegimes,
-      keyMetrics: input.keyMetrics,
-      positionSizing: input.positionSizing,
-      underlying: input.underlying,
-      reEntry: input.reEntry,
-      capProfits: input.capProfits,
-      capLosses: input.capLosses,
-      requireTwoPricesPT: input.requireTwoPricesPT,
-      closeOnCompletion: input.closeOnCompletion,
-      ignoreMarginReq: input.ignoreMarginReq
-    }, baseDir);
-    return createToolOutput(
-      `Profile saved: ${input.strategyName} for block ${input.blockId}`,
-      { profile: stored }
+    const stored = await upsertProfile(
+      conn,
+      {
+        blockId: input.blockId,
+        strategyName: input.strategyName,
+        structureType: input.structureType,
+        greeksBias: input.greeksBias,
+        thesis: input.thesis,
+        legs: input.legs,
+        entryFilters: input.entryFilters,
+        exitRules: input.exitRules,
+        expectedRegimes: input.expectedRegimes,
+        keyMetrics: input.keyMetrics,
+        positionSizing: input.positionSizing,
+        underlying: input.underlying,
+        reEntry: input.reEntry,
+        capProfits: input.capProfits,
+        capLosses: input.capLosses,
+        requireTwoPricesPT: input.requireTwoPricesPT,
+        closeOnCompletion: input.closeOnCompletion,
+        ignoreMarginReq: input.ignoreMarginReq
+      },
+      baseDir
     );
+    return createToolOutput(`Profile saved: ${input.strategyName} for block ${input.blockId}`, {
+      profile: stored
+    });
   } finally {
     await downgradeToReadOnly(baseDir);
   }
@@ -11790,10 +11908,7 @@ async function handleGetStrategyProfile(input, baseDir) {
       { profile: null }
     );
   }
-  return createToolOutput(
-    `Profile: ${input.strategyName} in block ${input.blockId}`,
-    { profile }
-  );
+  return createToolOutput(`Profile: ${input.strategyName} in block ${input.blockId}`, { profile });
 }
 async function handleListProfiles(input, baseDir) {
   const conn = await getConnection(baseDir);
@@ -11860,9 +11975,12 @@ function registerProfileTools(server, baseDir) {
     },
     async (input) => {
       if (input.blockId) {
-        const syncedHandler = withSyncedBlock(baseDir, async (syncInput, ctx) => {
-          return handleListProfiles({ blockId: syncInput.blockId }, ctx.baseDir);
-        });
+        const syncedHandler = withSyncedBlock(
+          baseDir,
+          async (syncInput, ctx) => {
+            return handleListProfiles({ blockId: syncInput.blockId }, ctx.baseDir);
+          }
+        );
         return syncedHandler({ blockId: input.blockId });
       }
       return handleListProfiles(input, baseDir);
@@ -12539,7 +12657,9 @@ async function handleValidateEntryFilters(input, baseDir) {
       single: ablationSingle,
       pairs: ablationPairs
     },
-    execution_filters_skipped: executionFilters.map((f) => f.description || `${f.field} ${f.operator} ${f.value}`),
+    execution_filters_skipped: executionFilters.map(
+      (f) => f.description || `${f.field} ${f.operator} ${f.value}`
+    ),
     profile_update_hints: profileUpdateHints,
     warnings
   });
@@ -12570,7 +12690,9 @@ async function handlePortfolioStructureMap(input, baseDir) {
       try {
         block = await loadBlock(baseDir, profile.blockId);
       } catch {
-        warnings.push(`Could not load block '${profile.blockId}' for strategy '${profile.strategyName}'`);
+        warnings.push(
+          `Could not load block '${profile.blockId}' for strategy '${profile.strategyName}'`
+        );
         continue;
       }
       let trades = filterByStrategy(block.trades, profile.strategyName);
@@ -12581,7 +12703,9 @@ async function handlePortfolioStructureMap(input, baseDir) {
         }
       }
       if (trades.length === 0) {
-        warnings.push(`No trades found for strategy '${profile.strategyName}' in block '${profile.blockId}'`);
+        warnings.push(
+          `No trades found for strategy '${profile.strategyName}' in block '${profile.blockId}'`
+        );
         continue;
       }
       const tradeKeys = uniqueTradeLookupKeys3(trades);
@@ -12699,10 +12823,7 @@ async function handlePortfolioStructureMap(input, baseDir) {
       );
     }
     const unknownTrendStats = unknownTrendPls.size > 0 ? Object.fromEntries(
-      [...unknownTrendPls.entries()].map(([name, pls]) => [
-        name,
-        computeSliceStats(pls)
-      ])
+      [...unknownTrendPls.entries()].map(([name, pls]) => [name, computeSliceStats(pls)])
     ) : void 0;
     const coverageSummary = {
       totalCells: 18,
@@ -12747,7 +12868,7 @@ function registerProfileAnalysisTools(server, baseDir) {
       if (getConnectionMode() === "read_write") {
         try {
           if (input.blockId) {
-            const { syncBlock: syncBlock2 } = await import("./sync-QFI5L7S7.js");
+            const { syncBlock: syncBlock2 } = await import("./sync-V25UQJA3.js");
             await syncBlock2(input.blockId, baseDir);
           } else {
             await syncAllBlocks(baseDir);
@@ -12849,12 +12970,8 @@ var VOL_REGIME_LABELS3 = {
   6: "extreme"
 };
 var regimeAllocationAdvisorSchema = z23.object({
-  blockId: z23.string().optional().describe(
-    "Block ID to analyze. When omitted, aggregate across all profiled strategies."
-  ),
-  minTrades: z23.number().optional().default(5).describe(
-    "Minimum trades per regime cell for reliable stats (default: 5)"
-  )
+  blockId: z23.string().optional().describe("Block ID to analyze. When omitted, aggregate across all profiled strategies."),
+  minTrades: z23.number().optional().default(5).describe("Minimum trades per regime cell for reliable stats (default: 5)")
 });
 async function handleRegimeAllocationAdvisor(input, baseDir) {
   const minTrades = input.minTrades ?? 5;
@@ -12946,9 +13063,7 @@ async function handleRegimeAllocationAdvisor(input, baseDir) {
         if (!regimeAggPls[label]) regimeAggPls[label] = [];
         regimeAggPls[label].push(trade.pl);
       }
-      const expectedSet = new Set(
-        profile.expectedRegimes.map((r) => r.toLowerCase())
-      );
+      const expectedSet = new Set(profile.expectedRegimes.map((r) => r.toLowerCase()));
       const regimePerformance = {};
       for (const [label, pls] of Object.entries(regimePls)) {
         const stats = computeSliceStats(pls);
@@ -13044,7 +13159,7 @@ function registerRegimeAdvisorTools(server, baseDir) {
       if (getConnectionMode() === "read_write") {
         try {
           if (input.blockId) {
-            const { syncBlock: syncBlock2 } = await import("./sync-QFI5L7S7.js");
+            const { syncBlock: syncBlock2 } = await import("./sync-V25UQJA3.js");
             await syncBlock2(input.blockId, baseDir);
           } else {
             await syncAllBlocks(baseDir);
@@ -13088,9 +13203,7 @@ var replayTradeSchema = z24.object({
   ).optional().describe("Explicit leg definitions for hypothetical replay"),
   // Mode B: Tradelog replay
   block_id: z24.string().optional().describe("Block ID to load trade from"),
-  trade_index: z24.number().optional().describe(
-    "0-based index of trade in block's tradelog (ordered by date_opened)"
-  ),
+  trade_index: z24.number().optional().describe("0-based index of trade in block's tradelog (ordered by date_opened)"),
   // Common fields
   open_date: z24.string().optional().describe(
     "Trade open date YYYY-MM-DD (required for hypothetical mode, auto-resolved for tradelog mode)"
@@ -13137,22 +13250,13 @@ function resolveOODateRange(parsedLegs, tradeYear, tradeOpenDate) {
   return { from: tradeOpenDate, to: maxDate };
 }
 async function handleReplayTrade(params, baseDir, stores, injectedConn) {
-  const {
-    legs: inputLegs,
-    block_id,
-    trade_index,
-    multiplier,
-    close_at,
-    skip_quotes
-  } = params;
+  const { legs: inputLegs, block_id, trade_index, multiplier, close_at, skip_quotes } = params;
   let { open_date, close_date } = params;
   let tradeCloseTimestamp;
   let replayLegs;
   if (inputLegs && inputLegs.length > 0) {
     if (!open_date || !close_date) {
-      throw new Error(
-        "open_date and close_date are required for hypothetical replay mode"
-      );
+      throw new Error("open_date and close_date are required for hypothetical replay mode");
     }
     replayLegs = inputLegs.map((leg) => ({
       occTicker: buildOccTicker(leg.ticker, leg.expiry, leg.type, leg.strike),
@@ -13171,9 +13275,7 @@ async function handleReplayTrade(params, baseDir, stores, injectedConn) {
     );
     const rows = result.getRows();
     if (rows.length === 0) {
-      throw new Error(
-        `No trade found at index ${trade_index} in block "${block_id}"`
-      );
+      throw new Error(`No trade found at index ${trade_index} in block "${block_id}"`);
     }
     const row = rows[0];
     const legsStr = String(row[0] ?? "");
@@ -13282,11 +13384,7 @@ async function handleReplayTrade(params, baseDir, stores, injectedConn) {
   );
   if (underlyingBars.length === 0) {
     try {
-      underlyingBars = await stores.spot.readDailyBars(
-        underlyingTicker,
-        open_date,
-        close_date
-      );
+      underlyingBars = await stores.spot.readDailyBars(underlyingTicker, open_date, close_date);
     } catch {
     }
   }
@@ -13439,9 +13537,7 @@ var getOptionSnapshotSchema = z25.object({
   expiration_date_gte: z25.string().optional().describe("Earliest expiration date (YYYY-MM-DD)"),
   expiration_date_lte: z25.string().optional().describe("Latest expiration date (YYYY-MM-DD)"),
   contract_type: z25.enum(["call", "put"]).optional().describe("Filter by call or put"),
-  limit: z25.number().optional().default(50).describe(
-    "Max contracts to return (default 50, use higher for full chain)"
-  )
+  limit: z25.number().optional().default(50).describe("Max contracts to return (default 50, use higher for full chain)")
 });
 async function handleGetOptionSnapshot(params) {
   try {
@@ -13611,7 +13707,7 @@ function evaluateTrigger(trigger, pnlPath, legs) {
     switch (type) {
       case "profitTarget": {
         if (trigger.unit === "percent" && trigger.entryCost == null) break;
-        const requiredHits = trigger.requiredHits ?? 1;
+        const requiredHits = trigger.requiredHits ?? 2;
         const dollarThresholdPT = trigger.unit === "percent" ? threshold * Math.abs(trigger.entryCost) : threshold;
         if (pnl >= dollarThresholdPT) {
           if (point.allLegsSync !== false) profitTargetHits++;
@@ -14019,7 +14115,9 @@ function numericalDecomposition(config, totalPnlChange, stepCount) {
     ...f,
     pctOfTotal: totalAbsSum > 0 ? Math.abs(f.totalPnl) / totalAbsSum * 100 : 0
   }));
-  const summaryParts = factors.map((f) => `${f.factor} ${f.totalPnl.toFixed(2)} (${f.pctOfTotal.toFixed(0)}%)`);
+  const summaryParts = factors.map(
+    (f) => `${f.factor} ${f.totalPnl.toFixed(2)} (${f.pctOfTotal.toFixed(0)}%)`
+  );
   const summary = `P&L of ${totalPnlChange.toFixed(2)} (numerical): ${summaryParts.join(", ")}`;
   return {
     factors,
@@ -14054,7 +14152,15 @@ function priceOption(type, S, K, dte, r, q, iv) {
   return bsPrice(bsType, S, K, T, r, q, iv);
 }
 function decomposeGreeks(config) {
-  const { pnlPath, legs, underlyingPrices, legGroups, legPricingInputs, riskFreeRate, dividendYield } = config;
+  const {
+    pnlPath,
+    legs,
+    underlyingPrices,
+    legGroups,
+    legPricingInputs,
+    riskFreeRate,
+    dividendYield
+  } = config;
   if (pnlPath.length <= 1) {
     const emptyFactors = [
       { factor: "delta", totalPnl: 0, pctOfTotal: 0, steps: [] },
@@ -14214,7 +14320,9 @@ function decomposeGreeks(config) {
   const summaryParts = factors.filter((f) => f.factor !== "residual").map((f) => `${f.factor} ${f.totalPnl.toFixed(2)} (${f.pctOfTotal.toFixed(0)}%)`);
   const residualFactor = factors.find((f) => f.factor === "residual");
   if (residualFactor && Math.abs(residualFactor.totalPnl) > 0.01) {
-    summaryParts.push(`residual ${residualFactor.totalPnl.toFixed(2)} (${residualFactor.pctOfTotal.toFixed(0)}%)`);
+    summaryParts.push(
+      `residual ${residualFactor.totalPnl.toFixed(2)} (${residualFactor.pctOfTotal.toFixed(0)}%)`
+    );
   }
   const summary = `P&L of ${totalPnlChange.toFixed(2)} (${methodLabel}): ${summaryParts.join(", ")}`;
   const warning = residualPct > 0.5 ? `Residual ${(residualPct * 100).toFixed(0)}% \u2014 attribution limited for some legs.` : null;
@@ -14257,11 +14365,13 @@ var triggerConfigSchema = z26.object({
   openDate: z26.string().optional(),
   clockTime: z26.string().optional(),
   trailAmount: z26.number().optional(),
-  steps: z26.array(z26.object({
-    armAt: z26.number(),
-    stopAt: z26.number(),
-    closeAllocationPct: z26.number().min(0).max(1).optional().describe("Fraction of REMAINING position to close at this milestone (0-1)")
-  })).optional(),
+  steps: z26.array(
+    z26.object({
+      armAt: z26.number(),
+      stopAt: z26.number(),
+      closeAllocationPct: z26.number().min(0).max(1).optional().describe("Fraction of REMAINING position to close at this milestone (0-1)")
+    })
+  ).optional(),
   spreadWidth: z26.number().optional(),
   contracts: z26.number().optional(),
   legIndex: z26.number().optional().describe("0-based leg index for perLegDelta \u2014 targets specific leg"),
@@ -14286,11 +14396,13 @@ var analyzeExitTriggersSchema = z26.object({
   multiplier: z26.number().default(100),
   triggers: z26.array(triggerConfigSchema).describe("Exit triggers to evaluate against the P&L path"),
   actual_exit_timestamp: z26.string().optional().describe("Actual exit time for comparison (format: YYYY-MM-DD HH:MM)"),
-  leg_groups: z26.array(z26.object({
-    label: z26.string(),
-    leg_indices: z26.array(z26.number()),
-    triggers: z26.array(triggerConfigSchema)
-  })).optional().describe("Per-leg-group exit triggers for multi-structure strategies"),
+  leg_groups: z26.array(
+    z26.object({
+      label: z26.string(),
+      leg_indices: z26.array(z26.number()),
+      triggers: z26.array(triggerConfigSchema)
+    })
+  ).optional().describe("Per-leg-group exit triggers for multi-structure strategies"),
   format: z26.enum(["summary", "full"]).default("summary").describe("'summary' omits per-step trigger states, 'full' includes all fire events")
 });
 var decomposeGreeksSchema = z26.object({
@@ -14301,10 +14413,12 @@ var decomposeGreeksSchema = z26.object({
   open_date: z26.string().optional(),
   close_date: z26.string().optional(),
   multiplier: z26.number().default(100),
-  leg_groups: z26.array(z26.object({
-    label: z26.string(),
-    leg_indices: z26.array(z26.number())
-  })).optional().describe("Leg grouping for per-group vega attribution (e.g., front_month vs back_month)"),
+  leg_groups: z26.array(
+    z26.object({
+      label: z26.string(),
+      leg_indices: z26.array(z26.number())
+    })
+  ).optional().describe("Leg grouping for per-group vega attribution (e.g., front_month vs back_month)"),
   format: z26.enum(["summary", "full"]).default("summary").describe("'summary' shows ranked factors, 'full' includes per-step contributions"),
   skip_quotes: z26.boolean().default(false).describe("Skip NBBO quote enrichment for option bars. Faster, but lower precision.")
 });
@@ -14329,7 +14443,8 @@ async function fetchPriceMap(stores, ticker, from, to) {
       }
     }
     for (const b of bars) {
-      if (!Number.isFinite(b.open) || b.open <= 0 || !Number.isFinite(b.high) || b.high <= 0 || !Number.isFinite(b.low) || b.low <= 0 || !Number.isFinite(b.close) || b.close <= 0) continue;
+      if (!Number.isFinite(b.open) || b.open <= 0 || !Number.isFinite(b.high) || b.high <= 0 || !Number.isFinite(b.low) || b.low <= 0 || !Number.isFinite(b.close) || b.close <= 0)
+        continue;
       const ts = `${b.date} ${b.time ?? ""}`.trim();
       map.set(ts, markPrice(b));
     }
@@ -14400,12 +14515,7 @@ async function handleAnalyzeExitTriggers(params, baseDir, stores, injectedConn)
     vix9dPrices = await fetchPriceMap(stores, "VIX9D", firstDate, lastDate);
   }
   if (needsUnderlying) {
-    underlyingPrices = await fetchPriceMap(
-      stores,
-      underlyingTicker,
-      firstDate,
-      lastDate
-    );
+    underlyingPrices = await fetchPriceMap(stores, underlyingTicker, firstDate, lastDate);
   }
   const exitTriggers = triggers.map((t) => ({
     type: t.type,
@@ -14827,11 +14937,13 @@ var triggerConfigSchema2 = z27.object({
   openDate: z27.string().optional(),
   clockTime: z27.string().optional(),
   trailAmount: z27.number().optional(),
-  steps: z27.array(z27.object({
-    armAt: z27.number(),
-    stopAt: z27.number(),
-    closeAllocationPct: z27.number().min(0).max(1).optional().describe("Fraction of REMAINING position to close at this milestone (0-1)")
-  })).optional(),
+  steps: z27.array(
+    z27.object({
+      armAt: z27.number(),
+      stopAt: z27.number(),
+      closeAllocationPct: z27.number().min(0).max(1).optional().describe("Fraction of REMAINING position to close at this milestone (0-1)")
+    })
+  ).optional(),
   spreadWidth: z27.number().optional(),
   contracts: z27.number().optional(),
   legIndex: z27.number().optional().describe("0-based leg index for perLegDelta \u2014 targets specific leg"),
@@ -14846,17 +14958,23 @@ var batchExitAnalysisSchema = z27.object({
     to: z27.string().optional().describe("End date YYYY-MM-DD")
   }).optional().describe("Filter trades by date range"),
   candidate_policy: z27.array(triggerConfigSchema2).describe("Candidate exit policy triggers to evaluate -- same schema as analyze_exit_triggers"),
-  leg_groups: z27.array(z27.object({
-    label: z27.string(),
-    leg_indices: z27.array(z27.number()),
-    triggers: z27.array(triggerConfigSchema2)
-  })).optional().describe("Per-leg-group exit triggers for multi-structure strategies"),
-  baseline_mode: z27.enum(["actual", "holdToEnd"]).default("actual").describe("'actual' compares candidate vs trade's actual P&L; 'holdToEnd' compares vs last replay timestamp"),
+  leg_groups: z27.array(
+    z27.object({
+      label: z27.string(),
+      leg_indices: z27.array(z27.number()),
+      triggers: z27.array(triggerConfigSchema2)
+    })
+  ).optional().describe("Per-leg-group exit triggers for multi-structure strategies"),
+  baseline_mode: z27.enum(["actual", "holdToEnd"]).default("actual").describe(
+    "'actual' compares candidate vs trade's actual P&L; 'holdToEnd' compares vs last replay timestamp"
+  ),
   limit: z27.number().min(1).max(200).default(50).describe("Max trades to analyze. Most recent trades selected"),
   min_pl: z27.number().optional().describe("Only include trades with actual P&L >= this value"),
   max_pl: z27.number().optional().describe("Only include trades with actual P&L <= this value"),
   multiplier: z27.number().default(100).describe("Contract multiplier (default 100)"),
-  format: z27.enum(["summary", "full"]).default("summary").describe("'summary' returns aggregate stats + trigger attribution; 'full' adds per-trade breakdown")
+  format: z27.enum(["summary", "full"]).default("summary").describe(
+    "'summary' returns aggregate stats + trigger attribution; 'full' adds per-trade breakdown"
+  )
 });
 async function handleBatchExitAnalysis(params, baseDir, stores, injectedConn) {
   const {
@@ -15019,9 +15137,7 @@ async function handleBatchExitAnalysis(params, baseDir, stores, injectedConn) {
       if (profile) {
         result.profileContext = {
           structureType: profile.structureType,
-          exitRules: profile.exitRules.map(
-            (r) => r.description ?? `${r.type} ${r.trigger}`
-          )
+          exitRules: profile.exitRules.map((r) => r.description ?? `${r.type} ${r.trigger}`)
         };
       }
     } catch {
@@ -15042,10 +15158,12 @@ function registerBatchExitAnalysisTools(server, baseDir, stores) {
         return createToolOutput(result.summary, result);
       } catch (error) {
         return {
-          content: [{
-            type: "text",
-            text: `Error in batch exit analysis: ${error.message}`
-          }],
+          content: [
+            {
+              type: "text",
+              text: `Error in batch exit analysis: ${error.message}`
+            }
+          ],
           isError: true
         };
       }
@@ -15075,8 +15193,12 @@ function tradingDays(from, to) {
 var getGreeksAttributionSchema = z28.object({
   block_id: z28.string().describe("Block ID to analyze"),
   mode: z28.enum(["summary", "instance"]).default("summary").describe("summary: block-level attribution. instance: single trade time-series."),
-  trade_index: z28.number().int().min(0).optional().describe("Trade index (required for instance mode). Use get_block_info to find trade indices."),
-  skip_quotes: z28.boolean().default(true).describe("Use cached bar data only (fast). Set false to fetch NBBO quotes for higher precision."),
+  trade_index: z28.number().int().min(0).optional().describe(
+    "Trade index (required for instance mode). Use get_block_info to find trade indices."
+  ),
+  skip_quotes: z28.boolean().default(true).describe(
+    "Use cached bar data only (fast). Set false to fetch NBBO quotes for higher precision."
+  ),
   detailed: z28.boolean().default(false).describe("false: 5 factors (delta, gamma, theta, vega, residual). true: adds charm, vanna."),
   strategy: z28.string().optional().describe("Filter to trades matching this strategy name (case-insensitive).")
 });
@@ -15084,7 +15206,16 @@ var COLLAPSE_MAP = {
   charm: "delta",
   vanna: "vega"
 };
-var FACTOR_ORDER = ["theta", "vega", "delta", "gamma", "residual", "time_and_vol", "charm", "vanna"];
+var FACTOR_ORDER = [
+  "theta",
+  "vega",
+  "delta",
+  "gamma",
+  "residual",
+  "time_and_vol",
+  "charm",
+  "vanna"
+];
 function collapseFactors(factors, detailed) {
   const totals = /* @__PURE__ */ new Map();
   for (const f of factors) {
@@ -15134,9 +15265,25 @@ async function handleGetGreeksAttribution(params, baseDir, stores, injectedConn)
     if (trade_index == null) {
       throw new Error("trade_index is required for instance mode");
     }
-    return handleInstanceMode(block_id, trade_index, skip_quotes, detailed, baseDir, stores, injectedConn);
+    return handleInstanceMode(
+      block_id,
+      trade_index,
+      skip_quotes,
+      detailed,
+      baseDir,
+      stores,
+      injectedConn
+    );
   }
-  return handleSummaryMode(block_id, skip_quotes, detailed, strategy, baseDir, stores, injectedConn);
+  return handleSummaryMode(
+    block_id,
+    skip_quotes,
+    detailed,
+    strategy,
+    baseDir,
+    stores,
+    injectedConn
+  );
 }
 async function handleSummaryMode(block_id, skip_quotes, detailed, strategy, baseDir, stores, injectedConn) {
   const conn = injectedConn ?? await getConnection(baseDir);
@@ -15188,7 +15335,10 @@ async function handleSummaryMode(block_id, skip_quotes, detailed, strategy, base
           injectedConn
         ).then((result) => {
           for (const factor of result.factors) {
-            accumulated.set(factor.factor, (accumulated.get(factor.factor) ?? 0) + factor.totalPnl);
+            accumulated.set(
+              factor.factor,
+              (accumulated.get(factor.factor) ?? 0) + factor.totalPnl
+            );
           }
           actualTotalPnl += trade.actualPl;
           markTotalPnl += result.totalPnlChange;
@@ -15291,10 +15441,20 @@ async function handleInstanceMode(block_id, trade_index, skip_quotes, detailed,
   for (let i = 0; i <= stepCount; i++) {
     const entry = {
       date: getStepDate(i),
-      delta: getStepValue(factorSteps, "delta", i, detailed ? 0 : factorSteps.get("charm")?.[i] ?? 0),
+      delta: getStepValue(
+        factorSteps,
+        "delta",
+        i,
+        detailed ? 0 : factorSteps.get("charm")?.[i] ?? 0
+      ),
       gamma: getStepValue(factorSteps, "gamma", i, 0),
       theta: getStepValue(factorSteps, "theta", i, 0),
-      vega: getStepValue(factorSteps, "vega", i, detailed ? 0 : factorSteps.get("vanna")?.[i] ?? 0),
+      vega: getStepValue(
+        factorSteps,
+        "vega",
+        i,
+        detailed ? 0 : factorSteps.get("vanna")?.[i] ?? 0
+      ),
       residual: getStepValue(factorSteps, "residual", i, 0)
     };
     if (factorSteps.has("time_and_vol")) {
@@ -15456,7 +15616,13 @@ var MarketIngestor = class {
           assetClass
         });
       } catch (error) {
-        const mapped = this.mapProviderFailure(provider, "bars", normalizedTicker, error, assetClass);
+        const mapped = this.mapProviderFailure(
+          provider,
+          "bars",
+          normalizedTicker,
+          error,
+          assetClass
+        );
         if (mapped) return mapped;
         throw error;
       }
@@ -15709,11 +15875,7 @@ var MarketIngestor = class {
         if (mapped) return mapped;
         throw error;
       }
-      const written = await this.writeQuotesForTicker(
-        provider,
-        ticker,
-        quotes
-      );
+      const written = await this.writeQuotesForTicker(provider, ticker, quotes);
       totalRows += written.rowsWritten;
       if (written.minDate && (!minDate || written.minDate < minDate)) minDate = written.minDate;
       if (written.maxDate && (!maxDate || written.maxDate > maxDate)) maxDate = written.maxDate;
@@ -15749,12 +15911,7 @@ var MarketIngestor = class {
     for (const underlying of underlyings) {
       const upperUnderlying = underlying.toUpperCase();
       for (const date of dates) {
-        const drain = await this.drainBulkQuotes(
-          provider,
-          upperUnderlying,
-          date,
-          onProgress
-        );
+        const drain = await this.drainBulkQuotes(provider, upperUnderlying, date, onProgress);
         if (drain.rowsWritten > 0) {
           totalRows += drain.rowsWritten;
           if (!minDate || date < minDate) minDate = date;
@@ -15814,7 +15971,11 @@ var MarketIngestor = class {
         totalContracts: info.totalContracts
       });
     } : void 0;
-    const stream = provider.fetchBulkQuotes({ underlying: upperUnderlying, date, onGroupComplete });
+    const stream = provider.fetchBulkQuotes({
+      underlying: upperUnderlying,
+      date,
+      onGroupComplete
+    });
     for await (const chunk of stream) {
       for (const row of chunk) {
         const root = extractRoot(row.ticker);
@@ -15865,15 +16026,12 @@ var MarketIngestor = class {
         );
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        console.warn(
-          "[drainBulkQuotes] enrichQuoteRows failed; skipping batch",
-          {
-            underlying: resolvedUnderlying,
-            date,
-            rows: rows.length,
-            error: message
-          }
-        );
+        console.warn("[drainBulkQuotes] enrichQuoteRows failed; skipping batch", {
+          underlying: resolvedUnderlying,
+          date,
+          rows: rows.length,
+          error: message
+        });
         skipped.push({
           underlying: resolvedUnderlying,
           date,
@@ -15960,16 +16118,13 @@ var MarketIngestor = class {
         );
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        console.warn(
-          "[writeQuotesForTicker] enrichQuoteRows failed; skipping batch",
-          {
-            underlying,
-            date,
-            ticker,
-            rows: rows.length,
-            error: message
-          }
-        );
+        console.warn("[writeQuotesForTicker] enrichQuoteRows failed; skipping batch", {
+          underlying,
+          date,
+          ticker,
+          rows: rows.length,
+          error: message
+        });
         skipped.push({
           underlying,
           date,
@@ -16036,7 +16191,12 @@ var MarketIngestor = class {
     for (const underlying of opts.underlyings) {
       const upperUnderlying = underlying.toUpperCase();
       const assetClass = this.detectAssetClass(upperUnderlying);
-      const unsupported = this.preflightProviderSupport(provider, "chain", upperUnderlying, assetClass);
+      const unsupported = this.preflightProviderSupport(
+        provider,
+        "chain",
+        upperUnderlying,
+        assetClass
+      );
       if (unsupported) return unsupported;
       const dates = this.enumerateDates(opts.from, opts.to);
       for (const date of dates) {
@@ -16048,7 +16208,13 @@ var MarketIngestor = class {
             expired: true
           });
         } catch (error) {
-          const mapped = this.mapProviderFailure(provider, "chain", upperUnderlying, error, assetClass);
+          const mapped = this.mapProviderFailure(
+            provider,
+            "chain",
+            upperUnderlying,
+            error,
+            assetClass
+          );
           if (mapped) return mapped;
           throw error;
         }
@@ -16196,43 +16362,75 @@ var MarketIngestor = class {
         case "spot_bars": {
           const ticker = opts.partition.ticker;
           if (!ticker) {
-            return { status: "error", rowsWritten: 0, error: "partition.ticker is required for datasetType='spot_bars'" };
+            return {
+              status: "error",
+              rowsWritten: 0,
+              error: "partition.ticker is required for datasetType='spot_bars'"
+            };
           }
           const { rowCount } = await this.deps.stores.spot.writeFromSelect(
             { ticker: ticker.toUpperCase(), date: partitionDate },
             opts.selectSql
           );
-          return { status: "ok", rowsWritten: rowCount, dateRange: { from: partitionDate, to: partitionDate } };
+          return {
+            status: "ok",
+            rowsWritten: rowCount,
+            dateRange: { from: partitionDate, to: partitionDate }
+          };
         }
         case "option_quotes": {
           const underlying = opts.partition.underlying;
           if (!underlying) {
-            return { status: "error", rowsWritten: 0, error: "partition.underlying is required for datasetType='option_quotes'" };
+            return {
+              status: "error",
+              rowsWritten: 0,
+              error: "partition.underlying is required for datasetType='option_quotes'"
+            };
           }
           const { rowCount } = await this.deps.stores.quote.writeFromSelect(
             { underlying: underlying.toUpperCase(), date: partitionDate },
             opts.selectSql
           );
-          return { status: "ok", rowsWritten: rowCount, dateRange: { from: partitionDate, to: partitionDate } };
+          return {
+            status: "ok",
+            rowsWritten: rowCount,
+            dateRange: { from: partitionDate, to: partitionDate }
+          };
         }
         case "option_chain": {
           const underlying = opts.partition.underlying;
           if (!underlying) {
-            return { status: "error", rowsWritten: 0, error: "partition.underlying is required for datasetType='option_chain'" };
+            return {
+              status: "error",
+              rowsWritten: 0,
+              error: "partition.underlying is required for datasetType='option_chain'"
+            };
           }
           const { rowCount } = await this.deps.stores.chain.writeFromSelect(
             { underlying: underlying.toUpperCase(), date: partitionDate },
             opts.selectSql
           );
-          return { status: "ok", rowsWritten: rowCount, dateRange: { from: partitionDate, to: partitionDate } };
+          return {
+            status: "ok",
+            rowsWritten: rowCount,
+            dateRange: { from: partitionDate, to: partitionDate }
+          };
         }
         default: {
           const _exhaustive = opts.datasetType;
-          return { status: "error", rowsWritten: 0, error: `Unknown datasetType: ${String(_exhaustive)}` };
+          return {
+            status: "error",
+            rowsWritten: 0,
+            error: `Unknown datasetType: ${String(_exhaustive)}`
+          };
         }
       }
     } catch (err) {
-      return { status: "error", rowsWritten: 0, error: err instanceof Error ? err.message : String(err) };
+      return {
+        status: "error",
+        rowsWritten: 0,
+        error: err instanceof Error ? err.message : String(err)
+      };
     }
   }
   async computeVixContext(opts) {
@@ -16322,7 +16520,11 @@ var MarketIngestor = class {
     const coverage = {};
     for (const ticker of opts.spotTickers) {
       try {
-        const cov = await this.deps.stores.spot.getCoverage(ticker.toUpperCase(), opts.asOf, opts.asOf);
+        const cov = await this.deps.stores.spot.getCoverage(
+          ticker.toUpperCase(),
+          opts.asOf,
+          opts.asOf
+        );
         coverage[ticker] = {
           totalDates: cov.totalDates,
           dateRange: cov.earliest && cov.latest ? { from: cov.earliest, to: cov.latest } : void 0
@@ -16346,7 +16548,13 @@ var MarketIngestor = class {
     else status = "ok";
     return {
       status,
-      perOperation: { spot: spotResults, chain: chainResults, quotes: quoteResults, openInterest: openInterestResults, vixContext },
+      perOperation: {
+        spot: spotResults,
+        chain: chainResults,
+        quotes: quoteResults,
+        openInterest: openInterestResults,
+        vixContext
+      },
       coverage,
       errors,
       ...aggregateSkipped.length > 0 ? { skipped: aggregateSkipped } : {}
@@ -16395,8 +16603,12 @@ function registerMarketFetchTools(server, baseDir, stores) {
     {
       description: "Fetch minute-level option quotes. Two modes \u2014 pass EITHER 'tickers' (specific OCC contracts, per-ticker provider calls) OR 'underlyings' (every contract under a symbol, provider bulk-by-root path \u2014 ThetaData only). ThetaData MDDS bulk mode enumerates contracts, fetches concrete quote history in bounded batches, and reuses first-order greeks bands per expiration/day with concrete-greeks fallback for misses. Writes to market.option_quote_minutes. The 'source' column tags Massive provider rows: 'nbbo' (real bid/ask via /v3/quotes when MASSIVE_DATA_TIER=quotes) or 'synth_close' (synthesized from /v2/aggs OHLCV close when the user's plan lacks /v3/quotes; bid=ask=close). ThetaData per-ticker rows are tagged 'nbbo'; ThetaData bulk rows are true NBBO and may persist source as NULL until the bulk row contract carries source. Massive falls back automatically on Developer/lower plans; ThetaData (both modes) returns true NBBO. Returns status='unsupported' with a clear error only when the active provider lacks the requested mode (e.g., bulk-by-underlying on Massive).",
       inputSchema: z29.object({
-        tickers: z29.array(z29.string()).min(1).optional().describe("Option tickers in OCC format (e.g., 'SPXW260321C05800000'). No O: prefix. Mutually exclusive with 'underlyings'."),
-        underlyings: z29.array(z29.string()).min(1).optional().describe("Underlying symbols (e.g. ['SPX']). Bulk mode \u2014 returns every contract's minute quotes per date. Mutually exclusive with 'tickers'."),
+        tickers: z29.array(z29.string()).min(1).optional().describe(
+          "Option tickers in OCC format (e.g., 'SPXW260321C05800000'). No O: prefix. Mutually exclusive with 'underlyings'."
+        ),
+        underlyings: z29.array(z29.string()).min(1).optional().describe(
+          "Underlying symbols (e.g. ['SPX']). Bulk mode \u2014 returns every contract's minute quotes per date. Mutually exclusive with 'tickers'."
+        ),
         from: z29.string().describe("Start date YYYY-MM-DD"),
         to: z29.string().describe("End date YYYY-MM-DD"),
         provider: z29.enum(["massive", "thetadata"]).optional(),
@@ -16455,7 +16667,13 @@ function registerMarketFetchTools(server, baseDir, stores) {
     async ({ underlyings, from, to, provider, dry_run }) => {
       await upgradeToReadWrite(baseDir);
       try {
-        const result = await ingestor.ingestChain({ underlyings, from, to, provider, dryRun: dry_run });
+        const result = await ingestor.ingestChain({
+          underlyings,
+          from,
+          to,
+          provider,
+          dryRun: dry_run
+        });
         const summary = result.status === "unsupported" ? `Unsupported: ${result.error}` : dry_run ? `[DRY RUN] Would fetch chain for ${underlyings.join(", ")}` : `${result.status}: wrote ${result.rowsWritten} contract rows`;
         return createToolOutput(summary, result);
       } finally {
@@ -16542,7 +16760,15 @@ function registerMarketFetchTools(server, baseDir, stores) {
         provider: z29.enum(["massive", "thetadata"]).optional()
       })
     },
-    async ({ asOf, spot_tickers, chain_underlyings, quote_tickers, quote_underlyings, compute_vix_context, provider }, extra) => {
+    async ({
+      asOf,
+      spot_tickers,
+      chain_underlyings,
+      quote_tickers,
+      quote_underlyings,
+      compute_vix_context,
+      provider
+    }, extra) => {
       await upgradeToReadWrite(baseDir);
       try {
         const progressToken = extra?._meta?.progressToken;
@@ -16577,7 +16803,9 @@ function registerMarketFetchTools(server, baseDir, stores) {
           ...result.perOperation.quotes,
           ...result.perOperation.vixContext ? [result.perOperation.vixContext] : []
         ];
-        const unsupportedCount = operationResults.filter((item) => item.status === "unsupported").length;
+        const unsupportedCount = operationResults.filter(
+          (item) => item.status === "unsupported"
+        ).length;
         const skippedOpCount = operationResults.filter((item) => item.status === "skipped").length;
         const partialBatchCount = result.skipped?.length ?? 0;
         const partialSuffix = result.status === "partial" && partialBatchCount > 0 ? ` \u2014 ${partialBatchCount} batch(es) skipped on enrichment (see result.skipped[])` : "";
@@ -16604,18 +16832,14 @@ var UnderlyingsFileSchema = z30.object({
 });
 var registerUnderlyingSchema = z30.object({
   underlying: z30.string().min(1).max(16).regex(TICKER_RE).describe("Canonical underlying symbol, e.g. SPX"),
-  roots: z30.array(z30.string().min(1).max(16).regex(TICKER_RE)).min(1).max(32).describe(
-    "OCC roots that resolve to this underlying, e.g. ['SPX','SPXW','SPXQ']"
-  )
+  roots: z30.array(z30.string().min(1).max(16).regex(TICKER_RE)).min(1).max(32).describe("OCC roots that resolve to this underlying, e.g. ['SPX','SPXW','SPXQ']")
 });
 var unregisterUnderlyingSchema = z30.object({
   underlying: z30.string().min(1).max(16).regex(TICKER_RE).describe("Underlying to remove. Bundled defaults cannot be removed.")
 });
 var listUnderlyingsSchema = z30.object({});
 var resolveRootSchema = z30.object({
-  input: z30.string().min(1).max(32).describe(
-    "Bare root ('SPXW') or full OCC ticker ('SPXW251219C05000000')"
-  )
+  input: z30.string().min(1).max(32).describe("Bare root ('SPXW') or full OCC ticker ('SPXW251219C05000000')")
 });
 
 // src/market/tickers/loader.ts
@@ -16630,9 +16854,7 @@ function validate(underlying, roots) {
   }
   for (const r of roots) {
     if (!TICKER_RE.test(r)) {
-      throw new Error(
-        `TickerRegistry: invalid root "${r}" \u2014 must match ${TICKER_RE.source}`
-      );
+      throw new Error(`TickerRegistry: invalid root "${r}" \u2014 must match ${TICKER_RE.source}`);
     }
   }
 }
@@ -16715,9 +16937,7 @@ var TickerRegistry = class {
   unregister(underlying) {
     const entry = this.entries.get(underlying);
     if (!entry) {
-      throw new Error(
-        `TickerRegistry.unregister: unknown underlying "${underlying}"`
-      );
+      throw new Error(`TickerRegistry.unregister: unknown underlying "${underlying}"`);
     }
     if (entry.source === "default") {
       throw new Error(
@@ -17295,11 +17515,7 @@ var ParquetSpotStore = class extends SpotStore {
     }));
   }
   async getCoverage(ticker, from, to) {
-    const tickerDir = path7.join(
-      resolveMarketDir(this.ctx.dataDir),
-      "spot",
-      `ticker=${ticker}`
-    );
+    const tickerDir = path7.join(resolveMarketDir(this.ctx.dataDir), "spot", `ticker=${ticker}`);
     if (!existsSync3(tickerDir)) {
       return { earliest: null, latest: null, missingDates: [], totalDates: 0 };
     }
@@ -17717,7 +17933,9 @@ async function setupParquetWorkingTables(conn, dataDir) {
   const enrichedTickerGlob = path8.join(enrichedDir, "ticker=*", "data.parquet");
   const enrichedContextPath = path8.join(enrichedDir, "context", "data.parquet");
   if (existsSync4(dailyPath)) {
-    await conn.run(`CREATE TEMP TABLE "${dailyTable}" AS SELECT * FROM read_parquet('${dailyPath}')`);
+    await conn.run(
+      `CREATE TEMP TABLE "${dailyTable}" AS SELECT * FROM read_parquet('${dailyPath}')`
+    );
     await alignDailyWorkingTableColumns(conn, dailyTable);
   } else if (hasEnrichedTickerFiles(enrichedDir)) {
     await conn.run(
@@ -17732,9 +17950,7 @@ async function setupParquetWorkingTables(conn, dataDir) {
     }
     await alignDailyWorkingTableColumns(conn, dailyTable);
   } else {
-    await conn.run(
-      `CREATE TEMP TABLE "${dailyTable}" AS SELECT * FROM market.enriched WHERE 1=0`
-    );
+    await conn.run(`CREATE TEMP TABLE "${dailyTable}" AS SELECT * FROM market.enriched WHERE 1=0`);
     for (const ohlcv of ["open", "high", "low", "close"]) {
       try {
         await conn.run(`ALTER TABLE "${dailyTable}" ADD COLUMN "${ohlcv}" DOUBLE`);
@@ -17757,7 +17973,9 @@ async function setupParquetWorkingTables(conn, dataDir) {
   } catch {
   }
   if (existsSync4(dateContextPath)) {
-    await conn.run(`CREATE TEMP TABLE "${dateContextTable}" AS SELECT * FROM read_parquet('${dateContextPath}')`);
+    await conn.run(
+      `CREATE TEMP TABLE "${dateContextTable}" AS SELECT * FROM read_parquet('${dateContextPath}')`
+    );
   } else if (existsSync4(enrichedContextPath)) {
     await conn.run(
       `CREATE TEMP TABLE "${dateContextTable}" AS SELECT * FROM read_parquet('${enrichedContextPath}')`
@@ -17768,7 +17986,9 @@ async function setupParquetWorkingTables(conn, dataDir) {
       Trend_Direction VARCHAR, VIX_Spike_Pct DOUBLE, VIX_Gap_Pct DOUBLE
     )`);
   }
-  await conn.run(`CREATE UNIQUE INDEX "idx_${dateContextTable}_date" ON "${dateContextTable}"(date)`);
+  await conn.run(
+    `CREATE UNIQUE INDEX "idx_${dateContextTable}_date" ON "${dateContextTable}"(date)`
+  );
   await conn.run(`CREATE UNIQUE INDEX "idx_${dailyTable}_pk" ON "${dailyTable}"(ticker, date)`);
   return { dailyTable, dateContextTable };
 }
@@ -17795,12 +18015,7 @@ async function flushEnrichedToParquet(conn, dataDir, ticker, tables) {
     targetPath: tickerFile,
     selectQuery: `SELECT ticker, date, ${enrichedColList} FROM "${tables.dailyTable}" WHERE ticker = '${ticker}' ORDER BY date`
   });
-  const contextFile = path8.join(
-    resolveMarketDir(dataDir),
-    "enriched",
-    "context",
-    "data.parquet"
-  );
+  const contextFile = path8.join(resolveMarketDir(dataDir), "enriched", "context", "data.parquet");
   await writeParquetAtomic(conn, {
     targetPath: contextFile,
     selectQuery: `SELECT * FROM "${tables.dateContextTable}" ORDER BY date`
@@ -17836,7 +18051,9 @@ async function runTier2(conn, targets, spotStore) {
       const BATCH_SIZE = 500;
       for (let start = 0; start < bars.length; start += BATCH_SIZE) {
         const batch = bars.slice(start, start + BATCH_SIZE);
-        const placeholders = batch.map((_, i) => `($${i * 6 + 1},$${i * 6 + 2},$${i * 6 + 3},$${i * 6 + 4},$${i * 6 + 5},$${i * 6 + 6})`).join(",");
+        const placeholders = batch.map(
+          (_, i) => `($${i * 6 + 1},$${i * 6 + 2},$${i * 6 + 3},$${i * 6 + 4},$${i * 6 + 5},$${i * 6 + 6})`
+        ).join(",");
         const params = batch.flatMap((b) => [b.ticker, b.date, b.open, b.high, b.low, b.close]);
         await conn.run(
           `INSERT INTO "${vixTempTable}" VALUES ${placeholders}`,
@@ -17968,12 +18185,21 @@ async function runTier2(conn, targets, spotStore) {
       };
     });
     const enrichedContext = computeVIXDerivedFields(contextRows);
-    const derivedCols = ["date", "Vol_Regime", "Term_Structure_State", "Trend_Direction", "VIX_Spike_Pct", "VIX_Gap_Pct"];
+    const derivedCols = [
+      "date",
+      "Vol_Regime",
+      "Term_Structure_State",
+      "Trend_Direction",
+      "VIX_Spike_Pct",
+      "VIX_Gap_Pct"
+    ];
     const BATCH_SIZE = 500;
     for (let start = 0; start < enrichedContext.length; start += BATCH_SIZE) {
       const batch = enrichedContext.slice(start, start + BATCH_SIZE);
       const placeholders = batch.map((_, rowIdx) => {
-        const params2 = derivedCols.map((__, colIdx) => `$${rowIdx * derivedCols.length + colIdx + 1}`);
+        const params2 = derivedCols.map(
+          (__, colIdx) => `$${rowIdx * derivedCols.length + colIdx + 1}`
+        );
         return `(${params2.join(", ")})`;
       }).join(", ");
       const sql = `INSERT OR REPLACE INTO ${dateContextTarget} (${derivedCols.join(", ")}) VALUES ${placeholders}`;
@@ -18007,10 +18233,9 @@ async function hasTier3Data(conn, ticker, spotStore) {
     const cov = await spotStore.getCoverage(ticker, "1970-01-01", "9999-12-31");
     return cov.totalDates > 0;
   }
-  const r = await conn.runAndReadAll(
-    `SELECT COUNT(*) FROM market.spot WHERE ticker = $1 LIMIT 1`,
-    [ticker]
-  );
+  const r = await conn.runAndReadAll(`SELECT COUNT(*) FROM market.spot WHERE ticker = $1 LIMIT 1`, [
+    ticker
+  ]);
   return Number(r.getRows()[0]?.[0] ?? 0) > 0;
 }
 async function runEnrichment(conn, ticker, opts = {}, io) {
@@ -18047,7 +18272,10 @@ async function runEnrichment(conn, ticker, opts = {}, io) {
         fetchParams.push(lookbackStart);
       }
       fetchSql += ` ORDER BY date ASC`;
-      const rawReader = await conn.runAndReadAll(fetchSql, fetchParams);
+      const rawReader = await conn.runAndReadAll(
+        fetchSql,
+        fetchParams
+      );
       rawRows = rawReader.getRows();
     }
     if (rawRows.length === 0) {
@@ -18264,7 +18492,8 @@ function computeIntradayTimingFields(bars) {
   const highInAfternoon = highTime >= 12;
   const lowInAfternoon = lowTime >= 12;
   let reversalType = 0;
-  if (highInMorning && lowInAfternoon) reversalType = 1;
+  if (highInMorning && lowInAfternoon)
+    reversalType = 1;
   else if (lowInMorning && highInAfternoon) reversalType = -1;
   const openingBars = bars.filter((b) => hhmmToDecimalHours(b.time) < 10);
   let openingDriveStrength = 0;
@@ -18289,7 +18518,14 @@ function computeIntradayTimingFields(bars) {
       intradayRealizedVol = barStdDev * Math.sqrt(bars.length * 252);
     }
   }
-  return { highTime, lowTime, highBeforeLow, reversalType, openingDriveStrength, intradayRealizedVol };
+  return {
+    highTime,
+    lowTime,
+    highBeforeLow,
+    reversalType,
+    openingDriveStrength,
+    intradayRealizedVol
+  };
 }
 async function runTier3(conn, ticker, dates, dailyTarget = "market.enriched", spotStore) {
   const hasData = await hasTier3Data(conn, ticker, spotStore);
@@ -18355,7 +18591,14 @@ async function runTier3(conn, ticker, dates, dailyTarget = "market.enriched", sp
       reason: "intraday data exists but no bars overlap with enrichment date range"
     };
   }
-  const tier3Cols = ["High_Time", "Low_Time", "High_Before_Low", "Reversal_Type", "Opening_Drive_Strength", "Intraday_Realized_Vol"];
+  const tier3Cols = [
+    "High_Time",
+    "Low_Time",
+    "High_Before_Low",
+    "Reversal_Type",
+    "Opening_Drive_Strength",
+    "Intraday_Realized_Vol"
+  ];
   const enrichedRows = [];
   for (const [dateStr, bars] of barsByDate) {
     const timing = computeIntradayTimingFields(bars);
@@ -18446,9 +18689,7 @@ var ParquetEnrichedStore = class extends EnrichedStore {
     });
     const reader = await this.ctx.conn.runAndReadAll(sql);
     const names = reader.columnNames();
-    return reader.getRows().map(
-      (row) => Object.fromEntries(names.map((n, i) => [n, row[i]]))
-    );
+    return reader.getRows().map((row) => Object.fromEntries(names.map((n, i) => [n, row[i]])));
   }
   async getCoverage(ticker) {
     const filePath = path9.join(
@@ -18521,9 +18762,7 @@ var DuckdbEnrichedStore = class extends EnrichedStore {
     });
     const reader = await this.ctx.conn.runAndReadAll(sql);
     const names = reader.columnNames();
-    return reader.getRows().map(
-      (row) => Object.fromEntries(names.map((n, i) => [n, row[i]]))
-    );
+    return reader.getRows().map((row) => Object.fromEntries(names.map((n, i) => [n, row[i]])));
   }
   async getCoverage(ticker) {
     const tickerLit = ticker.replace(/'/g, "''");
@@ -18876,9 +19115,7 @@ var ParquetQuoteStore = class extends QuoteStore {
   }
   async readQuotes(occTickers, from, to) {
     if (occTickers.length === 0) return /* @__PURE__ */ new Map();
-    const firstUnderlying = this.ctx.tickers.resolve(
-      extractRoot(occTickers[0])
-    );
+    const firstUnderlying = this.ctx.tickers.resolve(extractRoot(occTickers[0]));
     for (const t of occTickers) {
       const u = this.ctx.tickers.resolve(extractRoot(t));
       if (u !== firstUnderlying) {
@@ -19193,9 +19430,7 @@ var DuckdbQuoteStore = class extends QuoteStore {
   }
   async readQuotes(occTickers, from, to) {
     if (occTickers.length === 0) return /* @__PURE__ */ new Map();
-    const firstUnderlying = this.ctx.tickers.resolve(
-      extractRoot(occTickers[0])
-    );
+    const firstUnderlying = this.ctx.tickers.resolve(extractRoot(occTickers[0]));
     for (const t of occTickers) {
       const u = this.ctx.tickers.resolve(extractRoot(t));
       if (u !== firstUnderlying) {
@@ -19646,7 +19881,7 @@ async function startTradeBlocksMcp(options = {}) {
       console.error(`Error: Blocks directory does not exist: ${resolvedBlocksDir}`);
       process.exit(1);
     }
-    const { setBlocksDir } = await import("./sync-QFI5L7S7.js");
+    const { setBlocksDir } = await import("./sync-V25UQJA3.js");
     setBlocksDir(resolvedBlocksDir);
   }
   const tickerRegistry = await loadRegistry({ dataDir: resolvedDir });
@@ -19668,9 +19903,7 @@ async function startTradeBlocksMcp(options = {}) {
     parquetMode,
     getCurrentConnection
   };
-  console.error(
-    `[market-stores] Constructed: ${parquetMode ? "parquet" : "duckdb"} backend`
-  );
+  console.error(`[market-stores] Constructed: ${parquetMode ? "parquet" : "duckdb"} backend`);
   const createServer = () => {
     const server = new McpServer(
       { name: "tradeblocks-mcp", version: "2.0.0" },
@@ -19686,7 +19919,7 @@ async function startTradeBlocksMcp(options = {}) {
     return server;
   };
   if (http) {
-    const { loadAuthConfig } = await import("./config-6IZXEFEX.js");
+    const { loadAuthConfig } = await import("./config-DK7KOMNL.js");
     let auth;
     try {
       auth = loadAuthConfig({ noAuth });