tradeblocks-mcp 3.0.3 → 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-UBUC5A66.js";
+} from "./chunk-4HZLVUOZ.js";
 import {
   BACHELIER_DTE_THRESHOLD,
   IvSolverPool,
@@ -156,34 +157,48 @@ import {
   stockHistoryOhlc,
   thetaTimestampToEtMinute,
   toMassiveTicker
-} from "./chunk-VDU25Z6X.js";
+} from "./chunk-NWNSKALN.js";
 import {
   PortfolioStatsCalculator,
   calculateCorrelationMatrix,
+  holdingPeriodBlockDays,
+  pairedBlockBootstrap,
   performTailRiskAnalysis
-} from "./chunk-C6LL746C.js";
-import "./chunk-AP7IHUUR.js";
-import "./chunk-SEUZYQGQ.js";
-import "./chunk-6S37CXUA.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
@@ -232,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: {
@@ -2589,113 +2892,94 @@ 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(
+  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")
+  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(
+  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: 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 %)")
+  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)")
+  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: 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")
+  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);
@@ -2781,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})/);
@@ -2937,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;
@@ -3113,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;
@@ -3337,9 +3621,9 @@ async function handleValidateEntryFilters(input, baseDir) {
     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 {
@@ -3531,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})/);
@@ -3597,9 +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;
@@ -3795,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}$/;
@@ -3814,36 +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."
   )
 });
@@ -4128,15 +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 {
@@ -4948,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",
@@ -4966,70 +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)")
+  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: 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)")
+  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)
+  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: z6.enum(["summary", "full"]).default("summary").describe("'summary' omits per-step trigger states, 'full' includes all fire events")
+  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())
+  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: 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.")
+  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",
@@ -5455,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;
@@ -5469,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",
@@ -5486,50 +5770,50 @@ 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)")
+  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: 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)")
+  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)
+  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: z7.enum(["actual", "holdToEnd"]).default("actual").describe(
+  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: 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(
+  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"
   )
 });
@@ -5741,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" },
@@ -6005,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();
@@ -6079,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 {
@@ -6144,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) {
@@ -6162,17 +6446,17 @@ 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(
+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: z9.boolean().default(true).describe(
+  skip_quotes: z10.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).")
+  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",
@@ -8137,27 +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
@@ -9686,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 = [];
@@ -9805,6 +10088,7 @@ export {
   appendBackfillManifestLineDurable,
   applyQuoteGreeks,
   applyQuoteGreeksParallel,
+  armHoldingPeriods,
   assessPrecision,
   bachelierDelta,
   bachelierGamma,
@@ -9821,6 +10105,8 @@ export {
   bsPrice,
   bsTheta,
   bsVega,
+  buildArmDaySeries,
+  buildBlockTradingDayIndex,
   buildEnrichmentPlan,
   buildFilterPredicate,
   buildLookaheadFreeQuery,
@@ -9988,6 +10274,7 @@ export {
   optionHistoryQuote,
   optionHistoryQuoteBand,
   optionListContracts,
+  pairedComparisonInputSchema,
   parseBackfillOccTicker,
   parseCsvToBars,
   parseDatabaseRowsToBars,
@@ -10002,6 +10289,7 @@ export {
   readJsonFile,
   readParquetFilesSql,
   regimeAllocationAdvisorSchema,
+  registerPairedComparisonTool,
   registerTickerTools,
   registerUnderlyingSchema,
   replayTradeSchema,
@@ -10019,6 +10307,7 @@ export {
   rthDailyAggregateSubquery,
   runContextEnrichment,
   runEnrichment,
+  runPairedBootstrapComparison,
   saveUserOverride,
   scoreDataQuality,
   selectVerificationSampleDates,