tradeblocks-mcp 2.2.6 → 2.3.0

package/dist/test-exports.js

@@ -9,6 +9,7 @@ import {
   downgradeToReadOnly,
   ensureProfilesSchema,
   getConnection,
+  getIntradayWriteTable,
   getMarketImportMetadata,
   getProfile,
   importCsv,
@@ -27,7 +28,7 @@ import {
   upgradeToReadWrite,
   upsertMarketImportMetadata,
   upsertProfile
-} from "./chunk-FIKAXL2L.js";
+} from "./chunk-37JFR6NF.js";
 import "./chunk-MIVAK2ZU.js";
 import "./chunk-PWM4JHGO.js";
 import "./chunk-KRHCV4RF.js";
@@ -1827,6 +1828,18 @@ var MassiveSnapshotResponseSchema = z.object({
   results: z.array(MassiveSnapshotContractSchema),
   next_url: z.string().optional()
 });
+var MassiveContractReferenceSchema = z.object({
+  ticker: z.string(),
+  strike_price: z.number(),
+  expiration_date: z.string(),
+  contract_type: z.string(),
+  exercise_style: z.string().optional().default("american")
+});
+var MassiveContractListResponseSchema = z.object({
+  results: z.array(MassiveContractReferenceSchema),
+  next_url: z.string().nullable().optional(),
+  count: z.number().optional()
+});
 var MASSIVE_BASE_URL = "https://api.massive.com";
 var MASSIVE_MAX_LIMIT = 5e4;
 var MASSIVE_MAX_PAGES = 500;
@@ -1857,6 +1870,26 @@ function nanosToETMinuteKey(nanosTimestamp) {
   const time = massiveTimestampToETTime(ms);
   return `${date} ${time}`;
 }
+function etOffsetMinutesForDate(dateStr) {
+  const probe = /* @__PURE__ */ new Date(`${dateStr}T12:00:00Z`);
+  const offsetToken = probe.toLocaleString("en-US", {
+    timeZone: "America/New_York",
+    timeZoneName: "shortOffset"
+  }).match(/GMT([+-]\d{1,2})(?::(\d{2}))?/);
+  if (!offsetToken) {
+    throw new Error(`Unable to resolve ET offset for ${dateStr}`);
+  }
+  const hours = Number(offsetToken[1]);
+  const minutes = offsetToken[2] ? Number(offsetToken[2]) : 0;
+  return hours * 60 + Math.sign(hours || 1) * minutes;
+}
+function etDateTimeToUtcIso(dateStr, timeStr) {
+  const [year, month, day] = dateStr.split("-").map(Number);
+  const [hour, minute] = timeStr.split(":").map(Number);
+  const offsetMinutes = etOffsetMinutesForDate(dateStr);
+  const utcMs = Date.UTC(year, month - 1, day, hour, minute) - offsetMinutes * 6e4;
+  return new Date(utcMs).toISOString().replace(".000Z", "Z");
+}
 function getApiKey() {
   const key = process.env.MASSIVE_API_KEY;
   if (!key) {
@@ -1986,6 +2019,27 @@ function mapContract(contract) {
 }
 var MassiveProvider = class {
   name = "massive";
+  capabilities() {
+    const tier = (process.env.MASSIVE_DATA_TIER ?? "").toLowerCase();
+    return {
+      tradeBars: true,
+      quotes: tier === "quotes",
+      greeks: false,
+      // Massive does not provide greeks — we compute via BSM
+      flatFiles: true,
+      // S3 flat files available via rclone
+      bulkByRoot: false,
+      // Massive is per-ticker, not bulk-by-root
+      perTicker: true,
+      minuteBars: true,
+      dailyBars: true,
+      dataAvailability: {
+        option: { from: "2014-01-02" },
+        index: { from: "2023-02-14" },
+        stock: { from: "2014-01-02" }
+      }
+    };
+  }
   async fetchBars(options) {
     const apiKey = getApiKey();
     const {
@@ -2057,22 +2111,6 @@ var MassiveProvider = class {
         url = null;
       }
     }
-    const quotesEnabled2 = process.env.MASSIVE_QUOTES_ENABLED === "true" || process.env.MASSIVE_QUOTES_ENABLED === "1";
-    if (quotesEnabled2 && assetClass === "option" && timespan !== "day" && allRows.length > 0) {
-      const quotesMap = await this.fetchQuotesForBars(apiTicker, headers, from, to);
-      if (quotesMap.size > 0) {
-        for (const row of allRows) {
-          if (row.time != null) {
-            const key = `${row.date} ${row.time}`;
-            const quote = quotesMap.get(key);
-            if (quote != null) {
-              row.bid = quote.bid;
-              row.ask = quote.ask;
-            }
-          }
-        }
-      }
-    }
     return allRows;
   }
   /**
@@ -2080,54 +2118,54 @@ var MassiveProvider = class {
    * Returns a Map keyed by "YYYY-MM-DD HH:MM" ET minute key.
    * Any error (network, HTTP error, parse failure) silently returns an empty Map.
    */
+  /**
+   * Fetch the last NBBO quote for each trading minute in the date range.
+   *
+   * Uses per-minute requests (`order=desc&limit=1`) in parallel batches.
+   * This is much faster than paginating through tick-level quotes: ~400
+   * small requests vs millions of raw NBBO ticks. With concurrency=20,
+   * a full day completes in ~6-7 seconds and results are cached so
+   * subsequent fetches are instant.
+   */
   async fetchQuotesForBars(apiTicker, headers, from, to) {
     const result = /* @__PURE__ */ new Map();
-    try {
-      let url = `${MASSIVE_BASE_URL}/v3/quotes/${encodeURIComponent(apiTicker)}?timestamp.gte=${from}&timestamp.lte=${to}&order=asc&limit=${MASSIVE_MAX_LIMIT}`;
-      const seenCursors = /* @__PURE__ */ new Set();
-      const QUOTES_MAX_PAGES = 100;
-      let pageCount = 0;
-      while (url) {
-        pageCount++;
-        if (pageCount > QUOTES_MAX_PAGES) {
-          break;
-        }
-        let response;
+    const startDate = /* @__PURE__ */ new Date(from + "T00:00:00");
+    const endDate = /* @__PURE__ */ new Date(to + "T00:00:00");
+    const encodedTicker = encodeURIComponent(apiTicker);
+    for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
+      const day = d.getDay();
+      if (day === 0 || day === 6) continue;
+      const dateStr = d.toISOString().slice(0, 10);
+      const fromTs = etDateTimeToUtcIso(dateStr, "09:30");
+      const toTs = etDateTimeToUtcIso(dateStr, "16:00");
+      let url = `${MASSIVE_BASE_URL}/v3/quotes/${encodedTicker}?timestamp.gte=${fromTs}&timestamp.lte=${toTs}&limit=50000&order=asc`;
+      const dayQuotes = [];
+      let pages = 0;
+      while (url && pages < 50) {
+        pages++;
         try {
-          response = await fetch(url, {
-            headers,
-            signal: AbortSignal.timeout(3e4)
-          });
+          const response = await fetch(url, { headers, signal: AbortSignal.timeout(3e4) });
+          if (!response.ok) break;
+          const json = await response.json();
+          const parsed = MassiveQuotesResponseSchema.safeParse(json);
+          if (!parsed.success) break;
+          dayQuotes.push(...parsed.data.results);
+          url = parsed.data.next_url ?? null;
         } catch {
-          return result;
-        }
-        if (!response.ok) {
-          return result;
-        }
-        const json = await response.json();
-        const parsed = MassiveQuotesResponseSchema.safeParse(json);
-        if (!parsed.success) {
-          return result;
-        }
-        const data = parsed.data;
-        for (const quote of data.results) {
-          const key = nanosToETMinuteKey(quote.sip_timestamp);
-          result.set(key, { bid: quote.bid_price, ask: quote.ask_price });
-        }
-        if (data.next_url) {
-          const nextUrlObj = new URL(data.next_url);
-          const cursor = nextUrlObj.searchParams.get("cursor") ?? data.next_url;
-          if (seenCursors.has(cursor)) {
-            break;
-          }
-          seenCursors.add(cursor);
-          url = data.next_url;
-        } else {
-          url = null;
+          break;
         }
       }
-    } catch {
-      return /* @__PURE__ */ new Map();
+      const byMinute = /* @__PURE__ */ new Map();
+      for (const q of dayQuotes) {
+        const key = nanosToETMinuteKey(q.sip_timestamp);
+        const [keyDate, keyTime] = key.split(" ");
+        if (keyDate !== dateStr || !keyTime) continue;
+        if (keyTime < "09:30" || keyTime > "16:00") continue;
+        byMinute.set(key, { bid: q.bid_price, ask: q.ask_price });
+      }
+      for (const [key, val] of byMinute) {
+        result.set(key, val);
+      }
     }
     return result;
   }
@@ -2137,6 +2175,129 @@ var MassiveProvider = class {
     const headers = { Authorization: `Bearer ${apiKey}` };
     return this.fetchQuotesForBars(apiTicker, headers, from, to);
   }
+  async downloadFlatFile(date, assetClass) {
+    const [year, month] = date.split("-");
+    const assetPathMap = {
+      option: "us_options_opra/minute_aggs_v1",
+      index: "us_indices/minute_aggs_v1",
+      stock: "us_stocks_sip/minute_aggs_v1"
+    };
+    const assetPath = assetPathMap[assetClass] ?? assetPathMap.stock;
+    const s3Path = `s3massive:flatfiles/${assetPath}/${year}/${month}/${date}.csv.gz`;
+    const tmpDir = assetClass === "index" ? "/tmp/massive-flat-index" : "/tmp/massive-flat";
+    const localPath = `${tmpDir}/${date}.csv.gz`;
+    const { existsSync: existsSync2, mkdirSync: mkdirSync2 } = await import("fs");
+    const { execFile: execFile2 } = await import("child_process");
+    const { promisify: promisify2 } = await import("util");
+    const execFileAsync2 = promisify2(execFile2);
+    mkdirSync2(tmpDir, { recursive: true });
+    if (existsSync2(localPath)) return localPath;
+    try {
+      await execFileAsync2("rclone", ["copy", s3Path, `${tmpDir}/`], { timeout: 12e4 });
+    } catch {
+      return null;
+    }
+    return existsSync2(localPath) ? localPath : null;
+  }
+  async downloadBulkData(options) {
+    const { date, dataset, assetClass, tickers, outputPath } = options;
+    const { existsSync: exists, mkdirSync: mkdir } = await import("fs");
+    if (exists(outputPath)) {
+      return { rowCount: 0, skipped: true };
+    }
+    const availability = this.capabilities().dataAvailability?.[assetClass];
+    if (availability && date < availability.from) {
+      return { rowCount: 0, skipped: true };
+    }
+    const { execFile: execFile2 } = await import("child_process");
+    const { promisify: promisify2 } = await import("util");
+    const { dirname } = await import("path");
+    const execFileAsync2 = promisify2(execFile2);
+    const s3PathMap = {
+      option: {
+        minute_bars: "us_options_opra/minute_aggs_v1",
+        daily_bars: "us_options_opra/day_aggs_v1",
+        trades: "us_options_opra/trades_v1"
+      },
+      index: {
+        minute_bars: "us_indices/minute_aggs_v1",
+        daily_bars: "us_indices/day_aggs_v1"
+      }
+    };
+    const s3Subpath = s3PathMap[assetClass]?.[dataset];
+    if (!s3Subpath) {
+      throw new Error(`Unsupported asset class/dataset combination: ${assetClass}/${dataset}`);
+    }
+    const [year, month] = date.split("-");
+    const s3Path = `s3massive:flatfiles/${s3Subpath}/${year}/${month}/${date}.csv.gz`;
+    const tmpDir = `/tmp/massive-bulk-${assetClass}-${dataset}`;
+    const localCsv = `${tmpDir}/${date}.csv.gz`;
+    mkdir(tmpDir, { recursive: true });
+    try {
+      if (!exists(localCsv)) {
+        await execFileAsync2("rclone", ["copy", s3Path, `${tmpDir}/`], { timeout: 3e5 });
+        if (!exists(localCsv)) {
+          throw new Error(`rclone download failed \u2014 file not found: ${localCsv}`);
+        }
+      }
+      const prefix = assetClass === "option" ? "O:" : "I:";
+      const tickerConditions = tickers.map((t) => `ticker LIKE '${prefix}${t}%'`).join(" OR ");
+      const whereClause = `WHERE ${tickerConditions}`;
+      const isOption = assetClass === "option";
+      const csvColumns = isOption ? "columns = {'ticker': 'VARCHAR', 'volume': 'BIGINT', 'open': 'DOUBLE', 'close': 'DOUBLE', 'high': 'DOUBLE', 'low': 'DOUBLE', 'window_start': 'BIGINT', 'transactions': 'BIGINT'}" : "columns = {'ticker': 'VARCHAR', 'open': 'DOUBLE', 'close': 'DOUBLE', 'high': 'DOUBLE', 'low': 'DOUBLE', 'window_start': 'BIGINT'}";
+      const etConversion = `
+        make_timestamp(CAST(window_start / 1000 AS BIGINT)) AS utc_ts,
+        CASE
+          WHEN month(make_timestamp(CAST(window_start / 1000 AS BIGINT))) > 3
+               AND month(make_timestamp(CAST(window_start / 1000 AS BIGINT))) < 11 THEN 4
+          WHEN month(make_timestamp(CAST(window_start / 1000 AS BIGINT))) = 3
+               AND day(make_timestamp(CAST(window_start / 1000 AS BIGINT))) >= 8 THEN 4
+          WHEN month(make_timestamp(CAST(window_start / 1000 AS BIGINT))) = 11
+               AND day(make_timestamp(CAST(window_start / 1000 AS BIGINT))) < 7 THEN 4
+          ELSE 5
+        END AS et_offset
+      `;
+      const sql = `
+        COPY (
+          SELECT
+            replace(replace(ticker, 'O:', ''), 'I:', '') AS ticker,
+            strftime(utc_ts - et_offset * INTERVAL '1' HOUR, '%Y-%m-%d') AS date,
+            strftime(utc_ts - et_offset * INTERVAL '1' HOUR, '%H:%M') AS time,
+            open,
+            high,
+            low,
+            close,
+            NULL::DOUBLE AS bid,
+            NULL::DOUBLE AS ask
+          FROM (
+            SELECT *, ${etConversion}
+            FROM read_csv('${localCsv}', ${csvColumns}, header = true, compression = 'gzip')
+            ${whereClause}
+          ) sub
+        ) TO '${outputPath}' (FORMAT PARQUET, COMPRESSION ZSTD)
+      `;
+      const { DuckDBInstance } = await import("@duckdb/node-api");
+      const db = await DuckDBInstance.create(":memory:");
+      const conn = await db.connect();
+      try {
+        mkdir(dirname(outputPath), { recursive: true });
+        await conn.run(sql);
+        const countResult = await conn.runAndReadAll(
+          `SELECT count(*) AS cnt FROM '${outputPath}'`
+        );
+        const rowCount = Number(countResult.getRows()[0][0]);
+        return { rowCount, skipped: false };
+      } finally {
+        conn.closeSync();
+      }
+    } finally {
+      try {
+        const { unlinkSync: unlinkSync2 } = await import("fs");
+        if (exists(localCsv)) unlinkSync2(localCsv);
+      } catch {
+      }
+    }
+  }
   async fetchOptionSnapshot(options) {
     const apiKey = getApiKey();
     const { underlying } = options;
@@ -2219,571 +2380,1304 @@ var MassiveProvider = class {
       underlying_ticker: underlyingTicker
     };
   }
-};
-
-// src/utils/providers/thetadata.ts
-var ThetaDataProvider = class {
-  name = "thetadata";
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async fetchBars(options) {
-    throw new Error("ThetaData provider not yet implemented \u2014 set MARKET_DATA_PROVIDER=massive");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async fetchOptionSnapshot(options) {
-    throw new Error("ThetaData provider not yet implemented \u2014 set MARKET_DATA_PROVIDER=massive");
+  async fetchContractList(options) {
+    const apiKey = getApiKey();
+    const { underlying, as_of, expired = true, expiration_date_gte, expiration_date_lte } = options;
+    const headers = { Authorization: `Bearer ${apiKey}` };
+    const params = new URLSearchParams({
+      underlying_ticker: underlying,
+      limit: "1000"
+    });
+    if (expiration_date_gte || expiration_date_lte) {
+      if (expiration_date_gte) params.set("expiration_date.gte", expiration_date_gte);
+      if (expiration_date_lte) params.set("expiration_date.lte", expiration_date_lte);
+    } else {
+      params.set("as_of", as_of);
+    }
+    if (expired) {
+      params.set("expired", "true");
+    }
+    let url = `${MASSIVE_BASE_URL}/v3/reference/options/contracts?${params.toString()}`;
+    const allContracts = [];
+    const seenCursors = /* @__PURE__ */ new Set();
+    let pageCount = 0;
+    while (url) {
+      pageCount++;
+      if (pageCount > MASSIVE_MAX_PAGES) {
+        throw new Error(
+          `Pagination safety limit reached (${MASSIVE_MAX_PAGES} pages) -- possible API issue`
+        );
+      }
+      const response = await fetchWithRetry(url, headers);
+      if (response.status === 401) {
+        throw new Error("MASSIVE_API_KEY rejected by Massive.com -- check your key");
+      }
+      if (!response.ok) {
+        throw new Error(`Massive.com API error: HTTP ${response.status} ${response.statusText}`);
+      }
+      const json = await response.json();
+      const parsed = MassiveContractListResponseSchema.safeParse(json);
+      if (!parsed.success) {
+        const issues = parsed.error.issues.map((i) => `${String(i.path.join("."))}: ${i.message}`).join("; ");
+        throw new Error(`Massive contract list response validation failed: ${issues}`);
+      }
+      for (const contract of parsed.data.results) {
+        allContracts.push({
+          ticker: fromMassiveTicker(contract.ticker),
+          contract_type: contract.contract_type,
+          strike: contract.strike_price,
+          expiration: contract.expiration_date,
+          exercise_style: contract.exercise_style ?? "american"
+        });
+      }
+      if (parsed.data.next_url) {
+        const nextUrlObj = new URL(parsed.data.next_url);
+        const cursor = nextUrlObj.searchParams.get("cursor") ?? parsed.data.next_url;
+        if (seenCursors.has(cursor)) {
+          throw new Error(`Pagination loop detected -- cursor repeated: ${cursor.slice(0, 50)}...`);
+        }
+        seenCursors.add(cursor);
+        url = parsed.data.next_url;
+      } else {
+        url = null;
+      }
+    }
+    return { contracts: allContracts, underlying };
   }
 };
 
-// src/utils/market-provider.ts
-var _cached = null;
-function getProvider() {
-  if (_cached) return _cached;
-  const name = (process.env.MARKET_DATA_PROVIDER ?? "massive").toLowerCase();
-  switch (name) {
-    case "massive":
-      _cached = new MassiveProvider();
-      break;
-    case "thetadata":
-      _cached = new ThetaDataProvider();
-      break;
-    default:
-      throw new Error(
-        `Unknown MARKET_DATA_PROVIDER: "${name}". Supported: massive, thetadata`
-      );
+// src/utils/trade-replay.ts
+function markPrice(bar) {
+  if (bar.bid != null && bar.ask != null && (bar.bid > 0 || bar.ask > 0)) {
+    return (bar.bid + bar.ask) / 2;
   }
-  return _cached;
-}
-function _resetProvider() {
-  _cached = null;
+  return (bar.high + bar.low) / 2;
 }
-
-// src/utils/market-importer.ts
-var REQUIRED_SCHEMA_FIELDS = {
-  daily: ["date", "open", "high", "low", "close"],
-  context: ["date"],
-  intraday: ["date", "time", "open", "high", "low", "close"],
-  _context_derived: ["date"]
-  // Phase 75: cross-ticker derived fields
-};
-var CONFLICT_TARGETS = {
-  daily: "(ticker, date)",
-  context: "(date)",
-  intraday: "(ticker, date, time)",
-  _context_derived: "(date)"
-  // Phase 75: PK is date only
-};
-function validateColumnMapping(columnMapping, targetTable) {
-  const schemaValues = Object.values(columnMapping);
-  const required = REQUIRED_SCHEMA_FIELDS[targetTable] ?? [];
-  let missing = required.filter((field) => !schemaValues.includes(field));
-  if (targetTable === "intraday" && missing.includes("time") && schemaValues.includes("date")) {
-    missing = missing.filter((f) => f !== "time");
+function findNearestTimestamp(sortedTimestamps, target, toleranceSec = 60) {
+  if (sortedTimestamps.length === 0) return void 0;
+  const targetMin = timestampToMinutes(target);
+  if (targetMin === null) return void 0;
+  let lo = 0, hi = sortedTimestamps.length - 1;
+  let bestIdx = 0;
+  let bestDiff = Infinity;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    const midMin = timestampToMinutes(sortedTimestamps[mid]);
+    if (midMin === null) {
+      lo = mid + 1;
+      continue;
+    }
+    const diff = Math.abs(midMin - targetMin);
+    if (diff < bestDiff) {
+      bestDiff = diff;
+      bestIdx = mid;
+    }
+    if (midMin < targetMin) lo = mid + 1;
+    else if (midMin > targetMin) hi = mid - 1;
+    else break;
   }
-  return { valid: missing.length === 0, missingFields: missing };
+  return bestDiff <= toleranceSec / 60 ? sortedTimestamps[bestIdx] : void 0;
 }
-function parseCSV(content) {
-  const lines = content.replace(/^\uFEFF/, "").trim().split("\n");
-  if (lines.length < 2) {
-    return { headers: [], rows: [] };
-  }
-  const headers = lines[0].trim().split(",").map((h) => h.trim());
-  const rows = [];
-  for (let i = 1; i < lines.length; i++) {
-    const line = lines[i].trim();
-    if (!line) continue;
-    const values = line.split(",");
-    const row = {};
-    headers.forEach((h, idx) => {
-      row[h] = values[idx]?.trim() ?? "";
-    });
-    rows.push(row);
-  }
-  return { headers, rows };
+function timestampToMinutes(ts) {
+  const timePart = ts.split(" ")[1];
+  if (!timePart) return null;
+  const [h, m] = timePart.split(":").map(Number);
+  if (isNaN(h) || isNaN(m)) return null;
+  return h * 60 + m;
 }
-function parseFlexibleDate(value) {
-  const numeric = Number(value);
-  if (!isNaN(numeric) && numeric > 1e8) {
-    return new Date(numeric * 1e3).toLocaleDateString("en-CA", {
-      timeZone: "America/New_York",
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit"
-    });
+var COMPACT_LEG_RE = /^([A-Z]+)\s+(\d+(?:\.\d+)?)\s*(C|P)$/i;
+var COMPACT_NO_ROOT_RE = /^(\d+(?:\.\d+)?)\s*(C|P)$/i;
+var VERBOSE_LEG_RE = /^([A-Z]+)\s+\w+\s+(\d+(?:\.\d+)?)\s+(Call|Put)$/i;
+var OO_LEG_RE = /^(\d+)\s+(\w+)\s+(\d+)\s+(\d+(?:\.\d+)?)\s+(C|P)\s+(STO|BTO|STC|BTC)\s+(\d+(?:\.\d+)?)$/i;
+function parseLegsString(legsStr) {
+  if (!legsStr || legsStr.trim() === "") {
+    throw new Error('Cannot parse legs "" \u2014 use hypothetical mode with explicit strikes');
   }
-  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
-    return value;
+  if (legsStr.includes("|")) {
+    return parseOOLegs(legsStr);
   }
-  return null;
+  const parts = legsStr.includes("/") ? legsStr.split("/") : [legsStr];
+  const legs = [];
+  let inheritedRoot = "";
+  for (let i = 0; i < parts.length; i++) {
+    const raw = parts[i].trim();
+    let root;
+    let strike;
+    let type;
+    const compactMatch = raw.match(COMPACT_LEG_RE);
+    if (compactMatch) {
+      root = compactMatch[1].toUpperCase();
+      strike = parseFloat(compactMatch[2]);
+      type = compactMatch[3].toUpperCase();
+    } else {
+      const noRootMatch = raw.match(COMPACT_NO_ROOT_RE);
+      if (noRootMatch && inheritedRoot) {
+        root = inheritedRoot;
+        strike = parseFloat(noRootMatch[1]);
+        type = noRootMatch[2].toUpperCase();
+      } else {
+        const verboseMatch = raw.match(VERBOSE_LEG_RE);
+        if (verboseMatch) {
+          root = verboseMatch[1].toUpperCase();
+          strike = parseFloat(verboseMatch[2]);
+          type = verboseMatch[3].toLowerCase() === "call" ? "C" : "P";
+        } else {
+          throw new Error(
+            `Cannot parse legs "${legsStr}" \u2014 use hypothetical mode with explicit strikes`
+          );
+        }
+      }
+    }
+    if (i === 0) inheritedRoot = root;
+    const quantity = i === 0 ? 1 : i % 2 === 0 ? 1 : -1;
+    legs.push({ root, strike, type, quantity });
+  }
+  return legs;
 }
-function parseFlexibleTime(value) {
-  const numeric = Number(value);
-  if (!isNaN(numeric) && numeric > 1e8) {
-    const d = new Date(numeric * 1e3);
-    return d.toLocaleTimeString("en-US", {
-      timeZone: "America/New_York",
-      hour: "2-digit",
-      minute: "2-digit",
-      hour12: false
+function parseOOLegs(legsStr) {
+  const segments = legsStr.split("|").map((s) => s.trim());
+  const legs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const seg of segments) {
+    const match = seg.match(OO_LEG_RE);
+    if (!match) {
+      throw new Error(
+        `Cannot parse OO leg segment "${seg}" \u2014 use hypothetical mode with explicit strikes`
+      );
+    }
+    const contracts = parseInt(match[1], 10);
+    const month = match[2];
+    const day = match[3];
+    const strike = parseFloat(match[4]);
+    const type = match[5].toUpperCase();
+    const direction = match[6].toUpperCase();
+    const price = parseFloat(match[7]);
+    const key = `${month}${day}:${strike}${type}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    legs.push({
+      root: "",
+      // OO format doesn't include root — caller provides via trade's ticker field
+      strike,
+      type,
+      quantity: direction === "BTO" ? 1 : -1,
+      entryPrice: price,
+      contracts,
+      expiryHint: `${month} ${day}`
     });
   }
-  if (/^\d{2}:\d{2}$/.test(value)) {
-    return value;
+  return legs;
+}
+function buildOccTicker(root, expiry, type, strike) {
+  const [yyyy, mm, dd] = expiry.split("-");
+  const yy = yyyy.slice(2);
+  const strikeInt = Math.round(strike * 1e3);
+  const strikePadded = String(strikeInt).padStart(8, "0");
+  return `${root}${yy}${mm}${dd}${type}${strikePadded}`;
+}
+function computeStrategyPnlPath(legs, barsByLeg, greeksConfig) {
+  if (legs.length === 0 || barsByLeg.length === 0) return [];
+  for (const bars of barsByLeg) {
+    if (bars.length === 0) return [];
   }
-  if (/^\d{4}$/.test(value)) {
-    return `${value.slice(0, 2)}:${value.slice(2)}`;
+  const legMaps = barsByLeg.map((bars) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const bar of bars) {
+      const ts = `${bar.date} ${bar.time ?? ""}`.trim();
+      map.set(ts, bar);
+    }
+    return map;
+  });
+  const allTimestamps = /* @__PURE__ */ new Set();
+  for (const bars of barsByLeg) {
+    for (const bar of bars) {
+      allTimestamps.add(`${bar.date} ${bar.time ?? ""}`.trim());
+    }
   }
-  return null;
-}
-function applyColumnMapping(rows, columnMapping, ticker, targetTable) {
-  const normalizedTicker = normalizeTicker(ticker) ?? ticker.toUpperCase();
-  const result = [];
-  for (const row of rows) {
-    const mapped = {};
-    let hasNullDate = false;
-    for (const [sourceCol, schemaCol] of Object.entries(columnMapping)) {
-      const rawValue = row[sourceCol] ?? "";
-      if (schemaCol === "date") {
-        const parsedDate = parseFlexibleDate(rawValue);
-        if (parsedDate === null) {
-          console.warn(`[market-importer] Skipping row with unparseable date value: "${rawValue}"`);
-          hasNullDate = true;
-          break;
-        }
-        mapped[schemaCol] = parsedDate;
-      } else if (schemaCol === "time") {
-        const parsedTime = parseFlexibleTime(rawValue);
-        if (parsedTime === null) {
-          console.warn(`[market-importer] Skipping row with unparseable time value: "${rawValue}"`);
-          hasNullDate = true;
-          break;
-        }
-        mapped[schemaCol] = parsedTime;
-      } else {
-        if (rawValue === "" || rawValue === "NaN" || rawValue === "NA") {
-          mapped[schemaCol] = null;
-        } else {
-          const numVal = parseFloat(rawValue);
-          mapped[schemaCol] = isNaN(numVal) ? rawValue : numVal;
-        }
+  const sortedTimestamps = [...allTimestamps].sort();
+  const path2 = [];
+  const lastBar = new Array(legs.length).fill(void 0);
+  for (const ts of sortedTimestamps) {
+    let complete = true;
+    const legPrices = [];
+    let strategyPnl = 0;
+    for (let i = 0; i < legs.length; i++) {
+      const bar = legMaps[i].get(ts);
+      if (bar) {
+        lastBar[i] = bar;
       }
+      const effective = bar ?? lastBar[i];
+      if (!effective) {
+        complete = false;
+        break;
+      }
+      const hl2 = markPrice(effective);
+      legPrices.push(hl2);
+      strategyPnl += (hl2 - legs[i].entryPrice) * legs[i].quantity * legs[i].multiplier;
     }
-    if (hasNullDate) continue;
-    if (!("date" in mapped)) continue;
-    if (targetTable === "intraday" && !("time" in mapped)) {
-      const dateSourceCol = Object.entries(columnMapping).find(([, schema]) => schema === "date")?.[0];
-      if (dateSourceCol) {
-        const rawDateValue = row[dateSourceCol] ?? "";
-        const numericDate = Number(rawDateValue);
-        if (!isNaN(numericDate) && numericDate > 1e8) {
-          const parsedTime = parseFlexibleTime(rawDateValue);
-          if (parsedTime) {
-            mapped["time"] = parsedTime;
+    if (complete) {
+      const point = { timestamp: ts, strategyPnl, legPrices };
+      if (greeksConfig) {
+        let underlyingPrice = greeksConfig.underlyingPrices.get(ts);
+        if (underlyingPrice === void 0 && greeksConfig.sortedTimestamps) {
+          const nearest = findNearestTimestamp(greeksConfig.sortedTimestamps, ts, 60);
+          if (nearest) underlyingPrice = greeksConfig.underlyingPrices.get(nearest);
+        }
+        if (underlyingPrice === void 0) {
+          const dateOnly = ts.split(" ")[0];
+          underlyingPrice = greeksConfig.underlyingPrices.get(dateOnly);
+        }
+        if (underlyingPrice !== void 0) {
+          point.underlyingPrice = underlyingPrice;
+          const legGreeksArr = [];
+          let netDelta = 0, netGamma = 0, netTheta = 0, netVega = 0;
+          let allNull = true;
+          for (let j = 0; j < legs.length; j++) {
+            const legCfg = greeksConfig.legs[j];
+            if (!legCfg || !legCfg.expiryDate) {
+              legGreeksArr.push({ delta: null, gamma: null, theta: null, vega: null, iv: null });
+              continue;
+            }
+            const dateStr = ts.split(" ")[0];
+            const timePart = ts.split(" ")[1] ?? "09:30";
+            const [eyy, emm, edd] = legCfg.expiryDate.split("-").map(Number);
+            const [byy, bmm, bdd] = dateStr.split("-").map(Number);
+            const [hh, min] = timePart.split(":").map(Number);
+            const expiryMs = new Date(eyy, emm - 1, edd).getTime() + 16 * 60 * 60 * 1e3;
+            const barMs = new Date(byy, bmm - 1, bdd).getTime() + (hh * 60 + min) * 60 * 1e3;
+            const dte = (expiryMs - barMs) / (1e3 * 60 * 60 * 24);
+            if (dte <= 0) {
+              legGreeksArr.push({ delta: null, gamma: null, theta: null, vega: null, iv: null });
+              continue;
+            }
+            const g = computeLegGreeks(
+              legPrices[j],
+              underlyingPrice,
+              legCfg.strike,
+              dte,
+              legCfg.type,
+              greeksConfig.riskFreeRate,
+              greeksConfig.dividendYield
+            );
+            legGreeksArr.push(g);
+            if (g.delta !== null) {
+              allNull = false;
+              const weight = legs[j].quantity * legs[j].multiplier / 100;
+              netDelta += g.delta * weight;
+              netGamma += g.gamma * weight;
+              netTheta += g.theta * weight;
+              netVega += g.vega * weight;
+            }
           }
+          point.legGreeks = legGreeksArr;
+          point.netDelta = allNull ? null : netDelta;
+          point.netGamma = allNull ? null : netGamma;
+          point.netTheta = allNull ? null : netTheta;
+          point.netVega = allNull ? null : netVega;
+          const ivpDate = ts.split(" ")[0];
+          point.ivp = greeksConfig.ivpByDate?.get(ivpDate) ?? null;
         }
       }
+      path2.push(point);
     }
-    if (targetTable === "daily" || targetTable === "intraday") {
-      mapped["ticker"] = normalizedTicker;
-    }
-    result.push(mapped);
   }
-  return result;
+  return path2;
 }
-async function insertMappedRows(conn, targetTable, mappedRows) {
-  if (mappedRows.length === 0) {
-    return { inserted: 0, updated: 0, skipped: 0 };
+function computeReplayMfeMae(pnlPath) {
+  if (pnlPath.length === 0) {
+    return { mfe: 0, mae: 0, mfeTimestamp: "", maeTimestamp: "" };
   }
-  const tableName = `market.${targetTable}`;
-  const conflictTarget = CONFLICT_TARGETS[targetTable];
-  const columnSet = /* @__PURE__ */ new Set();
-  for (const row of mappedRows) {
-    for (const key of Object.keys(row)) {
-      columnSet.add(key);
+  let mfe = pnlPath[0].strategyPnl;
+  let mae = pnlPath[0].strategyPnl;
+  let mfeTimestamp = pnlPath[0].timestamp;
+  let maeTimestamp = pnlPath[0].timestamp;
+  for (let i = 1; i < pnlPath.length; i++) {
+    const pnl = pnlPath[i].strategyPnl;
+    if (pnl > mfe) {
+      mfe = pnl;
+      mfeTimestamp = pnlPath[i].timestamp;
     }
-  }
-  const columns = Array.from(columnSet);
-  const beforeResult = await conn.runAndReadAll(`SELECT COUNT(*) FROM ${tableName}`);
-  const beforeCount = Number(beforeResult.getRows()[0][0]);
-  const conflictKeys = new Set(
-    CONFLICT_TARGETS[targetTable].replace(/[()]/g, "").split(",").map((s) => s.trim())
-  );
-  const updateCols = columns.filter((c) => !conflictKeys.has(c));
-  const conflictAction = updateCols.length > 0 ? `DO UPDATE SET ${updateCols.map((c) => `${c} = EXCLUDED.${c}`).join(", ")}` : "DO NOTHING";
-  const columnList = columns.join(", ");
-  const BATCH_SIZE = 500;
-  for (let i = 0; i < mappedRows.length; i += BATCH_SIZE) {
-    const batch = mappedRows.slice(i, i + BATCH_SIZE);
-    const values = [];
-    const valuePlaceholders = [];
-    for (const row of batch) {
-      const rowPlaceholders = [];
-      for (const col of columns) {
-        values.push(row[col] ?? null);
-        rowPlaceholders.push(`$${values.length}`);
-      }
-      valuePlaceholders.push(`(${rowPlaceholders.join(", ")})`);
+    if (pnl < mae) {
+      mae = pnl;
+      maeTimestamp = pnlPath[i].timestamp;
     }
-    const sql = `INSERT INTO ${tableName} (${columnList}) VALUES ${valuePlaceholders.join(", ")} ON CONFLICT ${conflictTarget} ${conflictAction}`;
-    await conn.run(sql, values);
   }
-  const afterResult = await conn.runAndReadAll(`SELECT COUNT(*) FROM ${tableName}`);
-  const afterCount = Number(afterResult.getRows()[0][0]);
-  const inserted = afterCount - beforeCount;
-  const updated = updateCols.length > 0 ? mappedRows.length - inserted : 0;
-  const skipped = updateCols.length > 0 ? 0 : mappedRows.length - inserted;
-  return { inserted, updated, skipped };
+  return { mfe, mae, mfeTimestamp, maeTimestamp };
 }
-function computeDateRange(rows) {
-  const dates = [];
-  for (const row of rows) {
-    const d = row["date"];
-    if (typeof d === "string" && d) {
-      dates.push(d);
-    }
-  }
-  if (dates.length === 0) return null;
-  dates.sort();
-  return { min: dates[0], max: dates[dates.length - 1] };
+
+// src/utils/providers/thetadata-terminal.ts
+import { closeSync, existsSync, mkdirSync, openSync, symlinkSync, unlinkSync } from "fs";
+import { spawn, execFile } from "child_process";
+import net from "net";
+import os from "os";
+import path from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var DEFAULT_PORT = 25503;
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_JAR_NAME = "ThetaTerminalv3.jar";
+var DEFAULT_CREDS_NAME = "creds.txt";
+function defaultThetaTerminalHome() {
+  return path.join(
+    os.homedir(),
+    "Library",
+    "Application Support",
+    "tradeblocks",
+    "lib",
+    "thetadata"
+  );
 }
-async function triggerEnrichment(conn, ticker, targetTable, _dateRange, skipEnrichment) {
-  if (skipEnrichment) {
-    return {
-      status: "skipped",
-      message: "skip_enrichment=true; call enrich_market_data to populate computed fields."
+function legacyThetaTerminalHome() {
+  return path.join(
+    os.homedir(),
+    "Library",
+    "Application Support",
+    "tradeblocks",
+    "thetadata"
+  );
+}
+function parseJavaMajorVersion(output) {
+  const legacy = output.match(/version "1\.(\d+)\./);
+  if (legacy) return Number(legacy[1]);
+  const modern = output.match(/version "(\d+)(?:[.\-+]|")/);
+  if (modern) return Number(modern[1]);
+  return null;
+}
+function resolveThetaTerminalConfig(env = process.env) {
+  const defaultHome = defaultThetaTerminalHome();
+  const legacyHome = legacyThetaTerminalHome();
+  const homeDir = env.THETADATA_HOME ? path.resolve(env.THETADATA_HOME) : existsSync(defaultHome) || !existsSync(legacyHome) ? defaultHome : legacyHome;
+  const jarPath = env.THETADATA_JAR ? path.resolve(env.THETADATA_JAR) : path.join(homeDir, DEFAULT_JAR_NAME);
+  const credsPath = env.THETADATA_CREDS_FILE ? path.resolve(env.THETADATA_CREDS_FILE) : path.join(homeDir, DEFAULT_CREDS_NAME);
+  return {
+    homeDir,
+    jarPath,
+    credsPath,
+    managedCredsPath: path.join(homeDir, DEFAULT_CREDS_NAME),
+    logPath: path.join(homeDir, "ThetaTerminal.log"),
+    host: env.THETADATA_HOST || DEFAULT_HOST,
+    port: Number.parseInt(env.THETADATA_PORT || String(DEFAULT_PORT), 10) || DEFAULT_PORT,
+    javaCmd: env.JAVA_HOME ? path.join(env.JAVA_HOME, "bin", "java") : "java",
+    startTimeoutMs: Number.parseInt(env.THETADATA_START_TIMEOUT_MS || String(DEFAULT_TIMEOUT_MS), 10) || DEFAULT_TIMEOUT_MS
+  };
+}
+async function detectJavaMajorVersion(javaCmd) {
+  try {
+    const { stdout, stderr } = await execFileAsync(javaCmd, ["-version"]);
+    return parseJavaMajorVersion(`${stdout}
+${stderr}`);
+  } catch (error) {
+    const err = error;
+    return parseJavaMajorVersion(`${err.stdout || ""}
+${err.stderr || ""}`);
+  }
+}
+async function isThetaTerminalRunning(host, port, timeoutMs = 1e3) {
+  return await new Promise((resolve) => {
+    const socket = net.createConnection({ host, port });
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(value);
     };
+    socket.setTimeout(timeoutMs);
+    socket.once("connect", () => finish(true));
+    socket.once("timeout", () => finish(false));
+    socket.once("error", () => finish(false));
+  });
+}
+function ensureManagedCredsFile(config) {
+  mkdirSync(config.homeDir, { recursive: true });
+  if (!existsSync(config.credsPath)) {
+    throw new Error(
+      `ThetaData creds file not found at ${config.credsPath}. Place ${DEFAULT_CREDS_NAME} in ${config.homeDir} or set THETADATA_CREDS_FILE.`
+    );
   }
-  if (targetTable !== "daily") {
-    return {
-      status: "skipped",
-      message: `Enrichment only runs for daily table imports; skipping for ${targetTable}.`
-    };
+  if (path.resolve(config.credsPath) === path.resolve(config.managedCredsPath)) {
+    return;
   }
   try {
-    const result = await runEnrichment(conn, ticker, {});
-    const summaryParts = [
-      `Tier 1: ${result.tier1.status}${result.tier1.fieldsWritten !== void 0 ? ` (${result.tier1.fieldsWritten} fields)` : ""}${result.tier1.reason ? ` \u2014 ${result.tier1.reason}` : ""}`,
-      `Tier 2: ${result.tier2.status}${result.tier2.fieldsWritten !== void 0 ? ` (${result.tier2.fieldsWritten} fields)` : ""}${result.tier2.reason ? ` \u2014 ${result.tier2.reason}` : ""}`,
-      `Tier 3: ${result.tier3.status}${result.tier3.reason ? ` \u2014 ${result.tier3.reason}` : ""}`
-    ];
-    return {
-      status: "complete",
-      message: `Enriched ${result.rowsEnriched} rows for ${ticker} through ${result.enrichedThrough ?? "N/A"}. ${summaryParts.join("; ")}`
-    };
-  } catch (err) {
-    return {
-      status: "error",
-      message: `Enrichment failed for ${ticker}: ${err instanceof Error ? err.message : String(err)}`
-    };
+    if (existsSync(config.managedCredsPath)) unlinkSync(config.managedCredsPath);
+  } catch {
   }
+  symlinkSync(config.credsPath, config.managedCredsPath);
 }
-async function importMarketCsvFile(conn, options) {
-  const { filePath, ticker, targetTable, columnMapping, dryRun = false, skipEnrichment = false } = options;
-  const validation = validateColumnMapping(columnMapping, targetTable);
-  if (!validation.valid) {
+async function waitForThetaTerminal(config) {
+  const deadline = Date.now() + config.startTimeoutMs;
+  while (Date.now() < deadline) {
+    if (await isThetaTerminalRunning(config.host, config.port, 1e3)) return;
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  throw new Error(
+    `ThetaTerminal did not start listening on ${config.host}:${config.port} within ${config.startTimeoutMs}ms. Check ${config.logPath}.`
+  );
+}
+async function ensureThetaTerminalRunning(env = process.env) {
+  const config = resolveThetaTerminalConfig(env);
+  if (!existsSync(config.jarPath)) {
     throw new Error(
-      `Column mapping missing required fields for market.${targetTable}: ${validation.missingFields.join(", ")}`
+      `ThetaTerminal JAR not found at ${config.jarPath}. Expected ${DEFAULT_JAR_NAME} in ${config.homeDir} or set THETADATA_JAR.`
     );
   }
-  let content;
-  try {
-    content = await fs.readFile(filePath, "utf-8");
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to read CSV file at "${filePath}": ${msg}`);
+  const javaMajor = await detectJavaMajorVersion(config.javaCmd);
+  if (javaMajor == null || javaMajor < 21) {
+    throw new Error(
+      `ThetaTerminal requires Java 21+. Found ${javaMajor ?? "unknown"} via ${config.javaCmd}.`
+    );
   }
-  const { rows } = parseCSV(content);
-  if (rows.length === 0) {
-    throw new Error(`CSV file "${filePath}" has no data rows`);
+  if (await isThetaTerminalRunning(config.host, config.port, 1e3)) {
+    return "already_running";
   }
-  const mappedRows = applyColumnMapping(rows, columnMapping, ticker, targetTable);
-  if (mappedRows.length === 0) {
-    throw new Error(
-      `After applying column mapping, 0 valid rows remain from CSV file "${filePath}"`
+  ensureManagedCredsFile(config);
+  mkdirSync(config.homeDir, { recursive: true });
+  const stdoutFd = openSync(config.logPath, "a");
+  const stderrFd = openSync(config.logPath, "a");
+  try {
+    const child = spawn(
+      config.javaCmd,
+      ["-jar", config.jarPath],
+      {
+        cwd: config.homeDir,
+        detached: true,
+        stdio: ["ignore", stdoutFd, stderrFd]
+      }
     );
+    child.unref();
+  } finally {
+    closeSync(stdoutFd);
+    closeSync(stderrFd);
   }
-  const normalizedTicker = normalizeTicker(ticker) ?? ticker.toUpperCase();
-  const dateRange = computeDateRange(mappedRows);
-  if (dryRun) {
-    return {
-      rowsInserted: 0,
-      rowsUpdated: 0,
-      rowsSkipped: 0,
-      inputRowCount: mappedRows.length,
-      dateRange,
-      enrichment: {
-        status: "skipped",
-        message: `dry_run=true; no data written. Would import ${mappedRows.length} rows.`
+  await waitForThetaTerminal(config);
+  return "started";
+}
+
+// src/utils/providers/thetadata.ts
+var THETADATA_BASE_URL = "http://127.0.0.1:25503";
+var THETADATA_TIMEOUT_MS = 3e4;
+var THETADATA_RETRY_BASE_MS = 250;
+var THETADATA_MAX_ATTEMPTS = 4;
+var RETRYABLE_THETA_STATUS_CODES = /* @__PURE__ */ new Set([429, 474, 571]);
+var THETA_ERROR_NAMES = {
+  404: "NO_IMPL",
+  429: "OS_LIMIT",
+  470: "GENERAL",
+  471: "PERMISSION",
+  472: "NO_DATA",
+  473: "INVALID_PARAMS",
+  474: "DISCONNECTED",
+  475: "TERMINAL_PARSE",
+  476: "WRONG_IP",
+  477: "NO_PAGE_FOUND",
+  478: "INVALID_SESSION_ID",
+  571: "SERVER_STARTING",
+  572: "UNCAUGHT_ERROR"
+};
+function getBaseUrl(env = process.env) {
+  return env.THETADATA_BASE_URL || THETADATA_BASE_URL;
+}
+function getTimeoutMs(env = process.env) {
+  return Number.parseInt(
+    env.THETADATA_REQUEST_TIMEOUT_MS || String(THETADATA_TIMEOUT_MS),
+    10
+  ) || THETADATA_TIMEOUT_MS;
+}
+function getRetryBaseMs(env = process.env) {
+  return Number.parseInt(
+    env.THETADATA_RETRY_BASE_MS || String(THETADATA_RETRY_BASE_MS),
+    10
+  ) || THETADATA_RETRY_BASE_MS;
+}
+function getMaxAttempts(env = process.env) {
+  return Number.parseInt(
+    env.THETADATA_MAX_ATTEMPTS || String(THETADATA_MAX_ATTEMPTS),
+    10
+  ) || THETADATA_MAX_ATTEMPTS;
+}
+async function maybeEnsureThetaRunning(env = process.env) {
+  if (env.THETADATA_SKIP_AUTO_START === "1") return;
+  await ensureThetaTerminalRunning(env);
+}
+function compactDate(date) {
+  return date.replaceAll("-", "");
+}
+function formatDate(date) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function parseIsoDate(date) {
+  return /* @__PURE__ */ new Date(`${date}T12:00:00Z`);
+}
+function splitDateRangeByMonth(from, to) {
+  const start = parseIsoDate(from);
+  const end = parseIsoDate(to);
+  const chunks = [];
+  let cursor = new Date(start);
+  while (cursor <= end) {
+    const chunkStart = new Date(cursor);
+    const chunkEnd = new Date(Date.UTC(
+      cursor.getUTCFullYear(),
+      cursor.getUTCMonth() + 1,
+      0,
+      12,
+      0,
+      0
+    ));
+    if (chunkEnd > end) chunkEnd.setTime(end.getTime());
+    chunks.push({ from: formatDate(chunkStart), to: formatDate(chunkEnd) });
+    cursor = new Date(Date.UTC(
+      chunkEnd.getUTCFullYear(),
+      chunkEnd.getUTCMonth(),
+      chunkEnd.getUTCDate() + 1,
+      12,
+      0,
+      0
+    ));
+  }
+  return chunks;
+}
+function toThetaInterval(timespan, multiplier = 1) {
+  if (timespan === "day") return null;
+  if (timespan === "hour") {
+    if (multiplier !== 1) {
+      throw new Error(`ThetaData does not support ${multiplier}h bars`);
+    }
+    return "1h";
+  }
+  const minuteIntervals = /* @__PURE__ */ new Set([1, 5, 10, 15, 30]);
+  if (!minuteIntervals.has(multiplier)) {
+    throw new Error(`ThetaData does not support ${multiplier}m bars`);
+  }
+  return `${multiplier}m`;
+}
+function formatStrike(strike) {
+  return strike.toFixed(3);
+}
+function toThetaRight(right) {
+  return right;
+}
+function normalizeThetaRight(value) {
+  const raw = String(value ?? "").trim().toLowerCase();
+  if (raw === "c" || raw === "call") return "call";
+  if (raw === "p" || raw === "put") return "put";
+  throw new Error(`Unsupported ThetaData option right: ${String(value)}`);
+}
+function parseOccTicker(ticker) {
+  const match = ticker.match(/^([A-Z]+)(\d{2})(\d{2})(\d{2})(C|P)(\d{8})$/);
+  if (!match) {
+    throw new Error(`Invalid OCC option ticker: ${ticker}`);
+  }
+  const root = match[1];
+  const expiration = `20${match[2]}-${match[3]}-${match[4]}`;
+  const right = match[5] === "C" ? "call" : "put";
+  const strike = Number.parseInt(match[6], 10) / 1e3;
+  return { root, expiration, right, strike };
+}
+function thetaTimestampToEtDate(timestamp) {
+  return timestamp.slice(0, 10);
+}
+function thetaTimestampToEtTime(timestamp) {
+  return timestamp.slice(11, 16);
+}
+function toNumber(value) {
+  if (value == null) return null;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function toInteger(value) {
+  const num = toNumber(value);
+  return num == null ? null : Math.trunc(num);
+}
+function thetaKey(parts) {
+  return [
+    parts.symbol,
+    parts.expiration,
+    parts.strike.toFixed(3),
+    parts.right
+  ].join("|");
+}
+function inferExerciseStyle(symbol) {
+  const europeanRoots = /* @__PURE__ */ new Set([
+    "SPX",
+    "SPXW",
+    "XSP",
+    "NDX",
+    "NDXP",
+    "RUT",
+    "RUTW",
+    "VIX",
+    "VIX9D",
+    "DJX"
+  ]);
+  return europeanRoots.has(symbol.toUpperCase()) ? "european" : "american";
+}
+function breakEvenFor(contractType, strike, midpoint) {
+  const value = contractType === "call" ? strike + midpoint : strike - midpoint;
+  return Number(value.toFixed(6));
+}
+function filterSnapshotContract(contract, options) {
+  if (options.contract_type && contract.right !== options.contract_type) return false;
+  if (options.expiration_date_gte && contract.expiration < options.expiration_date_gte) return false;
+  if (options.expiration_date_lte && contract.expiration > options.expiration_date_lte) return false;
+  if (options.strike_price_gte != null && contract.strike < options.strike_price_gte) return false;
+  if (options.strike_price_lte != null && contract.strike > options.strike_price_lte) return false;
+  return true;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function thetaErrorLabel(status) {
+  return THETA_ERROR_NAMES[status] ?? `HTTP_${status}`;
+}
+function thetaErrorMessage(status, body) {
+  const prefix = `ThetaData ${status} ${thetaErrorLabel(status)}`;
+  const trimmed = body.trim();
+  if (!trimmed) return prefix;
+  return `${prefix}: ${trimmed}`;
+}
+async function requestThetaArray(endpointPath, params, env = process.env) {
+  await maybeEnsureThetaRunning(env);
+  const url = new URL(endpointPath, getBaseUrl(env));
+  for (const [key, value] of Object.entries(params)) {
+    if (value == null) continue;
+    url.searchParams.set(key, String(value));
+  }
+  if (!url.searchParams.has("format")) {
+    url.searchParams.set("format", "json");
+  }
+  const maxAttempts = getMaxAttempts(env);
+  const retryBaseMs = getRetryBaseMs(env);
+  let lastError = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const response = await fetch(url, {
+        signal: AbortSignal.timeout(getTimeoutMs(env))
+      });
+      const text = await response.text();
+      if (response.status === 472 && text.trim().startsWith("No data found for your request")) {
+        return [];
       }
-    };
+      if (!response.ok) {
+        if (RETRYABLE_THETA_STATUS_CODES.has(response.status) && attempt < maxAttempts) {
+          await sleep(retryBaseMs * attempt);
+          continue;
+        }
+        throw new Error(thetaErrorMessage(response.status, text));
+      }
+      const trimmed = text.trim();
+      if (!trimmed) return [];
+      if (!trimmed.startsWith("[") && !trimmed.startsWith("{")) {
+        throw new Error(trimmed);
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch (error) {
+        throw new Error(
+          `ThetaData returned invalid JSON from ${endpointPath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      if (Array.isArray(parsed)) return parsed;
+      if (parsed && typeof parsed === "object") {
+        const object = parsed;
+        if (Array.isArray(object.data)) return object.data;
+        if (Array.isArray(object.response)) return object.response;
+      }
+      throw new Error(`ThetaData ${endpointPath} returned unexpected JSON shape`);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      lastError = err;
+      const isTransportError = err.message === "fetch failed";
+      if ((isTransportError || err.name === "AbortError") && attempt < maxAttempts) {
+        await sleep(retryBaseMs * attempt);
+        continue;
+      }
+      throw err;
+    }
   }
-  const { inserted, updated, skipped } = await insertMappedRows(conn, targetTable, mappedRows);
-  await upsertMarketImportMetadata(conn, {
-    source: `import_market_csv:${filePath}`,
-    ticker: normalizedTicker,
-    target_table: targetTable,
-    max_date: dateRange?.max ?? null,
-    enriched_through: null,
-    synced_at: /* @__PURE__ */ new Date()
-  });
-  const enrichment = await triggerEnrichment(conn, normalizedTicker, targetTable, dateRange, skipEnrichment);
+  throw lastError ?? new Error(`ThetaData request failed for ${endpointPath}`);
+}
+function flattenThetaRows(rows) {
+  const flat = [];
+  for (const row of rows) {
+    if (Array.isArray(row.data) && row.contract && typeof row.contract === "object") {
+      for (const datum of row.data) {
+        if (!datum || typeof datum !== "object") continue;
+        flat.push({
+          ...row.contract,
+          ...datum
+        });
+      }
+      continue;
+    }
+    flat.push(row);
+  }
+  return flat;
+}
+function mapIntradayRow(row, ticker) {
+  const timestamp = String(row.timestamp ?? "");
   return {
-    rowsInserted: inserted,
-    rowsUpdated: updated,
-    rowsSkipped: skipped,
-    inputRowCount: mappedRows.length,
-    dateRange,
-    enrichment
+    date: thetaTimestampToEtDate(timestamp),
+    time: thetaTimestampToEtTime(timestamp),
+    open: toNumber(row.open) ?? 0,
+    high: toNumber(row.high) ?? 0,
+    low: toNumber(row.low) ?? 0,
+    close: toNumber(row.close) ?? 0,
+    volume: toInteger(row.volume) ?? 0,
+    ticker
   };
 }
-async function importFromDatabase(conn, options) {
-  const { dbPath, query, ticker, targetTable, columnMapping, dryRun = false, skipEnrichment = false } = options;
-  const validation = validateColumnMapping(columnMapping, targetTable);
-  if (!validation.valid) {
-    throw new Error(
-      `Column mapping missing required fields for market.${targetTable}: ${validation.missingFields.join(", ")}`
-    );
+function mapEodRow(row, ticker) {
+  const dateToken = String(row.date ?? row.timestamp ?? row.created ?? row.last_trade ?? "");
+  return {
+    date: dateToken.slice(0, 10),
+    open: toNumber(row.open) ?? 0,
+    high: toNumber(row.high) ?? 0,
+    low: toNumber(row.low) ?? 0,
+    close: toNumber(row.close) ?? 0,
+    volume: toInteger(row.volume) ?? 0,
+    ticker,
+    bid: toNumber(row.bid) ?? void 0,
+    ask: toNumber(row.ask) ?? void 0
+  };
+}
+function normalizedMidpoint(bid, ask) {
+  if (bid > 0 && ask > 0) return Number(((bid + ask) / 2).toFixed(6));
+  return Math.max(bid, ask, 0);
+}
+async function fetchOptionHistoryRows(ticker, from, to, endpoint, interval) {
+  const occ = parseOccTicker(ticker);
+  const chunks = splitDateRangeByMonth(from, to);
+  const rows = [];
+  for (const chunk of chunks) {
+    const params = {
+      symbol: occ.root,
+      expiration: compactDate(occ.expiration),
+      strike: formatStrike(occ.strike),
+      right: toThetaRight(occ.right),
+      format: "json",
+      ...interval ? { interval } : {},
+      ...chunk.from === chunk.to ? { date: compactDate(chunk.from) } : { start_date: compactDate(chunk.from), end_date: compactDate(chunk.to) }
+    };
+    rows.push(...flattenThetaRows(
+      await requestThetaArray(`/v3/option/history/${endpoint}`, params)
+    ));
   }
-  const EXT_ALIAS = "ext_import_source";
-  await conn.run(`ATTACH '${dbPath}' AS ${EXT_ALIAS} (READ_ONLY)`);
-  try {
-    const rawResult = await conn.runAndReadAll(query);
-    const resultColumnNames = rawResult.columnNames();
-    const resultRows = rawResult.getRows();
-    const rows = resultRows.map((row) => {
-      const obj = {};
-      resultColumnNames.forEach((colName, idx) => {
-        const val = row[idx];
-        obj[colName] = val === null || val === void 0 ? "" : String(val);
+  return rows;
+}
+async function fetchSymbolHistoryRows(ticker, from, to, assetClass, endpoint, interval) {
+  const chunks = splitDateRangeByMonth(from, to);
+  const rows = [];
+  for (const chunk of chunks) {
+    const params = {
+      symbol: ticker,
+      format: "json",
+      ...interval ? { interval } : {},
+      ...chunk.from === chunk.to ? { date: compactDate(chunk.from) } : { start_date: compactDate(chunk.from), end_date: compactDate(chunk.to) }
+    };
+    rows.push(...flattenThetaRows(
+      await requestThetaArray(`/v3/${assetClass}/history/${endpoint}`, params)
+    ));
+  }
+  return rows;
+}
+var ThetaDataProvider = class {
+  name = "thetadata";
+  capabilities() {
+    return {
+      tradeBars: true,
+      quotes: true,
+      greeks: true,
+      flatFiles: false,
+      bulkByRoot: true,
+      perTicker: false,
+      minuteBars: true,
+      dailyBars: true
+    };
+  }
+  async fetchBars(options) {
+    const {
+      ticker,
+      from,
+      to,
+      timespan = "day",
+      multiplier = 1,
+      assetClass = "stock"
+    } = options;
+    if (timespan === "day") {
+      const rows2 = assetClass === "option" ? await fetchOptionHistoryRows(ticker, from, to, "eod", null) : await fetchSymbolHistoryRows(ticker, from, to, assetClass, "eod", null);
+      return rows2.map((row) => mapEodRow(row, ticker)).sort((a, b) => a.date.localeCompare(b.date));
+    }
+    const interval = toThetaInterval(timespan, multiplier);
+    const rows = assetClass === "option" ? await fetchOptionHistoryRows(ticker, from, to, "ohlc", interval) : await fetchSymbolHistoryRows(ticker, from, to, assetClass, "ohlc", interval);
+    return rows.map((row) => mapIntradayRow(row, ticker)).sort((a, b) => {
+      const left = `${a.date} ${a.time ?? ""}`;
+      const right = `${b.date} ${b.time ?? ""}`;
+      return left.localeCompare(right);
+    });
+  }
+  async fetchQuotes(ticker, from, to) {
+    const rows = await fetchOptionHistoryRows(ticker, from, to, "quote", "1m");
+    const quotes = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const timestamp = String(row.timestamp ?? "");
+      if (!timestamp) continue;
+      const bid = toNumber(row.bid);
+      const ask = toNumber(row.ask);
+      if (bid == null || ask == null) continue;
+      quotes.set(`${thetaTimestampToEtDate(timestamp)} ${thetaTimestampToEtTime(timestamp)}`, {
+        bid,
+        ask
       });
-      return obj;
+    }
+    return quotes;
+  }
+  async fetchContractList(options) {
+    const { underlying, as_of, expiration_date_gte, expiration_date_lte } = options;
+    const maxDte = expiration_date_lte ? Math.max(
+      0,
+      Math.round(
+        (parseIsoDate(expiration_date_lte).getTime() - parseIsoDate(as_of).getTime()) / 864e5
+      )
+    ) : void 0;
+    const rows = await requestThetaArray("/v3/option/list/contracts/quote", {
+      symbol: underlying,
+      date: compactDate(as_of),
+      format: "json",
+      ...maxDte != null ? { max_dte: maxDte } : {}
     });
-    const mappedRows = applyColumnMapping(rows, columnMapping, ticker, targetTable);
-    const normalizedTicker = normalizeTicker(ticker) ?? ticker.toUpperCase();
-    const dateRange = computeDateRange(mappedRows);
-    if (dryRun) {
+    const contracts = [];
+    for (const row of rows) {
+      const symbol = String(row.symbol ?? underlying).toUpperCase();
+      const expiration = String(row.expiration ?? "");
+      const strike = toNumber(row.strike);
+      if (!expiration || strike == null) continue;
+      const contractType = normalizeThetaRight(row.right);
+      if (expiration_date_gte && expiration < expiration_date_gte) continue;
+      if (expiration_date_lte && expiration > expiration_date_lte) continue;
+      contracts.push({
+        ticker: buildOccTicker(
+          symbol,
+          expiration,
+          contractType === "call" ? "C" : "P",
+          strike
+        ),
+        contract_type: contractType,
+        strike,
+        expiration,
+        exercise_style: inferExerciseStyle(symbol)
+      });
+    }
+    return { contracts, underlying };
+  }
+  async fetchOptionSnapshot(options) {
+    const firstOrderRows = flattenThetaRows(await requestThetaArray("/v3/option/snapshot/greeks/first_order", {
+      symbol: options.underlying,
+      expiration: "*",
+      format: "json"
+    }));
+    if (firstOrderRows.length === 0) {
       return {
-        rowsInserted: 0,
-        rowsUpdated: 0,
-        rowsSkipped: 0,
-        inputRowCount: mappedRows.length,
-        dateRange,
-        enrichment: {
-          status: "skipped",
-          message: `dry_run=true; no data written. Would import ${mappedRows.length} rows.`
-        }
+        contracts: [],
+        underlying_price: 0,
+        underlying_ticker: options.underlying
       };
     }
-    const { inserted, updated, skipped } = await insertMappedRows(conn, targetTable, mappedRows);
-    await upsertMarketImportMetadata(conn, {
-      source: `import_from_database:${dbPath}`,
-      ticker: normalizedTicker,
-      target_table: targetTable,
-      max_date: dateRange?.max ?? null,
-      enriched_through: null,
-      synced_at: /* @__PURE__ */ new Date()
+    let underlyingPrice = toNumber(firstOrderRows[0].underlying_price) ?? 0;
+    const filtered = firstOrderRows.filter((row) => {
+      const strike = toNumber(row.strike);
+      const expiration = String(row.expiration ?? "");
+      if (strike == null || !expiration) return false;
+      return filterSnapshotContract({
+        symbol: String(row.symbol ?? options.underlying).toUpperCase(),
+        expiration,
+        strike,
+        right: normalizeThetaRight(row.right)
+      }, options);
+    });
+    const oiPromise = requestThetaArray("/v3/option/snapshot/open_interest", {
+      symbol: options.underlying,
+      expiration: "*",
+      format: "json"
+    }).then(flattenThetaRows).catch(() => []);
+    const expirations = [...new Set(filtered.map((row) => String(row.expiration)))];
+    const tradePromises = expirations.map(async (expiration) => {
+      try {
+        const rows = flattenThetaRows(await requestThetaArray("/v3/option/snapshot/trade", {
+          symbol: options.underlying,
+          expiration,
+          format: "json"
+        }));
+        return { expiration, rows };
+      } catch {
+        return { expiration, rows: [] };
+      }
+    });
+    const [oiRows, tradeGroups] = await Promise.all([
+      oiPromise,
+      Promise.all(tradePromises)
+    ]);
+    const openInterestByKey = /* @__PURE__ */ new Map();
+    for (const row of oiRows) {
+      const symbol = String(row.symbol ?? options.underlying).toUpperCase();
+      const expiration = String(row.expiration ?? "");
+      const strike = toNumber(row.strike);
+      if (!expiration || strike == null) continue;
+      openInterestByKey.set(thetaKey({
+        symbol,
+        expiration,
+        strike,
+        right: normalizeThetaRight(row.right)
+      }), toInteger(row.open_interest) ?? 0);
+    }
+    const tradePriceByKey = /* @__PURE__ */ new Map();
+    for (const group of tradeGroups) {
+      for (const row of group.rows) {
+        const symbol = String(row.symbol ?? options.underlying).toUpperCase();
+        const expiration = String(row.expiration ?? "");
+        const strike = toNumber(row.strike);
+        const price = toNumber(row.price);
+        if (!expiration || strike == null || price == null) continue;
+        tradePriceByKey.set(thetaKey({
+          symbol,
+          expiration,
+          strike,
+          right: normalizeThetaRight(row.right)
+        }), price);
+      }
+    }
+    const contracts = filtered.map((row) => {
+      const symbol = String(row.symbol ?? options.underlying).toUpperCase();
+      const expiration = String(row.expiration);
+      const strike = toNumber(row.strike) ?? 0;
+      const contractType = normalizeThetaRight(row.right);
+      const bid = toNumber(row.bid) ?? 0;
+      const ask = toNumber(row.ask) ?? 0;
+      const midpoint = normalizedMidpoint(bid, ask);
+      const rowUnderlying = toNumber(row.underlying_price) ?? 0;
+      if (underlyingPrice === 0 && rowUnderlying > 0) {
+        underlyingPrice = rowUnderlying;
+      }
+      const key = thetaKey({ symbol, expiration, strike, right: contractType });
+      return {
+        ticker: buildOccTicker(
+          symbol,
+          expiration,
+          contractType === "call" ? "C" : "P",
+          strike
+        ),
+        underlying_ticker: options.underlying,
+        underlying_price: rowUnderlying || underlyingPrice,
+        contract_type: contractType,
+        strike,
+        expiration,
+        exercise_style: inferExerciseStyle(symbol),
+        delta: toNumber(row.delta),
+        gamma: null,
+        theta: toNumber(row.theta),
+        vega: toNumber(row.vega),
+        iv: toNumber(row.implied_vol),
+        greeks_source: "thetadata",
+        bid,
+        ask,
+        midpoint,
+        last_price: tradePriceByKey.get(key) ?? null,
+        open_interest: openInterestByKey.get(key) ?? 0,
+        volume: 0,
+        break_even: breakEvenFor(contractType, strike, midpoint)
+      };
+    });
+    contracts.sort((a, b) => {
+      const left = `${a.expiration}|${a.strike.toFixed(3)}|${a.contract_type}`;
+      const right = `${b.expiration}|${b.strike.toFixed(3)}|${b.contract_type}`;
+      return left.localeCompare(right);
     });
-    const enrichment = await triggerEnrichment(conn, normalizedTicker, targetTable, dateRange, skipEnrichment);
     return {
-      rowsInserted: inserted,
-      rowsUpdated: updated,
-      rowsSkipped: skipped,
-      inputRowCount: mappedRows.length,
-      dateRange,
-      enrichment
+      contracts,
+      underlying_price: underlyingPrice,
+      underlying_ticker: options.underlying
     };
-  } finally {
-    try {
-      await conn.run(`DETACH ${EXT_ALIAS}`);
-    } catch {
-    }
   }
+};
+
+// src/utils/market-provider.ts
+var _cached = null;
+function getProvider() {
+  if (_cached) return _cached;
+  const name = (process.env.MARKET_DATA_PROVIDER ?? "massive").toLowerCase();
+  switch (name) {
+    case "massive":
+      _cached = new MassiveProvider();
+      break;
+    case "thetadata":
+      _cached = new ThetaDataProvider();
+      break;
+    default:
+      throw new Error(
+        `Unknown MARKET_DATA_PROVIDER: "${name}". Supported: massive, thetadata`
+      );
+  }
+  return _cached;
 }
-var INDEX_TICKERS2 = /* @__PURE__ */ new Set([
-  "VIX",
-  "VIX9D",
-  "VIX3M",
-  "SPX",
-  "NDX",
-  "RUT",
-  "DJX",
-  "VXN",
-  "OVX",
-  "GVZ"
-]);
-var OCC_TICKER_REGEX = /^[A-Z]+\d{6}[CP]\d{8}$/;
-function detectAssetClass(ticker) {
-  if (INDEX_TICKERS2.has(ticker.toUpperCase())) return "index";
-  if (OCC_TICKER_REGEX.test(ticker.toUpperCase())) return "option";
-  return "stock";
-}
-async function importFromApi(conn, options) {
-  const {
-    ticker,
-    from,
-    to,
-    targetTable,
-    timespan = "minute",
-    multiplier = 1,
-    assetClass,
-    dryRun = false,
-    skipEnrichment = false
-  } = options;
-  const normalizedTicker = normalizeTicker(ticker) ?? ticker.toUpperCase();
-  if (targetTable === "daily") {
-    const resolvedClass2 = assetClass ?? detectAssetClass(normalizedTicker);
-    const rows2 = await getProvider().fetchBars({
-      ticker: normalizedTicker,
-      from,
-      to,
-      timespan: "day",
-      multiplier: 1,
-      assetClass: resolvedClass2
+function _resetProvider() {
+  _cached = null;
+}
+
+// src/utils/market-importer.ts
+var REQUIRED_SCHEMA_FIELDS = {
+  daily: ["date", "open", "high", "low", "close"],
+  context: ["date"],
+  intraday: ["date", "time", "open", "high", "low", "close"],
+  _context_derived: ["date"]
+  // Phase 75: cross-ticker derived fields
+};
+var CONFLICT_TARGETS = {
+  daily: "(ticker, date)",
+  context: "(date)",
+  intraday: "(ticker, date, time)",
+  _context_derived: "(date)"
+  // Phase 75: PK is date only
+};
+function validateColumnMapping(columnMapping, targetTable) {
+  const schemaValues = Object.values(columnMapping);
+  const required = REQUIRED_SCHEMA_FIELDS[targetTable] ?? [];
+  let missing = required.filter((field) => !schemaValues.includes(field));
+  if (targetTable === "intraday" && missing.includes("time") && schemaValues.includes("date")) {
+    missing = missing.filter((f) => f !== "time");
+  }
+  return { valid: missing.length === 0, missingFields: missing };
+}
+function parseCSV(content) {
+  const lines = content.replace(/^\uFEFF/, "").trim().split("\n");
+  if (lines.length < 2) {
+    return { headers: [], rows: [] };
+  }
+  const headers = lines[0].trim().split(",").map((h) => h.trim());
+  const rows = [];
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    const values = line.split(",");
+    const row = {};
+    headers.forEach((h, idx) => {
+      row[h] = values[idx]?.trim() ?? "";
     });
-    const mappedRows2 = rows2.map((row) => ({
-      date: row.date,
-      open: row.open,
-      high: row.high,
-      low: row.low,
-      close: row.close,
-      ticker: row.ticker
-    }));
-    const dateRange2 = computeDateRange(mappedRows2);
-    if (dryRun) {
-      return {
-        rowsInserted: 0,
-        rowsUpdated: 0,
-        rowsSkipped: 0,
-        inputRowCount: mappedRows2.length,
-        dateRange: dateRange2,
-        enrichment: {
-          status: "skipped",
-          message: `dry_run=true; no data written. Would import ${mappedRows2.length} rows.`
-        }
-      };
-    }
-    const { inserted: inserted2, updated: updated2, skipped: skipped2 } = await insertMappedRows(conn, "daily", mappedRows2);
-    await upsertMarketImportMetadata(conn, {
-      source: `import_from_api:daily:${normalizedTicker}`,
-      ticker: normalizedTicker,
-      target_table: "daily",
-      max_date: dateRange2?.max ?? null,
-      enriched_through: null,
-      synced_at: /* @__PURE__ */ new Date()
+    rows.push(row);
+  }
+  return { headers, rows };
+}
+function parseFlexibleDate(value) {
+  const numeric = Number(value);
+  if (!isNaN(numeric) && numeric > 1e8) {
+    return new Date(numeric * 1e3).toLocaleDateString("en-CA", {
+      timeZone: "America/New_York",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
     });
-    const enrichment = await triggerEnrichment(conn, normalizedTicker, "daily", dateRange2, skipEnrichment);
-    return {
-      rowsInserted: inserted2,
-      rowsUpdated: updated2,
-      rowsSkipped: skipped2,
-      inputRowCount: mappedRows2.length,
-      dateRange: dateRange2,
-      enrichment
-    };
   }
-  if (targetTable === "context") {
-    const contextTickers = ["VIX", "VIX9D", "VIX3M"];
-    let totalInserted = 0;
-    let totalUpdated = 0;
-    let totalSkipped = 0;
-    let totalInput = 0;
-    let combinedDateRange = null;
-    for (const ctxTicker of contextTickers) {
-      const bars = await getProvider().fetchBars({ ticker: ctxTicker, from, to, timespan: "day", assetClass: "index" });
-      const mappedRows2 = bars.map((bar) => ({
-        ticker: ctxTicker,
-        date: bar.date,
-        open: bar.open,
-        high: bar.high,
-        low: bar.low,
-        close: bar.close
-      }));
-      totalInput += mappedRows2.length;
-      if (mappedRows2.length === 0) continue;
-      const dateRange2 = computeDateRange(mappedRows2);
-      if (dateRange2) {
-        if (!combinedDateRange) {
-          combinedDateRange = { ...dateRange2 };
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    return value;
+  }
+  return null;
+}
+function parseFlexibleTime(value) {
+  const numeric = Number(value);
+  if (!isNaN(numeric) && numeric > 1e8) {
+    const d = new Date(numeric * 1e3);
+    return d.toLocaleTimeString("en-US", {
+      timeZone: "America/New_York",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false
+    });
+  }
+  if (/^\d{2}:\d{2}$/.test(value)) {
+    return value;
+  }
+  if (/^\d{4}$/.test(value)) {
+    return `${value.slice(0, 2)}:${value.slice(2)}`;
+  }
+  return null;
+}
+function applyColumnMapping(rows, columnMapping, ticker, targetTable) {
+  const normalizedTicker = normalizeTicker(ticker) ?? ticker.toUpperCase();
+  const result = [];
+  for (const row of rows) {
+    const mapped = {};
+    let hasNullDate = false;
+    for (const [sourceCol, schemaCol] of Object.entries(columnMapping)) {
+      const rawValue = row[sourceCol] ?? "";
+      if (schemaCol === "date") {
+        const parsedDate = parseFlexibleDate(rawValue);
+        if (parsedDate === null) {
+          console.warn(`[market-importer] Skipping row with unparseable date value: "${rawValue}"`);
+          hasNullDate = true;
+          break;
+        }
+        mapped[schemaCol] = parsedDate;
+      } else if (schemaCol === "time") {
+        const parsedTime = parseFlexibleTime(rawValue);
+        if (parsedTime === null) {
+          console.warn(`[market-importer] Skipping row with unparseable time value: "${rawValue}"`);
+          hasNullDate = true;
+          break;
+        }
+        mapped[schemaCol] = parsedTime;
+      } else {
+        if (rawValue === "" || rawValue === "NaN" || rawValue === "NA") {
+          mapped[schemaCol] = null;
         } else {
-          if (dateRange2.min < combinedDateRange.min) combinedDateRange.min = dateRange2.min;
-          if (dateRange2.max > combinedDateRange.max) combinedDateRange.max = dateRange2.max;
+          const numVal = parseFloat(rawValue);
+          mapped[schemaCol] = isNaN(numVal) ? rawValue : numVal;
         }
       }
-      if (!dryRun) {
-        const { inserted: inserted2, updated: updated2, skipped: skipped2 } = await insertMappedRows(conn, "daily", mappedRows2);
-        totalInserted += inserted2;
-        totalUpdated += updated2;
-        totalSkipped += skipped2;
-        await upsertMarketImportMetadata(conn, {
-          source: `import_from_api:daily:${ctxTicker}`,
-          ticker: ctxTicker,
-          target_table: "daily",
-          max_date: dateRange2?.max ?? null,
-          enriched_through: null,
-          synced_at: /* @__PURE__ */ new Date()
-        });
-      }
     }
-    if (dryRun) {
-      return {
-        rowsInserted: 0,
-        rowsUpdated: 0,
-        rowsSkipped: 0,
-        inputRowCount: totalInput,
-        dateRange: combinedDateRange,
-        enrichment: {
-          status: "skipped",
-          message: `dry_run=true; no data written. Would import ${totalInput} rows for ${contextTickers.join(", ")} into market.daily.`
+    if (hasNullDate) continue;
+    if (!("date" in mapped)) continue;
+    if (targetTable === "intraday" && !("time" in mapped)) {
+      const dateSourceCol = Object.entries(columnMapping).find(([, schema]) => schema === "date")?.[0];
+      if (dateSourceCol) {
+        const rawDateValue = row[dateSourceCol] ?? "";
+        const numericDate = Number(rawDateValue);
+        if (!isNaN(numericDate) && numericDate > 1e8) {
+          const parsedTime = parseFlexibleTime(rawDateValue);
+          if (parsedTime) {
+            mapped["time"] = parsedTime;
+          }
         }
-      };
+      }
     }
-    let enrichment;
-    if (skipEnrichment) {
-      enrichment = {
-        status: "skipped",
-        message: "skip_enrichment=true; call enrich_market_data to populate computed fields."
-      };
-    } else {
-      try {
-        const tier2Result = await runContextEnrichment(conn);
-        enrichment = {
-          status: tier2Result.status === "complete" || tier2Result.status === "skipped" ? "complete" : "error",
-          message: tier2Result.reason ?? `Tier 2 enrichment: ${tier2Result.fieldsWritten ?? 0} fields`
-        };
-      } catch (e) {
-        enrichment = {
-          status: "error",
-          message: `Tier 2 enrichment failed: ${e instanceof Error ? e.message : String(e)}`
-        };
+    if (targetTable === "daily" || targetTable === "intraday") {
+      mapped["ticker"] = normalizedTicker;
+    }
+    result.push(mapped);
+  }
+  return result;
+}
+async function insertMappedRows(conn, targetTable, mappedRows) {
+  if (mappedRows.length === 0) {
+    return { inserted: 0, updated: 0, skipped: 0 };
+  }
+  const tableName = `market.${targetTable}`;
+  const conflictTarget = CONFLICT_TARGETS[targetTable];
+  const columnSet = /* @__PURE__ */ new Set();
+  for (const row of mappedRows) {
+    for (const key of Object.keys(row)) {
+      columnSet.add(key);
+    }
+  }
+  const columns = Array.from(columnSet);
+  const beforeResult = await conn.runAndReadAll(`SELECT COUNT(*) FROM ${tableName}`);
+  const beforeCount = Number(beforeResult.getRows()[0][0]);
+  const conflictKeys = new Set(
+    CONFLICT_TARGETS[targetTable].replace(/[()]/g, "").split(",").map((s) => s.trim())
+  );
+  const updateCols = columns.filter((c) => !conflictKeys.has(c));
+  const conflictAction = updateCols.length > 0 ? `DO UPDATE SET ${updateCols.map((c) => `${c} = EXCLUDED.${c}`).join(", ")}` : "DO NOTHING";
+  const columnList = columns.join(", ");
+  const BATCH_SIZE = 500;
+  for (let i = 0; i < mappedRows.length; i += BATCH_SIZE) {
+    const batch = mappedRows.slice(i, i + BATCH_SIZE);
+    const values = [];
+    const valuePlaceholders = [];
+    for (const row of batch) {
+      const rowPlaceholders = [];
+      for (const col of columns) {
+        values.push(row[col] ?? null);
+        rowPlaceholders.push(`$${values.length}`);
       }
+      valuePlaceholders.push(`(${rowPlaceholders.join(", ")})`);
+    }
+    const sql = `INSERT INTO ${tableName} (${columnList}) VALUES ${valuePlaceholders.join(", ")} ON CONFLICT ${conflictTarget} ${conflictAction}`;
+    await conn.run(sql, values);
+  }
+  const afterResult = await conn.runAndReadAll(`SELECT COUNT(*) FROM ${tableName}`);
+  const afterCount = Number(afterResult.getRows()[0][0]);
+  const inserted = afterCount - beforeCount;
+  const updated = updateCols.length > 0 ? mappedRows.length - inserted : 0;
+  const skipped = updateCols.length > 0 ? 0 : mappedRows.length - inserted;
+  return { inserted, updated, skipped };
+}
+function computeDateRange(rows) {
+  const dates = [];
+  for (const row of rows) {
+    const d = row["date"];
+    if (typeof d === "string" && d) {
+      dates.push(d);
     }
+  }
+  if (dates.length === 0) return null;
+  dates.sort();
+  return { min: dates[0], max: dates[dates.length - 1] };
+}
+async function triggerEnrichment(conn, ticker, targetTable, _dateRange, skipEnrichment) {
+  if (skipEnrichment) {
     return {
-      rowsInserted: totalInserted,
-      rowsUpdated: totalUpdated,
-      rowsSkipped: totalSkipped,
-      inputRowCount: totalInput,
-      dateRange: combinedDateRange,
-      enrichment
+      status: "skipped",
+      message: "skip_enrichment=true; call enrich_market_data to populate computed fields."
     };
   }
-  const resolvedClass = assetClass ?? detectAssetClass(normalizedTicker);
-  const rows = await getProvider().fetchBars({
-    ticker: normalizedTicker,
-    from,
-    to,
-    timespan,
-    multiplier,
-    assetClass: resolvedClass
-  });
-  const mappedRows = rows.filter((row) => row.time !== void 0).map((row) => ({
-    ticker: row.ticker,
-    date: row.date,
-    time: row.time,
-    open: row.open,
-    high: row.high,
-    low: row.low,
-    close: row.close
-    // volume intentionally omitted — not in intraday schema
-  }));
+  if (targetTable !== "daily") {
+    return {
+      status: "skipped",
+      message: `Enrichment only runs for daily table imports; skipping for ${targetTable}.`
+    };
+  }
+  try {
+    const result = await runEnrichment(conn, ticker, {});
+    const summaryParts = [
+      `Tier 1: ${result.tier1.status}${result.tier1.fieldsWritten !== void 0 ? ` (${result.tier1.fieldsWritten} fields)` : ""}${result.tier1.reason ? ` \u2014 ${result.tier1.reason}` : ""}`,
+      `Tier 2: ${result.tier2.status}${result.tier2.fieldsWritten !== void 0 ? ` (${result.tier2.fieldsWritten} fields)` : ""}${result.tier2.reason ? ` \u2014 ${result.tier2.reason}` : ""}`,
+      `Tier 3: ${result.tier3.status}${result.tier3.reason ? ` \u2014 ${result.tier3.reason}` : ""}`
+    ];
+    return {
+      status: "complete",
+      message: `Enriched ${result.rowsEnriched} rows for ${ticker} through ${result.enrichedThrough ?? "N/A"}. ${summaryParts.join("; ")}`
+    };
+  } catch (err) {
+    return {
+      status: "error",
+      message: `Enrichment failed for ${ticker}: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+async function importMarketCsvFile(conn, options) {
+  const { filePath, ticker, targetTable, columnMapping, dryRun = false, skipEnrichment = false } = options;
+  const validation = validateColumnMapping(columnMapping, targetTable);
+  if (!validation.valid) {
+    throw new Error(
+      `Column mapping missing required fields for market.${targetTable}: ${validation.missingFields.join(", ")}`
+    );
+  }
+  let content;
+  try {
+    content = await fs.readFile(filePath, "utf-8");
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read CSV file at "${filePath}": ${msg}`);
+  }
+  const { rows } = parseCSV(content);
+  if (rows.length === 0) {
+    throw new Error(`CSV file "${filePath}" has no data rows`);
+  }
+  const mappedRows = applyColumnMapping(rows, columnMapping, ticker, targetTable);
+  if (mappedRows.length === 0) {
+    throw new Error(
+      `After applying column mapping, 0 valid rows remain from CSV file "${filePath}"`
+    );
+  }
+  const normalizedTicker = normalizeTicker(ticker) ?? ticker.toUpperCase();
   const dateRange = computeDateRange(mappedRows);
   if (dryRun) {
     return {
@@ -2794,61 +3688,343 @@ async function importFromApi(conn, options) {
       dateRange,
       enrichment: {
         status: "skipped",
-        message: `dry_run=true; no data written. Would import ${mappedRows.length} intraday rows.`
+        message: `dry_run=true; no data written. Would import ${mappedRows.length} rows.`
       }
     };
   }
-  const { inserted, updated, skipped } = await insertMappedRows(conn, "intraday", mappedRows);
+  const { inserted, updated, skipped } = await insertMappedRows(conn, targetTable, mappedRows);
   await upsertMarketImportMetadata(conn, {
-    source: `import_from_api:intraday:${normalizedTicker}`,
+    source: `import_market_csv:${filePath}`,
     ticker: normalizedTicker,
-    target_table: "intraday",
+    target_table: targetTable,
     max_date: dateRange?.max ?? null,
     enriched_through: null,
     synced_at: /* @__PURE__ */ new Date()
   });
+  const enrichment = await triggerEnrichment(conn, normalizedTicker, targetTable, dateRange, skipEnrichment);
   return {
     rowsInserted: inserted,
     rowsUpdated: updated,
     rowsSkipped: skipped,
     inputRowCount: mappedRows.length,
     dateRange,
-    enrichment: {
-      status: "skipped",
-      message: "Enrichment only runs for daily and context table imports; skipping for intraday."
-    }
+    enrichment
   };
 }
-
-// src/utils/analysis-stats.ts
-function round2(n) {
-  return Math.round(n * 100) / 100;
-}
-function computeSliceStats(pls) {
-  if (pls.length === 0) {
+async function importFromDatabase(conn, options) {
+  const { dbPath, query, ticker, targetTable, columnMapping, dryRun = false, skipEnrichment = false } = options;
+  const validation = validateColumnMapping(columnMapping, targetTable);
+  if (!validation.valid) {
+    throw new Error(
+      `Column mapping missing required fields for market.${targetTable}: ${validation.missingFields.join(", ")}`
+    );
+  }
+  const EXT_ALIAS = "ext_import_source";
+  await conn.run(`ATTACH '${dbPath}' AS ${EXT_ALIAS} (READ_ONLY)`);
+  try {
+    const rawResult = await conn.runAndReadAll(query);
+    const resultColumnNames = rawResult.columnNames();
+    const resultRows = rawResult.getRows();
+    const rows = resultRows.map((row) => {
+      const obj = {};
+      resultColumnNames.forEach((colName, idx) => {
+        const val = row[idx];
+        obj[colName] = val === null || val === void 0 ? "" : String(val);
+      });
+      return obj;
+    });
+    const mappedRows = applyColumnMapping(rows, columnMapping, ticker, targetTable);
+    const normalizedTicker = normalizeTicker(ticker) ?? ticker.toUpperCase();
+    const dateRange = computeDateRange(mappedRows);
+    if (dryRun) {
+      return {
+        rowsInserted: 0,
+        rowsUpdated: 0,
+        rowsSkipped: 0,
+        inputRowCount: mappedRows.length,
+        dateRange,
+        enrichment: {
+          status: "skipped",
+          message: `dry_run=true; no data written. Would import ${mappedRows.length} rows.`
+        }
+      };
+    }
+    const { inserted, updated, skipped } = await insertMappedRows(conn, targetTable, mappedRows);
+    await upsertMarketImportMetadata(conn, {
+      source: `import_from_database:${dbPath}`,
+      ticker: normalizedTicker,
+      target_table: targetTable,
+      max_date: dateRange?.max ?? null,
+      enriched_through: null,
+      synced_at: /* @__PURE__ */ new Date()
+    });
+    const enrichment = await triggerEnrichment(conn, normalizedTicker, targetTable, dateRange, skipEnrichment);
     return {
-      tradeCount: 0,
-      wins: 0,
-      losses: 0,
-      winRate: 0,
-      totalPl: 0,
-      avgPl: 0,
-      avgWin: 0,
-      avgLoss: 0,
-      profitFactor: 0
+      rowsInserted: inserted,
+      rowsUpdated: updated,
+      rowsSkipped: skipped,
+      inputRowCount: mappedRows.length,
+      dateRange,
+      enrichment
     };
+  } finally {
+    try {
+      await conn.run(`DETACH ${EXT_ALIAS}`);
+    } catch {
+    }
   }
-  const winPls = pls.filter((p) => p > 0);
-  const lossPls = pls.filter((p) => p <= 0);
-  const wins = winPls.length;
-  const losses = lossPls.length;
-  const winRate = wins / pls.length * 100;
-  const totalPl = pls.reduce((sum, p) => sum + p, 0);
-  const avgPl = totalPl / pls.length;
-  const avgWin = wins > 0 ? winPls.reduce((s, p) => s + p, 0) / wins : 0;
-  const avgLoss = losses > 0 ? lossPls.reduce((s, p) => s + p, 0) / losses : 0;
-  const grossWins = winPls.reduce((s, p) => s + p, 0);
-  const grossLosses = Math.abs(lossPls.reduce((s, p) => s + p, 0));
+}
+var INDEX_TICKERS2 = /* @__PURE__ */ new Set([
+  "VIX",
+  "VIX9D",
+  "VIX3M",
+  "SPX",
+  "NDX",
+  "RUT",
+  "DJX",
+  "VXN",
+  "OVX",
+  "GVZ"
+]);
+var OCC_TICKER_REGEX = /^[A-Z]+\d{6}[CP]\d{8}$/;
+function detectAssetClass(ticker) {
+  if (INDEX_TICKERS2.has(ticker.toUpperCase())) return "index";
+  if (OCC_TICKER_REGEX.test(ticker.toUpperCase())) return "option";
+  return "stock";
+}
+async function importFromApi(conn, options) {
+  const {
+    ticker,
+    from,
+    to,
+    targetTable,
+    timespan = "minute",
+    multiplier = 1,
+    assetClass,
+    dryRun = false,
+    skipEnrichment = false
+  } = options;
+  const normalizedTicker = normalizeTicker(ticker) ?? ticker.toUpperCase();
+  if (targetTable === "daily") {
+    const resolvedClass2 = assetClass ?? detectAssetClass(normalizedTicker);
+    const rows2 = await getProvider().fetchBars({
+      ticker: normalizedTicker,
+      from,
+      to,
+      timespan: "day",
+      multiplier: 1,
+      assetClass: resolvedClass2
+    });
+    const mappedRows2 = rows2.map((row) => ({
+      date: row.date,
+      open: row.open,
+      high: row.high,
+      low: row.low,
+      close: row.close,
+      ticker: row.ticker
+    }));
+    const dateRange2 = computeDateRange(mappedRows2);
+    if (dryRun) {
+      return {
+        rowsInserted: 0,
+        rowsUpdated: 0,
+        rowsSkipped: 0,
+        inputRowCount: mappedRows2.length,
+        dateRange: dateRange2,
+        enrichment: {
+          status: "skipped",
+          message: `dry_run=true; no data written. Would import ${mappedRows2.length} rows.`
+        }
+      };
+    }
+    const { inserted: inserted2, updated: updated2, skipped: skipped2 } = await insertMappedRows(conn, "daily", mappedRows2);
+    await upsertMarketImportMetadata(conn, {
+      source: `import_from_api:daily:${normalizedTicker}`,
+      ticker: normalizedTicker,
+      target_table: "daily",
+      max_date: dateRange2?.max ?? null,
+      enriched_through: null,
+      synced_at: /* @__PURE__ */ new Date()
+    });
+    const enrichment = await triggerEnrichment(conn, normalizedTicker, "daily", dateRange2, skipEnrichment);
+    return {
+      rowsInserted: inserted2,
+      rowsUpdated: updated2,
+      rowsSkipped: skipped2,
+      inputRowCount: mappedRows2.length,
+      dateRange: dateRange2,
+      enrichment
+    };
+  }
+  if (targetTable === "context") {
+    const contextTickers = ["VIX", "VIX9D", "VIX3M"];
+    let totalInserted = 0;
+    let totalUpdated = 0;
+    let totalSkipped = 0;
+    let totalInput = 0;
+    let combinedDateRange = null;
+    for (const ctxTicker of contextTickers) {
+      const bars = await getProvider().fetchBars({ ticker: ctxTicker, from, to, timespan: "day", assetClass: "index" });
+      const mappedRows2 = bars.map((bar) => ({
+        ticker: ctxTicker,
+        date: bar.date,
+        open: bar.open,
+        high: bar.high,
+        low: bar.low,
+        close: bar.close
+      }));
+      totalInput += mappedRows2.length;
+      if (mappedRows2.length === 0) continue;
+      const dateRange2 = computeDateRange(mappedRows2);
+      if (dateRange2) {
+        if (!combinedDateRange) {
+          combinedDateRange = { ...dateRange2 };
+        } else {
+          if (dateRange2.min < combinedDateRange.min) combinedDateRange.min = dateRange2.min;
+          if (dateRange2.max > combinedDateRange.max) combinedDateRange.max = dateRange2.max;
+        }
+      }
+      if (!dryRun) {
+        const { inserted: inserted2, updated: updated2, skipped: skipped2 } = await insertMappedRows(conn, "daily", mappedRows2);
+        totalInserted += inserted2;
+        totalUpdated += updated2;
+        totalSkipped += skipped2;
+        await upsertMarketImportMetadata(conn, {
+          source: `import_from_api:daily:${ctxTicker}`,
+          ticker: ctxTicker,
+          target_table: "daily",
+          max_date: dateRange2?.max ?? null,
+          enriched_through: null,
+          synced_at: /* @__PURE__ */ new Date()
+        });
+      }
+    }
+    if (dryRun) {
+      return {
+        rowsInserted: 0,
+        rowsUpdated: 0,
+        rowsSkipped: 0,
+        inputRowCount: totalInput,
+        dateRange: combinedDateRange,
+        enrichment: {
+          status: "skipped",
+          message: `dry_run=true; no data written. Would import ${totalInput} rows for ${contextTickers.join(", ")} into market.daily.`
+        }
+      };
+    }
+    let enrichment;
+    if (skipEnrichment) {
+      enrichment = {
+        status: "skipped",
+        message: "skip_enrichment=true; call enrich_market_data to populate computed fields."
+      };
+    } else {
+      try {
+        const tier2Result = await runContextEnrichment(conn);
+        enrichment = {
+          status: tier2Result.status === "complete" || tier2Result.status === "skipped" ? "complete" : "error",
+          message: tier2Result.reason ?? `Tier 2 enrichment: ${tier2Result.fieldsWritten ?? 0} fields`
+        };
+      } catch (e) {
+        enrichment = {
+          status: "error",
+          message: `Tier 2 enrichment failed: ${e instanceof Error ? e.message : String(e)}`
+        };
+      }
+    }
+    return {
+      rowsInserted: totalInserted,
+      rowsUpdated: totalUpdated,
+      rowsSkipped: totalSkipped,
+      inputRowCount: totalInput,
+      dateRange: combinedDateRange,
+      enrichment
+    };
+  }
+  const resolvedClass = assetClass ?? detectAssetClass(normalizedTicker);
+  const rows = await getProvider().fetchBars({
+    ticker: normalizedTicker,
+    from,
+    to,
+    timespan,
+    multiplier,
+    assetClass: resolvedClass
+  });
+  const mappedRows = rows.filter((row) => row.time !== void 0).map((row) => ({
+    ticker: row.ticker,
+    date: row.date,
+    time: row.time,
+    open: row.open,
+    high: row.high,
+    low: row.low,
+    close: row.close
+    // volume intentionally omitted — not in intraday schema
+  }));
+  const dateRange = computeDateRange(mappedRows);
+  if (dryRun) {
+    return {
+      rowsInserted: 0,
+      rowsUpdated: 0,
+      rowsSkipped: 0,
+      inputRowCount: mappedRows.length,
+      dateRange,
+      enrichment: {
+        status: "skipped",
+        message: `dry_run=true; no data written. Would import ${mappedRows.length} intraday rows.`
+      }
+    };
+  }
+  const { inserted, updated, skipped } = await insertMappedRows(conn, "intraday", mappedRows);
+  await upsertMarketImportMetadata(conn, {
+    source: `import_from_api:intraday:${normalizedTicker}`,
+    ticker: normalizedTicker,
+    target_table: "intraday",
+    max_date: dateRange?.max ?? null,
+    enriched_through: null,
+    synced_at: /* @__PURE__ */ new Date()
+  });
+  return {
+    rowsInserted: inserted,
+    rowsUpdated: updated,
+    rowsSkipped: skipped,
+    inputRowCount: mappedRows.length,
+    dateRange,
+    enrichment: {
+      status: "skipped",
+      message: "Enrichment only runs for daily and context table imports; skipping for intraday."
+    }
+  };
+}
+
+// src/utils/analysis-stats.ts
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function computeSliceStats(pls) {
+  if (pls.length === 0) {
+    return {
+      tradeCount: 0,
+      wins: 0,
+      losses: 0,
+      winRate: 0,
+      totalPl: 0,
+      avgPl: 0,
+      avgWin: 0,
+      avgLoss: 0,
+      profitFactor: 0
+    };
+  }
+  const winPls = pls.filter((p) => p > 0);
+  const lossPls = pls.filter((p) => p <= 0);
+  const wins = winPls.length;
+  const losses = lossPls.length;
+  const winRate = wins / pls.length * 100;
+  const totalPl = pls.reduce((sum, p) => sum + p, 0);
+  const avgPl = totalPl / pls.length;
+  const avgWin = wins > 0 ? winPls.reduce((s, p) => s + p, 0) / wins : 0;
+  const avgLoss = losses > 0 ? lossPls.reduce((s, p) => s + p, 0) / losses : 0;
+  const grossWins = winPls.reduce((s, p) => s + p, 0);
+  const grossLosses = Math.abs(lossPls.reduce((s, p) => s + p, 0));
   let profitFactor;
   if (grossLosses > 0) {
     profitFactor = grossWins / grossLosses;
@@ -4100,330 +5276,194 @@ async function handleRegimeAllocationAdvisor(input, baseDir) {
             allHiddenEdges.push({
               strategyName: profile.strategyName,
               regime: label,
-              winRate: stats.winRate,
-              overallWinRate: overallStats.winRate
-            });
-          } else {
-            classification = "neutral";
-          }
-        }
-        regimePerformance[label] = { stats, isExpected, classification };
-      }
-      const allocationPct = profile.positionSizing?.liveAllocationPct ?? profile.positionSizing?.allocationPct;
-      strategies.push({
-        strategyName: profile.strategyName,
-        blockId: profile.blockId,
-        structureType: profile.structureType,
-        underlying: profile.underlying ?? void 0,
-        allocationPct,
-        expectedRegimes: profile.expectedRegimes,
-        regimePerformance,
-        tradeCount: trades.length,
-        matchedToMarket: matched.length,
-        unmatchedCount
-      });
-    } catch (err) {
-      warnings.push(
-        `Error processing strategy '${profile.strategyName}' (block: ${profile.blockId}): ${err.message}`
-      );
-    }
-  }
-  const regimeOverview = {};
-  for (const [label, pls] of Object.entries(regimeAggPls)) {
-    let strategiesActive = 0;
-    for (const strategy of strategies) {
-      if (strategy.regimePerformance[label]) {
-        strategiesActive++;
-      }
-    }
-    regimeOverview[label] = {
-      strategiesActive,
-      totalTrades: pls.length,
-      combinedStats: computeSliceStats(pls)
-    };
-  }
-  const summary = {
-    totalStrategies: profiles.length,
-    profiled: strategies.length,
-    skippedNoRegimes,
-    skippedNoMarket,
-    thesisViolations: allThesisViolations,
-    hiddenEdges: allHiddenEdges
-  };
-  const summaryText = `Regime allocation advisor: ${strategies.length}/${profiles.length} strategies analyzed. ${allThesisViolations.length} thesis violation(s), ${allHiddenEdges.length} hidden edge(s). ` + (skippedNoRegimes > 0 ? `${skippedNoRegimes} skipped (no expectedRegimes). ` : "") + (skippedNoMarket > 0 ? `${skippedNoMarket} skipped (no market data). ` : "");
-  return createToolOutput(summaryText, {
-    strategies,
-    summary,
-    regimeOverview,
-    warnings,
-    profileUpgradeHints
-  });
-}
-
-// src/utils/trade-replay.ts
-function markPrice(bar) {
-  if (bar.bid != null && bar.ask != null && (bar.bid > 0 || bar.ask > 0)) {
-    return (bar.bid + bar.ask) / 2;
-  }
-  return (bar.high + bar.low) / 2;
-}
-function findNearestTimestamp(sortedTimestamps, target, toleranceSec = 60) {
-  if (sortedTimestamps.length === 0) return void 0;
-  const targetMin = timestampToMinutes(target);
-  if (targetMin === null) return void 0;
-  let lo = 0, hi = sortedTimestamps.length - 1;
-  let bestIdx = 0;
-  let bestDiff = Infinity;
-  while (lo <= hi) {
-    const mid = lo + hi >>> 1;
-    const midMin = timestampToMinutes(sortedTimestamps[mid]);
-    if (midMin === null) {
-      lo = mid + 1;
-      continue;
-    }
-    const diff = Math.abs(midMin - targetMin);
-    if (diff < bestDiff) {
-      bestDiff = diff;
-      bestIdx = mid;
-    }
-    if (midMin < targetMin) lo = mid + 1;
-    else if (midMin > targetMin) hi = mid - 1;
-    else break;
-  }
-  return bestDiff <= toleranceSec / 60 ? sortedTimestamps[bestIdx] : void 0;
-}
-function timestampToMinutes(ts) {
-  const timePart = ts.split(" ")[1];
-  if (!timePart) return null;
-  const [h, m] = timePart.split(":").map(Number);
-  if (isNaN(h) || isNaN(m)) return null;
-  return h * 60 + m;
-}
-var COMPACT_LEG_RE = /^([A-Z]+)\s+(\d+(?:\.\d+)?)\s*(C|P)$/i;
-var COMPACT_NO_ROOT_RE = /^(\d+(?:\.\d+)?)\s*(C|P)$/i;
-var VERBOSE_LEG_RE = /^([A-Z]+)\s+\w+\s+(\d+(?:\.\d+)?)\s+(Call|Put)$/i;
-var OO_LEG_RE = /^(\d+)\s+(\w+)\s+(\d+)\s+(\d+(?:\.\d+)?)\s+(C|P)\s+(STO|BTO|STC|BTC)\s+(\d+(?:\.\d+)?)$/i;
-function parseLegsString(legsStr) {
-  if (!legsStr || legsStr.trim() === "") {
-    throw new Error('Cannot parse legs "" \u2014 use hypothetical mode with explicit strikes');
-  }
-  if (legsStr.includes("|")) {
-    return parseOOLegs(legsStr);
-  }
-  const parts = legsStr.includes("/") ? legsStr.split("/") : [legsStr];
-  const legs = [];
-  let inheritedRoot = "";
-  for (let i = 0; i < parts.length; i++) {
-    const raw = parts[i].trim();
-    let root;
-    let strike;
-    let type;
-    const compactMatch = raw.match(COMPACT_LEG_RE);
-    if (compactMatch) {
-      root = compactMatch[1].toUpperCase();
-      strike = parseFloat(compactMatch[2]);
-      type = compactMatch[3].toUpperCase();
-    } else {
-      const noRootMatch = raw.match(COMPACT_NO_ROOT_RE);
-      if (noRootMatch && inheritedRoot) {
-        root = inheritedRoot;
-        strike = parseFloat(noRootMatch[1]);
-        type = noRootMatch[2].toUpperCase();
-      } else {
-        const verboseMatch = raw.match(VERBOSE_LEG_RE);
-        if (verboseMatch) {
-          root = verboseMatch[1].toUpperCase();
-          strike = parseFloat(verboseMatch[2]);
-          type = verboseMatch[3].toLowerCase() === "call" ? "C" : "P";
-        } else {
-          throw new Error(
-            `Cannot parse legs "${legsStr}" \u2014 use hypothetical mode with explicit strikes`
-          );
-        }
-      }
-    }
-    if (i === 0) inheritedRoot = root;
-    const quantity = i === 0 ? 1 : i % 2 === 0 ? 1 : -1;
-    legs.push({ root, strike, type, quantity });
-  }
-  return legs;
-}
-function parseOOLegs(legsStr) {
-  const segments = legsStr.split("|").map((s) => s.trim());
-  const legs = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const seg of segments) {
-    const match = seg.match(OO_LEG_RE);
-    if (!match) {
-      throw new Error(
-        `Cannot parse OO leg segment "${seg}" \u2014 use hypothetical mode with explicit strikes`
-      );
-    }
-    const contracts = parseInt(match[1], 10);
-    const month = match[2];
-    const day = match[3];
-    const strike = parseFloat(match[4]);
-    const type = match[5].toUpperCase();
-    const direction = match[6].toUpperCase();
-    const price = parseFloat(match[7]);
-    const key = `${month}${day}:${strike}${type}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    legs.push({
-      root: "",
-      // OO format doesn't include root — caller provides via trade's ticker field
-      strike,
-      type,
-      quantity: direction === "BTO" ? 1 : -1,
-      entryPrice: price,
-      contracts,
-      expiryHint: `${month} ${day}`
-    });
-  }
-  return legs;
-}
-function buildOccTicker(root, expiry, type, strike) {
-  const [yyyy, mm, dd] = expiry.split("-");
-  const yy = yyyy.slice(2);
-  const strikeInt = Math.round(strike * 1e3);
-  const strikePadded = String(strikeInt).padStart(8, "0");
-  return `${root}${yy}${mm}${dd}${type}${strikePadded}`;
-}
-function computeStrategyPnlPath(legs, barsByLeg, greeksConfig) {
-  if (legs.length === 0 || barsByLeg.length === 0) return [];
-  for (const bars of barsByLeg) {
-    if (bars.length === 0) return [];
-  }
-  const legMaps = barsByLeg.map((bars) => {
-    const map = /* @__PURE__ */ new Map();
-    for (const bar of bars) {
-      const ts = `${bar.date} ${bar.time ?? ""}`.trim();
-      map.set(ts, bar);
-    }
-    return map;
-  });
-  const allTimestamps = /* @__PURE__ */ new Set();
-  for (const bars of barsByLeg) {
-    for (const bar of bars) {
-      allTimestamps.add(`${bar.date} ${bar.time ?? ""}`.trim());
-    }
-  }
-  const sortedTimestamps = [...allTimestamps].sort();
-  const path = [];
-  const lastBar = new Array(legs.length).fill(void 0);
-  for (const ts of sortedTimestamps) {
-    let complete = true;
-    const legPrices = [];
-    let strategyPnl = 0;
-    for (let i = 0; i < legs.length; i++) {
-      const bar = legMaps[i].get(ts);
-      if (bar) {
-        lastBar[i] = bar;
-      }
-      const effective = bar ?? lastBar[i];
-      if (!effective) {
-        complete = false;
-        break;
-      }
-      const hl2 = markPrice(effective);
-      legPrices.push(hl2);
-      strategyPnl += (hl2 - legs[i].entryPrice) * legs[i].quantity * legs[i].multiplier;
-    }
-    if (complete) {
-      const point = { timestamp: ts, strategyPnl, legPrices };
-      if (greeksConfig) {
-        let underlyingPrice = greeksConfig.underlyingPrices.get(ts);
-        if (underlyingPrice === void 0 && greeksConfig.sortedTimestamps) {
-          const nearest = findNearestTimestamp(greeksConfig.sortedTimestamps, ts, 60);
-          if (nearest) underlyingPrice = greeksConfig.underlyingPrices.get(nearest);
-        }
-        if (underlyingPrice === void 0) {
-          const dateOnly = ts.split(" ")[0];
-          underlyingPrice = greeksConfig.underlyingPrices.get(dateOnly);
-        }
-        if (underlyingPrice !== void 0) {
-          const legGreeksArr = [];
-          let netDelta = 0, netGamma = 0, netTheta = 0, netVega = 0;
-          let allNull = true;
-          for (let j = 0; j < legs.length; j++) {
-            const legCfg = greeksConfig.legs[j];
-            if (!legCfg || !legCfg.expiryDate) {
-              legGreeksArr.push({ delta: null, gamma: null, theta: null, vega: null, iv: null });
-              continue;
-            }
-            const dateStr = ts.split(" ")[0];
-            const timePart = ts.split(" ")[1] ?? "09:30";
-            const [eyy, emm, edd] = legCfg.expiryDate.split("-").map(Number);
-            const [byy, bmm, bdd] = dateStr.split("-").map(Number);
-            const [hh, min] = timePart.split(":").map(Number);
-            const expiryMs = new Date(eyy, emm - 1, edd).getTime() + 16 * 60 * 60 * 1e3;
-            const barMs = new Date(byy, bmm - 1, bdd).getTime() + (hh * 60 + min) * 60 * 1e3;
-            const dte = (expiryMs - barMs) / (1e3 * 60 * 60 * 24);
-            if (dte <= 0) {
-              legGreeksArr.push({ delta: null, gamma: null, theta: null, vega: null, iv: null });
-              continue;
-            }
-            const g = computeLegGreeks(
-              legPrices[j],
-              underlyingPrice,
-              legCfg.strike,
-              dte,
-              legCfg.type,
-              greeksConfig.riskFreeRate,
-              greeksConfig.dividendYield
-            );
-            legGreeksArr.push(g);
-            if (g.delta !== null) {
-              allNull = false;
-              const weight = legs[j].quantity * legs[j].multiplier / 100;
-              netDelta += g.delta * weight;
-              netGamma += g.gamma * weight;
-              netTheta += g.theta * weight;
-              netVega += g.vega * weight;
-            }
+              winRate: stats.winRate,
+              overallWinRate: overallStats.winRate
+            });
+          } else {
+            classification = "neutral";
           }
-          point.legGreeks = legGreeksArr;
-          point.netDelta = allNull ? null : netDelta;
-          point.netGamma = allNull ? null : netGamma;
-          point.netTheta = allNull ? null : netTheta;
-          point.netVega = allNull ? null : netVega;
-          const ivpDate = ts.split(" ")[0];
-          point.ivp = greeksConfig.ivpByDate?.get(ivpDate) ?? null;
         }
+        regimePerformance[label] = { stats, isExpected, classification };
       }
-      path.push(point);
+      const allocationPct = profile.positionSizing?.liveAllocationPct ?? profile.positionSizing?.allocationPct;
+      strategies.push({
+        strategyName: profile.strategyName,
+        blockId: profile.blockId,
+        structureType: profile.structureType,
+        underlying: profile.underlying ?? void 0,
+        allocationPct,
+        expectedRegimes: profile.expectedRegimes,
+        regimePerformance,
+        tradeCount: trades.length,
+        matchedToMarket: matched.length,
+        unmatchedCount
+      });
+    } catch (err) {
+      warnings.push(
+        `Error processing strategy '${profile.strategyName}' (block: ${profile.blockId}): ${err.message}`
+      );
     }
   }
-  return path;
-}
-function computeReplayMfeMae(pnlPath) {
-  if (pnlPath.length === 0) {
-    return { mfe: 0, mae: 0, mfeTimestamp: "", maeTimestamp: "" };
-  }
-  let mfe = pnlPath[0].strategyPnl;
-  let mae = pnlPath[0].strategyPnl;
-  let mfeTimestamp = pnlPath[0].timestamp;
-  let maeTimestamp = pnlPath[0].timestamp;
-  for (let i = 1; i < pnlPath.length; i++) {
-    const pnl = pnlPath[i].strategyPnl;
-    if (pnl > mfe) {
-      mfe = pnl;
-      mfeTimestamp = pnlPath[i].timestamp;
-    }
-    if (pnl < mae) {
-      mae = pnl;
-      maeTimestamp = pnlPath[i].timestamp;
+  const regimeOverview = {};
+  for (const [label, pls] of Object.entries(regimeAggPls)) {
+    let strategiesActive = 0;
+    for (const strategy of strategies) {
+      if (strategy.regimePerformance[label]) {
+        strategiesActive++;
+      }
     }
+    regimeOverview[label] = {
+      strategiesActive,
+      totalTrades: pls.length,
+      combinedStats: computeSliceStats(pls)
+    };
   }
-  return { mfe, mae, mfeTimestamp, maeTimestamp };
+  const summary = {
+    totalStrategies: profiles.length,
+    profiled: strategies.length,
+    skippedNoRegimes,
+    skippedNoMarket,
+    thesisViolations: allThesisViolations,
+    hiddenEdges: allHiddenEdges
+  };
+  const summaryText = `Regime allocation advisor: ${strategies.length}/${profiles.length} strategies analyzed. ${allThesisViolations.length} thesis violation(s), ${allHiddenEdges.length} hidden edge(s). ` + (skippedNoRegimes > 0 ? `${skippedNoRegimes} skipped (no expectedRegimes). ` : "") + (skippedNoMarket > 0 ? `${skippedNoMarket} skipped (no market data). ` : "");
+  return createToolOutput(summaryText, {
+    strategies,
+    summary,
+    regimeOverview,
+    warnings,
+    profileUpgradeHints
+  });
 }
 
 // src/tools/replay.ts
 import { z as z5 } from "zod";
 
 // src/utils/bar-cache.ts
+function getDataTier() {
+  const tier = (process.env.MASSIVE_DATA_TIER ?? "").toLowerCase();
+  if (tier === "quotes" || tier === "trades" || tier === "ohlc") return tier;
+  if (process.env.MASSIVE_QUOTES_ENABLED === "true" || process.env.MASSIVE_QUOTES_ENABLED === "1") return "quotes";
+  return "ohlc";
+}
 function quotesEnabled() {
-  return process.env.MASSIVE_QUOTES_ENABLED === "true" || process.env.MASSIVE_QUOTES_ENABLED === "1";
+  return getDataTier() === "quotes";
+}
+function mergeQuoteBars(tradeBars, quotesMap, ticker) {
+  if (quotesMap.size === 0) return tradeBars;
+  const tradeBarKeys = /* @__PURE__ */ new Set();
+  for (const bar of tradeBars) {
+    if (bar.time) tradeBarKeys.add(`${bar.date} ${bar.time}`);
+  }
+  const syntheticBars = [];
+  for (const [key, quote] of quotesMap) {
+    if (tradeBarKeys.has(key)) continue;
+    if (quote.bid <= 0 && quote.ask <= 0) continue;
+    const mid = (quote.bid + quote.ask) / 2;
+    const [date, time] = key.split(" ");
+    if (!date || !time) continue;
+    syntheticBars.push({
+      date,
+      time,
+      open: mid,
+      high: mid,
+      low: mid,
+      close: mid,
+      bid: quote.bid,
+      ask: quote.ask,
+      volume: 0,
+      ticker
+    });
+  }
+  if (syntheticBars.length === 0) {
+    for (const bar of tradeBars) {
+      if (bar.time && bar.bid == null && bar.ask == null) {
+        const quote = quotesMap.get(`${bar.date} ${bar.time}`);
+        if (quote) {
+          bar.bid = quote.bid;
+          bar.ask = quote.ask;
+        }
+      }
+    }
+    return tradeBars;
+  }
+  for (const bar of tradeBars) {
+    if (bar.time && bar.bid == null && bar.ask == null) {
+      const quote = quotesMap.get(`${bar.date} ${bar.time}`);
+      if (quote) {
+        bar.bid = quote.bid;
+        bar.ask = quote.ask;
+      }
+    }
+  }
+  const merged = [...tradeBars, ...syntheticBars];
+  merged.sort((a, b) => {
+    const ka = `${a.date} ${a.time ?? ""}`;
+    const kb = `${b.date} ${b.time ?? ""}`;
+    return ka < kb ? -1 : ka > kb ? 1 : 0;
+  });
+  return merged;
+}
+async function enrichWithQuotes(bars, ticker, from, to) {
+  const provider = getProvider();
+  if (!provider.fetchQuotes) return { bars, newBars: [] };
+  let quotesMap;
+  try {
+    quotesMap = await provider.fetchQuotes(ticker, from, to);
+  } catch {
+    return { bars, newBars: [] };
+  }
+  if (quotesMap.size === 0) return { bars, newBars: [] };
+  const merged = mergeQuoteBars(bars, quotesMap, ticker);
+  const originalKeys = new Set(bars.map((b) => `${b.date} ${b.time}`));
+  const added = merged.filter((b) => !originalKeys.has(`${b.date} ${b.time}`));
+  return { bars: merged, newBars: added };
+}
+async function cacheNewBars(newBars, ticker, conn, baseDir) {
+  if (newBars.length === 0) return;
+  try {
+    const c = conn ?? await getConnection(baseDir ?? ".");
+    const escaped = ticker.replace(/'/g, "''");
+    const values = newBars.filter((b) => b.time).map(
+      (b) => `('${escaped}', '${b.date}', '${b.time}', ${b.open}, ${b.high}, ${b.low}, ${b.close}, ${b.bid ?? "NULL"}, ${b.ask ?? "NULL"})`
+    );
+    for (let i = 0; i < values.length; i += 500) {
+      const chunk = values.slice(i, i + 500);
+      await c.run(
+        `INSERT OR REPLACE INTO ${getIntradayWriteTable()} (ticker, date, time, open, high, low, close, bid, ask) VALUES ${chunk.join(", ")}`
+      );
+    }
+  } catch {
+  }
+}
+async function readCachedBars(opts) {
+  const { ticker, from, to, conn } = opts;
+  try {
+    const escaped = ticker.replace(/'/g, "''");
+    const cached = await conn.runAndReadAll(
+      `SELECT open, high, low, close, bid, ask, time, date
+       FROM market.intraday
+       WHERE ticker = '${escaped}'
+         AND date >= '${from}'
+         AND date <= '${to}'
+       ORDER BY date, time`
+    );
+    const rows = cached.getRows();
+    return rows.map((row) => ({
+      open: Number(row[0]),
+      high: Number(row[1]),
+      low: Number(row[2]),
+      close: Number(row[3]),
+      bid: row[4] != null ? Number(row[4]) : void 0,
+      ask: row[5] != null ? Number(row[5]) : void 0,
+      time: String(row[6]),
+      date: String(row[7]),
+      ticker,
+      volume: 0
+    }));
+  } catch {
+    return [];
+  }
 }
 async function fetchBarsWithCache(opts) {
   const { ticker, from, to, timespan, assetClass, baseDir } = opts;
@@ -4439,7 +5479,13 @@ async function fetchBarsWithCache(opts) {
        ORDER BY date, time`
     );
     const rows = cached.getRows();
-    if (rows.length > 0) {
+    const cachedDates = new Set(rows.map((r) => String(r[7])));
+    const calendarDays = Math.round(
+      (new Date(to).getTime() - new Date(from).getTime()) / 864e5
+    );
+    const expectedTradingDays = Math.max(1, Math.ceil(calendarDays * 5 / 7));
+    const isPartialHit = rows.length > 0 && from !== to && cachedDates.size < expectedTradingDays * 0.7;
+    if (rows.length > 0 && (!isPartialHit || opts.skipQuotes)) {
       const bars2 = rows.map((row) => ({
         open: Number(row[0]),
         high: Number(row[1]),
@@ -4453,41 +5499,14 @@ async function fetchBarsWithCache(opts) {
         volume: 0
         // market.intraday has no volume column
       }));
-      const missingQuotes = assetClass === "option" && quotesEnabled() && bars2.some((b) => b.bid == null && b.ask == null);
-      if (missingQuotes) {
-        try {
-          const provider = getProvider();
-          if (provider.fetchQuotes) {
-            const quotesMap = await provider.fetchQuotes(ticker, from, to);
-            if (quotesMap.size > 0) {
-              const updates = [];
-              for (const bar of bars2) {
-                if (bar.time != null) {
-                  const key = `${bar.date} ${bar.time}`;
-                  const quote = quotesMap.get(key);
-                  if (quote != null) {
-                    bar.bid = quote.bid;
-                    bar.ask = quote.ask;
-                    updates.push(
-                      `('${escaped}', '${bar.date}', '${bar.time}', ${quote.bid}, ${quote.ask})`
-                    );
-                  }
-                }
-              }
-              if (updates.length > 0) {
-                const updateConn = opts.conn ?? await getConnection(baseDir ?? ".");
-                for (let i = 0; i < updates.length; i += 500) {
-                  const chunk = updates.slice(i, i + 500);
-                  await updateConn.run(
-                    `UPDATE market.intraday AS m SET bid = v.bid, ask = v.ask
-                     FROM (VALUES ${chunk.join(", ")}) AS v(ticker, date, time, bid, ask)
-                     WHERE m.ticker = v.ticker AND m.date = v.date AND m.time = v.time`
-                  );
-                }
-              }
-            }
-          }
-        } catch {
+      if (assetClass === "option" && quotesEnabled() && !opts.skipQuotes) {
+        const dates = new Set(bars2.map((b) => b.date));
+        const barsPerDay = dates.size > 0 ? bars2.length / dates.size : 0;
+        const hasQuotes = bars2.some((b) => b.bid != null && b.ask != null);
+        if (barsPerDay < 200 || !hasQuotes) {
+          const { bars: enriched, newBars } = await enrichWithQuotes(bars2, ticker, from, to);
+          await cacheNewBars(newBars, ticker, opts.conn, baseDir);
+          return enriched;
         }
       }
       return bars2;
@@ -4507,6 +5526,25 @@ async function fetchBarsWithCache(opts) {
     return [];
   }
   if (bars.length === 0) return [];
+  if (assetClass === "option" && quotesEnabled() && !opts.skipQuotes) {
+    const { bars: enriched } = await enrichWithQuotes(bars, ticker, from, to);
+    const allBars = enriched;
+    try {
+      const conn = opts.conn ?? await getConnection(baseDir ?? ".");
+      const escaped = ticker.replace(/'/g, "''");
+      const values = allBars.filter((b) => b.time).map(
+        (b) => `('${escaped}', '${b.date}', '${b.time}', ${b.open}, ${b.high}, ${b.low}, ${b.close}, ${b.bid ?? "NULL"}, ${b.ask ?? "NULL"})`
+      );
+      for (let i = 0; i < values.length; i += 500) {
+        const chunk = values.slice(i, i + 500);
+        await conn.run(
+          `INSERT OR REPLACE INTO ${getIntradayWriteTable()} (ticker, date, time, open, high, low, close, bid, ask) VALUES ${chunk.join(", ")}`
+        );
+      }
+    } catch {
+    }
+    return enriched;
+  }
   try {
     const conn = opts.conn ?? await getConnection(baseDir ?? ".");
     const escaped = ticker.replace(/'/g, "''");
@@ -4516,13 +5554,88 @@ async function fetchBarsWithCache(opts) {
     for (let i = 0; i < values.length; i += 500) {
       const chunk = values.slice(i, i + 500);
       await conn.run(
-        `INSERT OR REPLACE INTO market.intraday (ticker, date, time, open, high, low, close, bid, ask) VALUES ${chunk.join(", ")}`
+        `INSERT OR REPLACE INTO ${getIntradayWriteTable()} (ticker, date, time, open, high, low, close, bid, ask) VALUES ${chunk.join(", ")}`
       );
     }
   } catch {
   }
   return bars;
 }
+async function fetchEntryBarsForCandidates(tickers, entryDate, conn) {
+  const result = /* @__PURE__ */ new Map();
+  if (tickers.length === 0) return result;
+  const escapedTickers = tickers.map((t) => `'${t.replace(/'/g, "''")}'`);
+  try {
+    const cached = await conn.runAndReadAll(
+      `SELECT ticker, open, high, low, close, bid, ask, time, date
+       FROM market.intraday
+       WHERE ticker IN (${escapedTickers.join(", ")})
+         AND date = '${entryDate}'
+       ORDER BY ticker, time`
+    );
+    const rows = cached.getRows();
+    for (const row of rows) {
+      const ticker = String(row[0]);
+      const bar = {
+        ticker,
+        open: Number(row[1]),
+        high: Number(row[2]),
+        low: Number(row[3]),
+        close: Number(row[4]),
+        bid: row[5] != null ? Number(row[5]) : void 0,
+        ask: row[6] != null ? Number(row[6]) : void 0,
+        time: String(row[7]),
+        date: String(row[8]),
+        volume: 0
+      };
+      const existing = result.get(ticker);
+      if (existing) existing.push(bar);
+      else result.set(ticker, [bar]);
+    }
+  } catch {
+  }
+  return result;
+}
+async function fetchBarsForLegsBulk(legs, fromDate, conn) {
+  const result = /* @__PURE__ */ new Map();
+  if (legs.length === 0) return result;
+  const maxExpiry = legs.reduce((max, l) => l.expiration > max ? l.expiration : max, fromDate);
+  const escaped = legs.map((l) => `'${l.ticker.replace(/'/g, "''")}'`).join(", ");
+  try {
+    const cached = await conn.runAndReadAll(
+      `SELECT ticker, open, high, low, close, bid, ask, time, date
+       FROM market.intraday
+       WHERE ticker IN (${escaped})
+         AND date >= '${fromDate}'
+         AND date <= '${maxExpiry}'
+       ORDER BY ticker, date, time`
+    );
+    for (const row of cached.getRows()) {
+      const ticker = String(row[0]);
+      const bar = {
+        ticker,
+        open: Number(row[1]),
+        high: Number(row[2]),
+        low: Number(row[3]),
+        close: Number(row[4]),
+        bid: row[5] != null ? Number(row[5]) : void 0,
+        ask: row[6] != null ? Number(row[6]) : void 0,
+        time: String(row[7]),
+        date: String(row[8]),
+        volume: 0
+      };
+      const existing = result.get(ticker);
+      if (existing) existing.push(bar);
+      else result.set(ticker, [bar]);
+    }
+  } catch {
+    await Promise.all(legs.map(async (leg) => {
+      const bars = await readCachedBars({ ticker: leg.ticker, from: fromDate, to: leg.expiration, conn });
+      if (bars.length > 0) result.set(leg.ticker, bars);
+    }));
+  }
+  return result;
+}
 
 // src/tools/replay.ts
 var replayTradeSchema = z5.object({
@@ -4555,6 +5668,9 @@ var replayTradeSchema = z5.object({
   ),
   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: z5.boolean().default(false).describe(
+    "Skip NBBO quote enrichment for option bars. Faster, but uses cached trade bars / HL2 marks."
   )
 });
 var MONTH_MAP = {
@@ -4581,15 +5697,18 @@ function resolveOODateRange(parsedLegs, tradeYear, tradeOpenDate) {
   const hints = parsedLegs.filter((l) => l.expiryHint).map((l) => resolveOOExpiryHint(l.expiryHint, tradeYear));
   if (hints.length === 0) return null;
   const sorted = [...hints].sort();
-  const minDate = sorted[0];
   const maxDate = sorted[sorted.length - 1];
-  if (minDate === maxDate) {
-    return { from: tradeOpenDate, to: maxDate };
-  }
-  return { from: minDate, to: maxDate };
+  return { from: tradeOpenDate, to: maxDate };
 }
 async function handleReplayTrade(params, baseDir, injectedConn) {
-  const { legs: inputLegs, block_id, trade_index, multiplier, close_at } = params;
+  const {
+    legs: inputLegs,
+    block_id,
+    trade_index,
+    multiplier,
+    close_at,
+    skip_quotes
+  } = params;
   let { open_date, close_date } = params;
   let tradeCloseTimestamp;
   let replayLegs;
@@ -4611,7 +5730,7 @@ async function handleReplayTrade(params, baseDir, injectedConn) {
       `SELECT legs, premium, date_opened, date_closed, ticker, num_contracts, time_closed
        FROM trades.trade_data
        WHERE block_id = '${block_id.replace(/'/g, "''")}'
-       ORDER BY date_opened
+       ORDER BY date_opened, rowid
        LIMIT 1 OFFSET ${trade_index}`
     );
     const rows = result.getRows();
@@ -4683,7 +5802,8 @@ async function handleReplayTrade(params, baseDir, injectedConn) {
       timespan: "minute",
       assetClass: "option",
       conn: injectedConn,
-      baseDir
+      baseDir,
+      skipQuotes: skip_quotes
     });
     if (bars.length > 0) return bars;
     const rootMatch = occTicker.match(/^([A-Z]+)/);
@@ -4698,7 +5818,8 @@ async function handleReplayTrade(params, baseDir, injectedConn) {
         timespan: "minute",
         assetClass: "option",
         conn: injectedConn,
-        baseDir
+        baseDir,
+        skipQuotes: skip_quotes
       });
       if (fallbackBars.length > 0) {
         const leg = replayLegs.find((l) => l.occTicker === occTicker);
@@ -5077,8 +6198,8 @@ function decomposeGreeks(config) {
     let stepResidual = 0;
     const groupVegaAccum = legGroups ? legGroups.map(() => 0) : void 0;
     const legCount = Math.min(legs.length, cur.legPrices?.length ?? 0, next.legPrices?.length ?? 0);
-    const S1 = underlyingPrices?.get(cur.timestamp);
-    const S2 = underlyingPrices?.get(next.timestamp);
+    const S1 = cur.underlyingPrice ?? underlyingPrices?.get(cur.timestamp);
+    const S2 = next.underlyingPrice ?? underlyingPrices?.get(next.timestamp);
     for (let j = 0; j < legCount; j++) {
       const positionSize = legs[j].quantity * legs[j].multiplier;
       const legActualChange = ((next.legPrices?.[j] ?? 0) - (cur.legPrices?.[j] ?? 0)) * positionSize;
@@ -5731,7 +6852,8 @@ var decomposeGreeksSchema = 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")
+  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",
@@ -5782,7 +6904,8 @@ async function handleAnalyzeExitTriggers(params, baseDir, injectedConn) {
       close_date,
       multiplier,
       format: "full",
-      close_at: "trade"
+      close_at: "trade",
+      skip_quotes: false
     },
     baseDir,
     injectedConn
@@ -5883,7 +7006,8 @@ async function handleDecomposeGreeks(params, baseDir, injectedConn) {
     close_date,
     multiplier,
     leg_groups,
-    format
+    format,
+    skip_quotes
   } = params;
   const replayResult = await handleReplayTrade(
     {
@@ -5894,7 +7018,8 @@ async function handleDecomposeGreeks(params, baseDir, injectedConn) {
       close_date,
       multiplier,
       format: "full",
-      close_at: "trade"
+      close_at: "trade",
+      skip_quotes
     },
     baseDir,
     injectedConn
@@ -5906,16 +7031,11 @@ async function handleDecomposeGreeks(params, baseDir, injectedConn) {
       "No greeks data available. Ensure MASSIVE_API_KEY is set and underlying price data exists."
     );
   }
-  const underlyingTicker = extractUnderlyingTicker(replayLegs[0]?.occTicker ?? "");
-  let underlyingPrices;
-  if (pnlPath.length > 0 && underlyingTicker) {
-    const firstDate = pnlPath[0].timestamp.slice(0, 10);
-    const lastDate = pnlPath[pnlPath.length - 1].timestamp.slice(0, 10);
-    underlyingPrices = await fetchPriceMap(
-      underlyingTicker,
-      firstDate,
-      lastDate
-    );
+  const underlyingPrices = /* @__PURE__ */ new Map();
+  for (const point of pnlPath) {
+    if (point.underlyingPrice !== void 0) {
+      underlyingPrices.set(point.timestamp, point.underlyingPrice);
+    }
   }
   const legGroupDefs = leg_groups?.map((g) => ({
     label: g.label,
@@ -5942,7 +7062,7 @@ async function handleDecomposeGreeks(params, baseDir, injectedConn) {
   const result = decomposeGreeks({
     pnlPath,
     legs: replayLegs,
-    underlyingPrices,
+    underlyingPrices: underlyingPrices.size > 0 ? underlyingPrices : void 0,
     legGroups: legGroupDefs,
     legPricingInputs,
     riskFreeRate: 0.045,
@@ -6321,7 +7441,8 @@ async function handleBatchExitAnalysis(params, baseDir, injectedConn) {
             trade_index: tradeIdx,
             multiplier,
             format: "full",
-            close_at: "trade"
+            close_at: "trade",
+            skip_quotes: false
           },
           baseDir,
           injectedConn
@@ -6398,6 +7519,308 @@ async function handleBatchExitAnalysis(params, baseDir, injectedConn) {
   }
   return result;
 }
+
+// src/utils/quote-enricher.ts
+function shouldSkipEnrichment(barCount, densityThreshold = 200) {
+  return barCount >= densityThreshold;
+}
+function buildEnrichmentPlan(input) {
+  if (!input.providerSupportsQuotes) return [];
+  if (input.tickers.length === 0) return [];
+  const plan = [];
+  for (const tickerSpec of input.tickers) {
+    const dates = expandDateRange(tickerSpec.fromDate, tickerSpec.toDate);
+    for (const date of dates) {
+      const key = `${tickerSpec.ticker}:${date}`;
+      const existingBarCount = input.existingCoverage.get(key) ?? 0;
+      if (!shouldSkipEnrichment(existingBarCount)) {
+        plan.push({
+          ticker: tickerSpec.ticker,
+          date,
+          existingBarCount
+        });
+      }
+    }
+  }
+  return plan;
+}
+function expandDateRange(fromDate, toDate) {
+  const dates = [];
+  const from = /* @__PURE__ */ new Date(fromDate + "T00:00:00Z");
+  const to = /* @__PURE__ */ new Date(toDate + "T00:00:00Z");
+  const current = new Date(from);
+  while (current <= to) {
+    dates.push(current.toISOString().slice(0, 10));
+    current.setUTCDate(current.getUTCDate() + 1);
+  }
+  return dates;
+}
+
+// src/tools/greeks-attribution.ts
+import { z as z9 } from "zod";
+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 COLLAPSE_MAP = {
+  charm: "delta",
+  vanna: "vega"
+};
+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) {
+    const targetName = !detailed && COLLAPSE_MAP[f.factor] || f.factor;
+    totals.set(targetName, (totals.get(targetName) ?? 0) + f.totalPnl);
+  }
+  return totals;
+}
+function computeAttribution(totals, totalPnl, grossAttributionFlow) {
+  const entries = [];
+  for (const [factor, pnl] of totals) {
+    entries.push({
+      factor,
+      pnl: Math.round(pnl * 100) / 100,
+      pct: totalPnl !== 0 ? Math.round(pnl / totalPnl * 1e3) / 10 : 0,
+      ...grossAttributionFlow && grossAttributionFlow !== 0 ? { pct_of_gross: Math.round(pnl / grossAttributionFlow * 1e3) / 10 } : {}
+    });
+  }
+  entries.sort((a, b) => {
+    const ai = FACTOR_ORDER.indexOf(a.factor);
+    const bi = FACTOR_ORDER.indexOf(b.factor);
+    return (ai === -1 ? 99 : ai) - (bi === -1 ? 99 : bi);
+  });
+  return entries;
+}
+function computeGrossAttributionFlow(totals) {
+  let gross = 0;
+  for (const pnl of totals.values()) {
+    gross += Math.abs(pnl);
+  }
+  return gross;
+}
+function assessPrecision(residualPnl, totalPnl) {
+  if (totalPnl === 0) return { precision: "high" };
+  const residualPct = Math.abs(residualPnl / totalPnl) * 100;
+  if (residualPct > 25) {
+    return {
+      precision: "low",
+      hint: `Residual is ${Math.round(residualPct)}%. Re-run with skip_quotes=false for NBBO-based pricing.`
+    };
+  }
+  return { precision: "high" };
+}
+async function handleGetGreeksAttribution(params, baseDir, injectedConn) {
+  const { block_id, mode, trade_index, skip_quotes, detailed, strategy } = params;
+  if (mode === "instance") {
+    if (trade_index == null) {
+      throw new Error("trade_index is required for instance mode");
+    }
+    return handleInstanceMode(block_id, trade_index, skip_quotes, detailed, baseDir, injectedConn);
+  }
+  return handleSummaryMode(block_id, skip_quotes, detailed, strategy, baseDir, injectedConn);
+}
+async function handleSummaryMode(block_id, skip_quotes, detailed, strategy, baseDir, injectedConn) {
+  const conn = injectedConn ?? await getConnection(baseDir);
+  const selectedTradesQuery = strategy ? `SELECT trade_index, pl
+       FROM (
+         SELECT ROW_NUMBER() OVER (ORDER BY date_opened, rowid) - 1 AS trade_index, pl, strategy
+         FROM trades.trade_data
+         WHERE block_id = $1
+       )
+       WHERE LOWER(strategy) = LOWER($2)
+       ORDER BY trade_index` : `SELECT ROW_NUMBER() OVER (ORDER BY date_opened, rowid) - 1 AS trade_index, pl
+       FROM trades.trade_data
+       WHERE block_id = $1
+       ORDER BY trade_index`;
+  const selectedTradesParams = strategy ? [block_id, strategy] : [block_id];
+  const selectedTradesResult = await conn.runAndReadAll(selectedTradesQuery, selectedTradesParams);
+  const selectedTrades = selectedTradesResult.getRows().map((row) => ({
+    tradeIndex: Number(row[0] ?? 0),
+    actualPl: Number(row[1] ?? 0)
+  }));
+  const totalTrades = selectedTrades.length;
+  if (totalTrades === 0) {
+    throw new Error(
+      strategy ? `No trades found for block "${block_id}" with strategy "${strategy}"` : `No trades found for block "${block_id}"`
+    );
+  }
+  const accumulated = /* @__PURE__ */ new Map();
+  let decomposed = 0;
+  let skipped = 0;
+  let actualTotalPnl = 0;
+  let markTotalPnl = 0;
+  const BATCH_SIZE = 10;
+  for (let batch = 0; batch < totalTrades; batch += BATCH_SIZE) {
+    const batchEnd = Math.min(batch + BATCH_SIZE, totalTrades);
+    const promises = [];
+    for (let i = batch; i < batchEnd; i++) {
+      const trade = selectedTrades[i];
+      promises.push(
+        handleDecomposeGreeks(
+          {
+            block_id,
+            trade_index: trade.tradeIndex,
+            format: "summary",
+            multiplier: 100,
+            skip_quotes
+          },
+          baseDir,
+          injectedConn
+        ).then((result) => {
+          for (const factor of result.factors) {
+            accumulated.set(factor.factor, (accumulated.get(factor.factor) ?? 0) + factor.totalPnl);
+          }
+          actualTotalPnl += trade.actualPl;
+          markTotalPnl += result.totalPnlChange;
+          decomposed++;
+        }).catch(() => {
+          skipped++;
+        })
+      );
+    }
+    await Promise.allSettled(promises);
+  }
+  if (decomposed === 0) {
+    return {
+      block_id,
+      trades_decomposed: 0,
+      trades_skipped: skipped,
+      trades_total: totalTrades,
+      total_pnl: 0,
+      mark_total_pnl: 0,
+      execution_edge: 0,
+      gross_attribution_flow: 0,
+      attribution: [],
+      precision: "low",
+      hint: "No trades could be decomposed. Ensure market data is cached for the trade dates."
+    };
+  }
+  const collapsed = collapseFactors(
+    [...accumulated.entries()].map(([factor, totalPnl]) => ({
+      factor,
+      totalPnl,
+      pctOfTotal: 0,
+      steps: []
+    })),
+    detailed
+  );
+  const grossAttributionFlow = computeGrossAttributionFlow(collapsed);
+  const attribution = computeAttribution(collapsed, actualTotalPnl, grossAttributionFlow);
+  const residualPnl = collapsed.get("residual") ?? 0;
+  const precisionBase = grossAttributionFlow !== 0 ? grossAttributionFlow : markTotalPnl;
+  const { precision, hint } = assessPrecision(residualPnl, precisionBase);
+  const executionEdge = actualTotalPnl - markTotalPnl;
+  const hints = [];
+  if (hint) hints.push(hint);
+  const edgeRatio = Math.abs(actualTotalPnl) > 0.01 ? Math.abs(executionEdge) / Math.abs(actualTotalPnl) : 0;
+  if (edgeRatio > 3) {
+    hints.push(
+      `Execution edge is ${Math.round(edgeRatio)}x the actual P&L \u2014 mark-to-market pricing may be based on sparse or low-quality data. ` + (skip_quotes ? `Re-run with skip_quotes=false for NBBO-based marks.` : `Consider whether intraday bar coverage is sufficient for this date range.`)
+    );
+  }
+  return {
+    block_id,
+    trades_decomposed: decomposed,
+    trades_skipped: skipped,
+    trades_total: totalTrades,
+    total_pnl: Math.round(actualTotalPnl * 100) / 100,
+    mark_total_pnl: Math.round(markTotalPnl * 100) / 100,
+    execution_edge: Math.round(executionEdge * 100) / 100,
+    gross_attribution_flow: Math.round(grossAttributionFlow * 100) / 100,
+    attribution,
+    precision,
+    ...hints.length > 0 ? { hint: hints.join(" ") } : {}
+  };
+}
+async function handleInstanceMode(block_id, trade_index, skip_quotes, detailed, baseDir, injectedConn) {
+  const conn = injectedConn ?? await getConnection(baseDir);
+  const tradeResult = await conn.runAndReadAll(
+    `SELECT date_opened, date_closed, pl FROM trades.trade_data
+     WHERE block_id = $1
+     ORDER BY date_opened, rowid
+     LIMIT 1 OFFSET $2`,
+    [block_id, trade_index]
+  );
+  const tradeRows = tradeResult.getRows();
+  if (tradeRows.length === 0) {
+    throw new Error(`Trade index ${trade_index} not found in block "${block_id}"`);
+  }
+  const tradeDate = String(tradeRows[0][0] ?? "");
+  const closeDate = String(tradeRows[0][1] ?? tradeDate);
+  const actualPnl = Number(tradeRows[0][2] ?? 0);
+  const result = await handleDecomposeGreeks(
+    {
+      block_id,
+      trade_index,
+      format: "full",
+      multiplier: 100,
+      skip_quotes
+    },
+    baseDir,
+    injectedConn
+  );
+  const stepCount = result.stepCount;
+  const datesResult = await conn.runAndReadAll(
+    `SELECT DISTINCT date FROM market.intraday
+     WHERE date >= $1 AND date <= $2
+     ORDER BY date`,
+    [tradeDate, closeDate]
+  );
+  const tradingDates = datesResult.getRows().map((r) => String(r[0]));
+  const getStepDate = (i) => i < tradingDates.length ? tradingDates[i] : `day-${i}`;
+  const factorSteps = /* @__PURE__ */ new Map();
+  for (const f of result.factors) {
+    factorSteps.set(f.factor, f.steps);
+  }
+  const steps = [];
+  for (let i = 0; i <= stepCount; i++) {
+    const entry = {
+      date: getStepDate(i),
+      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),
+      residual: getStepValue(factorSteps, "residual", i, 0)
+    };
+    if (factorSteps.has("time_and_vol")) {
+      entry.time_and_vol = getStepValue(factorSteps, "time_and_vol", i, 0);
+    }
+    if (detailed) {
+      entry.charm = factorSteps.get("charm")?.[i] ?? 0;
+      entry.vanna = factorSteps.get("vanna")?.[i] ?? 0;
+    }
+    steps.push(entry);
+  }
+  const collapsed = collapseFactors(result.factors, detailed);
+  const grossAttributionFlow = computeGrossAttributionFlow(collapsed);
+  const attribution = computeAttribution(collapsed, actualPnl, grossAttributionFlow);
+  const executionEdge = actualPnl - result.totalPnlChange;
+  const filteredSteps = filterSparseSteps(steps);
+  return {
+    block_id,
+    trade_index,
+    trade_date: tradeDate,
+    total_pnl: Math.round(actualPnl * 100) / 100,
+    mark_total_pnl: Math.round(result.totalPnlChange * 100) / 100,
+    execution_edge: Math.round(executionEdge * 100) / 100,
+    gross_attribution_flow: Math.round(grossAttributionFlow * 100) / 100,
+    steps: filteredSteps,
+    attribution
+  };
+}
+function filterSparseSteps(steps) {
+  return steps.filter(
+    (s) => s.delta !== 0 || s.gamma !== 0 || s.theta !== 0 || s.vega !== 0 || s.residual !== 0 || (s.time_and_vol ?? 0) !== 0 || (s.charm ?? 0) !== 0 || (s.vanna ?? 0) !== 0
+  );
+}
+function getStepValue(factorSteps, factor, index, collapsedAddition) {
+  return Math.round(((factorSteps.get(factor)?.[index] ?? 0) + collapsedAddition) * 100) / 100;
+}
 export {
   BACHELIER_DTE_THRESHOLD,
   CLOSE_KNOWN_FIELDS,
@@ -6425,6 +7848,7 @@ export {
   analyzeExitTriggers,
   analyzeExitTriggersSchema,
   analyzeStructureFitSchema,
+  assessPrecision,
   bachelierDelta,
   bachelierGamma,
   bachelierPrice,
@@ -6436,6 +7860,7 @@ export {
   bsPrice,
   bsTheta,
   bsVega,
+  buildEnrichmentPlan,
   buildFilterPredicate,
   buildLookaheadFreeQuery,
   buildOccTicker,
@@ -6447,10 +7872,13 @@ export {
   classifyTrendDirection,
   classifyVolRegime,
   closeConnection,
+  collapseFactors,
   computeATR,
   computeAggregateStats,
+  computeAttribution,
   computeConsecutiveDays,
   computeEMA,
+  computeGrossAttributionFlow,
   computeIVP,
   computeIVR,
   computeIntradayTimingFields,
@@ -6472,13 +7900,18 @@ export {
   discoverCsvFiles,
   ensureProfilesSchema,
   evaluateTrigger,
+  fetchBarsForLegsBulk,
   fetchBarsWithCache,
+  fetchEntryBarsForCandidates,
   filterByDateRange,
   filterByStrategy,
   filterDailyLogsByDateRange,
+  filterSparseSteps,
   findNearestTimestamp,
   fromMassiveTicker,
   getConnection,
+  getDataTier,
+  getGreeksAttributionSchema,
   getMarketImportMetadata,
   getOptionSnapshotSchema,
   getProfile,
@@ -6489,6 +7922,7 @@ export {
   handleBatchExitAnalysis,
   handleDecomposeGreeks,
   handleDeleteProfile,
+  handleGetGreeksAttribution,
   handleGetOptionSnapshot,
   handleGetStrategyProfile,
   handleListProfiles,
@@ -6513,17 +7947,20 @@ export {
   markPrice,
   massiveTimestampToETDate,
   massiveTimestampToETTime,
+  mergeQuoteBars,
   nanosToETMinuteKey,
   parseLegsString,
   pdf,
   performTailRiskAnalysis,
   portfolioStructureMapSchema,
   profileStrategySchema,
+  readCachedBars,
   regimeAllocationAdvisorSchema,
   replayTradeSchema,
   resolveOODateRange,
   runContextEnrichment,
   runEnrichment,
+  shouldSkipEnrichment,
   solveIV,
   solveNormalIV,
   syncAllBlocks,