@bobfrankston/mailx 1.0.378 → 1.0.382

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.getCalendarEventByUuid(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.getCalendarEventByUuid(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.getTaskByUuid(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.getTaskByUuid(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,54 @@ 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[];
+    /** Lookup by uuid only — used by patch/delete paths that don't have an
+     *  accountId context. Returns the row even when it's soft-deleted. */
+    getCalendarEventByUuid(uuid: string): any | null;
+    getTaskByUuid(uuid: string): any | null;
+    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 +190,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,162 @@ 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);
+    }
+    /** Lookup by uuid only — used by patch/delete paths that don't have an
+     *  accountId context. Returns the row even when it's soft-deleted. */
+    getCalendarEventByUuid(uuid) {
+        const r = this.db.prepare("SELECT * FROM calendar_events WHERE uuid = ?").get(uuid);
+        return r ? this.calendarRowToObject(r) : null;
+    }
+    getTaskByUuid(uuid) {
+        const r = this.db.prepare("SELECT * FROM tasks WHERE uuid = ?").get(uuid);
+        return r ? this.taskRowToObject(r) : null;
+    }
+    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 {
@@ -785,11 +1007,34 @@ export class MailxDB {
     }
     /** Search contacts by name or email prefix */
     searchContacts(query, limit = 10) {
-        const q = `%${query}%`;
-        const rows = this.db.prepare(`SELECT name, email, source, use_count FROM contacts
+        // Two-pass ranking so autocomplete feels responsive: rows whose name or
+        // local-part starts with the query rank first (exact prefix match is
+        // usually what the user wants), then substring matches fill out the
+        // rest. Within each tier, sort by (recency-weighted use_count) so a
+        // contact the user messaged today beats one from two years ago even
+        // if the older one has more total sends. Recency bonus: +1 per send
+        // decayed by ~half every 30 days.
+        const prefixQ = `${query}%`;
+        const substr = `%${query}%`;
+        const rows = this.db.prepare(`SELECT name, email, source, use_count, last_used,
+                    (CASE
+                        WHEN lower(name) LIKE lower(?) THEN 3
+                        WHEN substr(email, 1, instr(email, '@') - 1) LIKE lower(?) THEN 2
+                        WHEN email LIKE ? OR name LIKE ? THEN 1
+                        ELSE 0
+                     END) AS match_rank
+             FROM contacts
              WHERE email LIKE ? OR name LIKE ?
-             ORDER BY use_count DESC, last_used DESC
-             LIMIT ?`).all(q, q, limit);
+             ORDER BY match_rank DESC, use_count DESC, last_used DESC
+             LIMIT ?`).all(prefixQ, prefixQ, substr, substr, substr, substr, limit);
+        // Recency-weighted rescore, best-in-JS since SQLite lacks log/exp
+        // natively. 30-day half-life — close enough to "recent contacts
+        // float up" without being fussy about the exact decay curve.
+        const now = Date.now();
+        const HALF_LIFE_MS = 30 * 86400_000;
+        const score = (r) => r.match_rank * 10_000
+            + (r.use_count || 0) * Math.pow(0.5, Math.max(0, now - (r.last_used || 0)) / HALF_LIFE_MS);
+        rows.sort((a, b) => score(b) - score(a));
         return rows.map(r => ({ name: r.name, email: r.email, source: r.source, useCount: r.use_count }));
     }
     /** List all contacts (address-book view) with pagination + optional filter. */
@@ -800,12 +1045,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,
         };