hypermail-mcp 0.7.12 → 0.7.14

package/dist/cli.js

@@ -13954,18 +13954,81 @@ async function tryKeytarSet(key) {
   }
 }
 
+// src/logger.ts
+var noopLogger = {
+  debug: () => void 0
+};
+var REDACTED = "[redacted]";
+var SENSITIVE_FIELD = /token|secret|password|credential|key|body|content/i;
+function createLogger(opts) {
+  if (!opts.enabled) return noopLogger;
+  const write = opts.write ?? ((line) => process.stderr.write(line));
+  return {
+    debug(component, event, fields = {}) {
+      try {
+        const payload = {
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          pid: process.pid,
+          component,
+          event,
+          ...sanitizeFields(fields)
+        };
+        write(`[hypermail-mcp] debug ${JSON.stringify(payload)}
+`);
+      } catch {
+      }
+    }
+  };
+}
+function sanitizeFields(fields) {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(fields)) {
+    sanitized[key] = sanitizeValue(key, value, 0);
+  }
+  return sanitized;
+}
+function sanitizeValue(key, value, depth) {
+  if (SENSITIVE_FIELD.test(key)) return REDACTED;
+  if (value === null || value === void 0) return value;
+  const valueType = typeof value;
+  if (valueType === "string" || valueType === "number" || valueType === "boolean") {
+    return value;
+  }
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) {
+    if (depth >= 2) return `[array:${value.length}]`;
+    return value.map((item) => sanitizeValue(key, item, depth + 1));
+  }
+  if (valueType === "object") {
+    if (depth >= 2) return "[object]";
+    const out = {};
+    for (const [childKey, childValue] of Object.entries(value)) {
+      out[childKey] = sanitizeValue(childKey, childValue, depth + 1);
+    }
+    return out;
+  }
+  return String(value);
+}
+
 // src/store/account-store.ts
 var FILE_NAME = "accounts.json.enc";
+var LOCK_STALE_MS = 3e4;
+var LOCK_TIMEOUT_MS = 1e4;
+var LOCK_RETRY_MS = 25;
 var AccountStore = class _AccountStore {
-  constructor(filePath, key, data) {
+  constructor(filePath, key, data, logger) {
     this.filePath = filePath;
     this.key = key;
     this.data = data;
+    this.logger = logger;
+    this.lockPath = `${filePath}.lock`;
   }
   filePath;
   key;
   data;
+  logger;
   writeLocks = /* @__PURE__ */ new Map();
+  lockPath;
   static async open(opts = {}) {
     const dataDir = resolveDataDir(opts.dataDir);
     await fs2.mkdir(dataDir, { recursive: true, mode: 448 });
@@ -13982,7 +14045,12 @@ var AccountStore = class _AccountStore {
         throw err;
       }
     }
-    return new _AccountStore(filePath, key, data);
+    const logger = opts.logger ?? noopLogger;
+    logger.debug("account-store", "open", {
+      filePath,
+      accountCount: data.accounts.length
+    });
+    return new _AccountStore(filePath, key, data, logger);
   }
   listAccounts() {
     return this.data.accounts.map((a) => ({ ...a }));
@@ -13993,62 +14061,181 @@ var AccountStore = class _AccountStore {
     return rec ? { ...rec } : void 0;
   }
   async upsertAccount(rec) {
-    return this.runSerial(rec.email, async () => {
+    return this.runSerial(rec.email, async () => this.updateLocked((data) => {
       const norm = rec.email.trim().toLowerCase();
+      const idx = data.accounts.findIndex((a) => a.email.toLowerCase() === norm);
+      const current = idx >= 0 ? data.accounts[idx] : void 0;
       const next = { ...rec, email: norm };
-      const idx = this.data.accounts.findIndex((a) => a.email.toLowerCase() === norm);
-      if (idx >= 0) this.data.accounts[idx] = next;
-      else this.data.accounts.push(next);
-      await this.flush();
-      return { ...next };
-    });
+      const mergedCheckpoint = mergeNewEmailCheckpoints(
+        current?.newEmailCheckpoint,
+        rec.newEmailCheckpoint
+      );
+      if (mergedCheckpoint) next.newEmailCheckpoint = mergedCheckpoint;
+      else delete next.newEmailCheckpoint;
+      if (idx >= 0) data.accounts[idx] = next;
+      else data.accounts.push(next);
+      this.logger.debug("account-store", "upsertAccount", {
+        email: norm,
+        existed: idx >= 0,
+        checkpointReceivedAt: mergedCheckpoint?.receivedAt ?? null,
+        deliveredIdCount: mergedCheckpoint?.deliveredIdsAtReceivedAt?.length ?? 0,
+        changed: true
+      });
+      return { result: { ...next }, changed: true };
+    }));
   }
   async updateTokens(email, tokens) {
-    return this.runSerial(email, async () => {
+    return this.runSerial(email, async () => this.updateLocked((data) => {
       const norm = email.trim().toLowerCase();
-      const idx = this.data.accounts.findIndex((a) => a.email.toLowerCase() === norm);
-      if (idx < 0) return void 0;
-      const current = this.data.accounts[idx];
+      const idx = data.accounts.findIndex((a) => a.email.toLowerCase() === norm);
+      if (idx < 0) {
+        this.logger.debug("account-store", "updateTokens", {
+          email: norm,
+          found: false,
+          changed: false
+        });
+        return { result: void 0, changed: false };
+      }
+      const current = data.accounts[idx];
       const next = { ...current, tokens };
-      this.data.accounts[idx] = next;
-      await this.flush();
-      return { ...next };
-    });
+      data.accounts[idx] = next;
+      this.logger.debug("account-store", "updateTokens", {
+        email: norm,
+        found: true,
+        fieldCount: Object.keys(tokens).length,
+        storedCheckpointReceivedAt: current.newEmailCheckpoint?.receivedAt ?? null,
+        storedDeliveredIdCount: current.newEmailCheckpoint?.deliveredIdsAtReceivedAt?.length ?? 0,
+        changed: true
+      });
+      return { result: { ...next }, changed: true };
+    }));
   }
   async updateNewEmailCheckpoint(email, checkpoint) {
-    return this.runSerial(email, async () => {
+    return this.runSerial(email, async () => this.updateLocked((data) => {
       const norm = email.trim().toLowerCase();
-      const idx = this.data.accounts.findIndex((a) => a.email.toLowerCase() === norm);
-      if (idx < 0) return void 0;
-      const current = this.data.accounts[idx];
-      const currentCheckpoint = current.newEmailCheckpoint;
-      const mergedCheckpoint = currentCheckpoint?.receivedAt === checkpoint.receivedAt ? {
-        receivedAt: checkpoint.receivedAt,
-        deliveredIdsAtReceivedAt: [
-          .../* @__PURE__ */ new Set([
-            ...currentCheckpoint.deliveredIdsAtReceivedAt ?? [],
-            ...checkpoint.deliveredIdsAtReceivedAt ?? []
-          ])
-        ]
-      } : checkpoint;
+      const idx = data.accounts.findIndex((a) => a.email.toLowerCase() === norm);
+      if (idx < 0) {
+        this.logger.debug("account-store", "updateNewEmailCheckpoint", {
+          email: norm,
+          found: false,
+          incomingReceivedAt: checkpoint.receivedAt,
+          incomingDeliveredIdCount: checkpoint.deliveredIdsAtReceivedAt?.length ?? 0,
+          changed: false
+        });
+        return { result: void 0, changed: false };
+      }
+      const current = data.accounts[idx];
+      const mergedCheckpoint = mergeNewEmailCheckpoints(
+        current.newEmailCheckpoint,
+        checkpoint
+      );
+      if (!mergedCheckpoint) {
+        this.logger.debug("account-store", "updateNewEmailCheckpoint", {
+          email: norm,
+          found: true,
+          incomingReceivedAt: checkpoint.receivedAt,
+          incomingDeliveredIdCount: checkpoint.deliveredIdsAtReceivedAt?.length ?? 0,
+          changed: false
+        });
+        return { result: { ...current }, changed: false };
+      }
       const next = {
         ...current,
         newEmailCheckpoint: mergedCheckpoint
       };
-      this.data.accounts[idx] = next;
-      await this.flush();
-      return { ...next };
-    });
+      data.accounts[idx] = next;
+      this.logger.debug("account-store", "updateNewEmailCheckpoint", {
+        email: norm,
+        found: true,
+        currentReceivedAt: current.newEmailCheckpoint?.receivedAt ?? null,
+        incomingReceivedAt: checkpoint.receivedAt,
+        mergedReceivedAt: mergedCheckpoint.receivedAt,
+        mergedDeliveredIdCount: mergedCheckpoint.deliveredIdsAtReceivedAt?.length ?? 0,
+        changed: true
+      });
+      return { result: { ...next }, changed: true };
+    }));
+  }
+  async claimNewEmails(email, candidates) {
+    return this.runSerial(email, async () => this.updateLocked((data) => {
+      const norm = email.trim().toLowerCase();
+      const idx = data.accounts.findIndex((a) => a.email.toLowerCase() === norm);
+      if (idx < 0 || candidates.length === 0) {
+        this.logger.debug("account-store", "claimNewEmails", {
+          email: norm,
+          found: idx >= 0,
+          candidateCount: candidates.length,
+          candidateIds: candidates.map((candidate) => candidate.summaryId),
+          claimedCount: 0,
+          changed: false
+        });
+        return { result: [], changed: false };
+      }
+      const account = data.accounts[idx];
+      let checkpoint = normalizeCheckpoint(account.newEmailCheckpoint);
+      const claimed = [];
+      const ordered = [...candidates].sort((a, b) => {
+        const byTime = compareTimestamp(normalizeTimestamp(a.receivedAt) ?? a.receivedAt, normalizeTimestamp(b.receivedAt) ?? b.receivedAt);
+        if (byTime !== 0) return byTime;
+        return a.summaryId.localeCompare(b.summaryId);
+      });
+      for (const candidate of ordered) {
+        const receivedAt = normalizeTimestamp(candidate.receivedAt);
+        if (!receivedAt) continue;
+        const ids = uniqueIds([candidate.summaryId, ...candidate.ids]);
+        if (ids.length === 0) continue;
+        if (isAlreadyDelivered(checkpoint, receivedAt, ids)) continue;
+        claimed.push(candidate.summaryId);
+        checkpoint = mergeNewEmailCheckpoints(checkpoint, {
+          receivedAt,
+          deliveredIdsAtReceivedAt: ids
+        });
+      }
+      if (claimed.length === 0 || !checkpoint) {
+        this.logger.debug("account-store", "claimNewEmails", {
+          email: norm,
+          found: true,
+          candidateCount: candidates.length,
+          candidateIds: candidates.map((candidate) => candidate.summaryId),
+          claimedCount: claimed.length,
+          claimedIds: claimed,
+          checkpointReceivedAt: checkpoint?.receivedAt ?? null,
+          deliveredIdCount: checkpoint?.deliveredIdsAtReceivedAt?.length ?? 0,
+          changed: false
+        });
+        return { result: claimed, changed: false };
+      }
+      const next = {
+        ...account,
+        newEmailCheckpoint: checkpoint
+      };
+      data.accounts[idx] = next;
+      this.logger.debug("account-store", "claimNewEmails", {
+        email: norm,
+        found: true,
+        candidateCount: candidates.length,
+        candidateIds: candidates.map((candidate) => candidate.summaryId),
+        claimedCount: claimed.length,
+        claimedIds: claimed,
+        checkpointReceivedAt: checkpoint.receivedAt,
+        deliveredIdCount: checkpoint.deliveredIdsAtReceivedAt?.length ?? 0,
+        changed: true
+      });
+      return { result: claimed, changed: true };
+    }));
   }
   async removeAccount(email) {
-    return this.runSerial(email, async () => {
+    return this.runSerial(email, async () => this.updateLocked((data) => {
       const norm = email.trim().toLowerCase();
-      const before = this.data.accounts.length;
-      this.data.accounts = this.data.accounts.filter((a) => a.email.toLowerCase() !== norm);
-      if (this.data.accounts.length === before) return false;
-      await this.flush();
-      return true;
-    });
+      const before = data.accounts.length;
+      data.accounts = data.accounts.filter((a) => a.email.toLowerCase() !== norm);
+      const changed = data.accounts.length !== before;
+      this.logger.debug("account-store", "removeAccount", {
+        email: norm,
+        changed
+      });
+      return { result: changed, changed };
+    }));
   }
   async runSerial(email, task) {
     const norm = email.trim().toLowerCase();
@@ -14067,11 +14254,146 @@ var AccountStore = class _AccountStore {
       }
     }
   }
+  async updateLocked(task) {
+    return this.withFileLock(async () => {
+      this.data = await this.readLatest();
+      const { result, changed } = await task(this.data);
+      if (changed) await this.flush();
+      return result;
+    });
+  }
+  async readLatest() {
+    try {
+      const buf = await fs2.readFile(this.filePath);
+      return decrypt(buf, this.key);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return { version: 1, accounts: [] };
+      }
+      throw err;
+    }
+  }
   async flush() {
     const buf = encrypt(this.data, this.key);
     await writeAtomic(this.filePath, buf);
+    this.logger.debug("account-store", "flush", {
+      filePath: this.filePath,
+      accountCount: this.data.accounts.length
+    });
+  }
+  async withFileLock(task) {
+    await this.acquireFileLock();
+    try {
+      return await task();
+    } finally {
+      await fs2.rm(this.lockPath, { recursive: true, force: true });
+      this.logger.debug("account-store", "lockReleased", {
+        lockPath: this.lockPath
+      });
+    }
+  }
+  async acquireFileLock() {
+    const startedAt = Date.now();
+    let loggedWait = false;
+    while (true) {
+      try {
+        await fs2.mkdir(this.lockPath, { mode: 448 });
+        await fs2.writeFile(
+          path2.join(this.lockPath, "owner"),
+          `${process.pid}
+${(/* @__PURE__ */ new Date()).toISOString()}
+`,
+          { mode: 384 }
+        );
+        this.logger.debug("account-store", "lockAcquired", {
+          lockPath: this.lockPath,
+          waitedMs: Date.now() - startedAt
+        });
+        return;
+      } catch (err) {
+        if (err.code !== "EEXIST") throw err;
+        if (!loggedWait) {
+          this.logger.debug("account-store", "lockWait", {
+            lockPath: this.lockPath
+          });
+          loggedWait = true;
+        }
+        await this.removeStaleLock();
+        if (Date.now() - startedAt > LOCK_TIMEOUT_MS) {
+          this.logger.debug("account-store", "lockTimeout", {
+            lockPath: this.lockPath,
+            waitedMs: Date.now() - startedAt
+          });
+          throw new Error(`timed out waiting for account store lock: ${this.lockPath}`);
+        }
+        await delay(LOCK_RETRY_MS);
+      }
+    }
+  }
+  async removeStaleLock() {
+    try {
+      const stat = await fs2.stat(this.lockPath);
+      if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+        await fs2.rm(this.lockPath, { recursive: true, force: true });
+        this.logger.debug("account-store", "staleLockRemoved", {
+          lockPath: this.lockPath,
+          staleMs: Date.now() - stat.mtimeMs
+        });
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
   }
 };
+function normalizeCheckpoint(checkpoint) {
+  const receivedAt = normalizeTimestamp(checkpoint?.receivedAt);
+  if (!receivedAt) return void 0;
+  return {
+    receivedAt,
+    deliveredIdsAtReceivedAt: uniqueIds(checkpoint?.deliveredIdsAtReceivedAt ?? [])
+  };
+}
+function mergeNewEmailCheckpoints(current, incoming) {
+  const normalizedCurrent = normalizeCheckpoint(current);
+  const normalizedIncoming = normalizeCheckpoint(incoming);
+  if (!normalizedIncoming) return normalizedCurrent;
+  if (!normalizedCurrent) return normalizedIncoming;
+  const comparison = compareTimestamp(normalizedIncoming.receivedAt, normalizedCurrent.receivedAt);
+  if (comparison > 0) return normalizedIncoming;
+  if (comparison < 0) return normalizedCurrent;
+  return {
+    receivedAt: normalizedCurrent.receivedAt,
+    deliveredIdsAtReceivedAt: uniqueIds([
+      ...normalizedCurrent.deliveredIdsAtReceivedAt ?? [],
+      ...normalizedIncoming.deliveredIdsAtReceivedAt ?? []
+    ])
+  };
+}
+function isAlreadyDelivered(checkpoint, receivedAt, ids) {
+  if (!checkpoint) return false;
+  const comparison = compareTimestamp(receivedAt, checkpoint.receivedAt);
+  if (comparison < 0) return true;
+  if (comparison > 0) return false;
+  const delivered = new Set(checkpoint.deliveredIdsAtReceivedAt ?? []);
+  return ids.some((id) => delivered.has(id));
+}
+function normalizeTimestamp(value) {
+  if (!value) return void 0;
+  const ms = Date.parse(value);
+  if (!Number.isFinite(ms)) return void 0;
+  return new Date(ms).toISOString();
+}
+function compareTimestamp(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+function uniqueIds(ids) {
+  return [...new Set(ids.filter((id) => id.length > 0))];
+}
+async function delay(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 // src/providers/outlook/index.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -14490,8 +14812,8 @@ async function updateDraft(client, account, id, update) {
       payload.attachments = converted.attachments;
     }
   }
-  await client.api(`/me/messages/${encodeURIComponent(id)}`).patch(payload);
-  return { id };
+  const updated = await client.api(`/me/messages/${encodeURIComponent(id)}`).header("Prefer", "return=representation").patch(payload);
+  return { id: updated?.id ?? id };
 }
 async function addAttachmentToDraft(client, account, draftId, name, contentBytes, contentType) {
   const att = await client.api(`/me/messages/${encodeURIComponent(draftId)}/attachments`).post({
@@ -14744,6 +15066,9 @@ var OutlookProvider = class {
   async moveEmail(account, id, destinationId) {
     return moveEmail(this.clients.get(account), account, id, destinationId);
   }
+  async trashEmail(account, id) {
+    return moveEmail(this.clients.get(account), account, id, "deleteditems");
+  }
   async sendDraft(account, id) {
     return sendDraft(this.clients.get(account), account, id);
   }
@@ -14910,6 +15235,21 @@ var WELL_KNOWN_TO_IMAP = {
 function resolveFolder(wellKnownOrPath) {
   return WELL_KNOWN_TO_IMAP[wellKnownOrPath.toLowerCase()] ?? wellKnownOrPath;
 }
+function isTrashFolderAlias(wellKnownOrPath) {
+  const lower = wellKnownOrPath.toLowerCase();
+  return lower === "deleteditems" || lower === "trash";
+}
+function resolveTrashMailbox(mailboxes) {
+  for (const mailbox of mailboxes) {
+    const specialUse = mailbox.specialUse?.toLowerCase();
+    if (specialUse === "\\trash") return mailbox.path;
+    const flags = mailbox.flags ? Array.from(mailbox.flags) : [];
+    if (flags.some((flag) => flag.toLowerCase() === "\\trash")) {
+      return mailbox.path;
+    }
+  }
+  return "Trash";
+}
 function clampLimit2(v, dflt, max) {
   if (!v || v <= 0) return dflt;
   return Math.min(v, max);
@@ -15380,6 +15720,9 @@ async function updateDraft2(clients, account, id, update) {
   });
 }
 async function moveEmail2(clients, account, id, destinationId) {
+  if (isTrashFolderAlias(destinationId)) {
+    return trashEmail(clients, account, id);
+  }
   const client = clients.get(account);
   const { folder, uid } = decodeId(id);
   const dest = resolveFolder(destinationId);
@@ -15387,6 +15730,17 @@ async function moveEmail2(clients, account, id, destinationId) {
     await imap.messageMove(uid, dest, { uid: true });
   });
 }
+async function trashEmail(clients, account, id) {
+  const client = clients.get(account);
+  const { folder, uid } = decodeId(id);
+  const imap = await client.getImap();
+  const dest = resolveTrashMailbox(
+    await imap.list()
+  );
+  return client.withMailbox(folder, async (lockedImap) => {
+    await lockedImap.messageMove(uid, dest, { uid: true });
+  });
+}
 async function sendDraft2(clients, account, id) {
   const client = clients.get(account);
   const { folder, uid } = decodeId(id);
@@ -15599,6 +15953,9 @@ var ImapProvider = class {
   async moveEmail(account, id, destinationId) {
     return moveEmail2(this.clients, account, id, destinationId);
   }
+  async trashEmail(account, id) {
+    return trashEmail(this.clients, account, id);
+  }
   async sendDraft(account, id) {
     return sendDraft2(this.clients, account, id);
   }
@@ -16355,7 +16712,14 @@ async function updateDraft3(clients, account, id, update) {
   });
   return { id: updated.data.message?.id ?? updated.data.id ?? id };
 }
+function isTrashDestination(destinationId) {
+  const lower = destinationId.toLowerCase();
+  return lower === "deleteditems" || lower === "trash";
+}
 async function moveEmail3(clients, account, id, destinationId) {
+  if (isTrashDestination(destinationId)) {
+    return trashEmail2(clients, account, id);
+  }
   const { gmail } = clients.get(account);
   const { addLabelIds, removeLabelIds } = resolveLabelsForMove(destinationId);
   await gmail.users.messages.modify({
@@ -16364,6 +16728,13 @@ async function moveEmail3(clients, account, id, destinationId) {
     requestBody: { addLabelIds, removeLabelIds }
   });
 }
+async function trashEmail2(clients, account, id) {
+  const { gmail } = clients.get(account);
+  await gmail.users.messages.trash({
+    userId: "me",
+    id
+  });
+}
 async function sendDraft3(clients, account, id) {
   const { gmail } = clients.get(account);
   const res = await gmail.users.drafts.send({
@@ -16685,6 +17056,9 @@ var GmailProvider = class {
   async moveEmail(account, id, destinationId) {
     return moveEmail3(this.clients, account, id, destinationId);
   }
+  async trashEmail(account, id) {
+    return trashEmail2(this.clients, account, id);
+  }
   async sendDraft(account, id) {
     return sendDraft3(this.clients, account, id);
   }
@@ -17150,7 +17524,7 @@ var BODY_LIMIT = 2e4;
 var PAGE_SIZE = 100;
 var MISSING_RECEIVED_AT = "1970-01-01T00:00:00.000Z";
 function registerNewEmailTool(server, ctx) {
-  const { store, registry, tools } = ctx;
+  const { store, registry, tools, logger = noopLogger } = ctx;
   if (!shouldRegister("get_new_emails", tools)) return;
   const newEmailOutputSchema = z4.object({
     account: z4.string(),
@@ -17192,20 +17566,46 @@ function registerNewEmailTool(server, ctx) {
     },
     async (args) => {
       const limit = args.limit ?? DEFAULT_LIMIT;
+      logger.debug("get-new-emails", "start", {
+        account: args.account ?? null,
+        limit
+      });
       if (args.account) {
         try {
           const { provider, account } = registry.resolveByEmail(args.account);
-          const result = await collectCandidatesForAccount(store, provider, account);
+          const result = await collectCandidatesForAccount(store, provider, account, logger);
           const selected2 = oldestCandidatesFirst(result.candidates).slice(0, limit);
-          const emails2 = limit === 0 ? [] : await hydrateAndAdvance(store, provider, result.account, selected2);
+          logger.debug("get-new-emails", "selected", {
+            account: result.account.email,
+            candidateCount: result.candidates.length,
+            selectedCount: selected2.length,
+            selectedIds: selected2.map((candidate) => candidate.summary.id),
+            selectedReceivedAt: selected2.map((candidate) => candidate.timestamp),
+            limit
+          });
+          const emails2 = limit === 0 ? [] : await hydrateAndAdvance(store, provider, result.account, selected2, logger);
           const data2 = { count: emails2.length, emails: emails2, errors: [] };
+          logger.debug("get-new-emails", "end", {
+            account: result.account.email,
+            returnedCount: emails2.length,
+            errorCount: 0
+          });
           return ok(data2, data2);
         } catch (err) {
+          logger.debug("get-new-emails", "error", {
+            account: args.account,
+            message: errMsg(err)
+          });
           return fail(errMsg(err));
         }
       }
       const accounts = store.listAccounts();
       if (accounts.length === 0) {
+        logger.debug("get-new-emails", "end", {
+          accountCount: 0,
+          returnedCount: 0,
+          errorCount: 1
+        });
         return fail("no accounts registered. Call add_account first.");
       }
       const errors = [];
@@ -17215,15 +17615,27 @@ function registerNewEmailTool(server, ctx) {
       for (const stored of accounts) {
         try {
           const { provider, account } = registry.resolveByEmail(stored.email);
-          const result = await collectCandidatesForAccount(store, provider, account);
+          const result = await collectCandidatesForAccount(store, provider, account, logger);
           providersByEmail.set(result.account.email, provider);
           accountsByEmail.set(result.account.email, result.account);
           collected.push(...result.candidates);
         } catch (err) {
+          logger.debug("get-new-emails", "accountError", {
+            account: stored.email,
+            message: errMsg(err)
+          });
           errors.push({ account: stored.email, message: errMsg(err) });
         }
       }
       const selected = oldestCandidatesFirst(collected).slice(0, limit);
+      logger.debug("get-new-emails", "selected", {
+        accountCount: accounts.length,
+        candidateCount: collected.length,
+        selectedCount: selected.length,
+        selectedIds: selected.map((candidate) => candidate.summary.id),
+        selectedReceivedAt: selected.map((candidate) => candidate.timestamp),
+        limit
+      });
       const emails = [];
       if (limit > 0) {
         const byAccount = /* @__PURE__ */ new Map();
@@ -17242,24 +17654,39 @@ function registerNewEmailTool(server, ctx) {
                 store,
                 provider,
                 account,
-                accountCandidates
+                accountCandidates,
+                logger
               )
             );
           } catch (err) {
+            logger.debug("get-new-emails", "accountError", {
+              account: email,
+              message: errMsg(err)
+            });
             errors.push({ account: email, message: errMsg(err) });
           }
         }
       }
       const orderedEmails = emails.sort(compareNewEmailOutputOldestFirst);
       const data = { count: orderedEmails.length, emails: orderedEmails, errors };
+      logger.debug("get-new-emails", "end", {
+        accountCount: accounts.length,
+        returnedCount: orderedEmails.length,
+        errorCount: errors.length
+      });
       return ok(data, data);
     }
   );
 }
-async function collectCandidatesForAccount(store, provider, account) {
-  const checkpoint = normalizeCheckpoint(account.newEmailCheckpoint);
+async function collectCandidatesForAccount(store, provider, account, logger) {
+  const checkpoint = normalizeCheckpoint2(account.newEmailCheckpoint);
   if (!checkpoint) {
-    await initializeCheckpoint(store, provider, account);
+    await initializeCheckpoint(store, provider, account, logger);
+    logger.debug("get-new-emails", "candidatesCollected", {
+      account: account.email,
+      initialized: true,
+      candidateCount: 0
+    });
     return { account, candidates: [] };
   }
   const deliveredAtCheckpoint = new Set(checkpoint.deliveredIdsAtReceivedAt ?? []);
@@ -17275,7 +17702,7 @@ async function collectCandidatesForAccount(store, provider, account) {
     let sawOlderThanCheckpoint = false;
     for (const item of items) {
       const timestamp = effectiveReceivedAt(item.receivedAt);
-      const comparison = compareTimestamp(timestamp, checkpoint.receivedAt);
+      const comparison = compareTimestamp2(timestamp, checkpoint.receivedAt);
       if (comparison > 0) {
         candidates.push({ account, summary: item, timestamp });
       } else if (comparison === 0) {
@@ -17289,9 +17716,18 @@ async function collectCandidatesForAccount(store, provider, account) {
     if (sawOlderThanCheckpoint || !hasMore) break;
     skip += items.length;
   }
+  logger.debug("get-new-emails", "candidatesCollected", {
+    account: account.email,
+    initialized: false,
+    checkpointReceivedAt: checkpoint.receivedAt,
+    deliveredIdCount: checkpoint.deliveredIdsAtReceivedAt?.length ?? 0,
+    candidateCount: candidates.length,
+    candidateIds: candidates.map((candidate) => candidate.summary.id),
+    candidateReceivedAt: candidates.map((candidate) => candidate.timestamp)
+  });
   return { account, candidates };
 }
-async function initializeCheckpoint(store, provider, account) {
+async function initializeCheckpoint(store, provider, account, logger) {
   const { items } = await provider.listEmails(account, {
     folder: "inbox",
     limit: PAGE_SIZE
@@ -17303,16 +17739,50 @@ async function initializeCheckpoint(store, provider, account) {
     receivedAt,
     deliveredIdsAtReceivedAt
   });
+  logger.debug("get-new-emails", "checkpointInitialized", {
+    account: account.email,
+    receivedAt,
+    deliveredIdCount: deliveredIdsAtReceivedAt.length
+  });
 }
-async function hydrateAndAdvance(store, provider, account, selected) {
-  if (selected.length === 0) return [];
-  const emails = [];
+async function hydrateAndAdvance(store, provider, account, selected, logger) {
+  if (selected.length === 0) {
+    logger.debug("get-new-emails", "hydrated", {
+      account: account.email,
+      selectedCount: 0,
+      hydratedCount: 0,
+      claimedCount: 0
+    });
+    return [];
+  }
+  const hydrated = [];
   for (const candidate of selected) {
     const full = await provider.readEmail(account, candidate.summary.id);
-    emails.push(formatNewEmail(account.email, full, candidate.summary));
+    hydrated.push({
+      candidate,
+      email: formatNewEmail(account.email, full, candidate.summary),
+      fullId: full.id
+    });
   }
-  await advanceCheckpoint(store, account, selected);
-  return emails;
+  const claims = hydrated.map(({ candidate, fullId }) => ({
+    summaryId: candidate.summary.id,
+    receivedAt: candidate.timestamp,
+    ids: [candidate.summary.id, fullId]
+  }));
+  logger.debug("get-new-emails", "hydrated", {
+    account: account.email,
+    selectedCount: selected.length,
+    hydratedCount: hydrated.length
+  });
+  const claimed = new Set(await store.claimNewEmails(account.email, claims));
+  logger.debug("get-new-emails", "claimed", {
+    account: account.email,
+    claimCount: claims.length,
+    claimedCount: claimed.size,
+    claimIds: claims.map((claim) => claim.summaryId),
+    claimedIds: [...claimed]
+  });
+  return hydrated.filter(({ candidate }) => claimed.has(candidate.summary.id)).map(({ email }) => email);
 }
 function formatNewEmail(account, msg, summary) {
   const body = selectBody(msg, "markdown");
@@ -17337,19 +17807,8 @@ function formatNewEmail(account, msg, summary) {
     bodyOriginalLength: body.length
   };
 }
-async function advanceCheckpoint(store, account, selected) {
-  const ordered = oldestCandidatesFirst(selected);
-  const newest = ordered[ordered.length - 1];
-  if (!newest) return;
-  const newestTimestamp = newest.timestamp;
-  const idsAtNewest = ordered.filter((candidate) => candidate.timestamp === newestTimestamp).map((candidate) => candidate.summary.id);
-  await store.updateNewEmailCheckpoint(account.email, {
-    receivedAt: newestTimestamp,
-    deliveredIdsAtReceivedAt: idsAtNewest
-  });
-}
-function normalizeCheckpoint(checkpoint) {
-  const receivedAt = normalizeTimestamp(checkpoint?.receivedAt);
+function normalizeCheckpoint2(checkpoint) {
+  const receivedAt = normalizeTimestamp2(checkpoint?.receivedAt);
   if (!receivedAt) return null;
   return {
     receivedAt,
@@ -17357,9 +17816,9 @@ function normalizeCheckpoint(checkpoint) {
   };
 }
 function effectiveReceivedAt(receivedAt) {
-  return normalizeTimestamp(receivedAt) ?? MISSING_RECEIVED_AT;
+  return normalizeTimestamp2(receivedAt) ?? MISSING_RECEIVED_AT;
 }
-function normalizeTimestamp(value) {
+function normalizeTimestamp2(value) {
   if (!value) return null;
   const ms = Date.parse(value);
   if (!Number.isFinite(ms)) return null;
@@ -17367,20 +17826,20 @@ function normalizeTimestamp(value) {
 }
 function oldestCandidatesFirst(items) {
   return [...items].sort((a, b) => {
-    const byTimestamp = compareTimestamp(a.timestamp, b.timestamp);
+    const byTimestamp = compareTimestamp2(a.timestamp, b.timestamp);
     if (byTimestamp !== 0) return byTimestamp;
     return a.summary.id.localeCompare(b.summary.id);
   });
 }
 function compareNewEmailOutputOldestFirst(a, b) {
-  const byTimestamp = compareTimestamp(
+  const byTimestamp = compareTimestamp2(
     effectiveReceivedAt(a.receivedAt),
     effectiveReceivedAt(b.receivedAt)
   );
   if (byTimestamp !== 0) return byTimestamp;
   return a.id.localeCompare(b.id);
 }
-function compareTimestamp(a, b) {
+function compareTimestamp2(a, b) {
   if (a < b) return -1;
   if (a > b) return 1;
   return 0;
@@ -17388,7 +17847,7 @@ function compareTimestamp(a, b) {
 
 // src/tools/browse.ts
 function registerBrowseTools(server, ctx) {
-  const { store, registry, tools } = ctx;
+  const { store, registry, tools, logger } = ctx;
   const emailListOutputSchema = z5.object({
     account: z5.string(),
     count: z5.number(),
@@ -17438,7 +17897,7 @@ function registerBrowseTools(server, ctx) {
       }
     );
   }
-  registerNewEmailTool(server, { store, registry, tools });
+  registerNewEmailTool(server, { store, registry, tools, logger });
   if (shouldRegister("search_emails", tools)) {
     server.registerTool(
       "search_emails",
@@ -17713,6 +18172,12 @@ function registerOrganizeTools(server, ctx) {
     const data = { marked: true, id: args.id, isRead };
     return ok(data, data);
   }
+  async function trashMessage(args) {
+    const { provider, account } = registry.resolveByEmail(args.account);
+    await provider.trashEmail(account, args.id);
+    const data = { trashed: true, id: args.id };
+    return ok(data, data);
+  }
   const archiveMoveSchema = z7.object({
     account: z7.string().email(),
     id: z7.string().min(1).describe("Message ID to move")
@@ -17752,7 +18217,7 @@ function registerOrganizeTools(server, ctx) {
       },
       async (args) => {
         try {
-          return await moveToWellKnown(args, "deleteditems", "trashed");
+          return await trashMessage(args);
         } catch (err) {
           return fail(errMsg(err));
         }
@@ -17840,7 +18305,7 @@ function registerOrganizeTools(server, ctx) {
 }
 
 // src/tools/compose.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 import { readFileSync } from "fs";
 import { basename, extname } from "path";
 
@@ -17871,42 +18336,106 @@ var MIME_TYPES = {
   ".mp4": "video/mp4"
 };
 
+// src/tools/edit-draft-verify.ts
+var EDIT_DRAFT_VERIFY_DELAYS_MS = [250, 1e3, 2e3];
+function normalizeDraftBody2(body) {
+  return body.replace(/\r\n/g, "\n").trim();
+}
+function bodyEditPersisted(actualBody, expectation) {
+  const actual = normalizeDraftBody2(actualBody);
+  const expected = normalizeDraftBody2(expectation.expectedBody);
+  if (actual === expected) return true;
+  const oldText = normalizeDraftBody2(expectation.oldText);
+  const replacementBody = normalizeDraftBody2(expectation.replacementBody);
+  if (oldText === replacementBody) {
+    return actual.includes(replacementBody);
+  }
+  return actual.includes(replacementBody) && !actual.includes(oldText);
+}
+function delay2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function readDraftWithVerifiedBody(provider, account, id, expectation) {
+  let draft = await provider.readEmail(account, id);
+  for (const delayMs of EDIT_DRAFT_VERIFY_DELAYS_MS) {
+    const body2 = draft.bodyHtml ?? draft.bodyText ?? "";
+    if (bodyEditPersisted(body2, expectation)) return draft;
+    await delay2(delayMs);
+    draft = await provider.readEmail(account, id);
+  }
+  const body = draft.bodyHtml ?? draft.bodyText ?? "";
+  return bodyEditPersisted(body, expectation) ? draft : void 0;
+}
+
+// src/tools/compose-schemas.ts
+import { z as z8 } from "zod";
+var sendEmailSchema = z8.object({
+  account: z8.string().email(),
+  to: z8.array(emailAddrSchema).min(1),
+  cc: z8.array(emailAddrSchema).optional(),
+  bcc: z8.array(emailAddrSchema).optional(),
+  subject: z8.string(),
+  body: z8.string(),
+  format: z8.enum(["html", "markdown"]).describe(
+    "Body format. 'html' sends the body as-is (must be valid HTML). 'markdown' converts the body from Markdown to HTML for clean rendering on the recipient side."
+  ),
+  include_signature: z8.boolean().describe(
+    "Whether to append the account's saved HTML signature to the email. If true, don't include a signature in the body param to avoid double signature. Returns an error if true but no signature is configured for this account."
+  ),
+  inReplyTo: z8.union([z8.string(), z8.literal(false)]).describe(
+    "Message ID to reply to. When set, sends as a threaded reply which includes the quoted thread history automatically. Set to `false` for a new email (not a reply)."
+  ),
+  replyAll: z8.boolean().default(false).optional().describe(
+    "When true and `inReplyTo` is set, reply to all recipients instead of just the sender."
+  ),
+  forwardMessageId: z8.string().optional().describe(
+    "Message ID to forward. When set, sends as a forward of the specified message, preserving the original content. Mutually exclusive with `inReplyTo`."
+  ),
+  attachments: z8.array(
+    z8.object({
+      filePath: z8.string().min(1).describe("Absolute path to a local file"),
+      name: z8.string().optional().describe("Attachment filename. Defaults to the file's basename.")
+    })
+  ).optional().describe(
+    "File attachments to include. The server reads the files from disk and base64-encodes them automatically."
+  )
+});
+var editDraftSchema = z8.object({
+  account: z8.string().email(),
+  id: z8.string().min(1).describe("Draft message ID to edit"),
+  to: z8.array(emailAddrSchema).optional(),
+  cc: z8.array(emailAddrSchema).optional(),
+  bcc: z8.array(emailAddrSchema).optional(),
+  subject: z8.string().optional(),
+  old_text: z8.string().min(1).optional().describe(
+    "Exact current HTML section to replace in the draft body. Copy this from `draftHtml` or from `read_email` with format='html'. Must match exactly once; unselected content is preserved."
+  ),
+  new_text: z8.string().optional().describe(
+    "Replacement content for `old_text`. The replacement is composed using `format` and `include_signature`, then inserted exactly where `old_text` matched."
+  ),
+  body: z8.string().optional().describe(
+    "Deprecated alias for `new_text`. Body-only full replacement is not supported; provide `old_text` with this field."
+  ),
+  format: z8.enum(["html", "markdown"]).optional().describe(
+    "Replacement format. Only meaningful when `new_text` or deprecated `body` is also provided. 'html' inserts the replacement as-is (must be valid HTML). 'markdown' converts the replacement from Markdown to HTML."
+  ),
+  include_signature: z8.boolean().optional().describe(
+    "Whether to append the account's saved HTML signature to the replacement section. If true, don't include a signature in `new_text`/`body`. Only meaningful when replacement content is provided. Returns an error if true but no signature is configured for this account."
+  ),
+  new_attachments: z8.array(
+    z8.object({
+      filePath: z8.string().min(1).describe("Absolute path to a local file"),
+      name: z8.string().optional().describe("Attachment filename. Defaults to the file's basename.")
+    })
+  ).optional().describe(
+    "New file attachments to add to the draft. The server reads the files from disk and base64-encodes them automatically."
+  ),
+  remove_attachments: z8.array(z8.string().min(1)).optional().describe("Attachment IDs to remove from the draft. Get attachment IDs from read_email.")
+});
+
 // src/tools/compose.ts
 function registerComposeTools(server, ctx) {
   const { store, registry, tools } = ctx;
-  const sendEmailSchema = z8.object({
-    account: z8.string().email(),
-    to: z8.array(emailAddrSchema).min(1),
-    cc: z8.array(emailAddrSchema).optional(),
-    bcc: z8.array(emailAddrSchema).optional(),
-    subject: z8.string(),
-    body: z8.string(),
-    format: z8.enum(["html", "markdown"]).describe(
-      "Body format. 'html' sends the body as-is (must be valid HTML). 'markdown' converts the body from Markdown to HTML for clean rendering on the recipient side."
-    ),
-    include_signature: z8.boolean().describe(
-      "Whether to append the account's saved HTML signature to the email. If true, don't include a signature in the body param to avoid double signature. Returns an error if true but no signature is configured for this account."
-    ),
-    inReplyTo: z8.union([z8.string(), z8.literal(false)]).describe(
-      "Message ID to reply to. When set, sends as a threaded reply which includes the quoted thread history automatically. Set to `false` for a new email (not a reply)."
-    ),
-    replyAll: z8.boolean().default(false).optional().describe(
-      "When true and `inReplyTo` is set, reply to all recipients instead of just the sender."
-    ),
-    forwardMessageId: z8.string().optional().describe(
-      "Message ID to forward. When set, sends as a forward of the specified message, preserving the original content. Mutually exclusive with `inReplyTo`."
-    ),
-    attachments: z8.array(
-      z8.object({
-        filePath: z8.string().min(1).describe("Absolute path to a local file"),
-        name: z8.string().optional().describe(
-          "Attachment filename. Defaults to the file's basename."
-        )
-      })
-    ).optional().describe(
-      "File attachments to include. The server reads the files from disk and base64-encodes them automatically."
-    )
-  });
   async function handleSendOrDraft(args, action, resultKey, toolName) {
     try {
       const { provider, account } = registry.resolveByEmail(args.account);
@@ -17962,8 +18491,8 @@ function registerComposeTools(server, ctx) {
     }
   }
   const sendEmailOutputSchema = {
-    sent: z8.literal(true),
-    id: z8.string()
+    sent: z9.literal(true),
+    id: z9.string()
   };
   if (shouldRegister("send_email", tools)) {
     server.registerTool(
@@ -17982,9 +18511,9 @@ function registerComposeTools(server, ctx) {
     );
   }
   const draftEmailOutputSchema = {
-    draft: z8.literal(true),
-    id: z8.string(),
-    draftHtml: z8.string().optional()
+    draft: z9.literal(true),
+    id: z9.string(),
+    draftHtml: z9.string().optional()
   };
   if (shouldRegister("draft_email", tools)) {
     server.registerTool(
@@ -18002,46 +18531,10 @@ function registerComposeTools(server, ctx) {
       )
     );
   }
-  const editDraftSchema = z8.object({
-    account: z8.string().email(),
-    id: z8.string().min(1).describe("Draft message ID to edit"),
-    to: z8.array(emailAddrSchema).optional(),
-    cc: z8.array(emailAddrSchema).optional(),
-    bcc: z8.array(emailAddrSchema).optional(),
-    subject: z8.string().optional(),
-    old_text: z8.string().min(1).optional().describe(
-      "Exact current HTML section to replace in the draft body. Copy this from `draftHtml` or from `read_email` with format='html'. Must match exactly once; unselected content is preserved."
-    ),
-    new_text: z8.string().optional().describe(
-      "Replacement content for `old_text`. The replacement is composed using `format` and `include_signature`, then inserted exactly where `old_text` matched."
-    ),
-    body: z8.string().optional().describe(
-      "Deprecated alias for `new_text`. Body-only full replacement is not supported; provide `old_text` with this field."
-    ),
-    format: z8.enum(["html", "markdown"]).optional().describe(
-      "Replacement format. Only meaningful when `new_text` or deprecated `body` is also provided. 'html' inserts the replacement as-is (must be valid HTML). 'markdown' converts the replacement from Markdown to HTML."
-    ),
-    include_signature: z8.boolean().optional().describe(
-      "Whether to append the account's saved HTML signature to the replacement section. If true, don't include a signature in `new_text`/`body`. Only meaningful when replacement content is provided. Returns an error if true but no signature is configured for this account."
-    ),
-    new_attachments: z8.array(
-      z8.object({
-        filePath: z8.string().min(1).describe("Absolute path to a local file"),
-        name: z8.string().optional().describe(
-          "Attachment filename. Defaults to the file's basename."
-        )
-      })
-    ).optional().describe(
-      "New file attachments to add to the draft. The server reads the files from disk and base64-encodes them automatically."
-    ),
-    remove_attachments: z8.array(z8.string().min(1)).optional().describe(
-      "Attachment IDs to remove from the draft. Get attachment IDs from read_email."
-    )
-  });
   const editDraftOutputSchema = {
-    edited: z8.literal(true),
-    id: z8.string(),
-    draftHtml: z8.string().optional()
+    edited: z9.literal(true),
+    id: z9.string(),
+    draftHtml: z9.string().optional()
   };
   if (shouldRegister("edit_draft", tools)) {
     server.registerTool(
@@ -18080,6 +18573,7 @@ function registerComposeTools(server, ctx) {
           }
           let bodyPayload;
           let isHtmlPayload;
+          let bodyExpectation;
           if (replacementText !== void 0) {
             const existing = await provider.readEmail(account, a.id);
             const existingBody = existing.bodyHtml ?? existing.bodyText ?? "";
@@ -18092,6 +18586,11 @@ function registerComposeTools(server, ctx) {
             });
             bodyPayload = applyExactTextEdit(existingBody, a.old_text ?? "", composed.body);
             isHtmlPayload = composed.isHtml;
+            bodyExpectation = {
+              expectedBody: bodyPayload,
+              oldText: a.old_text ?? "",
+              replacementBody: composed.body
+            };
           }
           const hasDraftUpdate = a.to !== void 0 || a.cc !== void 0 || a.bcc !== void 0 || a.subject !== void 0 || bodyPayload !== void 0;
           let currentId = a.id;
@@ -18134,7 +18633,35 @@ function registerComposeTools(server, ctx) {
               removedIds.push(attId);
             }
           }
-          const draft = await provider.readEmail(account, currentId);
+          let draft;
+          if (bodyExpectation) {
+            draft = await readDraftWithVerifiedBody(
+              provider,
+              account,
+              currentId,
+              bodyExpectation
+            );
+            if (!draft && provider.id === "outlook" && bodyPayload !== void 0) {
+              const res = await provider.updateDraft(account, currentId, {
+                body: bodyPayload,
+                isHtml: isHtmlPayload
+              });
+              currentId = res.id;
+              draft = await readDraftWithVerifiedBody(
+                provider,
+                account,
+                currentId,
+                bodyExpectation
+              );
+            }
+            if (!draft) {
+              return fail(
+                "Draft body edit was not observable after saving. Retry edit_draft, or recreate the draft with draft_email before sending."
+              );
+            }
+          } else {
+            draft = await provider.readEmail(account, currentId);
+          }
           const result = {
             edited: true,
             id: currentId,
@@ -18148,8 +18675,8 @@ function registerComposeTools(server, ctx) {
     );
   }
   const sendDraftOutputSchema = {
-    sent: z8.literal(true),
-    id: z8.string()
+    sent: z9.literal(true),
+    id: z9.string()
   };
   if (shouldRegister("send_draft", tools)) {
     server.registerTool(
@@ -18157,8 +18684,8 @@ function registerComposeTools(server, ctx) {
       {
         description: "Send an existing draft email by ID. Use this with draft IDs returned by `draft_email` or `edit_draft`. Disabled in --read-only mode.",
         inputSchema: {
-          account: z8.string().email(),
-          id: z8.string().min(1).describe("Draft message ID to send")
+          account: z9.string().email(),
+          id: z9.string().min(1).describe("Draft message ID to send")
         },
         outputSchema: sendDraftOutputSchema
       },
@@ -18178,9 +18705,9 @@ function registerComposeTools(server, ctx) {
 
 // src/tools/index.ts
 function registerTools(server, opts) {
-  const { store, registry, tools } = opts;
+  const { store, registry, tools, logger } = opts;
   registerAccountTools(server, { store, registry, tools });
-  registerBrowseTools(server, { store, registry, tools });
+  registerBrowseTools(server, { store, registry, tools, logger });
   registerFolderTools(server, { registry, tools });
   registerOrganizeTools(server, { registry, tools });
   registerComposeTools(server, { store, registry, tools });
@@ -18189,7 +18716,7 @@ function registerTools(server, opts) {
 // package.json
 var package_default = {
   name: "hypermail-mcp",
-  version: "0.7.12",
+  version: "0.7.14",
   description: "Unified email MCP server \u2014 operate any inbox (Outlook now, IMAP/Gmail later) by passing an email address.",
   type: "module",
   bin: {
@@ -18269,6 +18796,7 @@ var ENV_HTTP_PORT = "HYPERMAIL_HTTP_PORT";
 var ENV_HTTP_HOST = "HYPERMAIL_HTTP_HOST";
 var ENV_TOOLS_DISABLED = "HYPERMAIL_TOOLS_DISABLED";
 var ENV_TOOLS_ENABLED = "HYPERMAIL_TOOLS_ENABLED";
+var ENV_DEBUG = "HYPERMAIL_DEBUG";
 var ENV_OUTLOOK_CLIENT_ID = "HYPERMAIL_OUTLOOK_CLIENT_ID";
 var ENV_OUTLOOK_TENANT_ID = "HYPERMAIL_OUTLOOK_TENANT_ID";
 var ENV_GMAIL_CLIENT_ID = "HYPERMAIL_GMAIL_CLIENT_ID";
@@ -18309,6 +18837,15 @@ function parseStringArray(value) {
   if (trimmed === "") return [];
   return trimmed.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
 }
+function resolveDebugLogging(warnings) {
+  const value = envRaw(ENV_DEBUG);
+  if (value === void 0 || value.trim() === "") return false;
+  const lower = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on", "debug"].includes(lower)) return true;
+  if (["0", "false", "no", "off"].includes(lower)) return false;
+  warnings.push(`Invalid ${ENV_DEBUG}; debug logging disabled.`);
+  return false;
+}
 function validateToolNames(toolNames, envName) {
   if (!toolNames || toolNames.length === 0) return;
   const known = new Set(KNOWN_TOOLS);
@@ -18390,6 +18927,7 @@ function loadConfig(cliOverrides = {}) {
   const tools = resolveToolsConfig();
   const providers = resolveProvidersConfig();
   const dataDir = cliOverrides.dataDir ?? optionalEnvString(ENV_DATA_DIR);
+  const debugLogging = resolveDebugLogging(warnings);
   if (!optionalEnvString(ENV_KEY)) {
     warnings.push(
       `${ENV_KEY} is not set; a local generated key will be used. Set ${ENV_KEY} explicitly for portable hosted deployments.`
@@ -18401,7 +18939,8 @@ function loadConfig(cliOverrides = {}) {
       transport,
       http,
       tools,
-      providers
+      providers,
+      debugLogging
     },
     warnings
   };
@@ -18447,7 +18986,16 @@ function resolveTools(config) {
 // src/server.ts
 async function startServer(opts) {
   const { config } = opts;
-  const store = await AccountStore.open({ dataDir: config.dataDir });
+  const logger = createLogger({ enabled: config.debugLogging });
+  const dataDir = resolveDataDir(config.dataDir);
+  logger.debug("server", "startup", {
+    version: VERSION,
+    transport: config.transport,
+    dataDir,
+    toolsEnabled: config.tools?.enabled ?? null,
+    toolsDisabled: config.tools?.disabled ?? null
+  });
+  const store = await AccountStore.open({ dataDir, logger });
   const registry = buildRegistry({ store, providers: config.providers });
   const tools = resolveTools(config);
   const createServer = () => {
@@ -18455,7 +19003,7 @@ async function startServer(opts) {
       { name: "hypermail-mcp", version: VERSION },
       { capabilities: { tools: {}, logging: {} } }
     );
-    registerTools(s, { store, registry, tools });
+    registerTools(s, { store, registry, tools, logger });
     return s;
   };
   if (config.transport === "http") {
@@ -18646,6 +19194,7 @@ Core environment variables:
   HYPERMAIL_HTTP_HOST
   HYPERMAIL_TOOLS_ENABLED
   HYPERMAIL_TOOLS_DISABLED
+  HYPERMAIL_DEBUG=1|true|yes|on|debug
 
 Provider environment variables:
   HYPERMAIL_OUTLOOK_CLIENT_ID