@lengelhard/imap-email-mcp 1.7.4 → 1.8.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 1.8.0
+
+### Added
+- `find_duplicates`: lists messages that exist more than once, matched on the Message-ID header. `scope: "same_folder"` reports a folder holding the same message twice, a filing error, and names the extra copies under `redundant_copies` (the lowest UID is kept). `scope: "cross_folder"` reports a message present in several folders, usually a split thread, and never marks anything redundant, because deleting one copy of those only relocates the problem. Messages with no Message-ID are counted in `coverage.without_message_id` instead of being silently skipped. Requires the local index.
+- `message_id` on the results of `list_emails`, `search_emails`, `search_index` and `get_email`, with the angle brackets stripped. It was already fetched and stored by the indexer but never exposed, which left callers matching on subject, sender and timestamp instead. That heuristic is unreliable: in a fast thread two genuinely different replies can share a subject, a sender and a minute, and on 19 Sep 2026 it produced five candidate pairs of which none were duplicates.
+- `messages.message_id` is now indexed in SQLite.
+
+### Changed
+- **`delete_email` moves to Trash instead of erasing.** It previously flagged `\Deleted` and expunged, so a wrong UID was unrecoverable and nothing appeared in Trash. It now moves the message to the folder the server flags as `\Trash` (falling back to the usual names), and the response says where it went. Pass `expunge: true` for the old behaviour, which is permanent. A message already in Trash is still erased. On an account with no Trash folder the call now fails and says so, rather than erasing a message when the recoverable path was the one asked for.
+
+### Fixed
+- `normalizeMessageId` returned the literal `<>` for an empty Message-ID header instead of treating it as absent, which would have grouped every such message together as duplicates of one another.
+
 ## 1.7.4
 
 ### Added

package/README.md

@@ -75,7 +75,8 @@ Add to your config file:
 - **Compose** - Create and save email drafts
 - **Send** - Send emails directly via SMTP
 - **Manage drafts** - List, read, update, and delete drafts
-- **Delete emails** - Remove unwanted messages
+- **Find duplicates** - Spot messages filed twice in one folder, or the same message sitting in several folders, matched on Message-ID
+- **Delete emails** - Move to Trash by default, with an explicit opt-in to erase permanently
 - **Multi-provider support** - Works with Gmail, Outlook, Yahoo, Fastmail, and any standard IMAP provider
 
 ## Configuration
@@ -118,6 +119,15 @@ Some IMAP servers return incomplete results for body searches without reporting
 - **Recovery.** If the connection dies silently, the running sync gives up at the command time limit, records the error and releases its lock. The next sync reconnects on its own.
 - **Requirements.** Node 22.13 or later (uses the built-in `node:sqlite`, no native modules).
 
+### Finding duplicates
+
+Mail clients that file by tag sometimes append a fresh copy of a message instead of moving the one already on the server, which leaves the same message in a folder twice. `find_duplicates` reports those, using the Message-ID header as the identity of a message.
+
+- **Why Message-ID.** It is set by the sending server, it is unique, and it does not change when mail is moved. Matching on subject, sender and timestamp instead produces false pairs: in a fast thread two different replies can share a subject, a sender and a minute.
+- **Two shapes.** `scope: "same_folder"` finds a folder holding one message more than once. Those extra copies carry nothing unique, and the tool lists them under `redundant_copies` (lowest UID kept). `scope: "cross_folder"` finds a message present in several folders, usually a split thread. Do not resolve those by deleting: removing one copy only moves the problem.
+- **Honest coverage.** A message with no Message-ID header cannot be compared. It is counted in `coverage.without_message_id` rather than quietly skipped, and `index.complete` says whether the index had seen everything.
+- **Nothing is deleted.** The tool only reports. Acting on it means calling `delete_email`, which moves to Trash unless you pass `expunge: true`.
+
 ### Provider Settings
 
 | Provider | IMAP_HOST | SMTP_HOST | Notes |
@@ -139,12 +149,13 @@ Some IMAP servers return incomplete results for body searches without reporting
 | `search_index` | Full-text search of the local index (when `INDEX_ENABLED=true`); `index.warning` flags a stale index or folder errors |
 | `index_status` | Per-folder index coverage, last sync and errors |
 | `sync_index` | Run an index sync now |
+| `find_duplicates` | Messages that exist more than once, matched on Message-ID: filed twice in one folder, or spread across folders |
 | `list_drafts` | List all draft emails |
 | `get_draft` | Get a specific draft by UID |
 | `create_draft` | Create a new email draft |
 | `update_draft` | Update an existing draft |
 | `send_email` | Send an email directly |
-| `delete_email` | Delete an email by UID |
+| `delete_email` | Delete an email by UID. Moves to Trash unless `expunge: true` |
 | `download_attachment` | Download an attachment: ≤700KB returns inline base64, larger saves to disk (ATTACHMENT_DIR) |
 | `extract_text` | Extract plain text from a PDF, xlsx/xlsm/xls, docx, or text attachment in one call, parsed server-side |
 

package/index.js

@@ -31,7 +31,7 @@ import {
   buildCriteria
 } from './lib/imap-session.js';
 import { htmlToText, stripDataUris, leafParts } from './lib/mime-text.js';
-import { LocalIndex } from './lib/local-index.js';
+import { LocalIndex, normalizeMessageId } from './lib/local-index.js';
 
 const PKG_VERSION = createRequire(import.meta.url)('./package.json').version;
 
@@ -450,6 +450,45 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           description: 'Show the local index state: per-folder message counts on the server and in the index, whether backfill is complete, last sync time and errors.',
           inputSchema: { type: 'object', properties: {}, required: [] }
         },
+        {
+          name: 'find_duplicates',
+          description: 'List messages that exist more than once, matched on their Message-ID header. Message-ID is assigned by the sending server and survives moves, so it identifies a message reliably; matching on subject, sender and timestamp instead pairs up genuinely different messages in fast threads. scope "same_folder" finds a folder holding the same message twice, which is a filing error and whose extra copies are listed under redundant_copies. scope "cross_folder" finds a message sitting in several folders, usually a split thread; never resolve those by deleting, since that only relocates the problem. Check index.complete and coverage.without_message_id before treating the result as exhaustive.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              scope: {
+                type: 'string',
+                enum: ['all', 'same_folder', 'cross_folder'],
+                description: 'same_folder: one folder holds the message more than once; cross_folder: the message is in several folders; all: either (default)',
+                default: 'all'
+              },
+              folders: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Only these folders (default: all indexed folders). A copy outside this list is not counted.'
+              },
+              since_date: {
+                type: 'string',
+                description: 'Only messages delivered on or after this date (YYYY-MM-DD)'
+              },
+              before_date: {
+                type: 'string',
+                description: 'Only messages delivered before this date (YYYY-MM-DD)'
+              },
+              limit: {
+                type: 'number',
+                description: 'Maximum groups to return (default: 50, max: 500). total_groups reports the full count.',
+                default: 50
+              },
+              refresh: {
+                type: 'boolean',
+                description: 'Pick up new and moved mail before searching (default: true). Skipped while a background sync is running.',
+                default: true
+              }
+            },
+            required: []
+          }
+        },
         {
           name: 'sync_index',
           description: 'Run an index sync now and wait for it (up to wait_seconds). The index is read-only: syncing never changes anything on the mail server.',
@@ -670,7 +709,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: 'delete_email',
-        description: 'Delete an email by UID',
+        description: 'Delete an email by UID. By default the message is moved to the Trash folder, so it can still be recovered; the response says where it went. Pass expunge: true to erase it from the server instead, which cannot be undone. A message already in Trash is always erased.',
         inputSchema: {
           type: 'object',
           properties: {
@@ -682,6 +721,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               type: 'string',
               description: 'Folder name (default: INBOX)',
               default: 'INBOX'
+            },
+            expunge: {
+              type: 'boolean',
+              description: 'Erase the message from the server instead of moving it to Trash. Permanent and not recoverable (default: false).',
+              default: false
             }
           },
           required: ['uid']
@@ -812,7 +856,7 @@ async function connectIMAP() {
   return await sessions.acquire();
 }
 
-const LIST_HEADER_FIELDS = 'HEADER.FIELDS (FROM TO CC SUBJECT DATE)';
+const LIST_HEADER_FIELDS = 'HEADER.FIELDS (FROM TO CC SUBJECT DATE MESSAGE-ID)';
 const MAX_LIMIT = 200;
 
 function clampLimit(value, fallback = 20) {
@@ -839,6 +883,8 @@ async function summarize(connection, folder, uids, { withFlags = true } = {}) {
       subject: h.subject?.[0]
     };
     if (h.cc?.length) item.cc = h.cc.join(', ');
+    const messageId = normalizeMessageId(h['message-id']?.[0]);
+    if (messageId) item.message_id = messageId;
     if (withFlags) item.flags = rec.attributes.flags;
     out.push(item);
   }
@@ -850,6 +896,37 @@ function dateValue(item) {
   return Number.isNaN(t) ? 0 : t;
 }
 
+/**
+ * Find the mailbox that holds deleted mail.
+ *
+ * Prefers the folder the server itself flags as \Trash, since that is what the
+ * user's other mail clients will treat as the bin, and falls back to the usual
+ * names. Returns null when nothing plausible exists, which the caller reports
+ * rather than guessing and writing mail somewhere unexpected.
+ */
+async function findTrashFolder(connection) {
+  const boxes = await connection.getBoxes();
+  const walk = (node, prefix = '', out = []) => {
+    for (const [name, box] of Object.entries(node || {})) {
+      const full = prefix ? `${prefix}${box.delimiter || '/'}${name}` : name;
+      const attribs = (box.attribs || []).map((a) => String(a).toLowerCase());
+      if (box.special_use_attrib) attribs.push(String(box.special_use_attrib).toLowerCase());
+      out.push({ name: full, attribs, leaf: name });
+      if (box.children) walk(box.children, full, out);
+    }
+    return out;
+  };
+  const all = walk(boxes);
+  const selectable = all.filter((b) => !b.attribs.includes('\\noselect') && !b.attribs.includes('\\nonexistent'));
+
+  const flagged = selectable.find((b) => b.attribs.includes('\\trash'));
+  if (flagged) return flagged.name;
+
+  const known = ['trash', 'deleted items', 'deleted messages', 'bin', 'papierkorb', 'corbeille'];
+  const byName = selectable.find((b) => known.includes(b.leaf.toLowerCase()));
+  return byName ? byName.name : null;
+}
+
 // Helper to find drafts folder (handles different provider conventions)
 async function findDraftsFolder(connection) {
   const boxes = await connection.getBoxes();
@@ -986,6 +1063,7 @@ async function handleTool(name, args) {
                 cc: parsed.cc?.text,
                 subject: parsed.subject,
                 date: parsed.date,
+                ...(normalizeMessageId(parsed.messageId) && { message_id: normalizeMessageId(parsed.messageId) }),
                 text: (htmlOnly || !parsed.text) && parsed.html ? htmlToText(parsed.html) : (parsed.text || ''),
                 ...(htmlOnly && { text_source: 'converted from HTML' }),
                 ...(args.include_html && parsed.html && { html: stripDataUris(parsed.html) }),
@@ -1582,11 +1660,60 @@ async function handleTool(name, args) {
         const connection = await connectIMAP();
 
         try {
+          // Default to the recoverable path: move to Trash. Erasing is opt-in,
+          // because an expunge cannot be undone and a wrong uid is silent.
+          const trash = args.expunge ? null : await findTrashFolder(connection);
+          const alreadyInTrash = trash && trash.toLowerCase() === folder.toLowerCase();
+
           await connection.openBox(folder);
+
+          if (trash && !alreadyInTrash) {
+            await new Promise((resolve, reject) => {
+              connection.imap.move(args.uid, trash, (err) => (err ? reject(err) : resolve()));
+            });
+            return {
+              content: [{
+                type: 'text',
+                text: JSON.stringify({
+                  success: true,
+                  uid: args.uid,
+                  folder,
+                  action: 'moved_to_trash',
+                  trash_folder: trash,
+                  recoverable: true,
+                  note: `Moved to ${trash}. Pass expunge: true to erase permanently instead.`
+                }, null, 2)
+              }]
+            };
+          }
+
+          if (!args.expunge && !trash) {
+            // The caller asked for the recoverable path and it is not available.
+            // Erasing anyway would be a permanent action nobody asked for.
+            return {
+              content: [{
+                type: 'text',
+                text: `No Trash folder found on this server, so the message was left where it is. Pass expunge: true to erase uid ${args.uid} from ${folder} permanently, or create a Trash folder first.`
+              }],
+              isError: true
+            };
+          }
+
           await connection.addFlags(args.uid, ['\\Deleted']);
           await connection.closeBox(true); // Expunge
-
-          return { content: [{ type: 'text', text: 'Email deleted successfully' }] };
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                uid: args.uid,
+                folder,
+                action: 'expunged',
+                recoverable: false,
+                ...(alreadyInTrash && { reason: 'message was already in Trash' })
+              }, null, 2)
+            }]
+          };
         } finally {
           connection.end();
         }
@@ -1831,6 +1958,36 @@ async function handleTool(name, args) {
         return { content: [{ type: 'text', text: JSON.stringify(localIndex.status(), null, 2) }] };
       }
 
+      case 'find_duplicates': {
+        if (!localIndex) throw new Error(localIndexError || 'Local index is not enabled (set INDEX_ENABLED=true)');
+        let refresh = null;
+        if (args.refresh !== false) {
+          if (localIndex.running) {
+            refresh = 'skipped: background sync in progress';
+          } else {
+            const quick = localIndex.sync({ maxPerFolder: 300, passes: 1 });
+            const outcome = await Promise.race([
+              quick.then((r) => (r && r.skipped ? 'skipped' : 'done')),
+              new Promise((resolve) => setTimeout(() => resolve('timeout'), 20000))
+            ]);
+            refresh = {
+              done: 'done',
+              skipped: 'skipped: another server process is syncing the index',
+              timeout: 'partial: refresh still running in background'
+            }[outcome];
+          }
+        }
+        const found = localIndex.findDuplicates({
+          folders: args.folders || null,
+          scope: args.scope || 'all',
+          since_date: args.since_date || null,
+          before_date: args.before_date || null,
+          limit: args.limit
+        });
+        if (refresh) found.index = { ...found.index, refresh };
+        return { content: [{ type: 'text', text: JSON.stringify(found, null, 2) }] };
+      }
+
       case 'sync_index': {
         if (!localIndex) throw new Error(localIndexError || 'Local index is not enabled (set INDEX_ENABLED=true)');
         const waitMs = Math.max(0, Number(args.wait_seconds ?? 60)) * 1000;

package/lib/local-index.js

@@ -116,6 +116,23 @@ function ftsQuery(query, { match = 'all', prefix = false, field = 'any' } = {})
   return expr;
 }
 
+/**
+ * Compare form for a Message-ID header.
+ *
+ * Strips the surrounding angle brackets and whitespace and nothing else.
+ * Case is preserved on purpose: the local part of a Message-ID is
+ * case-sensitive per RFC 5322, and this value decides whether two messages
+ * are reported as copies of each other. A missed duplicate is a nuisance; a
+ * wrongly matched pair could cost someone a message, so this errs strict.
+ */
+export function normalizeMessageId(value) {
+  const s = String(value ?? '').trim();
+  if (!s) return null;
+  const m = s.match(/<([^<>]+)>/);
+  const id = (m ? m[1] : s.replace(/^<+|>+$/g, '')).trim();
+  return id || null;
+}
+
 export class LocalIndex {
   constructor({ imapConfig, dbPath, folders = null, excludeFolders = [], intervalMinutes = 5, batchSize = 100, maxBodyChars = 100000, log = console.error }) {
     this.imapConfig = imapConfig;
@@ -177,6 +194,7 @@ export class LocalIndex {
       );
       CREATE INDEX IF NOT EXISTS messages_date ON messages (internal_date);
       CREATE INDEX IF NOT EXISTS messages_folder_date ON messages (folder, internal_date);
+      CREATE INDEX IF NOT EXISTS messages_message_id ON messages (message_id);
       CREATE VIRTUAL TABLE IF NOT EXISTS fts USING fts5 (
         subject, from_addr, to_addr, attachments, body,
         tokenize = 'unicode61 remove_diacritics 2'
@@ -611,6 +629,148 @@ export class LocalIndex {
     };
   }
 
+  /** Sync health for a set of folders, shared by search() and findDuplicates(). */
+  _indexHealth(folderList = []) {
+    const st = this.status();
+    const scope = folderList.length ? st.folders.filter((f) => folderList.includes(f.folder)) : st.folders;
+    const warnings = [];
+    const lastFullMs = Number(this._meta('last_full_sync') || 0);
+    if (!lastFullMs) {
+      warnings.push('index has never completed a full sync, results may be missing mail');
+    } else if (Date.now() - lastFullMs > STALE_AFTER_MS) {
+      warnings.push(`index last synced ${describeAge(Date.now() - lastFullMs)} ago, results may be missing recent mail`);
+    }
+    const errored = scope.filter((f) => f.last_error);
+    if (errored.length) {
+      warnings.push(`folder error${errored.length === 1 ? '' : 's'}: ${errored.map((f) => `${f.folder} (${f.last_error})`).join(', ')}; results from ${errored.length === 1 ? 'that folder' : 'those folders'} may be incomplete`);
+    }
+    return {
+      complete: scope.length > 0 && scope.every((f) => f.complete && !f.last_error),
+      sync_running: st.sync_running,
+      oldest_folder_sync: scope.reduce((min, f) => (f.last_sync && (!min || f.last_sync < min) ? f.last_sync : min), null),
+      incomplete_folders: scope.filter((f) => !f.complete || f.last_error).map((f) => f.folder),
+      ...(warnings.length && { warning: warnings.join('; ') })
+    };
+  }
+
+  /**
+   * Find messages that exist more than once, keyed on Message-ID.
+   *
+   * Message-ID is assigned by the sending server and does not change when mail
+   * is moved, so it is the only dependable identity for a message across
+   * folders. Matching on subject, sender and timestamp instead produces false
+   * pairs on fast back-and-forth threads, where two genuinely different
+   * messages can share everything but the second.
+   *
+   * scope:
+   *   same_folder  one folder holds the message more than once. A filing
+   *                error: the extra copies carry nothing unique.
+   *   cross_folder the message sits in more than one folder. Usually a split
+   *                thread or a stray archive copy. Never resolve these by
+   *                deleting; deleting one copy only relocates the problem.
+   *   all          either of the above (default).
+   *
+   * Messages with no Message-ID header cannot be compared and are reported
+   * under coverage rather than silently ignored.
+   */
+  findDuplicates({ folders = null, scope = 'all', since_date = null, before_date = null, limit = 50 } = {}) {
+    if (!['all', 'same_folder', 'cross_folder'].includes(scope)) {
+      throw new Error(`Unknown scope: ${scope}. Use all, same_folder or cross_folder.`);
+    }
+    const folderList = Array.isArray(folders) ? folders.filter(Boolean) : (folders ? [folders] : []);
+    const where = [];
+    const params = [];
+    if (folderList.length) {
+      where.push(`folder IN (${folderList.map(() => '?').join(', ')})`);
+      params.push(...folderList);
+    }
+    if (since_date) {
+      where.push('internal_date >= ?');
+      params.push(localDate(since_date).getTime());
+    }
+    if (before_date) {
+      where.push('internal_date < ?');
+      params.push(localDate(before_date).getTime());
+    }
+    const scopeSql = where.length ? `WHERE ${where.join(' AND ')}` : '';
+    const hasId = "message_id IS NOT NULL AND trim(message_id) <> ''";
+    const andHasId = where.length ? `${scopeSql} AND ${hasId}` : `WHERE ${hasId}`;
+
+    const inScope = this.db.prepare(`SELECT count(*) AS n FROM messages ${scopeSql}`).get(...params).n;
+    const withId = this.db.prepare(`SELECT count(*) AS n FROM messages ${andHasId}`).get(...params).n;
+
+    // Pre-filter in SQL to the ids that occur more than once, then regroup in
+    // JS on the normalized id so bracket differences cannot split a group.
+    const key = "trim(replace(replace(message_id, '<', ''), '>', ''))";
+    const rows = this.db.prepare(`
+      SELECT folder, uid, message_id, subject, from_addr, internal_date, sent_date
+      FROM messages
+      ${andHasId} AND ${key} IN (
+        SELECT ${key} FROM messages ${andHasId} GROUP BY ${key} HAVING count(*) > 1
+      )
+      ORDER BY internal_date DESC, folder, uid`).all(...params, ...params);
+
+    const groups = new Map();
+    for (const r of rows) {
+      const id = normalizeMessageId(r.message_id);
+      if (!id) continue;
+      if (!groups.has(id)) groups.set(id, []);
+      groups.get(id).push(r);
+    }
+
+    const out = [];
+    for (const [message_id, copies] of groups) {
+      if (copies.length < 2) continue;
+      const byFolder = {};
+      for (const c of copies) byFolder[c.folder] = (byFolder[c.folder] || 0) + 1;
+      const sameFolder = Object.values(byFolder).some((n) => n > 1);
+      const crossFolder = Object.keys(byFolder).length > 1;
+      if (scope === 'same_folder' && !sameFolder) continue;
+      if (scope === 'cross_folder' && !crossFolder) continue;
+      const first = copies[0];
+      // Redundant copies only ever come from a folder holding the message more
+      // than once: within that folder keep the lowest uid and list the rest.
+      const redundant = [];
+      for (const [folder, n] of Object.entries(byFolder)) {
+        if (n < 2) continue;
+        const inFolder = copies.filter((c) => c.folder === folder).sort((a, b) => Number(a.uid) - Number(b.uid));
+        for (const c of inFolder.slice(1)) redundant.push({ folder, uid: Number(c.uid) });
+      }
+      out.push({
+        message_id,
+        subject: first.subject,
+        from: first.from_addr,
+        date: first.sent_date || (first.internal_date ? new Date(Number(first.internal_date)).toISOString() : null),
+        copies: copies.length,
+        same_folder_duplicates: sameFolder,
+        cross_folder: crossFolder,
+        by_folder: byFolder,
+        ...(redundant.length && { redundant_copies: redundant }),
+        messages: copies.map((c) => ({
+          folder: c.folder,
+          uid: Number(c.uid),
+          date: c.sent_date || (c.internal_date ? new Date(Number(c.internal_date)).toISOString() : null)
+        }))
+      });
+    }
+    out.sort((a, b) => (b.copies - a.copies) || String(b.date || '').localeCompare(String(a.date || '')));
+    const cap = Math.min(Math.max(1, Number(limit) || 50), 500);
+    return {
+      scope,
+      folders_searched: folderList.length ? folderList : 'all indexed folders',
+      coverage: {
+        messages_in_scope: inScope,
+        with_message_id: withId,
+        without_message_id: inScope - withId,
+        ...(inScope > withId && { note: 'messages without a Message-ID header cannot be compared and are not included' })
+      },
+      total_groups: out.length,
+      returned: Math.min(out.length, cap),
+      groups: out.slice(0, cap),
+      index: this._indexHealth(folderList)
+    };
+  }
+
   search({ query, folders = null, from = null, since_date = null, before_date = null, field = 'any', match = 'all', prefix = false, sort = 'date', limit = 20, offset = 0 }) {
     const where = ['fts MATCH ?'];
     const params = [ftsQuery(query, { match, prefix, field })];
@@ -638,37 +798,18 @@ export class LocalIndex {
 
     const total = this.db.prepare(`SELECT count(*) AS n FROM fts JOIN messages m ON m.id = fts.rowid WHERE ${whereSql}`).get(...params).n;
     const rows = this.db.prepare(`
-      SELECT m.folder, m.uid, m.internal_date, m.sent_date, m.from_addr, m.to_addr, m.subject, m.attachments,
+      SELECT m.folder, m.uid, m.internal_date, m.sent_date, m.from_addr, m.to_addr, m.subject, m.attachments, m.message_id,
              snippet(fts, -1, '[', ']', '...', 16) AS snippet
       FROM fts JOIN messages m ON m.id = fts.rowid
       WHERE ${whereSql}
       ORDER BY ${order}
       LIMIT ? OFFSET ?`).all(...params, cap, skip);
 
-    const st = this.status();
-    const scope = folderList.length ? st.folders.filter((f) => folderList.includes(f.folder)) : st.folders;
-    const warnings = [];
-    const lastFullMs = Number(this._meta('last_full_sync') || 0);
-    if (!lastFullMs) {
-      warnings.push('index has never completed a full sync, results may be missing mail');
-    } else if (Date.now() - lastFullMs > STALE_AFTER_MS) {
-      warnings.push(`index last synced ${describeAge(Date.now() - lastFullMs)} ago, results may be missing recent mail`);
-    }
-    const errored = scope.filter((f) => f.last_error);
-    if (errored.length) {
-      warnings.push(`folder error${errored.length === 1 ? '' : 's'}: ${errored.map((f) => `${f.folder} (${f.last_error})`).join(', ')}; results from ${errored.length === 1 ? 'that folder' : 'those folders'} may be incomplete`);
-    }
     return {
       total_matches: total,
       returned: rows.length,
       offset: skip,
-      index: {
-        complete: scope.length > 0 && scope.every((f) => f.complete && !f.last_error),
-        sync_running: st.sync_running,
-        oldest_folder_sync: scope.reduce((min, f) => (f.last_sync && (!min || f.last_sync < min) ? f.last_sync : min), null),
-        incomplete_folders: scope.filter((f) => !f.complete || f.last_error).map((f) => f.folder),
-        ...(warnings.length && { warning: warnings.join('; ') })
-      },
+      index: this._indexHealth(folderList),
       results: rows.map((r) => ({
         folder: r.folder,
         uid: Number(r.uid),
@@ -676,6 +817,7 @@ export class LocalIndex {
         from: r.from_addr,
         to: r.to_addr,
         subject: r.subject,
+        message_id: normalizeMessageId(r.message_id) || undefined,
         attachments: r.attachments || undefined,
         snippet: r.snippet
       }))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lengelhard/imap-email-mcp",
-  "version": "1.7.4",
+  "version": "1.8.0",
   "description": "MCP server for Claude Code that provides email capabilities through IMAP/SMTP. Read, search, compose, and manage emails from any IMAP provider.",
   "type": "module",
   "main": "index.js",