@bobfrankston/mailx 1.0.306 → 1.0.313

package/packages/mailx-service/index.js

@@ -6,9 +6,46 @@
 import * as dns from "node:dns/promises";
 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 { loadSettings, saveSettings, loadAccounts, loadAccountsAsync, saveAccounts, initCloudConfig, loadAllowlist, saveAllowlist, loadAutocomplete, saveAutocomplete, getStorePath, getStorageInfo, getConfigDir } from "@bobfrankston/mailx-settings";
 import { sanitizeHtml, encodeQuotedPrintable } from "@bobfrankston/mailx-types";
 import { simpleParser } from "mailparser";
+/** Parse `List-Unsubscribe` (RFC 2369) and `List-Unsubscribe-Post` (RFC 8058).
+ *  mailparser only exposes ONE of mail/url even when both are present, so we
+ *  also scan the raw header text for the full set of angle-bracketed URIs. */
+function parseListUnsubscribe(headers) {
+    let mail = "";
+    let http = "";
+    let oneClick = false;
+    const raw = headers.get("list-unsubscribe");
+    const rawStr = typeof raw === "string" ? raw : (raw && typeof raw.text === "string" ? raw.text : "");
+    if (rawStr) {
+        const matches = rawStr.match(/<([^>]+)>/g) || [];
+        for (const m of matches) {
+            const url = m.slice(1, -1).trim();
+            if (!mail && /^mailto:/i.test(url))
+                mail = url;
+            else if (!http && /^https?:/i.test(url))
+                http = url;
+        }
+    }
+    if (!mail && !http) {
+        const listHeaders = headers.get("list");
+        if (listHeaders?.unsubscribe) {
+            const unsub = listHeaders.unsubscribe;
+            if (unsub.url)
+                http = Array.isArray(unsub.url) ? unsub.url[0] : unsub.url;
+            if (unsub.mail)
+                mail = `mailto:${Array.isArray(unsub.mail) ? unsub.mail[0] : unsub.mail}`;
+        }
+    }
+    const post = headers.get("list-unsubscribe-post");
+    const postStr = typeof post === "string" ? post : (post && typeof post.text === "string" ? post.text : "");
+    if (postStr && /one-?click/i.test(postStr))
+        oneClick = true;
+    return { listUnsubscribeMail: mail, listUnsubscribeHttp: http, listUnsubscribeOneClick: oneClick };
+}
 // ── Email provider detection (MX-based) ──
 const GOOGLE_DOMAINS = ["gmail.com", "googlemail.com"];
 const MS_DOMAINS = ["outlook.com", "hotmail.com", "live.com"];
@@ -161,6 +198,9 @@ export class MailxService {
         let deliveredTo = "";
         let returnPath = "";
         let listUnsubscribe = "";
+        let listUnsubscribeMail = "";
+        let listUnsubscribeHttp = "";
+        let listUnsubscribeOneClick = false;
         if (raw) {
             const parsed2 = await simpleParser(raw);
             const hdr = (key) => {
@@ -211,19 +251,32 @@ export class MailxService {
                 }
             }
             returnPath = hdr("return-path").replace(/[<>]/g, "");
-            const listHeaders = parsed2.headers.get("list");
-            if (listHeaders?.unsubscribe) {
-                const unsub = listHeaders.unsubscribe;
-                listUnsubscribe = unsub.url || (unsub.mail ? `mailto:${unsub.mail}` : "");
-            }
+            ({ listUnsubscribeMail, listUnsubscribeHttp, listUnsubscribeOneClick } =
+                parseListUnsubscribe(parsed2.headers));
+            listUnsubscribe = listUnsubscribeHttp || listUnsubscribeMail;
         }
         const storePath = getStorePath();
         const emlPath = path.join(storePath, accountId, String(envelope.folderId), `${envelope.uid}.eml`);
         return {
             ...envelope, bodyHtml, bodyText, hasRemoteContent, remoteAllowed: allowRemote,
-            attachments, emlPath, deliveredTo, returnPath, listUnsubscribe,
+            attachments, emlPath, deliveredTo, returnPath,
+            listUnsubscribe, listUnsubscribeMail, listUnsubscribeHttp, listUnsubscribeOneClick,
         };
     }
+    /** RFC 8058 one-click unsubscribe: POST `List-Unsubscribe=One-Click` to the
+     *  HTTPS URL the message's List-Unsubscribe header advertised. Done server-
+     *  side because the unsubscribe endpoint usually doesn't set CORS headers,
+     *  so a browser-side fetch would be blocked. */
+    async unsubscribeOneClick(url) {
+        if (!/^https:\/\//i.test(url))
+            throw new Error("one-click unsubscribe requires an https URL");
+        const resp = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: "List-Unsubscribe=One-Click",
+        });
+        return { ok: resp.ok, status: resp.status, statusText: resp.statusText };
+    }
     async updateFlags(accountId, uid, flags) {
         const envelope = this.db.getMessageByUid(accountId, uid);
         await this.imapManager.updateFlagsLocal(accountId, uid, envelope?.folderId || 0, flags);
@@ -677,6 +730,45 @@ export class MailxService {
         const { cloudRead } = await import("@bobfrankston/mailx-settings");
         return cloudRead(name);
     }
+    /** 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) {
+        const WHITELIST = ["accounts.jsonc", "allowlist.jsonc", "clients.jsonc", "config.jsonc"];
+        if (!WHITELIST.includes(name))
+            return "";
+        // Look in the repo root (dev) and in the installed package dir (production).
+        const candidates = [
+            path.join(__dirname, "..", "..", "docs", "config-help.md"),
+            path.join(__dirname, "config-help.md"),
+        ];
+        let md = "";
+        for (const p of candidates) {
+            try {
+                md = fs.readFileSync(p, "utf-8");
+                break;
+            }
+            catch { /* try next */ }
+        }
+        if (!md)
+            return "";
+        const lines = md.split(/\r?\n/);
+        let inSection = false;
+        const out = [];
+        for (const line of lines) {
+            const h2 = /^##\s+(.+?)\s*$/.exec(line);
+            if (h2) {
+                if (inSection)
+                    break; // next section — stop
+                if (h2[1].trim() === name) {
+                    inSection = true;
+                    continue;
+                }
+            }
+            if (inSection)
+                out.push(line);
+        }
+        return out.join("\n").trim();
+    }
     /** Write a JSONC config file. Validates that the content parses as JSONC
      *  (loosely — strips comments/trailing commas) before writing. */
     async writeJsoncFile(name, content) {
@@ -913,6 +1005,106 @@ export class MailxService {
         }
         return { suggestion: "" };
     }
+    /** Generic AI text transform — translate / proofread / summarize.
+     *  Shares the autocomplete provider config (provider, key, model). Each
+     *  feature has its own opt-in toggle (translateEnabled / proofreadEnabled),
+     *  default false. Returns empty text + reason when disabled or on error. */
+    async aiTransform(req) {
+        const cfg = loadAutocomplete();
+        if (cfg.provider === "off")
+            return { text: "", reason: "AI provider not configured" };
+        const featureGate = {
+            translate: cfg.translateEnabled,
+            proofread: cfg.proofreadEnabled,
+            summarize: cfg.proofreadEnabled, // bundled with proofread for now
+        };
+        if (!featureGate[req.action])
+            return { text: "", reason: `AI ${req.action} disabled in settings` };
+        const text = (req.text || "").slice(0, 8000); // sanity cap
+        if (!text.trim())
+            return { text: "", reason: "no input" };
+        const target = req.targetLang || "en";
+        let systemPrompt;
+        let userPrompt;
+        switch (req.action) {
+            case "translate":
+                systemPrompt = `You are a translator. Render the user's text into ${target}. Preserve formatting (paragraphs, lists). Output ONLY the translation, no explanation.`;
+                userPrompt = text;
+                break;
+            case "proofread":
+                systemPrompt = `You are an editor. Return the user's text with grammar, spelling, and clarity fixed. Preserve voice and meaning. Output ONLY the corrected text, no explanation.`;
+                userPrompt = text;
+                break;
+            case "summarize":
+                systemPrompt = `You are a summarizer. Render the user's text as a short paragraph (2-4 sentences). Output ONLY the summary.`;
+                userPrompt = text;
+                break;
+        }
+        try {
+            if (cfg.provider === "ollama") {
+                const res = await fetch(`${cfg.ollamaUrl}/api/generate`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        model: cfg.ollamaModel,
+                        prompt: `${systemPrompt}\n\n${userPrompt}`,
+                        stream: false,
+                        options: { num_predict: 1024 },
+                    }),
+                });
+                if (!res.ok)
+                    return { text: "", reason: `ollama ${res.status}` };
+                const data = await res.json();
+                return { text: (data.response || "").trim() };
+            }
+            if (cfg.provider === "claude") {
+                const res = await fetch("https://api.anthropic.com/v1/messages", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "x-api-key": cfg.cloudApiKey,
+                        "anthropic-version": "2023-06-01",
+                    },
+                    body: JSON.stringify({
+                        model: cfg.cloudModel,
+                        max_tokens: 2048,
+                        system: systemPrompt,
+                        messages: [{ role: "user", content: userPrompt }],
+                    }),
+                });
+                if (!res.ok)
+                    return { text: "", reason: `claude ${res.status}` };
+                const data = await res.json();
+                return { text: (data.content?.[0]?.text || "").trim() };
+            }
+            if (cfg.provider === "openai") {
+                const res = await fetch("https://api.openai.com/v1/chat/completions", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "Authorization": `Bearer ${cfg.cloudApiKey}`,
+                    },
+                    body: JSON.stringify({
+                        model: cfg.cloudModel,
+                        max_tokens: 2048,
+                        messages: [
+                            { role: "system", content: systemPrompt },
+                            { role: "user", content: userPrompt },
+                        ],
+                    }),
+                });
+                if (!res.ok)
+                    return { text: "", reason: `openai ${res.status}` };
+                const data = await res.json();
+                return { text: (data.choices?.[0]?.message?.content || "").trim() };
+            }
+        }
+        catch (e) {
+            console.error(`  [aiTransform] ${cfg.provider} ${req.action} error: ${e.message}`);
+            return { text: "", reason: e.message };
+        }
+        return { text: "", reason: "no provider matched" };
+    }
 }
 /** Trim suggestion: remove leading/trailing whitespace, cap at sentence boundary */
 function trimSuggestion(text) {

package/packages/mailx-service/jsonrpc.js

@@ -105,6 +105,10 @@ async function dispatchAction(svc, action, p) {
         case "writeJsoncFile":
             await svc.writeJsoncFile(p.name, p.content);
             return { ok: true };
+        case "readConfigHelp":
+            return { content: await svc.readConfigHelp(p.name) };
+        case "unsubscribeOneClick":
+            return await svc.unsubscribeOneClick(p.url);
         // Settings
         case "getSettings":
             return svc.getSettings();
@@ -133,6 +137,10 @@ async function dispatchAction(svc, action, p) {
         case "saveAutocompleteSettings":
             svc.saveAutocompleteSettings(p);
             return { ok: true };
+        // AI transform (translate / proofread / summarize) — gated by per-feature
+        // toggles in autocomplete settings, both default false.
+        case "aiTransform":
+            return svc.aiTransform(p);
         // Attachments
         case "getAttachment": {
             const att = await svc.getAttachment(p.accountId, p.uid, p.attachmentId, p.folderId);

package/packages/mailx-store/db.js

@@ -270,7 +270,7 @@ export class MailxDB {
     }
     getFolders(accountId) {
         const rows = this.db.prepare("SELECT * FROM folders WHERE account_id = ? ORDER BY path").all(accountId);
-        return rows.map(r => ({
+        const folders = rows.map(r => ({
             id: r.id,
             accountId: r.account_id,
             path: r.path,
@@ -281,6 +281,35 @@ export class MailxDB {
             unreadCount: r.unread_count,
             children: []
         }));
+        // Sub-folder inheritance: a folder under Drafts/Sent/Trash/Junk/Archive
+        // inherits the parent's special role for UI purposes (column layout,
+        // open-in-compose, etc.). INBOX is intentionally excluded — its sub-
+        // folders are typically filtered mail and inheriting "inbox" would
+        // inflate All Inboxes. findFolder() still resolves to the canonical
+        // folder because rows are sorted by path and the parent sorts before
+        // its children.
+        const INHERITABLE = new Set(["sent", "drafts", "trash", "junk", "archive"]);
+        const roleByPath = new Map();
+        for (const f of folders) {
+            if (f.specialUse && INHERITABLE.has(f.specialUse)) {
+                roleByPath.set(f.path, f.specialUse);
+            }
+        }
+        for (const f of folders) {
+            if (f.specialUse)
+                continue;
+            const delim = f.delimiter || "/";
+            const parts = f.path.split(delim);
+            while (parts.length > 1) {
+                parts.pop();
+                const role = roleByPath.get(parts.join(delim));
+                if (role) {
+                    f.specialUse = role;
+                    break;
+                }
+            }
+        }
+        return folders;
     }
     deleteFolder(folderId) {
         this.db.prepare("DELETE FROM messages WHERE folder_id = ?").run(folderId);
@@ -313,10 +342,23 @@ export class MailxDB {
             if (msg.providerId && !existing.provider_id) {
                 this.db.prepare("UPDATE messages SET provider_id = ? WHERE id = ?").run(msg.providerId, existing.id);
             }
-            this.db.prepare(`
-                UPDATE messages SET flags_json = ?, preview = ?, body_path = ?, cached_at = ?
-                WHERE id = ?
-            `).run(JSON.stringify(msg.flags), msg.preview, msg.bodyPath, Date.now(), existing.id);
+            // Only overwrite body_path / preview when the caller actually has a
+            // body. Metadata-only syncs (Gmail API storeApiMessages, IMAP
+            // header-only fetches) pass bodyPath: "" and would otherwise wipe
+            // the path that prefetch just wrote, causing prefetch to re-download
+            // every message every cycle.
+            if (msg.bodyPath) {
+                this.db.prepare(`
+                    UPDATE messages SET flags_json = ?, preview = ?, body_path = ?, cached_at = ?
+                    WHERE id = ?
+                `).run(JSON.stringify(msg.flags), msg.preview, msg.bodyPath, Date.now(), existing.id);
+            }
+            else {
+                this.db.prepare(`
+                    UPDATE messages SET flags_json = ?, cached_at = ?
+                    WHERE id = ?
+                `).run(JSON.stringify(msg.flags), Date.now(), existing.id);
+            }
             return existing.id;
         }
         const toText = msg.to.map(a => `${a.name} ${a.address}`).join(" ");

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

@@ -33,8 +33,8 @@ function emitEvent(event) {
         }
         catch { /* ignore */ }
     }
-    if (typeof window._mailxapiEvent === "function") {
-        window._mailxapiEvent(event);
+    if (typeof window._msgapiServiceEvent === "function") {
+        window._msgapiServiceEvent(event);
     }
 }
 // ── Helpers ──
@@ -54,6 +54,10 @@ class AndroidSyncManager {
     bodyStore;
     providers = new Map();
     tokenProviders = new Map();
+    // One prefetch session per account — prevents every syncAll tick from
+    // spawning parallel fetch loops that race on IndexedDB and blow through
+    // Gmail's per-user quota.
+    prefetchingAccounts = new Set();
     constructor(db, bodyStore) {
         this.db = db;
         this.bodyStore = bodyStore;
@@ -150,6 +154,91 @@ class AndroidSyncManager {
                 emitEvent({ type: "syncError", accountId: account.id, error: e.message });
             }
         }
+        // Phase 3: background body prefetch. Fire-and-forget — sync itself is
+        // already done and the UI doesn't wait on this. Per-account guard means
+        // a slow account can't block a fast one.
+        for (const account of accounts) {
+            if (!this.providers.has(account.id))
+                continue;
+            this.prefetchBodies(account.id).catch(e => console.error(`[prefetch] ${account.id}: ${e.message}`));
+        }
+    }
+    /** Background body prefetch — download bodies for messages that don't have
+     *  them yet, so tapping a message in the list opens instantly from cache. */
+    async prefetchBodies(accountId) {
+        if (this.prefetchingAccounts.has(accountId))
+            return;
+        this.prefetchingAccounts.add(accountId);
+        try {
+            const BATCH_SIZE = 20;
+            const THROTTLE_MS = 150;
+            const RATE_LIMIT_PAUSE_MS = 30000;
+            const ERROR_BUDGET = 10;
+            let totalFetched = 0;
+            let errors = 0;
+            let announced = false;
+            while (true) {
+                const missing = this.db.getMessagesWithoutBody(accountId, BATCH_SIZE);
+                if (missing.length === 0)
+                    break;
+                if (!announced) {
+                    console.log(`[prefetch] ${accountId}: ${missing.length}+ bodies to fetch`);
+                    vlog(`prefetch ${accountId} start: ${missing.length}+ pending`);
+                    announced = true;
+                }
+                let progressedThisBatch = false;
+                for (const m of missing) {
+                    // Sync the DB path if the body is already in IndexedDB — common
+                    // when upgrading from a build that didn't set body_path on cache.
+                    if (await this.bodyStore.hasMessage(accountId, m.folderId, m.uid)) {
+                        this.db.updateBodyPath(accountId, m.uid, `idb:${accountId}/${m.folderId}/${m.uid}`);
+                        progressedThisBatch = true;
+                        continue;
+                    }
+                    try {
+                        const result = await this.fetchMessageBody(accountId, m.folderId, m.uid);
+                        if (result) {
+                            totalFetched++;
+                            progressedThisBatch = true;
+                            emitEvent({ type: "bodyCached", accountId, uid: m.uid, folderId: m.folderId });
+                        }
+                        else {
+                            errors++;
+                        }
+                    }
+                    catch (e) {
+                        errors++;
+                        const msg = String(e?.message || "");
+                        if (/429|rate|too many/i.test(msg)) {
+                            console.log(`[prefetch] ${accountId}: rate-limited — pausing ${RATE_LIMIT_PAUSE_MS / 1000}s`);
+                            await new Promise(r => setTimeout(r, RATE_LIMIT_PAUSE_MS));
+                        }
+                        else {
+                            console.error(`[prefetch] ${accountId}/${m.uid}: ${msg}`);
+                        }
+                    }
+                    if (errors >= ERROR_BUDGET) {
+                        console.error(`[prefetch] ${accountId}: stopping after ${errors} errors (${totalFetched} cached)`);
+                        vlog(`prefetch ${accountId} aborted: ${errors} errors, ${totalFetched} cached`);
+                        return;
+                    }
+                    await new Promise(r => setTimeout(r, THROTTLE_MS));
+                }
+                // If a full batch made no progress, bail out to avoid an infinite
+                // loop on messages the server can't deliver.
+                if (!progressedThisBatch) {
+                    console.warn(`[prefetch] ${accountId}: batch made no progress, stopping`);
+                    break;
+                }
+            }
+            if (totalFetched > 0) {
+                console.log(`[prefetch] ${accountId}: done — cached ${totalFetched} bodies`);
+                vlog(`prefetch ${accountId} done: ${totalFetched} cached`);
+            }
+        }
+        finally {
+            this.prefetchingAccounts.delete(accountId);
+        }
     }
     async syncFolders(accountId) {
         const provider = this.getProvider(accountId);

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

@@ -368,7 +368,10 @@ export class WebMailxDB {
         this.run("UPDATE messages SET body_path = ? WHERE account_id = ? AND uid = ?", [bodyPath, accountId, uid]);
     }
     getMessagesWithoutBody(accountId, limit = 50) {
-        return this.all("SELECT uid, folder_id as folderId FROM messages WHERE account_id = ? AND (body_path IS NULL OR body_path = '') ORDER BY date DESC LIMIT ?", [accountId, limit]);
+        // "idb:<acct>/<folder>/<uid>" means the body is cached in IndexedDB via
+        // WebMessageStore. Anything else (NULL, "", "gmail:<id>", legacy paths)
+        // still needs fetching.
+        return this.all("SELECT uid, folder_id as folderId FROM messages WHERE account_id = ? AND (body_path IS NULL OR body_path NOT LIKE 'idb:%') ORDER BY date DESC LIMIT ?", [accountId, limit]);
     }
     getHighestUid(accountId, folderId) {
         const r = this.get("SELECT MAX(uid) as maxUid FROM messages WHERE account_id = ? AND folder_id = ?", [accountId, folderId]);

package/packages/mailx-store-web/main-thread-host.js

@@ -162,8 +162,8 @@ function handleWorkerEvent(event) {
         }
         catch { /* ignore */ }
     }
-    // Also dispatch to the global mailxapi event callback
-    const cb = window._mailxapiEvent;
+    // Also dispatch to the global host service-channel event callback
+    const cb = window._msgapiServiceEvent;
     if (cb)
         try {
             cb(event);

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

@@ -225,6 +225,12 @@ export interface AutocompleteSettings {
     cloudModel: string;
     debounceMs: number;
     maxTokens: number;
+    /** Per-feature opt-in for non-autocomplete AI helpers. All default false
+     *  per user preference (2026-04-21): AI features should be controlled by
+     *  a flag, initially OFF in settings. Provider config is shared with
+     *  autocomplete (provider, cloudApiKey, cloudModel, etc.). */
+    translateEnabled?: boolean;
+    proofreadEnabled?: boolean;
 }
 export interface AutocompleteRequest {
     subject: string;
@@ -235,6 +241,21 @@ export interface AutocompleteRequest {
 export interface AutocompleteResponse {
     suggestion: string;
 }
+export interface AiTransformRequest {
+    /** translate = render in `targetLang`; proofread = corrected version
+     *  with grammar/spelling fixes; summarize = short paragraph summary. */
+    action: "translate" | "proofread" | "summarize";
+    text: string;
+    /** ISO-639-1 (or BCP-47) language code for translate. Defaults to "en". */
+    targetLang?: string;
+}
+export interface AiTransformResponse {
+    /** Transformed text. Empty when AI is disabled / provider error / feature
+     *  not enabled — caller should treat empty as "no result". */
+    text: string;
+    /** Optional reason for empty result, surfaced to UI status bar. */
+    reason?: string;
+}
 /** Body storage backend interface -- implementations are swappable */
 export interface MessageStore {
     putMessage(accountId: string, folderId: number, uid: number, raw: Buffer): Promise<string>;

package/tempfix.cmd

@@ -0,0 +1,77 @@
+@echo off
+rem --------------------------------------------------------------------
+rem tempfix.cmd — recover Claude Code + msger build after session wedge
+rem
+rem Problem: Claude Code's Bash tool keeps throwing EEXIST on
+rem   C:\Users\Bob\.claude\session-env\<uuid> because the current session
+rem   left a stale dir and the tool's mkdir isn't recursive.
+rem Separately: msger's Windows build and stable-hardlink update need
+rem   mailx NOT to be holding msgernative.exe when npmglobalize runs.
+rem   (Fixed in source via rename-aside, but we still want a clean slate
+rem   so the first rebuild doesn't have to juggle three generations of
+rem   .old-<ts> files on top of a running process.)
+rem
+rem What this script does, in order:
+rem   1. Kill Claude Code so it releases its session-env lock.
+rem   2. Kill mailx + any running msger window so msgernative.exe can be
+rem      replaced (strictly not required with the rename-aside fix, but
+rem      cleaner for this one-time recovery).
+rem   3. Nuke the entire session-env dir so the NEXT Claude start gets
+rem      a fresh UUID subdir.
+rem   4. Remind you of the next commands to run.
+rem
+rem Safe to re-run. Everything taskkill'd is optional — not-found is fine.
+rem --------------------------------------------------------------------
+
+echo.
+echo === 1/3  Killing Claude Code ===
+taskkill /F /IM claude.exe 2>nul
+if %errorlevel% equ 0 ( echo    claude.exe terminated ) else ( echo    claude.exe was not running )
+
+echo.
+echo === 2/3  Killing mailx + msger so msgernative.exe is free ===
+rem mailx runs as node.exe but node.exe runs EVERYTHING on this box, so
+rem we do NOT blanket-kill node. Instead kill the msger native window and
+rem any mailx launcher by image name. mailx's own node process stays up
+rem unless you want to close the UI — uncomment the last line to kill it.
+taskkill /F /IM msgernative.exe 2>nul
+if %errorlevel% equ 0 ( echo    msgernative.exe terminated ) else ( echo    msgernative.exe was not running )
+rem To also stop mailx's node service, uncomment:
+rem taskkill /F /FI "WINDOWTITLE eq mailx*" 2>nul
+
+echo.
+echo === 3/3  Removing stale Claude session-env dir ===
+if exist "%USERPROFILE%\.claude\session-env" (
+    rmdir /s /q "%USERPROFILE%\.claude\session-env"
+    if exist "%USERPROFILE%\.claude\session-env" (
+        echo    WARNING: session-env still exists — something was holding it open
+    ) else (
+        echo    session-env removed
+    )
+) else (
+    echo    session-env already gone
+)
+
+echo.
+echo --------------------------------------------------------------------
+echo Done. Next steps:
+echo.
+echo   1. Start Claude Code again. Your in-flight state is saved in memory
+echo      at C:\Users\Bob\.claude\projects\Y--dev-email-mailx\memory\
+echo      (see project_session_apr20_state.md for the full handoff).
+echo.
+echo   2. Rebuild msger so the new binary is installed:
+echo        cd /d y:\dev\utils\msgx\msger
+echo        npmglobalize
+echo.
+echo   3. Once that succeeds, test keyboard input:
+echo        msger y:\dev\projects\Cards\bbt\bbs.json
+echo      Try typing + Ctrl+C. If fixed, stale-binary theory was correct.
+echo      If still broken, tell Claude and we'll dig into focus/MoveFocus.
+echo.
+echo   4. In mailx root, wire up the new mailx-host workspace:
+echo        cd /d y:\dev\email\mailx
+echo        npm install
+echo        cd packages\mailx-host
+echo        tsc
+echo --------------------------------------------------------------------