@bobfrankston/mailx-imap 0.1.104 → 0.1.106

package/index.d.ts

@@ -135,63 +135,62 @@ export declare class ImapManager extends EventEmitter {
      *  forbids nesting under Trash. Self-contained on the worker. */
     moveFolderToTrashViaServer(accountId: string, folderId: number, folderPath: string, targetPath: string, trashId: number, trashPath: string, delim: string): Promise<void>;
     private spillFolderToTrashServer;
-    /** Persistent slow-lane operational connection per account. Used by sync,
-     *  prefetch, outbox-append, large backfills, and any other "this might
-     *  take a while" operation. */
-    private opsClients;
-    /** Lazy-allocated fast-lane client per account (C123). Lives alongside
-     *  `opsClients` so click-time body fetches and flag toggles don't have
-     *  to wait behind a multi-minute prefetch / backfill on the slow client.
-     *  Created on the first fast-lane `withConnection` call; reused while
-     *  alive; recreated on stale-detect or error-discard like opsClients.
-     *  Costs +1 IMAP socket per active account, well under any reasonable
-     *  per-user-IP cap (Dovecot's default is 20). */
-    private fastClients;
-    /** Two-lane operation queue per account — interactive ops (body fetch on
-     *  click, flag toggle) drain before background ops (sync, prefetch). FIFO
-     *  within each lane. The single ops connection means there's never a race
-     *  on which folder is SELECTed; commands run strictly sequentially. */
-    private opsQueues;
+    /** Per-workload connection lanes. Each (lane, account) gets its OWN
+     *  persistent IMAP connection so a slow op on one lane can't block another:
+     *  a 90s `SELECT Sent` on "outbox" or a giant `UID FETCH` on "prefetch" no
+     *  longer wedges INBOX sync/backfill on "sync". This is the root fix for
+     *  the "whole sync worker goes silent" wedge (Bob 2026-06-20): before, all
+     *  background work shared ONE slow connection and serialized behind the
+     *  slowest command (a 90s SELECT Sent / a giant prefetch FETCH stalled
+     *  INBOX backfill behind it). Lanes in use:
+     *    fast     — interactive: body fetch on click, flag toggle, move
+     *    slow     — folder sync + set-diff backfill (the `{slow:true}` default)
+     *    prefetch — background body download (heaviest, longest)
+     *    outbox   — send + sent-sweep + Outbox/Sent SELECT/APPEND
+     *  Per account that's ≤4 persistent sockets + 1 IDLE, under Dovecot's 20.
+     *  laneName → (accountId → persistent client). */
+    private laneClients;
+    /** Per-account, per-lane FIFO task queues. accountId → (laneName → queue).
+     *  All lanes for an account drain concurrently (each on its own socket);
+     *  within a lane, strictly sequential — no SELECT race. */
+    private laneQueues;
     /** Per-host semaphore — caps simultaneous IMAP socket opens to one server.
-     *  Defensive guardrail: with the single-ops-per-account model an individual
-     *  user's mailx never hits more than (#accounts × 2) sockets per host, well
-     *  under any reasonable server cap. Exists for the multi-account-on-one-host
-     *  case (e.g. bobma + bobma2 both on imap.iecc.com). */
+     *  Defensive guardrail for the multi-account-on-one-host case (e.g. bobma +
+     *  bobma2 both on imap.iecc.com). NOTE: the permit is held for the
+     *  connection's LIFETIME (released on logout/destroy), not just the open —
+     *  so this also bounds the number of live persistent connections per host.
+     *  Each account now keeps up to 4 persistent lanes (fast/slow/prefetch/
+     *  outbox) + 1 IDLE (IDLE bypasses the semaphore). 8 permits covers two
+     *  accounts' lanes with headroom, still far under Dovecot's ~20/user+IP. */
     private hostSemaphores;
     private static readonly HOST_PERMITS;
-    /** Get (or create) a persistent connection for an account on the named
-     *  lane. Two lanes today: `slow` (the original `opsClients` map — sync,
-     *  prefetch, backfill, outbox) and `fast` (the C123 `fastClients` map —
-     *  click-time body fetch, flag toggles, anything user-driven). Same
-     *  stale-detect + reconnect semantics on both. logout() is wrapped as a
-     *  no-op so legacy callers don't close the persistent client. */
+    /** The (accountId → client) map for a lane, created on first use. */
+    private laneClientMap;
     private getLaneClient;
     /** Backwards-compat shim — callers outside the queue still ask for the
      *  ops client by historical name. New code should prefer withConnection
      *  with `slow:true` for slow operations. */
     private getOpsClient;
-    /** Run an operation on the account's connection — queued, sequential, no concurrency */
-    /** Run an operation against the account's single ops connection. Tasks
-     *  queue strictly sequentially per account — only one IMAP command in
-     *  flight at a time. This eliminates the SELECT-races and "stale client
-     *  recovery" paths the old multi-client design needed.
+    /** Run an operation against one of the account's per-workload lane
+     *  connections. Tasks queue strictly sequentially WITHIN a lane (one IMAP
+     *  command in flight, no SELECT race) but lanes run CONCURRENTLY, each on
+     *  its own socket — so a slow op on one lane never blocks another.
      *
-     *  Default lane is `fast` — covers virtually everything (body fetch,
-     *  flag toggle, move, incremental sync). Pass `slow: true` only for
-     *  operations the caller knows will take a long time and shouldn't
-     *  block the user (multi-folder prefetch batches, large backfills).
-     *  When both lanes have tasks, fast drains first.
+     *  Pick the lane via `opts.lane` (e.g. "sync", "prefetch", "outbox").
+     *  Default is "fast" — interactive ops (body fetch on click, flag toggle,
+     *  move). `slow: true` is a legacy alias for the "slow" misc lane; prefer
+     *  a named lane so distinct workloads don't serialize behind each other.
      *
-     *  Within a lane, FIFO. The running task always finishes — IMAP can't
-     *  preempt a command mid-flight. */
+     *  The running task always finishes — IMAP can't preempt a command
+     *  mid-flight; the wall-clock timeout below bounds how long that can be. */
     withConnection<T>(accountId: string, fn: (client: any) => Promise<T>, opts?: {
         slow?: boolean;
+        lane?: string;
         timeoutMs?: number;
     }): Promise<T>;
-    /** Run the next queued task on each lane. Fast and slow lanes drain
-     *  CONCURRENTLY — each on its own connection (C123). FIFO within each
-     *  lane. The running flag per lane prevents reentrant draining of the
-     *  same lane. */
+    /** Drain the next queued task on EVERY lane for the account. Lanes run
+     *  concurrently — each on its own connection — and the per-lane running
+     *  flag prevents reentrant draining of the same lane. */
     private drainOpsQueue;
     /** Acquire one slot of the per-host connection semaphore. Returns a release
      *  function — call exactly once when the socket is closed. Used by
@@ -304,7 +303,8 @@ export declare class ImapManager extends EventEmitter {
     private syncFolderViaApi;
     /** Store API-fetched messages to DB */
     private storeApiMessages;
-    /** Kill and recreate the persistent ops connection */
+    /** Kill and recreate the persistent connections for an account — drops the
+     *  client on every lane so the next task on each reconnects fresh. */
     private reconnectOps;
     /** Handle sync errors — classify and emit appropriate UI events.
      *  The connection-cap branch was removed: with the unified ops queue +

package/index.js

@@ -566,38 +566,46 @@ export class ImapManager extends EventEmitter {
     // All operations on an account are serialized through an operation queue.
     // No semaphore, no pool, no per-operation connect/disconnect.
     // IDLE uses a separate connection (see startWatching).
-    /** Persistent slow-lane operational connection per account. Used by sync,
-     *  prefetch, outbox-append, large backfills, and any other "this might
-     *  take a while" operation. */
-    opsClients = new Map();
-    /** Lazy-allocated fast-lane client per account (C123). Lives alongside
-     *  `opsClients` so click-time body fetches and flag toggles don't have
-     *  to wait behind a multi-minute prefetch / backfill on the slow client.
-     *  Created on the first fast-lane `withConnection` call; reused while
-     *  alive; recreated on stale-detect or error-discard like opsClients.
-     *  Costs +1 IMAP socket per active account, well under any reasonable
-     *  per-user-IP cap (Dovecot's default is 20). */
-    fastClients = new Map();
-    /** Two-lane operation queue per account — interactive ops (body fetch on
-     *  click, flag toggle) drain before background ops (sync, prefetch). FIFO
-     *  within each lane. The single ops connection means there's never a race
-     *  on which folder is SELECTed; commands run strictly sequentially. */
-    opsQueues = new Map();
+    /** Per-workload connection lanes. Each (lane, account) gets its OWN
+     *  persistent IMAP connection so a slow op on one lane can't block another:
+     *  a 90s `SELECT Sent` on "outbox" or a giant `UID FETCH` on "prefetch" no
+     *  longer wedges INBOX sync/backfill on "sync". This is the root fix for
+     *  the "whole sync worker goes silent" wedge (Bob 2026-06-20): before, all
+     *  background work shared ONE slow connection and serialized behind the
+     *  slowest command (a 90s SELECT Sent / a giant prefetch FETCH stalled
+     *  INBOX backfill behind it). Lanes in use:
+     *    fast     — interactive: body fetch on click, flag toggle, move
+     *    slow     — folder sync + set-diff backfill (the `{slow:true}` default)
+     *    prefetch — background body download (heaviest, longest)
+     *    outbox   — send + sent-sweep + Outbox/Sent SELECT/APPEND
+     *  Per account that's ≤4 persistent sockets + 1 IDLE, under Dovecot's 20.
+     *  laneName → (accountId → persistent client). */
+    laneClients = new Map();
+    /** Per-account, per-lane FIFO task queues. accountId → (laneName → queue).
+     *  All lanes for an account drain concurrently (each on its own socket);
+     *  within a lane, strictly sequential — no SELECT race. */
+    laneQueues = new Map();
     /** Per-host semaphore — caps simultaneous IMAP socket opens to one server.
-     *  Defensive guardrail: with the single-ops-per-account model an individual
-     *  user's mailx never hits more than (#accounts × 2) sockets per host, well
-     *  under any reasonable server cap. Exists for the multi-account-on-one-host
-     *  case (e.g. bobma + bobma2 both on imap.iecc.com). */
+     *  Defensive guardrail for the multi-account-on-one-host case (e.g. bobma +
+     *  bobma2 both on imap.iecc.com). NOTE: the permit is held for the
+     *  connection's LIFETIME (released on logout/destroy), not just the open —
+     *  so this also bounds the number of live persistent connections per host.
+     *  Each account now keeps up to 4 persistent lanes (fast/slow/prefetch/
+     *  outbox) + 1 IDLE (IDLE bypasses the semaphore). 8 permits covers two
+     *  accounts' lanes with headroom, still far under Dovecot's ~20/user+IP. */
     hostSemaphores = new Map();
-    static HOST_PERMITS = 4;
-    /** Get (or create) a persistent connection for an account on the named
-     *  lane. Two lanes today: `slow` (the original `opsClients` map — sync,
-     *  prefetch, backfill, outbox) and `fast` (the C123 `fastClients` map —
-     *  click-time body fetch, flag toggles, anything user-driven). Same
-     *  stale-detect + reconnect semantics on both. logout() is wrapped as a
-     *  no-op so legacy callers don't close the persistent client. */
+    static HOST_PERMITS = 8;
+    /** The (accountId → client) map for a lane, created on first use. */
+    laneClientMap(lane) {
+        let m = this.laneClients.get(lane);
+        if (!m) {
+            m = new Map();
+            this.laneClients.set(lane, m);
+        }
+        return m;
+    }
     async getLaneClient(accountId, lane) {
-        const map = lane === "fast" ? this.fastClients : this.opsClients;
+        const map = this.laneClientMap(lane);
         let client = map.get(accountId);
         if (client) {
             // C38: health-check the cached client before returning. If the
@@ -618,7 +626,7 @@ export class ImapManager extends EventEmitter {
             console.log(`  [conn] ${accountId}: stale ${lane} client detected — reconnecting`);
             client = undefined;
         }
-        client = await this.newClient(accountId, lane === "fast" ? "fast" : "ops");
+        client = await this.newClient(accountId, lane);
         // Wrap logout as no-op — this is a persistent connection. The
         // newClient wrapper's close-counter runs on `_realLogout`.
         const realLogout = client.logout.bind(client);
@@ -633,29 +641,32 @@ export class ImapManager extends EventEmitter {
     async getOpsClient(accountId) {
         return this.getLaneClient(accountId, "slow");
     }
-    /** Run an operation on the account's connection — queued, sequential, no concurrency */
-    /** Run an operation against the account's single ops connection. Tasks
-     *  queue strictly sequentially per account — only one IMAP command in
-     *  flight at a time. This eliminates the SELECT-races and "stale client
-     *  recovery" paths the old multi-client design needed.
+    /** Run an operation against one of the account's per-workload lane
+     *  connections. Tasks queue strictly sequentially WITHIN a lane (one IMAP
+     *  command in flight, no SELECT race) but lanes run CONCURRENTLY, each on
+     *  its own socket — so a slow op on one lane never blocks another.
      *
-     *  Default lane is `fast` — covers virtually everything (body fetch,
-     *  flag toggle, move, incremental sync). Pass `slow: true` only for
-     *  operations the caller knows will take a long time and shouldn't
-     *  block the user (multi-folder prefetch batches, large backfills).
-     *  When both lanes have tasks, fast drains first.
+     *  Pick the lane via `opts.lane` (e.g. "sync", "prefetch", "outbox").
+     *  Default is "fast" — interactive ops (body fetch on click, flag toggle,
+     *  move). `slow: true` is a legacy alias for the "slow" misc lane; prefer
+     *  a named lane so distinct workloads don't serialize behind each other.
      *
-     *  Within a lane, FIFO. The running task always finishes — IMAP can't
-     *  preempt a command mid-flight. */
+     *  The running task always finishes — IMAP can't preempt a command
+     *  mid-flight; the wall-clock timeout below bounds how long that can be. */
     async withConnection(accountId, fn, opts = {}) {
-        let queue = this.opsQueues.get(accountId);
+        const lane = opts.lane ?? (opts.slow ? "slow" : "fast");
+        let perAccount = this.laneQueues.get(accountId);
+        if (!perAccount) {
+            perAccount = new Map();
+            this.laneQueues.set(accountId, perAccount);
+        }
+        let queue = perAccount.get(lane);
         if (!queue) {
-            queue = { fast: [], slow: [], runningFast: false, runningSlow: false };
-            this.opsQueues.set(accountId, queue);
+            queue = { tasks: [], running: false };
+            perAccount.set(lane, queue);
         }
-        const lane = opts.slow ? "slow" : "fast";
         // Per-task wall-clock cap. Without one, a wedged IMAP command (TCP
-        // half-open, server stalled mid-FETCH) keeps the queue's running flag
+        // half-open, server stalled mid-FETCH) keeps the lane's running flag
         // set forever and every subsequent same-lane task — including the
         // retry button the user just hit — waits behind it. Default is
         // generous; callers driving user-visible reads pass a tighter value.
@@ -676,13 +687,12 @@ export class ImapManager extends EventEmitter {
                 }
                 catch (e) {
                     clearTimeout(timer);
-                    // Discard the lane's client on any error — a half-broken
-                    // socket poisons every subsequent request on that lane.
-                    // Don't touch the OTHER lane's client; the lanes are
-                    // independent. Destroy synchronously kills the in-flight
-                    // command's socket so the underlying promise rejects and
-                    // stops holding state.
-                    const map = lane === "fast" ? this.fastClients : this.opsClients;
+                    // Discard THIS lane's client on any error — a half-broken
+                    // socket poisons every subsequent request on the lane.
+                    // Other lanes' clients are independent and untouched.
+                    // Destroy synchronously kills the in-flight command's
+                    // socket so the underlying promise rejects.
+                    const map = this.laneClientMap(lane);
                     const stale = map.get(accountId);
                     map.delete(accountId);
                     if (stale) {
@@ -698,33 +708,29 @@ export class ImapManager extends EventEmitter {
                     reject(e);
                 }
             };
-            queue[lane].push(task);
+            queue.tasks.push(task);
             this.drainOpsQueue(accountId);
         });
     }
-    /** Run the next queued task on each lane. Fast and slow lanes drain
-     *  CONCURRENTLY — each on its own connection (C123). FIFO within each
-     *  lane. The running flag per lane prevents reentrant draining of the
-     *  same lane. */
+    /** Drain the next queued task on EVERY lane for the account. Lanes run
+     *  concurrently — each on its own connection — and the per-lane running
+     *  flag prevents reentrant draining of the same lane. */
     drainOpsQueue(accountId) {
-        const queue = this.opsQueues.get(accountId);
-        if (!queue)
+        const perAccount = this.laneQueues.get(accountId);
+        if (!perAccount)
             return;
-        const drainLane = (lane) => {
-            const runningKey = lane === "fast" ? "runningFast" : "runningSlow";
-            if (queue[runningKey])
-                return;
-            const next = queue[lane].shift();
+        for (const queue of perAccount.values()) {
+            if (queue.running)
+                continue;
+            const next = queue.tasks.shift();
             if (!next)
-                return;
-            queue[runningKey] = true;
+                continue;
+            queue.running = true;
             next().finally(() => {
-                queue[runningKey] = false;
-                drainLane(lane);
+                queue.running = false;
+                this.drainOpsQueue(accountId);
             });
-        };
-        drainLane("fast");
-        drainLane("slow");
+        }
     }
     /** Acquire one slot of the per-host connection semaphore. Returns a release
      *  function — call exactly once when the socket is closed. Used by
@@ -849,7 +855,7 @@ export class ImapManager extends EventEmitter {
      *  so the server's connection slots free immediately rather than
      *  waiting for socket idle timeouts. */
     async closeAllClients(accountId) {
-        for (const map of [this.opsClients, this.fastClients]) {
+        for (const map of this.laneClients.values()) {
             const c = map.get(accountId);
             map.delete(accountId);
             if (c) {
@@ -881,7 +887,7 @@ export class ImapManager extends EventEmitter {
     /** Disconnect the persistent operational connections (both lanes) for
      *  an account. */
     async disconnectOps(accountId) {
-        for (const [name, map] of [["ops", this.opsClients], ["fast", this.fastClients]]) {
+        for (const [name, map] of this.laneClients) {
             const client = map.get(accountId);
             map.delete(accountId);
             if (client) {
@@ -1333,7 +1339,13 @@ export class ImapManager extends EventEmitter {
      */
     async fetchServerOnlyUids(client, accountId, folderId, folder, statusMessageCount, excludeUids) {
         const folderPath = folder.path;
-        const existingUids = this.db.getUidsForFolder(accountId, folderId);
+        // Diff against UIDs we actually have a MESSAGE ROW for (messages table),
+        // NOT message_folders memberships. An orphan membership (member row but
+        // no message row) would otherwise look "present" and never get its real
+        // data fetched — leaving the message permanently missing from the list
+        // while the folder count looks full (Bob 2026-06-20: ~1k old INBOX
+        // messages stuck missing behind orphan memberships).
+        const existingUids = this.db.getStoredUids(accountId, folderId);
         // Small folders (Drafts, Sent, …) get a FULL UID fetch so server-side
         // deletions of OLDER messages are reflected; large folders (134k INBOX)
         // get a date-bounded query so we don't enumerate the whole mailbox.
@@ -1625,7 +1637,11 @@ export class ImapManager extends EventEmitter {
                     // retries instead of locking out for RECONCILE_THROTTLE_MS
                     // (Bob 2026-06-20: boot-time "Not connected" failure locked
                     // INBOX recovery out for 15 min).
-                    const localCount = this.db.getMessageCount(accountId, folderId);
+                    // Compare STORED-ROW count (messages table) to the server's
+                    // count — not getMessageCount (message_folders), which orphan
+                    // memberships can inflate to match the server while real rows
+                    // are still missing.
+                    const localCount = this.db.getStoredCount(accountId, folderId);
                     const hasDeficit = statusMessageCount !== null && localCount < statusMessageCount;
                     const lastRecon = this.lastReconcileMs.get(folderId) ?? 0;
                     const throttleElapsed = Date.now() - lastRecon > RECONCILE_THROTTLE_MS;
@@ -2495,17 +2511,20 @@ export class ImapManager extends EventEmitter {
             console.error(`  [api] storeApiMessages: ${errors} of ${msgs.length} rows failed (${stored} stored)`);
         return stored;
     }
-    /** Kill and recreate the persistent ops connection */
+    /** Kill and recreate the persistent connections for an account — drops the
+     *  client on every lane so the next task on each reconnects fresh. */
     async reconnectOps(accountId) {
-        const old = this.opsClients.get(accountId);
-        this.opsClients.delete(accountId);
-        if (old) {
-            try {
-                await (old._realLogout || old.logout)();
+        for (const map of this.laneClients.values()) {
+            const old = map.get(accountId);
+            map.delete(accountId);
+            if (old) {
+                try {
+                    await (old._realLogout || old.logout)();
+                }
+                catch { /* */ }
             }
-            catch { /* */ }
         }
-        console.log(`  [conn] ${accountId}: reconnecting`);
+        console.log(`  [conn] ${accountId}: reconnecting (all lanes)`);
     }
     /** Handle sync errors — classify and emit appropriate UI events.
      *  The connection-cap branch was removed: with the unified ops queue +
@@ -3587,7 +3606,7 @@ export class ImapManager extends EventEmitter {
                                     })());
                                 });
                                 await Promise.all(pending);
-                            }, { slow: true, timeoutMs: 300_000 });
+                            }, { lane: "prefetch", timeoutMs: 300_000 });
                             // 5-min cap, not the 90s interactive default:
                             // prefetch is background, and a 25-message body
                             // chunk on a slow Dovecot legitimately runs past
@@ -4403,7 +4422,7 @@ export class ImapManager extends EventEmitter {
             await this.withConnection(accountId, async (client) => {
                 await client.createmailbox("Outbox");
                 await this.syncFolders(accountId, client);
-            });
+            }, { lane: "outbox" });
         }
         catch (e) {
             // Might already exist — benign
@@ -4517,7 +4536,7 @@ export class ImapManager extends EventEmitter {
             await this.withConnection(accountId, async (client) => {
                 appendedUid = await client.appendMessage(outboxPath, rawMessage, ["\\Seen"]);
                 console.log(`  [outbox] Queued message in ${outboxPath}${appendedUid != null ? ` (UID ${appendedUid})` : ""}`);
-            });
+            }, { lane: "outbox" });
             if (outboxFolder) {
                 if (appendedUid != null) {
                     // Inserts the row from the source bytes we already have +
@@ -4741,7 +4760,9 @@ export class ImapManager extends EventEmitter {
         // claim so the recovery sweeper picks it up next tick.
         try {
             const outboxPath = await this.ensureOutbox(accountId);
-            const client = await this.createClientWithLimit(accountId);
+            // Outbox lane, not the slow/sync lane — a wedged APPEND here (which
+            // withTimeout force-closes the socket on) must not disrupt sync.
+            const client = await this.getLaneClient(accountId, "outbox");
             try {
                 for (const { dir, file } of filesToSend) {
                     const filePath = path.join(dir, file);
@@ -4887,8 +4908,8 @@ export class ImapManager extends EventEmitter {
         const account = settings.accounts.find(a => a.id === accountId);
         if (!account)
             return;
-        // List UIDs first — quick command, fast lane.
-        const uids = await this.withConnection(accountId, (client) => client.getUids(outboxFolder.path));
+        // List UIDs first — quick command on the dedicated outbox lane.
+        const uids = await this.withConnection(accountId, (client) => client.getUids(outboxFolder.path), { lane: "outbox" });
         if (uids.length === 0)
             return;
         const STALE_CLAIM_MS = 3600_000; // 1 hour — longer than any reasonable SMTP send
@@ -4896,9 +4917,9 @@ export class ImapManager extends EventEmitter {
         const sendingFlag = `$Sending-${this.hostname}-${nowSec}`;
         const sentFolder = this.findFolder(accountId, "sent");
         for (const uid of uids) {
-            // Each iteration is one slow-lane turn — fast-lane work can run
-            // between iterations, so a body click during a long outbox drain
-            // gets serviced promptly.
+            // Each iteration is one outbox-lane turn — sync, prefetch and
+            // fast-lane (click) work all run on their own connections, so a
+            // long outbox drain never blocks them.
             const result = await this.withConnection(accountId, async (client) => {
                 const flags = await client.getFlags(outboxFolder.path, uid);
                 // Sweep stale claims. $Sending-<host>-<sec> with old timestamp,
@@ -4945,7 +4966,7 @@ export class ImapManager extends EventEmitter {
                     return { skip: true };
                 }
                 return { source: msg.source };
-            }, { slow: true });
+            }, { lane: "outbox" });
             if (result.skip)
                 continue;
             const source = result.source;
@@ -4959,13 +4980,13 @@ export class ImapManager extends EventEmitter {
                 await this.withConnection(accountId, async (client) => {
                     // Delete FIRST to prevent double-send if Sent-copy fails.
                     await client.deleteMessageByUid(outboxFolder.path, uid);
-                }, { slow: true });
+                }, { lane: "outbox" });
                 if (sentFolder) {
                     let appendedSentUid = null;
                     try {
                         await this.withConnection(accountId, async (client) => {
                             appendedSentUid = await client.appendMessage(sentFolder.path, source, ["\\Seen"]);
-                        }, { slow: true });
+                        }, { lane: "outbox" });
                     }
                     catch (sentErr) {
                         console.error(`  [outbox] Failed to copy to Sent: ${sentErr.message} — message was sent successfully`);
@@ -4998,7 +5019,7 @@ export class ImapManager extends EventEmitter {
                     await this.withConnection(accountId, async (client) => {
                         await client.removeFlags(outboxFolder.path, uid, [sendingFlag]);
                         await client.addFlags(outboxFolder.path, uid, ["$Failed"]);
-                    }, { slow: true });
+                    }, { lane: "outbox" });
                 }
                 catch { /* best-effort */ }
                 // Suppress the banner for transient network errors. ETIMEDOUT
@@ -5154,10 +5175,10 @@ export class ImapManager extends EventEmitter {
                 }
                 catch (e) {
                     // Stale-socket errors (Dovecot silently drops idle connections,
-                    // or the sync path timed out and destroyed the socket): force a
-                    // fresh ops client so the next tick doesn't keep hitting the same
-                    // dead socket. Without reconnectOps, the dead client stays in the
-                    // opsClients map and every subsequent processOutbox call fails
+                    // or the sync path timed out and destroyed the socket): force
+                    // fresh lane clients so the next tick doesn't keep hitting the
+                    // same dead socket. Without reconnectOps, the dead client stays
+                    // in its lane map and every subsequent processOutbox call fails
                     // immediately with "Not connected" — forever.
                     const msg = String(e?.message || e);
                     if (/Not connected|ECONNRESET|socket hang up|EPIPE|write after end/i.test(msg)) {
@@ -5261,19 +5282,18 @@ export class ImapManager extends EventEmitter {
             return;
         let reconciled = 0;
         let appended = 0;
-        // Use a DEDICATED IMAP client for sent-sweep — do NOT share the
-        // slow-lane ops client. The priority-INBOX sync grabs the slow-lane
-        // client via getOpsClient() (no lane queueing) and runs SEARCH→FETCH
-        // as a logical transaction; if sent-sweep's searchByHeader (SELECT
-        // Sent → SEARCH → CLOSE) interleaves on the same wire between the
-        // sync's SEARCH and FETCH, the FETCH lands with no mailbox selected
-        // and Dovecot returns "BAD No mailbox selected" — new mail never
-        // lands locally (Bob 2026-05-25: "not seeing recent mail").
-        // iflow-direct serializes per-command, not per-task, so reusing the
-        // shared client is unsafe across logical transactions. A dedicated
-        // client is the smallest surgical fix.
-        const client = await this.createClientWithLimit(accountId);
-        try {
+        // Run the whole sweep on the dedicated "outbox" lane — its OWN
+        // persistent connection, separate from the slow/sync lane. Two reasons:
+        //  1. Sent-sweep's `SELECT Sent` has been observed taking 90s on this
+        //     server; on the shared slow lane that stalled INBOX sync/backfill
+        //     behind it (the "whole worker goes silent" wedge, Bob 2026-06-20).
+        //  2. withConnection serializes the entire SEARCH→APPEND sweep on one
+        //     connection, so it can't interleave mid-transaction with another
+        //     task's SELECT (the "BAD No mailbox selected" class, Bob
+        //     2026-05-25). Previously this used createClientWithLimit() — which
+        //     actually returned the SHARED slow client and then destroyed it in
+        //     a finally, the opposite of "dedicated".
+        await this.withConnection(accountId, async (client) => {
             for (const row of rows) {
                 const msgId = row.message_id;
                 if (!msgId)
@@ -5317,17 +5337,7 @@ export class ImapManager extends EventEmitter {
                     }
                 }
             }
-        }
-        finally {
-            try {
-                await (client._realLogout || client.logout)();
-            }
-            catch { /* */ }
-            try {
-                client.destroy?.();
-            }
-            catch { /* */ }
-        }
+        }, { lane: "outbox", timeoutMs: 120_000 });
         if (reconciled + appended > 0) {
             this.emit("folderCountsChanged", accountId, {});
             console.log(`  [sent-sweep] ${accountId}: ${reconciled} rebound, ${appended} re-appended`);
@@ -5617,13 +5627,14 @@ export class ImapManager extends EventEmitter {
         this.stopPeriodicSync();
         this.stopOutboxWorker();
         await this.stopWatching();
-        // Disconnect persistent connections on both lanes. Use a Set
-        // because fastClients can hold an entry an account doesn't have
-        // in opsClients (e.g. body fetches happened but no sync did).
-        const accountIds = new Set([
-            ...this.opsClients.keys(),
-            ...this.fastClients.keys(),
-        ]);
+        // Disconnect persistent connections on every lane. Union across all
+        // lane maps because a lane can hold an account the others don't (e.g.
+        // body fetches happened on "fast" but no sync ran on "sync").
+        const accountIds = new Set();
+        for (const map of this.laneClients.values()) {
+            for (const k of map.keys())
+                accountIds.add(k);
+        }
         for (const accountId of accountIds) {
             await this.disconnectOps(accountId);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx-imap",
-  "version": "0.1.104",
+  "version": "0.1.106",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",