apple-tools-mcp 1.1.1 → 1.1.3

package/index.js

@@ -8,11 +8,20 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import fs from "fs";
 import path from "path";
-import { validateEmailPath, stripHtmlTags } from "./lib/validators.js";
+import { validateEmailPath, stripHtmlTags, unfoldRfc822Headers, validateLimit, validateDaysBack, validateWeekOffset, toUnixMillis } from "./lib/validators.js";
+import { isSearchBlockedByIndexing, cycleEndFlags, indexUnavailableMessage } from "./lib/indexGate.js";
+
+const PACKAGE_VERSION = JSON.parse(
+  fs.readFileSync(new URL("./package.json", import.meta.url), "utf8")
+).version;
 
 // Lock file to prevent duplicate indexing processes
 const LOCK_FILE = path.join(process.env.HOME, ".apple-tools-mcp", "indexer.lock");
 const LOCK_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes - if lock is older, assume hung process
+// True only while this process won the indexer lock. Distinct from
+// sessionIndexComplete: a secondary instance that lost the lock never
+// completes a local cycle and must not stay on "still indexing" forever.
+let ownsIndexLock = false;
 
 function acquireLock() {
   try {
@@ -32,6 +41,7 @@ function acquireLock() {
 
       // If we already hold the lock, return true
       if (pid === process.pid) {
+        ownsIndexLock = true;
         return true;
       }
 
@@ -44,6 +54,7 @@ function acquireLock() {
           fs.unlinkSync(LOCK_FILE);
         } else {
           console.error(`Another indexing instance running (PID ${pid}). Skipping indexing.`);
+          ownsIndexLock = false;
           return false;
         }
       } catch {
@@ -57,17 +68,20 @@ function acquireLock() {
     // This prevents TOCTOU race condition - will throw EEXIST if file was created between check and write
     try {
       fs.writeFileSync(LOCK_FILE, `${process.pid}:${Date.now()}`, { flag: 'wx' });
+      ownsIndexLock = true;
       return true;
     } catch (err) {
       if (err.code === 'EEXIST') {
         // Another process won the race
         console.error("Another process acquired lock during race. Skipping indexing.");
+        ownsIndexLock = false;
         return false;
       }
       throw err; // Re-throw unexpected errors
     }
   } catch (e) {
     console.error("Lock file error:", e.message);
+    ownsIndexLock = false;
     return false; // On error, fail safe - don't proceed
   }
 }
@@ -80,6 +94,7 @@ function releaseLock() {
       const pid = parseInt(pidStr);
       if (pid === process.pid) {
         fs.unlinkSync(LOCK_FILE);
+        ownsIndexLock = false;
         console.error(`Released lock file (PID ${process.pid})`);
       }
     }
@@ -234,12 +249,12 @@ function runIndexCycle() {
   progressCheckTimer = setInterval(() => {
     const timeSinceProgress = Date.now() - lastProgressTime;
     if (timeSinceProgress > MAX_NO_PROGRESS_MS) {
-      console.error(`⚠️  No indexing progress for ${Math.round(timeSinceProgress / 60000)} minutes. Terminating hung process.`);
+      console.error(`⚠️  No indexing progress for ${Math.round(timeSinceProgress / 60000)} minutes. Indexing still running; not starting another cycle.`);
       clearInterval(progressCheckTimer);
       progressCheckTimer = null;
-      indexingInProgress = false;
+      // Allow searches, but do NOT clear indexingInProgress or release the lock
+      // while indexAll() is still running — overlapping writes can corrupt LanceDB.
       sessionIndexComplete = true;
-      releaseLock();
     }
   }, PROGRESS_CHECK_INTERVAL_MS);
 
@@ -259,11 +274,8 @@ function runIndexCycle() {
 
       lastIndexTime = Date.now();
       lastProgressTime = Date.now();
-      indexingInProgress = false;
-      sessionIndexComplete = true;
-      isFirstEverRun = false;  // After successful index, no longer first run
+      applyCycleEnd(true);
       console.error("Indexing complete.");
-      releaseLock(); // Allow other instances to index
       // Pre-warm tables to eliminate first-query latency
       await prewarmTables();
     }).catch(e => {
@@ -274,9 +286,7 @@ function runIndexCycle() {
       }
 
       console.error("Indexing error:", e.message);
-      indexingInProgress = false;
-      sessionIndexComplete = true;  // Mark complete even on error so queries can proceed
-      releaseLock(); // Allow other instances to index
+      applyCycleEnd(false);
     });
 }
 
@@ -313,6 +323,28 @@ function stopBackgroundIndexing() {
   console.error("Background indexing stopped");
 }
 
+// Unblock searches and drop the indexer lock after a cycle ends.
+// Must run on failure as well as success so tools are not stuck forever.
+function applyCycleEnd(success) {
+  const flags = cycleEndFlags(success);
+  indexingInProgress = flags.indexingInProgress;
+  sessionIndexComplete = flags.sessionIndexComplete;
+  ownsIndexLock = flags.ownsIndexLock;
+  if (flags.isFirstEverRun === false) {
+    isFirstEverRun = false;
+  }
+  releaseLock();
+}
+
+// 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();
+  }
+  return null;
+}
+
 // Initialize and start indexing
 async function initializeIndexing() {
   isFirstEverRun = await checkIfFirstRun();
@@ -321,6 +353,9 @@ async function initializeIndexing() {
   // indexing but keep the MCP server running so search still works.
   if (!acquireLock()) {
     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.
+    ownsIndexLock = false;
     return;
   }
 
@@ -338,13 +373,14 @@ async function mailSearch(query, options = {}) {
     return "Error: query parameter is required for mail_search";
   }
 
-  if (!sessionIndexComplete) {
-    return getIndexingMessage();
+  const indexing = stillIndexingMessage();
+  if (indexing) {
+    return indexing;
   }
 
   const ready = await isIndexReady("emails");
   if (!ready) {
-    return "Email index not available. Please try again shortly.";
+    return indexUnavailableMessage("emails");
   }
 
   const result = await searchEmails(query, options);
@@ -352,13 +388,14 @@ async function mailSearch(query, options = {}) {
 }
 
 async function mailRecent(limit = 30, daysBack = 7, unreadOnly = false, includeJunk = false) {
-  if (!sessionIndexComplete) {
-    return getIndexingMessage();
+  const indexing = stillIndexingMessage();
+  if (indexing) {
+    return indexing;
   }
 
   const ready = await isIndexReady("emails");
   if (!ready) {
-    return "Email index not available. Please try again shortly.";
+    return indexUnavailableMessage("emails");
   }
 
   const result = await getRecentEmailResults(limit, daysBack, unreadOnly, includeJunk);
@@ -366,13 +403,14 @@ async function mailRecent(limit = 30, daysBack = 7, unreadOnly = false, includeJ
 }
 
 async function mailDate(date, includeJunk = false) {
-  if (!sessionIndexComplete) {
-    return getIndexingMessage();
+  const indexing = stillIndexingMessage();
+  if (indexing) {
+    return indexing;
   }
 
   const ready = await isIndexReady("emails");
   if (!ready) {
-    return "Email index not available. Please try again shortly.";
+    return indexUnavailableMessage("emails");
   }
 
   const result = await getEmailDateResults(date, includeJunk);
@@ -380,13 +418,14 @@ async function mailDate(date, includeJunk = false) {
 }
 
 async function messagesSearch(query, options = {}) {
-  if (!sessionIndexComplete) {
-    return getIndexingMessage();
+  const indexing = stillIndexingMessage();
+  if (indexing) {
+    return indexing;
   }
 
   const ready = await isIndexReady("messages");
   if (!ready) {
-    return "Messages index not available. Please try again shortly.";
+    return indexUnavailableMessage("messages");
   }
 
   const result = await searchMessages(query, options);
@@ -394,13 +433,14 @@ async function messagesSearch(query, options = {}) {
 }
 
 async function messagesRecent(limit = 10, daysBack = 1) {
-  if (!sessionIndexComplete) {
-    return getIndexingMessage();
+  const indexing = stillIndexingMessage();
+  if (indexing) {
+    return indexing;
   }
 
   const ready = await isIndexReady("messages");
   if (!ready) {
-    return "Messages index not available. Please try again shortly.";
+    return indexUnavailableMessage("messages");
   }
 
   const result = await getRecentMessageResults(limit, daysBack);
@@ -408,13 +448,14 @@ async function messagesRecent(limit = 10, daysBack = 1) {
 }
 
 async function messagesConversation(contact, limit = 50) {
-  if (!sessionIndexComplete) {
-    return getIndexingMessage();
+  const indexing = stillIndexingMessage();
+  if (indexing) {
+    return indexing;
   }
 
   const ready = await isIndexReady("messages");
   if (!ready) {
-    return "Messages index not available. Please try again shortly.";
+    return indexUnavailableMessage("messages");
   }
 
   const result = await getConversationResults(contact, limit);
@@ -422,13 +463,14 @@ async function messagesConversation(contact, limit = 50) {
 }
 
 async function calendarSearch(query, options = {}) {
-  if (!sessionIndexComplete) {
-    return getIndexingMessage();
+  const indexing = stillIndexingMessage();
+  if (indexing) {
+    return indexing;
   }
 
   const ready = await isIndexReady("calendar");
   if (!ready) {
-    return "Calendar index not available. Please try again shortly.";
+    return indexUnavailableMessage("calendar");
   }
 
   const result = await searchCalendar(query, options);
@@ -464,7 +506,7 @@ function readFullEmail(filePath) {
       return "Email file not found.";
     }
 
-    const content = fs.readFileSync(validatedPath, 'utf-8');
+    const content = unfoldRfc822Headers(fs.readFileSync(validatedPath, 'utf-8'));
 
     // Parse email headers and body
     const fromMatch = content.match(/^From:\s*(.+)$/m);
@@ -565,7 +607,7 @@ function formatSmartSearchResults(results, synthesizedGroups = null) {
       sections.push(`  [${r.rank}] Score: ${r.score}`);
       sections.push(`      From: ${r.sender}${r.isGroupChat ? ' (Group)' : ''}`);
       sections.push(`      Date: ${r.date}`);
-      sections.push(`      Text: ${r.text.substring(0, 100)}...`);
+      sections.push(`      Text: ${(r.text || "").substring(0, 100)}${(r.text || "").length > 100 ? "..." : ""}`);
     }
     sections.push("");
   }
@@ -591,6 +633,11 @@ function formatSmartSearchResults(results, synthesizedGroups = null) {
 
 // Smart search - routes to appropriate sources and optionally synthesizes results
 async function smartSearch(query, options = {}) {
+  const indexing = stillIndexingMessage();
+  if (indexing) {
+    return indexing;
+  }
+
   const { limit = 5, synthesize = true } = options;
 
   const sources = detectSources(query);
@@ -634,6 +681,10 @@ async function smartSearch(query, options = {}) {
 
   await Promise.all(searches);
 
+  if (Object.keys(results).length === 0) {
+    return indexUnavailableMessage();
+  }
+
   // Synthesize results into timeline if multiple sources returned data
   let synthesizedGroups = null;
   if (synthesize) {
@@ -671,21 +722,21 @@ function synthesizeResults(mailResults, messageResults, calendarResults) {
 
   // Add mail results
   for (const r of mailResults) {
-    const ts = r.dateTimestamp || new Date(r.date).getTime();
+    const ts = toUnixMillis(r.dateTimestamp) || new Date(r.date).getTime();
     const bucket = getBucket(ts);
     if (bucket) bucket.mail.push(r);
   }
 
   // Add message results
   for (const r of messageResults) {
-    const ts = r.dateTimestamp || new Date(r.date).getTime();
+    const ts = toUnixMillis(r.dateTimestamp) || new Date(r.date).getTime();
     const bucket = getBucket(ts);
     if (bucket) bucket.messages.push(r);
   }
 
   // Add calendar results
   for (const r of calendarResults) {
-    const ts = r.startTimestamp || new Date(r.start).getTime();
+    const ts = toUnixMillis(r.startTimestamp) || new Date(r.start).getTime();
     const bucket = getBucket(ts);
     if (bucket) bucket.calendar.push(r);
   }
@@ -759,6 +810,11 @@ function formatContactLookupResult(contact) {
 // ============ PERSON SEARCH (CROSS-SOURCE) ============
 
 async function personSearch(name, limit = 10) {
+  const indexing = stillIndexingMessage();
+  if (indexing) {
+    return indexing;
+  }
+
   // First, try to find the contact to get all their identifiers
   const contacts = searchContacts(name, 5);
 
@@ -887,7 +943,7 @@ function formatPersonSearchResults(results) {
   if (results.messages && results.messages.results && results.messages.results.length > 0) {
     sections.push(`💬 MESSAGES (${results.messages.results.length}):`);
     for (const r of results.messages.results.slice(0, 10)) {
-      sections.push(`  • ${r.text.substring(0, 80)}${r.text.length > 80 ? "..." : ""}`);
+      sections.push(`  • ${(r.text || "").substring(0, 80)}${(r.text || "").length > 80 ? "..." : ""}`);
       sections.push(`    ${r.date}`);
     }
     sections.push("");
@@ -916,7 +972,7 @@ function formatPersonSearchResults(results) {
 // ============ MCP SERVER SETUP ============
 
 const server = new Server(
-  { name: "apple-tools-mcp", version: "2.0.0" },
+  { name: "apple-tools-mcp", version: PACKAGE_VERSION },
   { capabilities: { tools: {} } }
 );
 
@@ -1244,7 +1300,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       // Smart search (agentic)
       case "smart_search":
         result = await smartSearch(args.query, {
-          limit: args?.limit || 5,
+          limit: validateLimit(args?.limit, 5, 100),
           synthesize: args?.synthesize !== false
         });
         break;
@@ -1252,8 +1308,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       // Email tools
       case "mail_search":
         result = await mailSearch(args.query, {
-          limit: args?.limit || 30,
-          daysBack: args?.days_back || 0,
+          limit: validateLimit(args?.limit, 30),
+          daysBack: validateDaysBack(args?.days_back),
           sender: args?.sender || null,
           recipient: args?.recipient || null,
           hasAttachment: args?.has_attachment ?? null,
@@ -1266,7 +1322,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         break;
 
       case "mail_recent":
-        result = await mailRecent(args?.limit || 30, args?.days_back || 7, args?.unread_only || false, args?.include_junk || false);
+        result = await mailRecent(
+          validateLimit(args?.limit, 30),
+          validateDaysBack(args?.days_back) || 7,
+          args?.unread_only || false,
+          args?.include_junk || false
+        );
         break;
 
       case "mail_date":
@@ -1280,8 +1341,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       // Messages tools
       case "messages_search":
         result = await messagesSearch(args.query, {
-          limit: args?.limit || 30,
-          daysBack: args?.days_back || 0,
+          limit: validateLimit(args?.limit, 30),
+          daysBack: validateDaysBack(args?.days_back),
           contact: args?.contact || null,
           groupChatOnly: args?.group_chat_only || false,
           groupChatName: args?.group_chat_name || null,
@@ -1291,19 +1352,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         break;
 
       case "messages_recent":
-        result = await messagesRecent(args?.limit || 30, args?.days_back || 1);
+        result = await messagesRecent(
+          validateLimit(args?.limit, 30),
+          validateDaysBack(args?.days_back) || 1
+        );
         break;
 
       case "messages_conversation":
-        result = await messagesConversation(args.contact, args?.limit || 50);
+        result = await messagesConversation(args.contact, validateLimit(args?.limit, 50));
         break;
 
       // Calendar tools
       case "calendar_search":
         result = await calendarSearch(args.query, {
-          limit: args?.limit || 30,
-          daysBack: args?.days_back || 0,
-          daysAhead: args?.days_ahead || 0,
+          limit: validateLimit(args?.limit, 30),
+          daysBack: validateDaysBack(args?.days_back),
+          daysAhead: validateDaysBack(args?.days_ahead),
           calendarName: args?.calendar_name || null,
           allDayOnly: args?.all_day_only || false,
           sortBy: args?.sort_by || "relevance"
@@ -1326,32 +1390,45 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       // Mail tools
       case "mail_senders":
-        result = formatSendersResults(await getFrequentSenders(args?.limit || 30, args?.days_back || 0, args?.include_junk || false));
+        {
+          const indexing = stillIndexingMessage();
+          if (indexing) {
+            result = indexing;
+            break;
+          }
+        }
+        if (!(await isIndexReady("emails"))) {
+          result = indexUnavailableMessage("emails");
+          break;
+        }
+        result = formatSendersResults(await getFrequentSenders(
+          validateLimit(args?.limit, 30),
+          validateDaysBack(args?.days_back),
+          args?.include_junk || false
+        ));
         break;
 
       case "rebuild_index":
         // Check if indexing is already in progress in this session
         if (indexingInProgress) {
-          result = "⏳ Indexing is already in progress. Please wait for it to complete before starting a rebuild.";
+          result = "Indexing is already in progress. Please wait for it to complete before starting a rebuild.";
           break;
         }
 
         // Acquire lock to prevent parallel rebuilds across multiple MCP instances
         if (!acquireLock()) {
-          result = "Another indexing operation is already in progress in a different session. Please wait for it to complete.";
+          result = "Indexing is already in progress in a different session. Please wait for it to complete before starting a rebuild.";
           break;
         }
 
         // Start rebuild in background and return immediately
         indexingInProgress = true;
+        sessionIndexComplete = false;
         const rebuildSources = args?.sources || ["emails", "messages", "calendar"];
 
         // Fire and forget - don't await
         rebuildIndex(rebuildSources).then((rebuildResult) => {
-          sessionIndexComplete = true;
-          isFirstEverRun = false;
-          indexingInProgress = false;
-          releaseLock();
+          applyCycleEnd(true);
           console.error("Index rebuild completed:", JSON.stringify({
             cleared: rebuildResult.cleared,
             indexed: Object.fromEntries(
@@ -1361,8 +1438,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           }));
         }).catch(e => {
           console.error("Index rebuild error:", e.message);
-          indexingInProgress = false;
-          releaseLock();
+          applyCycleEnd(false);
         });
 
         result = `🔄 Index rebuild started for: ${rebuildSources.join(", ")}.\n\nThis runs in the background and may take several minutes for large mailboxes. You can continue using other tools - searches will use the new index once complete.`;
@@ -1381,34 +1457,45 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       // Messages tools
       case "messages_contacts":
-        result = formatMessageContactsResults(getMessageContacts(args?.limit || 50));
+        result = formatMessageContactsResults(getMessageContacts(validateLimit(args?.limit, 50, 500)));
         break;
 
       // Calendar tools
       case "calendar_upcoming":
-        result = formatUpcomingEventsResults(getUpcomingEvents(args?.limit || 30));
+        result = formatUpcomingEventsResults(getUpcomingEvents(validateLimit(args?.limit, 30, 100)));
         break;
 
       // ============ NEW TOOLS - PHASE 2 ============
 
       case "calendar_week":
-        result = formatWeekEventsResults(getWeekEvents(args?.week_offset || 0));
+        result = formatWeekEventsResults(getWeekEvents(validateWeekOffset(args?.week_offset)));
         break;
 
       // ============ NEW TOOLS - PHASE 3 ============
 
       case "mail_thread":
-        result = formatEmailThreadResults(await getEmailThread(args.file_path, args?.limit || 30));
+        {
+          const indexing = stillIndexingMessage();
+          if (indexing) {
+            result = indexing;
+            break;
+          }
+        }
+        if (!(await isIndexReady("emails"))) {
+          result = indexUnavailableMessage("emails");
+          break;
+        }
+        result = formatEmailThreadResults(await getEmailThread(args.file_path, validateLimit(args?.limit, 30)));
         break;
 
       case "calendar_recurring":
-        result = formatRecurringEventsResults(getRecurringEvents(args?.limit || 30));
+        result = formatRecurringEventsResults(getRecurringEvents(validateLimit(args?.limit, 30, 100)));
         break;
 
       // ============ CONTACTS TOOLS ============
 
       case "contacts_search":
-        result = formatContactsSearchResults(searchContacts(args.query, args?.limit || 30));
+        result = formatContactsSearchResults(searchContacts(args.query, validateLimit(args?.limit, 30)));
         break;
 
       case "contacts_lookup":
@@ -1416,7 +1503,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         break;
 
       case "person_search":
-        result = await personSearch(args.name, args?.limit || 10);
+        result = await personSearch(args.name, validateLimit(args?.limit, 10));
         break;
 
       default:
@@ -1436,7 +1523,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("Apple Tools MCP server running (v1.1.1)");
+  console.error(`Apple Tools MCP server running (v${PACKAGE_VERSION})`);
   // Background indexing runs automatically on startup and every INDEX_INTERVAL
 }
 

package/indexer.js

@@ -9,9 +9,13 @@ import {
   validateLimit,
   validateLanceDBId,
   escapeSQL,
-  stripHtmlTags
+  stripHtmlTags,
+  toUnixMillis,
+  unfoldRfc822Headers,
+  stripSubjectPrefixes
 } from "./lib/validators.js";
 import { safeSqlite3Json, safeOsascript, safeFind } from "./lib/shell.js";
+import { indexUnavailableMessage } from "./lib/indexGate.js";
 
 // Re-export contact functions for use by other modules
 export {
@@ -252,14 +256,17 @@ function parseEmlx(filePath) {
       content = lines.slice(1).join("\n");
     }
 
+    // Unfold RFC 822 wrapped headers so long From/Subject/To values are complete
+    const unfolded = unfoldRfc822Headers(content);
+
     // Extract headers
-    const fromMatch = content.match(/^From:\s*(.+)$/m);
-    const subjectMatch = content.match(/^Subject:\s*(.+)$/m);
-    const dateMatch = content.match(/^Date:\s*(.+)$/m);
-    const toMatch = content.match(/^To:\s*(.+)$/m);
-    const ccMatch = content.match(/^Cc:\s*(.+)$/m);
-    const messageIdMatch = content.match(/^Message-ID:\s*(.+)$/im);
-    const flaggedMatch = content.match(/^X-Flagged:\s*(.+)$/im) || content.match(/flags.*flagged/i);
+    const fromMatch = unfolded.match(/^From:\s*(.+)$/m);
+    const subjectMatch = unfolded.match(/^Subject:\s*(.+)$/m);
+    const dateMatch = unfolded.match(/^Date:\s*(.+)$/m);
+    const toMatch = unfolded.match(/^To:\s*(.+)$/m);
+    const ccMatch = unfolded.match(/^Cc:\s*(.+)$/m);
+    const messageIdMatch = unfolded.match(/^Message-ID:\s*(.+)$/im);
+    const flaggedMatch = unfolded.match(/^X-Flagged:\s*(.+)$/im) || unfolded.match(/flags.*flagged/i);
 
     // Check for attachments
     const hasAttachment = /Content-Disposition:\s*attachment/i.test(content) ||
@@ -335,13 +342,10 @@ function parseEmlx(filePath) {
 // Full scan - used for first run and rebuild_index
 // Includes both .emlx and .partial.emlx files (partial = not fully downloaded via IMAP)
 async function findAllEmlxFiles() {
-  try {
-    // "*.emlx" also matches "*.partial.emlx"
-    return safeFind(MAIL_DIR, { name: "*.emlx", type: "f" });
-  } catch (e) {
-    console.error("Error finding emlx files:", e.message);
-    return [];
-  }
+  // "*.emlx" also matches "*.partial.emlx"
+  // Let permission/IO errors propagate so indexEmails does not persist a
+  // timestamp for an empty scan and skip real mail forever.
+  return safeFind(MAIL_DIR, { name: "*.emlx", type: "f" });
 }
 
 // Fast incremental scan - uses find with -mtime filter (more reliable than mdfind/Spotlight)
@@ -579,6 +583,9 @@ function getMessages(sinceTimestamp = null) {
       ORDER BY m.date DESC
     `;
     const results = safeSqlite3Json(MESSAGES_DB, query, { timeout: 60000 });
+    if (!Array.isArray(results)) {
+      throw new Error("Unexpected sqlite3 result for messages");
+    }
 
     // Post-process: extract text from attributedBody where text is NULL
     let extractedCount = 0;
@@ -607,7 +614,7 @@ function getMessages(sinceTimestamp = null) {
     return results.filter(msg => msg.text && msg.text.trim() !== '');
   } catch (e) {
     console.error("Error reading messages:", e.message);
-    return [];
+    throw e;
   }
 }
 
@@ -645,19 +652,24 @@ function getParticipantStatus(status) {
 }
 
 function getCalendarEvents() {
-  try {
-    // NOTE: We index ALL calendar events, not filtered by date
-    // Calendar events don't have a "file modification time" like emails do,
-    // so we can't use the mdfind + DAYS_BACK approach.
-    // Calendar indexing is always comprehensive - filtering by date would lose historical context.
-    const now = Date.now();
-    const pastDate = unixMsToMacAbsolute(now - 10 * 365 * 24 * 60 * 60 * 1000); // 10 years back
-    const futureDate = unixMsToMacAbsolute(now + 10 * 365 * 24 * 60 * 60 * 1000); // 10 years ahead
-
-    // Query OccurrenceCache for recurring events and their calculated occurrences
-    // This includes both recurring and non-recurring events
-    // GROUP BY to avoid duplicate entries for recurring events
-    const query = `
+  // NOTE: We index ALL calendar events, not filtered by date
+  // Calendar events don't have a "file modification time" like emails do,
+  // so we can't use the mdfind + DAYS_BACK approach.
+  // Calendar indexing is always comprehensive - filtering by date would lose historical context.
+  // Must throw on source-read failure: a silent [] would look like "every event
+  // was deleted" and the stale-entry pass would wipe the calendar index.
+  if (!fs.existsSync(CALENDAR_DB)) {
+    throw new Error("Calendar database not found");
+  }
+
+  const now = Date.now();
+  const pastDate = unixMsToMacAbsolute(now - 10 * 365 * 24 * 60 * 60 * 1000); // 10 years back
+  const futureDate = unixMsToMacAbsolute(now + 10 * 365 * 24 * 60 * 60 * 1000); // 10 years ahead
+
+  // Query OccurrenceCache for recurring events and their calculated occurrences
+  // This includes both recurring and non-recurring events
+  // GROUP BY to avoid duplicate entries for recurring events
+  const query = `
       SELECT
         ci.ROWID as id,
         ci.summary,
@@ -679,10 +691,7 @@ function getCalendarEvents() {
       ORDER BY MIN(oc.day) ASC
     `;
 
-    const rows = safeSqlite3Json(CALENDAR_DB, query, { timeout: 30000 });
-
-    // Get attendees for events that have them (separate query for efficiency)
-    const attendeesQuery = `
+  const attendeesQuery = `
       SELECT
         p.owner_id,
         COALESCE(i.display_name, p.email, 'Unknown') as name,
@@ -692,11 +701,13 @@ function getCalendarEvents() {
       WHERE p.entity_type = 0
     `;
 
+  return withCalendarCopy((dbPath) => {
+    const rows = safeSqlite3Json(dbPath, query, { timeout: 30000 });
+
     let attendeesMap = new Map();
     try {
-      const attendeesRows = safeSqlite3Json(CALENDAR_DB, attendeesQuery, { timeout: 10000 });
+      const attendeesRows = safeSqlite3Json(dbPath, attendeesQuery, { timeout: 10000 });
 
-      // Group attendees by owner_id (event id)
       for (const att of attendeesRows) {
         if (!attendeesMap.has(att.owner_id)) {
           attendeesMap.set(att.owner_id, []);
@@ -734,10 +745,7 @@ function getCalendarEvents() {
 
     console.error(`Calendar: Retrieved ${events.length} events via SQLite (~${Math.round((Date.now() - now))}ms)`);
     return events;
-  } catch (e) {
-    console.error("Error reading calendar:", e.message);
-    return [];
-  }
+  });
 }
 
 // ============ DATABASE FUNCTIONS ============
@@ -927,7 +935,13 @@ export async function indexEmails(progressCallback = null, forceFullScan = false
   // Use fast incremental scan if we have a previous timestamp
   const startTime = Date.now();
   console.error(`Calling findNewEmlxFiles with timestamp: ${lastEmailIndexTime ? new Date(lastEmailIndexTime).toISOString() : 'null (full scan)'}`);
-  const newFiles = await findNewEmlxFiles(lastEmailIndexTime);
+  let newFiles;
+  try {
+    newFiles = await findNewEmlxFiles(lastEmailIndexTime);
+  } catch (e) {
+    console.error(`Email source read failed; skipping this cycle so the lookback timestamp is not advanced: ${e.message}`);
+    return { indexed: 0, added: 0, error: e.message };
+  }
   console.error(`Found ${newFiles.length} new/modified email files (${Date.now() - startTime}ms)`);
 
   const indexedPaths = await getIndexedIdsWithRetry("emails", "filePath");
@@ -1041,6 +1055,13 @@ export async function indexEmails(progressCallback = null, forceFullScan = false
       if (uniqueRecords.length > 0) {
         if (!tables.emails) {
           tables.emails = await db.createTable("emails", uniqueRecords, { mode: "overwrite" });
+          // Track messageIds from the first batch so later batches can
+          // dedupe IMAP copies (INBOX vs Junk) of the same Message-ID.
+          for (const record of uniqueRecords) {
+            if (record.messageId) {
+              indexedMessageIds.add(record.messageId);
+            }
+          }
         } else {
           // Double-check: verify these IDs truly aren't in the index
           const currentIndexed = await getIndexedIdsWithRetry("emails", "filePath");
@@ -1130,7 +1151,13 @@ export async function indexMessages(forceFullScan = false) {
   const indexStartTime = Date.now();
 
   // Use incremental scan if we have a previous timestamp
-  const messages = getMessages(lastMessageIndexTime);
+  let messages;
+  try {
+    messages = getMessages(lastMessageIndexTime);
+  } catch (e) {
+    console.error(`Messages source read failed; skipping this cycle so the lookback timestamp is not advanced: ${e.message}`);
+    return { indexed: 0, added: 0, error: e.message };
+  }
   console.error(`Found ${messages.length} messages${lastMessageIndexTime ? ' (incremental)' : ' (full scan)'}`);
 
   const indexed = await getIndexedIdsWithRetry("messages", "id");
@@ -1186,7 +1213,7 @@ export async function indexMessages(forceFullScan = false) {
       return {
         id: String(msg.id),
         date: msg.date,
-        dateTimestamp: msg.dateTimestamp || 0,
+        dateTimestamp: toUnixMillis(msg.dateTimestamp),
         sender: msg.sender,
         text: msg.text?.substring(0, 500) || "",
         chatId: String(msg.chatId || ""),
@@ -1270,7 +1297,15 @@ export async function indexMessages(forceFullScan = false) {
 export async function indexCalendar() {
   await initDB();
 
-  const events = getCalendarEvents();
+  let events;
+  try {
+    events = getCalendarEvents();
+  } catch (e) {
+    // Do not treat a source-read failure as "zero events" — that would mark
+    // every indexed row stale and delete the calendar index.
+    console.error(`Calendar source read failed; skipping index update to avoid data loss: ${e.message}`);
+    return { indexed: 0, added: 0, removed: 0, error: e.message };
+  }
   console.error(`Found ${events.length} calendar events`);
 
   // Get already indexed event IDs for incremental indexing
@@ -1493,14 +1528,14 @@ export async function getRecentMessages(limit = 10, daysBack = 1) {
   if (!tables.messages) return { messages: [], hasMore: false };
 
   try {
-    const cutoff = Date.now() / 1000 - (daysBack * 24 * 60 * 60); // Messages use Unix timestamp
+    const cutoff = Date.now() - (daysBack * 24 * 60 * 60 * 1000);
     const results = await tables.messages.query()
       .select(["id", "date", "dateTimestamp", "sender", "text", "chatId", "isGroupChat"])
       .toArray();
 
     const filtered = results
-      .filter(r => r.dateTimestamp >= cutoff)
-      .sort((a, b) => b.dateTimestamp - a.dateTimestamp);
+      .filter(r => toUnixMillis(r.dateTimestamp) >= cutoff)
+      .sort((a, b) => toUnixMillis(b.dateTimestamp) - toUnixMillis(a.dateTimestamp));
 
     const hasMore = filtered.length > limit;
     const messages = filtered.slice(0, limit);
@@ -1530,7 +1565,7 @@ export async function getConversation(contact, limit = 50) {
 
     // Sort chronologically (oldest first for conversation view)
     return filtered
-      .sort((a, b) => a.dateTimestamp - b.dateTimestamp)
+      .sort((a, b) => toUnixMillis(a.dateTimestamp) - toUnixMillis(b.dateTimestamp))
       .slice(-limit); // Take last N messages
   } catch (e) {
     console.error("Error getting conversation:", e.message);
@@ -1648,7 +1683,7 @@ export function getMessageContacts(limit = 50) {
     return safeSqlite3Json(MESSAGES_DB, query, { timeout: 30000 });
   } catch (e) {
     console.error("Error getting message contacts:", e.message);
-    return [];
+    return { error: e.message };
   }
 }
 
@@ -1678,13 +1713,15 @@ export function getUpcomingEvents(limit = 10) {
       ORDER BY sort_day ASC
       LIMIT ${fetchLimit}
     `;
-    const events = safeSqlite3Json(CALENDAR_DB, query, { timeout: 10000 });
+    const events = withCalendarCopy((dbPath) => {
+      return safeSqlite3Json(dbPath, query, { timeout: 10000 });
+    });
     const hasMore = events.length > safeLimit;
     const limitedEvents = events.slice(0, safeLimit);
     return { events: limitedEvents, showing: limitedEvents.length, hasMore };
   } catch (e) {
     console.error("Error getting upcoming events:", e.message);
-    return { events: [], showing: 0, hasMore: false };
+    return { events: [], showing: 0, hasMore: false, error: e.message };
   }
 }
 
@@ -1876,7 +1913,9 @@ export function getWeekEvents(weekOffset = 0) {
         AND ci.summary IS NOT NULL AND ci.summary <> ''
       ORDER BY oc.day ASC
     `;
-    const events = safeSqlite3Json(CALENDAR_DB, query, { timeout: 15000 });
+    const events = withCalendarCopy((dbPath) => {
+      return safeSqlite3Json(dbPath, query, { timeout: 15000 });
+    });
 
     const weekStart = monday.toLocaleDateString("en-US", { weekday: "short", month: "short", day: "numeric" });
     const weekEnd = sunday.toLocaleDateString("en-US", { weekday: "short", month: "short", day: "numeric" });
@@ -1898,7 +1937,7 @@ export function getWeekEvents(weekOffset = 0) {
 // Uses subject-based matching since Message-ID isn't indexed
 export async function getEmailThread(filePath, limit = 20) {
   await initDB();
-  if (!tables.emails) return { error: "Email index not ready", emails: [] };
+  if (!tables.emails) return { error: indexUnavailableMessage("emails"), emails: [] };
 
   try {
     // Validate file path to prevent path traversal attacks
@@ -1915,15 +1954,13 @@ export async function getEmailThread(filePath, limit = 20) {
     }
 
     // Read the email to get subject
-    const content = fs.readFileSync(validatedPath, "utf-8");
+    const content = unfoldRfc822Headers(fs.readFileSync(validatedPath, "utf-8"));
     const subjectMatch = content.match(/^Subject:\s*(.+)$/m);
     if (!subjectMatch) {
       return { error: "Could not extract subject from email", emails: [] };
     }
 
-    // Clean subject - remove Re:, Fwd:, etc.
-    let subject = subjectMatch[1].trim();
-    const baseSubject = subject.replace(/^(Re|Fwd|Fw):\s*/gi, "").trim();
+    const baseSubject = stripSubjectPrefixes(subjectMatch[1]);
 
     if (baseSubject.length < 5) {
       return { error: "Subject too short to find thread", emails: [] };
@@ -1937,7 +1974,7 @@ export async function getEmailThread(filePath, limit = 20) {
     // Filter to emails with matching base subject
     const threadEmails = allEmails
       .filter(e => {
-        const eBaseSubject = (e.subject || "").replace(/^(Re|Fwd|Fw):\s*/gi, "").trim();
+        const eBaseSubject = stripSubjectPrefixes(e.subject || "");
         return eBaseSubject.toLowerCase() === baseSubject.toLowerCase();
       })
       .sort((a, b) => a.dateTimestamp - b.dateTimestamp)
@@ -1981,12 +2018,14 @@ export function getRecurringEvents(limit = 20) {
       ORDER BY occurrenceCount DESC, MIN(oc.day) ASC
       LIMIT ${fetchLimit}
     `;
-    const events = safeSqlite3Json(CALENDAR_DB, query, { timeout: 30000 });
+    const events = withCalendarCopy((dbPath) => {
+      return safeSqlite3Json(dbPath, query, { timeout: 30000 });
+    });
     const hasMore = events.length > safeLimit;
     const limitedEvents = events.slice(0, safeLimit);
     return { events: limitedEvents, showing: limitedEvents.length, hasMore };
   } catch (e) {
     console.error("Error getting recurring events:", e.message);
-    return { events: [], showing: 0, hasMore: false };
+    return { events: [], showing: 0, hasMore: false, error: e.message };
   }
 }

package/lib/indexGate.js

@@ -0,0 +1,59 @@
+/**
+ * Index-session search gating.
+ *
+ * sessionIndexComplete means "this process finished (or abandoned) its own
+ * 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.
+ */
+
+/**
+ * Whether index-backed tools should return the still-indexing message.
+ *
+ * @param {boolean} sessionIndexComplete
+ * @param {boolean} ownsIndexLock true if this process won/holds the indexer lock
+ * @returns {boolean}
+ */
+export function isSearchBlockedByIndexing(sessionIndexComplete, ownsIndexLock) {
+  return Boolean(ownsIndexLock) && !sessionIndexComplete;
+}
+
+/**
+ * In-memory flags after an index or rebuild cycle ends.
+ * Searches must be unblocked on both success and failure.
+ *
+ * @param {boolean} success
+ * @returns {{ indexingInProgress: false, sessionIndexComplete: true, ownsIndexLock: false, isFirstEverRun?: false }}
+ */
+export function cycleEndFlags(success) {
+  const flags = {
+    indexingInProgress: false,
+    sessionIndexComplete: true,
+    ownsIndexLock: false
+  };
+  if (success) {
+    flags.isFirstEverRun = false;
+  }
+  return flags;
+}
+
+/**
+ * User-facing message when a source table is missing.
+ * Distinct from still-indexing: retry because the index is not there yet,
+ * not because this process is mid-cycle.
+ *
+ * @param {"emails"|"messages"|"calendar"|undefined} type
+ * @returns {string}
+ */
+export function indexUnavailableMessage(type) {
+  if (type === "messages") {
+    return "Messages index not available. Please try again shortly.";
+  }
+  if (type === "calendar") {
+    return "Calendar index not available. Please try again shortly.";
+  }
+  if (type === "emails") {
+    return "Email index not available. Please try again shortly.";
+  }
+  return "Index not available. Please try again shortly.";
+}

package/lib/shell.js

@@ -93,8 +93,7 @@ export function safeSqlite3Json(dbPath, query, options = {}) {
   try {
     return JSON.parse(output);
   } catch (e) {
-    console.error('Failed to parse sqlite3 JSON output:', e.message);
-    return [];
+    throw new Error(`Failed to parse sqlite3 JSON output: ${e.message}`);
   }
 }
 
@@ -267,12 +266,20 @@ export function safeFind(searchPath, options = {}) {
     throw result.error;
   }
 
-  // find may return non-zero if some paths are inaccessible
-  // We still want to return whatever paths it found
-  return result.stdout
+  const paths = (result.stdout || '')
     .split('\n')
     .map(line => line.trim())
     .filter(line => line.length > 0);
+
+  // Partial permission errors can still yield some paths; keep those.
+  // A complete failure (no paths + non-zero status) must not be treated as
+  // "zero files" — callers persist index timestamps on empty scans.
+  if (result.status !== 0 && paths.length === 0) {
+    const errorMsg = (result.stderr || '').trim() || `find exited with code ${result.status}`;
+    throw new Error(errorMsg);
+  }
+
+  return paths;
 }
 
 // ============ GENERIC SAFE SPAWN ============

package/lib/validators.js

@@ -118,10 +118,14 @@ export function escapeAppleScript(str) {
   if (!str || typeof str !== 'string') {
     return '';
   }
-  // Escape backslashes first, then double quotes
+  // Escape backslashes first, then quotes, then line breaks.
+  // Unescaped CR/LF inside an AppleScript double-quoted string can close the
+  // string and inject additional statements.
   return str
     .replace(/\\/g, '\\\\')
-    .replace(/"/g, '\\"');
+    .replace(/"/g, '\\"')
+    .replace(/\r/g, '\\r')
+    .replace(/\n/g, '\\n');
 }
 
 /**
@@ -407,6 +411,64 @@ export function stripHtmlTags(html, maxLength = 100000) {
  */
 const MAC_ABSOLUTE_EPOCH = 978307200;
 
+/**
+ * Normalize a Unix timestamp to milliseconds.
+ * Messages chat.db values are stored as seconds; email/calendar timestamps
+ * are milliseconds. Treating seconds as ms drops every date-filtered message.
+ *
+ * Threshold 1e11 ms is 1973-03-03 — well before any real mail/message date,
+ * and far above Unix seconds for year 2100 (~4e9).
+ *
+ * @param {number|string|null|undefined} ts
+ * @returns {number} Timestamp in milliseconds, or 0 if invalid
+ */
+export function toUnixMillis(ts) {
+  if (ts === null || ts === undefined || ts === '') {
+    return 0;
+  }
+  const n = Number(ts);
+  if (!Number.isFinite(n) || n <= 0) {
+    return 0;
+  }
+  return n < 1e11 ? n * 1000 : n;
+}
+
+/**
+ * Unfold RFC 822 wrapped header lines (CRLF + WSP continuation) so
+ * From/Subject/To matchers see the full header value.
+ *
+ * @param {string} content - Raw email content (headers + body)
+ * @returns {string} Content with folded headers joined into single lines
+ */
+export function unfoldRfc822Headers(content) {
+  if (!content || typeof content !== 'string') {
+    return '';
+  }
+  const split = content.search(/\r?\n\r?\n/);
+  const headers = split >= 0 ? content.slice(0, split) : content;
+  const body = split >= 0 ? content.slice(split) : '';
+  return headers.replace(/\r?\n[ \t]+/g, ' ') + body;
+}
+
+/**
+ * Strip repeated Re:/Fwd:/Fw: prefixes from an email subject for thread matching.
+ *
+ * @param {string} subject
+ * @returns {string}
+ */
+export function stripSubjectPrefixes(subject) {
+  if (!subject || typeof subject !== 'string') {
+    return '';
+  }
+  let s = subject.trim();
+  let prev;
+  do {
+    prev = s;
+    s = s.replace(/^(re|fwd|fw)\s*:\s*/i, '').trim();
+  } while (s !== prev);
+  return s;
+}
+
 /**
  * Convert Mac Absolute Time to Unix timestamp (milliseconds)
  * Handles both seconds and nanoseconds formats

package/package.json

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

package/search.js

@@ -1,8 +1,9 @@
 import * as lancedb from "@lancedb/lancedb";
 import * as chrono from "chrono-node";
 import { safeOsascript } from "./lib/shell.js";
-import { safeMatch, validateSearchQuery } from "./lib/validators.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 { indexUnavailableMessage } from "./lib/indexGate.js";
 
 let db = null;
 let tables = {};
@@ -102,13 +103,15 @@ function resolvePronouns(query) {
     return query;
   }
 
-  const pronounPattern = /\b(they|them|their|he|him|his|she|her|hers)\b/gi;
-
-  if (pronounPattern.test(query) && queryContext.lastPerson) {
-    return query.replace(pronounPattern, queryContext.lastPerson);
+  if (!queryContext.lastPerson) {
+    return query;
   }
 
-  return query;
+  // Never use RegExp#test with a /g regex — lastIndex is stateful and can
+  // skip the first (or only) pronoun on this or a later call. A fresh
+  // regex plus replace() is lastIndex-safe; do not hoist or test() it.
+  const pronounRe = new RegExp('\\b(they|them|their|he|him|his|she|her|hers)\\b', 'gi');
+  return query.replace(pronounRe, queryContext.lastPerson);
 }
 
 // Extract entities (people, dates) from natural language query and convert to filters
@@ -525,8 +528,10 @@ export function getDateRange(dateStr) {
   const start = parseNaturalDate(dateStr);
   if (!start) return null;
 
-  const end = start + (24 * 60 * 60 * 1000); // End of day
-  return { start, end };
+  // Local next midnight — not +24h, which is wrong on DST transition days
+  const endDate = new Date(start);
+  endDate.setDate(endDate.getDate() + 1);
+  return { start, end: endDate.getTime() };
 }
 
 // Parse various date formats and return timestamp (for filtering results)
@@ -559,7 +564,7 @@ function filterByDateRange(results, daysBack, daysAhead, dateField = "date") {
   if (daysBack === 0 && daysAhead === 0) return results;
 
   return results.filter(r => {
-    const ts = r.dateTimestamp || parseDate(r[dateField]);
+    const ts = toUnixMillis(r.dateTimestamp) || parseDate(r[dateField]);
     if (!ts) return daysBack === 0 && daysAhead === 0;
     return ts >= cutoffPast && ts <= cutoffFuture;
   });
@@ -568,8 +573,8 @@ function filterByDateRange(results, daysBack, daysAhead, dateField = "date") {
 // Sort results by date (newest first)
 function sortByDate(results, descending = true) {
   return results.sort((a, b) => {
-    const tsA = a.dateTimestamp || parseDate(a.date) || parseDate(a.start) || 0;
-    const tsB = b.dateTimestamp || parseDate(b.date) || parseDate(b.start) || 0;
+    const tsA = toUnixMillis(a.dateTimestamp) || parseDate(a.date) || parseDate(a.start) || 0;
+    const tsB = toUnixMillis(b.dateTimestamp) || parseDate(b.date) || parseDate(b.start) || 0;
     return descending ? tsB - tsA : tsA - tsB;
   });
 }
@@ -582,7 +587,7 @@ export async function searchEmails(query, options = {}) {
   try {
     validatedQuery = validateSearchQuery(query);
   } catch (e) {
-    return { results: [], error: e.message };
+    return { success: false, results: [], error: e.message };
   }
 
   // Check result cache first
@@ -622,7 +627,7 @@ export async function searchEmails(query, options = {}) {
   if (!tbl) {
     return {
       success: false,
-      error: "Email index not ready. Please wait for indexing to complete."
+      error: indexUnavailableMessage("emails")
     };
   }
 
@@ -714,6 +719,7 @@ export async function searchEmails(query, options = {}) {
         to: row.to || "Unknown",
         subject: row.subject || "No subject",
         date: formatLocalDate(row.date) || "Unknown",
+        dateTimestamp: toUnixMillis(row.dateTimestamp) || null,
         mailbox: row.mailbox || "Unknown",
         hasAttachment: row.hasAttachment || false,
         isFlagged: row.isFlagged || false,
@@ -950,7 +956,7 @@ export async function getEmailDateResults(dateStr, includeJunk = false) {
 }
 
 export function formatEmailResults(searchResult) {
-  if (!searchResult.success) return searchResult.error;
+  if (!searchResult.success) return searchResult.error || "Email search failed";
   if (searchResult.results.length === 0) return searchResult.message;
 
   const results = searchResult.results.map(r => {
@@ -965,6 +971,9 @@ export function formatEmailResults(searchResult) {
     return result + "\n---";
   }).join("\n");
 
+  if (searchResult.hasMore) {
+    return results + `\n\nShowing ${searchResult.showing} results. More matches exist; increase limit to see them.`;
+  }
   return results;
 }
 
@@ -976,7 +985,7 @@ export async function searchMessages(query, options = {}) {
   try {
     validatedQuery = validateSearchQuery(query);
   } catch (e) {
-    return { results: [], error: e.message };
+    return { success: false, results: [], error: e.message };
   }
 
   // Check result cache first
@@ -1013,7 +1022,7 @@ export async function searchMessages(query, options = {}) {
   if (!tbl) {
     return {
       success: false,
-      error: "Messages index not ready. Please wait for indexing to complete."
+      error: indexUnavailableMessage("messages")
     };
   }
 
@@ -1084,6 +1093,7 @@ export async function searchMessages(query, options = {}) {
         rank: idx + 1,
         score: row._hybridScore ? row._hybridScore.toFixed(3) : (row._distance ? (1 - row._distance).toFixed(3) : "N/A"),
         date: formatLocalDate(row.date) || "Unknown",
+        dateTimestamp: toUnixMillis(row.dateTimestamp) || null,
         sender: sender,
         senderContact: senderContact,  // Resolved contact name (if found)
         text: row.text || "",
@@ -1126,6 +1136,7 @@ export async function getRecentMessageResults(limit = 10, daysBack = 1) {
       return {
         rank: idx + 1,
         date: formatLocalDate(row.date) || "Unknown",
+        dateTimestamp: toUnixMillis(row.dateTimestamp) || null,
         sender: sender,
         senderContact: senderContact,
         text: row.text || "",
@@ -1166,7 +1177,7 @@ export async function getConversationResults(contact, limit = 50) {
 }
 
 export function formatMessageResults(searchResult) {
-  if (!searchResult.success) return searchResult.error;
+  if (!searchResult.success) return searchResult.error || "Message search failed";
   if (searchResult.results.length === 0) return searchResult.message;
 
   const results = searchResult.results.map(r => {
@@ -1180,6 +1191,9 @@ export function formatMessageResults(searchResult) {
     return result + "\n---";
   }).join("\n");
 
+  if (searchResult.hasMore) {
+    return results + `\n\nShowing ${searchResult.showing} results. More matches exist; increase limit to see them.`;
+  }
   return results;
 }
 
@@ -1202,7 +1216,7 @@ export async function searchCalendar(query, options = {}) {
   try {
     validatedQuery = validateSearchQuery(query);
   } catch (e) {
-    return { results: [], error: e.message };
+    return { success: false, results: [], error: e.message };
   }
 
   // Check result cache first
@@ -1238,7 +1252,7 @@ export async function searchCalendar(query, options = {}) {
   if (!tbl) {
     return {
       success: false,
-      error: "Calendar index not ready. Please wait for indexing to complete."
+      error: indexUnavailableMessage("calendar")
     };
   }
 
@@ -1498,7 +1512,7 @@ function formatMinutes(minutes) {
 }
 
 export function formatCalendarResults(searchResult) {
-  if (!searchResult.success) return searchResult.error;
+  if (!searchResult.success) return searchResult.error || "Calendar search failed";
   if (searchResult.results.length === 0) return searchResult.message;
 
   let header = "";
@@ -1521,6 +1535,9 @@ export function formatCalendarResults(searchResult) {
     return result + "\n---";
   }).join("\n");
 
+  if (searchResult.hasMore) {
+    return header + results + `\n\nShowing ${searchResult.showing} results. More matches exist; increase limit to see them.`;
+  }
   return header + results;
 }
 
@@ -1567,6 +1584,9 @@ export function formatSendersResults(senders) {
 
 // Format messages_contacts results
 export function formatMessageContactsResults(contacts) {
+  if (contacts?.error) {
+    return `Error getting message contacts: ${contacts.error}`;
+  }
   if (!contacts || contacts.length === 0) {
     return "No message contacts found.";
   }
@@ -1581,6 +1601,9 @@ export function formatMessageContactsResults(contacts) {
 
 // Format calendar_upcoming results
 export function formatUpcomingEventsResults(result) {
+  if (result?.error) {
+    return `Error getting upcoming events: ${result.error}`;
+  }
   const events = result.events || result; // Handle both new {events, showing, hasMore} and old array format
   if (!events || events.length === 0) {
     return "No upcoming events found.";
@@ -1650,6 +1673,9 @@ export function formatWeekEventsResults(result) {
 // Format mail_thread results
 export function formatEmailThreadResults(result) {
   if (result.error) {
+    if (result.error === indexUnavailableMessage("emails")) {
+      return result.error;
+    }
     return `Error: ${result.error}`;
   }
 
@@ -1673,6 +1699,9 @@ export function formatEmailThreadResults(result) {
 
 // Format calendar_recurring results
 export function formatRecurringEventsResults(result) {
+  if (result?.error) {
+    return `Error getting recurring events: ${result.error}`;
+  }
   const events = result.events || result; // Handle both new {events, showing, hasMore} and old array format
   if (!events || events.length === 0) {
     return "No recurring events found.";
@@ -1689,4 +1718,4 @@ export function formatRecurringEventsResults(result) {
 }
 
 // Export internal functions for testing
-export { expandQuery, parseNegation, extractKeywords };
+export { expandQuery, parseNegation, extractKeywords, resolvePronouns, updateContext };