@bobfrankston/mailx 1.0.395 → 1.0.405

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

@@ -158,6 +158,10 @@ export declare class MailxService {
     }>;
     deleteDraft(accountId: string, draftUid: number, draftId?: string): Promise<void>;
     searchContacts(query: string): any[];
+    /** Q49: boolean hint for compose to auto-expand Cc when replying to this
+     *  address. True when at least one past sent message to the same recipient
+     *  had a non-empty Cc field. */
+    hasCcHistoryTo(email: string): boolean;
     syncGoogleContacts(): Promise<void>;
     seedContacts(): number;
     /** Explicit add to address book — used by the right-click "Add to contacts"

package/packages/mailx-service/index.js

@@ -1351,6 +1351,12 @@ export class MailxService {
             return [];
         return this.db.searchContacts(query);
     }
+    /** Q49: boolean hint for compose to auto-expand Cc when replying to this
+     *  address. True when at least one past sent message to the same recipient
+     *  had a non-empty Cc field. */
+    hasCcHistoryTo(email) {
+        return this.db.hasCcHistoryTo(email);
+    }
     async syncGoogleContacts() {
         await this.imapManager.syncAllContacts();
     }

package/packages/mailx-service/jsonrpc.js

@@ -140,6 +140,8 @@ async function dispatchAction(svc, action, p) {
             return svc.search(p.query, p.page, p.pageSize, p.scope, p.accountId, p.folderId);
         case "searchContacts":
             return svc.searchContacts(p.query);
+        case "hasCcHistoryTo":
+            return { hasCc: svc.hasCcHistoryTo(p.email) };
         case "addContact":
             return { ok: svc.addContact(p.name, p.email) };
         case "listContacts":

package/packages/mailx-store/db.d.ts

@@ -19,6 +19,14 @@ export declare class MailxDB {
     hasSentMessage(messageId: string): boolean;
     /** Record a successfully sent message so future attempts are skipped. */
     recordSent(messageId: string, accountId: string, subject: string, recipients: string[]): void;
+    /** Q49 heuristic: has the user ever sent a message to `recipientEmail`
+     *  that had a non-empty Cc field? Used by compose to auto-expand the Cc
+     *  input when replying to someone who customarily gets Cc'd with others.
+     *  Query scans only Sent folders (special_use='sent') and matches the
+     *  recipient's address inside `to_json` via LIKE. No special index — the
+     *  Sent folder's row count is typically a few thousand at most; acceptable
+     *  on the compose-open path. */
+    hasCcHistoryTo(recipientEmail: string): boolean;
     /** Mark a Message-ID as locally-deleted for an account. No-op if messageId
      *  is empty (e.g. provider stripped the header) — without a stable id we
      *  can't check against future sync results anyway. */

package/packages/mailx-store/db.js

@@ -338,6 +338,32 @@ export class MailxDB {
             console.error(`  [sent_log] failed to record ${messageId}: ${e.message}`);
         }
     }
+    /** Q49 heuristic: has the user ever sent a message to `recipientEmail`
+     *  that had a non-empty Cc field? Used by compose to auto-expand the Cc
+     *  input when replying to someone who customarily gets Cc'd with others.
+     *  Query scans only Sent folders (special_use='sent') and matches the
+     *  recipient's address inside `to_json` via LIKE. No special index — the
+     *  Sent folder's row count is typically a few thousand at most; acceptable
+     *  on the compose-open path. */
+    hasCcHistoryTo(recipientEmail) {
+        const email = (recipientEmail || "").trim().toLowerCase();
+        if (!email)
+            return false;
+        try {
+            const row = this.db.prepare(`
+                SELECT 1 FROM messages m
+                JOIN folders f ON m.folder_id = f.id
+                WHERE f.special_use = 'sent'
+                  AND lower(m.to_json) LIKE ?
+                  AND m.cc_json IS NOT NULL AND m.cc_json != '[]' AND m.cc_json != ''
+                LIMIT 1
+            `).get(`%"${email}"%`);
+            return !!row;
+        }
+        catch {
+            return false;
+        }
+    }
     // ── Tombstones (local-delete record so server echo can't resurrect) ──
     /** Mark a Message-ID as locally-deleted for an account. No-op if messageId
      *  is empty (e.g. provider stripped the header) — without a stable id we
@@ -853,7 +879,9 @@ export class MailxDB {
         const rows = this.db.prepare(`SELECT m.*, EXISTS(
                 SELECT 1 FROM sync_actions sa
                 WHERE sa.account_id = m.account_id AND sa.uid = m.uid
-            ) AS pending
+            ) AS pending,
+            (SELECT COUNT(DISTINCT account_id) FROM messages m2
+             WHERE m2.message_id = m.message_id AND m.message_id != '') AS dupeCount
             FROM messages m WHERE m.folder_id IN (${placeholders})
             ORDER BY m.date DESC LIMIT ? OFFSET ?`).all(...folderIds, pageSize, offset);
         const items = rows.map(r => ({
@@ -876,6 +904,11 @@ export class MailxDB {
             preview: r.preview,
             bodyPath: r.body_path || "",
             pending: !!r.pending,
+            // >=2 means the same message-id exists under another account in
+            // the local DB (delivered to both accounts, or a mailing-list
+            // Bcc). The unified-inbox UI shows a small ⇆ badge on these
+            // rows so the user knows "this is a copy of the same message".
+            dupeCount: r.dupeCount | 0,
         }));
         return { items, total, page, pageSize };
     }

package/packages/mailx-store-web/android-bootstrap.js

@@ -174,9 +174,19 @@ class AndroidSyncManager {
             const THROTTLE_MS = 150;
             const RATE_LIMIT_PAUSE_MS = 30000;
             const ERROR_BUDGET = 10;
+            const CONCURRENCY = 2; // S62: 2 in-flight per account
             let totalFetched = 0;
             let errors = 0;
             let announced = false;
+            // S62: INBOX always first. Within each folder the DB returns rows
+            // most-recent-first (PRIMARY KEY order), so newest unfetched INBOX
+            // mail wins the queue. A slow label (`[Gmail]/Jerrry`, etc.) can't
+            // starve INBOX any more.
+            const folderPriority = (folderId) => {
+                const f = this.db.getFolders(accountId).find((x) => x.id === folderId);
+                return f?.specialUse === "inbox" ? 0 : 1;
+            };
+            let rateLimitCooldownUntil = 0;
             while (true) {
                 const missing = this.db.getMessagesWithoutBody(accountId, BATCH_SIZE);
                 if (missing.length === 0)
@@ -186,46 +196,70 @@ class AndroidSyncManager {
                     vlog(`prefetch ${accountId} start: ${missing.length}+ pending`);
                     announced = true;
                 }
+                // Sort this batch INBOX-first. getMessagesWithoutBody doesn't
+                // know the priority, and re-querying per folder would multiply
+                // the SELECTs. One in-memory sort is cheap.
+                missing.sort((a, b) => folderPriority(a.folderId) - folderPriority(b.folderId));
                 let progressedThisBatch = false;
-                for (const m of missing) {
-                    // Sync the DB path if the body is already in IndexedDB — common
-                    // when upgrading from a build that didn't set body_path on cache.
-                    if (await this.bodyStore.hasMessage(accountId, m.folderId, m.uid)) {
-                        this.db.updateBodyPath(accountId, m.uid, `idb:${accountId}/${m.folderId}/${m.uid}`);
-                        progressedThisBatch = true;
-                        continue;
-                    }
-                    try {
-                        const result = await this.fetchMessageBody(accountId, m.folderId, m.uid);
-                        if (result) {
-                            totalFetched++;
-                            progressedThisBatch = true;
-                            emitEvent({ type: "bodyCached", accountId, uid: m.uid, folderId: m.folderId });
+                let batchAborted = false;
+                // Bounded-concurrency worker pool. Each worker pulls the next
+                // unclaimed item from `missing`. Shared flags (errors,
+                // rateLimitCooldownUntil, progressedThisBatch) are updated
+                // inside the loop — sql.js is single-threaded so there's no
+                // actual race on reads/writes.
+                let cursor = 0;
+                const worker = async () => {
+                    while (cursor < missing.length) {
+                        if (batchAborted)
+                            return;
+                        if (errors >= ERROR_BUDGET)
+                            return;
+                        const idx = cursor++;
+                        const m = missing[idx];
+                        // Honor rate-limit cooldown across workers.
+                        const now = Date.now();
+                        if (rateLimitCooldownUntil > now) {
+                            await new Promise(r => setTimeout(r, rateLimitCooldownUntil - now));
                         }
-                        else {
-                            errors++;
+                        if (await this.bodyStore.hasMessage(accountId, m.folderId, m.uid)) {
+                            this.db.updateBodyPath(accountId, m.uid, `idb:${accountId}/${m.folderId}/${m.uid}`);
+                            progressedThisBatch = true;
+                            continue;
                         }
-                    }
-                    catch (e) {
-                        errors++;
-                        const msg = String(e?.message || "");
-                        if (/429|rate|too many/i.test(msg)) {
-                            console.log(`[prefetch] ${accountId}: rate-limited — pausing ${RATE_LIMIT_PAUSE_MS / 1000}s`);
-                            await new Promise(r => setTimeout(r, RATE_LIMIT_PAUSE_MS));
+                        try {
+                            const result = await this.fetchMessageBody(accountId, m.folderId, m.uid);
+                            if (result) {
+                                totalFetched++;
+                                progressedThisBatch = true;
+                                emitEvent({ type: "bodyCached", accountId, uid: m.uid, folderId: m.folderId });
+                            }
+                            else {
+                                errors++;
+                            }
                         }
-                        else {
-                            console.error(`[prefetch] ${accountId}/${m.uid}: ${msg}`);
+                        catch (e) {
+                            errors++;
+                            const msg = String(e?.message || "");
+                            if (/429|rate|too many/i.test(msg)) {
+                                console.log(`[prefetch] ${accountId}: rate-limited — pausing ${RATE_LIMIT_PAUSE_MS / 1000}s`);
+                                rateLimitCooldownUntil = Date.now() + RATE_LIMIT_PAUSE_MS;
+                            }
+                            else {
+                                console.error(`[prefetch] ${accountId}/${m.uid}: ${msg}`);
+                            }
                         }
+                        // Throttle kept per-request to spread load on flaky
+                        // phone networks; concurrency-2 means effective request
+                        // rate is ~1 per THROTTLE_MS/2.
+                        await new Promise(r => setTimeout(r, THROTTLE_MS));
                     }
-                    if (errors >= ERROR_BUDGET) {
-                        console.error(`[prefetch] ${accountId}: stopping after ${errors} errors (${totalFetched} cached)`);
-                        vlog(`prefetch ${accountId} aborted: ${errors} errors, ${totalFetched} cached`);
-                        return;
-                    }
-                    await new Promise(r => setTimeout(r, THROTTLE_MS));
+                };
+                await Promise.all(Array.from({ length: Math.min(CONCURRENCY, missing.length) }, () => worker()));
+                if (errors >= ERROR_BUDGET) {
+                    console.error(`[prefetch] ${accountId}: stopping after ${errors} errors (${totalFetched} cached)`);
+                    vlog(`prefetch ${accountId} aborted: ${errors} errors, ${totalFetched} cached`);
+                    return;
                 }
-                // If a full batch made no progress, bail out to avoid an infinite
-                // loop on messages the server can't deliver.
                 if (!progressedThisBatch) {
                     console.warn(`[prefetch] ${accountId}: batch made no progress, stopping`);
                     break;
@@ -447,6 +481,58 @@ class AndroidSyncManager {
     async undeleteMessage(accountId, uid, folderId) {
         this.db.queueSyncAction(accountId, "undelete", uid, folderId);
     }
+    /** Q112: drain queued move/flag/trash actions to the provider. Android is
+     *  standalone — it pushes state changes directly to Gmail (or other
+     *  provider) the same way desktop does. Called from the periodic 2-min
+     *  tick above. `send` actions drain separately via `processSendQueue`. */
+    async processSyncActions(accountId) {
+        const provider = this.providers.get(accountId);
+        if (!provider)
+            return;
+        const pending = this.db.getPendingSyncActions(accountId)
+            .filter((a) => a.action !== "send");
+        if (pending.length === 0)
+            return;
+        const folders = this.db.getFolders(accountId);
+        const folderPath = (id) => {
+            const f = folders.find((x) => x.id === id);
+            return f?.path || null;
+        };
+        for (const p of pending) {
+            const path = folderPath(p.folderId);
+            if (!path) {
+                this.db.failSyncActionByUid(accountId, p.action, p.uid, `unknown folder ${p.folderId}`);
+                continue;
+            }
+            try {
+                if (p.action === "flags" && typeof provider.setFlags === "function") {
+                    await provider.setFlags(path, p.uid, Array.isArray(p.flags) ? p.flags : (p.flags ? [p.flags] : []));
+                }
+                else if (p.action === "trash" && typeof provider.trashMessage === "function") {
+                    await provider.trashMessage(path, p.uid);
+                }
+                else if (p.action === "move" && typeof provider.moveMessage === "function") {
+                    const toId = p.targetFolderId;
+                    const toPath = folderPath(toId);
+                    if (!toPath) {
+                        this.db.failSyncActionByUid(accountId, p.action, p.uid, `unknown target folder ${toId}`);
+                        continue;
+                    }
+                    await provider.moveMessage(path, p.uid, toPath);
+                }
+                else {
+                    this.db.failSyncActionByUid(accountId, p.action, p.uid, `provider does not support ${p.action}`);
+                    continue;
+                }
+                this.db.completeSyncActionByUid(accountId, p.action, p.uid);
+            }
+            catch (e) {
+                const msg = e?.message || String(e);
+                console.error(`[sync-action] ${accountId} ${p.action} uid=${p.uid}: ${msg}`);
+                this.db.failSyncActionByUid(accountId, p.action, p.uid, msg);
+            }
+        }
+    }
     queueOutgoingLocal(accountId, rawMessage) {
         // Local-first: PERSIST to sync_actions before attempting the network
         // send, so a crash / offline / process kill between now and SMTP ACK
@@ -858,76 +944,87 @@ export async function initAndroid() {
         }
         await syncManager.addAccount(account);
     }
-    // Connect to GDrive using the Gmail token — read shared accounts.jsonc
-    if (gmailTokenProvider) {
-        setGDriveTokenProvider(gmailTokenProvider);
-        try {
-            console.log("[android] Looking up GDrive mailx folder...");
-            const folderId = await findGDriveMailxFolder(gmailTokenProvider);
-            if (!folderId) {
-                console.warn("[android] GDrive mailx folder not found");
-            }
-            else {
-                setGDriveFolderId(folderId);
-                console.log(`[android] GDrive mailx folder: ${folderId}`);
-                // DEBUG: list all files in the folder
-                try {
-                    const tk = await gmailTokenProvider();
-                    const lr = await fetch(`https://www.googleapis.com/drive/v3/files?q='${folderId}'+in+parents+and+trashed%3Dfalse&fields=files(id,name,mimeType,owners(emailAddress))`, { headers: { "Authorization": `Bearer ${tk}` } });
-                    if (lr.ok) {
-                        const ld = await lr.json();
-                        const names = (ld.files || []).map((f) => `${f.name}(${f.owners?.[0]?.emailAddress || "?"})`).join(",");
-                        console.log(`[android] Folder contents: ${ld.files?.length || 0} files [${names}]`);
-                    }
-                    else {
-                        console.warn(`[android] List folder failed: ${lr.status}`);
-                    }
-                }
-                catch (e) {
-                    console.warn(`[android] List debug: ${e.message}`);
-                }
-                // Read accounts directly from GDrive (bypass IndexedDB cache)
-                console.log("[android] Reading accounts.jsonc from GDrive...");
-                const gdriveAccounts = await loadAccountsFromCloud();
-                console.log(`[android] GDrive returned ${gdriveAccounts.length} accounts: ${gdriveAccounts.map(a => a.id).join(",")}`);
-                if (gdriveAccounts.length > 0) {
-                    // Use canonical GDrive accounts (upsert handles overwrites)
-                    accounts = gdriveAccounts;
-                    for (const account of accounts) {
-                        vlog(`init: registering ${account.id} email=${account.email} enabled=${account.enabled} imap=${JSON.stringify(account.imap)}`);
-                        if (!account.enabled) {
-                            vlog(`init: ${account.id} disabled, skipping`);
-                            continue;
-                        }
-                        const domain = account.email?.split("@")[1]?.toLowerCase() || "";
-                        if (domain === "gmail.com" || domain === "googlemail.com") {
-                            syncManager.setTokenProvider(account.id, createNativeTokenProvider(account.email));
-                        }
-                        await syncManager.addAccount(account);
-                    }
-                    console.log(`[android] Loaded ${accounts.length} accounts from GDrive`);
-                }
-                // Register this Android device in clients.jsonc
-                await registerDeviceInGDrive(gmailTokenProvider, folderId, accounts.map(a => a.id));
-            }
-        }
-        catch (e) {
-            console.warn(`[android] GDrive access failed: ${e.message}`);
-        }
-    }
+    // Install the mailxapi bridge + drain pending queues IMMEDIATELY using
+    // the local-cache account list. UI shouldn't wait on GDrive (which can
+    // be slow on cold network) before becoming actionable. GDrive
+    // reconciliation (below) runs in the background and re-registers fresh
+    // accounts when it returns.
     installBridge();
-    // Drain any stranded send-queue entries BEFORE first sync. A message
-    // queued in a prior session (offline, crashed mid-send, process killed)
-    // gets a retry as soon as we have accounts registered. Desktop parity.
     for (const account of accounts) {
         if (!account.enabled)
             continue;
         syncManager.processSendQueue(account.id)
             .catch(e => console.error(`[android] processSendQueue ${account.id}: ${e.message}`));
+        syncManager.processSyncActions(account.id)
+            .catch(e => console.error(`[android] processSyncActions ${account.id}: ${e.message}`));
     }
+    // First sync from local accounts on a tiny delay so the UI gets to paint.
     setTimeout(() => {
         syncManager.syncAll().catch(e => console.error(`[android] Sync error: ${e.message}`));
     }, 1000);
+    // GDrive reconciliation runs in the background — accounts.jsonc on the
+    // shared cloud may have been edited from another device, so we re-pull
+    // and re-register if it differs from the cached copy. The user can
+    // already see and use mail by the time this resolves.
+    if (gmailTokenProvider) {
+        const tp = gmailTokenProvider;
+        (async () => {
+            setGDriveTokenProvider(tp);
+            try {
+                console.log("[android] Looking up GDrive mailx folder…");
+                const folderId = await findGDriveMailxFolder(tp);
+                if (!folderId) {
+                    console.warn("[android] GDrive mailx folder not found");
+                }
+                else {
+                    setGDriveFolderId(folderId);
+                    console.log(`[android] GDrive mailx folder: ${folderId}`);
+                    // DEBUG: list all files in the folder
+                    try {
+                        const tk = await tp();
+                        const lr = await fetch(`https://www.googleapis.com/drive/v3/files?q='${folderId}'+in+parents+and+trashed%3Dfalse&fields=files(id,name,mimeType,owners(emailAddress))`, { headers: { "Authorization": `Bearer ${tk}` } });
+                        if (lr.ok) {
+                            const ld = await lr.json();
+                            const names = (ld.files || []).map((f) => `${f.name}(${f.owners?.[0]?.emailAddress || "?"})`).join(",");
+                            console.log(`[android] Folder contents: ${ld.files?.length || 0} files [${names}]`);
+                        }
+                        else {
+                            console.warn(`[android] List folder failed: ${lr.status}`);
+                        }
+                    }
+                    catch (e) {
+                        console.warn(`[android] List debug: ${e.message}`);
+                    }
+                    // Read accounts directly from GDrive (bypass IndexedDB cache)
+                    console.log("[android] Reading accounts.jsonc from GDrive...");
+                    const gdriveAccounts = await loadAccountsFromCloud();
+                    console.log(`[android] GDrive returned ${gdriveAccounts.length} accounts: ${gdriveAccounts.map(a => a.id).join(",")}`);
+                    if (gdriveAccounts.length > 0) {
+                        // Use canonical GDrive accounts (upsert handles overwrites)
+                        accounts = gdriveAccounts;
+                        for (const account of accounts) {
+                            vlog(`init: registering ${account.id} email=${account.email} enabled=${account.enabled} imap=${JSON.stringify(account.imap)}`);
+                            if (!account.enabled) {
+                                vlog(`init: ${account.id} disabled, skipping`);
+                                continue;
+                            }
+                            const domain = account.email?.split("@")[1]?.toLowerCase() || "";
+                            if (domain === "gmail.com" || domain === "googlemail.com") {
+                                syncManager.setTokenProvider(account.id, createNativeTokenProvider(account.email));
+                            }
+                            await syncManager.addAccount(account);
+                        }
+                        console.log(`[android] Loaded ${accounts.length} accounts from GDrive`);
+                    }
+                    // Register this Android device in clients.jsonc
+                    await registerDeviceInGDrive(tp, folderId, accounts.map(a => a.id));
+                }
+            }
+            catch (e) {
+                console.warn(`[android] GDrive access failed: ${e.message}`);
+            }
+        })();
+    }
     // Periodic re-sync every 2 minutes (no IDLE on Android, so poll)
     const SYNC_INTERVAL_MS = 2 * 60 * 1000;
     setInterval(() => {
@@ -937,6 +1034,8 @@ export async function initAndroid() {
         for (const account of db.getAccounts()) {
             syncManager.processSendQueue(account.id)
                 .catch(e => console.error(`[android] retry ${account.id}: ${e.message}`));
+            syncManager.processSyncActions(account.id)
+                .catch(e => console.error(`[android] processSyncActions ${account.id}: ${e.message}`));
         }
         syncManager.syncAll().catch(e => console.error(`[android] Periodic sync error: ${e.message}`));
     }, SYNC_INTERVAL_MS);
@@ -998,6 +1097,7 @@ function installBridge() {
         },
         searchMessages: (query, page, pageSize) => service.search(query, page, pageSize),
         searchContacts: (query) => service.searchContacts(query),
+        hasCcHistoryTo: (email) => ({ hasCc: service.hasCcHistoryTo?.(email) ?? false }),
         syncAll: async () => { await service.syncAll(); return { ok: true }; },
         syncAccount: async (accountId) => { await service.syncAccount(accountId); return { ok: true }; },
         getSyncPending: () => service.getSyncPending(),

package/packages/mailx-store-web/db.d.ts

@@ -94,6 +94,10 @@ export declare class WebMailxDB {
         source: string;
         useCount: number;
     }[];
+    /** Q49 heuristic: has the user ever sent to `recipientEmail` with a
+     *  non-empty Cc? Scans Sent folder(s). Used by compose to auto-expand
+     *  the Cc row on reply to a frequent-Cc'd recipient. */
+    hasCcHistoryTo(recipientEmail: string): boolean;
     searchMessages(query: string, page?: number, pageSize?: number, accountId?: string, folderId?: number): PagedResult<MessageEnvelope>;
     queueSyncAction(accountId: string, action: string, uid: number, folderId: number, extra?: {
         targetFolderId?: number;

package/packages/mailx-store-web/db.js

@@ -483,11 +483,36 @@ export class WebMailxDB {
         return added;
     }
     searchContacts(query, limit = 10) {
+        query = (query || "").trim();
+        if (!query)
+            return [];
         const q = `%${query}%`;
         return this.all(`SELECT name, email, source, use_count as useCount FROM contacts
              WHERE email LIKE ? OR name LIKE ?
              ORDER BY use_count DESC, last_used DESC LIMIT ?`, [q, q, limit]);
     }
+    /** Q49 heuristic: has the user ever sent to `recipientEmail` with a
+     *  non-empty Cc? Scans Sent folder(s). Used by compose to auto-expand
+     *  the Cc row on reply to a frequent-Cc'd recipient. */
+    hasCcHistoryTo(recipientEmail) {
+        const email = (recipientEmail || "").trim().toLowerCase();
+        if (!email)
+            return false;
+        try {
+            const row = this.get(`
+                SELECT 1 FROM messages m
+                JOIN folders f ON m.folder_id = f.id
+                WHERE f.special_use = 'sent'
+                  AND lower(m.to_json) LIKE ?
+                  AND m.cc_json IS NOT NULL AND m.cc_json != '[]' AND m.cc_json != ''
+                LIMIT 1
+            `, [`%"${email}"%`]);
+            return !!row;
+        }
+        catch {
+            return false;
+        }
+    }
     // ── Search ──
     searchMessages(query, page = 1, pageSize = 50, accountId, folderId) {
         const offset = (page - 1) * pageSize;

package/packages/mailx-store-web/sync-manager.d.ts

@@ -48,6 +48,13 @@ export declare class SyncManager implements WebSyncManager {
     }[], targetFolderId: number): Promise<void>;
     moveMessageCrossAccount(): Promise<void>;
     undeleteMessage(accountId: string, uid: number, folderId: number): Promise<void>;
+    /** Q112: drain queued move/flag/trash actions to the provider. Android is
+     *  standalone — it pushes state changes to Gmail (or other provider) the
+     *  same way desktop does, so local actions propagate without needing a
+     *  desktop to relay them. Called from android-bootstrap on startup and
+     *  every 2-min sync tick. `send` actions are drained separately by
+     *  processSendQueue. */
+    processSyncActions(accountId: string): Promise<void>;
     markFolderRead(folderId: number): Promise<void>;
     emptyFolder(accountId: string, folderId: number): Promise<void>;
     queueOutgoingLocal(accountId: string, rawMessage: string): void;

package/packages/mailx-store-web/sync-manager.js

@@ -329,6 +329,61 @@ export class SyncManager {
     async undeleteMessage(accountId, uid, folderId) {
         this.db.queueSyncAction(accountId, "undelete", uid, folderId);
     }
+    /** Q112: drain queued move/flag/trash actions to the provider. Android is
+     *  standalone — it pushes state changes to Gmail (or other provider) the
+     *  same way desktop does, so local actions propagate without needing a
+     *  desktop to relay them. Called from android-bootstrap on startup and
+     *  every 2-min sync tick. `send` actions are drained separately by
+     *  processSendQueue. */
+    async processSyncActions(accountId) {
+        const provider = this.getProvider(accountId);
+        if (!provider)
+            return;
+        const pending = this.db.getPendingSyncActions(accountId)
+            .filter((a) => a.action !== "send");
+        if (pending.length === 0)
+            return;
+        const folders = this.db.getFolders(accountId);
+        const folderPath = (id) => {
+            const f = folders.find((x) => x.id === id);
+            return f?.path || null;
+        };
+        for (const p of pending) {
+            const path = folderPath(p.folderId);
+            if (!path) {
+                this.db.failSyncActionByUid(accountId, p.action, p.uid, `unknown folder ${p.folderId}`);
+                continue;
+            }
+            try {
+                if (p.action === "flags" && typeof provider.setFlags === "function") {
+                    await provider.setFlags(path, p.uid, Array.isArray(p.flags) ? p.flags : (p.flags ? [p.flags] : []));
+                }
+                else if (p.action === "trash" && typeof provider.trashMessage === "function") {
+                    await provider.trashMessage(path, p.uid);
+                }
+                else if (p.action === "move" && typeof provider.moveMessage === "function") {
+                    const toId = p.targetFolderId;
+                    const toPath = folderPath(toId);
+                    if (!toPath) {
+                        this.db.failSyncActionByUid(accountId, p.action, p.uid, `unknown target folder ${toId}`);
+                        continue;
+                    }
+                    await provider.moveMessage(path, p.uid, toPath);
+                }
+                else {
+                    // Unsupported action for this provider — don't loop forever.
+                    this.db.failSyncActionByUid(accountId, p.action, p.uid, `provider does not support ${p.action}`);
+                    continue;
+                }
+                this.db.completeSyncActionByUid(accountId, p.action, p.uid);
+            }
+            catch (e) {
+                const msg = e?.message || String(e);
+                console.error(`[sync-action] ${accountId} ${p.action} uid=${p.uid}: ${msg}`);
+                this.db.failSyncActionByUid(accountId, p.action, p.uid, msg);
+            }
+        }
+    }
     async markFolderRead(folderId) {
         this.db.markFolderRead(folderId);
     }

package/packages/mailx-store-web/web-service.d.ts

@@ -71,6 +71,10 @@ export declare class WebMailxService {
     }>;
     deleteDraft(accountId: string, draftUid: number): Promise<void>;
     searchContacts(query: string): any[];
+    /** Q49 heuristic mirror: true if the user has ever sent a message to
+     *  `recipientEmail` that had a non-empty Cc field. Compose uses this to
+     *  decide whether to auto-expand the Cc row on reply. */
+    hasCcHistoryTo(recipientEmail: string): boolean;
     getSettings(): Promise<any>;
     saveSettingsData(settings: any): Promise<void>;
     getStorageInfo(): {

package/packages/mailx-store-web/web-service.js

@@ -437,10 +437,17 @@ export class WebMailxService {
     }
     // ── Contacts ──
     searchContacts(query) {
+        query = (query || "").trim();
         if (query.length < 1)
             return [];
         return this.db.searchContacts(query);
     }
+    /** Q49 heuristic mirror: true if the user has ever sent a message to
+     *  `recipientEmail` that had a non-empty Cc field. Compose uses this to
+     *  decide whether to auto-expand the Cc row on reply. */
+    hasCcHistoryTo(recipientEmail) {
+        return this.db.hasCcHistoryTo?.(recipientEmail) ?? false;
+    }
     // ── Settings ──
     async getSettings() {
         return loadSettings();

package/tdview.cmd

@@ -0,0 +1 @@
+call mdview todo.md -pos 100,100,1 -size 900,1400

package/unwedge.cmd

@@ -0,0 +1 @@
+rmdir C:\Users\Bob\.claude\session-env\5a053d1d-7856-4e74-9b2b-23a4e3262aed /s /q