apple-tools-mcp 1.1.0 → 1.1.2

package/README.md

@@ -137,10 +137,10 @@ Once configured, Claude can use these tools:
 | Tool | Description |
 |------|-------------|
 | `calendar_search` | Semantic search for events with filters |
-| `calendar_date` | Get events on a specific date |
+| `calendar_date` | Get events on a specific date (live Calendar.app, not the search index) |
 | `calendar_upcoming` | Get next N upcoming events |
 | `calendar_week` | Get all events for current or future week |
-| `calendar_free_time` | Find available time slots on a date |
+| `calendar_free_time` | Find available time slots on a date (live Calendar.app, not the search index) |
 | `calendar_recurring` | List recurring events |
 
 ### Contacts Tools

package/index.js

@@ -8,7 +8,7 @@ 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";
 
 // Lock file to prevent duplicate indexing processes
 const LOCK_FILE = path.join(process.env.HOME, ".apple-tools-mcp", "indexer.lock");
@@ -234,12 +234,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);
 
@@ -436,29 +436,11 @@ async function calendarSearch(query, options = {}) {
 }
 
 async function calendarDate(date) {
-  if (!sessionIndexComplete) {
-    return getIndexingMessage();
-  }
-
-  const ready = await isIndexReady("calendar");
-  if (!ready) {
-    return "Calendar index not available. Please try again shortly.";
-  }
-
   const result = await getCalendarDateResults(date);
   return formatCalendarResults(result);
 }
 
 async function calendarFreeTime(date, options = {}) {
-  if (!sessionIndexComplete) {
-    return getIndexingMessage();
-  }
-
-  const ready = await isIndexReady("calendar");
-  if (!ready) {
-    return "Calendar index not available. Please try again shortly.";
-  }
-
   const result = await calculateFreeTime(date, options);
   return formatFreeTimeResults(result);
 }
@@ -482,7 +464,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);
@@ -583,7 +565,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("");
   }
@@ -609,6 +591,10 @@ function formatSmartSearchResults(results, synthesizedGroups = null) {
 
 // Smart search - routes to appropriate sources and optionally synthesizes results
 async function smartSearch(query, options = {}) {
+  if (!sessionIndexComplete) {
+    return getIndexingMessage();
+  }
+
   const { limit = 5, synthesize = true } = options;
 
   const sources = detectSources(query);
@@ -689,21 +675,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);
   }
@@ -777,6 +763,10 @@ function formatContactLookupResult(contact) {
 // ============ PERSON SEARCH (CROSS-SOURCE) ============
 
 async function personSearch(name, limit = 10) {
+  if (!sessionIndexComplete) {
+    return getIndexingMessage();
+  }
+
   // First, try to find the contact to get all their identifiers
   const contacts = searchContacts(name, 5);
 
@@ -905,7 +895,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("");
@@ -1262,7 +1252,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;
@@ -1270,8 +1260,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,
@@ -1284,7 +1274,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":
@@ -1298,8 +1293,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,
@@ -1309,19 +1304,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"
@@ -1344,7 +1342,15 @@ 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));
+        if (!sessionIndexComplete) {
+          result = getIndexingMessage();
+          break;
+        }
+        result = formatSendersResults(await getFrequentSenders(
+          validateLimit(args?.limit, 30),
+          validateDaysBack(args?.days_back),
+          args?.include_junk || false
+        ));
         break;
 
       case "rebuild_index":
@@ -1362,6 +1368,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
         // Start rebuild in background and return immediately
         indexingInProgress = true;
+        sessionIndexComplete = false;
         const rebuildSources = args?.sources || ["emails", "messages", "calendar"];
 
         // Fire and forget - don't await
@@ -1399,34 +1406,38 @@ 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));
+        if (!sessionIndexComplete) {
+          result = getIndexingMessage();
+          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":
@@ -1434,7 +1445,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:
@@ -1454,7 +1465,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.0)");
+  console.error("Apple Tools MCP server running (v1.1.2)");
   // Background indexing runs automatically on startup and every INDEX_INTERVAL
 }
 

package/indexer.js

@@ -9,7 +9,10 @@ import {
   validateLimit,
   validateLanceDBId,
   escapeSQL,
-  stripHtmlTags
+  stripHtmlTags,
+  toUnixMillis,
+  unfoldRfc822Headers,
+  stripSubjectPrefixes
 } from "./lib/validators.js";
 import { safeSqlite3Json, safeOsascript, safeFind } from "./lib/shell.js";
 
@@ -63,6 +66,7 @@ const BATCH_DELAY_MS = 0; // No delay needed - benchmarks showed no thermal thro
 
 // Mac Absolute Time epoch: Jan 1, 2001 00:00:00 UTC
 const MAC_ABSOLUTE_EPOCH = 978307200;
+export const CALENDAR_TMP_PREFIX = "apple-tools-cal-";
 
 let embeddingPipeline = null;
 let db = null;
@@ -251,14 +255,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) ||
@@ -334,13 +341,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)
@@ -578,6 +582,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;
@@ -606,7 +613,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;
   }
 }
 
@@ -644,19 +651,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,
@@ -678,10 +690,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,
@@ -691,11 +700,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, []);
@@ -733,10 +744,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 ============
@@ -926,7 +934,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");
@@ -1040,6 +1054,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");
@@ -1129,7 +1150,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");
@@ -1185,7 +1212,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 || ""),
@@ -1269,7 +1296,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
@@ -1492,14 +1527,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);
@@ -1529,7 +1564,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);
@@ -1647,7 +1682,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 };
   }
 }
 
@@ -1677,13 +1712,126 @@ 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 };
+  }
+}
+
+// Convert local-day unix ms bounds to Apple/Core Data seconds (unix - 978307200)
+export function localDayToMacBounds(startMs, endMs) {
+  const startMac = Math.floor(Number(startMs) / 1000) - MAC_ABSOLUTE_EPOCH;
+  const endMac = Math.floor(Number(endMs) / 1000) - MAC_ABSOLUTE_EPOCH;
+  if (!Number.isFinite(startMac) || !Number.isFinite(endMac)) {
+    throw new Error("Invalid date bounds");
+  }
+  return { startMac, endMac };
+}
+
+// Date-bounded OccurrenceCache query: one row per occurrence, no GROUP BY ci.ROWID
+export function buildEventsOnDateQuery(startMac, endMac) {
+  const startBound = Math.floor(Number(startMac));
+  const endBound = Math.floor(Number(endMac));
+  if (!Number.isFinite(startBound) || !Number.isFinite(endBound)) {
+    throw new Error("Invalid Mac Absolute Time bounds");
+  }
+  const timedStart = "COALESCE(oc.occurrence_end_date - (ci.end_date - ci.start_date), ci.start_date)";
+  const occEnd = "COALESCE(oc.occurrence_end_date, ci.end_date)";
+  // First local day = occurrence-end local date minus (durationDays - 1). Day math, not seconds (DST-safe).
+  const allDayStartDate = `date(${occEnd} + 978307200, 'unixepoch', 'localtime', '-' || (CAST(round((ci.end_date - ci.start_date) / 86400.0) AS INTEGER) - 1) || ' days')`;
+  const allDayStartMac = `CAST(strftime('%s', ${allDayStartDate} || ' 00:00:00', 'utc') AS INTEGER) - 978307200`;
+  return `
+      SELECT DISTINCT
+        ci.ROWID as itemId,
+        ci.summary as title,
+        datetime(CASE WHEN ci.all_day THEN ${allDayStartMac} ELSE ${timedStart} END + 978307200, 'unixepoch', 'localtime') as start,
+        datetime(${occEnd} + 978307200, 'unixepoch', 'localtime') as end,
+        CASE WHEN ci.all_day THEN ${allDayStartMac} ELSE ${timedStart} END as startMac,
+        ${occEnd} as endMac,
+        ci.all_day as isAllDay,
+        c.title as calendar,
+        l.title as location
+      FROM OccurrenceCache oc
+      INNER JOIN CalendarItem ci ON oc.event_id = ci.ROWID
+      LEFT JOIN Calendar c ON ci.calendar_id = c.ROWID
+      LEFT JOIN Location l ON ci.location_id = l.ROWID
+      WHERE ci.summary IS NOT NULL AND ci.summary <> ''
+        AND (c.title IS NULL OR c.title NOT IN ('Found in Mail', 'Found in Natural Language'))
+        AND (
+          (oc.day >= ${startBound} AND oc.day < ${endBound})
+          OR (
+            ci.all_day = 0
+            AND ${timedStart} < ${startBound}
+            AND ${occEnd} > ${startBound}
+          )
+        )
+      ORDER BY startMac ASC, title ASC
+    `;
+}
+
+// Copy Calendar.sqlitedb (+ wal/shm) to /tmp for one query, then delete the copies.
+// Calendar.app holds a lock on the live db; sqlite can read a snapshot copy.
+function withCalendarCopy(fn) {
+  const id = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const tmpDb = path.join("/tmp", `${CALENDAR_TMP_PREFIX}${id}.sqlitedb`);
+  const tmpWal = `${tmpDb}-wal`;
+  const tmpShm = `${tmpDb}-shm`;
+  const srcWal = `${CALENDAR_DB}-wal`;
+  const srcShm = `${CALENDAR_DB}-shm`;
+
+  try {
+    if (!fs.existsSync(CALENDAR_DB)) {
+      throw new Error("Calendar database not found");
+    }
+    fs.copyFileSync(CALENDAR_DB, tmpDb);
+    if (fs.existsSync(srcWal)) {
+      fs.copyFileSync(srcWal, tmpWal);
+    }
+    if (fs.existsSync(srcShm)) {
+      fs.copyFileSync(srcShm, tmpShm);
+    }
+    return fn(tmpDb);
+  } finally {
+    for (const file of [tmpDb, tmpWal, tmpShm]) {
+      try {
+        fs.unlinkSync(file);
+      } catch {
+        // already gone or never created
+      }
+    }
+  }
+}
+
+// calendar_date: live OccurrenceCache for every occurrence on a local day
+export function getEventsOnDate(startMs, endMs) {
+  try {
+    if (!fs.existsSync(CALENDAR_DB)) {
+      return { events: [], error: "Calendar database not found" };
+    }
+    const { startMac, endMac } = localDayToMacBounds(startMs, endMs);
+    const query = buildEventsOnDateQuery(startMac, endMac);
+    let lastError;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const events = withCalendarCopy((dbPath) => {
+          return safeSqlite3Json(dbPath, query, { timeout: 15000 });
+        });
+        return { events, error: null };
+      } catch (e) {
+        lastError = e;
+        console.error(`Error getting events on date (attempt ${attempt + 1}):`, e.message);
+      }
+    }
+    return { events: [], error: lastError.message };
+  } catch (e) {
+    console.error("Error getting events on date:", e.message);
+    return { events: [], error: e.message };
   }
 }
 
@@ -1764,7 +1912,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" });
@@ -1803,15 +1953,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: [] };
@@ -1825,7 +1973,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)
@@ -1869,12 +2017,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/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.0",
+  "version": "1.1.2",
   "description": "MCP server for semantic search across Apple Mail, Messages, and Calendar",
   "type": "module",
   "main": "index.js",

package/search.js

@@ -1,8 +1,8 @@
 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 { embed, INDEX_DIR, getRecentEmails, getEmailsByDateRange, getRecentMessages, getConversation, getCalendarByDate, getAllCalendarEvents, resolveEmail, resolvePhone, formatContact } from "./indexer.js";
+import { safeMatch, validateSearchQuery, toUnixMillis } from "./lib/validators.js";
+import { embed, INDEX_DIR, getRecentEmails, getEmailsByDateRange, getRecentMessages, getConversation, getEventsOnDate, resolveEmail, resolvePhone, formatContact } from "./indexer.js";
 
 let db = null;
 let tables = {};
@@ -102,13 +102,16 @@ 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;
+  // Do not use RegExp#test with /g — lastIndex is stateful and can skip the
+  // first (or only) pronoun. replace() with a fresh regex is sufficient.
+  return query.replace(
+    /\b(they|them|their|he|him|his|she|her|hers)\b/gi,
+    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
@@ -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
@@ -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
@@ -1319,28 +1333,40 @@ export async function searchCalendar(query, options = {}) {
   }
 }
 
-// Get events on a specific date
+// Local midnight of parsed date through next local midnight (handles DST; not +24h)
+export function getLocalDayBounds(dateStr) {
+  const start = parseNaturalDate(dateStr);
+  if (start == null) return null;
+  const endDate = new Date(start);
+  endDate.setDate(endDate.getDate() + 1);
+  return { start, end: endDate.getTime() };
+}
+
+// Get events on a specific date from live Calendar.sqlitedb (not the vector index)
 export async function getCalendarDateResults(dateStr) {
   try {
-    const range = getDateRange(dateStr);
+    const range = getLocalDayBounds(dateStr);
     if (!range) {
       return { success: false, error: `Could not parse date: ${dateStr}` };
     }
 
     console.error(`[Calendar Date] Query for "${dateStr}"`);
-    console.error(`[Calendar Date] Range: ${new Date(range.start).toISOString()} to ${new Date(range.end).toISOString()}`);
+    console.error(`[Calendar Date] Range: ${new Date(range.start).toString()} to ${new Date(range.end).toString()}`);
 
-    const results = await getCalendarByDate(range.start, range.end);
+    const { events, error } = getEventsOnDate(range.start, range.end);
+    if (error) {
+      return { success: false, error: `Error getting calendar events: ${error}` };
+    }
 
-    const formattedResults = results.map((row, idx) => ({
+    const formattedResults = events.map((row, idx) => ({
       index: idx + 1,
       title: row.title || "No title",
-      start: formatLocalDate(row.start) || "Unknown",
-      startTimestamp: row.startTimestamp || null,
-      end: formatLocalDate(row.end) || "Unknown",
+      start: formatLocalDate(row.start) || row.start || "Unknown",
+      startTimestamp: row.startMac != null ? (Number(row.startMac) + 978307200) * 1000 : null,
+      end: formatLocalDate(row.end) || row.end || "Unknown",
       calendar: row.calendar || "Unknown",
       location: row.location || "",
-      isAllDay: row.isAllDay || false
+      isAllDay: !!row.isAllDay
     }));
 
     const dateLabel = new Date(range.start).toLocaleDateString("en-US", {
@@ -1360,6 +1386,24 @@ export async function getCalendarDateResults(dateStr) {
   }
 }
 
+// Clamp a timed event to [dayStartMs, dayEndMs) and return minutes from local midnight.
+// Overnight events (23:00–01:00) contribute only the slice that falls on this day.
+export function clampBusyToLocalDay(evtStartMs, evtEndMs, dayStartMs, dayEndMs) {
+  const clampedStart = Math.max(evtStartMs, dayStartMs);
+  const clampedEnd = Math.min(evtEndMs, dayEndMs);
+  if (!(clampedEnd > clampedStart)) return null;
+
+  const startMinutes = clampedStart <= dayStartMs
+    ? 0
+    : new Date(clampedStart).getHours() * 60 + new Date(clampedStart).getMinutes();
+  const endMinutes = clampedEnd >= dayEndMs
+    ? 24 * 60
+    : new Date(clampedEnd).getHours() * 60 + new Date(clampedEnd).getMinutes();
+
+  if (!(endMinutes > startMinutes)) return null;
+  return { startMinutes, endMinutes };
+}
+
 // Calculate free time slots on a specific date
 export async function calculateFreeTime(dateStr, options = {}) {
   const {
@@ -1369,12 +1413,17 @@ export async function calculateFreeTime(dateStr, options = {}) {
   } = options;
 
   try {
-    const range = getDateRange(dateStr);
+    const range = getLocalDayBounds(dateStr);
     if (!range) {
       return { success: false, error: `Could not parse date: ${dateStr}` };
     }
 
-    let events = await getCalendarByDate(range.start, range.end);
+    const { events: liveEvents, error } = getEventsOnDate(range.start, range.end);
+    if (error) {
+      return { success: false, error: `Error calculating free time: ${error}` };
+    }
+
+    let events = liveEvents;
 
     // Filter by calendar if specified
     if (calendarName) {
@@ -1390,16 +1439,21 @@ export async function calculateFreeTime(dateStr, options = {}) {
         continue;
       }
 
-      const evtStart = new Date(evt.startTimestamp);
-      const evtEnd = evt.end ? parseDate(evt.end) : evt.startTimestamp + (60 * 60 * 1000); // Default 1 hour
+      const evtStart = evt.startMac != null
+        ? (Number(evt.startMac) + 978307200) * 1000
+        : (evt.startTimestamp || parseDate(evt.start));
+      const evtEnd = evt.endMac != null
+        ? (Number(evt.endMac) + 978307200) * 1000
+        : (evt.end ? parseDate(evt.end) : evtStart + (60 * 60 * 1000));
 
-      const startMinutes = evtStart.getHours() * 60 + evtStart.getMinutes();
-      const endMinutes = new Date(evtEnd).getHours() * 60 + new Date(evtEnd).getMinutes();
+      const clamped = clampBusyToLocalDay(evtStart, evtEnd, range.start, range.end);
+      if (!clamped) continue;
 
-      busyPeriods.push({
-        start: Math.max(startMinutes, startHour * 60),
-        end: Math.min(endMinutes, endHour * 60)
-      });
+      const start = Math.max(clamped.startMinutes, startHour * 60);
+      const end = Math.min(clamped.endMinutes, endHour * 60);
+      if (end > start) {
+        busyPeriods.push({ start, end });
+      }
     }
 
     // Sort busy periods
@@ -1458,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 = "";
@@ -1481,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;
 }
 
@@ -1527,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.";
   }
@@ -1541,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.";
@@ -1633,6 +1696,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.";
@@ -1649,4 +1715,4 @@ export function formatRecurringEventsResults(result) {
 }
 
 // Export internal functions for testing
-export { expandQuery, parseNegation, extractKeywords };
+export { expandQuery, parseNegation, extractKeywords, resolvePronouns, updateContext };