@bobfrankston/mailx 1.0.378 → 1.0.379

package/client/components/calendar-sidebar.js

@@ -10,68 +10,33 @@
  * Sidebar and the full-screen calendar modal (calendar.ts) read the SAME
  * underlying data — two views onto one source.
  *
- * Local-only events (LOCAL_STORE_KEY) are merged with Google events.
+ * All storage goes through the service-side two-way cache (calendar_events
+ * and tasks tables); this file does not use localStorage for data.
  */
-import { getPrimaryAccount } from "../lib/api-client.js";
-const LOCAL_STORE_KEY = "mailx-cal-events-v1";
-const TASK_STORE_KEY = "mailx-tasks-v1";
+import { getCalendarEvents, createCalendarEvent, getTasks, createTask, updateTask, } from "../lib/api-client.js";
 const SIDEBAR_PREF = "mailx-calendar-sidebar-on";
 let viewYear = new Date().getFullYear();
 let viewMonth = new Date().getMonth();
 let viewDay = new Date().getDate();
 let lastEvents = [];
-function loadLocalEvents() {
-    try {
-        const raw = localStorage.getItem(LOCAL_STORE_KEY);
-        if (!raw)
-            return [];
-        const arr = JSON.parse(raw);
-        return Array.isArray(arr) ? arr : [];
-    }
-    catch {
-        return [];
-    }
-}
-function loadTasks() {
-    try {
-        const raw = localStorage.getItem(TASK_STORE_KEY);
-        if (!raw)
-            return [];
-        const arr = JSON.parse(raw);
-        return Array.isArray(arr) ? arr : [];
-    }
-    catch {
-        return [];
-    }
-}
-function saveTasks(tasks) {
-    try {
-        localStorage.setItem(TASK_STORE_KEY, JSON.stringify(tasks));
-    }
-    catch { /* */ }
-}
-/** Fetch upcoming events from Google Calendar via the primary account's
- *  OAuth token. Returns merged Google + local events for the next 30 days
- *  starting at `from`. Quietly returns local-only on any error so the
- *  sidebar still works without network / without Google Calendar scope. */
+/** Fetch events from the local two-way cache; service returns local rows
+ *  immediately and kicks a background refresh from Google. Next render
+ *  (view-nav or user action) picks up the refreshed rows. No localStorage
+ *  — everything lives in the service-side DB so phone / desktop share
+ *  the same events. */
 async function fetchUpcoming(from) {
-    const local = loadLocalEvents();
-    let google = [];
-    try {
-        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
-            // implemented yet — this is the seam). For now: local-only.
-            // Wire-up: TODO — service.fetchGoogleCalendarEvents(accountId, from, days).
-            // Sidebar already renders correctly with the merged result.
-        }
-    }
-    catch { /* google unavailable, fall back to local */ }
     const horizon = from.getTime() + 30 * 86400_000;
-    return [...local, ...google]
-        .filter(e => e.start >= from.getTime() && e.start < horizon)
-        .sort((a, b) => a.start - b.start);
+    const rows = await getCalendarEvents(from.getTime(), horizon);
+    return rows.map((r) => ({
+        id: r.uuid,
+        title: r.title,
+        start: r.startMs,
+        end: r.endMs,
+        allDay: !!r.allDay,
+        location: r.location,
+        notes: r.notes,
+        source: r.providerId ? "google" : "local",
+    }));
 }
 function formatDayHeader(d, today, tomorrow) {
     const sameDay = (a, b) => a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
@@ -124,9 +89,9 @@ function renderEvents(events) {
     }
     body.innerHTML = html;
 }
-function renderTasks() {
+async function renderTasks() {
     const showDone = document.getElementById("cal-side-show-done")?.checked || false;
-    const tasks = loadTasks().filter(t => showDone || !t.completed);
+    const tasks = await getTasks(showDone);
     const host = document.getElementById("cal-side-tasks");
     if (!host)
         return;
@@ -136,23 +101,19 @@ function renderTasks() {
     }
     let html = "<div class='cal-side-task-head'>Title</div>";
     for (const t of tasks) {
-        html += `<div class="cal-side-task" data-id="${t.id}">
-            <input type="checkbox" ${t.completed ? "checked" : ""} class="cal-side-task-check">
-            <span class="cal-side-task-title${t.completed ? " done" : ""}">${escapeHtml(t.title)}</span>
+        const done = !!t.completedMs;
+        html += `<div class="cal-side-task" data-uuid="${t.uuid}">
+            <input type="checkbox" ${done ? "checked" : ""} class="cal-side-task-check">
+            <span class="cal-side-task-title${done ? " done" : ""}">${escapeHtml(t.title)}</span>
         </div>`;
     }
     host.innerHTML = html;
     host.querySelectorAll(".cal-side-task").forEach(row => {
-        const id = row.dataset.id;
-        row.querySelector(".cal-side-task-check")?.addEventListener("change", (e) => {
+        const uuid = row.dataset.uuid;
+        row.querySelector(".cal-side-task-check")?.addEventListener("change", async (e) => {
             const checked = e.target.checked;
-            const all = loadTasks();
-            const t = all.find(x => x.id === id);
-            if (t) {
-                t.completed = checked ? Date.now() : undefined;
-                saveTasks(all);
-                renderTasks();
-            }
+            await updateTask(uuid, { completedMs: checked ? Date.now() : null });
+            renderTasks();
         });
     });
 }
@@ -225,19 +186,19 @@ export function initCalendarSidebar() {
             alert("Couldn't parse that date.");
             return;
         }
-        const ev = {
-            id: `cal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-            title, start, end: start + (allDay ? 86400_000 : 3600_000),
-            allDay, source: "local",
-        };
-        const all = loadLocalEvents();
-        all.push(ev);
-        try {
-            localStorage.setItem(LOCAL_STORE_KEY, JSON.stringify(all));
-        }
-        catch { /* */ }
+        // Two-way cache: commit locally, service queues the push to Google.
+        await createCalendarEvent({
+            title, startMs: start, endMs: start + (allDay ? 86400_000 : 3600_000), allDay,
+        });
         await refresh();
     });
+    wireOnce("cal-side-new-task", async () => {
+        const title = prompt("Task title:");
+        if (!title)
+            return;
+        await createTask({ title });
+        renderTasks();
+    });
     const showDoneCb = document.getElementById("cal-side-show-done");
     if (showDoneCb && !showDoneCb.__wired) {
         showDoneCb.__wired = true;

package/client/index.html

@@ -170,7 +170,10 @@
             <div class="cal-side-empty">Loading…</div>
         </div>
         <footer class="cal-side-foot">
-            <label><input type="checkbox" id="cal-side-show-done"> Show completed Tasks</label>
+            <div class="cal-side-task-header-row">
+                <label><input type="checkbox" id="cal-side-show-done"> Show completed Tasks</label>
+                <button class="cal-side-new" id="cal-side-new-task" title="New task">＋ Task</button>
+            </div>
             <div class="cal-side-tasks" id="cal-side-tasks"></div>
         </footer>
     </aside>

package/client/lib/api-client.js

@@ -141,6 +141,35 @@ export function getDiagnostics() {
 export function getPrimaryAccount(feature) {
     return ipc().getPrimaryAccount?.(feature) ?? Promise.resolve(null);
 }
+// Calendar / Tasks: two-way cache. Reads return local-cached rows; writes
+// commit locally and queue a push to Google. Service layer handles drain.
+export function getCalendarEvents(fromMs, toMs) {
+    return ipc().getCalendarEvents?.(fromMs, toMs) ?? Promise.resolve([]);
+}
+export function createCalendarEvent(ev) {
+    return ipc().createCalendarEvent?.(ev);
+}
+export function updateCalendarEvent(uuid, patch) {
+    return ipc().updateCalendarEvent?.(uuid, patch);
+}
+export function deleteCalendarEvent(uuid) {
+    return ipc().deleteCalendarEvent?.(uuid);
+}
+export function getTasks(includeCompleted = false) {
+    return ipc().getTasks?.(includeCompleted) ?? Promise.resolve([]);
+}
+export function createTask(t) {
+    return ipc().createTask?.(t);
+}
+export function updateTask(uuid, patch) {
+    return ipc().updateTask?.(uuid, patch);
+}
+export function deleteTask(uuid) {
+    return ipc().deleteTask?.(uuid);
+}
+export function drainStoreSync() {
+    return ipc().drainStoreSync?.();
+}
 export function getOutboxStatus() {
     return ipc().getOutboxStatus();
 }

package/client/lib/mailxapi.js

@@ -109,6 +109,19 @@
         getThreadMessages: function(accountId, threadId) {
             return callNode("getThreadMessages", { accountId: accountId, threadId: threadId });
         },
+        // Calendar / Tasks two-way cache. Reads return local DB immediately;
+        // writes commit locally and queue a push-to-Google action.
+        getCalendarEvents: function(fromMs, toMs) {
+            return callNode("getCalendarEvents", { fromMs: fromMs, toMs: toMs });
+        },
+        createCalendarEvent: function(ev) { return callNode("createCalendarEvent", ev); },
+        updateCalendarEvent: function(uuid, patch) { return callNode("updateCalendarEvent", { uuid: uuid, patch: patch }); },
+        deleteCalendarEvent: function(uuid) { return callNode("deleteCalendarEvent", { uuid: uuid }); },
+        getTasks: function(includeCompleted) { return callNode("getTasks", { includeCompleted: !!includeCompleted }); },
+        createTask: function(t) { return callNode("createTask", t); },
+        updateTask: function(uuid, patch) { return callNode("updateTask", { uuid: uuid, patch: patch }); },
+        deleteTask: function(uuid) { return callNode("deleteTask", { uuid: uuid }); },
+        drainStoreSync: function() { return callNode("drainStoreSync"); },
         readJsoncFile: function(name) {
             return callNode("readJsoncFile", { name: name });
         },

package/client/styles/layout.css

@@ -44,15 +44,17 @@ body.calendar-sidebar-on {
 .main-area { grid-area: main; }
 .status-bar { grid-area: status; }
 
-/* Vertical icon rail (Dovecot/Thunderbird-style). Always visible on
-   wide+medium tiers; collapses on narrow (icons move into the hamburger
-   menu — TBD; for now hidden on narrow). */
+/* Vertical icon rail — Thunderbird Supernova style: dark background with
+   light icons so the rail reads as "chrome" and contrasts visibly against
+   the content area (whether the app's in light or dark theme). Always
+   visible on wide+medium tiers; hidden on narrow (icons fold into
+   hamburger — TBD). */
 .icon-rail {
     display: flex;
     flex-direction: column;
     justify-content: space-between;
-    background: var(--color-bg-alt, #f4f4f5);
-    border-right: 1px solid var(--color-border);
+    background: oklch(0.25 0.01 250);
+    border-right: 1px solid oklch(0.18 0.01 250);
     padding: 6px 0;
     overflow: hidden;
 }
@@ -71,16 +73,21 @@ body.calendar-sidebar-on {
     background: transparent;
     cursor: pointer;
     font-size: 16px;
-    color: var(--color-text);
+    color: oklch(0.88 0.01 250);
     border-left: 3px solid transparent;
-    transition: background 0.12s, border-color 0.12s;
+    transition: background 0.12s, border-color 0.12s, color 0.12s;
 }
 .rail-btn:hover:not([disabled]) {
-    background: var(--color-hover, rgba(0,0,0,0.06));
+    background: oklch(0.32 0.02 250);
+    color: oklch(0.96 0.01 250);
 }
 .rail-btn[data-active="true"] {
-    background: var(--color-hover, rgba(0,0,0,0.06));
-    border-left-color: var(--color-accent, #1a6dd4);
+    background: oklch(0.35 0.03 250);
+    color: oklch(0.98 0.01 250);
+    border-left-color: var(--color-accent, #4a9cff);
+}
+.rail-btn[disabled] {
+    color: oklch(0.55 0.01 250);
 }
 .rail-btn[disabled] {
     opacity: 0.35;

package/package.json

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

package/packages/mailx-imap/index.js

@@ -564,7 +564,11 @@ export class ImapManager extends EventEmitter {
                 const hasToken = fs.existsSync(path.join(tokenDir, "oauth-token.json"));
                 const TOKEN_FETCH_TIMEOUT_MS = hasToken ? 30_000 : 120_000;
                 const authPromise = authenticateOAuth(credPath, {
-                    scope: "https://mail.google.com/ https://www.googleapis.com/auth/contacts.readonly https://www.googleapis.com/auth/calendar https://www.googleapis.com/auth/drive",
+                    // Scope set covers two-way sync of all mailx-managed local
+                    // stores: mail (mail.google.com), contacts (full, not
+                    // readonly — we write edits back), calendar (full), tasks
+                    // (full), drive (for shared accounts.jsonc).
+                    scope: "https://mail.google.com/ https://www.googleapis.com/auth/contacts https://www.googleapis.com/auth/calendar https://www.googleapis.com/auth/tasks https://www.googleapis.com/auth/drive",
                     tokenDirectory: tokenDir,
                     credentialsKey: "installed",
                     loginHint: account.imap.user,

package/packages/mailx-service/google-sync.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Google Calendar / Tasks / People (Contacts) two-way sync helpers.
+ *
+ * Used by MailxService to push local edits to Google and pull server
+ * changes into the local cache. All functions take a `getToken` function
+ * and a fetch implementation so they stay platform-agnostic (Node uses
+ * global `fetch` on Node 18+; browsers use window.fetch).
+ *
+ * Error handling: throws on network / HTTP errors. Caller catches and
+ * either retries via the store_sync drainer or surfaces to the UI.
+ */
+type TokenProvider = () => Promise<string>;
+export interface GCalEvent {
+    id: string;
+    summary: string;
+    start: {
+        dateTime?: string;
+        date?: string;
+    };
+    end: {
+        dateTime?: string;
+        date?: string;
+    };
+    location?: string;
+    description?: string;
+    etag?: string;
+}
+export declare function listCalendarEvents(tokenProvider: TokenProvider, fromMs: number, toMs: number, calendarId?: string): Promise<GCalEvent[]>;
+export declare function createCalendarEvent(tokenProvider: TokenProvider, event: any, calendarId?: string): Promise<GCalEvent>;
+export declare function updateCalendarEvent(tokenProvider: TokenProvider, eventId: string, event: any, calendarId?: string): Promise<GCalEvent>;
+export declare function deleteCalendarEvent(tokenProvider: TokenProvider, eventId: string, calendarId?: string): Promise<void>;
+export interface GTask {
+    id: string;
+    title: string;
+    notes?: string;
+    due?: string;
+    completed?: string;
+    status?: "needsAction" | "completed";
+    etag?: string;
+}
+export declare function listTasks(tokenProvider: TokenProvider, listId?: string, showCompleted?: boolean): Promise<GTask[]>;
+export declare function createTask(tokenProvider: TokenProvider, task: any, listId?: string): Promise<GTask>;
+export declare function updateTask(tokenProvider: TokenProvider, taskId: string, task: any, listId?: string): Promise<GTask>;
+export declare function deleteTask(tokenProvider: TokenProvider, taskId: string, listId?: string): Promise<void>;
+export declare function createContact(tokenProvider: TokenProvider, person: any): Promise<any>;
+export declare function updateContact(tokenProvider: TokenProvider, resourceName: string, updatePersonFields: string, person: any): Promise<any>;
+export declare function deleteContact(tokenProvider: TokenProvider, resourceName: string): Promise<void>;
+export declare function calendarEventToLocal(ev: GCalEvent, accountId: string): {
+    providerId: string;
+    accountId: string;
+    title: string;
+    startMs: number;
+    endMs: number;
+    allDay: boolean;
+    location: string;
+    notes: string;
+    etag: string;
+};
+export declare function localToCalendarEvent(local: {
+    title: string;
+    startMs: number;
+    endMs: number;
+    allDay?: boolean;
+    location?: string;
+    notes?: string;
+}): any;
+export declare function taskToLocal(t: GTask, accountId: string): {
+    providerId: string;
+    accountId: string;
+    title: string;
+    notes: string;
+    dueMs: number | undefined;
+    completedMs: number | undefined;
+    etag: string;
+};
+export declare function localToTask(local: {
+    title: string;
+    notes?: string;
+    dueMs?: number;
+    completedMs?: number;
+}): any;
+export {};
+//# sourceMappingURL=google-sync.d.ts.map

package/packages/mailx-service/google-sync.js

@@ -0,0 +1,140 @@
+/**
+ * Google Calendar / Tasks / People (Contacts) two-way sync helpers.
+ *
+ * Used by MailxService to push local edits to Google and pull server
+ * changes into the local cache. All functions take a `getToken` function
+ * and a fetch implementation so they stay platform-agnostic (Node uses
+ * global `fetch` on Node 18+; browsers use window.fetch).
+ *
+ * Error handling: throws on network / HTTP errors. Caller catches and
+ * either retries via the store_sync drainer or surfaces to the UI.
+ */
+async function googleFetch(tokenProvider, url, init = {}) {
+    const token = await tokenProvider();
+    const headers = new Headers(init.headers || {});
+    headers.set("Authorization", `Bearer ${token}`);
+    if (init.body && !headers.has("Content-Type"))
+        headers.set("Content-Type", "application/json");
+    const res = await fetch(url, { ...init, headers });
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`Google API ${res.status} ${res.statusText}: ${body.slice(0, 300)}`);
+    }
+    return res;
+}
+export async function listCalendarEvents(tokenProvider, fromMs, toMs, calendarId = "primary") {
+    const from = new Date(fromMs).toISOString();
+    const to = new Date(toMs).toISOString();
+    const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events`
+        + `?timeMin=${encodeURIComponent(from)}&timeMax=${encodeURIComponent(to)}`
+        + `&singleEvents=true&orderBy=startTime&maxResults=250`;
+    const all = [];
+    let pageToken;
+    do {
+        const pagedUrl = pageToken ? `${url}&pageToken=${encodeURIComponent(pageToken)}` : url;
+        const res = await googleFetch(tokenProvider, pagedUrl);
+        const data = await res.json();
+        for (const ev of (data.items || []))
+            all.push(ev);
+        pageToken = data.nextPageToken;
+    } while (pageToken);
+    return all;
+}
+export async function createCalendarEvent(tokenProvider, event, calendarId = "primary") {
+    const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events`;
+    const res = await googleFetch(tokenProvider, url, { method: "POST", body: JSON.stringify(event) });
+    return res.json();
+}
+export async function updateCalendarEvent(tokenProvider, eventId, event, calendarId = "primary") {
+    const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`;
+    const res = await googleFetch(tokenProvider, url, { method: "PATCH", body: JSON.stringify(event) });
+    return res.json();
+}
+export async function deleteCalendarEvent(tokenProvider, eventId, calendarId = "primary") {
+    const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`;
+    await googleFetch(tokenProvider, url, { method: "DELETE" });
+}
+export async function listTasks(tokenProvider, listId = "@default", showCompleted = false) {
+    const url = `https://tasks.googleapis.com/tasks/v1/lists/${encodeURIComponent(listId)}/tasks`
+        + `?showCompleted=${showCompleted}&maxResults=100`;
+    const res = await googleFetch(tokenProvider, url);
+    const data = await res.json();
+    return data.items || [];
+}
+export async function createTask(tokenProvider, task, listId = "@default") {
+    const url = `https://tasks.googleapis.com/tasks/v1/lists/${encodeURIComponent(listId)}/tasks`;
+    const res = await googleFetch(tokenProvider, url, { method: "POST", body: JSON.stringify(task) });
+    return res.json();
+}
+export async function updateTask(tokenProvider, taskId, task, listId = "@default") {
+    const url = `https://tasks.googleapis.com/tasks/v1/lists/${encodeURIComponent(listId)}/tasks/${encodeURIComponent(taskId)}`;
+    const res = await googleFetch(tokenProvider, url, { method: "PATCH", body: JSON.stringify(task) });
+    return res.json();
+}
+export async function deleteTask(tokenProvider, taskId, listId = "@default") {
+    const url = `https://tasks.googleapis.com/tasks/v1/lists/${encodeURIComponent(listId)}/tasks/${encodeURIComponent(taskId)}`;
+    await googleFetch(tokenProvider, url, { method: "DELETE" });
+}
+// ── Contacts (People API) ──
+export async function createContact(tokenProvider, person) {
+    const url = `https://people.googleapis.com/v1/people:createContact`;
+    const res = await googleFetch(tokenProvider, url, { method: "POST", body: JSON.stringify(person) });
+    return res.json();
+}
+export async function updateContact(tokenProvider, resourceName, updatePersonFields, person) {
+    const url = `https://people.googleapis.com/v1/${resourceName}:updateContact`
+        + `?updatePersonFields=${encodeURIComponent(updatePersonFields)}`;
+    const res = await googleFetch(tokenProvider, url, { method: "PATCH", body: JSON.stringify(person) });
+    return res.json();
+}
+export async function deleteContact(tokenProvider, resourceName) {
+    const url = `https://people.googleapis.com/v1/${resourceName}:deleteContact`;
+    await googleFetch(tokenProvider, url, { method: "DELETE" });
+}
+// ── Conversion helpers ──
+export function calendarEventToLocal(ev, accountId) {
+    const allDay = !!ev.start.date && !ev.start.dateTime;
+    const startMs = allDay
+        ? Date.parse(ev.start.date)
+        : Date.parse(ev.start.dateTime);
+    const endMs = allDay
+        ? Date.parse(ev.end.date)
+        : Date.parse(ev.end.dateTime);
+    return {
+        providerId: ev.id, accountId,
+        title: ev.summary || "(no title)",
+        startMs, endMs, allDay,
+        location: ev.location || "", notes: ev.description || "",
+        etag: ev.etag || "",
+    };
+}
+export function localToCalendarEvent(local) {
+    const toIso = (ms) => new Date(ms).toISOString();
+    const toDate = (ms) => new Date(ms).toISOString().slice(0, 10);
+    return {
+        summary: local.title,
+        start: local.allDay ? { date: toDate(local.startMs) } : { dateTime: toIso(local.startMs) },
+        end: local.allDay ? { date: toDate(local.endMs) } : { dateTime: toIso(local.endMs) },
+        location: local.location || undefined,
+        description: local.notes || undefined,
+    };
+}
+export function taskToLocal(t, accountId) {
+    return {
+        providerId: t.id, accountId, title: t.title || "",
+        notes: t.notes || "",
+        dueMs: t.due ? Date.parse(t.due) : undefined,
+        completedMs: t.completed ? Date.parse(t.completed) : undefined,
+        etag: t.etag || "",
+    };
+}
+export function localToTask(local) {
+    return {
+        title: local.title,
+        notes: local.notes || undefined,
+        due: local.dueMs ? new Date(local.dueMs).toISOString() : undefined,
+        completed: local.completedMs ? new Date(local.completedMs).toISOString() : undefined,
+        status: local.completedMs ? "completed" : "needsAction",
+    };
+}
+//# sourceMappingURL=google-sync.js.map

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

@@ -47,6 +47,46 @@ export declare class MailxService {
      *  Called without `feature` it returns the catch-all primary — same
      *  semantics as the original single-flag version for back-compat. */
     getPrimaryAccount(feature?: string): any;
+    private primaryTokenProvider;
+    /** Return cal events visible in [fromMs..toMs), refreshing from Google
+     *  in the background if enough time has passed. Caller displays local
+     *  results immediately; events updated from Google emit an event. */
+    getCalendarEvents(fromMs: number, toMs: number): Promise<any[]>;
+    private refreshCalendarEvents;
+    createCalendarEventLocal(ev: {
+        title: string;
+        startMs: number;
+        endMs: number;
+        allDay?: boolean;
+        location?: string;
+        notes?: string;
+    }): Promise<string>;
+    updateCalendarEventLocal(uuid: string, patch: {
+        title?: string;
+        startMs?: number;
+        endMs?: number;
+        allDay?: boolean;
+        location?: string;
+        notes?: string;
+    }): Promise<void>;
+    deleteCalendarEventLocal(uuid: string): Promise<void>;
+    getTasks(includeCompleted?: boolean): Promise<any[]>;
+    private refreshTasks;
+    createTaskLocal(t: {
+        title: string;
+        notes?: string;
+        dueMs?: number;
+    }): Promise<string>;
+    updateTaskLocal(uuid: string, patch: {
+        title?: string;
+        notes?: string;
+        dueMs?: number;
+        completedMs?: number;
+    }): Promise<void>;
+    deleteTaskLocal(uuid: string): Promise<void>;
+    /** Drain the store_sync queue — calendar / tasks / contacts push-to-server.
+     *  Called on every local edit, and on a periodic tick from the outbox worker. */
+    drainStoreSync(): Promise<void>;
     /** List queued outgoing messages with parsed envelope headers so the UI
      *  can render a pink-row "pending" view before IMAP APPEND succeeds. */
     listQueuedOutgoing(): any[];
@@ -95,11 +135,13 @@ export declare class MailxService {
     addContact(name: string, email: string): boolean;
     /** Address-book listing — paginated, filterable. */
     listContacts(query: string, page?: number, pageSize?: number): any;
-    /** Upsert a contact from the address book UI (edit name). */
+    /** Upsert a contact from the address book UI (edit name). Two-way cache:
+     *  commits locally, queues a Google People push. */
     upsertContact(name: string, email: string): {
         ok: true;
     };
-    /** Delete a contact from the address book. */
+    /** Delete a contact from the address book. Also pushes the deletion to
+     *  Google People if the contact had a resourceName (i.e. was synced). */
     deleteContact(email: string): {
         ok: true;
     };

package/packages/mailx-service/index.js

@@ -8,6 +8,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+import * as gsync from "./google-sync.js";
 import { loadSettings, saveSettings, loadAccounts, loadAccountsAsync, saveAccounts, initCloudConfig, loadAllowlist, saveAllowlist, loadAutocomplete, saveAutocomplete, getStorageInfo, getConfigDir } from "@bobfrankston/mailx-settings";
 import { sanitizeHtml, encodeQuotedPrintable } from "@bobfrankston/mailx-types";
 import { simpleParser } from "mailparser";
@@ -445,6 +446,198 @@ export class MailxService {
         }
         return all.find((a) => a.primary) || all[0] || null;
     }
+    // ── Calendar / Tasks / Contacts: two-way cache (2026-04-23) ──
+    async primaryTokenProvider(feature) {
+        const acct = this.getPrimaryAccount(feature);
+        if (!acct)
+            throw new Error(`No primary account for ${feature}`);
+        return async () => {
+            const tok = await this.imapManager.getOAuthToken(acct.id);
+            if (!tok)
+                throw new Error(`No OAuth token for ${acct.id}`);
+            return tok;
+        };
+    }
+    /** Return cal events visible in [fromMs..toMs), refreshing from Google
+     *  in the background if enough time has passed. Caller displays local
+     *  results immediately; events updated from Google emit an event. */
+    async getCalendarEvents(fromMs, toMs) {
+        const acct = this.getPrimaryAccount("calendar");
+        if (!acct)
+            return [];
+        // Fire-and-forget refresh; don't block the read on it.
+        this.refreshCalendarEvents(acct.id, fromMs, toMs).catch(e => console.error(`[calendar] refresh failed: ${e.message}`));
+        return this.db.getCalendarEvents(acct.id, fromMs, toMs);
+    }
+    async refreshCalendarEvents(accountId, fromMs, toMs) {
+        const tp = await this.primaryTokenProvider("calendar");
+        const events = await gsync.listCalendarEvents(tp, fromMs, toMs);
+        for (const ev of events) {
+            const local = gsync.calendarEventToLocal(ev, accountId);
+            // Use provider_id as the uuid basis — existing local row with matching
+            // providerId stays; if we invent a new uuid every time we'd create
+            // duplicates on every poll. Look up by provider_id first.
+            const existing = this.db.getCalendarEvents(accountId, fromMs, toMs).find(e => e.providerId === ev.id);
+            this.db.upsertCalendarEvent({
+                uuid: existing?.uuid,
+                ...local,
+            });
+        }
+    }
+    async createCalendarEventLocal(ev) {
+        const acct = this.getPrimaryAccount("calendar");
+        if (!acct)
+            throw new Error("No primary calendar account");
+        const uuid = this.db.upsertCalendarEvent({
+            accountId: acct.id, ...ev, dirty: true,
+        });
+        this.db.enqueueStoreSync("calendar", "create", acct.id, uuid, ev);
+        this.drainStoreSync().catch(() => { });
+        return uuid;
+    }
+    async updateCalendarEventLocal(uuid, patch) {
+        // Merge with existing row before writing so partial patches don't
+        // null-out unspecified fields in upsert.
+        const existing = this.db.getCalendarEvents("", 0, Number.MAX_SAFE_INTEGER).find(e => e.uuid === uuid);
+        if (!existing)
+            throw new Error(`No calendar event ${uuid}`);
+        this.db.upsertCalendarEvent({
+            uuid, accountId: existing.accountId, providerId: existing.providerId,
+            calendarId: existing.calendarId, dirty: true,
+            title: patch.title ?? existing.title,
+            startMs: patch.startMs ?? existing.startMs,
+            endMs: patch.endMs ?? existing.endMs,
+            allDay: patch.allDay ?? existing.allDay,
+            location: patch.location ?? existing.location,
+            notes: patch.notes ?? existing.notes,
+        });
+        this.db.enqueueStoreSync("calendar", "update", existing.accountId, uuid, { providerId: existing.providerId, patch });
+        this.drainStoreSync().catch(() => { });
+    }
+    async deleteCalendarEventLocal(uuid) {
+        const ev = this.db.getCalendarEvents("", 0, Number.MAX_SAFE_INTEGER).find(e => e.uuid === uuid);
+        if (!ev)
+            return;
+        this.db.deleteCalendarEventLocal(uuid);
+        if (ev.providerId) {
+            this.db.enqueueStoreSync("calendar", "delete", ev.accountId, uuid, { providerId: ev.providerId });
+            this.drainStoreSync().catch(() => { });
+        }
+        else {
+            // Never made it to the server; just purge locally.
+            this.db.purgeCalendarEvent(uuid);
+        }
+    }
+    async getTasks(includeCompleted = false) {
+        const acct = this.getPrimaryAccount("tasks");
+        if (!acct)
+            return [];
+        this.refreshTasks(acct.id, includeCompleted).catch(e => console.error(`[tasks] refresh failed: ${e.message}`));
+        return this.db.getTasks(acct.id, includeCompleted);
+    }
+    async refreshTasks(accountId, includeCompleted) {
+        const tp = await this.primaryTokenProvider("tasks");
+        const tasks = await gsync.listTasks(tp, "@default", includeCompleted);
+        const existing = this.db.getTasks(accountId, true);
+        for (const t of tasks) {
+            const local = gsync.taskToLocal(t, accountId);
+            const prior = existing.find(e => e.providerId === t.id);
+            this.db.upsertTask({ uuid: prior?.uuid, ...local });
+        }
+    }
+    async createTaskLocal(t) {
+        const acct = this.getPrimaryAccount("tasks");
+        if (!acct)
+            throw new Error("No primary tasks account");
+        const uuid = this.db.upsertTask({ accountId: acct.id, ...t, dirty: true });
+        this.db.enqueueStoreSync("tasks", "create", acct.id, uuid, t);
+        this.drainStoreSync().catch(() => { });
+        return uuid;
+    }
+    async updateTaskLocal(uuid, patch) {
+        const existing = this.db.getTasks("", true).find(t => t.uuid === uuid);
+        if (!existing)
+            throw new Error(`No task ${uuid}`);
+        this.db.upsertTask({
+            uuid, accountId: existing.accountId, providerId: existing.providerId,
+            listId: existing.listId, dirty: true,
+            title: patch.title ?? existing.title,
+            notes: patch.notes ?? existing.notes,
+            dueMs: patch.dueMs ?? existing.dueMs,
+            completedMs: patch.completedMs ?? existing.completedMs,
+        });
+        this.db.enqueueStoreSync("tasks", "update", existing.accountId, uuid, { providerId: existing.providerId, patch });
+        this.drainStoreSync().catch(() => { });
+    }
+    async deleteTaskLocal(uuid) {
+        const task = this.db.getTasks("", true).find(t => t.uuid === uuid);
+        if (!task)
+            return;
+        this.db.deleteTaskLocal(uuid);
+        if (task.providerId) {
+            this.db.enqueueStoreSync("tasks", "delete", task.accountId, uuid, { providerId: task.providerId });
+            this.drainStoreSync().catch(() => { });
+        }
+        else {
+            this.db.purgeTask(uuid);
+        }
+    }
+    /** Drain the store_sync queue — calendar / tasks / contacts push-to-server.
+     *  Called on every local edit, and on a periodic tick from the outbox worker. */
+    async drainStoreSync() {
+        const queue = this.db.getStoreSyncQueue();
+        for (const entry of queue) {
+            try {
+                if (entry.kind === "calendar") {
+                    const tp = await this.primaryTokenProvider("calendar");
+                    if (entry.op === "create") {
+                        const created = await gsync.createCalendarEvent(tp, gsync.localToCalendarEvent(entry.payload));
+                        this.db.markCalendarEventClean(entry.targetUuid, created.id, created.etag || "");
+                    }
+                    else if (entry.op === "update") {
+                        const updated = await gsync.updateCalendarEvent(tp, entry.payload.providerId, gsync.localToCalendarEvent(entry.payload.patch));
+                        this.db.markCalendarEventClean(entry.targetUuid, updated.id, updated.etag || "");
+                    }
+                    else if (entry.op === "delete") {
+                        await gsync.deleteCalendarEvent(tp, entry.payload.providerId);
+                        this.db.purgeCalendarEvent(entry.targetUuid);
+                    }
+                }
+                else if (entry.kind === "tasks") {
+                    const tp = await this.primaryTokenProvider("tasks");
+                    if (entry.op === "create") {
+                        const created = await gsync.createTask(tp, gsync.localToTask(entry.payload));
+                        this.db.markTaskClean(entry.targetUuid, created.id, created.etag || "");
+                    }
+                    else if (entry.op === "update") {
+                        const updated = await gsync.updateTask(tp, entry.payload.providerId, gsync.localToTask(entry.payload.patch));
+                        this.db.markTaskClean(entry.targetUuid, updated.id, updated.etag || "");
+                    }
+                    else if (entry.op === "delete") {
+                        await gsync.deleteTask(tp, entry.payload.providerId);
+                        this.db.purgeTask(entry.targetUuid);
+                    }
+                }
+                else if (entry.kind === "contacts") {
+                    const tp = await this.primaryTokenProvider("contacts");
+                    if (entry.op === "create") {
+                        await gsync.createContact(tp, entry.payload);
+                    }
+                    else if (entry.op === "update") {
+                        await gsync.updateContact(tp, entry.payload.resourceName, entry.payload.updatePersonFields || "names,emailAddresses", entry.payload.person);
+                    }
+                    else if (entry.op === "delete") {
+                        await gsync.deleteContact(tp, entry.payload.resourceName);
+                    }
+                }
+                this.db.completeStoreSync(entry.id);
+            }
+            catch (e) {
+                console.error(`[store_sync] ${entry.kind}/${entry.op}/${entry.targetUuid} failed: ${e.message}`);
+                this.db.failStoreSync(entry.id, e.message || String(e));
+            }
+        }
+    }
     /** List queued outgoing messages with parsed envelope headers so the UI
      *  can render a pink-row "pending" view before IMAP APPEND succeeds. */
     listQueuedOutgoing() {
@@ -985,14 +1178,36 @@ export class MailxService {
     listContacts(query, page = 1, pageSize = 100) {
         return this.db.listContacts(query || "", page, pageSize);
     }
-    /** Upsert a contact from the address book UI (edit name). */
+    /** Upsert a contact from the address book UI (edit name). Two-way cache:
+     *  commits locally, queues a Google People push. */
     upsertContact(name, email) {
         this.db.upsertContact(name || "", email);
+        const acct = this.getPrimaryAccount("contacts");
+        if (acct) {
+            // Google People `createContact` — resourceName is assigned by the
+            // server and stored back as google_id once the drainer gets an ACK.
+            this.db.enqueueStoreSync("contacts", "create", acct.id, email, {
+                names: [{ givenName: name || "" }],
+                emailAddresses: [{ value: email }],
+            });
+            this.drainStoreSync().catch(() => { });
+        }
         return { ok: true };
     }
-    /** Delete a contact from the address book. */
+    /** Delete a contact from the address book. Also pushes the deletion to
+     *  Google People if the contact had a resourceName (i.e. was synced). */
     deleteContact(email) {
-        this.db.deleteContact(email);
+        const acct = this.getPrimaryAccount("contacts");
+        // Look up the resourceName before deleting so we can push to Google.
+        const contacts = this.db.listContacts("", 1, 10_000);
+        const contact = (contacts.items || []).find((c) => c.email === email);
+        this.db.deleteContactLocal(email);
+        if (acct && contact?.googleId) {
+            this.db.enqueueStoreSync("contacts", "delete", acct.id, email, {
+                resourceName: contact.googleId,
+            });
+            this.drainStoreSync().catch(() => { });
+        }
         return { ok: true };
     }
     /** Open a configured local path in the OS file explorer. Whitelisted to

package/packages/mailx-service/jsonrpc.js

@@ -98,6 +98,31 @@ async function dispatchAction(svc, action, p) {
             return svc.getDiagnostics();
         case "getPrimaryAccount":
             return svc.getPrimaryAccount(p?.feature);
+        // Calendar / Tasks: two-way cache. Reads return local immediately
+        // and kick a background refresh that emits updates when done.
+        case "getCalendarEvents":
+            return await svc.getCalendarEvents(p.fromMs, p.toMs);
+        case "createCalendarEvent":
+            return { uuid: await svc.createCalendarEventLocal(p) };
+        case "updateCalendarEvent":
+            await svc.updateCalendarEventLocal(p.uuid, p.patch);
+            return { ok: true };
+        case "deleteCalendarEvent":
+            await svc.deleteCalendarEventLocal(p.uuid);
+            return { ok: true };
+        case "getTasks":
+            return await svc.getTasks(!!p.includeCompleted);
+        case "createTask":
+            return { uuid: await svc.createTaskLocal(p) };
+        case "updateTask":
+            await svc.updateTaskLocal(p.uuid, p.patch);
+            return { ok: true };
+        case "deleteTask":
+            await svc.deleteTaskLocal(p.uuid);
+            return { ok: true };
+        case "drainStoreSync":
+            await svc.drainStoreSync();
+            return { ok: true };
         case "getOutboxStatus":
             return svc.getOutboxStatus();
         case "listQueuedOutgoing":

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

@@ -33,6 +33,50 @@ export declare class MailxDB {
      *  growing unboundedly. Default retention is 30 days; caller passes the
      *  actual cutoff in ms since epoch. */
     pruneTombstones(olderThanMs: number): number;
+    upsertCalendarEvent(ev: {
+        uuid?: string;
+        accountId: string;
+        providerId?: string;
+        calendarId?: string;
+        title: string;
+        startMs: number;
+        endMs: number;
+        allDay?: boolean;
+        location?: string;
+        notes?: string;
+        etag?: string;
+        dirty?: boolean;
+    }): string;
+    getCalendarEvents(accountId: string, fromMs: number, toMs: number): any[];
+    getDirtyCalendarEvents(accountId: string): any[];
+    private calendarRowToObject;
+    markCalendarEventClean(uuid: string, providerId: string, etag: string): void;
+    deleteCalendarEventLocal(uuid: string): void;
+    purgeCalendarEvent(uuid: string): void;
+    upsertTask(t: {
+        uuid?: string;
+        accountId: string;
+        providerId?: string;
+        listId?: string;
+        title: string;
+        notes?: string;
+        dueMs?: number;
+        completedMs?: number;
+        etag?: string;
+        dirty?: boolean;
+    }): string;
+    getTasks(accountId: string, includeCompleted?: boolean): any[];
+    getDirtyTasks(accountId: string): any[];
+    private taskRowToObject;
+    markTaskClean(uuid: string, providerId: string, etag: string): void;
+    deleteTaskLocal(uuid: string): void;
+    purgeTask(uuid: string): void;
+    /** Local delete for the two-way cache drainer (symmetric with calendar/tasks). */
+    deleteContactLocal(email: string): void;
+    enqueueStoreSync(kind: string, op: string, accountId: string, targetUuid: string, payload: any): void;
+    getStoreSyncQueue(kind?: string, accountId?: string): any[];
+    completeStoreSync(id: number): void;
+    failStoreSync(id: number, error: string): void;
     /** Idempotently add a column to a table if it's missing. */
     private addColumnIfMissing;
     /** Compute a thread id for an incoming message. Strategy:
@@ -142,6 +186,7 @@ export declare class MailxDB {
             name: string;
             email: string;
             source: string;
+            googleId: string | null;
             useCount: number;
             lastUsed: number;
         }[];

package/packages/mailx-store/db.js

@@ -142,6 +142,72 @@ const SCHEMA = `
         PRIMARY KEY (account_id, message_id)
     );
     CREATE INDEX IF NOT EXISTS idx_tombstones_deleted_at ON tombstones(deleted_at);
+
+    -- Calendar events: two-way cache of Google Calendar / local events.
+    -- uuid = local stable identity (survives provider_id rebinds).
+    -- provider_id = Google Calendar event id when known (null for local-only
+    -- events that haven't been pushed yet).
+    -- deleted = tombstone marker; drainer removes row from server then deletes
+    -- the row locally.
+    CREATE TABLE IF NOT EXISTS calendar_events (
+        uuid TEXT PRIMARY KEY,
+        account_id TEXT NOT NULL,
+        provider_id TEXT,
+        calendar_id TEXT DEFAULT 'primary',
+        title TEXT NOT NULL DEFAULT '',
+        start_ms INTEGER NOT NULL,
+        end_ms INTEGER NOT NULL,
+        all_day INTEGER DEFAULT 0,
+        location TEXT DEFAULT '',
+        notes TEXT DEFAULT '',
+        etag TEXT,
+        last_synced INTEGER DEFAULT 0,
+        dirty INTEGER DEFAULT 0,
+        deleted INTEGER DEFAULT 0,
+        updated_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_calendar_events_start ON calendar_events(account_id, start_ms);
+    CREATE INDEX IF NOT EXISTS idx_calendar_events_dirty ON calendar_events(dirty) WHERE dirty = 1;
+
+    -- Tasks: two-way cache of Google Tasks / local tasks. Same shape as
+    -- calendar_events minus the time range.
+    CREATE TABLE IF NOT EXISTS tasks (
+        uuid TEXT PRIMARY KEY,
+        account_id TEXT NOT NULL,
+        provider_id TEXT,
+        list_id TEXT DEFAULT '@default',
+        title TEXT NOT NULL DEFAULT '',
+        notes TEXT DEFAULT '',
+        due_ms INTEGER,
+        completed_ms INTEGER,
+        etag TEXT,
+        last_synced INTEGER DEFAULT 0,
+        dirty INTEGER DEFAULT 0,
+        deleted INTEGER DEFAULT 0,
+        updated_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_tasks_account ON tasks(account_id);
+    CREATE INDEX IF NOT EXISTS idx_tasks_dirty ON tasks(dirty) WHERE dirty = 1;
+
+    -- Generic store-sync queue for domains OTHER than messages. Messages
+    -- use sync_actions above. This table queues push-to-server actions
+    -- for calendar / tasks / contacts / allowlist. Kind identifies the
+    -- domain; op is "create" / "update" / "delete"; payload is JSON the
+    -- drainer posts to the provider. Target URL isn't stored — the
+    -- drainer knows the provider endpoint from kind + payload.
+    CREATE TABLE IF NOT EXISTS store_sync (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        kind TEXT NOT NULL,
+        op TEXT NOT NULL,
+        account_id TEXT NOT NULL,
+        target_uuid TEXT NOT NULL,
+        payload TEXT,
+        attempts INTEGER DEFAULT 0,
+        last_error TEXT,
+        created_at INTEGER NOT NULL,
+        UNIQUE(kind, target_uuid, op)
+    );
+    CREATE INDEX IF NOT EXISTS idx_store_sync_account ON store_sync(account_id, kind);
 `;
 export class MailxDB {
     db;
@@ -303,6 +369,152 @@ export class MailxDB {
             return 0;
         }
     }
+    // ── Calendar events (two-way cache) ──
+    upsertCalendarEvent(ev) {
+        const uuid = ev.uuid || randomUUID().replace(/-/g, "");
+        this.db.prepare(`
+            INSERT INTO calendar_events
+                (uuid, account_id, provider_id, calendar_id, title, start_ms, end_ms,
+                 all_day, location, notes, etag, last_synced, dirty, deleted, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?)
+            ON CONFLICT(uuid) DO UPDATE SET
+                account_id=excluded.account_id, provider_id=excluded.provider_id,
+                calendar_id=excluded.calendar_id, title=excluded.title,
+                start_ms=excluded.start_ms, end_ms=excluded.end_ms,
+                all_day=excluded.all_day, location=excluded.location,
+                notes=excluded.notes, etag=excluded.etag,
+                last_synced=excluded.last_synced, dirty=excluded.dirty,
+                updated_at=excluded.updated_at
+        `).run(uuid, ev.accountId, ev.providerId || null, ev.calendarId || "primary", ev.title, ev.startMs, ev.endMs, ev.allDay ? 1 : 0, ev.location || "", ev.notes || "", ev.etag || null, ev.dirty ? 0 : Date.now(), ev.dirty ? 1 : 0, Date.now());
+        return uuid;
+    }
+    getCalendarEvents(accountId, fromMs, toMs) {
+        const rows = this.db.prepare(`
+            SELECT * FROM calendar_events
+            WHERE account_id = ? AND deleted = 0 AND start_ms >= ? AND start_ms < ?
+            ORDER BY start_ms ASC
+        `).all(accountId, fromMs, toMs);
+        return rows.map(this.calendarRowToObject);
+    }
+    getDirtyCalendarEvents(accountId) {
+        const rows = this.db.prepare(`
+            SELECT * FROM calendar_events WHERE account_id = ? AND (dirty = 1 OR deleted = 1)
+        `).all(accountId);
+        return rows.map(this.calendarRowToObject);
+    }
+    calendarRowToObject(r) {
+        return {
+            uuid: r.uuid, accountId: r.account_id, providerId: r.provider_id,
+            calendarId: r.calendar_id, title: r.title, startMs: r.start_ms,
+            endMs: r.end_ms, allDay: !!r.all_day, location: r.location, notes: r.notes,
+            etag: r.etag, lastSynced: r.last_synced, dirty: !!r.dirty, deleted: !!r.deleted,
+        };
+    }
+    markCalendarEventClean(uuid, providerId, etag) {
+        this.db.prepare(`
+            UPDATE calendar_events SET dirty=0, provider_id=?, etag=?, last_synced=? WHERE uuid=?
+        `).run(providerId, etag, Date.now(), uuid);
+    }
+    deleteCalendarEventLocal(uuid) {
+        this.db.prepare("UPDATE calendar_events SET deleted=1, dirty=1, updated_at=? WHERE uuid=?").run(Date.now(), uuid);
+    }
+    purgeCalendarEvent(uuid) {
+        this.db.prepare("DELETE FROM calendar_events WHERE uuid=?").run(uuid);
+    }
+    // ── Tasks (two-way cache) ──
+    upsertTask(t) {
+        const uuid = t.uuid || randomUUID().replace(/-/g, "");
+        this.db.prepare(`
+            INSERT INTO tasks
+                (uuid, account_id, provider_id, list_id, title, notes, due_ms, completed_ms,
+                 etag, last_synced, dirty, deleted, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?)
+            ON CONFLICT(uuid) DO UPDATE SET
+                account_id=excluded.account_id, provider_id=excluded.provider_id,
+                list_id=excluded.list_id, title=excluded.title, notes=excluded.notes,
+                due_ms=excluded.due_ms, completed_ms=excluded.completed_ms,
+                etag=excluded.etag, last_synced=excluded.last_synced,
+                dirty=excluded.dirty, updated_at=excluded.updated_at
+        `).run(uuid, t.accountId, t.providerId || null, t.listId || "@default", t.title, t.notes || "", t.dueMs || null, t.completedMs || null, t.etag || null, t.dirty ? 0 : Date.now(), t.dirty ? 1 : 0, Date.now());
+        return uuid;
+    }
+    getTasks(accountId, includeCompleted = false) {
+        const where = includeCompleted
+            ? "account_id = ? AND deleted = 0"
+            : "account_id = ? AND deleted = 0 AND completed_ms IS NULL";
+        const rows = this.db.prepare(`SELECT * FROM tasks WHERE ${where} ORDER BY COALESCE(due_ms, updated_at) ASC`).all(accountId);
+        return rows.map(this.taskRowToObject);
+    }
+    getDirtyTasks(accountId) {
+        const rows = this.db.prepare(`SELECT * FROM tasks WHERE account_id = ? AND (dirty = 1 OR deleted = 1)`).all(accountId);
+        return rows.map(this.taskRowToObject);
+    }
+    taskRowToObject(r) {
+        return {
+            uuid: r.uuid, accountId: r.account_id, providerId: r.provider_id,
+            listId: r.list_id, title: r.title, notes: r.notes, dueMs: r.due_ms,
+            completedMs: r.completed_ms, etag: r.etag, lastSynced: r.last_synced,
+            dirty: !!r.dirty, deleted: !!r.deleted,
+        };
+    }
+    markTaskClean(uuid, providerId, etag) {
+        this.db.prepare(`UPDATE tasks SET dirty=0, provider_id=?, etag=?, last_synced=? WHERE uuid=?`)
+            .run(providerId, etag, Date.now(), uuid);
+    }
+    deleteTaskLocal(uuid) {
+        this.db.prepare("UPDATE tasks SET deleted=1, dirty=1, updated_at=? WHERE uuid=?").run(Date.now(), uuid);
+    }
+    purgeTask(uuid) {
+        this.db.prepare("DELETE FROM tasks WHERE uuid=?").run(uuid);
+    }
+    // ── Contacts two-way: existing upsertContact / deleteContact handle the
+    //     local side; the service layer adds store_sync push-queue entries.
+    //     (No extra methods needed here — upsertContact/deleteContact at the
+    //     regular contact-management section are the two-way cache's local
+    //     writers.)
+    /** Local delete for the two-way cache drainer (symmetric with calendar/tasks). */
+    deleteContactLocal(email) { this.deleteContact(email); }
+    // ── Store-sync queue (calendar / tasks / contacts / allowlist) ──
+    enqueueStoreSync(kind, op, accountId, targetUuid, payload) {
+        try {
+            this.db.prepare(`
+                INSERT OR REPLACE INTO store_sync (kind, op, account_id, target_uuid, payload, created_at)
+                VALUES (?, ?, ?, ?, ?, ?)
+            `).run(kind, op, accountId, targetUuid, JSON.stringify(payload), Date.now());
+        }
+        catch (e) {
+            console.error(`  [store_sync] enqueue ${kind}/${op}/${targetUuid} failed: ${e.message}`);
+        }
+    }
+    getStoreSyncQueue(kind, accountId) {
+        let sql = "SELECT * FROM store_sync";
+        const params = [];
+        const wh = [];
+        if (kind) {
+            wh.push("kind = ?");
+            params.push(kind);
+        }
+        if (accountId) {
+            wh.push("account_id = ?");
+            params.push(accountId);
+        }
+        if (wh.length)
+            sql += " WHERE " + wh.join(" AND ");
+        sql += " ORDER BY created_at ASC";
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(r => ({
+            id: r.id, kind: r.kind, op: r.op, accountId: r.account_id,
+            targetUuid: r.target_uuid,
+            payload: r.payload ? JSON.parse(r.payload) : null,
+            attempts: r.attempts, lastError: r.last_error,
+        }));
+    }
+    completeStoreSync(id) {
+        this.db.prepare("DELETE FROM store_sync WHERE id = ?").run(id);
+    }
+    failStoreSync(id, error) {
+        this.db.prepare("UPDATE store_sync SET attempts = attempts + 1, last_error = ? WHERE id = ?").run(error, id);
+    }
     /** Idempotently add a column to a table if it's missing. */
     addColumnIfMissing(table, column, sqlType) {
         try {
@@ -800,12 +1012,16 @@ export class MailxDB {
         const params = hasQuery ? [q, q] : [];
         const totalRow = this.db.prepare(`SELECT COUNT(*) as c FROM contacts ${whereClause}`).get(...params);
         const offset = (page - 1) * pageSize;
-        const rows = this.db.prepare(`SELECT name, email, source, use_count, last_used FROM contacts
+        const rows = this.db.prepare(`SELECT name, email, source, google_id, use_count, last_used FROM contacts
              ${whereClause}
              ORDER BY use_count DESC, last_used DESC
              LIMIT ? OFFSET ?`).all(...params, pageSize, offset);
         return {
-            items: rows.map(r => ({ name: r.name, email: r.email, source: r.source, useCount: r.use_count, lastUsed: r.last_used })),
+            items: rows.map(r => ({
+                name: r.name, email: r.email, source: r.source,
+                googleId: r.google_id || null,
+                useCount: r.use_count, lastUsed: r.last_used,
+            })),
             total: totalRow?.c || 0,
             page, pageSize,
         };