tradeblocks-mcp 3.0.2 → 3.3.1

package/dist/test-exports.js

@@ -57,6 +57,7 @@ import {
   resolveCanonicalMarketPartitionDir,
   resolveCanonicalMarketPartitionFile,
   resolveCanonicalMarketPartitionPath,
+  resolveDbPath,
   resolveMarketDir,
   resolveTradeTicker,
   setDataRoot,
@@ -80,7 +81,7 @@ import {
   writeParquetPartition,
   writeQuoteMinutesPartition,
   writeSpotPartition
-} from "./chunk-4BLCXNQ6.js";
+} from "./chunk-4HZLVUOZ.js";
 import {
   BACHELIER_DTE_THRESHOLD,
   IvSolverPool,
@@ -156,42 +157,54 @@ import {
   stockHistoryOhlc,
   thetaTimestampToEtMinute,
   toMassiveTicker
-} from "./chunk-XXYOUIZY.js";
+} from "./chunk-NWNSKALN.js";
 import {
   PortfolioStatsCalculator,
   calculateCorrelationMatrix,
+  holdingPeriodBlockDays,
+  pairedBlockBootstrap,
   performTailRiskAnalysis
-} from "./chunk-QTTR7AAW.js";
-import "./chunk-PRAYH3RT.js";
-import "./chunk-W2PP3LEH.js";
-import "./chunk-BKQ4PM4Y.js";
-import "./chunk-LDKTV7GW.js";
-import "./chunk-FGZH632F.js";
+} from "./chunk-2I3S2ZLT.js";
+import "./chunk-WNTYA7ER.js";
+import "./chunk-ZTJXC3LS.js";
+import "./chunk-YZA4RS76.js";
+import "./chunk-27S67XW3.js";
+import "./chunk-2E63THNI.js";
 import "./chunk-5WRI5ZAA.js";
 
-// src/utils/trading-dates.ts
-function yesterdayET(now = /* @__PURE__ */ new Date()) {
-  const todayET = new Intl.DateTimeFormat("en-CA", {
-    timeZone: "America/New_York",
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit"
-  }).format(now);
-  const [y, m, d] = todayET.split("-").map(Number);
-  const prior = new Date(Date.UTC(y, m - 1, d));
-  prior.setUTCDate(prior.getUTCDate() - 1);
-  const py = prior.getUTCFullYear();
-  const pm = String(prior.getUTCMonth() + 1).padStart(2, "0");
-  const pd = String(prior.getUTCDate()).padStart(2, "0");
-  return `${py}-${pm}-${pd}`;
+// src/tools/blocks/paired-comparison.ts
+import { z } from "zod";
+
+// src/utils/output-formatter.ts
+function createToolOutput(summary, data) {
+  return {
+    content: [
+      { type: "text", text: summary },
+      {
+        type: "resource",
+        resource: {
+          uri: "data:application/json",
+          mimeType: "application/json",
+          text: JSON.stringify(data)
+        }
+      }
+    ]
+  };
+}
+function formatCurrency(value) {
+  const isNegative = value < 0;
+  const absValue = Math.abs(value);
+  const formatted = absValue.toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  });
+  return isNegative ? `-$${formatted}` : `$${formatted}`;
 }
 
 // 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) {
@@ -234,6 +247,294 @@ function filterDailyLogsByDateRange(dailyLogs, startDate, endDate) {
   return filtered;
 }
 
+// src/tools/middleware/sync-middleware.ts
+function withSyncedBlock(baseDir, handler) {
+  return async (input) => {
+    await upgradeToReadWrite(baseDir, { fallbackToReadOnly: true });
+    let syncResult;
+    if (getConnectionMode() === "read_write") {
+      try {
+        syncResult = await syncBlock(input.blockId, baseDir);
+      } finally {
+        await downgradeToReadOnly(baseDir);
+      }
+    } else {
+      syncResult = { blockId: input.blockId, status: "unchanged" };
+    }
+    if (syncResult.status === "deleted") {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Block '${input.blockId}' no longer exists (folder was deleted). Call list_blocks to see available blocks.`
+          }
+        ],
+        isError: true
+      };
+    }
+    if (syncResult.status === "error" && syncResult.error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Sync error for block '${input.blockId}': ${syncResult.error}. Call list_blocks to see available blocks.`
+          }
+        ],
+        isError: true
+      };
+    }
+    return handler(input, { syncResult, baseDir });
+  };
+}
+
+// src/tools/blocks/paired-comparison.ts
+var ATTRIBUTION_NOTE = "A trade's P&L is attributed evenly across the trading days it was open (dateOpened through dateClosed). Trading days are derived from the block's own trade data (the union of every trade's open and close dates) -- no market calendar is assumed, so weekends or holidays appear only if a trade spans them.";
+var DEFAULT_CI_LEVEL = 0.95;
+var DEFAULT_RESAMPLES = 2e3;
+var DEFAULT_SEED = 42;
+var SENSITIVITY_MULTIPLIERS = [0.5, 2];
+var pairedComparisonInputSchema = z.object({
+  blockId: z.string().describe("Block folder name to analyze"),
+  strategyA: z.string().describe("Strategy name for arm A (case-insensitive)"),
+  strategyB: z.string().optional().describe(
+    "Strategy name for arm B (case-insensitive). If omitted, arm A is compared against a constant 0 -- i.e. is the edge distinguishable from nothing."
+  ),
+  statistic: z.enum(["mean_daily_pnl", "median_daily_pnl"]).default("mean_daily_pnl").describe("Which daily-P&L functional to compare. Default mean_daily_pnl."),
+  dateRange: z.object({
+    start: z.string().describe("Start date (YYYY-MM-DD)"),
+    end: z.string().describe("End date (YYYY-MM-DD)")
+  }).optional().describe("Optional date range filter applied to both arms (by trade open date)."),
+  ciLevel: z.number().default(DEFAULT_CI_LEVEL).describe("Confidence level in (0, 1). Default 0.95 (deterministic)."),
+  resamples: z.number().int().default(DEFAULT_RESAMPLES).describe("Number of bootstrap resamples. Default 2000 (deterministic)."),
+  seed: z.number().int().default(DEFAULT_SEED).describe("PRNG seed. Same inputs + seed -> identical result. Default 42 (deterministic)."),
+  blockDays: z.number().int().min(1).optional().describe(
+    "Override the block length. By default it is derived from this block's own holding-period distribution (95th percentile of days-open)."
+  ),
+  effectiveNFloorBlocks: z.number().min(0).optional().describe(
+    "Optional: refuse with notComparable when the shared overlap yields fewer distinct blocks than this floor. When omitted, only structural degeneracy refuses (underpowered)."
+  )
+});
+function toCalendarDateStr2(date) {
+  const y = date.getUTCFullYear();
+  const m = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(date.getUTCDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function buildBlockTradingDayIndex(trades) {
+  const days = /* @__PURE__ */ new Set();
+  for (const t of trades) {
+    days.add(toCalendarDateStr2(t.dateOpened));
+    days.add(toCalendarDateStr2(t.dateClosed ?? t.dateOpened));
+  }
+  return Array.from(days).sort();
+}
+function gridSpan(grid, openStr, closeStr) {
+  let lo = grid.findIndex((d) => d >= openStr);
+  if (lo === -1) lo = grid.length;
+  let hi = -1;
+  for (let i = grid.length - 1; i >= 0; i--) {
+    if (grid[i] <= closeStr) {
+      hi = i;
+      break;
+    }
+  }
+  return [lo, hi];
+}
+function armHoldingPeriods(armTrades, grid) {
+  return armTrades.map((t) => {
+    const openStr = toCalendarDateStr2(t.dateOpened);
+    const closeStr = toCalendarDateStr2(t.dateClosed ?? t.dateOpened);
+    const [lo, hi] = gridSpan(grid, openStr, closeStr);
+    return Math.max(1, hi - lo + 1);
+  });
+}
+function buildArmDaySeries(armTrades, grid) {
+  const values = new Array(grid.length).fill(0);
+  const observedMask = new Array(grid.length).fill(false);
+  for (const t of armTrades) {
+    const openStr = toCalendarDateStr2(t.dateOpened);
+    const closeStr = toCalendarDateStr2(t.dateClosed ?? t.dateOpened);
+    const [lo, hi] = gridSpan(grid, openStr, closeStr);
+    if (hi < lo) continue;
+    const span = hi - lo + 1;
+    const perDay = t.pl / span;
+    for (let i = lo; i <= hi; i++) {
+      values[i] += perDay;
+      observedMask[i] = true;
+    }
+  }
+  return { index: grid, values, observedMask };
+}
+function countObserved(series) {
+  return series.observedMask.reduce((n, o) => n + (o ? 1 : 0), 0);
+}
+function meanOf(values) {
+  return values.reduce((s, v) => s + v, 0) / values.length;
+}
+function medianOf(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+var STATISTIC_FNS = {
+  mean_daily_pnl: meanOf,
+  median_daily_pnl: medianOf
+};
+var STATISTIC_LABELS = {
+  mean_daily_pnl: "mean daily P&L",
+  median_daily_pnl: "median daily P&L"
+};
+function runPairedBootstrapComparison(params) {
+  const {
+    armATrades,
+    armBTrades,
+    blockTrades,
+    statistic,
+    ciLevel,
+    resamples,
+    seed,
+    blockDays: blockDaysOverride,
+    effectiveNFloorBlocks,
+    strategyA,
+    strategyB
+  } = params;
+  if (armATrades.length === 0) {
+    throw new Error(`No trades found for strategy "${strategyA}".`);
+  }
+  if (armBTrades !== null && armBTrades.length === 0) {
+    throw new Error(`No trades found for strategy "${strategyB}".`);
+  }
+  const grid = buildBlockTradingDayIndex(blockTrades);
+  const armA = buildArmDaySeries(armATrades, grid);
+  const armB = armBTrades !== null ? buildArmDaySeries(armBTrades, grid) : null;
+  const hpA = holdingPeriodBlockDays(armHoldingPeriods(armATrades, grid));
+  const hpB = armBTrades !== null ? holdingPeriodBlockDays(armHoldingPeriods(armBTrades, grid)) : hpA;
+  const derivedBlockDays = Math.max(hpA, hpB);
+  const derivedFromArm = hpB > hpA ? "B" : "A";
+  const blockDays = blockDaysOverride ?? derivedBlockDays;
+  const blockDaysNote = blockDaysOverride !== void 0 ? `block length = ${blockDays} trading day(s), caller-supplied override` : armB !== null ? `block length = ${blockDays} trading day(s), derived from the 95th-percentile holding period of arm ${derivedFromArm} (the longer-held arm -- the conservative choice)` : `block length = ${blockDays} trading day(s), derived from the 95th-percentile holding period of arm A`;
+  const result = pairedBlockBootstrap({
+    armA,
+    armB: armB ?? { constant: 0 },
+    statistic: STATISTIC_FNS[statistic],
+    holdingRule: { blockDays, sensitivity: SENSITIVITY_MULTIPLIERS },
+    ciLevel,
+    resamples,
+    seed,
+    effectiveNFloorBlocks
+  });
+  const statLabel = STATISTIC_LABELS[statistic];
+  const comparisonLabel = armB !== null ? `${strategyA} minus ${strategyB}` : `${strategyA} vs 0`;
+  let summary;
+  let refusalMessage = null;
+  if (result.status === "notComparable") {
+    refusalMessage = `Not comparable: effective sample (${result.effectiveN.toFixed(2)} blocks) is below the required power floor. A confidence interval is withheld.`;
+    summary = `Paired comparison (${comparisonLabel}): ${refusalMessage}`;
+  } else if (result.status === "underpowered") {
+    refusalMessage = `Underpowered: the shared overlap is too short to resample at a block length of ${blockDays} trading day(s) (fewer than two drawable blocks). A confidence interval is withheld.`;
+    summary = `Paired comparison (${comparisonLabel}): ${refusalMessage}`;
+  } else {
+    const point = result.point ?? 0;
+    const low = result.ci.low ?? 0;
+    const high = result.ci.high ?? 0;
+    const includesZero = low <= 0 && high >= 0;
+    const zeroClause = includesZero ? "includes zero (not distinguishable)" : "excludes zero (distinguishable)";
+    const subject = armB !== null ? `the difference in ${statLabel} (${comparisonLabel})` : `${statLabel}`;
+    summary = `Paired comparison: ${subject} is ${formatCurrency(point)}, ${(ciLevel * 100).toFixed(0)}% CI [${formatCurrency(low)}, ${formatCurrency(high)}] -- ${zeroClause}.`;
+  }
+  const data = {
+    comparison: {
+      strategyA,
+      strategyB: strategyB ?? null,
+      mode: armB !== null ? "two-arm" : "single-arm-vs-zero",
+      description: comparisonLabel
+    },
+    statistic,
+    point: result.point,
+    ci: result.ci,
+    status: result.status,
+    refusal: refusalMessage,
+    effectiveN: result.effectiveN,
+    blockDays: result.blockDays,
+    blockDaysDerivation: blockDaysNote,
+    overlapWindow: result.overlapWindow,
+    observedDays: {
+      armA: countObserved(armA),
+      armB: armB !== null ? countObserved(armB) : null
+    },
+    tradeCounts: {
+      armA: armATrades.length,
+      armB: armBTrades !== null ? armBTrades.length : null
+    },
+    sensitivity: result.sensitivity,
+    resamples,
+    seed: result.seed,
+    ciLevel,
+    attributionMethodology: ATTRIBUTION_NOTE
+  };
+  return { summary, data, result };
+}
+function registerPairedComparisonTool(server, baseDir) {
+  server.registerTool(
+    "paired_bootstrap_comparison",
+    {
+      description: "Honest confidence intervals for 'is strategy A actually different from strategy B (or from zero)' -- day-block resampling that accounts for multi-day positions, dormant periods, and paired comparison on shared days. " + ATTRIBUTION_NOTE,
+      inputSchema: pairedComparisonInputSchema
+    },
+    withSyncedBlock(baseDir, async (input) => {
+      try {
+        const { blockId, strategyA, strategyB, statistic, dateRange } = input;
+        const block = await loadBlock(baseDir, blockId);
+        const inRange = (trades) => dateRange ? filterByDateRange(trades, dateRange.start, dateRange.end) : trades;
+        const blockTrades = inRange(block.trades);
+        const armATrades = inRange(filterByStrategy(block.trades, strategyA));
+        const armBTrades = strategyB !== void 0 ? inRange(filterByStrategy(block.trades, strategyB)) : null;
+        const { summary, data } = runPairedBootstrapComparison({
+          armATrades,
+          armBTrades,
+          blockTrades,
+          statistic,
+          ciLevel: input.ciLevel,
+          resamples: input.resamples,
+          seed: input.seed,
+          blockDays: input.blockDays,
+          effectiveNFloorBlocks: input.effectiveNFloorBlocks,
+          strategyA,
+          strategyB
+        });
+        return createToolOutput(summary, { blockId, ...data });
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error running paired bootstrap comparison: ${error.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    })
+  );
+}
+
+// src/utils/trading-dates.ts
+function yesterdayET(now = /* @__PURE__ */ new Date()) {
+  const todayET = new Intl.DateTimeFormat("en-CA", {
+    timeZone: "America/New_York",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(now);
+  const [y, m, d] = todayET.split("-").map(Number);
+  const prior = new Date(Date.UTC(y, m - 1, d));
+  prior.setUTCDate(prior.getUTCDate() - 1);
+  const py = prior.getUTCFullYear();
+  const pm = String(prior.getUTCMonth() + 1).padStart(2, "0");
+  const pd = String(prior.getUTCDate()).padStart(2, "0");
+  return `${py}-${pm}-${pd}`;
+}
+
 // src/utils/schema-metadata.ts
 var SCHEMA_DESCRIPTIONS = {
   trades: {
@@ -798,10 +1099,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" },
@@ -811,10 +1124,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]),
@@ -851,9 +1161,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];
@@ -978,7 +1286,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(", ");
@@ -1098,11 +1410,11 @@ function scoreDataQuality(input) {
 async function queryCoverage(stores, underlying, fromDate, toDate) {
   const spotCov = await stores.spot.getCoverage(underlying, fromDate, toDate);
   const quoteCov = await stores.quote.getCoverage(underlying, fromDate, toDate);
-  const dates = enumerateCoveredDates(spotCov.earliest, spotCov.latest).concat(enumerateCoveredDates(quoteCov.earliest, quoteCov.latest));
-  const uniqueDates = [...new Set(dates)].sort();
-  const quoteDateSet = new Set(
+  const dates = enumerateCoveredDates(spotCov.earliest, spotCov.latest).concat(
     enumerateCoveredDates(quoteCov.earliest, quoteCov.latest)
   );
+  const uniqueDates = [...new Set(dates)].sort();
+  const quoteDateSet = new Set(enumerateCoveredDates(quoteCov.earliest, quoteCov.latest));
   if (uniqueDates.length === 0) {
     return {
       totalBars: 0,
@@ -1168,9 +1480,7 @@ function formatCoverageReport(tickerPattern, coverage) {
   }
   if (current) groups.push(current);
   for (const group of groups) {
-    const avgBars = group.barCounts.length > 0 ? Math.round(
-      group.barCounts.reduce((s, v) => s + v, 0) / group.barCounts.length
-    ) : 0;
+    const avgBars = group.barCounts.length > 0 ? Math.round(group.barCounts.reduce((s, v) => s + v, 0) / group.barCounts.length) : 0;
     const rangeStr = group.fromDate === group.toDate ? group.fromDate : `${group.fromDate} to ${group.toDate}`;
     let detail;
     if (group.density === "dense") {
@@ -1445,7 +1755,9 @@ async function setupParquetWorkingTables(conn, dataDir) {
   const enrichedTickerGlob = path.join(enrichedDir, "ticker=*", "data.parquet");
   const enrichedContextPath = path.join(enrichedDir, "context", "data.parquet");
   if (existsSync(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(
@@ -1460,9 +1772,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`);
@@ -1485,7 +1795,9 @@ async function setupParquetWorkingTables(conn, dataDir) {
   } catch {
   }
   if (existsSync(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 (existsSync(enrichedContextPath)) {
     await conn.run(
       `CREATE TEMP TABLE "${dateContextTable}" AS SELECT * FROM read_parquet('${enrichedContextPath}')`
@@ -1496,7 +1808,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 };
 }
@@ -1523,12 +1837,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 = path.join(
-    resolveMarketDir(dataDir),
-    "enriched",
-    "context",
-    "data.parquet"
-  );
+  const contextFile = path.join(resolveMarketDir(dataDir), "enriched", "context", "data.parquet");
   await writeParquetAtomic(conn, {
     targetPath: contextFile,
     selectQuery: `SELECT * FROM "${tables.dateContextTable}" ORDER BY date`
@@ -1564,7 +1873,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}`,
@@ -1696,12 +2007,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}`;
@@ -1735,10 +2055,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 runContextEnrichment(conn, targets) {
@@ -1778,7 +2097,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) {
@@ -1995,7 +2317,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;
@@ -2020,7 +2343,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);
@@ -2086,7 +2416,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);
@@ -2205,7 +2542,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);
@@ -2553,134 +2892,126 @@ function buildFilterPredicate(filter) {
 }
 
 // src/tools/profiles.ts
-import { z } from "zod";
-
-// src/utils/output-formatter.ts
-function createToolOutput(summary, data) {
-  return {
-    content: [
-      { type: "text", text: summary },
-      {
-        type: "resource",
-        resource: {
-          uri: "data:application/json",
-          mimeType: "application/json",
-          text: JSON.stringify(data)
-        }
-      }
-    ]
-  };
-}
-
-// src/tools/profiles.ts
-var profileStrategySchema = z.object({
-  blockId: z.string().describe("Block ID (block_id) to associate the profile with"),
-  strategyName: z.string().describe("Human-readable strategy name (e.g., 'Pickle RIC v2')"),
-  structureType: z.string().describe(
+import { z as z2 } from "zod";
+var profileStrategySchema = z2.object({
+  blockId: z2.string().describe("Block ID (block_id) to associate the profile with"),
+  strategyName: z2.string().describe("Human-readable strategy name (e.g., 'Pickle RIC v2')"),
+  structureType: z2.string().describe(
     "Option structure type: iron_condor, calendar_spread, double_calendar, vertical_spread, butterfly, reverse_iron_condor, short_put_spread, short_call_spread, straddle, strangle, etc."
   ),
-  greeksBias: z.string().describe(
+  greeksBias: z2.string().describe(
     "Primary greeks exposure: theta_positive, vega_negative, delta_neutral, delta_positive, delta_negative, gamma_scalp, etc."
   ),
-  thesis: z.string().default("").describe("Free-text description of the strategy thesis"),
-  legs: z.array(
-    z.object({
-      type: z.string().describe("Leg type: long_put, short_call, long_call, short_put, etc."),
-      strike: z.string().describe("Strike selection: ATM, 5-delta, 30-delta, etc."),
-      expiry: z.string().describe("Expiry selection: same-day, weekly, 45-DTE, etc."),
-      quantity: z.number().describe("Quantity (positive=long, negative=short)"),
-      strikeMethod: z.enum(["delta", "dollar_price", "offset", "percentage"]).optional().describe("How strike is selected"),
-      strikeValue: z.number().optional().describe("Numeric strike value (e.g., 25 for 25-delta)")
+  thesis: z2.string().default("").describe("Free-text description of the strategy thesis"),
+  legs: z2.array(
+    z2.object({
+      type: z2.string().describe("Leg type: long_put, short_call, long_call, short_put, etc."),
+      strike: z2.string().describe("Strike selection: ATM, 5-delta, 30-delta, etc."),
+      expiry: z2.string().describe("Expiry selection: same-day, weekly, 45-DTE, etc."),
+      quantity: z2.number().describe("Quantity (positive=long, negative=short)"),
+      strikeMethod: z2.enum(["delta", "dollar_price", "offset", "percentage"]).optional().describe("How strike is selected"),
+      strikeValue: z2.number().optional().describe("Numeric strike value (e.g., 25 for 25-delta)")
     })
   ).default([]).describe("Structured leg descriptions"),
-  entryFilters: z.array(
-    z.object({
-      field: z.string().describe("Market data field: VIX_Close, RSI_14, Vol_Regime, etc."),
-      operator: z.string().describe("Comparison operator: >, <, >=, <=, ==, between, in"),
-      value: z.union([z.string(), z.number(), z.array(z.union([z.string(), z.number()]))]).describe("Filter value or array for between/in operators"),
-      description: z.string().optional().describe("Human-readable description of this filter"),
-      source: z.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.")
+  entryFilters: z2.array(
+    z2.object({
+      field: z2.string().describe("Market data field: VIX_Close, RSI_14, Vol_Regime, etc."),
+      operator: z2.string().describe("Comparison operator: >, <, >=, <=, ==, between, in"),
+      value: z2.union([z2.string(), z2.number(), z2.array(z2.union([z2.string(), z2.number()]))]).describe("Filter value or array for between/in operators"),
+      description: z2.string().optional().describe("Human-readable description of this filter"),
+      source: z2.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)."),
-  exitRules: z.array(
-    z.object({
-      type: z.string().describe("Rule type: stop_loss, profit_target, time_exit, conditional"),
-      trigger: z.string().describe("Trigger condition: '200% of credit', '50% of max profit', '15:00 ET'"),
-      description: z.string().optional().describe("Human-readable description"),
-      stopLossType: z.enum(["percentage", "dollar", "sl_ratio", "debit_percentage"]).optional().describe("Stop loss calculation method"),
-      stopLossValue: z.number().optional().describe("Stop loss numeric value"),
-      monitoring: z.object({
-        granularity: z.enum(["intra_minute", "candle_close", "end_of_bar"]).optional().describe("Price check frequency"),
-        priceSource: z.enum(["nbbo", "mid", "last"]).optional().describe("Which price to use")
+  ).default([]).describe(
+    "Entry condition filters. Tag each with source: 'market' (testable in analysis) or 'execution' (OO/platform-level, skipped in analysis)."
+  ),
+  exitRules: z2.array(
+    z2.object({
+      type: z2.string().describe("Rule type: stop_loss, profit_target, time_exit, conditional"),
+      trigger: z2.string().describe("Trigger condition: '200% of credit', '50% of max profit', '15:00 ET'"),
+      description: z2.string().optional().describe("Human-readable description"),
+      stopLossType: z2.enum(["percentage", "dollar", "sl_ratio", "debit_percentage"]).optional().describe("Stop loss calculation method"),
+      stopLossValue: z2.number().optional().describe("Stop loss numeric value"),
+      monitoring: z2.object({
+        granularity: z2.enum(["intra_minute", "candle_close", "end_of_bar"]).optional().describe("Price check frequency"),
+        priceSource: z2.enum(["nbbo", "mid", "last"]).optional().describe("Which price to use")
       }).optional().describe("Monitoring configuration for this rule"),
-      slippage: z.number().optional().describe("Per-rule slippage override")
+      slippage: z2.number().optional().describe("Per-rule slippage override")
     })
   ).default([]).describe("Exit rules and triggers"),
-  expectedRegimes: z.array(z.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: z.object({
-    expectedWinRate: z.number().optional().describe("Expected win rate (0-1)"),
-    targetPremium: z.number().optional().describe("Target premium collected ($)"),
-    maxLoss: z.number().optional().describe("Maximum loss per contract ($)"),
-    profitTarget: z.number().optional().describe("Profit target ($ or %)")
+  expectedRegimes: z2.array(z2.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: z2.object({
+    expectedWinRate: z2.number().optional().describe("Expected win rate (0-1)"),
+    targetPremium: z2.number().optional().describe("Target premium collected ($)"),
+    maxLoss: z2.number().optional().describe("Maximum loss per contract ($)"),
+    profitTarget: z2.number().optional().describe("Profit target ($ or %)")
   }).passthrough().default({}).describe("Performance benchmarks and strategy-specific metrics"),
-  positionSizing: z.object({
-    method: z.string().describe("Sizing method: pct_of_portfolio, fixed_contracts, fixed_dollar, discretionary"),
-    allocationPct: z.number().optional().describe("Portfolio allocation percentage (e.g., 2 for 2%)"),
-    maxContracts: z.number().optional().describe("Maximum contracts per trade"),
-    maxAllocationDollar: z.number().optional().describe("Maximum dollar allocation per trade"),
-    maxOpenPositions: z.number().optional().describe("Maximum concurrent open positions"),
-    description: z.string().optional().describe("Free-text sizing notes"),
-    backtestAllocationPct: z.number().optional().describe("Allocation % used in backtest"),
-    liveAllocationPct: z.number().optional().describe("Allocation % used in live portfolio"),
-    maxContractsPerTrade: z.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."),
-  underlying: z.string().optional().describe("Underlying symbol: SPX, QQQ, etc."),
-  reEntry: z.boolean().optional().describe("Strategy supports re-entry on same day"),
-  capProfits: z.boolean().optional().describe("Profits are capped by structure"),
-  capLosses: z.boolean().optional().describe("Losses are capped by structure"),
-  requireTwoPricesPT: z.boolean().optional().describe("Profit target requires two prices"),
-  closeOnCompletion: z.boolean().optional().describe("Close entire position when any leg hits target"),
-  ignoreMarginReq: z.boolean().optional().describe("Strategy ignores standard margin requirements")
+  positionSizing: z2.object({
+    method: z2.string().describe("Sizing method: pct_of_portfolio, fixed_contracts, fixed_dollar, discretionary"),
+    allocationPct: z2.number().optional().describe("Portfolio allocation percentage (e.g., 2 for 2%)"),
+    maxContracts: z2.number().optional().describe("Maximum contracts per trade"),
+    maxAllocationDollar: z2.number().optional().describe("Maximum dollar allocation per trade"),
+    maxOpenPositions: z2.number().optional().describe("Maximum concurrent open positions"),
+    description: z2.string().optional().describe("Free-text sizing notes"),
+    backtestAllocationPct: z2.number().optional().describe("Allocation % used in backtest"),
+    liveAllocationPct: z2.number().optional().describe("Allocation % used in live portfolio"),
+    maxContractsPerTrade: z2.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."
+  ),
+  underlying: z2.string().optional().describe("Underlying symbol: SPX, QQQ, etc."),
+  reEntry: z2.boolean().optional().describe("Strategy supports re-entry on same day"),
+  capProfits: z2.boolean().optional().describe("Profits are capped by structure"),
+  capLosses: z2.boolean().optional().describe("Losses are capped by structure"),
+  requireTwoPricesPT: z2.boolean().optional().describe("Profit target requires two prices"),
+  closeOnCompletion: z2.boolean().optional().describe("Close entire position when any leg hits target"),
+  ignoreMarginReq: z2.boolean().optional().describe("Strategy ignores standard margin requirements")
 });
-var getStrategyProfileSchema = z.object({
-  blockId: z.string().describe("Block ID to look up"),
-  strategyName: z.string().describe("Strategy name to look up")
+var getStrategyProfileSchema = z2.object({
+  blockId: z2.string().describe("Block ID to look up"),
+  strategyName: z2.string().describe("Strategy name to look up")
 });
-var listProfilesSchema = z.object({
-  blockId: z.string().optional().describe("Optional block ID filter. Omit to list all profiles across all blocks.")
+var listProfilesSchema = z2.object({
+  blockId: z2.string().optional().describe("Optional block ID filter. Omit to list all profiles across all blocks.")
 });
-var deleteProfileSchema = z.object({
-  blockId: z.string().describe("Block ID of the profile to delete"),
-  strategyName: z.string().describe("Strategy name of the profile to delete")
+var deleteProfileSchema = z2.object({
+  blockId: z2.string().describe("Block ID of the profile to delete"),
+  strategyName: z2.string().describe("Strategy name of the profile to delete")
 });
 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);
   }
@@ -2694,10 +3025,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);
@@ -2737,7 +3065,7 @@ async function handleDeleteProfile(input, baseDir) {
 }
 
 // src/tools/profile-analysis.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 function formatTradeDate(date) {
   if (typeof date === "string") {
     const match = date.match(/^(\d{4})-(\d{2})-(\d{2})/);
@@ -2893,10 +3221,10 @@ function findBucket(value, buckets) {
   }
   return null;
 }
-var analyzeStructureFitSchema = z2.object({
-  blockId: z2.string().describe("Block ID to analyze"),
-  strategyName: z2.string().describe("Strategy name matching a stored profile"),
-  minTrades: z2.number().optional().default(10).describe("Minimum trades per bucket for reliable stats (thin-data warning threshold)")
+var analyzeStructureFitSchema = z3.object({
+  blockId: z3.string().describe("Block ID to analyze"),
+  strategyName: z3.string().describe("Strategy name matching a stored profile"),
+  minTrades: z3.number().optional().default(10).describe("Minimum trades per bucket for reliable stats (thin-data warning threshold)")
 });
 async function handleAnalyzeStructureFit(input, baseDir) {
   const { blockId, strategyName } = input;
@@ -3069,11 +3397,11 @@ async function handleAnalyzeStructureFit(input, baseDir) {
     }
   });
 }
-var validateEntryFiltersSchema = z2.object({
-  blockId: z2.string().describe("Block ID to analyze"),
-  strategyName: z2.string().describe("Strategy name matching a stored profile"),
-  minTrades: z2.number().optional().default(10).describe("Minimum trades per group for reliable stats"),
-  maxAblationFilters: z2.number().optional().default(8).describe("Maximum number of filters for pairwise ablation (cap for combinatorial explosion)")
+var validateEntryFiltersSchema = z3.object({
+  blockId: z3.string().describe("Block ID to analyze"),
+  strategyName: z3.string().describe("Strategy name matching a stored profile"),
+  minTrades: z3.number().optional().default(10).describe("Minimum trades per group for reliable stats"),
+  maxAblationFilters: z3.number().optional().default(8).describe("Maximum number of filters for pairwise ablation (cap for combinatorial explosion)")
 });
 async function handleValidateEntryFilters(input, baseDir) {
   const { blockId, strategyName } = input;
@@ -3286,14 +3614,16 @@ 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
   });
 }
-var portfolioStructureMapSchema = z2.object({
-  blockId: z2.string().optional().describe("Block ID to analyze. When omitted, aggregate across all blocks."),
-  minTrades: z2.number().optional().default(10).describe("Thin-data warning threshold (default: 10)")
+var portfolioStructureMapSchema = z3.object({
+  blockId: z3.string().optional().describe("Block ID to analyze. When omitted, aggregate across all blocks."),
+  minTrades: z3.number().optional().default(10).describe("Thin-data warning threshold (default: 10)")
 });
 async function handlePortfolioStructureMap(input, baseDir) {
   try {
@@ -3317,7 +3647,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);
@@ -3328,7 +3660,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 = uniqueTradeLookupKeys(trades);
@@ -3446,10 +3780,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,
@@ -3484,7 +3815,7 @@ async function handlePortfolioStructureMap(input, baseDir) {
 }
 
 // src/tools/regime-advisor.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 function formatTradeDate2(date) {
   if (typeof date === "string") {
     const match = date.match(/^(\d{4})-(\d{2})-(\d{2})/);
@@ -3550,13 +3881,9 @@ var VOL_REGIME_LABELS2 = {
   5: "high",
   6: "extreme"
 };
-var regimeAllocationAdvisorSchema = z3.object({
-  blockId: z3.string().optional().describe(
-    "Block ID to analyze. When omitted, aggregate across all profiled strategies."
-  ),
-  minTrades: z3.number().optional().default(5).describe(
-    "Minimum trades per regime cell for reliable stats (default: 5)"
-  )
+var regimeAllocationAdvisorSchema = z4.object({
+  blockId: z4.string().optional().describe("Block ID to analyze. When omitted, aggregate across all profiled strategies."),
+  minTrades: z4.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;
@@ -3648,9 +3975,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);
@@ -3754,7 +4079,7 @@ function getResolvedProviderCapabilities(env = process.env) {
 }
 
 // src/tools/replay.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/market/tickers/resolver.ts
 var OCC_RE = /^([A-Z]+)\d{6}[CP]\d{6,11}$/;
@@ -3773,38 +4098,36 @@ function rootToUnderlying(input, registry) {
 }
 
 // src/tools/replay.ts
-var replayTradeSchema = z4.object({
+var replayTradeSchema = z5.object({
   // Mode A: Hypothetical / explicit legs
-  legs: z4.array(
-    z4.object({
-      ticker: z4.string().describe("Underlying ticker, e.g., 'SPY', 'SPX'"),
-      strike: z4.number().describe("Strike price"),
-      type: z4.enum(["C", "P"]).describe("Call or Put"),
-      expiry: z4.string().describe("Expiration date YYYY-MM-DD"),
-      quantity: z4.number().describe("Positive = long, negative = short"),
-      entry_price: z4.number().describe("Per-contract entry price (premium paid/received)")
+  legs: z5.array(
+    z5.object({
+      ticker: z5.string().describe("Underlying ticker, e.g., 'SPY', 'SPX'"),
+      strike: z5.number().describe("Strike price"),
+      type: z5.enum(["C", "P"]).describe("Call or Put"),
+      expiry: z5.string().describe("Expiration date YYYY-MM-DD"),
+      quantity: z5.number().describe("Positive = long, negative = short"),
+      entry_price: z5.number().describe("Per-contract entry price (premium paid/received)")
     })
   ).optional().describe("Explicit leg definitions for hypothetical replay"),
   // Mode B: Tradelog replay
-  block_id: z4.string().optional().describe("Block ID to load trade from"),
-  trade_index: z4.number().optional().describe(
-    "0-based index of trade in block's tradelog (ordered by date_opened)"
-  ),
+  block_id: z5.string().optional().describe("Block ID to load trade from"),
+  trade_index: z5.number().optional().describe("0-based index of trade in block's tradelog (ordered by date_opened)"),
   // Common fields
-  open_date: z4.string().optional().describe(
+  open_date: z5.string().optional().describe(
     "Trade open date YYYY-MM-DD (required for hypothetical mode, auto-resolved for tradelog mode)"
   ),
-  close_date: z4.string().optional().describe(
+  close_date: z5.string().optional().describe(
     "Trade close date YYYY-MM-DD (required for hypothetical, auto-resolved for tradelog)"
   ),
-  multiplier: z4.number().default(100).describe("Contract multiplier (default 100 for standard options)"),
-  format: z4.enum(["full", "summary", "sampled"]).default("sampled").describe(
+  multiplier: z5.number().default(100).describe("Contract multiplier (default 100 for standard options)"),
+  format: z5.enum(["full", "summary", "sampled"]).default("sampled").describe(
     "Output format: 'sampled' returns path sampled at ~15min intervals (default), 'full' returns complete minute-by-minute P&L path, 'summary' returns MFE/MAE/P&L without minute-level path"
   ),
-  close_at: z4.enum(["trade", "expiry"]).default("trade").describe(
+  close_at: z5.enum(["trade", "expiry"]).default("trade").describe(
     "When to end the P&L path: 'trade' (default) truncates at the trade's actual close time, 'expiry' shows full path through option expiry. Only applies to tradelog mode."
   ),
-  skip_quotes: z4.boolean().default(false).describe(
+  skip_quotes: z5.boolean().default(false).describe(
     "Skip NBBO quote enrichment for option bars. Faster, but uses cached trade bars / HL2 marks."
   )
 });
@@ -3836,22 +4159,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),
@@ -3870,9 +4184,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] ?? "");
@@ -3981,11 +4293,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 {
     }
   }
@@ -4104,17 +4412,15 @@ async function handleReplayTrade(params, baseDir, stores, injectedConn) {
 }
 
 // src/tools/snapshot.ts
-import { z as z5 } from "zod";
-var getOptionSnapshotSchema = z5.object({
-  underlying: z5.string().describe("Underlying ticker symbol (e.g., 'SPX', 'SPY', 'AAPL')"),
-  strike_price_gte: z5.number().optional().describe("Minimum strike price filter"),
-  strike_price_lte: z5.number().optional().describe("Maximum strike price filter"),
-  expiration_date_gte: z5.string().optional().describe("Earliest expiration date (YYYY-MM-DD)"),
-  expiration_date_lte: z5.string().optional().describe("Latest expiration date (YYYY-MM-DD)"),
-  contract_type: z5.enum(["call", "put"]).optional().describe("Filter by call or put"),
-  limit: z5.number().optional().default(50).describe(
-    "Max contracts to return (default 50, use higher for full chain)"
-  )
+import { z as z6 } from "zod";
+var getOptionSnapshotSchema = z6.object({
+  underlying: z6.string().describe("Underlying ticker symbol (e.g., 'SPX', 'SPY', 'AAPL')"),
+  strike_price_gte: z6.number().optional().describe("Minimum strike price filter"),
+  strike_price_lte: z6.number().optional().describe("Maximum strike price filter"),
+  expiration_date_gte: z6.string().optional().describe("Earliest expiration date (YYYY-MM-DD)"),
+  expiration_date_lte: z6.string().optional().describe("Latest expiration date (YYYY-MM-DD)"),
+  contract_type: z6.enum(["call", "put"]).optional().describe("Filter by call or put"),
+  limit: z6.number().optional().default(50).describe("Max contracts to return (default 50, use higher for full chain)")
 });
 async function handleGetOptionSnapshot(params) {
   try {
@@ -4231,7 +4537,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,
@@ -4266,7 +4574,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: [] },
@@ -4426,7 +4742,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;
@@ -4558,7 +4876,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++;
@@ -4914,8 +5232,8 @@ function analyzeExitTriggers(config) {
 }
 
 // src/tools/exit-analysis.ts
-import { z as z6 } from "zod";
-var triggerTypeEnum = z6.enum([
+import { z as z7 } from "zod";
+var triggerTypeEnum = z7.enum([
   "profitTarget",
   "stopLoss",
   "trailingStop",
@@ -4932,64 +5250,70 @@ var triggerTypeEnum = z6.enum([
   "slRatioThreshold",
   "slRatioMove"
 ]);
-var triggerConfigSchema = z6.object({
+var triggerConfigSchema = z7.object({
   type: triggerTypeEnum,
-  threshold: z6.number(),
-  unit: z6.enum(["percent", "dollar"]).default("dollar").optional(),
-  expiry: z6.string().optional(),
-  openDate: z6.string().optional(),
-  clockTime: z6.string().optional(),
-  trailAmount: z6.number().optional(),
-  steps: z6.array(z6.object({
-    armAt: z6.number(),
-    stopAt: z6.number(),
-    closeAllocationPct: z6.number().min(0).max(1).optional().describe("Fraction of REMAINING position to close at this milestone (0-1)")
-  })).optional(),
-  spreadWidth: z6.number().optional(),
-  contracts: z6.number().optional(),
-  legIndex: z6.number().optional().describe("0-based leg index for perLegDelta \u2014 targets specific leg"),
-  exitAbove: z6.number().optional().describe("Fire when value exceeds this (directional, no abs)"),
-  exitBelow: z6.number().optional().describe("Fire when value drops below this (directional, no abs)")
+  threshold: z7.number(),
+  unit: z7.enum(["percent", "dollar"]).default("dollar").optional(),
+  expiry: z7.string().optional(),
+  openDate: z7.string().optional(),
+  clockTime: z7.string().optional(),
+  trailAmount: z7.number().optional(),
+  steps: z7.array(
+    z7.object({
+      armAt: z7.number(),
+      stopAt: z7.number(),
+      closeAllocationPct: z7.number().min(0).max(1).optional().describe("Fraction of REMAINING position to close at this milestone (0-1)")
+    })
+  ).optional(),
+  spreadWidth: z7.number().optional(),
+  contracts: z7.number().optional(),
+  legIndex: z7.number().optional().describe("0-based leg index for perLegDelta \u2014 targets specific leg"),
+  exitAbove: z7.number().optional().describe("Fire when value exceeds this (directional, no abs)"),
+  exitBelow: z7.number().optional().describe("Fire when value drops below this (directional, no abs)")
 });
-var legSchema = z6.object({
-  ticker: z6.string(),
-  strike: z6.number(),
-  type: z6.enum(["C", "P"]),
-  expiry: z6.string(),
-  quantity: z6.number(),
-  entry_price: z6.number()
+var legSchema = z7.object({
+  ticker: z7.string(),
+  strike: z7.number(),
+  type: z7.enum(["C", "P"]),
+  expiry: z7.string(),
+  quantity: z7.number(),
+  entry_price: z7.number()
 });
-var analyzeExitTriggersSchema = z6.object({
+var analyzeExitTriggersSchema = z7.object({
   // Replay inputs (same shape as replay_trade)
-  legs: z6.array(legSchema).optional(),
-  block_id: z6.string().optional(),
-  trade_index: z6.number().optional(),
-  open_date: z6.string().optional(),
-  close_date: z6.string().optional(),
-  multiplier: z6.number().default(100),
-  triggers: z6.array(triggerConfigSchema).describe("Exit triggers to evaluate against the P&L path"),
-  actual_exit_timestamp: z6.string().optional().describe("Actual exit time for comparison (format: YYYY-MM-DD HH:MM)"),
-  leg_groups: z6.array(z6.object({
-    label: z6.string(),
-    leg_indices: z6.array(z6.number()),
-    triggers: z6.array(triggerConfigSchema)
-  })).optional().describe("Per-leg-group exit triggers for multi-structure strategies"),
-  format: z6.enum(["summary", "full"]).default("summary").describe("'summary' omits per-step trigger states, 'full' includes all fire events")
+  legs: z7.array(legSchema).optional(),
+  block_id: z7.string().optional(),
+  trade_index: z7.number().optional(),
+  open_date: z7.string().optional(),
+  close_date: z7.string().optional(),
+  multiplier: z7.number().default(100),
+  triggers: z7.array(triggerConfigSchema).describe("Exit triggers to evaluate against the P&L path"),
+  actual_exit_timestamp: z7.string().optional().describe("Actual exit time for comparison (format: YYYY-MM-DD HH:MM)"),
+  leg_groups: z7.array(
+    z7.object({
+      label: z7.string(),
+      leg_indices: z7.array(z7.number()),
+      triggers: z7.array(triggerConfigSchema)
+    })
+  ).optional().describe("Per-leg-group exit triggers for multi-structure strategies"),
+  format: z7.enum(["summary", "full"]).default("summary").describe("'summary' omits per-step trigger states, 'full' includes all fire events")
 });
-var decomposeGreeksSchema = z6.object({
+var decomposeGreeksSchema = z7.object({
   // Same replay inputs
-  legs: z6.array(legSchema).optional(),
-  block_id: z6.string().optional(),
-  trade_index: z6.number().optional(),
-  open_date: z6.string().optional(),
-  close_date: z6.string().optional(),
-  multiplier: z6.number().default(100),
-  leg_groups: z6.array(z6.object({
-    label: z6.string(),
-    leg_indices: z6.array(z6.number())
-  })).optional().describe("Leg grouping for per-group vega attribution (e.g., front_month vs back_month)"),
-  format: z6.enum(["summary", "full"]).default("summary").describe("'summary' shows ranked factors, 'full' includes per-step contributions"),
-  skip_quotes: z6.boolean().default(false).describe("Skip NBBO quote enrichment for option bars. Faster, but lower precision.")
+  legs: z7.array(legSchema).optional(),
+  block_id: z7.string().optional(),
+  trade_index: z7.number().optional(),
+  open_date: z7.string().optional(),
+  close_date: z7.string().optional(),
+  multiplier: z7.number().default(100),
+  leg_groups: z7.array(
+    z7.object({
+      label: z7.string(),
+      leg_indices: z7.array(z7.number())
+    })
+  ).optional().describe("Leg grouping for per-group vega attribution (e.g., front_month vs back_month)"),
+  format: z7.enum(["summary", "full"]).default("summary").describe("'summary' shows ranked factors, 'full' includes per-step contributions"),
+  skip_quotes: z7.boolean().default(false).describe("Skip NBBO quote enrichment for option bars. Faster, but lower precision.")
 });
 var REVERSE_ROOT_MAP = {
   SPXW: "SPX",
@@ -5012,7 +5336,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));
     }
@@ -5083,12 +5408,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,
@@ -5419,7 +5739,7 @@ function analyzeBatch(trades, config) {
 }
 
 // src/tools/batch-exit-analysis.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 async function mapWithLimit(items, limit, fn) {
   const results = new Array(items.length);
   let idx = 0;
@@ -5433,7 +5753,7 @@ async function mapWithLimit(items, limit, fn) {
   await Promise.all(workers);
   return results;
 }
-var triggerTypeEnum2 = z7.enum([
+var triggerTypeEnum2 = z8.enum([
   "profitTarget",
   "stopLoss",
   "trailingStop",
@@ -5450,44 +5770,52 @@ var triggerTypeEnum2 = z7.enum([
   "slRatioThreshold",
   "slRatioMove"
 ]);
-var triggerConfigSchema2 = z7.object({
+var triggerConfigSchema2 = z8.object({
   type: triggerTypeEnum2,
-  threshold: z7.number(),
-  unit: z7.enum(["percent", "dollar"]).default("dollar").optional(),
-  expiry: z7.string().optional(),
-  openDate: z7.string().optional(),
-  clockTime: z7.string().optional(),
-  trailAmount: z7.number().optional(),
-  steps: z7.array(z7.object({
-    armAt: z7.number(),
-    stopAt: z7.number(),
-    closeAllocationPct: z7.number().min(0).max(1).optional().describe("Fraction of REMAINING position to close at this milestone (0-1)")
-  })).optional(),
-  spreadWidth: z7.number().optional(),
-  contracts: z7.number().optional(),
-  legIndex: z7.number().optional().describe("0-based leg index for perLegDelta \u2014 targets specific leg"),
-  exitAbove: z7.number().optional().describe("Fire when value exceeds this (directional, no abs)"),
-  exitBelow: z7.number().optional().describe("Fire when value drops below this (directional, no abs)")
+  threshold: z8.number(),
+  unit: z8.enum(["percent", "dollar"]).default("dollar").optional(),
+  expiry: z8.string().optional(),
+  openDate: z8.string().optional(),
+  clockTime: z8.string().optional(),
+  trailAmount: z8.number().optional(),
+  steps: z8.array(
+    z8.object({
+      armAt: z8.number(),
+      stopAt: z8.number(),
+      closeAllocationPct: z8.number().min(0).max(1).optional().describe("Fraction of REMAINING position to close at this milestone (0-1)")
+    })
+  ).optional(),
+  spreadWidth: z8.number().optional(),
+  contracts: z8.number().optional(),
+  legIndex: z8.number().optional().describe("0-based leg index for perLegDelta \u2014 targets specific leg"),
+  exitAbove: z8.number().optional().describe("Fire when value exceeds this (directional, no abs)"),
+  exitBelow: z8.number().optional().describe("Fire when value drops below this (directional, no abs)")
 });
-var batchExitAnalysisSchema = z7.object({
-  block_id: z7.string().describe("Block ID to analyze trades from"),
-  strategy: z7.string().optional().describe("Filter trades by strategy name (case-insensitive ILIKE)"),
-  date_range: z7.object({
-    from: z7.string().optional().describe("Start date YYYY-MM-DD"),
-    to: z7.string().optional().describe("End date YYYY-MM-DD")
+var batchExitAnalysisSchema = z8.object({
+  block_id: z8.string().describe("Block ID to analyze trades from"),
+  strategy: z8.string().optional().describe("Filter trades by strategy name (case-insensitive ILIKE)"),
+  date_range: z8.object({
+    from: z8.string().optional().describe("Start date YYYY-MM-DD"),
+    to: z8.string().optional().describe("End date YYYY-MM-DD")
   }).optional().describe("Filter trades by date range"),
-  candidate_policy: z7.array(triggerConfigSchema2).describe("Candidate exit policy triggers to evaluate -- same schema as analyze_exit_triggers"),
-  leg_groups: z7.array(z7.object({
-    label: z7.string(),
-    leg_indices: z7.array(z7.number()),
-    triggers: z7.array(triggerConfigSchema2)
-  })).optional().describe("Per-leg-group exit triggers for multi-structure strategies"),
-  baseline_mode: z7.enum(["actual", "holdToEnd"]).default("actual").describe("'actual' compares candidate vs trade's actual P&L; 'holdToEnd' compares vs last replay timestamp"),
-  limit: z7.number().min(1).max(200).default(50).describe("Max trades to analyze. Most recent trades selected"),
-  min_pl: z7.number().optional().describe("Only include trades with actual P&L >= this value"),
-  max_pl: z7.number().optional().describe("Only include trades with actual P&L <= this value"),
-  multiplier: z7.number().default(100).describe("Contract multiplier (default 100)"),
-  format: z7.enum(["summary", "full"]).default("summary").describe("'summary' returns aggregate stats + trigger attribution; 'full' adds per-trade breakdown")
+  candidate_policy: z8.array(triggerConfigSchema2).describe("Candidate exit policy triggers to evaluate -- same schema as analyze_exit_triggers"),
+  leg_groups: z8.array(
+    z8.object({
+      label: z8.string(),
+      leg_indices: z8.array(z8.number()),
+      triggers: z8.array(triggerConfigSchema2)
+    })
+  ).optional().describe("Per-leg-group exit triggers for multi-structure strategies"),
+  baseline_mode: z8.enum(["actual", "holdToEnd"]).default("actual").describe(
+    "'actual' compares candidate vs trade's actual P&L; 'holdToEnd' compares vs last replay timestamp"
+  ),
+  limit: z8.number().min(1).max(200).default(50).describe("Max trades to analyze. Most recent trades selected"),
+  min_pl: z8.number().optional().describe("Only include trades with actual P&L >= this value"),
+  max_pl: z8.number().optional().describe("Only include trades with actual P&L <= this value"),
+  multiplier: z8.number().default(100).describe("Contract multiplier (default 100)"),
+  format: z8.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 {
@@ -5650,9 +5978,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 {
@@ -5699,7 +6025,7 @@ function expandDateRange(fromDate, toDate) {
 
 // src/tools/sql.ts
 import * as path2 from "path";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var BLOCKED_PATTERNS = [
   // External access
   { pattern: /\bCOPY\b/i, operation: "COPY" },
@@ -5813,13 +6139,7 @@ function filterChain(contracts, filter) {
 import { open, mkdir } from "fs/promises";
 import { dirname, join as join2 } from "path";
 function backfillManifestPath(dataRoot, runId) {
-  return join2(
-    dataRoot,
-    "market",
-    "_manifests",
-    "thetadata-mdds-backfill",
-    `${runId}.ndjson`
-  );
+  return join2(dataRoot, "market", "_manifests", "thetadata-mdds-backfill", `${runId}.ndjson`);
 }
 function backfillPartitionPath(dataRoot, underlying, date) {
   return join2(
@@ -5969,15 +6289,15 @@ function collectBackfillConcreteFallbacks(input) {
   return fallbacks;
 }
 async function appendBackfillManifestLineDurable(manifestPath, line) {
-  const path12 = requireNonEmpty("manifestPath", manifestPath);
+  const path11 = requireNonEmpty("manifestPath", manifestPath);
   const text = String(line);
   if (!text.endsWith("\n")) {
     throw new Error("manifest line must end with a newline");
   }
-  const parentDir = dirname(path12);
+  const parentDir = dirname(path11);
   await mkdir(parentDir, { recursive: true });
-  const existedBeforeOpen = await pathExists(path12);
-  const handle = await open(path12, "a");
+  const existedBeforeOpen = await pathExists(path11);
+  const handle = await open(path11, "a");
   try {
     await handle.writeFile(text);
     await handle.sync();
@@ -6043,9 +6363,9 @@ function validateManifestStatus(value) {
   }
   throw new Error("status must be prepared, committed, failed, or committed_manifest_failed");
 }
-async function pathExists(path12) {
+async function pathExists(path11) {
   try {
-    const handle = await open(path12, "r");
+    const handle = await open(path11, "r");
     await handle.close();
     return true;
   } catch {
@@ -6108,7 +6428,7 @@ function formatIsoDate(date) {
 }
 
 // src/tools/greeks-attribution.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/utils/flatfile-importer.ts
 function tradingDays(from, to) {
@@ -6126,19 +6446,32 @@ function tradingDays(from, to) {
 }
 
 // src/tools/greeks-attribution.ts
-var getGreeksAttributionSchema = z9.object({
-  block_id: z9.string().describe("Block ID to analyze"),
-  mode: z9.enum(["summary", "instance"]).default("summary").describe("summary: block-level attribution. instance: single trade time-series."),
-  trade_index: z9.number().int().min(0).optional().describe("Trade index (required for instance mode). Use get_block_info to find trade indices."),
-  skip_quotes: z9.boolean().default(true).describe("Use cached bar data only (fast). Set false to fetch NBBO quotes for higher precision."),
-  detailed: z9.boolean().default(false).describe("false: 5 factors (delta, gamma, theta, vega, residual). true: adds charm, vanna."),
-  strategy: z9.string().optional().describe("Filter to trades matching this strategy name (case-insensitive).")
+var getGreeksAttributionSchema = z10.object({
+  block_id: z10.string().describe("Block ID to analyze"),
+  mode: z10.enum(["summary", "instance"]).default("summary").describe("summary: block-level attribution. instance: single trade time-series."),
+  trade_index: z10.number().int().min(0).optional().describe(
+    "Trade index (required for instance mode). Use get_block_info to find trade indices."
+  ),
+  skip_quotes: z10.boolean().default(true).describe(
+    "Use cached bar data only (fast). Set false to fetch NBBO quotes for higher precision."
+  ),
+  detailed: z10.boolean().default(false).describe("false: 5 factors (delta, gamma, theta, vega, residual). true: adds charm, vanna."),
+  strategy: z10.string().optional().describe("Filter to trades matching this strategy name (case-insensitive).")
 });
 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) {
@@ -6188,9 +6521,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);
@@ -6242,7 +6591,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;
@@ -6345,10 +6697,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")) {
@@ -6815,11 +7177,7 @@ var ParquetSpotStore = class extends SpotStore {
     }));
   }
   async getCoverage(ticker, from, to) {
-    const tickerDir = path5.join(
-      resolveMarketDir(this.ctx.dataDir),
-      "spot",
-      `ticker=${ticker}`
-    );
+    const tickerDir = path5.join(resolveMarketDir(this.ctx.dataDir), "spot", `ticker=${ticker}`);
     if (!existsSync4(tickerDir)) {
       return { earliest: null, latest: null, missingDates: [], totalDates: 0 };
     }
@@ -7044,9 +7402,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 = path6.join(
@@ -7119,9 +7475,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, "''");
@@ -7474,9 +7828,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) {
@@ -7791,9 +8143,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) {
@@ -8071,31 +8421,27 @@ function createMarketStores(ctx) {
 }
 
 // src/market/tickers/schemas.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var TICKER_RE = /^[A-Z][A-Z0-9^_-]*$/;
-var UnderlyingsFileSchema = z10.object({
-  version: z10.literal(1),
-  underlyings: z10.array(
-    z10.object({
-      underlying: z10.string().min(1).max(16).regex(TICKER_RE),
-      roots: z10.array(z10.string().min(1).max(16).regex(TICKER_RE)).min(1).max(32)
+var UnderlyingsFileSchema = z11.object({
+  version: z11.literal(1),
+  underlyings: z11.array(
+    z11.object({
+      underlying: z11.string().min(1).max(16).regex(TICKER_RE),
+      roots: z11.array(z11.string().min(1).max(16).regex(TICKER_RE)).min(1).max(32)
     })
   )
 });
-var registerUnderlyingSchema = z10.object({
-  underlying: z10.string().min(1).max(16).regex(TICKER_RE).describe("Canonical underlying symbol, e.g. SPX"),
-  roots: z10.array(z10.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 registerUnderlyingSchema = z11.object({
+  underlying: z11.string().min(1).max(16).regex(TICKER_RE).describe("Canonical underlying symbol, e.g. SPX"),
+  roots: z11.array(z11.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 = z10.object({
-  underlying: z10.string().min(1).max(16).regex(TICKER_RE).describe("Underlying to remove. Bundled defaults cannot be removed.")
+var unregisterUnderlyingSchema = z11.object({
+  underlying: z11.string().min(1).max(16).regex(TICKER_RE).describe("Underlying to remove. Bundled defaults cannot be removed.")
 });
-var listUnderlyingsSchema = z10.object({});
-var resolveRootSchema = z10.object({
-  input: z10.string().min(1).max(32).describe(
-    "Bare root ('SPXW') or full OCC ticker ('SPXW251219C05000000')"
-  )
+var listUnderlyingsSchema = z11.object({});
+var resolveRootSchema = z11.object({
+  input: z11.string().min(1).max(32).describe("Bare root ('SPXW') or full OCC ticker ('SPXW251219C05000000')")
 });
 
 // src/market/tickers/registry.ts
@@ -8107,9 +8453,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}`);
     }
   }
 }
@@ -8192,9 +8536,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(
@@ -8482,7 +8824,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;
       }
@@ -8735,11 +9083,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;
@@ -8775,12 +9119,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;
@@ -8840,7 +9179,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);
@@ -8891,15 +9234,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,
@@ -8986,16 +9326,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,
@@ -9062,7 +9399,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) {
@@ -9074,7 +9416,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;
         }
@@ -9222,43 +9570,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) {
@@ -9348,7 +9728,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
@@ -9372,7 +9756,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 } : {}
@@ -9455,9 +9845,7 @@ function selectVerificationSampleDates(fromDate = "2022-01-01", toDate = (/* @__
     ...PHASE_5_KNOWN_EVENTS.map((s) => s.date),
     ...PHASE_5_STRUCTURAL_DATES.map((s) => s.date)
   ]);
-  const candidates = enumerateWeekdays(fromDate, toDate).filter(
-    (d) => !selectedSet.has(d)
-  );
+  const candidates = enumerateWeekdays(fromDate, toDate).filter((d) => !selectedSet.has(d));
   const random = [];
   const pool = [...candidates];
   for (let i = 0; i < randomCount && pool.length > 0; i++) {
@@ -9582,11 +9970,10 @@ function compareRow(oldRow, newRow, kind, ticker, date) {
 }
 
 // src/utils/calibration-probe.ts
-import * as path11 from "path";
 import { DuckDBInstance } from "@duckdb/node-api";
 async function calibrateProviderFetch(ticker, probeDates, dataRoot) {
   const provider = getProvider();
-  const dbPath = path11.join(dataRoot, "database", "market.duckdb");
+  const dbPath = resolveDbPath(dataRoot, "market");
   const instance = await DuckDBInstance.create(dbPath);
   const conn = await instance.connect();
   const deltas = [];
@@ -9701,6 +10088,7 @@ export {
   appendBackfillManifestLineDurable,
   applyQuoteGreeks,
   applyQuoteGreeksParallel,
+  armHoldingPeriods,
   assessPrecision,
   bachelierDelta,
   bachelierGamma,
@@ -9717,6 +10105,8 @@ export {
   bsPrice,
   bsTheta,
   bsVega,
+  buildArmDaySeries,
+  buildBlockTradingDayIndex,
   buildEnrichmentPlan,
   buildFilterPredicate,
   buildLookaheadFreeQuery,
@@ -9884,6 +10274,7 @@ export {
   optionHistoryQuote,
   optionHistoryQuoteBand,
   optionListContracts,
+  pairedComparisonInputSchema,
   parseBackfillOccTicker,
   parseCsvToBars,
   parseDatabaseRowsToBars,
@@ -9898,6 +10289,7 @@ export {
   readJsonFile,
   readParquetFilesSql,
   regimeAllocationAdvisorSchema,
+  registerPairedComparisonTool,
   registerTickerTools,
   registerUnderlyingSchema,
   replayTradeSchema,
@@ -9915,6 +10307,7 @@ export {
   rthDailyAggregateSubquery,
   runContextEnrichment,
   runEnrichment,
+  runPairedBootstrapComparison,
   saveUserOverride,
   scoreDataQuality,
   selectVerificationSampleDates,