tradeblocks-mcp 3.0.2 → 3.3.1

package/src/db/connection.ts

@@ -73,7 +73,7 @@ const isWindows = process.platform === "win32";
  * a DuckDB-compatible string like "90GB".
  */
 function defaultMemoryLimit(): string {
-  const totalGB = os.totalmem() / (1024 ** 3);
+  const totalGB = os.totalmem() / 1024 ** 3;
   const targetGB = Math.max(1, Math.floor(totalGB * 0.75));
   return `${targetGB}GB`;
 }
@@ -121,7 +121,12 @@ async function getProcessParentPid(pid: number): Promise<number | null> {
   try {
     if (isWindows) {
       const { stdout } = await execFileAsync("wmic", [
-        "process", "where", `ProcessId=${pid}`, "get", "ParentProcessId", "/value",
+        "process",
+        "where",
+        `ProcessId=${pid}`,
+        "get",
+        "ParentProcessId",
+        "/value",
       ]);
       const match = stdout.match(/ParentProcessId=(\d+)/);
       if (!match) return null;
@@ -140,7 +145,12 @@ async function getProcessCommand(pid: number): Promise<string | null> {
   try {
     if (isWindows) {
       const { stdout } = await execFileAsync("wmic", [
-        "process", "where", `ProcessId=${pid}`, "get", "CommandLine", "/value",
+        "process",
+        "where",
+        `ProcessId=${pid}`,
+        "get",
+        "CommandLine",
+        "/value",
       ]);
       const match = stdout.match(/CommandLine=(.+)/);
       if (!match) return null;
@@ -169,7 +179,7 @@ async function waitForProcessExit(pid: number, timeoutMs: number): Promise<boole
 async function tryRecoverLockByTerminatingStaleProcess(
   errorMessage: string,
   dbPath: string,
-  forceRecovery: boolean
+  forceRecovery: boolean,
 ): Promise<boolean> {
   const lockHolderPid = parseLockHolderPid(errorMessage);
   if (!lockHolderPid || lockHolderPid === process.pid) {
@@ -192,7 +202,8 @@ async function tryRecoverLockByTerminatingStaleProcess(
     command.includes("packages\\mcp-server\\server\\index.js");
   // Normalize command paths for consistent comparison (Windows backslashes → forward slashes)
   const normalizedCommand = command.replace(/\\/g, "/");
-  const targetsSameDb = normalizedCommand.includes(normalizedDbPath) || normalizedCommand.includes(normalizedDbDir);
+  const targetsSameDb =
+    normalizedCommand.includes(normalizedDbPath) || normalizedCommand.includes(normalizedDbDir);
 
   if (!isTradeblocksProcess || !targetsSameDb) {
     return false;
@@ -203,9 +214,7 @@ async function tryRecoverLockByTerminatingStaleProcess(
   // Windows: child keeps original PPID even after parent dies — check if parent is still alive.
   // Only kill non-orphaned processes if forceRecovery is explicitly enabled.
   const ppid = await getProcessParentPid(lockHolderPid);
-  const orphaned = isWindows
-    ? (ppid !== null && !isProcessAlive(ppid))
-    : ppid === 1;
+  const orphaned = isWindows ? ppid !== null && !isProcessAlive(ppid) : ppid === 1;
   if (!orphaned && !forceRecovery) {
     return false;
   }
@@ -221,12 +230,12 @@ async function tryRecoverLockByTerminatingStaleProcess(
 
   const exited = await waitForProcessExit(
     lockHolderPid,
-    Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 1500
+    Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 1500,
   );
 
   if (exited) {
     console.error(
-      `Recovered DuckDB lock at ${dbPath} by stopping ${reason} tradeblocks-mcp process PID ${lockHolderPid}.`
+      `Recovered DuckDB lock at ${dbPath} by stopping ${reason} tradeblocks-mcp process PID ${lockHolderPid}.`,
     );
   }
 
@@ -267,7 +276,7 @@ function resolveMarketDbPath(dataDir: string): string {
 async function attachMarketDb(
   conn: DuckDBConnection,
   marketDbPath: string,
-  mode: "read_write" | "read_only"
+  mode: "read_write" | "read_only",
 ): Promise<void> {
   await fs.mkdir(path.dirname(marketDbPath), { recursive: true });
   const readOnlyClause = mode === "read_only" ? " (READ_ONLY)" : "";
@@ -278,9 +287,17 @@ async function attachMarketDb(
     const msg = error instanceof Error ? error.message : String(error);
     if (msg.includes("corrupt") || msg.includes("Invalid") || msg.includes("cannot open")) {
       console.error(`market.duckdb appears corrupted at ${marketDbPath}. Recreating.`);
-      try { await fs.unlink(marketDbPath); } catch { /* file may not exist */ }
+      try {
+        await fs.unlink(marketDbPath);
+      } catch {
+        /* file may not exist */
+      }
       // Also try removing WAL file
-      try { await fs.unlink(marketDbPath + ".wal"); } catch { /* ignore */ }
+      try {
+        await fs.unlink(marketDbPath + ".wal");
+      } catch {
+        /* ignore */
+      }
       await conn.run(`ATTACH '${escapedPath}' AS market${readOnlyClause}`);
     } else {
       throw new Error(`Failed to attach market.duckdb at ${marketDbPath}: ${msg}`);
@@ -303,7 +320,7 @@ async function detachMarketDb(conn: DuckDBConnection): Promise<void> {
 async function openReadWriteConnection(
   dbPath: string,
   threads: string,
-  memoryLimit: string
+  memoryLimit: string,
 ): Promise<DuckDBConnection> {
   // enable_external_access must be "true" at instance creation to allow ATTACH of local files.
   // DuckDB 1.4+ blocks all filesystem operations (including local ATTACH) when set to "false"
@@ -373,7 +390,10 @@ async function openReadWriteConnection(
     const blocksDir = (await import("../sync/index.ts")).getBlocksDir(dataRoot);
     await migrateMetadataToJson(connection, dataRoot, blocksDir);
   } catch (err) {
-    console.warn("[json-migration] Migration failed (non-fatal):", err instanceof Error ? err.message : err);
+    console.warn(
+      "[json-migration] Migration failed (non-fatal):",
+      err instanceof Error ? err.message : err,
+    );
   }
 
   connectionMode = "read_write";
@@ -384,7 +404,7 @@ async function openReadWriteConnection(
 async function openReadOnlyConnection(
   dbPath: string,
   threads: string,
-  memoryLimit: string
+  memoryLimit: string,
 ): Promise<DuckDBConnection> {
   // enable_external_access must be "true" at instance creation to allow ATTACH.
   // We do NOT call SET enable_external_access = false because it also blocks local
@@ -405,11 +425,19 @@ async function openReadOnlyConnection(
 
 function resetConnectionState(): void {
   if (connection) {
-    try { connection.closeSync(); } catch { /* non-fatal */ }
+    try {
+      connection.closeSync();
+    } catch {
+      /* non-fatal */
+    }
   }
   connection = null;
   if (instance) {
-    try { instance.closeSync(); } catch { /* non-fatal */ }
+    try {
+      instance.closeSync();
+    } catch {
+      /* non-fatal */
+    }
   }
   instance = null;
   connectionMode = null;
@@ -469,7 +497,11 @@ export async function getConnection(dataDir: string): Promise<DuckDBConnection>
     // Lock recovery: auto-kill orphaned tradeblocks-mcp processes (PPID=1) that hold the lock.
     // With DUCKDB_LOCK_RECOVERY=true, also kills non-orphaned holders (force mode).
     if (isLockError(errorMessage)) {
-      const recovered = await tryRecoverLockByTerminatingStaleProcess(errorMessage, dbPath, forceRecovery);
+      const recovered = await tryRecoverLockByTerminatingStaleProcess(
+        errorMessage,
+        dbPath,
+        forceRecovery,
+      );
       if (recovered) {
         // DuckDB file locks may linger briefly after process death — retry with backoff
         for (let attempt = 0; attempt < 3; attempt++) {
@@ -484,7 +516,7 @@ export async function getConnection(dataDir: string): Promise<DuckDBConnection>
             if (attempt < 2 && isLockError(retryMsg)) continue;
             resetConnectionState();
             throw new Error(
-              `Failed to initialize DuckDB at ${dbPath} after lock recovery: ${retryMsg}`
+              `Failed to initialize DuckDB at ${dbPath} after lock recovery: ${retryMsg}`,
             );
           }
         }
@@ -503,7 +535,7 @@ export async function getConnection(dataDir: string): Promise<DuckDBConnection>
       throw new Error(
         `DuckDB database appears corrupted at ${dbPath}. ` +
           `Please delete the file manually and restart. ` +
-          `Original error: ${errorMessage}`
+          `Original error: ${errorMessage}`,
       );
     }
 
@@ -520,8 +552,16 @@ export async function getConnection(dataDir: string): Promise<DuckDBConnection>
  */
 export async function closeConnection(): Promise<void> {
   if (connection) {
-    try { await connection.run("CHECKPOINT"); } catch { /* non-fatal */ }
-    try { await detachMarketDb(connection); } catch { /* non-fatal, log debug */ }
+    try {
+      await connection.run("CHECKPOINT");
+    } catch {
+      /* non-fatal */
+    }
+    try {
+      await detachMarketDb(connection);
+    } catch {
+      /* non-fatal, log debug */
+    }
     try {
       // closeSync is the synchronous close method for DuckDB connections
       connection.closeSync();
@@ -536,7 +576,11 @@ export async function closeConnection(): Promise<void> {
   // Close the DuckDB instance to release the file lock.
   // Without this, the native handle leaks until GC and blocks subsequent RW opens.
   if (instance) {
-    try { instance.closeSync(); } catch { /* non-fatal */ }
+    try {
+      instance.closeSync();
+    } catch {
+      /* non-fatal */
+    }
   }
   instance = null;
   connectionMode = null;
@@ -554,7 +598,7 @@ export async function closeConnection(): Promise<void> {
  */
 export async function upgradeToReadWrite(
   dataDir: string,
-  options?: { fallbackToReadOnly?: boolean }
+  options?: { fallbackToReadOnly?: boolean },
 ): Promise<DuckDBConnection> {
   if (connectionMode === "read_write" && connection) return connection;
   await closeConnection();
@@ -599,9 +643,12 @@ export async function upgradeToReadWrite(
     }
   }
 
-  throw lastError || new Error(
-    "Cannot acquire DuckDB write lock. Another process holds it. " +
-    "Kill other tradeblocks-mcp processes or restart Claude Code."
+  throw (
+    lastError ||
+    new Error(
+      "Cannot acquire DuckDB write lock. Another process holds it. " +
+        "Kill other tradeblocks-mcp processes or restart Claude Code.",
+    )
   );
 }
 
@@ -666,9 +713,7 @@ export interface MarketOnlyConnection {
   close(): Promise<void>;
 }
 
-export async function openMarketOnlyConnection(
-  baseDir: string,
-): Promise<MarketOnlyConnection> {
+export async function openMarketOnlyConnection(baseDir: string): Promise<MarketOnlyConnection> {
   const marketDbPath = resolveMarketDbPath(baseDir);
 
   // `:memory:` host means the connection does not open any on-disk database
@@ -704,10 +749,26 @@ export async function openMarketOnlyConnection(
     // for the next reader. DETACH is best-effort — if it fails (e.g. an
     // in-flight statement still references the catalog), we still want to
     // close the handle so subsequent processes can acquire the RW lock.
-    try { await conn.run("CHECKPOINT market"); } catch { /* non-fatal */ }
-    try { await detachMarketDb(conn); } catch { /* non-fatal */ }
-    try { conn.closeSync(); } catch { /* non-fatal */ }
-    try { memoryInstance.closeSync(); } catch { /* non-fatal */ }
+    try {
+      await conn.run("CHECKPOINT market");
+    } catch {
+      /* non-fatal */
+    }
+    try {
+      await detachMarketDb(conn);
+    } catch {
+      /* non-fatal */
+    }
+    try {
+      conn.closeSync();
+    } catch {
+      /* non-fatal */
+    }
+    try {
+      memoryInstance.closeSync();
+    } catch {
+      /* non-fatal */
+    }
   };
 
   return { conn, marketDbPath, close };
@@ -800,8 +861,16 @@ export async function openMarketParquetConnection(
   const close = async (): Promise<void> => {
     if (closed) return;
     closed = true;
-    try { conn.closeSync(); } catch { /* non-fatal */ }
-    try { memoryInstance.closeSync(); } catch { /* non-fatal */ }
+    try {
+      conn.closeSync();
+    } catch {
+      /* non-fatal */
+    }
+    try {
+      memoryInstance.closeSync();
+    } catch {
+      /* non-fatal */
+    }
   };
 
   return { conn, dataRoot, close };
@@ -815,9 +884,7 @@ export async function openMarketParquetConnection(
  */
 export type MarketReadOnlyConnection = MarketParquetConnection;
 
-export function openMarketReadOnlyConnection(
-  baseDir: string,
-): Promise<MarketReadOnlyConnection> {
+export function openMarketReadOnlyConnection(baseDir: string): Promise<MarketReadOnlyConnection> {
   return openMarketParquetConnection(baseDir);
 }
 

package/src/db/data-root.ts

@@ -17,9 +17,31 @@
  * contexts, or sandboxed iframes will see the same divergence across realm
  * boundaries and must coordinate state another way.
  */
+import path from "node:path";
+
 const KEY = "__tradeblocks_data_root__";
 type GlobalSlot = { [KEY]?: string | null };
 
+/**
+ * The DuckDB files that live under a data root's `database/` subdirectory.
+ *   - `analytics` — the base DB hosting the `trades` schema (CSV-imported blocks)
+ *   - `market`    — attached market data (`market.duckdb`)
+ *   - `backtests` — the backtest run-persistence index (`backtests.duckdb`)
+ */
+export type DbKind = "analytics" | "market" | "backtests";
+
+/**
+ * Single source of truth for where a DuckDB file lives under a data root:
+ * `<dataRoot>/database/<kind>.duckdb`. Every writer and reader across the fleet
+ * (the engine's backtests-db resolver, the console reader, the calibration
+ * probe) MUST resolve through this so the `database/` segment can never drift —
+ * a missing segment silently splits reads from writes (runs succeed, the console
+ * shows an empty history forever). See tradeblocks-org/enterprise#983.
+ */
+export function resolveDbPath(dataRoot: string, kind: DbKind): string {
+  return path.join(dataRoot, "database", `${kind}.duckdb`);
+}
+
 export function setDataRoot(dir: string): void {
   (globalThis as GlobalSlot)[KEY] = dir;
 }

package/src/db/index.ts

@@ -5,8 +5,23 @@
  * (analytics.duckdb) and the market database (market.duckdb).
  */
 
-export { getConnection, closeConnection, isConnected, upgradeToReadWrite, downgradeToReadOnly, getConnectionMode, getCurrentConnection, openMarketOnlyConnection, openMarketParquetConnection, openMarketReadOnlyConnection } from "./connection.ts";
-export type { MarketOnlyConnection, MarketParquetConnection, MarketReadOnlyConnection } from "./connection.ts";
+export {
+  getConnection,
+  closeConnection,
+  isConnected,
+  upgradeToReadWrite,
+  downgradeToReadOnly,
+  getConnectionMode,
+  getCurrentConnection,
+  openMarketOnlyConnection,
+  openMarketParquetConnection,
+  openMarketReadOnlyConnection,
+} from "./connection.ts";
+export type {
+  MarketOnlyConnection,
+  MarketParquetConnection,
+  MarketReadOnlyConnection,
+} from "./connection.ts";
 export {
   ensureSyncTables,
   ensureTradeDataTable,
@@ -14,8 +29,19 @@ export {
   tableExists,
 } from "./schemas.ts";
 export { ensureMutableMarketTables, ensureMarketDataTables } from "./market-schemas.ts";
-export { ensureProfilesSchema, upsertProfile, getProfile, listProfiles, deleteProfile } from "./profile-schemas.ts";
-export { isParquetMode, writeParquetAtomic, writeParquetPartition, resolveMarketDir } from "./parquet-writer.ts";
+export {
+  ensureProfilesSchema,
+  upsertProfile,
+  getProfile,
+  listProfiles,
+  deleteProfile,
+} from "./profile-schemas.ts";
+export {
+  isParquetMode,
+  writeParquetAtomic,
+  writeParquetPartition,
+  resolveMarketDir,
+} from "./parquet-writer.ts";
 export {
   resolveCanonicalMarketFile,
   resolveCanonicalMarketPartitionDir,
@@ -23,4 +49,10 @@ export {
   resolveCanonicalMarketPartitionFile,
   canonicalMarketTableName,
 } from "./market-datasets.ts";
-export { readJsonFile, writeJsonFile, deleteJsonFile, listJsonFiles, toFileSlug } from "./json-store.ts";
+export {
+  readJsonFile,
+  writeJsonFile,
+  deleteJsonFile,
+  listJsonFiles,
+  toFileSlug,
+} from "./json-store.ts";

package/src/db/json-adapters.ts

@@ -70,7 +70,7 @@ function profilePath(blockId: string, strategyName: string, blocksDir: string):
  */
 export async function upsertProfileJson(
   profile: Omit<StrategyProfile, "createdAt" | "updatedAt">,
-  blocksDir: string
+  blocksDir: string,
 ): Promise<StrategyProfile> {
   const filePath = profilePath(profile.blockId, profile.strategyName, blocksDir);
   const now = new Date();
@@ -97,7 +97,7 @@ export async function upsertProfileJson(
 export async function getProfileJson(
   blockId: string,
   strategyName: string,
-  blocksDir: string
+  blocksDir: string,
 ): Promise<StrategyProfile | null> {
   const filePath = profilePath(blockId, strategyName, blocksDir);
   const json = await readJsonFile<ProfileJson>(filePath);
@@ -113,7 +113,7 @@ export async function getProfileJson(
  */
 export async function listProfilesJson(
   blocksDir: string,
-  blockId?: string
+  blockId?: string,
 ): Promise<StrategyProfile[]> {
   if (blockId) {
     const profileDir = path.join(blocksDir, blockId, "profiles");
@@ -151,7 +151,7 @@ export async function listProfilesJson(
 export async function deleteProfileJson(
   blockId: string,
   strategyName: string,
-  blocksDir: string
+  blocksDir: string,
 ): Promise<boolean> {
   const filePath = profilePath(blockId, strategyName, blocksDir);
   return deleteJsonFile(filePath);
@@ -195,7 +195,7 @@ function syncMetaPath(blockId: string, blocksDir: string): string {
  */
 export async function getSyncMetadataJson(
   blockId: string,
-  blocksDir: string
+  blocksDir: string,
 ): Promise<BlockSyncMetadata | null> {
   const filePath = syncMetaPath(blockId, blocksDir);
   const json = await readJsonFile<SyncMetadataJson>(filePath);
@@ -207,7 +207,7 @@ export async function getSyncMetadataJson(
  */
 export async function upsertSyncMetadataJson(
   metadata: BlockSyncMetadata,
-  blocksDir: string
+  blocksDir: string,
 ): Promise<void> {
   const filePath = syncMetaPath(metadata.block_id, blocksDir);
   await writeJsonFile(filePath, syncMetaToJson(metadata));
@@ -218,10 +218,7 @@ export async function upsertSyncMetadataJson(
  *
  * @returns true if deleted, false if not found
  */
-export async function deleteSyncMetadataJson(
-  blockId: string,
-  blocksDir: string
-): Promise<boolean> {
+export async function deleteSyncMetadataJson(blockId: string, blocksDir: string): Promise<boolean> {
   const filePath = syncMetaPath(blockId, blocksDir);
   return deleteJsonFile(filePath);
 }
@@ -231,9 +228,7 @@ export async function deleteSyncMetadataJson(
  *
  * @returns Array of block IDs that have sync metadata
  */
-export async function getAllSyncedBlockIdsJson(
-  blocksDir: string
-): Promise<string[]> {
+export async function getAllSyncedBlockIdsJson(blocksDir: string): Promise<string[]> {
   let entries: import("fs").Dirent[];
   try {
     entries = await fs.readdir(blocksDir, { withFileTypes: true });
@@ -287,7 +282,7 @@ export async function getMarketImportMetadataJson(
   source: string,
   ticker: string,
   targetTable: string,
-  dataDir: string
+  dataDir: string,
 ): Promise<MarketImportMetadata | null> {
   const filePath = marketMetaFilePath(dataDir);
   const file = await readJsonFile<MarketSyncMetadataFile>(filePath);
@@ -309,10 +304,10 @@ export async function getMarketImportMetadataJson(
  */
 export async function upsertMarketImportMetadataJson(
   metadata: MarketImportMetadata,
-  dataDir: string
+  dataDir: string,
 ): Promise<void> {
   const filePath = marketMetaFilePath(dataDir);
-  const file = await readJsonFile<MarketSyncMetadataFile>(filePath) ?? { entries: {} };
+  const file = (await readJsonFile<MarketSyncMetadataFile>(filePath)) ?? { entries: {} };
 
   const key = marketMetaKey(metadata.source, metadata.ticker, metadata.target_table);
   file.entries[key] = {
@@ -362,7 +357,7 @@ export async function getFlatImportLogJson(
   underlying: string,
   from: string,
   to: string,
-  dataDir: string
+  dataDir: string,
 ): Promise<Set<string>> {
   const filePath = flatLogFilePath(dataDir);
   const file = await readJsonFile<FlatImportLogFile>(filePath);
@@ -388,13 +383,13 @@ export async function getFlatImportLogJson(
  */
 export async function upsertFlatImportLogJson(
   entry: FlatImportLogEntry,
-  dataDir: string
+  dataDir: string,
 ): Promise<void> {
   const filePath = flatLogFilePath(dataDir);
-  const file = await readJsonFile<FlatImportLogFile>(filePath) ?? { entries: [] };
+  const file = (await readJsonFile<FlatImportLogFile>(filePath)) ?? { entries: [] };
 
   const key = flatLogKey(entry);
-  const idx = file.entries.findIndex(e => flatLogKey(e) === key);
+  const idx = file.entries.findIndex((e) => flatLogKey(e) === key);
   if (idx >= 0) {
     file.entries[idx] = entry;
   } else {
@@ -430,7 +425,10 @@ const TickerEntrySchema = z
   .object({
     // ISO calendar date `YYYY-MM-DD` or null when the ticker has been
     // registered but not yet enriched through any date.
-    enriched_through: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable(),
+    enriched_through: z
+      .string()
+      .regex(/^\d{4}-\d{2}-\d{2}$/)
+      .nullable(),
   })
   // Passthrough keeps forward compatibility — fields like `wilder_state` added
   // by future phases survive load/upsert round-trips without schema changes.
@@ -458,16 +456,12 @@ function watermarksFilePath(dataDir: string): string {
  * clear error; we never silently reset to empty, which would lose data
  * invisibly.
  */
-export async function loadEnrichmentWatermarks(
-  dataDir: string,
-): Promise<EnrichmentWatermarks> {
+export async function loadEnrichmentWatermarks(dataDir: string): Promise<EnrichmentWatermarks> {
   const raw = await readJsonFile<unknown>(watermarksFilePath(dataDir));
   if (raw === null) return { version: 1, watermarks: {} };
   const parsed = EnrichmentWatermarksSchema.safeParse(raw);
   if (!parsed.success) {
-    throw new Error(
-      `enrichment-watermarks.json is malformed: ${parsed.error.message}`,
-    );
+    throw new Error(`enrichment-watermarks.json is malformed: ${parsed.error.message}`);
   }
   return parsed.data;
 }
@@ -479,10 +473,7 @@ export async function loadEnrichmentWatermarks(
  * same (most common case) can use the value directly; callers that need to
  * distinguish can read the raw file via `loadEnrichmentWatermarks`.
  */
-export async function getEnrichedThrough(
-  ticker: string,
-  dataDir: string,
-): Promise<string | null> {
+export async function getEnrichedThrough(ticker: string, dataDir: string): Promise<string | null> {
   const { watermarks } = await loadEnrichmentWatermarks(dataDir);
   return watermarks[ticker]?.enriched_through ?? null;
 }

package/src/db/json-migration.ts

@@ -15,11 +15,7 @@
 import type { DuckDBConnection } from "@duckdb/node-api";
 import * as path from "path";
 import { isParquetMode } from "./parquet-writer.ts";
-import {
-  readJsonFile,
-  writeJsonFile,
-  toFileSlug,
-} from "./json-store.ts";
+import { readJsonFile, writeJsonFile, toFileSlug } from "./json-store.ts";
 import {
   listProfilesJson,
   upsertSyncMetadataJson,
@@ -149,12 +145,7 @@ async function migrateProfiles(conn: DuckDBConnection, blocksDir: string): Promi
     };
 
     // Write directly using json-store to preserve original timestamps
-    const filePath = path.join(
-      blocksDir,
-      blockId,
-      "profiles",
-      toFileSlug(strategyName) + ".json"
-    );
+    const filePath = path.join(blocksDir, blockId, "profiles", toFileSlug(strategyName) + ".json");
     await writeJsonFile(filePath, profileJson);
   }
 
@@ -202,7 +193,10 @@ async function migrateSyncMetadata(conn: DuckDBConnection, blocksDir: string): P
  * Migrate market import metadata from DuckDB to JSON.
  * @returns Count of migrated entries
  */
-async function migrateMarketImportMetadata(conn: DuckDBConnection, dataDir: string): Promise<number> {
+async function migrateMarketImportMetadata(
+  conn: DuckDBConnection,
+  dataDir: string,
+): Promise<number> {
   // Idempotency: skip if aggregate JSON file already exists
   const existingFile = await readJsonFile(path.join(dataDir, "market-meta", "sync-metadata.json"));
   if (existingFile !== null) return 0;
@@ -240,7 +234,9 @@ async function migrateMarketImportMetadata(conn: DuckDBConnection, dataDir: stri
  */
 async function migrateFlatImportLog(conn: DuckDBConnection, dataDir: string): Promise<number> {
   // Idempotency: skip if aggregate JSON file already exists
-  const existingFile = await readJsonFile(path.join(dataDir, "market-meta", "flat-import-log.json"));
+  const existingFile = await readJsonFile(
+    path.join(dataDir, "market-meta", "flat-import-log.json"),
+  );
   if (existingFile !== null) return 0;
 
   let rows: unknown[][];
@@ -293,7 +289,7 @@ async function migrateFlatImportLog(conn: DuckDBConnection, dataDir: string): Pr
 export async function migrateMetadataToJson(
   conn: DuckDBConnection,
   dataDir: string,
-  blocksDir: string
+  blocksDir: string,
 ): Promise<MigrationResult> {
   // Guard: only run in Parquet mode
   if (!isParquetMode()) {
@@ -310,7 +306,7 @@ export async function migrateMetadataToJson(
   if (migrated) {
     console.log(
       `[json-migration] Migrated: ${profiles} profiles, ${syncMeta} sync metadata, ` +
-      `${marketMeta} market import records, ${flatLog} flat import records`
+        `${marketMeta} market import records, ${flatLog} flat import records`,
     );
   }
 

package/src/db/json-store.ts

@@ -23,7 +23,9 @@ import * as path from "path";
 
 /** Check for Node.js ENOENT errors */
 function isEnoent(err: unknown): boolean {
-  return typeof err === "object" && err !== null && (err as Record<string, unknown>).code === "ENOENT";
+  return (
+    typeof err === "object" && err !== null && (err as Record<string, unknown>).code === "ENOENT"
+  );
 }
 
 /**
@@ -94,8 +96,8 @@ export async function listJsonFiles(dirPath: string, suffix = ".json"): Promise<
   try {
     const entries = await fs.readdir(dirPath, { withFileTypes: true });
     return entries
-      .filter(e => e.isFile() && e.name.endsWith(suffix))
-      .map(e => path.join(dirPath, e.name))
+      .filter((e) => e.isFile() && e.name.endsWith(suffix))
+      .map((e) => path.join(dirPath, e.name))
       .sort();
   } catch (err: unknown) {
     if (isEnoent(err)) {