@echomem/mcp 1.3.1 → 1.4.0

package/dist/setup.js

@@ -15,17 +15,20 @@
 import http from "node:http";
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
+import { Worker } from "node:worker_threads";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
+import { fileURLToPath } from "node:url";
 import axios from "axios";
 import { KeyStore } from "./keystore.js";
 import { fetchEncryptionConfig, deriveAndVerifyKey, verifyKeyB64 } from "./encryption.js";
-import { collect, runReport, buildReportText, buildStatsPayload } from "./report.js";
-import { cmdMigrate, discoverMigratableSessions, estimateMigrationEta, startMigration } from "./migrate.js";
+import { collect, runReport, buildStatsPayload } from "./report.js";
+import { cmdMigrate, applyAccountImportStatus, applyFastAccountImportStatus, discoverMigratableFastDiscovery, discoverMigratableSessions, discoverPendingSessionsTargeted, estimateMigrationEta, fetchProcessedImportKeys, isImportStatusUnsupported, markAccountImportStatusFailed, markAccountImportStatusUnavailable, markFastAccountImportStatusUnavailable, startMigration, summarizeFastMigratableDiscovery, MIGRATE_CONCURRENCY, } from "./migrate.js";
 import { syncCodexUsage } from "./codex-sync.js";
 import { renderSetupPage } from "./setup-page.js";
+import { repoLabel } from "./forensics.js";
 // The hosted connect-device page is now only the account-auth/token courier. The dashboard itself is
 // served by this localhost bridge, where local logs and processed/unprocessed counts never leave the
 // device unless the user explicitly starts migration. Override the hosted auth origin with ECHO_WEB_URL.
@@ -149,6 +152,50 @@ function openBrowser(url) {
         /* headless — caller prints the URL */
     }
 }
+function migratableFromDiscovery(disc) {
+    const eta = estimateMigrationEta(disc.pending, disc.skippedActive);
+    return {
+        pending: disc.pending.length,
+        pendingTotal: disc.pendingTotal,
+        alreadyMigrated: disc.alreadyMigrated,
+        skippedActive: disc.skippedActive,
+        limited: disc.limited,
+        eta,
+        buckets: eta.buckets,
+        totalChars: eta.totalChars,
+        approxInputTokens: eta.approxInputTokens,
+        estimatedSeconds: eta.estimatedSeconds,
+        estimatedLabel: eta.estimatedLabel,
+        accountChecked: disc.accountChecked === true,
+        accountCheckFailed: disc.accountCheckFailed === true,
+        accountCheckUnavailable: disc.accountCheckUnavailable === true,
+    };
+}
+function sessionsFromDiscovery(disc) {
+    return {
+        total: disc.sessions.length,
+        codex: disc.codexCount,
+        claudeCode: disc.claudeCount,
+    };
+}
+function migratableFromFastSummary(summary) {
+    return {
+        pending: summary.pending,
+        pendingTotal: summary.pendingTotal,
+        alreadyMigrated: summary.alreadyMigrated,
+        skippedActive: summary.skippedActive,
+        eta: summary.eta,
+        buckets: summary.eta.buckets,
+        totalChars: summary.eta.totalChars,
+        approxInputTokens: summary.eta.approxInputTokens,
+        estimatedSeconds: summary.eta.estimatedSeconds,
+        estimatedLabel: summary.eta.estimatedLabel,
+        quickEstimate: true,
+        accountChecked: summary.accountChecked === true,
+        accountCheckFailed: summary.accountCheckFailed === true,
+        accountCheckUnavailable: summary.accountCheckUnavailable === true,
+    };
+}
 function deferred() {
     let done = false;
     let resolveInner;
@@ -214,6 +261,137 @@ function withTimeout(promise, ms, code, onTimeout) {
             clearTimeout(timer);
     });
 }
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const CITY_ASSET_TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".wasm": "application/wasm",
+    ".riv": "application/octet-stream",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+};
+function repoCityArtifactsRoot() {
+    // Monorepo/dev: read the city assets live from repo-root /artifacts.
+    const repo = fileURLToPath(new URL("../../../artifacts/", import.meta.url));
+    if (fs.existsSync(repo))
+        return repo;
+    // Published install: fall back to the copy bundled into dist/city by prepack (bundle-city.mjs).
+    return fileURLToPath(new URL("./city/", import.meta.url));
+}
+function serveRepoCityAsset(reqPath, res) {
+    const root = repoCityArtifactsRoot();
+    const rel = reqPath === "/city" || reqPath === "/city/" ? "echo-ai-city-only.html" : decodeURIComponent(reqPath.slice("/city/".length));
+    const filePath = path.resolve(root, rel);
+    const rootWithSep = root.endsWith(path.sep) ? root : root + path.sep;
+    if (!filePath.startsWith(rootWithSep)) {
+        res.writeHead(403).end("forbidden");
+        return true;
+    }
+    if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+        res.writeHead(404).end("not found");
+        return true;
+    }
+    res.writeHead(200, {
+        "Content-Type": CITY_ASSET_TYPES[path.extname(filePath)] || "application/octet-stream",
+        "Cache-Control": "no-store",
+    });
+    fs.createReadStream(filePath).pipe(res);
+    return true;
+}
+function discoverMigratableSessionsOffThread() {
+    const migrateUrl = new URL("./migrate.js", import.meta.url).href;
+    const code = `
+    import { parentPort } from "node:worker_threads";
+    import { discoverMigratableSessions } from ${JSON.stringify(migrateUrl)};
+
+    try {
+      parentPort?.postMessage({ ok: true, discovery: discoverMigratableSessions() });
+    } catch (error) {
+      parentPort?.postMessage({
+        ok: false,
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined,
+      });
+    }
+  `;
+    const worker = new Worker(new URL(`data:text/javascript;charset=utf-8,${encodeURIComponent(code)}`));
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        worker.once("message", (message) => {
+            settled = true;
+            const msg = message;
+            if (msg.ok === true && msg.discovery && typeof msg.discovery === "object") {
+                resolve(msg.discovery);
+                return;
+            }
+            const err = new Error(typeof msg.message === "string" ? msg.message : "Exact local discovery failed");
+            if (typeof msg.stack === "string")
+                err.stack = msg.stack;
+            reject(err);
+        });
+        worker.once("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(error);
+        });
+        worker.once("exit", (code) => {
+            // Reject on ANY unsettled exit (incl. code 0): a worker that exits without posting a result must
+            // not leave this promise pending forever (that was the "stuck at finishing local job sizing" hang).
+            if (settled)
+                return;
+            settled = true;
+            reject(new Error(`Exact local discovery worker exited (code ${code}) without a result`));
+        });
+    });
+}
+/** Build the local forensic "Context Doctor" report on a worker thread so the multi-file scan never
+ * blocks the bridge's event loop (the freeze postmortem: any unbounded sync work on this path is risky). */
+function buildForensicReportOffThread(onProgress) {
+    const forensicsUrl = new URL("./forensics.js", import.meta.url).href;
+    const code = `
+    import { parentPort } from "node:worker_threads";
+    import { buildForensicReport } from ${JSON.stringify(forensicsUrl)};
+    try {
+      const report = buildForensicReport({ onProgress: (done, total) => parentPort?.postMessage({ progress: { done, total } }) });
+      parentPort?.postMessage({ ok: true, report });
+    } catch (error) {
+      parentPort?.postMessage({ ok: false, message: error instanceof Error ? error.message : String(error) });
+    }
+  `;
+    const worker = new Worker(new URL(`data:text/javascript;charset=utf-8,${encodeURIComponent(code)}`));
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        worker.on("message", (message) => {
+            const msg = message;
+            if (msg.progress) {
+                onProgress?.(msg.progress.done, msg.progress.total);
+                return;
+            }
+            settled = true;
+            if (msg.ok === true && msg.report && typeof msg.report === "object")
+                resolve(msg.report);
+            else
+                reject(new Error(typeof msg.message === "string" ? msg.message : "Local forensic report failed"));
+            void worker.terminate();
+        });
+        worker.once("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(error);
+        });
+        worker.once("exit", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(new Error(`Forensic report worker exited (code ${code}) without a result`));
+        });
+    });
+}
 export function respondMigrate(res, body, status = 200) {
     if (res.writableEnded)
         return;
@@ -226,6 +404,7 @@ export function respondMigrate(res, body, status = 200) {
  */
 export function startCallbackServer(opts = {}) {
     const timeoutMs = opts.timeoutMs ?? 300_000;
+    const dashboardTimeoutMs = 4 * 60 * 60 * 1000;
     const expectedNonce = opts.nonce;
     return new Promise((resolveOuter, rejectOuter) => {
         const onToken = deferred();
@@ -233,9 +412,12 @@ export function startCallbackServer(opts = {}) {
         const migrateRequest = deferred();
         let stats = null;
         let authUrl = "";
+        let switchAccountUrl = "";
         let connected = false;
         let progress = { status: "idle", total: 0, completed: 0, running: 0, queued: 0, failed: 0, extracted: 0 };
         let migrateStarted = false;
+        let tokenRefreshHandler = null;
+        let logoutHandler = null;
         let timer;
         let closed = false;
         let server;
@@ -254,6 +436,7 @@ export function startCallbackServer(opts = {}) {
         const armTimeout = () => {
             if (timer)
                 clearTimeout(timer);
+            const waitMs = onToken.settled() ? dashboardTimeoutMs : timeoutMs;
             timer = setTimeout(() => {
                 if (!onToken.settled()) {
                     onToken.reject(new Error("timed out waiting for browser approval"));
@@ -262,16 +445,27 @@ export function startCallbackServer(opts = {}) {
                     decision.resolve("timeout");
                 }
                 close();
-            }, timeoutMs);
+            }, waitMs);
+            timer.unref?.();
         };
         const handleCallback = (res, token, key, nonce) => {
             if (!checkNonce(nonce))
                 return void text(res, 403, "bad nonce");
             if (!token)
                 return void text(res, 400, "missing token");
+            const firstToken = !onToken.settled();
             connected = true;
-            res.writeHead(200, { "Content-Type": "text/html" }).end(`<!doctype html><html><head><meta charset="utf-8"><meta http-equiv="refresh" content="0; url=/setup?nonce=${encodeURIComponent(nonce || "")}&connected=1"></head><body style="font-family:system-ui;padding:3rem;text-align:center"><h2>EchoMem connected</h2><p>Returning to the local dashboard...</p><p><a href="/setup?nonce=${encodeURIComponent(nonce || "")}&connected=1">Continue</a></p></body></html>`);
-            onToken.resolve({ token, key });
+            const setupPath = `/setup?nonce=${encodeURIComponent(nonce || "")}&connected=1`;
+            res.writeHead(200, { "Content-Type": "text/html" }).end(`<!doctype html><html><head><meta charset="utf-8"></head><body style="font-family:system-ui;padding:3rem;text-align:center"><h2>EchoMem connected</h2><p>Returning to the local setup page...</p><p><a href="${setupPath}">Continue</a></p><script>(function(){var target=${JSON.stringify(setupPath)};try{if(window.opener&&!window.opener.closed){window.opener.postMessage({type:"echomem:connected",nonce:${JSON.stringify(nonce || "")}},window.location.origin);window.close();setTimeout(function(){window.location.href=target;},500);return;}}catch(_){}window.location.href=target;})();</script></body></html>`);
+            const callbackToken = { token, key };
+            if (firstToken) {
+                onToken.resolve(callbackToken);
+            }
+            else if (tokenRefreshHandler) {
+                Promise.resolve(tokenRefreshHandler(callbackToken)).catch((e) => {
+                    console.error(`Could not refresh local login: ${e instanceof Error ? e.message : String(e)}`);
+                });
+            }
             armTimeout();
         };
         server = http.createServer((req, res) => {
@@ -285,6 +479,10 @@ export function startCallbackServer(opts = {}) {
             const url = new URL(req.url || "/", "http://127.0.0.1");
             const route = url.pathname;
             const run = async () => {
+                if ((route === "/city" || route.startsWith("/city/")) && req.method === "GET") {
+                    serveRepoCityAsset(route, res);
+                    return;
+                }
                 if (route === "/setup" && req.method === "GET") {
                     res.writeHead(200, {
                         "Content-Type": "text/html; charset=utf-8",
@@ -295,7 +493,7 @@ export function startCallbackServer(opts = {}) {
                 if (route === "/config" && req.method === "GET") {
                     if (!checkNonce(url.searchParams.get("nonce") || undefined))
                         return void text(res, 403, "bad nonce");
-                    json(res, 200, { connected, authUrl, localOnly: true });
+                    json(res, 200, { connected, authUrl, switchAccountUrl: switchAccountUrl || authUrl, localOnly: true });
                     return;
                 }
                 if (route === "/callback" && req.method === "GET") {
@@ -323,12 +521,58 @@ export function startCallbackServer(opts = {}) {
                     json(res, 200, payload);
                     return;
                 }
+                if (route === "/report" && req.method === "GET") {
+                    // Local forensic "Context Doctor" report — computed locally, served BEFORE auth (scan-first).
+                    if (!checkNonce(url.searchParams.get("nonce") || undefined))
+                        return void text(res, 403, "bad nonce");
+                    const payload = opts.getReport ? opts.getReport() : null;
+                    if (payload == null) {
+                        // 202 carries scan progress so the page can show a live "scanned N/total" indicator.
+                        const prog = opts.getReportProgress ? opts.getReportProgress() : { scanned: 0, total: 0 };
+                        return void res.writeHead(202, { "Content-Type": "application/json" }).end(JSON.stringify(prog));
+                    }
+                    json(res, 200, payload);
+                    return;
+                }
                 if (route === "/progress" && req.method === "GET") {
                     if (!checkNonce(url.searchParams.get("nonce") || undefined))
                         return void text(res, 403, "bad nonce");
                     json(res, 200, progress);
                     return;
                 }
+                if (route === "/logout" && req.method === "POST") {
+                    let body;
+                    try {
+                        body = await readJsonBody(req);
+                    }
+                    catch {
+                        text(res, 400, "bad json");
+                        return;
+                    }
+                    if (!checkNonce(asString(body.nonce)))
+                        return void text(res, 403, "bad nonce");
+                    if (migrateStarted && (progress.status === "starting" || progress.status === "running")) {
+                        json(res, 409, { error: "MIGRATION_RUNNING", message: "Wait for extraction to finish before signing out locally." });
+                        return;
+                    }
+                    try {
+                        fs.rmSync(new KeyStore().path(), { force: true });
+                    }
+                    catch {
+                        /* already logged out locally */
+                    }
+                    connected = false;
+                    stats = null;
+                    migrateStarted = false;
+                    progress = { status: "idle", total: 0, completed: 0, running: 0, queued: 0, failed: 0, extracted: 0 };
+                    json(res, 200, { ok: true, authUrl, switchAccountUrl: switchAccountUrl || authUrl, localOnly: true });
+                    Promise.resolve()
+                        .then(() => logoutHandler?.())
+                        .catch((e) => {
+                        console.error(`Could not reset local login state: ${e instanceof Error ? e.message : String(e)}`);
+                    });
+                    return;
+                }
                 if (route === "/migrate" && req.method === "POST") {
                     let body;
                     try {
@@ -385,8 +629,15 @@ export function startCallbackServer(opts = {}) {
                 wait: onToken.promise,
                 decision: decision.promise,
                 migrateRequest: migrateRequest.promise,
-                setAuthUrl: (url) => {
+                setTokenRefreshHandler: (handler) => {
+                    tokenRefreshHandler = handler;
+                },
+                setLogoutHandler: (handler) => {
+                    logoutHandler = handler;
+                },
+                setAuthUrl: (url, nextSwitchAccountUrl) => {
                     authUrl = url;
+                    switchAccountUrl = nextSwitchAccountUrl || url;
                 },
                 setStats: (s) => {
                     stats = s;
@@ -408,6 +659,42 @@ function authedAxios(token) {
         headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
     });
 }
+function formatVerificationError(error) {
+    if (axios.isAxiosError(error)) {
+        const status = typeof error.response?.status === "number" ? error.response.status : null;
+        const statusText = error.response?.statusText ? ` ${error.response.statusText}` : "";
+        const requestPath = typeof error.config?.url === "string" ? error.config.url : "";
+        const endpoint = requestPath
+            ? requestPath.startsWith("http")
+                ? requestPath
+                : `${API_BASE_URL}${requestPath}`
+            : API_BASE_URL;
+        const statusLabel = status ? `HTTP ${status}${statusText}` : error.code || error.message;
+        const localApi = /^https?:\/\/(127\.0\.0\.1|localhost)(:\d+)?/.test(API_BASE_URL);
+        const routeHint = status === 404 && requestPath.includes("/api/extension/account/encryption")
+            ? localApi
+                ? "That usually means ECHO_API_BASE_URL is pointing at a different local app or an older EchoMem API server."
+                : "That usually means the EchoMem API route is missing on the configured server."
+            : null;
+        const localHint = localApi ? "Start the EchoMem-Chrome Next API on that port, or unset ECHO_API_BASE_URL to use production." : null;
+        return [
+            `Could not verify this device token against ${endpoint}: ${statusLabel}.`,
+            routeHint,
+            localHint,
+        ].filter(Boolean).join(" ");
+    }
+    return `Could not verify this device token: ${error instanceof Error ? error.message : String(error)}`;
+}
+async function verifyAndPrint(input) {
+    try {
+        console.log(await verifyAndStore(input));
+        return true;
+    }
+    catch (error) {
+        console.error(`❌ ${formatVerificationError(error)}`);
+        return false;
+    }
+}
 /**
  * Verify supplied secrets and persist them. Given a token (required), and EITHER a base64 key or a
  * passphrase (optional — only for encrypted accounts), this verifies the key against the server's
@@ -415,8 +702,8 @@ function authedAxios(token) {
  */
 export async function verifyAndStore(input) {
     const store = new KeyStore();
-    store.saveToken(input.token);
     const config = await fetchEncryptionConfig(authedAxios(input.token));
+    store.saveToken(input.token);
     if (!config.enabled) {
         return input.key || input.passphrase
             ? "Token saved. (Account is not encrypted — the supplied key was ignored.)"
@@ -505,23 +792,17 @@ async function cmdSetup(flags) {
     }
     console.log("");
     await cmdLogin(flags);
-    // Onboarding reveal: show the local usage audit right after connecting (proactive trigger).
-    try {
-        console.log("\n" + (await buildReportText(true)));
-    }
-    catch {
-        /* report is best-effort — never block setup */
-    }
 }
 async function cmdLogin(flags) {
     // Manual path (also the headless path): secrets supplied as flags.
     if (typeof flags.token === "string") {
-        const msg = await verifyAndStore({
+        const ok = await verifyAndPrint({
             token: flags.token,
             key: typeof flags.key === "string" ? flags.key : undefined,
             passphrase: typeof flags.passphrase === "string" ? flags.passphrase : undefined,
         });
-        console.log(msg);
+        if (!ok)
+            process.exitCode = 1;
         return;
     }
     // Browser path: open a localhost dashboard. It briefly leaves for hosted auth, then returns here
@@ -529,13 +810,36 @@ async function cmdLogin(flags) {
     console.log("Opening your browser to approve this device…");
     const nonce = randomUUID();
     let stats = null;
-    const srv = await startCallbackServer({ nonce, getStats: () => stats });
+    let forensicReport = null;
+    let forensicProgress = { scanned: 0, total: 0 };
+    const srv = await startCallbackServer({
+        nonce,
+        getStats: () => stats,
+        getReport: () => forensicReport,
+        getReportProgress: () => forensicProgress,
+    });
     const callbackUrl = `http://127.0.0.1:${srv.port}/callback`;
     const localSetupUrl = `http://127.0.0.1:${srv.port}/setup?nonce=${nonce}`;
     const connectUrl = `${WEB_URL}/connect-device?callback=${encodeURIComponent(callbackUrl)}&nonce=${nonce}&return_to=${encodeURIComponent(localSetupUrl)}`;
-    srv.setAuthUrl(connectUrl);
+    const switchAccountUrl = new URL(connectUrl);
+    // The hosted connect-device page should clear its own Supabase/browser session before minting
+    // the localhost token when this hint is present. Localhost cannot safely clear yeahecho.com auth.
+    switchAccountUrl.searchParams.set("force_signout", "1");
+    switchAccountUrl.searchParams.set("prompt", "login");
+    srv.setAuthUrl(connectUrl, switchAccountUrl.toString());
     openBrowser(localSetupUrl);
     console.log(`If it didn't open, visit:\n  ${localSetupUrl}\n`);
+    // Scan-first: build the local forensic "Context Doctor" report off-thread so the page shows it
+    // BEFORE the user connects an account (the scan is local-only; nothing leaves the machine).
+    buildForensicReportOffThread((done, total) => {
+        forensicProgress = { scanned: done, total };
+    })
+        .then((r) => {
+        forensicReport = r;
+    })
+        .catch((e) => {
+        console.error(`Could not build the local report: ${e instanceof Error ? e.message : String(e)}`);
+    });
     let token;
     let key;
     try {
@@ -547,61 +851,345 @@ async function cmdLogin(flags) {
         process.exitCode = 1;
         return;
     }
-    console.log(await verifyAndStore({ token, key }));
-    const disc = discoverMigratableSessions();
-    const eta = estimateMigrationEta(disc.pending, disc.skippedActive);
-    const migratable = {
-        pending: disc.pending.length,
-        alreadyMigrated: disc.alreadyMigrated,
-        skippedActive: disc.skippedActive,
-        eta,
-        buckets: eta.buckets,
-        totalChars: eta.totalChars,
-        approxInputTokens: eta.approxInputTokens,
-        estimatedSeconds: eta.estimatedSeconds,
-        estimatedLabel: eta.estimatedLabel,
-    };
-    const sessionSummary = {
-        total: disc.sessions.length,
-        codex: disc.codexCount,
-        claudeCode: disc.claudeCount,
+    if (!await verifyAndPrint({ token, key })) {
+        srv.close();
+        process.exitCode = 1;
+        return;
+    }
+    let disc = null;
+    let exactDiscovery = Promise.resolve(null);
+    let refreshGeneration = 0;
+    let latestPendingEstimate = 0;
+    // The account's already-imported keys, shared so the /migrate sizing can assemble ONLY pending sessions.
+    let lastProcessedImportKeys = null;
+    const resetLocalLoginState = () => {
+        refreshGeneration++;
+        stats = null;
+        disc = null;
+        exactDiscovery = Promise.resolve(null);
+        latestPendingEstimate = 0;
+        lastProcessedImportKeys = null;
+        srv.setStats(null);
+        srv.setProgress({
+            status: "idle",
+            total: 0,
+            completed: 0,
+            running: 0,
+            queued: 0,
+            failed: 0,
+            extracted: 0,
+        });
     };
-    stats = await buildStatsPayload([], {
-        partial: true,
-        skipMemoryCount: true,
-        sessions: sessionSummary,
-        migratable,
-    });
-    srv.setStats(stats);
-    const fullStatsTimer = setTimeout(() => {
-        void buildStatsPayload(collect(), {
+    const refreshLocalStatsForToken = async (activeToken) => {
+        const generation = ++refreshGeneration;
+        lastProcessedImportKeys = null; // shared with /migrate so it can assemble only the pending sessions
+        let importStatusUnavailable = false;
+        const quickDiscovery = discoverMigratableFastDiscovery();
+        const quick = summarizeFastMigratableDiscovery(quickDiscovery);
+        let migratable = migratableFromFastSummary(quick);
+        latestPendingEstimate = migratable.pending;
+        let sessionSummary = {
+            total: quick.sessions,
+            codex: quick.codexCount,
+            claudeCode: quick.claudeCount,
+        };
+        stats = await buildStatsPayload([], {
+            partial: true,
+            skipMemoryCount: true,
             sessions: sessionSummary,
             migratable,
-        }).then((payload) => {
-            stats = payload;
-            srv.setStats(payload);
-        }).catch(() => {
-            /* best effort — the fast local counts are already available */
+            discovery: { phase: "quick", exact: false },
+        });
+        if (generation !== refreshGeneration)
+            return;
+        srv.setStats(stats);
+        srv.setProgress({
+            status: "idle",
+            total: quick.pending,
+            completed: 0,
+            running: 0,
+            queued: quick.pending,
+            failed: 0,
+            extracted: 0,
         });
-    }, 1500);
-    fullStatsTimer.unref?.();
-    srv.setProgress({
-        status: "idle",
-        total: disc.pending.length,
-        completed: 0,
-        running: 0,
-        queued: disc.pending.length,
-        failed: 0,
-        extracted: 0,
+        const fastAccountController = new AbortController();
+        const fastAccountCheck = withTimeout(fetchProcessedImportKeys(activeToken, quickDiscovery.sessions, fastAccountController.signal), 8_000, "ACCOUNT_STATUS_TIMEOUT", () => fastAccountController.abort()).then(async (processedKeys) => {
+            if (generation !== refreshGeneration)
+                return;
+            lastProcessedImportKeys = processedKeys;
+            const cloudQuick = applyFastAccountImportStatus(quickDiscovery, processedKeys);
+            const currentPhase = stats?.discovery?.phase;
+            if (currentPhase !== "quick")
+                return;
+            const cloudSummary = summarizeFastMigratableDiscovery(cloudQuick);
+            migratable = migratableFromFastSummary(cloudSummary);
+            latestPendingEstimate = migratable.pending;
+            sessionSummary = {
+                total: cloudSummary.sessions,
+                codex: cloudSummary.codexCount,
+                claudeCode: cloudSummary.claudeCount,
+            };
+            const cloudPayload = await buildStatsPayload([], {
+                partial: true,
+                skipMemoryCount: true,
+                sessions: sessionSummary,
+                migratable,
+                discovery: { phase: "account", exact: false },
+            });
+            if (generation !== refreshGeneration)
+                return;
+            stats = cloudPayload;
+            srv.setStats(cloudPayload);
+            srv.setProgress({
+                status: "idle",
+                total: cloudSummary.pending,
+                completed: 0,
+                running: 0,
+                queued: cloudSummary.pending,
+                failed: 0,
+                extracted: 0,
+            });
+        }).catch(async (e) => {
+            if (generation !== refreshGeneration)
+                return;
+            if (isImportStatusUnsupported(e)) {
+                importStatusUnavailable = true;
+                const unavailableQuick = markFastAccountImportStatusUnavailable(quickDiscovery);
+                const currentPhase = stats?.discovery?.phase;
+                if (currentPhase !== "quick")
+                    return;
+                const unavailableSummary = summarizeFastMigratableDiscovery(unavailableQuick);
+                migratable = migratableFromFastSummary(unavailableSummary);
+                latestPendingEstimate = migratable.pending;
+                sessionSummary = {
+                    total: unavailableSummary.sessions,
+                    codex: unavailableSummary.codexCount,
+                    claudeCode: unavailableSummary.claudeCount,
+                };
+                const unavailablePayload = await buildStatsPayload([], {
+                    partial: true,
+                    skipMemoryCount: true,
+                    sessions: sessionSummary,
+                    migratable,
+                    discovery: { phase: "account", exact: false },
+                });
+                if (generation !== refreshGeneration)
+                    return;
+                stats = unavailablePayload;
+                srv.setStats(unavailablePayload);
+                srv.setProgress({
+                    status: "idle",
+                    total: unavailableSummary.pending,
+                    completed: 0,
+                    running: 0,
+                    queued: unavailableSummary.pending,
+                    failed: 0,
+                    extracted: 0,
+                });
+                return;
+            }
+            if (generation === refreshGeneration) {
+                console.error(`Could not check this EchoMem account's import status quickly: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        });
+        exactDiscovery = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                void (async () => {
+                    try {
+                        // Start the local sizing pass without waiting on cloud/account status. The
+                        // account check is useful for tighter counts, but extraction can safely start
+                        // from local candidates because the import path skips true duplicates.
+                        await delay(250);
+                        resolve(await discoverMigratableSessionsOffThread());
+                    }
+                    catch (e) {
+                        reject(e instanceof Error ? e : new Error(String(e)));
+                    }
+                })();
+            }, 250);
+            timer.unref?.();
+        }).then(async (exact) => {
+            if (generation !== refreshGeneration)
+                return disc;
+            const initialExact = lastProcessedImportKeys
+                ? applyAccountImportStatus(exact, lastProcessedImportKeys)
+                : importStatusUnavailable
+                    ? markAccountImportStatusUnavailable(exact)
+                    : exact;
+            disc = initialExact;
+            migratable = migratableFromDiscovery(initialExact);
+            latestPendingEstimate = migratable.pending;
+            sessionSummary = sessionsFromDiscovery(initialExact);
+            const partialPayload = await buildStatsPayload([], {
+                partial: true,
+                skipMemoryCount: true,
+                sessions: sessionSummary,
+                migratable,
+                discovery: { phase: "exact", exact: true },
+            });
+            if (generation !== refreshGeneration)
+                return disc;
+            stats = partialPayload;
+            srv.setStats(partialPayload);
+            srv.setProgress({
+                status: "idle",
+                total: initialExact.pending.length,
+                completed: 0,
+                running: 0,
+                queued: initialExact.pending.length,
+                failed: 0,
+                extracted: 0,
+            });
+            void (async () => {
+                let reconciled = initialExact;
+                try {
+                    await fastAccountCheck;
+                    const controller = new AbortController();
+                    const processedKeys = await withTimeout(fetchProcessedImportKeys(activeToken, exact.sessions, controller.signal), 15_000, "ACCOUNT_STATUS_TIMEOUT", () => controller.abort());
+                    lastProcessedImportKeys = processedKeys;
+                    reconciled = applyAccountImportStatus(exact, processedKeys);
+                }
+                catch (e) {
+                    if (lastProcessedImportKeys) {
+                        reconciled = applyAccountImportStatus(exact, lastProcessedImportKeys);
+                        if (!isImportStatusUnsupported(e)) {
+                            console.error(`Could not refresh this EchoMem account's exact import status; keeping the last successful account check. ${e instanceof Error ? e.message : String(e)}`);
+                        }
+                    }
+                    else if (isImportStatusUnsupported(e)) {
+                        reconciled = markAccountImportStatusUnavailable(exact);
+                    }
+                    else {
+                        reconciled = markAccountImportStatusFailed(exact);
+                        console.error(`Could not check this EchoMem account's import status: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                }
+                if (generation !== refreshGeneration)
+                    return;
+                disc = reconciled;
+                migratable = migratableFromDiscovery(reconciled);
+                latestPendingEstimate = migratable.pending;
+                sessionSummary = sessionsFromDiscovery(reconciled);
+                const reconciledPayload = await buildStatsPayload([], {
+                    partial: true,
+                    skipMemoryCount: true,
+                    sessions: sessionSummary,
+                    migratable,
+                    discovery: { phase: "exact", exact: true },
+                });
+                if (generation !== refreshGeneration)
+                    return;
+                stats = reconciledPayload;
+                srv.setStats(reconciledPayload);
+                srv.setProgress({
+                    status: "idle",
+                    total: reconciled.pending.length,
+                    completed: 0,
+                    running: 0,
+                    queued: reconciled.pending.length,
+                    failed: 0,
+                    extracted: 0,
+                });
+                const fullPayload = await buildStatsPayload(collect(), {
+                    sessions: sessionSummary,
+                    migratable,
+                    discovery: { phase: "full", exact: true },
+                });
+                if (generation !== refreshGeneration)
+                    return;
+                stats = fullPayload;
+                srv.setStats(fullPayload);
+            })();
+            return initialExact;
+        }).catch((e) => {
+            if (generation === refreshGeneration) {
+                console.error(`Could not finish exact local extraction estimate: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            return disc;
+        });
+    };
+    srv.setLogoutHandler(resetLocalLoginState);
+    srv.setTokenRefreshHandler(async ({ token: nextToken, key: nextKey }) => {
+        if (!await verifyAndPrint({ token: nextToken, key: nextKey }))
+            return;
+        await refreshLocalStatsForToken(nextToken);
     });
+    await refreshLocalStatsForToken(token);
     const choice = await srv.decision;
     if (choice === "migrate") {
         const { res } = await srv.migrateRequest;
+        let migrateResponded = false;
+        const sendMigrate = (body, status = 200) => {
+            if (migrateResponded)
+                return;
+            migrateResponded = true;
+            respondMigrate(res, body, status);
+        };
         let activeSessionId = "";
-        let activeJobCount = disc.pending.length;
+        let activeJobCount = latestPendingEstimate;
         let progressDone = 0;
         let progressFailed = 0;
         let progressExtracted = 0;
+        if (!disc) {
+            srv.setProgress({
+                status: "starting",
+                total: activeJobCount,
+                completed: 0,
+                running: 0,
+                queued: activeJobCount,
+                failed: 0,
+                extracted: 0,
+                latest: "Finishing local job sizing before import starts.",
+            });
+            sendMigrate({
+                status: "preparing",
+                jobCount: activeJobCount,
+                message: "Finishing local job sizing before import starts.",
+            });
+        }
+        let exact = disc;
+        if (!exact) {
+            // The full account-reconciled scan (disc) is not ready yet. Do NOT read the whole local history to
+            // size a few new jobs — assemble ONLY the sessions the fast scan already flagged as pending (using
+            // the account's processed keys when we have them). This is the fast path for "start extraction".
+            try {
+                exact = discoverPendingSessionsTargeted(lastProcessedImportKeys);
+            }
+            catch (e) {
+                console.error(`Targeted local sizing failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        if (!exact) {
+            // Last resort only: the off-thread full scan, then an in-process full scan. Capped so a stalled
+            // worker can never leave extraction stuck at "finishing local job sizing".
+            exact = await withTimeout(exactDiscovery, 40_000, "SIZING_TIMEOUT").catch(() => null);
+            if (!exact) {
+                srv.setProgress({ status: "starting", total: activeJobCount, completed: 0, running: 0, queued: activeJobCount, failed: 0, extracted: 0, latest: "Sizing your sessions…" });
+                try {
+                    exact = discoverMigratableSessions();
+                }
+                catch (e) {
+                    console.error(`Direct local sizing failed: ${e instanceof Error ? e.message : String(e)}`);
+                }
+            }
+        }
+        if (!exact) {
+            srv.setProgress({
+                status: "failed",
+                total: activeJobCount,
+                completed: progressDone,
+                running: 0,
+                queued: Math.max(0, activeJobCount - progressDone - progressFailed),
+                failed: progressFailed || 1,
+                extracted: progressExtracted,
+                error: "Local session discovery did not finish.",
+            });
+            sendMigrate({ error: "IMPORT_START_FAILED", message: "Local session discovery did not finish." }, 500);
+            srv.close();
+            process.exitCode = 1;
+            return;
+        }
+        activeJobCount = exact.pending.length;
         const updateProgress = (patch) => {
             srv.setProgress({
                 status: "running",
@@ -609,15 +1197,15 @@ async function cmdLogin(flags) {
                 jobCount: activeJobCount,
                 total: activeJobCount,
                 completed: progressDone,
-                running: progressDone + progressFailed < activeJobCount ? 1 : 0,
-                queued: Math.max(0, activeJobCount - progressDone - progressFailed - 1),
+                running: Math.min(MIGRATE_CONCURRENCY, Math.max(0, activeJobCount - progressDone - progressFailed)),
+                queued: Math.max(0, activeJobCount - progressDone - progressFailed - MIGRATE_CONCURRENCY),
                 failed: progressFailed,
                 extracted: progressExtracted,
                 ...patch,
             });
         };
         try {
-            if (disc.pending.length === 0) {
+            if (exact.pending.length === 0) {
                 srv.setProgress({
                     status: "completed",
                     total: 0,
@@ -628,33 +1216,36 @@ async function cmdLogin(flags) {
                     extracted: 0,
                     latest: "No unprocessed local conversations found.",
                 });
-                respondMigrate(res, { error: "NO_PENDING_SESSIONS" }, 409);
+                sendMigrate({ error: "NO_PENDING_SESSIONS" }, 409);
                 srv.close();
                 console.log("Setup complete — no unprocessed local conversations to extract.");
                 return;
             }
-            updateProgress({ status: "starting", running: 0, queued: disc.pending.length, latest: "Creating import session." });
+            updateProgress({ status: "starting", running: 0, queued: exact.pending.length, latest: "Creating import session." });
             const controller = new AbortController();
             const h = await withTimeout(startMigration({
-                pending: disc.pending,
+                pending: exact.pending,
                 signal: controller.signal,
                 onProgress: (ev) => {
+                    let latestRepo;
                     if (ev.error) {
                         progressFailed += 1;
                     }
                     else {
                         progressDone += 1;
                         progressExtracted += ev.memories ?? 0;
+                        latestRepo = repoLabel(ev.session.cwd); // building this completed conversation belongs to
                     }
                     updateProgress({
                         latest: `${ev.session.source} ${(ev.session.firstTs || "").slice(0, 10)}${ev.error ? ` failed: ${ev.error}` : ""}`,
+                        ...(latestRepo ? { latestRepo } : {}),
                     });
                 },
             }), 30_000, "IMPORT_START_TIMEOUT", () => controller.abort());
             activeSessionId = h.sessionId;
             activeJobCount = h.jobCount;
             updateProgress({ status: "running", sessionId: h.sessionId, jobCount: h.jobCount, total: h.jobCount, capped: h.capped, latest: "Import session created." });
-            respondMigrate(res, { sessionId: h.sessionId, jobCount: h.jobCount, ...(h.capped ? { capped: h.capped } : {}) });
+            sendMigrate({ sessionId: h.sessionId, jobCount: h.jobCount, ...(h.capped ? { capped: h.capped } : {}) });
             console.log("Migrating your history… keep this terminal open until it completes.");
             console.log(`Migration metrics: ${h.metricsFile}`);
             const r = await h.done;
@@ -692,17 +1283,17 @@ async function cmdLogin(flags) {
                 error: String(e?.message || e),
             });
             if (e?.code === "NOT_LOGGED_IN")
-                respondMigrate(res, { error: "NOT_LOGGED_IN" }, 401);
+                sendMigrate({ error: "NOT_LOGGED_IN" }, 401);
             else if (e?.code === "FORBIDDEN_SCOPE")
-                respondMigrate(res, { error: "FORBIDDEN_SCOPE" }, 403);
+                sendMigrate({ error: "FORBIDDEN_SCOPE" }, 403);
             else if (e?.code === "VAULT_LOCKED")
-                respondMigrate(res, { error: "VAULT_LOCKED" }, 409);
+                sendMigrate({ error: "VAULT_LOCKED" }, 409);
             else if (e?.code === "NO_PENDING_SESSIONS")
-                respondMigrate(res, { error: "NO_PENDING_SESSIONS" }, 409);
+                sendMigrate({ error: "NO_PENDING_SESSIONS" }, 409);
             else if (e?.code === "IMPORT_START_TIMEOUT")
-                respondMigrate(res, { error: "IMPORT_START_TIMEOUT" }, 504);
+                sendMigrate({ error: "IMPORT_START_TIMEOUT" }, 504);
             else
-                respondMigrate(res, { error: "IMPORT_START_FAILED", message: String(e?.message || e) }, 500);
+                sendMigrate({ error: "IMPORT_START_FAILED", message: String(e?.message || e) }, 500);
             await new Promise((resolve) => setTimeout(resolve, 2000));
             srv.close();
             process.exitCode = 1;