apple-tools-mcp 1.2.0 → 1.2.1

package/index.js

@@ -9,7 +9,7 @@ import {
 import fs from "fs";
 import path from "path";
 import { validateEmailPath, stripHtmlTags, unfoldRfc822Headers, validateLimit, validateDaysBack, validateWeekOffset, toUnixMillis } from "./lib/validators.js";
-import { isSearchBlockedByIndexing, cycleEndFlags, indexUnavailableMessage } from "./lib/indexGate.js";
+import { cycleEndFlags, indexUnavailableMessage, indexQueryGate } from "./lib/indexGate.js";
 import { isIndexerMode } from "./lib/processMode.js";
 import { loadResolvedIndexInterval, logResolvedInterval } from "./lib/config.js";
 import { createIndexerLock, DEFAULT_LOCK_HEARTBEAT_MS } from "./lib/indexerLock.js";
@@ -180,14 +180,6 @@ async function checkIfFirstRun() {
   return !(emailsReady || messagesReady || calendarReady);
 }
 
-// Get appropriate status message based on indexing state
-function getIndexingMessage() {
-  if (isFirstEverRun) {
-    return "Building initial index. This may take several minutes on first run. Please try again shortly.";
-  }
-  return "Indexing new data. Please try again in a moment.";
-}
-
 // Run a single indexing cycle (called by background timer)
 function runIndexCycle() {
   const cycle = beginIndexCycle(indexingInProgress);
@@ -318,10 +310,30 @@ function applyCycleEnd(success) {
 // Index-backed tools wait only while THIS process owns the lock and has not
 // finished its cycle. Lost-lock secondaries fall through to isIndexReady().
 function stillIndexingMessage() {
-  if (isSearchBlockedByIndexing(sessionIndexComplete, ownsIndexLock)) {
-    return getIndexingMessage();
+  const gate = indexQueryGate({
+    sessionIndexComplete,
+    ownsIndexLock,
+    indexReady: true,
+    isFirstEverRun
+  });
+  return gate.ok ? null : gate.message;
+}
+
+/** Shared preflight for index-backed query tools (on-disk tables, not local cycle). */
+async function requireIndex(type) {
+  const indexing = stillIndexingMessage();
+  if (indexing) {
+    return indexing;
   }
-  return null;
+  const ready = await isIndexReady(type);
+  const gate = indexQueryGate({
+    sessionIndexComplete,
+    ownsIndexLock,
+    indexReady: ready,
+    type,
+    isFirstEverRun
+  });
+  return gate.ok ? null : gate.message;
 }
 
 function waitForLockAndStartDaemon() {
@@ -355,7 +367,8 @@ async function initializeIndexing() {
   if (!startup.startBackground) {
     console.error("Another apple-tools-mcp instance is indexing. Server will run without background indexing.");
     // Lost lock is not "still indexing": this process will never complete a
-    // local cycle. Searches proceed whenever isIndexReady() is true.
+    // local cycle. Searches proceed whenever isIndexReady() is true (initDB
+    // re-lists shared on-disk tables; it must not cache an empty first connect).
     ownsIndexLock = false;
     return;
   }
@@ -379,14 +392,9 @@ async function mailSearch(query, options = {}) {
     return "Error: query parameter is required for mail_search";
   }
 
-  const indexing = stillIndexingMessage();
-  if (indexing) {
-    return indexing;
-  }
-
-  const ready = await isIndexReady("emails");
-  if (!ready) {
-    return indexUnavailableMessage("emails");
+  const blocked = await requireIndex("emails");
+  if (blocked) {
+    return blocked;
   }
 
   const result = await searchEmails(query, options);
@@ -394,14 +402,9 @@ async function mailSearch(query, options = {}) {
 }
 
 async function mailRecent(limit = 30, daysBack = 7, unreadOnly = false, includeJunk = false) {
-  const indexing = stillIndexingMessage();
-  if (indexing) {
-    return indexing;
-  }
-
-  const ready = await isIndexReady("emails");
-  if (!ready) {
-    return indexUnavailableMessage("emails");
+  const blocked = await requireIndex("emails");
+  if (blocked) {
+    return blocked;
   }
 
   const result = await getRecentEmailResults(limit, daysBack, unreadOnly, includeJunk);
@@ -409,14 +412,9 @@ async function mailRecent(limit = 30, daysBack = 7, unreadOnly = false, includeJ
 }
 
 async function mailDate(date, includeJunk = false) {
-  const indexing = stillIndexingMessage();
-  if (indexing) {
-    return indexing;
-  }
-
-  const ready = await isIndexReady("emails");
-  if (!ready) {
-    return indexUnavailableMessage("emails");
+  const blocked = await requireIndex("emails");
+  if (blocked) {
+    return blocked;
   }
 
   const result = await getEmailDateResults(date, includeJunk);
@@ -424,14 +422,9 @@ async function mailDate(date, includeJunk = false) {
 }
 
 async function messagesSearch(query, options = {}) {
-  const indexing = stillIndexingMessage();
-  if (indexing) {
-    return indexing;
-  }
-
-  const ready = await isIndexReady("messages");
-  if (!ready) {
-    return indexUnavailableMessage("messages");
+  const blocked = await requireIndex("messages");
+  if (blocked) {
+    return blocked;
   }
 
   const result = await searchMessages(query, options);
@@ -439,14 +432,9 @@ async function messagesSearch(query, options = {}) {
 }
 
 async function messagesRecent(limit = 10, daysBack = 1) {
-  const indexing = stillIndexingMessage();
-  if (indexing) {
-    return indexing;
-  }
-
-  const ready = await isIndexReady("messages");
-  if (!ready) {
-    return indexUnavailableMessage("messages");
+  const blocked = await requireIndex("messages");
+  if (blocked) {
+    return blocked;
   }
 
   const result = await getRecentMessageResults(limit, daysBack);
@@ -454,14 +442,9 @@ async function messagesRecent(limit = 10, daysBack = 1) {
 }
 
 async function messagesConversation(contact, limit = 50) {
-  const indexing = stillIndexingMessage();
-  if (indexing) {
-    return indexing;
-  }
-
-  const ready = await isIndexReady("messages");
-  if (!ready) {
-    return indexUnavailableMessage("messages");
+  const blocked = await requireIndex("messages");
+  if (blocked) {
+    return blocked;
   }
 
   const result = await getConversationResults(contact, limit);
@@ -469,14 +452,9 @@ async function messagesConversation(contact, limit = 50) {
 }
 
 async function calendarSearch(query, options = {}) {
-  const indexing = stillIndexingMessage();
-  if (indexing) {
-    return indexing;
-  }
-
-  const ready = await isIndexReady("calendar");
-  if (!ready) {
-    return indexUnavailableMessage("calendar");
+  const blocked = await requireIndex("calendar");
+  if (blocked) {
+    return blocked;
   }
 
   const result = await searchCalendar(query, options);
@@ -1397,16 +1375,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       // Mail tools
       case "mail_senders":
         {
-          const indexing = stillIndexingMessage();
-          if (indexing) {
-            result = indexing;
+          const blocked = await requireIndex("emails");
+          if (blocked) {
+            result = blocked;
             break;
           }
         }
-        if (!(await isIndexReady("emails"))) {
-          result = indexUnavailableMessage("emails");
-          break;
-        }
         result = formatSendersResults(await getFrequentSenders(
           validateLimit(args?.limit, 30),
           validateDaysBack(args?.days_back),
@@ -1481,16 +1455,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       case "mail_thread":
         {
-          const indexing = stillIndexingMessage();
-          if (indexing) {
-            result = indexing;
+          const blocked = await requireIndex("emails");
+          if (blocked) {
+            result = blocked;
             break;
           }
         }
-        if (!(await isIndexReady("emails"))) {
-          result = indexUnavailableMessage("emails");
-          break;
-        }
         result = formatEmailThreadResults(await getEmailThread(args.file_path, validateLimit(args?.limit, 30)));
         break;
 

package/indexer.js

@@ -16,6 +16,7 @@ import {
 } from "./lib/validators.js";
 import { safeSqlite3Json, safeOsascript, safeFind } from "./lib/shell.js";
 import { indexUnavailableMessage } from "./lib/indexGate.js";
+import { createLanceTableCache, LANCE_CONNECT_OPTIONS } from "./lib/lancedbTables.js";
 
 // Re-export contact functions for use by other modules
 export {
@@ -70,8 +71,17 @@ const MAC_ABSOLUTE_EPOCH = 978307200;
 export const CALENDAR_TMP_PREFIX = "apple-tools-cal-";
 
 let embeddingPipeline = null;
+
+// One connection per process. Do not early-return a first connect that saw an
+// empty catalog — MCP stdio must pick up tables the indexer daemon already wrote.
+const lanceCache = createLanceTableCache({
+  connect: (uri, options) => lancedb.connect(uri, options),
+  indexDir: INDEX_DIR,
+  mkdirSync: (p, o) => fs.mkdirSync(p, o),
+  connectOptions: LANCE_CONNECT_OPTIONS
+});
+const tables = lanceCache.tables;
 let db = null;
-let tables = {};
 
 async function getEmbedder() {
   if (!embeddingPipeline) {
@@ -751,23 +761,19 @@ function getCalendarEvents() {
 // ============ DATABASE FUNCTIONS ============
 
 export async function initDB() {
-  if (db) return { db, tables };
-
-  fs.mkdirSync(INDEX_DIR, { recursive: true });
-  db = await lancedb.connect(INDEX_DIR);
+  const result = await lanceCache.initDB();
+  db = result.db;
+  return { db, tables };
+}
 
-  const tableNames = await db.tableNames();
-  if (tableNames.includes("emails")) {
-    tables.emails = await db.openTable("emails");
-  }
-  if (tableNames.includes("messages")) {
-    tables.messages = await db.openTable("messages");
-  }
-  if (tableNames.includes("calendar")) {
-    tables.calendar = await db.openTable("calendar");
-  }
+export async function getOpenTable(type) {
+  await initDB();
+  return tables[type] || null;
+}
 
-  return { db, tables };
+function resetLanceConnection() {
+  lanceCache.reset();
+  db = null;
 }
 
 export async function clearEmailsTable() {
@@ -828,10 +834,9 @@ export async function rebuildIndex(sources = ["emails", "messages", "calendar"],
     }
   }
 
-  // Reset module-level cache after dropping tables
-  // This ensures that initDB() will re-initialize and pick up the newly created tables
-  db = null;
-  tables = {};
+  // Reset connection cache after dropping tables so initDB() re-opens
+  // (or recreates) them instead of holding stale/empty handles.
+  resetLanceConnection();
 
   // Re-index requested sources
   for (const source of sources) {
@@ -1451,7 +1456,7 @@ export async function indexAll(progressCallback = null) {
 
 export async function isIndexReady(type = "emails") {
   await initDB();
-  return tables[type] !== null && tables[type] !== undefined;
+  return tables[type] != null;
 }
 
 // ============ DIRECT QUERIES (for recent items) ============

package/lib/audit.js

@@ -15,6 +15,7 @@ import fs from "fs";
 import path from "path";
 import { safeSqlite3Json, safeFind } from "./shell.js";
 import * as lancedb from "@lancedb/lancedb";
+import { LANCE_CONNECT_OPTIONS, openMissingIndexTables } from "./lancedbTables.js";
 
 // ============================================================================
 // CONSTANTS AND PATHS
@@ -55,22 +56,29 @@ let tables = {};
 // ============================================================================
 
 async function initDB() {
-  if (db) return { db, tables };
-
-  try {
-    db = await lancedb.connect(INDEX_DIR);
-    const tableNames = await db.tableNames();
-
-    if (tableNames.includes("emails")) {
-      tables.emails = await db.openTable("emails");
-    }
-    if (tableNames.includes("messages")) {
-      tables.messages = await db.openTable("messages");
-    }
-    if (tableNames.includes("calendar")) {
-      tables.calendar = await db.openTable("calendar");
+  if (!db) {
+    try {
+      db = await lancedb.connect(INDEX_DIR, LANCE_CONNECT_OPTIONS);
+    } catch (e) {
+      console.error("Error initializing database:", e.message);
+      return { db: null, tables: {} };
     }
+  }
 
+  try {
+    const result = await openMissingIndexTables({
+      db,
+      tables,
+      indexDir: INDEX_DIR,
+      reconnect: async () => {
+        try {
+          db?.close?.();
+        } catch {}
+        db = await lancedb.connect(INDEX_DIR, LANCE_CONNECT_OPTIONS);
+        return db;
+      }
+    });
+    db = result.db;
     return { db, tables };
   } catch (e) {
     console.error("Error initializing database:", e.message);

package/lib/indexGate.js

@@ -5,6 +5,8 @@
  * index cycle." A second MCP instance that lost the indexer lock never runs
  * a cycle, so that flag stays false. Lost-lock must not be treated as
  * "still indexing" — callers still check isIndexReady() for a missing index.
+ * isIndexReady() / initDB() must re-list LanceDB tables on each check so a
+ * first empty catalog (daemon writer in flight) is not cached forever.
  */
 
 /**
@@ -57,3 +59,50 @@ export function indexUnavailableMessage(type) {
   }
   return "Index not available. Please try again shortly.";
 }
+
+export const BUILDING_INITIAL_INDEX_MESSAGE =
+  "Building initial index. This may take several minutes on first run. Please try again shortly.";
+
+export const INDEXING_NEW_DATA_MESSAGE =
+  "Indexing new data. Please try again in a moment.";
+
+/**
+ * Still-indexing copy. Only for a process that owns the lock and has not
+ * finished a local cycle — never for a lost-lock MCP reader.
+ *
+ * @param {boolean} isFirstEverRun
+ * @returns {string}
+ */
+export function indexingInProgressMessage(isFirstEverRun) {
+  return isFirstEverRun ? BUILDING_INITIAL_INDEX_MESSAGE : INDEXING_NEW_DATA_MESSAGE;
+}
+
+/**
+ * Preflight for index-backed MCP query tools.
+ * Readiness is `indexReady` (usable on-disk tables), not sessionIndexComplete.
+ * Lost-lock never returns "building initial index" / still-indexing.
+ *
+ * @param {{
+ *   sessionIndexComplete: boolean,
+ *   ownsIndexLock: boolean,
+ *   indexReady: boolean,
+ *   type?: "emails"|"messages"|"calendar",
+ *   isFirstEverRun?: boolean
+ * }} args
+ * @returns {{ ok: boolean, message: string|null }}
+ */
+export function indexQueryGate({
+  sessionIndexComplete,
+  ownsIndexLock,
+  indexReady,
+  type,
+  isFirstEverRun = false
+}) {
+  if (isSearchBlockedByIndexing(sessionIndexComplete, ownsIndexLock)) {
+    return { ok: false, message: indexingInProgressMessage(isFirstEverRun) };
+  }
+  if (!indexReady) {
+    return { ok: false, message: indexUnavailableMessage(type) };
+  }
+  return { ok: true, message: null };
+}

package/lib/lancedbTables.js

@@ -0,0 +1,307 @@
+/**
+ * Shared LanceDB table cache for the vector index.
+ *
+ * MCP stdio and the indexer daemon are separate processes. The daemon keeps a
+ * writer connection for its lifetime. A short-lived MCP reader must still see
+ * on-disk emails/messages/calendar tables — including when the first connect
+ * listed an empty catalog (writer commit in flight, stale snapshot, or a
+ * concurrent initDB that returned before openTable finished).
+ *
+ * Default LanceDB consistency does not re-check other processes. Readers pass
+ * readConsistencyInterval: 0 so tableNames()/openTable() see committed catalog.
+ */
+
+import fs from "fs";
+import path from "path";
+
+export const INDEX_TABLE_NAMES = ["emails", "messages", "calendar"];
+
+/** Strong cross-process read freshness (seconds). 0 = check on every read. */
+export const LANCE_READ_CONSISTENCY_INTERVAL = 0;
+
+export const LANCE_CONNECT_OPTIONS = {
+  readConsistencyInterval: LANCE_READ_CONSISTENCY_INTERVAL
+};
+
+/**
+ * LanceDB stores each table as `<name>.lance` under the index directory.
+ *
+ * @param {string} indexDir
+ * @param {string} name
+ * @param {(p: string) => boolean} [existsSync]
+ * @returns {boolean}
+ */
+export function lanceTableExistsOnDisk(indexDir, name, existsSync = fs.existsSync) {
+  if (!indexDir || !INDEX_TABLE_NAMES.includes(name)) {
+    return false;
+  }
+  try {
+    const tableDir = path.join(indexDir, `${name}.lance`);
+    const resolvedIndex = path.resolve(indexDir);
+    const resolvedTable = path.resolve(tableDir);
+    if (resolvedTable !== path.join(resolvedIndex, `${name}.lance`)) {
+      return false;
+    }
+    return existsSync(tableDir);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Open any INDEX_TABLE_NAMES entries not already in `tables`.
+ * Always re-lists tableNames — never assume a prior empty catalog is final.
+ *
+ * @param {{
+ *   db: { tableNames: () => Promise<string[]>, openTable: (name: string) => Promise<unknown>, close?: () => void },
+ *   tables: Record<string, unknown>,
+ *   indexDir: string,
+ *   existsSync?: (p: string) => boolean,
+ *   reconnect?: () => Promise<{ tableNames: () => Promise<string[]>, openTable: (name: string) => Promise<unknown>, close?: () => void }>,
+ *   isCurrent?: () => boolean,
+ *   log?: (msg: string) => void
+ * }} args
+ * @returns {Promise<{ db: object, tables: Record<string, unknown>, reconnected: boolean, aborted: boolean }>}
+ */
+export async function openMissingIndexTables({
+  db,
+  tables,
+  indexDir,
+  existsSync = fs.existsSync,
+  reconnect,
+  isCurrent = () => true,
+  log = (msg) => console.error(msg)
+}) {
+  const stillCurrent = () => {
+    try {
+      return isCurrent() !== false;
+    } catch {
+      return false;
+    }
+  };
+
+  const missing = INDEX_TABLE_NAMES.filter((name) => tables[name] == null);
+  if (missing.length === 0) {
+    return { db, tables, reconnected: false, aborted: false };
+  }
+
+  let tableNames = [];
+  try {
+    tableNames = await db.tableNames();
+  } catch (e) {
+    log(`Failed to list index tables: ${e.message}`);
+    return { db, tables, reconnected: false, aborted: !stillCurrent() };
+  }
+
+  if (!stillCurrent()) {
+    return { db, tables, reconnected: false, aborted: true };
+  }
+
+  const listed = new Set(tableNames);
+  const onDiskButUnlisted = missing.filter(
+    (name) => !listed.has(name) && lanceTableExistsOnDisk(indexDir, name, existsSync)
+  );
+
+  let reconnected = false;
+  let conn = db;
+  if (onDiskButUnlisted.length > 0 && typeof reconnect === "function") {
+    log("Index catalog missed on-disk tables; reconnecting to shared vector-index.");
+    for (const name of INDEX_TABLE_NAMES) {
+      delete tables[name];
+    }
+    try {
+      conn = await reconnect();
+      reconnected = true;
+      if (!stillCurrent()) {
+        return { db: conn, tables, reconnected, aborted: true };
+      }
+      tableNames = await conn.tableNames();
+    } catch (e) {
+      log(`Failed to reconnect to index: ${e.message}`);
+      return { db: conn, tables, reconnected, aborted: !stillCurrent() };
+    }
+  }
+
+  if (!stillCurrent()) {
+    return { db: conn, tables, reconnected, aborted: true };
+  }
+
+  const stillMissing = INDEX_TABLE_NAMES.filter((name) => tables[name] == null);
+  for (const name of stillMissing) {
+    if (!tableNames.includes(name)) {
+      continue;
+    }
+    try {
+      tables[name] = await conn.openTable(name);
+    } catch (e) {
+      log(`Failed to open ${name} table: ${e.message}`);
+    }
+    if (!stillCurrent()) {
+      return { db: conn, tables, reconnected, aborted: true };
+    }
+  }
+
+  return { db: conn, tables, reconnected, aborted: false };
+}
+
+/**
+ * Process-local LanceDB connection + table handles.
+ * `tables` is a stable object (reset deletes keys, does not replace the object)
+ * so indexer.js can alias it for createTable/dropTable mutation.
+ *
+ * @param {{
+ *   connect: (uri: string, options: object) => Promise<object>,
+ *   indexDir: string,
+ *   mkdirSync?: (p: string, opts?: object) => void,
+ *   existsSync?: (p: string) => boolean,
+ *   log?: (msg: string) => void,
+ *   connectOptions?: object
+ * }} options
+ */
+export function createLanceTableCache(options) {
+  const {
+    connect,
+    indexDir,
+    mkdirSync,
+    existsSync = fs.existsSync,
+    log = (msg) => console.error(msg),
+    connectOptions = LANCE_CONNECT_OPTIONS
+  } = options;
+
+  const tables = {};
+  let db = null;
+  let connecting = null;
+  let refreshing = null;
+  let generation = 0;
+
+  function rememberPromise(getSlot, setSlot, pending) {
+    // Store the .finally() chain, not the raw pending. Discarding the derived
+    // promise leaves connect() failures as unhandledRejection (index.js exits).
+    const tracked = pending.finally(() => {
+      if (getSlot() === tracked) {
+        setSlot(null);
+      }
+    });
+    setSlot(tracked);
+    return tracked;
+  }
+
+  async function ensureDb() {
+    if (db) {
+      return db;
+    }
+    if (!connecting) {
+      const gen = generation;
+      rememberPromise(
+        () => connecting,
+        (value) => {
+          connecting = value;
+        },
+        (async () => {
+          if (typeof mkdirSync === "function") {
+            mkdirSync(indexDir, { recursive: true });
+          }
+          const conn = await connect(indexDir, connectOptions);
+          if (gen !== generation) {
+            try {
+              conn?.close?.();
+            } catch {
+              // stale connect after reset
+            }
+            return ensureDb();
+          }
+          db = conn;
+          return db;
+        })()
+      );
+    }
+    return connecting;
+  }
+
+  async function initDB() {
+    if (!refreshing) {
+      const gen = generation;
+      rememberPromise(
+        () => refreshing,
+        (value) => {
+          refreshing = value;
+        },
+        (async () => {
+          await ensureDb();
+          if (gen !== generation) {
+            return;
+          }
+          const result = await openMissingIndexTables({
+            db,
+            tables,
+            indexDir,
+            existsSync,
+            log,
+            isCurrent: () => gen === generation,
+            reconnect: async () => {
+              if (gen !== generation) {
+                return ensureDb();
+              }
+              try {
+                db?.close?.();
+              } catch {
+                // ignore close errors on a stale handle
+              }
+              if (gen !== generation) {
+                return ensureDb();
+              }
+              db = null;
+              return ensureDb();
+            }
+          });
+          if (gen !== generation || result.aborted) {
+            return;
+          }
+          db = result.db;
+        })()
+      );
+    }
+    await refreshing;
+    return { db, tables };
+  }
+
+  async function isIndexReady(type = "emails") {
+    await initDB();
+    return tables[type] != null;
+  }
+
+  async function getOpenTable(type) {
+    await initDB();
+    return tables[type] || null;
+  }
+
+  function reset() {
+    generation += 1;
+    const toClose = db;
+    db = null;
+    connecting = null;
+    refreshing = null;
+    for (const key of Object.keys(tables)) {
+      delete tables[key];
+    }
+    try {
+      toClose?.close?.();
+    } catch {
+      // ignore
+    }
+  }
+
+  return {
+    initDB,
+    isIndexReady,
+    getOpenTable,
+    reset,
+    get db() {
+      return db;
+    },
+    set db(value) {
+      db = value;
+    },
+    tables
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apple-tools-mcp",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "MCP server for semantic search across Apple Mail, Messages, and Calendar",
   "type": "module",
   "main": "index.js",

package/search.js

@@ -1,13 +1,9 @@
-import * as lancedb from "@lancedb/lancedb";
 import * as chrono from "chrono-node";
 import { safeOsascript } from "./lib/shell.js";
 import { safeMatch, validateSearchQuery, toUnixMillis } from "./lib/validators.js";
-import { embed, INDEX_DIR, getRecentEmails, getEmailsByDateRange, getRecentMessages, getConversation, getEventsOnDate, resolveEmail, resolvePhone, formatContact } from "./indexer.js";
+import { embed, getOpenTable, getRecentEmails, getEmailsByDateRange, getRecentMessages, getConversation, getEventsOnDate, resolveEmail, resolvePhone, formatContact } from "./indexer.js";
 import { indexUnavailableMessage } from "./lib/indexGate.js";
 
-let db = null;
-let tables = {};
-
 // ============ CACHING ============
 
 // Embedding cache with TTL (5 minutes)
@@ -458,19 +454,9 @@ async function searchWithRetry(_searchFn, tbl, query, options, keyField) {
 }
 
 async function getTable(type) {
-  if (tables[type]) return tables[type];
-
-  if (!db) {
-    db = await lancedb.connect(INDEX_DIR);
-  }
-
-  const tableNames = await db.tableNames();
-  if (!tableNames.includes(type)) {
-    return null;
-  }
-
-  tables[type] = await db.openTable(type);
-  return tables[type];
+  // Share indexer.js's connection so a first empty catalog is refreshed the
+  // same way isIndexReady() is — not a second handle that can stay empty.
+  return getOpenTable(type);
 }
 
 // Pre-warm all tables to eliminate first-query latency