@bobfrankston/mailx 1.0.376 → 1.0.378

package/client/components/calendar-sidebar.js

@@ -58,7 +58,7 @@ async function fetchUpcoming(from) {
     const local = loadLocalEvents();
     let google = [];
     try {
-        const primary = await getPrimaryAccount();
+        const primary = await getPrimaryAccount("calendar");
         if (primary?.email) {
             // The OAuth token is held by the service-side OAuthTokenManager;
             // calendar fetch goes through a server-side proxy method (not
@@ -188,11 +188,15 @@ export function hideCalendarSidebar() {
     catch { /* */ }
 }
 export function isCalendarSidebarOn() {
+    // Default is ON — user-reported 2026-04-23 that the sidebar should be
+    // visible by default, not hidden. An explicit "false" in localStorage
+    // still hides it (the user's stored preference wins).
     try {
-        return localStorage.getItem(SIDEBAR_PREF) === "true";
+        const v = localStorage.getItem(SIDEBAR_PREF);
+        return v === null ? true : v !== "false";
     }
     catch {
-        return false;
+        return true;
     }
 }
 /** Wire one-time event handlers + restore from localStorage. Safe to call

package/client/components/message-list.js

@@ -370,7 +370,7 @@ function restoreSelection(body, savedUid) {
 /** Show a floating list of all messages in a thread when the pill is clicked.
  *  Each entry in the popup selects that message in the viewer when clicked.
  *  This is simpler than inline expansion and avoids duplicating the row builder. */
-async function showThreadPopup(pillEl, headMsg) {
+export async function showThreadPopup(pillEl, headMsg) {
     // Remove any existing popup
     document.querySelectorAll(".ml-thread-popup").forEach(el => el.remove());
     let thread = [];
@@ -464,6 +464,11 @@ function appendMessages(body, accountId, items) {
         // action (move/flag/delete) hasn't been ACK'd by the server yet.
         if (msg.pending)
             row.classList.add("pending-reconcile");
+        // Reply-row marker: messages with In-Reply-To are replies. Shows a
+        // subtle left-border accent so the eye can pick out threaded replies
+        // without enabling full thread grouping.
+        if (msg.inReplyTo)
+            row.classList.add("is-reply");
         row.dataset.uid = String(msg.uid);
         row.dataset.accountId = msgAccountId;
         row.dataset.folderId = String(msg.folderId);
@@ -600,6 +605,37 @@ function appendMessages(body, accountId, items) {
             }
         });
         row.addEventListener("dragend", () => row.classList.remove("dragging"));
+        // ── Q66: long-press on touch → context menu ──
+        // Mirrors right-click on the phone where right-click isn't a thing.
+        // Cancelled by any touchmove or touchend before the threshold.
+        let longPressTimer = null;
+        const LONG_PRESS_MS = 550;
+        row.addEventListener("touchstart", (e) => {
+            const t = e.touches[0];
+            if (!t)
+                return;
+            const cx = t.clientX, cy = t.clientY;
+            if (longPressTimer)
+                clearTimeout(longPressTimer);
+            longPressTimer = setTimeout(() => {
+                longPressTimer = null;
+                // Synthesize a contextmenu event so the existing handler below
+                // owns all the menu logic — no per-event duplication.
+                const ev = new MouseEvent("contextmenu", {
+                    clientX: cx, clientY: cy, bubbles: true, cancelable: true,
+                });
+                row.dispatchEvent(ev);
+            }, LONG_PRESS_MS);
+        }, { passive: true });
+        const cancelLongPress = () => {
+            if (longPressTimer) {
+                clearTimeout(longPressTimer);
+                longPressTimer = null;
+            }
+        };
+        row.addEventListener("touchmove", cancelLongPress, { passive: true });
+        row.addEventListener("touchend", cancelLongPress, { passive: true });
+        row.addEventListener("touchcancel", cancelLongPress, { passive: true });
         // ── Right-click context menu ──
         row.addEventListener("contextmenu", (e) => {
             e.preventDefault();

package/client/components/message-viewer.js

@@ -395,6 +395,23 @@ export async function showMessage(accountId, uid, folderId, specialUse, isRetry
                 unsubBtn.hidden = true;
             }
         }
+        // View Thread button — opens the thread popup from the message list
+        // so the user can see all messages in the conversation. Works from
+        // the viewer even when thread-grouping is off.
+        const threadBtn = document.getElementById("mv-view-thread");
+        if (threadBtn) {
+            const tid = msg.threadId || "";
+            if (tid) {
+                threadBtn.hidden = false;
+                threadBtn.onclick = async () => {
+                    const { showThreadPopup } = await import("./message-list.js");
+                    await showThreadPopup(threadBtn, { accountId, threadId: tid });
+                };
+            }
+            else {
+                threadBtn.hidden = true;
+            }
+        }
         // View Source button — shows .eml file path
         const srcBtn = document.getElementById("mv-view-source");
         if (srcBtn) {

package/client/index.html

@@ -134,6 +134,7 @@
                     <button class="tb-btn" id="btn-spam" title="Mark as spam — move to configured spam folder" hidden>⚠</button>
                     <button class="tb-btn" id="btn-flag" title="Flag">⚑</button>
                     <button class="tb-btn" id="btn-mark-unread" title="Mark unread (R)">◉</button>
+                    <button class="tb-btn" id="mv-view-thread" title="View thread (conversation)" hidden>💬</button>
                     <span style="flex:1"></span>
                     <button class="mv-action mv-action-primary" id="mv-edit-draft" hidden>Edit & Send</button>
                     <a class="mv-unsubscribe" id="mv-unsubscribe" hidden>Unsubscribe</a>

package/client/lib/api-client.js

@@ -134,10 +134,12 @@ export function getSyncPending() {
 export function getDiagnostics() {
     return ipc().getDiagnostics?.() ?? Promise.resolve([]);
 }
-/** Account marked `primary: true` in accounts.jsonc — used by Calendar /
- *  Tasks / Contacts to pick which Google account's data to show. */
-export function getPrimaryAccount() {
-    return ipc().getPrimaryAccount?.() ?? Promise.resolve(null);
+/** Account that supplies `feature` data (calendar / tasks / contacts).
+ *  Resolution: per-feature primary flag → catch-all `primary` → first account.
+ *  Pass e.g. "calendar" to honor `primaryCalendar:true` overrides; omit for
+ *  back-compat single-flag behavior. */
+export function getPrimaryAccount(feature) {
+    return ipc().getPrimaryAccount?.(feature) ?? Promise.resolve(null);
 }
 export function getOutboxStatus() {
     return ipc().getOutboxStatus();

package/client/lib/mailxapi.js

@@ -160,7 +160,7 @@
         getSyncPending: function() { return callNode("getSyncPending"); },
         getOutboxStatus: function() { return callNode("getOutboxStatus"); },
         getDiagnostics: function() { return callNode("getDiagnostics"); },
-        getPrimaryAccount: function() { return callNode("getPrimaryAccount"); },
+        getPrimaryAccount: function(feature) { return callNode("getPrimaryAccount", { feature: feature }); },
         listQueuedOutgoing: function() { return callNode("listQueuedOutgoing"); },
         cancelQueuedOutgoing: function(p) { return callNode("cancelQueuedOutgoing", { path: p }); },
         reauthenticate: function(accountId) { return callNode("reauthenticate", { accountId: accountId }); },

package/client/styles/components.css

@@ -788,6 +788,24 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
     opacity: 0.5;
 }
 
+/* Reply marker — messages whose In-Reply-To points at another message get a
+   subtle left-edge accent so threaded replies visibly distinguish from top-
+   level posts without needing thread-grouping mode on. Works regardless of
+   whether thread-grouping is enabled. */
+.ml-row.is-reply::before {
+    content: "";
+    position: absolute;
+    left: 0;
+    top: 2px;
+    bottom: 2px;
+    width: 2px;
+    background: oklch(0.70 0.12 250);  /* muted blue */
+    border-radius: 0 1px 1px 0;
+    pointer-events: none;
+    opacity: 0.5;
+}
+.ml-row { position: relative; }
+
 /* S1 slice C — local action (move/flag/delete) queued but server hasn't
    ACK'd. Reuses the same date-column dot as the download indicator so
    "still on client, not yet on server" sits in the same visual slot as
@@ -799,25 +817,24 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
 }
 
 /* S51 — calendar sidebar (Thunderbird Lightning Events & Tasks pane).
-   Right-docked, fixed width, hidden by default. Toggled by View menu.
+   Right-docked, fixed width. Visible by default; user hides via View menu.
    Hides automatically on narrow screens (< 1100px) — Android uses the
-   native calendar app. */
+   native calendar app. When hidden, the main grid does NOT reserve a column
+   for it, so there's no blank strip on the right. */
 .calendar-sidebar {
     grid-area: cal-side;
-    width: 280px;
     border-left: 1px solid var(--color-border);
     background: var(--color-bg);
-    display: flex;
+    display: none;  /* Opt-in: only show when body.calendar-sidebar-on */
     flex-direction: column;
     overflow: hidden;
     font-size: var(--font-size-sm);
 }
+body.calendar-sidebar-on .calendar-sidebar { display: flex; }
+
 @media (max-width: 1100px) {
-    .calendar-sidebar { display: none; }
-}
-body.calendar-sidebar-on {
-    /* Re-flow main grid to make room for the sidebar on the right.
-       Folder-tree / message-list / message-viewer share the remaining area. */
+    .calendar-sidebar,
+    body.calendar-sidebar-on .calendar-sidebar { display: none; }
 }
 .cal-side-head {
     display: flex;

package/client/styles/layout.css

@@ -25,6 +25,18 @@ body {
     background: var(--color-bg);
 }
 
+/* When the calendar sidebar is on, re-flow the grid to reserve a fourth
+   column on the right. When off, no column is reserved — the aside is
+   display:none and the grid stays three-column. */
+body.calendar-sidebar-on {
+    grid-template-columns: var(--rail-width, 48px) var(--folder-width) 1fr var(--cal-side-width, 280px);
+    grid-template-areas:
+        "toolbar  toolbar  toolbar  toolbar"
+        "alert    alert    alert    alert"
+        "rail     folders  main     cal-side"
+        "status   status   status   status";
+}
+
 .toolbar { grid-area: toolbar; }
 .icon-rail { grid-area: rail; }
 .folder-panel { grid-area: folders; display: flex; flex-direction: column; overflow: hidden; }
@@ -101,9 +113,13 @@ body {
     background: var(--color-accent);
 }
 
-/* Responsive: mid-width (tablets, foldables) — keep rail + list + viewer; folders overlay */
+/* Responsive: mid-width (tablets, foldables) — keep rail + list + viewer; folders overlay.
+   Calendar sidebar is hidden in this tier by its own media query, and the
+   body grid does NOT include a cal-side column here — the .calendar-sidebar-on
+   body class override above is shadowed by this mid-width rule. */
 @media (max-width: 1100px) and (min-width: 769px) {
-    body {
+    body,
+    body.calendar-sidebar-on {
         grid-template-columns: var(--rail-width, 48px) 1fr;
         grid-template-rows: var(--toolbar-height) auto 1fr var(--statusbar-height);
         grid-template-areas:
@@ -157,7 +173,8 @@ body {
     #status-version { display: none; }
 }
 @media (max-width: 768px), (max-height: 600px) {
-    body {
+    body,
+    body.calendar-sidebar-on {
         grid-template-columns: 1fr;
         grid-template-rows: var(--toolbar-height) auto 1fr var(--statusbar-height);
         grid-template-areas:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.376",
+  "version": "1.0.378",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",

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

@@ -39,11 +39,14 @@ export declare class MailxService {
     /** Per-account health snapshot: inactivity-timeout count, conn-cap hits,
      *  last failed IMAP command. Drives the diagnostics ⚠ badge in the UI. */
     getDiagnostics(): any;
-    /** Return the account marked `primary: true` in accounts.jsonc, or the
-     *  first account if none. Used by Calendar / Tasks / Contacts to pick
-     *  which Google account's data to show. Single-flag for now;
-     *  per-feature flags + multi-calendar comingling deferred. */
-    getPrimaryAccount(): any;
+    /** Return the account that supplies `feature` data (calendar / tasks /
+     *  contacts). Resolution order:
+     *    1. Any account with `primary<Feature>: true`   (per-feature override)
+     *    2. Any account with `primary: true`            (catch-all default)
+     *    3. First account                               (fallback)
+     *  Called without `feature` it returns the catch-all primary — same
+     *  semantics as the original single-flag version for back-compat. */
+    getPrimaryAccount(feature?: string): any;
     /** List queued outgoing messages with parsed envelope headers so the UI
      *  can render a pink-row "pending" view before IMAP APPEND succeeds. */
     listQueuedOutgoing(): any[];

package/packages/mailx-service/index.js

@@ -102,7 +102,14 @@ export class MailxService {
         for (const cfg of cfgs) {
             const a = dbAccounts.find(d => d.id === cfg.id);
             if (a)
-                ordered.push({ ...a, label: cfg.label, defaultSend: cfg.defaultSend || false, primary: !!cfg.primary, identityDomains: cfg.identityDomains || [] });
+                ordered.push({
+                    ...a, label: cfg.label, defaultSend: cfg.defaultSend || false,
+                    primary: !!cfg.primary,
+                    primaryCalendar: !!cfg.primaryCalendar,
+                    primaryTasks: !!cfg.primaryTasks,
+                    primaryContacts: !!cfg.primaryContacts,
+                    identityDomains: cfg.identityDomains || [],
+                });
         }
         // Append any DB accounts not in settings
         for (const a of dbAccounts) {
@@ -421,12 +428,21 @@ export class MailxService {
     getDiagnostics() {
         return this.imapManager.getDiagnosticsSnapshot();
     }
-    /** Return the account marked `primary: true` in accounts.jsonc, or the
-     *  first account if none. Used by Calendar / Tasks / Contacts to pick
-     *  which Google account's data to show. Single-flag for now;
-     *  per-feature flags + multi-calendar comingling deferred. */
-    getPrimaryAccount() {
+    /** Return the account that supplies `feature` data (calendar / tasks /
+     *  contacts). Resolution order:
+     *    1. Any account with `primary<Feature>: true`   (per-feature override)
+     *    2. Any account with `primary: true`            (catch-all default)
+     *    3. First account                               (fallback)
+     *  Called without `feature` it returns the catch-all primary — same
+     *  semantics as the original single-flag version for back-compat. */
+    getPrimaryAccount(feature) {
         const all = this.getAccounts();
+        if (feature) {
+            const perFeatureKey = "primary" + feature.charAt(0).toUpperCase() + feature.slice(1);
+            const perFeature = all.find((a) => a[perFeatureKey]);
+            if (perFeature)
+                return perFeature;
+        }
         return all.find((a) => a.primary) || all[0] || null;
     }
     /** List queued outgoing messages with parsed envelope headers so the UI

package/packages/mailx-service/jsonrpc.js

@@ -97,7 +97,7 @@ async function dispatchAction(svc, action, p) {
         case "getDiagnostics":
             return svc.getDiagnostics();
         case "getPrimaryAccount":
-            return svc.getPrimaryAccount();
+            return svc.getPrimaryAccount(p?.feature);
         case "getOutboxStatus":
             return svc.getOutboxStatus();
         case "listQueuedOutgoing":

package/packages/mailx-settings/index.js

@@ -377,6 +377,9 @@ function normalizeAccount(acct, globalName) {
         },
         enabled: acct.enabled ?? true,
         primary: acct.primary,
+        primaryCalendar: acct.primaryCalendar,
+        primaryTasks: acct.primaryTasks,
+        primaryContacts: acct.primaryContacts,
         defaultSend: acct.defaultSend,
         syncContacts: acct.syncContacts ?? (provider?.imap.auth === "oauth2"),
         relayDomains: acct.relayDomains,

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

@@ -7,6 +7,9 @@ import type { MessageEnvelope, Folder, EmailAddress, PagedResult, MessageQuery }
 export declare class MailxDB {
     private db;
     constructor(dbDir: string);
+    /** Fail loud + early if expected columns are missing. Cheap (PRAGMA only
+     *  runs at startup). The user-facing message names the recovery command. */
+    private verifySchema;
     /** One-time: assign UUIDs to every `messages` row that's missing one.
      *  Runs on every startup but the WHERE clause makes it a no-op after the
      *  first pass. */

package/packages/mailx-store/db.js

@@ -182,6 +182,34 @@ export class MailxDB {
         // this column landed. One UPDATE + an id roundtrip per row — cheap
         // at our row counts, runs once per DB upgrade.
         this.backfillUuids();
+        // Post-migration sanity check: verify the columns we actually read in
+        // SELECTs exist. If any migration silently failed (stale driver, DB
+        // file locked, permission error), later code would throw cryptic
+        // "no such column" errors buried deep in a sync run. Fail loud here
+        // with a clear "run mailx -rebuild" message. C32 on Linux was exactly
+        // this — old mailx-store that predated thread_id/uuid migrations.
+        this.verifySchema();
+    }
+    /** Fail loud + early if expected columns are missing. Cheap (PRAGMA only
+     *  runs at startup). The user-facing message names the recovery command. */
+    verifySchema() {
+        const required = {
+            messages: ["thread_id", "provider_id", "uuid"],
+        };
+        for (const [table, cols] of Object.entries(required)) {
+            let actual;
+            try {
+                actual = this.db.prepare(`PRAGMA table_info(${table})`).all();
+            }
+            catch (e) {
+                throw new Error(`[mailx-store] schema check failed for "${table}": ${e.message}. Run 'mailx -rebuild' to rebuild the local store.`);
+            }
+            const names = new Set(actual.map(r => r.name));
+            const missing = cols.filter(c => !names.has(c));
+            if (missing.length > 0) {
+                throw new Error(`[mailx-store] table "${table}" is missing columns [${missing.join(", ")}] — schema migration did not complete. Run 'mailx -rebuild' to rebuild the local store.`);
+            }
+        }
     }
     /** One-time: assign UUIDs to every `messages` row that's missing one.
      *  Runs on every startup but the WHERE clause makes it a no-op after the

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

@@ -430,23 +430,35 @@ class AndroidSyncManager {
         this.db.queueSyncAction(accountId, "undelete", uid, folderId);
     }
     queueOutgoingLocal(accountId, rawMessage) {
-        // Two paths, both real (no stubs that pretend success — see programming.md
-        // rule "Stubs MUST NOT appear successful"):
-        //   - Gmail accounts: POST to users.messages.send (Gmail handles SMTP +
-        //     auto-files into Sent label).
-        //   - Non-Gmail accounts: smtp-direct over BridgeTransport (mailxapi.tcp).
-        // Caller (web-service.send) is sync-returning; we kick off the network
-        // request and surface success/failure via events. Compose UI listens for
-        // sendError/sendComplete.
+        // Local-first: PERSIST to sync_actions before attempting the network
+        // send, so a crash / offline / process kill between now and SMTP ACK
+        // doesn't drop the message. Desktop parity — PC writes `.ltr` to disk
+        // before calling SMTP; Android writes a sync_actions row to sql.js +
+        // IndexedDB (which saveDbToIdb persists on scheduleSave). Unique neg
+        // uid = Date.now() to avoid colliding with real message UIDs and to
+        // give us a stable tracking key through the async send pipeline.
+        //
+        // User-flagged 2026-04-23: "sending on android, like on the PC must
+        // be queued." Equivalent of PC's `~/.mailx/outbox/<acct>/*.ltr`.
+        const queueUid = -Date.now();
+        this.db.queueSyncAction(accountId, "send", queueUid, -1, { rawMessage });
+        this.attemptSend(accountId, queueUid, rawMessage);
+    }
+    /** Kick off a send for a message that's already in the queue. Called by
+     *  queueOutgoingLocal on a fresh submit AND by processSendQueue on
+     *  startup / periodic tick for anything stranded from a prior run. */
+    attemptSend(accountId, queueUid, rawMessage) {
         const provider = this.getProvider(accountId);
         if (provider && typeof provider.sendRaw === "function") {
             provider.sendRaw(rawMessage)
                 .then((result) => {
                 console.log(`[send] ${accountId}: sent via Gmail API (id=${result.id})`);
+                this.db.completeSyncActionByUid(accountId, "send", queueUid);
                 emitEvent({ type: "sendComplete", accountId, messageId: result.id });
             })
                 .catch((e) => {
                 console.error(`[send] ${accountId}: Gmail send failed: ${e.message}`);
+                this.db.failSyncActionByUid(accountId, "send", queueUid, e.message || String(e));
                 emitEvent({ type: "sendError", accountId, error: e.message });
             });
             return;
@@ -458,8 +470,9 @@ class AndroidSyncManager {
         if (!row) {
             const e = "Unknown account";
             console.error(`[send] ${accountId}: ${e}`);
+            this.db.failSyncActionByUid(accountId, "send", queueUid, e);
             emitEvent({ type: "sendError", accountId, error: e });
-            throw new Error(e);
+            return;
         }
         let account;
         try {
@@ -467,26 +480,41 @@ class AndroidSyncManager {
         }
         catch {
             const e = "Account config malformed";
+            this.db.failSyncActionByUid(accountId, "send", queueUid, e);
             emitEvent({ type: "sendError", accountId, error: e });
-            throw new Error(e);
+            return;
         }
         if (!account.smtp) {
             const e = "No SMTP config for this account";
             console.error(`[send] ${accountId}: ${e}`);
+            this.db.failSyncActionByUid(accountId, "send", queueUid, e);
             emitEvent({ type: "sendError", accountId, error: e });
-            throw new Error(e);
+            return;
         }
-        // Fire async — same pattern as Gmail path above.
         this.sendViaSmtpDirect(accountId, account, rawMessage)
             .then((result) => {
             console.log(`[send] ${accountId}: sent via SMTP (${result.accepted.length} accepted, ${result.rejected.length} rejected)`);
+            this.db.completeSyncActionByUid(accountId, "send", queueUid);
             emitEvent({ type: "sendComplete", accountId });
         })
             .catch((e) => {
             console.error(`[send] ${accountId}: SMTP send failed: ${e.message}`);
+            this.db.failSyncActionByUid(accountId, "send", queueUid, e.message || String(e));
             emitEvent({ type: "sendError", accountId, error: e.message });
         });
     }
+    /** Drain any stranded 'send' queue entries — called at startup and on
+     *  each periodic sync tick so messages queued while offline or stranded
+     *  by a crash get a retry. Each row keeps its queueUid as tracking key. */
+    async processSendQueue(accountId) {
+        const pending = this.db.getPendingSyncActions(accountId).filter(a => a.action === "send" && a.rawMessage);
+        if (pending.length === 0)
+            return;
+        console.log(`[send] ${accountId}: draining ${pending.length} queued message(s)`);
+        for (const p of pending) {
+            this.attemptSend(accountId, p.uid, p.rawMessage);
+        }
+    }
     /** Build SMTP config from account, send via smtp-direct over BridgeTransport. */
     async sendViaSmtpDirect(accountId, account, raw) {
         const SMTP_PORT_STARTTLS = 587;
@@ -870,6 +898,15 @@ export async function initAndroid() {
         }
     }
     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}`));
+    }
     setTimeout(() => {
         syncManager.syncAll().catch(e => console.error(`[android] Sync error: ${e.message}`));
     }, 1000);
@@ -878,6 +915,11 @@ export async function initAndroid() {
     setInterval(() => {
         console.log("[sync] periodic poll");
         vlog("periodic sync poll");
+        // Retry any failed/stranded sends every poll tick
+        for (const account of db.getAccounts()) {
+            syncManager.processSendQueue(account.id)
+                .catch(e => console.error(`[android] retry ${account.id}: ${e.message}`));
+        }
         syncManager.syncAll().catch(e => console.error(`[android] Periodic sync error: ${e.message}`));
     }, SYNC_INTERVAL_MS);
     // Immediate sync when app comes back to foreground (e.g. user switches from
@@ -941,6 +983,25 @@ function installBridge() {
         syncAll: async () => { await service.syncAll(); return { ok: true }; },
         syncAccount: async (accountId) => { await service.syncAccount(accountId); return { ok: true }; },
         getSyncPending: () => service.getSyncPending(),
+        getPrimaryAccount: (feature) => {
+            // Resolve primary account for a feature (calendar/tasks/contacts):
+            // per-feature flag → catch-all `primary` → first account.
+            const all = db.getAccountConfigs().map(r => {
+                try {
+                    return { id: r.id, name: r.name, email: r.email, ...JSON.parse(r.configJson) };
+                }
+                catch {
+                    return { id: r.id, name: r.name, email: r.email };
+                }
+            });
+            if (feature) {
+                const key = "primary" + feature.charAt(0).toUpperCase() + feature.slice(1);
+                const perFeature = all.find((a) => a[key]);
+                if (perFeature)
+                    return perFeature;
+            }
+            return all.find((a) => a.primary) || all[0] || null;
+        },
         reauthenticate: async (accountId) => ({ ok: await service.reauthenticate(accountId) }),
         markFolderRead: (_accountId, folderId) => { service.markFolderRead(folderId); return { ok: true }; },
         createFolder: async () => ({ ok: false, error: "Not supported on mobile" }),

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

@@ -103,6 +103,12 @@ export declare class WebMailxDB {
     getPendingSyncActions(accountId: string): any[];
     completeSyncAction(id: number): void;
     failSyncAction(id: number, error: string): void;
+    /** Delete a queued sync action by (accountId, action, uid) — used by the
+     *  send path which tracks queued sends via a unique negative uid rather
+     *  than threading the row id through the async send pipeline. */
+    completeSyncActionByUid(accountId: string, action: string, uid: number): void;
+    /** Mark a send-queue action failed by uid — same tracking-key rationale. */
+    failSyncActionByUid(accountId: string, action: string, uid: number, error: string): void;
     getPendingSyncCount(accountId: string): number;
     getTotalPendingSyncCount(): number;
     /** Reset the entire database */

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

@@ -478,6 +478,16 @@ export class WebMailxDB {
     failSyncAction(id, error) {
         this.run("UPDATE sync_actions SET attempts = attempts + 1, last_error = ? WHERE id = ?", [error, id]);
     }
+    /** Delete a queued sync action by (accountId, action, uid) — used by the
+     *  send path which tracks queued sends via a unique negative uid rather
+     *  than threading the row id through the async send pipeline. */
+    completeSyncActionByUid(accountId, action, uid) {
+        this.run("DELETE FROM sync_actions WHERE account_id = ? AND action = ? AND uid = ?", [accountId, action, uid]);
+    }
+    /** Mark a send-queue action failed by uid — same tracking-key rationale. */
+    failSyncActionByUid(accountId, action, uid, error) {
+        this.run("UPDATE sync_actions SET attempts = attempts + 1, last_error = ? WHERE account_id = ? AND action = ? AND uid = ?", [error, accountId, action, uid]);
+    }
     getPendingSyncCount(accountId) {
         const r = this.get("SELECT COUNT(*) as cnt FROM sync_actions WHERE account_id = ?", [accountId]);
         return r?.cnt || 0;

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

@@ -29,7 +29,10 @@ export interface AccountConfig {
         password?: string;
     };
     enabled: boolean;
-    primary?: boolean; /** Designates the account that supplies Calendar / Tasks / Contacts data. At most one per user; first one wins if multiple set. */
+    primary?: boolean; /** Catch-all "this is my main account" — default source for Calendar / Tasks / Contacts when no per-feature override set. */
+    primaryCalendar?: boolean; /** Per-feature override: use this account's Google Calendar. Falls back to `primary` if unset. */
+    primaryTasks?: boolean; /** Per-feature override: use this account's Google Tasks. Falls back to `primary` if unset. */
+    primaryContacts?: boolean; /** Per-feature override: use this account's Google Contacts. Falls back to `primary` if unset. */
     defaultSend?: boolean; /** Use this account's SMTP when From doesn't match any account */
     syncContacts?: boolean; /** Sync contacts even when account is disabled (contacts-only Gmail) */
     relayDomains?: string[]; /** Domains to skip in Delivered-To chain (e.g., ["m.connectivity.xyz"]) */