@bobfrankston/mailx 1.0.338 → 1.0.340

package/bin/mailx.js

@@ -909,6 +909,53 @@ async function main() {
         }
     }
     const db = new MailxDB(getConfigDir());
+    // Auto-create the sending/ recovery README on every startup. Stays in
+    // sync with the running version of mailx; user can ignore once the
+    // disk-staging fallback is no longer needed.
+    try {
+        const sendingDir = path.join(getConfigDir(), "sending");
+        fs.mkdirSync(sendingDir, { recursive: true });
+        const readmePath = path.join(sendingDir, "README.md");
+        const readmeBody = `# \`~/.mailx/sending/\` and \`~/.mailx/outbox/\` — outgoing-mail staging
+
+Auto-generated by mailx on startup. Manual recovery reference for when mailx is broken or you need to feed an outgoing message into another mail program.
+
+## Layout
+
+\`\`\`
+~/.mailx/
+├── outbox/<account>/
+│   └── *.ltr                  ← THE QUEUE. Worker scans every 10s, sends, deletes on success.
+└── sending/<account>/
+    ├── editing/               ← Last 3 draft autosaves while composing.
+    ├── queued/                ← Manual drop-in / crash-recovery copies.
+    └── sent/                  ← Audit trail of successfully sent messages.
+\`\`\`
+
+In-flight files are atomically renamed to \`<file>.sending-<host>-<pid>\` while the worker is processing them — same-machine claim so two mailx instances don't double-send. Stale claims (dead PIDs on this host) are recovered on the next tick.
+
+## Manual fallback
+
+- **mailx is dead, need to send a draft** — most recent file in \`sending/<account>/editing/\` is a complete RFC 822 message; copy the body into another mail client and resend.
+- **Feed a raw .eml to mailx** — drop into \`sending/<account>/queued/\`. Picked up within 10s.
+- **mailx says queued but server doesn't have it** — look in \`outbox/<account>/\`. \`.ltr\` still there → worker hasn't sent yet (check \`~/.mailx/logs/\`). \`.sending-<host>-<pid>\` → in flight. Gone → success.
+
+## Format
+
+RFC 5322 with CRLF line endings. Bodies are quoted-printable encoded (readable in a text editor). Every message carries \`Message-ID:\` for cross-device dedup; \`X-Mailx-Retry\` marks retry attempts.
+`;
+        // Only rewrite if content drifted (avoids gratuitous mtime updates).
+        let existing = "";
+        try {
+            existing = fs.readFileSync(readmePath, "utf-8");
+        }
+        catch { /* missing */ }
+        if (existing !== readmeBody)
+            fs.writeFileSync(readmePath, readmeBody);
+    }
+    catch (e) {
+        console.error(`  [readme] Could not write sending README: ${e?.message || e}`);
+    }
     const { NodeTcpTransport } = await import("@bobfrankston/node-tcp-transport");
     const imapManager = new ImapManager(db, () => new NodeTcpTransport());
     // Native client is the only option (iflow-direct)
@@ -1119,6 +1166,9 @@ async function main() {
     imapManager.on("configChanged", (filename) => {
         handle.send({ _event: "configChanged", type: "configChanged", filename });
     });
+    imapManager.on("outboxStatus", (status) => {
+        handle.send({ _event: "outboxStatus", type: "outboxStatus", ...status });
+    });
     // syncComplete drives the folder-tree refresh that picks up newly-discovered
     // folders on first run (Gmail accounts have no folders in the DB until the
     // first sync fetches the labels). Without this forward, the UI shows the

package/client/app.js

@@ -1335,6 +1335,9 @@ onWsEvent((event) => {
                 statusSync.textContent = `Error: ${event.message}`;
             showAlert(event.message, "ws-error");
             break;
+        case "outboxStatus":
+            renderOutboxStatus(event);
+            break;
         case "accountError": {
             // Show actual error + hint in banner
             const msg = `${event.accountId}: ${event.error}`;
@@ -2208,6 +2211,57 @@ else
             }
         }
     }, 5000);
+// ── Outbox queue indicator (status-queue span) ──
+// Event-driven in IPC mode (service pushes outboxStatus on every mutation).
+// Plus a 15s poll safety net for both modes so a missed event doesn't leave
+// the user staring at stale numbers. Idempotent — renderOutboxStatus just
+// overwrites the text.
+function renderOutboxStatus(s) {
+    const el = document.getElementById("status-queue");
+    if (!el)
+        return;
+    if (!s || !s.total || s.total === 0) {
+        el.textContent = "";
+        el.title = "";
+        el.style.color = "";
+        return;
+    }
+    const parts = [`✉ ${s.total} queued`];
+    if (s.claimed > 0)
+        parts.push(`${s.claimed} sending`);
+    if (s.retrying > 0)
+        parts.push(`${s.retrying} retrying (×${s.maxAttempts})`);
+    if (s.oldestAgeSec >= 60) {
+        const age = s.oldestAgeSec >= 3600
+            ? `${Math.floor(s.oldestAgeSec / 3600)}h`
+            : `${Math.floor(s.oldestAgeSec / 60)}m`;
+        parts.push(`oldest ${age}`);
+    }
+    el.textContent = parts.join(" · ");
+    const perAcct = s.perAccount || {};
+    const detail = Object.keys(perAcct).sort().map(a => `${a}: ${perAcct[a].total} total, ${perAcct[a].claimed} sending, ${perAcct[a].retrying} retrying`).join("\n");
+    el.title = detail || "";
+    // Orange when retrying, red when stuck >5min, else muted.
+    el.style.color = s.oldestAgeSec > 300 ? "oklch(0.65 0.2 25)"
+        : s.retrying > 0 ? "oklch(0.75 0.15 60)"
+            : "";
+}
+setInterval(async () => {
+    try {
+        const { getOutboxStatus } = await import("./lib/api-client.js");
+        const s = await getOutboxStatus();
+        renderOutboxStatus(s);
+    }
+    catch { /* service unreachable */ }
+}, 15000);
+// First read on startup so the bar isn't blank.
+(async () => {
+    try {
+        const { getOutboxStatus } = await import("./lib/api-client.js");
+        renderOutboxStatus(await getOutboxStatus());
+    }
+    catch { /* */ }
+})();
 console.log("mailx client initialized, location:", location.href);
 updateNewMessageCount();
 // ── Midnight refresh — update date display when day changes ──

package/client/compose/compose.js

@@ -528,7 +528,7 @@ function scheduleDraftSave() {
 document.getElementById("btn-send")?.addEventListener("click", async () => {
     const btn = document.getElementById("btn-send");
     btn.disabled = true;
-    btn.textContent = "Sending...";
+    btn.textContent = "Sending…";
     const body = {
         from: getFromAccountId(),
         fromAddress: getFromAddress(),
@@ -540,11 +540,22 @@ document.getElementById("btn-send")?.addEventListener("click", async () => {
         bodyText: editor.getText(),
         attachments: attachments.map(a => ({ filename: a.filename, mimeType: a.mimeType, dataBase64: a.dataBase64 })),
     };
+    console.log(`[compose] Send clicked: from=${body.from} to=${JSON.stringify(body.to)} subject="${body.subject}" attachments=${body.attachments.length}`);
+    // Live countdown so the user sees the IPC is alive. Hard timeout is 120s.
+    const sendStart = Date.now();
+    const sendTick = setInterval(() => {
+        const sec = Math.floor((Date.now() - sendStart) / 1000);
+        if (sec < 2)
+            btn.textContent = "Sending…";
+        else if (sec < 10)
+            btn.textContent = `Queueing… (${sec}s)`;
+        else
+            btn.textContent = `Still working… (${sec}s of 120s)`;
+    }, 500);
     try {
         await sendMessage(body);
-        // Delete draft after successful send — stop auto-save first so it can't
-        // append a fresh copy after we delete. Use the stored draftId as a fallback
-        // so any orphaned drafts with the same stable ID are cleaned up too.
+        clearInterval(sendTick);
+        console.log(`[compose] Send IPC returned OK in ${Date.now() - sendStart}ms`);
         if (draftTimer) {
             clearInterval(draftTimer);
             draftTimer = null;
@@ -555,23 +566,20 @@ document.getElementById("btn-send")?.addEventListener("click", async () => {
         closeCompose();
     }
     catch (e) {
+        clearInterval(sendTick);
+        const msg = e?.message || String(e);
+        console.error(`[compose] Send IPC failed after ${Date.now() - sendStart}ms: ${msg}`);
         btn.disabled = false;
         btn.textContent = "Send";
-        const msg = e?.message || String(e);
-        // Distinguish the IPC-timeout case from real send failures. The
-        // service-side send() queues the message to the local DB synchronously
-        // before attempting any IMAP/SMTP work — so if the IPC reached Node at
-        // all, the message is queued and the background worker will retry it
-        // with backoff (X-Mailx-Retry header, 60s settling delay, up to 10
-        // attempts). Treating that as a failure that demands a re-click leads
-        // to duplicate sends. Tell the user honestly: "probably queued, check
-        // Outbox before retrying."
         if (msg.startsWith("mailxapi timeout")) {
-            alert("Send is taking longer than expected.\n\n" +
-                "The message has likely been queued and will be retried in the background. " +
-                "Check the Outbox folder before clicking Send again — clicking Send now may " +
-                "produce a duplicate.\n\n" +
-                "Your draft is preserved either way.");
+            // Disk-first queueing means the .ltr file should be on disk even
+            // if the IPC reply itself was lost. Tell the user where to look.
+            alert(`Send IPC timed out after 120s.\n\n` +
+                `If the disk-first queue was reached, the message is in:\n` +
+                `~/.mailx/outbox/${getFromAccountId()}/*.ltr\n\n` +
+                `Don't click Send again — it could double-send. Check that ` +
+                `directory first (and the log) before deciding.\n\n` +
+                `Your draft is preserved either way.`);
         }
         else {
             alert(`Send failed: ${msg}`);

package/client/lib/api-client.js

@@ -62,6 +62,9 @@ export function reauthenticate(accountId) {
 export function getSyncPending() {
     return ipc().getSyncPending();
 }
+export function getOutboxStatus() {
+    return ipc().getOutboxStatus();
+}
 export function searchContacts(query) {
     return ipc().searchContacts(query);
 }

package/client/lib/mailxapi.js

@@ -140,6 +140,7 @@
         syncAll: function() { return callNode("syncAll"); },
         syncAccount: function(accountId) { return callNode("syncAccount", { accountId: accountId }); },
         getSyncPending: function() { return callNode("getSyncPending"); },
+        getOutboxStatus: function() { return callNode("getOutboxStatus"); },
         reauthenticate: function(accountId) { return callNode("reauthenticate", { accountId: accountId }); },
 
         // Bulk operations

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.338",
+  "version": "1.0.340",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -25,7 +25,7 @@
     "@bobfrankston/miscinfo": "^1.0.9",
     "@bobfrankston/oauthsupport": "^1.0.24",
     "@bobfrankston/msger": "^0.1.344",
-    "@bobfrankston/mailx-host": "^0.1.3",
+    "@bobfrankston/mailx-host": "^0.1.4",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
     "@capacitor/core": "^8.3.0",
@@ -89,7 +89,7 @@
       "@bobfrankston/miscinfo": "^1.0.9",
       "@bobfrankston/oauthsupport": "^1.0.24",
       "@bobfrankston/msger": "^0.1.344",
-      "@bobfrankston/mailx-host": "^0.1.3",
+      "@bobfrankston/mailx-host": "^0.1.4",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",
       "@capacitor/core": "^8.3.0",

package/packages/mailx-host/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-host",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Host abstraction for mailx — dispatches to msger or msgview",
   "type": "module",
   "main": "index.js",

package/packages/mailx-host/types-shim.d.ts

@@ -0,0 +1,14 @@
+// Stub for `marked` — pulled in transitively via msger → msgcommon → markdown.ts.
+// mailx-host doesn't use marked at runtime; the type chain only references it
+// because msgcommon ships markdown.ts alongside its other modules. Without
+// this shim, tsc errors with "Cannot find module 'marked'" while building
+// mailx-host. The proper fix is `npm install` inside msgcommon (which has
+// marked declared as a dep) or installing marked at the mailx root; this
+// shim is a fallback so the build doesn't block on either.
+declare module "marked" {
+    export const marked: {
+        parse(input: string, opts?: any): string | Promise<string>;
+        Renderer: any;
+        [k: string]: any;
+    };
+}

package/packages/mailx-imap/index.d.ts

@@ -23,6 +23,24 @@ export interface ImapManagerEvents {
      *  the UI flip a row's "not-downloaded" indicator without re-rendering. */
     bodyCached: (accountId: string, uid: number) => void;
     syncActionFailed: (accountId: string, action: string, uid: number, error: string) => void;
+    /** Fired whenever the outbox queue depth or state changes (file added,
+     *  file sent and removed, retry attempted). Lets the UI show a persistent
+     *  queue-status indicator without polling. Aggregate status across all
+     *  accounts is included so the listener doesn't have to reassemble it. */
+    outboxStatus: (status: OutboxStatus) => void;
+}
+/** Per-account outbox queue breakdown, plus totals for the UI. */
+export interface OutboxStatus {
+    total: number;
+    retrying: number;
+    claimed: number;
+    oldestAgeSec: number;
+    maxAttempts: number;
+    perAccount: Record<string, {
+        total: number;
+        retrying: number;
+        claimed: number;
+    }>;
 }
 export declare class ImapManager extends EventEmitter {
     private configs;
@@ -231,6 +249,12 @@ export declare class ImapManager extends EventEmitter {
      *  sync_actions "send" branch was removed because it duplicated the same
      *  work and risked double-send when both paths fired on the same message. */
     queueOutgoingLocal(accountId: string, rawMessage: string): void;
+    /** Scan the local outbox + sending/queued dirs and return counts + age.
+     *  Cheap — a handful of readdir + head-read per file. Called by both the
+     *  polling UI (status bar) and emitted as an event after queue mutations. */
+    getOutboxStatus(): OutboxStatus;
+    /** Emit outboxStatus now. Call after any queue mutation. */
+    private emitOutboxStatus;
     /** Guard against concurrent processSendActions for the same account */
     private sendingAccounts;
     /** Process local send actions — APPEND to Outbox, which the outbox worker then sends */

package/packages/mailx-imap/index.js

@@ -1640,10 +1640,42 @@ export class ImapManager extends EventEmitter {
         // "gmail: 17266796 bodies cached" in the logs, which is the counter
         // spinning on the same 100 rows.
         if (await this.bodyStore.hasMessage(accountId, folderId, uid)) {
-            const existingPath = this.bodyStore.getMessagePath?.(accountId, folderId, uid);
-            if (existingPath)
-                this.db.updateBodyPath(accountId, uid, existingPath);
-            return this.bodyStore.getMessage(accountId, folderId, uid);
+            // COMINGLING GUARD: verify the cached body's Message-ID matches the
+            // DB row's messageId. If UIDVALIDITY changed server-side (mailbox
+            // recreated, server quirk) the same integer UID can point at a
+            // different message — the on-disk .eml becomes stale but hasMessage()
+            // still returns true. User-reported: "Peter Hoddie letter comingled
+            // with a much older letter." Check fixes it regardless of root cause.
+            const cached = await this.bodyStore.getMessage(accountId, folderId, uid);
+            const envelope = this.db.getMessageByUid(accountId, uid, folderId);
+            const expectedId = envelope?.messageId || "";
+            if (expectedId) {
+                // Scan headers only — Message-ID should land in the first few KB.
+                const head = cached.subarray(0, Math.min(cached.length, 16 * 1024)).toString("utf-8");
+                const m = head.match(/^Message-ID:\s*<([^>\r\n]+)>/im);
+                const cachedId = m ? `<${m[1]}>` : "";
+                if (cachedId && expectedId && cachedId !== expectedId) {
+                    console.error(`  [body] COMINGLING DETECTED ${accountId}/${folderId}/${uid}: expected ${expectedId}, cached ${cachedId} — dropping cache, re-fetching`);
+                    try {
+                        await this.bodyStore.deleteMessage(accountId, folderId, uid);
+                    }
+                    catch { /* */ }
+                    // fall through to re-fetch path
+                }
+                else {
+                    const existingPath = this.bodyStore.getMessagePath?.(accountId, folderId, uid);
+                    if (existingPath)
+                        this.db.updateBodyPath(accountId, uid, existingPath);
+                    return cached;
+                }
+            }
+            else {
+                // No messageId on the DB row (shouldn't happen but be permissive).
+                const existingPath = this.bodyStore.getMessagePath?.(accountId, folderId, uid);
+                if (existingPath)
+                    this.db.updateBodyPath(accountId, uid, existingPath);
+                return cached;
+            }
         }
         if (!this.configs.has(accountId))
             return null;
@@ -2421,15 +2453,122 @@ export class ImapManager extends EventEmitter {
      *  sync_actions "send" branch was removed because it duplicated the same
      *  work and risked double-send when both paths fired on the same message. */
     queueOutgoingLocal(accountId, rawMessage) {
+        // Loud logging so a "vanished message" report is diagnosable from the log alone.
         const outboxDir = path.join(getConfigDir(), "outbox", accountId);
-        fs.mkdirSync(outboxDir, { recursive: true });
+        try {
+            fs.mkdirSync(outboxDir, { recursive: true });
+        }
+        catch (e) {
+            console.error(`  [outbox] FAIL mkdirSync ${outboxDir}: ${e?.message || e}`);
+            throw new Error(`Cannot create outbox dir ${outboxDir}: ${e?.message || e}`);
+        }
         const now = new Date();
         const pad2 = (n) => String(n).padStart(2, "0");
         const filename = `${now.getFullYear()}${pad2(now.getMonth() + 1)}${pad2(now.getDate())}_${pad2(now.getHours())}${pad2(now.getMinutes())}${pad2(now.getSeconds())}-${String(Math.floor(Math.random() * 10000)).padStart(4, "0")}.ltr`;
         const filePath = path.join(outboxDir, filename);
-        fs.writeFileSync(filePath, rawMessage);
-        console.log(`  [outbox] Queued ${filePath}`);
-        this.processLocalQueue(accountId).catch((e) => console.error(`  [outbox] processLocalQueue error: ${e?.message || e}`));
+        try {
+            fs.writeFileSync(filePath, rawMessage);
+        }
+        catch (e) {
+            console.error(`  [outbox] FAIL writeFileSync ${filePath}: ${e?.message || e}`);
+            throw new Error(`Cannot write outbox file ${filePath}: ${e?.message || e}`);
+        }
+        // Immediate readback verification — if this DOESN'T print, the user's
+        // "neither in outbox nor file system" report has a real explanation.
+        const written = fs.existsSync(filePath);
+        const size = written ? fs.statSync(filePath).size : 0;
+        console.log(`  [outbox] WROTE ${filePath} (${size} bytes, exists=${written})`);
+        this.emitOutboxStatus();
+        // CRITICAL: defer to next tick. processLocalQueue runs ~30+ lines
+        // of synchronous fs work BEFORE its first await — calling it inline
+        // blocks the IPC ack on all that work.
+        setImmediate(() => {
+            this.processLocalQueue(accountId)
+                .catch((e) => console.error(`  [outbox] processLocalQueue error: ${e?.message || e}`))
+                .finally(() => this.emitOutboxStatus());
+        });
+    }
+    /** Scan the local outbox + sending/queued dirs and return counts + age.
+     *  Cheap — a handful of readdir + head-read per file. Called by both the
+     *  polling UI (status bar) and emitted as an event after queue mutations. */
+    getOutboxStatus() {
+        const configDir = getConfigDir();
+        const perAccount = {};
+        let total = 0;
+        let retrying = 0;
+        let claimed = 0;
+        let oldestMs = 0;
+        let maxAttempts = 0;
+        const now = Date.now();
+        const scan = (accountId, dir) => {
+            if (!fs.existsSync(dir))
+                return;
+            for (const f of fs.readdirSync(dir)) {
+                const isClaim = /\.sending-[^-]+-\d+$/.test(f);
+                const isActive = isClaim || f.endsWith(".ltr") || f.endsWith(".eml");
+                if (!isActive)
+                    continue;
+                total++;
+                const acctSlot = perAccount[accountId] ||= { total: 0, retrying: 0, claimed: 0 };
+                acctSlot.total++;
+                if (isClaim) {
+                    claimed++;
+                    acctSlot.claimed++;
+                }
+                const fp = path.join(dir, f);
+                try {
+                    const st = fs.statSync(fp);
+                    const age = now - st.mtimeMs;
+                    if (age > oldestMs)
+                        oldestMs = age;
+                    // Only read header region to count retry attempts — tiny I/O.
+                    const fd = fs.openSync(fp, "r");
+                    try {
+                        const buf = Buffer.alloc(4096);
+                        const n = fs.readSync(fd, buf, 0, 4096, 0);
+                        const head = buf.slice(0, n).toString("utf-8");
+                        const info = parseRetryInfo(head);
+                        if (info.attemptCount > 0) {
+                            retrying++;
+                            acctSlot.retrying++;
+                        }
+                        if (info.attemptCount > maxAttempts)
+                            maxAttempts = info.attemptCount;
+                    }
+                    finally {
+                        fs.closeSync(fd);
+                    }
+                }
+                catch { /* ignore per-file errors */ }
+            }
+        };
+        const outboxRoot = path.join(configDir, "outbox");
+        const sendingRoot = path.join(configDir, "sending");
+        try {
+            if (fs.existsSync(outboxRoot)) {
+                for (const acct of fs.readdirSync(outboxRoot))
+                    scan(acct, path.join(outboxRoot, acct));
+            }
+            if (fs.existsSync(sendingRoot)) {
+                for (const acct of fs.readdirSync(sendingRoot)) {
+                    scan(acct, path.join(sendingRoot, acct, "queued"));
+                }
+            }
+        }
+        catch { /* */ }
+        return {
+            total, retrying, claimed,
+            oldestAgeSec: Math.floor(oldestMs / 1000),
+            maxAttempts,
+            perAccount,
+        };
+    }
+    /** Emit outboxStatus now. Call after any queue mutation. */
+    emitOutboxStatus() {
+        try {
+            this.emit("outboxStatus", this.getOutboxStatus());
+        }
+        catch { /* */ }
     }
     /** Guard against concurrent processSendActions for the same account */
     sendingAccounts = new Set();
@@ -2948,6 +3087,8 @@ export class ImapManager extends EventEmitter {
                     }
                 }
             }
+            // After each full tick, refresh the UI indicator.
+            this.emitOutboxStatus();
         };
         setTimeout(() => processAll(), 3000);
         this.outboxInterval = setInterval(processAll, 10000);
@@ -2969,10 +3110,20 @@ export class ImapManager extends EventEmitter {
         const files = ["accounts.jsonc", "allowlist.jsonc", "clients.jsonc", "config.jsonc"];
         const configDir = getConfigDir();
         const debounce = new Map();
+        // Cache the last-seen normalized content per file. fs.watch fires on
+        // metadata-only events (atime, attrib change) AND on no-op rewrites
+        // that land identical bytes — both would fire a spurious banner.
+        // Compare after the debounce window and only emit on a real change.
+        const normalize = (s) => s.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").replace(/[ \t\r\n]+$/, "");
+        const lastContent = new Map();
         for (const filename of files) {
             const full = path.join(configDir, filename);
             if (!fs.existsSync(full))
                 continue;
+            try {
+                lastContent.set(filename, normalize(fs.readFileSync(full, "utf-8")));
+            }
+            catch { /* */ }
             try {
                 const watcher = fs.watch(full, () => {
                     const prev = debounce.get(filename);
@@ -2980,7 +3131,32 @@ export class ImapManager extends EventEmitter {
                         clearTimeout(prev);
                     debounce.set(filename, setTimeout(() => {
                         debounce.delete(filename);
-                        console.log(`  [watch] ${filename} changed`);
+                        let current = "";
+                        try {
+                            current = normalize(fs.readFileSync(full, "utf-8"));
+                        }
+                        catch { /* missing */ }
+                        const previous = lastContent.get(filename) || "";
+                        if (current === previous) {
+                            console.log(`  [watch] ${filename} fs.watch fired but content unchanged — no banner`);
+                            return;
+                        }
+                        // Log a short diff hint so repeat-firings are diagnosable.
+                        const prevSize = previous.length;
+                        const curSize = current.length;
+                        const firstDiff = (() => {
+                            const n = Math.min(prevSize, curSize);
+                            for (let i = 0; i < n; i++)
+                                if (previous[i] !== current[i])
+                                    return i;
+                            return n;
+                        })();
+                        const prevSnip = previous.slice(Math.max(0, firstDiff - 20), firstDiff + 40).replace(/\n/g, "\\n");
+                        const curSnip = current.slice(Math.max(0, firstDiff - 20), firstDiff + 40).replace(/\n/g, "\\n");
+                        console.log(`  [watch] ${filename} changed: size ${prevSize}→${curSize}, first diff at byte ${firstDiff}`);
+                        console.log(`  [watch]   was: ${JSON.stringify(prevSnip)}`);
+                        console.log(`  [watch]   now: ${JSON.stringify(curSnip)}`);
+                        lastContent.set(filename, current);
                         this.emit("configChanged", filename);
                     }, 500));
                 });
@@ -2999,11 +3175,9 @@ export class ImapManager extends EventEmitter {
         // config.jsonc is per-machine / local-only — never polled.
         const cloudFiles = ["accounts.jsonc", "allowlist.jsonc", "clients.jsonc"];
         const CLOUD_POLL_MS = 3 * 60 * 1000;
-        // Normalize before comparing: strip BOM, CRLF→LF, trailing whitespace.
-        // Without this, cloud round-trips that re-wrap newlines or add a
-        // trailing newline trigger a local overwrite every poll, which fires
-        // fs.watch, which shows the spurious "accounts.jsonc changed" banner.
-        const normalize = (s) => s.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n").replace(/[ \t\r\n]+$/, "");
+        // normalize() reused from the fs.watch block above — same intent:
+        // cloud round-trips that re-wrap newlines / add a trailing newline are
+        // semantically identical; don't overwrite local on those.
         const pollCloud = async () => {
             let cloudRead;
             let parseJsonc;

package/packages/mailx-service/index.d.ts

@@ -34,6 +34,8 @@ export declare class MailxService {
     getSyncPending(): {
         pending: number;
     };
+    /** Outbox queue depth + retry status for the UI status bar. Cheap to call. */
+    getOutboxStatus(): any;
     syncAll(): Promise<void>;
     syncAccount(accountId: string): Promise<void>;
     /** Force re-authentication for an account (deletes token, opens browser consent) */

package/packages/mailx-service/index.js

@@ -409,6 +409,10 @@ export class MailxService {
     getSyncPending() {
         return { pending: this.db.getTotalPendingSyncCount() };
     }
+    /** Outbox queue depth + retry status for the UI status bar. Cheap to call. */
+    getOutboxStatus() {
+        return this.imapManager.getOutboxStatus();
+    }
     async syncAll() {
         await this.imapManager.syncAll();
     }
@@ -440,6 +444,9 @@ export class MailxService {
         // locally. Everything else (contacts recording, IMAP APPEND,
         // SMTP) happens after the IPC ACK. Settings come from cache so
         // a stalled GDrive mount doesn't block the send.
+        const t0 = Date.now();
+        const lap = (label) => console.log(`  [send] +${Date.now() - t0}ms ${label}`);
+        console.log(`  [send] ENTRY from=${msg?.from} to=${JSON.stringify(msg?.to)} subject="${msg?.subject}" attachments=${msg?.attachments?.length || 0}`);
         const accounts = this.getCachedAccounts();
         let account = accounts.find(a => a.id === msg.from);
         if (!account) {
@@ -447,8 +454,12 @@ export class MailxService {
             this._accountsCache = null;
             account = this.getCachedAccounts().find(a => a.id === msg.from);
         }
-        if (!account)
+        if (!account) {
+            const ids = accounts.map(a => a.id).join(", ");
+            console.error(`  [send] FAIL: Unknown account "${msg.from}". Known accounts: [${ids}]`);
             throw new Error(`Unknown account: ${msg.from}`);
+        }
+        lap("account resolved");
         // Vet every recipient address — refuse to send if any field contains a
         // non-email (e.g. "Bob Frankston <Bob Frankston>" from a bad contact
         // autocomplete). This catches garbage BEFORE it hits SMTP, where the
@@ -531,7 +542,9 @@ export class MailxService {
             ].join("\r\n");
             rawMessage = `${headers}\r\n\r\n${bodyEncoded}`;
         }
+        lap(`MIME assembled (${rawMessage.length} bytes${hasAttachments ? `, ${msg.attachments.length} attachment(s)` : ""})`);
         this.imapManager.queueOutgoingLocal(account.id, rawMessage);
+        lap("queued to disk");
         console.log(`  Queued locally: ${msg.subject} via ${account.id} from ${fromHeader}`);
         // Contacts recording is off the critical path — deferred until after
         // the IPC ACK so a slow DB write can't stall the send.
@@ -604,8 +617,13 @@ export class MailxService {
     /** Move messages to the account's configured spam folder (accounts.jsonc "spam" path).
      *  Throws if the account has no spam folder configured or the folder doesn't exist locally. */
     async markAsSpamMessages(accountId, uids) {
-        const settings = loadSettings();
-        const account = settings.accounts.find(a => a.id === accountId);
+        // Cached accounts — same reason as send/saveDraft: a stalled GDrive
+        // mount could turn `Mark as spam` into a 120s IPC timeout.
+        let account = this.getCachedAccounts().find(a => a.id === accountId);
+        if (!account) {
+            this._accountsCache = null;
+            account = this.getCachedAccounts().find(a => a.id === accountId);
+        }
         if (!account)
             throw new Error(`Account ${accountId} not found`);
         const spamPath = account.spam;
@@ -760,8 +778,15 @@ export class MailxService {
         // a prerequisite. X-Mailx-Draft-ID is carried in the MIME headers
         // so the reconciler can de-duplicate on the server by header search
         // even without the previousDraftUid round-trip.
-        const settings = loadSettings();
-        const account = settings.accounts.find(a => a.id === accountId);
+        // Account lookup uses the cached list — `loadSettings()` reads
+        // accounts.jsonc from the GDrive mount and could itself stall for
+        // 120s, which was the actual `mailxapi timeout: saveDraft` source
+        // (the IMAP work was fire-and-forget, but loadSettings wasn't).
+        let account = this.getCachedAccounts().find(a => a.id === accountId);
+        if (!account) {
+            this._accountsCache = null;
+            account = this.getCachedAccounts().find(a => a.id === accountId);
+        }
         if (!account)
             throw new Error(`Unknown account: ${accountId}`);
         // Generate or reuse a stable draft ID for dedup

package/packages/mailx-service/jsonrpc.js

@@ -89,6 +89,8 @@ async function dispatchAction(svc, action, p) {
             return { ok: true };
         case "getSyncPending":
             return svc.getSyncPending();
+        case "getOutboxStatus":
+            return svc.getOutboxStatus();
         case "reauthenticate":
             return { ok: await svc.reauthenticate(p.accountId) };
         // Search & contacts