@bobfrankston/mailx 1.0.441 → 1.0.443

package/client/app.js

@@ -696,9 +696,17 @@ async function openCompose(mode) {
     sessionStorage.setItem("composeInit", JSON.stringify(init));
     // Inline compose: load compose.html in an overlay iframe (same origin, same IPC)
     // Popup windows don't work in IPC mode (custom protocol doesn't propagate to child windows)
-    showComposeOverlay();
+    // Title reflects mode + subject so the user can see what they're replying to
+    // ("Re: Stars of STEM 2026" instead of just "Compose"). Forward shows the
+    // forward target subject; new compose stays generic.
+    const titlePrefix = mode === "reply" ? "Reply" :
+        mode === "replyAll" ? "Reply All" :
+            mode === "forward" ? "Forward" :
+                "Compose";
+    const titleSubject = mode === "new" ? "" : (msg?.subject || init.subject || "");
+    showComposeOverlay(titleSubject ? `${titlePrefix}: ${titleSubject}` : titlePrefix);
 }
-function showComposeOverlay() {
+function showComposeOverlay(title = "Compose") {
     const wrapper = document.createElement("div");
     wrapper.className = "compose-overlay";
     // Full-screen on small/short screens, floating on larger
@@ -712,7 +720,7 @@ function showComposeOverlay() {
     // Title bar — drag to move, close button
     const titleBar = document.createElement("div");
     titleBar.style.cssText = "display:flex;align-items:center;justify-content:space-between;padding:4px 8px;background:#e8ecf0;border-radius:8px 8px 0 0;cursor:move;user-select:none;flex-shrink:0;";
-    titleBar.textContent = "Compose";
+    titleBar.textContent = title;
     const closeBtn = document.createElement("button");
     closeBtn.textContent = "✕";
     closeBtn.title = "Save draft and close";
@@ -2051,11 +2059,21 @@ viewBtn?.addEventListener("click", (e) => {
     if (viewDropdown)
         viewDropdown.hidden = !viewDropdown.hidden;
 });
-document.addEventListener("click", () => {
-    if (viewDropdown)
+document.addEventListener("click", (e) => {
+    // Only close when the click is genuinely outside the menu container.
+    // The earlier unconditional close had two problems: clicks on radio
+    // buttons / checkboxes INSIDE the menu also closed it (so the user
+    // couldn't toggle anything without reopening), and any handler
+    // upstream that consumed the event (preventDefault paths, focus
+    // shifts) could keep the menu open inappropriately. The closest()
+    // check ensures inside-clicks pass through and outside-clicks close.
+    const target = e.target;
+    if (viewDropdown && !viewDropdown.hidden && !target?.closest("#view-menu") && !target?.closest("#view-dropdown")) {
         viewDropdown.hidden = true;
-    if (settingsDropdown)
+    }
+    if (settingsDropdown && !settingsDropdown.hidden && !target?.closest("#settings-menu") && !target?.closest("#settings-dropdown")) {
         settingsDropdown.hidden = true;
+    }
 });
 // Restore saved view settings
 const savedTwoLine = localStorage.getItem("mailx-two-line") === "true";
@@ -2225,7 +2243,7 @@ document.getElementById("btn-open-log")?.addEventListener("click", async () => {
     }
 });
 async function openJsoncEditor(initialFile) {
-    const { readJsoncFile, writeJsoncFile, readConfigHelp, formatJsonc } = await import("./lib/api-client.js");
+    const { readJsoncFile, writeJsoncFile, readConfigHelp, formatJsonc, leanAccountsJsonc } = await import("./lib/api-client.js");
     const backdrop = document.createElement("div");
     backdrop.className = "mailx-modal-backdrop";
     const panel = document.createElement("div");
@@ -2261,6 +2279,7 @@ async function openJsoncEditor(initialFile) {
         <div class="mailx-modal-error" id="jsonc-error" hidden></div>
         <div class="mailx-modal-buttons">
             <button type="button" class="mailx-modal-btn" data-action="format" title="Reformat indentation while preserving comments and trailing commas">Format</button>
+            <button type="button" class="mailx-modal-btn" data-action="lean" title="accounts.jsonc only — strip default-valued fields (port, tls, auth, etc.) so the file stays compact. Comments are dropped (the lean output is regenerated from values, not the original text)">Lean</button>
             <span class="mailx-modal-spacer"></span>
             <button type="button" class="mailx-modal-btn" data-action="cancel">Cancel</button>
             <button type="button" class="mailx-modal-btn mailx-modal-btn-primary" data-action="save">Save</button>
@@ -2427,6 +2446,38 @@ async function openJsoncEditor(initialFile) {
                 }
                 return;
             }
+            if (action === "lean") {
+                // accounts.jsonc-only: strip defaulted fields and re-emit
+                // a compact form. User reviews it in the editor, then Save
+                // commits. Lean drops comments because the output is
+                // regenerated from canonical values, not the original text.
+                if (fileSelect.value !== "accounts.jsonc") {
+                    errorEl.textContent = "Lean is only available for accounts.jsonc.";
+                    errorEl.hidden = false;
+                    return;
+                }
+                btn.disabled = true;
+                const orig = btn.textContent;
+                btn.textContent = "Leaning…";
+                try {
+                    const r = await leanAccountsJsonc(textarea.value);
+                    if (r?.content !== undefined) {
+                        textarea.value = r.content;
+                        renderGutter();
+                        scheduleValidate();
+                        errorEl.hidden = true;
+                    }
+                }
+                catch (e) {
+                    errorEl.textContent = `Lean failed: ${e.message}`;
+                    errorEl.hidden = false;
+                }
+                finally {
+                    btn.disabled = false;
+                    btn.textContent = orig || "Lean";
+                }
+                return;
+            }
             if (action === "save") {
                 // Final sync-check; refuse to save if it doesn't parse
                 const err = validateJsonc(textarea.value);

package/client/compose/compose.js

@@ -92,10 +92,59 @@ catch { /* private-mode / SecurityError — default quill */ }
     }
     catch { /* non-fatal */ }
 })();
-await loadEditorAssets(editorType);
+// Whatever happens in editor init, surface failures to the mailx log.
+// Until this round the failures were swallowed silently — Quill CDN
+// timing out or createEditor throwing left the iframe with empty body
+// + dead buttons (because the rest of the script after the await never
+// ran). With logClientEvent here, the failure mode is visible in the
+// service log instead of "Reply just shows blank compose".
+let editor;
+try {
+    await loadEditorAssets(editorType);
+}
+catch (e) {
+    logClientEvent("compose-editor-assets-failed", { type: editorType, error: String(e?.message || e) });
+    throw e;
+}
 const container = document.getElementById("compose-editor");
 container.classList.add(editorType === "tiptap" ? "editor-tiptap" : "editor-quill");
-const editor = await createEditor(container, editorType);
+try {
+    editor = await createEditor(container, editorType);
+}
+catch (e) {
+    logClientEvent("compose-editor-create-failed", { type: editorType, error: String(e?.message || e) });
+    // Render a minimal contenteditable fallback so the user can still type
+    // SOMETHING. Without this, an editor failure leaves the compose form
+    // half-functional (To/Cc/Bcc work, body doesn't) and the user doesn't
+    // know why. The fallback is a plain div — no toolbar, no rich text.
+    container.innerHTML = `<div class="compose-fallback-editor" contenteditable="true" style="border:1px solid #c00;padding:8px;min-height:200px;background:#fff" data-fallback="true"></div>`;
+    const fallback = container.querySelector(".compose-fallback-editor");
+    editor = {
+        root: fallback,
+        setHtml: (html) => { fallback.innerHTML = html; },
+        getHtml: () => fallback.innerHTML,
+        getText: () => fallback.innerText,
+        focus: () => fallback.focus(),
+        setCursor: () => { },
+        getScrollContainer: () => fallback,
+        onContentChange: (handler) => { fallback.addEventListener("input", handler); },
+        onKeyDown: (handler) => { fallback.addEventListener("keydown", handler); },
+        insertTextAtCursor: (text) => {
+            const sel = window.getSelection();
+            if (sel && sel.rangeCount > 0) {
+                const range = sel.getRangeAt(0);
+                range.deleteContents();
+                range.insertNode(document.createTextNode(text));
+            }
+            else {
+                fallback.append(document.createTextNode(text));
+            }
+        },
+    };
+    // Surface the failure to the user in the status bar so they know
+    // why the toolbar is missing and the editor is plain.
+    setTimeout(() => showDraftStatus(`Editor failed to load (${editorType}). Plain-text fallback in use. Open log for details.`, true), 0);
+}
 // Ctrl+scroll / Ctrl+= / Ctrl+- / Ctrl+0 zoom for the compose editor body.
 // Persists per-session in localStorage so zoom survives window pop/close cycles.
 (() => {

package/client/lib/api-client.js

@@ -351,6 +351,9 @@ export function readConfigHelp(name) {
 export function unsubscribeOneClick(url) {
     return ipc().unsubscribeOneClick?.(url);
 }
+export function leanAccountsJsonc(content) {
+    return ipc().leanAccountsJsonc?.(content) ?? Promise.resolve({ content });
+}
 export function openInWord(editId, html) {
     return ipc().openInWord?.(editId, html) ?? Promise.resolve({ ok: false, path: "", opener: "none" });
 }

package/client/lib/mailxapi.js

@@ -134,6 +134,9 @@
         formatJsonc: function(content) {
             return callNode("formatJsonc", { content: content });
         },
+        leanAccountsJsonc: function(content) {
+            return callNode("leanAccountsJsonc", { content: content });
+        },
         readConfigHelp: function(name) {
             return callNode("readConfigHelp", { name: name });
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.441",
+  "version": "1.0.443",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -36,7 +36,7 @@
     "@bobfrankston/iflow-node": "^0.1.8",
     "@bobfrankston/miscinfo": "^1.0.10",
     "@bobfrankston/oauthsupport": "^1.0.25",
-    "@bobfrankston/msger": "^0.1.364",
+    "@bobfrankston/msger": "^0.1.366",
     "@bobfrankston/mailx-host": "^0.1.8",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
@@ -100,7 +100,7 @@
       "@bobfrankston/iflow-node": "^0.1.8",
       "@bobfrankston/miscinfo": "^1.0.10",
       "@bobfrankston/oauthsupport": "^1.0.25",
-      "@bobfrankston/msger": "^0.1.364",
+      "@bobfrankston/msger": "^0.1.366",
       "@bobfrankston/mailx-host": "^0.1.8",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",

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

@@ -316,6 +316,16 @@ export declare class MailxService {
      *  `config.jsonc` is the local per-machine config (not cloud-synced). */
     readJsoncFile(name: string): Promise<string | null>;
     formatJsonc(content: string): Promise<string>;
+    /** Strip default-valued fields from accounts.jsonc and return the lean
+     *  form. Called from the JSONC editor's "Lean" button so the user can
+     *  see the tidy version before saving. Round-trips through normalize→
+     *  denormalize so the canonicalization rules stay in one place
+     *  (mailx-settings). Drops port: 993, tls: true, auth: "password",
+     *  enabled: true, sig.html: false, etc. when they match the defaults
+     *  for the email's provider. Promotes a shared `name` to the file
+     *  level when every account has the same name. Only handles
+     *  accounts.jsonc — other JSONC files have hand-curated shapes. */
+    leanAccountsJsonc(content: string): Promise<string>;
     /** Return the help section for a named config file, extracted from docs/config-help.md.
      *  Matches a level-2 heading whose text equals the filename. Returns markdown. */
     readConfigHelp(name: string): Promise<string>;

package/packages/mailx-service/index.js

@@ -9,7 +9,7 @@ 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 { loadSettings, saveSettings, loadAccounts, loadAccountsAsync, saveAccounts, initCloudConfig, loadAllowlist, saveAllowlist, loadAutocomplete, saveAutocomplete, getStorageInfo, getConfigDir, normalizeAccount, denormalizeAccount } from "@bobfrankston/mailx-settings";
 import { sanitizeHtml, encodeQuotedPrintable, htmlToPlainText } from "@bobfrankston/mailx-types";
 import { simpleParser } from "mailparser";
 /** Parse `List-Unsubscribe` (RFC 2369) and `List-Unsubscribe-Post` (RFC 8058).
@@ -559,11 +559,23 @@ export class MailxService {
         // in PATH) fall back to the OS default handler so the user still gets
         // *some* editor. Report which one ran so the UI can say "Opening in
         // Word…" vs "Opening in default editor…".
-        const { spawnSync, spawn } = await import("node:child_process");
+        //
+        // CRITICAL: must use async spawn (not spawnSync). spawnSync blocks
+        // the Node event loop until the spawned process exits — and on
+        // Windows, `cmd /c start ... <gui-app>` sometimes does not return
+        // immediately when the GUI app hangs around. That froze the entire
+        // mailx IPC bridge on Edit-in-Word click; subsequent clicks
+        // (Discard, X, anything) hung waiting for a response that never
+        // came back. Async spawn launches and returns immediately;
+        // success/failure of the GUI launch is invisible from here, but
+        // the file is written and the watcher is armed regardless.
+        const { spawn } = await import("node:child_process");
         const tryLaunch = (cmd, args) => {
             try {
-                const r = spawnSync(cmd, args, { stdio: "ignore", windowsHide: true });
-                return r.status === 0 && !r.error;
+                const child = spawn(cmd, args, { detached: true, stdio: "ignore", windowsHide: true });
+                child.on("error", () => { });
+                child.unref();
+                return true;
             }
             catch {
                 return false;
@@ -2041,6 +2053,30 @@ export class MailxService {
         });
         return applyEdits(content, edits);
     }
+    /** Strip default-valued fields from accounts.jsonc and return the lean
+     *  form. Called from the JSONC editor's "Lean" button so the user can
+     *  see the tidy version before saving. Round-trips through normalize→
+     *  denormalize so the canonicalization rules stay in one place
+     *  (mailx-settings). Drops port: 993, tls: true, auth: "password",
+     *  enabled: true, sig.html: false, etc. when they match the defaults
+     *  for the email's provider. Promotes a shared `name` to the file
+     *  level when every account has the same name. Only handles
+     *  accounts.jsonc — other JSONC files have hand-curated shapes. */
+    async leanAccountsJsonc(content) {
+        const { parse: parseJsonc } = await import("jsonc-parser");
+        const errors = [];
+        const cfg = parseJsonc(content, errors, { allowTrailingComma: true });
+        if (errors.length)
+            throw new Error(`JSONC parse error: ${errors.map((e) => e.error).join(", ")}`);
+        const raw = cfg?.accounts || (Array.isArray(cfg) ? cfg : []);
+        const globalName = cfg?.name;
+        const normalized = raw.map((a) => normalizeAccount(a, globalName));
+        const names = new Set(normalized.map((a) => a.name).filter(Boolean));
+        const sharedName = names.size === 1 ? [...names][0] : globalName;
+        const lean = normalized.map((a) => denormalizeAccount(a, sharedName));
+        const payload = sharedName ? { name: sharedName, accounts: lean } : { accounts: lean };
+        return JSON.stringify(payload, null, 2);
+    }
     /** Return the help section for a named config file, extracted from docs/config-help.md.
      *  Matches a level-2 heading whose text equals the filename. Returns markdown. */
     async readConfigHelp(name) {

package/packages/mailx-service/jsonrpc.js

@@ -177,6 +177,8 @@ async function dispatchAction(svc, action, p) {
             return await svc.unsubscribeOneClick(p.url);
         case "openInWord":
             return await svc.openInWord(p.editId, p.html);
+        case "leanAccountsJsonc":
+            return { content: await svc.leanAccountsJsonc(p.content) };
         case "closeWordEdit":
             return await svc.closeWordEdit(p.editId);
         // Client-side tracing — lets webview / iframe code ship events to the

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

@@ -40,6 +40,10 @@ export declare function getStorageInfo(): {
     cloudPath?: string;
     cloudError?: string;
 };
+/** Fill in provider defaults for an account based on email domain.
+ *  Exported so mailx-service's leanAccountsJsonc helper can reuse the same
+ *  canonicalization rules that loadAccounts uses. */
+export declare function normalizeAccount(acct: any, globalName?: string): AccountConfig;
 declare const DEFAULT_PREFERENCES: {
     ui: {
         theme: "system" | "dark" | "light";
@@ -76,8 +80,27 @@ declare const DEFAULT_ALLOWLIST: {
 export declare function loadAccounts(): AccountConfig[];
 /** Load accounts with cloud API fallback (async — use when cloud settings may not be mounted) */
 export declare function loadAccountsAsync(): Promise<AccountConfig[]>;
+/** Strip default-valued fields from a normalized AccountConfig so the
+ *  serialized JSONC stays compact and human-editable. The previous version
+ *  was round-tripping every defaulted field (port: 993, tls: true, auth:
+ *  "password", enabled: true, etc.), which bloated a 10-line accounts.jsonc
+ *  to 60+ lines and embedded unnecessary "knowledge" about defaults.
+ *
+ *  Rules:
+ *  - Drop fields that match the provider default (host/port/tls/auth derived
+ *    from email domain via PROVIDERS).
+ *  - Drop `enabled: true` (default).
+ *  - Drop `name` if equal to the file-level `globalName`.
+ *  - Drop `imap.user` / `smtp.user` if they equal the email.
+ *  - Drop `sig.html: false` (default; only keep when user enabled HTML sigs).
+ *  - Keep field order: id → label → email → primary* → imap → smtp → defaultSend
+ *    → relayDomains → deliveredToPrefix → identityDomains → syncContacts → sig.
+ *    Curated for readability, not alphabetic. */
+export declare function denormalizeAccount(acct: AccountConfig, globalName?: string): any;
 /** Save account configs */
-/** Save accounts — merges with cloud copy by email (multi-client safe) */
+/** Save accounts — merges with cloud copy by email (multi-client safe).
+ *  Writes the lean form via denormalizeAccount so accounts.jsonc stays
+ *  compact and human-editable. */
 export declare function saveAccounts(accounts: AccountConfig[]): Promise<void>;
 /** Load preferences (shared + local overrides, with legacy fallback) */
 export declare function loadPreferences(): typeof DEFAULT_PREFERENCES;

package/packages/mailx-settings/index.js

@@ -339,8 +339,10 @@ const PROVIDERS = {
         smtp: { host: "smtp.mail.me.com", port: 587, tls: true, auth: "password" },
     },
 };
-/** Fill in provider defaults for an account based on email domain */
-function normalizeAccount(acct, globalName) {
+/** Fill in provider defaults for an account based on email domain.
+ *  Exported so mailx-service's leanAccountsJsonc helper can reuse the same
+ *  canonicalization rules that loadAccounts uses. */
+export function normalizeAccount(acct, globalName) {
     const email = acct.email || "";
     const localPart = email.split("@")[0]?.toLowerCase() || "";
     const domain = email.split("@")[1]?.toLowerCase() || "";
@@ -552,8 +554,100 @@ export async function loadAccountsAsync() {
     }
     return [];
 }
+/** Strip default-valued fields from a normalized AccountConfig so the
+ *  serialized JSONC stays compact and human-editable. The previous version
+ *  was round-tripping every defaulted field (port: 993, tls: true, auth:
+ *  "password", enabled: true, etc.), which bloated a 10-line accounts.jsonc
+ *  to 60+ lines and embedded unnecessary "knowledge" about defaults.
+ *
+ *  Rules:
+ *  - Drop fields that match the provider default (host/port/tls/auth derived
+ *    from email domain via PROVIDERS).
+ *  - Drop `enabled: true` (default).
+ *  - Drop `name` if equal to the file-level `globalName`.
+ *  - Drop `imap.user` / `smtp.user` if they equal the email.
+ *  - Drop `sig.html: false` (default; only keep when user enabled HTML sigs).
+ *  - Keep field order: id → label → email → primary* → imap → smtp → defaultSend
+ *    → relayDomains → deliveredToPrefix → identityDomains → syncContacts → sig.
+ *    Curated for readability, not alphabetic. */
+export function denormalizeAccount(acct, globalName) {
+    const domain = (acct.email || "").split("@")[1]?.toLowerCase() || "";
+    const provider = PROVIDERS[domain];
+    const out = {};
+    out.id = acct.id;
+    if (acct.label && acct.label !== provider?.label && acct.label !== acct.id)
+        out.label = acct.label;
+    out.email = acct.email;
+    if (acct.name && acct.name !== globalName)
+        out.name = acct.name;
+    if (acct.primary)
+        out.primary = true;
+    if (acct.primaryCalendar !== undefined)
+        out.primaryCalendar = acct.primaryCalendar;
+    if (acct.primaryTasks !== undefined)
+        out.primaryTasks = acct.primaryTasks;
+    if (acct.primaryContacts !== undefined)
+        out.primaryContacts = acct.primaryContacts;
+    // imap — keep only fields that differ from provider defaults.
+    const imapOut = {};
+    if (acct.imap?.host && acct.imap.host !== provider?.imap.host)
+        imapOut.host = acct.imap.host;
+    if (acct.imap?.user && acct.imap.user !== acct.email)
+        imapOut.user = acct.imap.user;
+    if (acct.imap?.password)
+        imapOut.password = acct.imap.password;
+    if (acct.imap?.port && acct.imap.port !== (provider?.imap.port ?? 993))
+        imapOut.port = acct.imap.port;
+    if (acct.imap?.tls !== undefined && acct.imap.tls !== (provider?.imap.tls ?? true))
+        imapOut.tls = acct.imap.tls;
+    if (acct.imap?.auth && acct.imap.auth !== (provider?.imap.auth ?? "password"))
+        imapOut.auth = acct.imap.auth;
+    if (Object.keys(imapOut).length > 0)
+        out.imap = imapOut;
+    // smtp — same treatment.
+    const smtpOut = {};
+    if (acct.smtp?.host && acct.smtp.host !== provider?.smtp.host)
+        smtpOut.host = acct.smtp.host;
+    if (acct.smtp?.user && acct.smtp.user !== acct.email && acct.smtp.user !== acct.imap?.user)
+        smtpOut.user = acct.smtp.user;
+    if (acct.smtp?.password)
+        smtpOut.password = acct.smtp.password;
+    if (acct.smtp?.port && acct.smtp.port !== (provider?.smtp.port ?? 587))
+        smtpOut.port = acct.smtp.port;
+    if (acct.smtp?.tls !== undefined && acct.smtp.tls !== (provider?.smtp.tls ?? true))
+        smtpOut.tls = acct.smtp.tls;
+    if (acct.smtp?.auth && acct.smtp.auth !== (provider?.smtp.auth ?? "password"))
+        smtpOut.auth = acct.smtp.auth;
+    if (Object.keys(smtpOut).length > 0)
+        out.smtp = smtpOut;
+    if (acct.defaultSend)
+        out.defaultSend = true;
+    if (acct.enabled === false)
+        out.enabled = false; // default true → omit
+    if (acct.relayDomains && acct.relayDomains.length > 0)
+        out.relayDomains = acct.relayDomains;
+    if (acct.deliveredToPrefix && acct.deliveredToPrefix.length > 0)
+        out.deliveredToPrefix = acct.deliveredToPrefix;
+    if (acct.identityDomains && acct.identityDomains.length > 0)
+        out.identityDomains = acct.identityDomains;
+    // syncContacts default: true for OAuth, false otherwise. Only emit when
+    // the user overrode the default.
+    const syncContactsDefault = provider?.imap.auth === "oauth2";
+    if (acct.syncContacts !== undefined && acct.syncContacts !== syncContactsDefault) {
+        out.syncContacts = acct.syncContacts;
+    }
+    if (acct.signature)
+        out.signature = acct.signature;
+    if (acct.sig?.text) {
+        // html: false is default; only keep the html flag when explicitly true.
+        out.sig = acct.sig.html ? { text: acct.sig.text, html: true } : { text: acct.sig.text };
+    }
+    return out;
+}
 /** Save account configs */
-/** Save accounts — merges with cloud copy by email (multi-client safe) */
+/** Save accounts — merges with cloud copy by email (multi-client safe).
+ *  Writes the lean form via denormalizeAccount so accounts.jsonc stays
+ *  compact and human-editable. */
 export async function saveAccounts(accounts) {
     // Merge with cloud: keep all accounts, deduplicate by normalized email
     try {
@@ -565,7 +659,9 @@ export async function saveAccounts(accounts) {
                 const seen = new Set(accounts.map(a => normalizeEmail(a.email)));
                 for (const ca of cloudAccts) {
                     if (ca.email && !seen.has(normalizeEmail(ca.email))) {
-                        accounts.push(ca);
+                        // Cloud entries are already lean — feed through
+                        // normalizeAccount to coerce to AccountConfig shape.
+                        accounts.push(normalizeAccount(ca));
                         seen.add(normalizeEmail(ca.email));
                     }
                 }
@@ -573,7 +669,14 @@ export async function saveAccounts(accounts) {
         }
     }
     catch { /* cloud read failed — save local version */ }
-    saveFile("accounts.jsonc", { accounts });
+    // Promote a shared "name" to file level when every account has the same
+    // name — keeps the JSONC tidy ({ "name": "Bob Frankston", "accounts": [...] }
+    // instead of repeating "name" on each entry).
+    const names = new Set(accounts.map(a => a.name).filter(Boolean));
+    const globalName = names.size === 1 ? [...names][0] : undefined;
+    const lean = accounts.map(a => denormalizeAccount(a, globalName));
+    const payload = globalName ? { name: globalName, accounts: lean } : { accounts: lean };
+    saveFile("accounts.jsonc", payload);
 }
 /** Load preferences (shared + local overrides, with legacy fallback) */
 export function loadPreferences() {