@echomem/mcp 1.4.44 → 1.4.46

package/dist/setup.js

@@ -3,7 +3,7 @@
  *
  * Design goals from the spec:
  *   - `login` establishes the account and trusted device only; it never reads local history.
- *   - `init` runs one ordered flow: local-history permission, login, plan if needed, then extraction.
+ *   - `init` runs one ordered flow: local-history permission/report, login, plan if needed, then extraction.
  *   - Both secrets (API token + encryption key) ride a single browser flow and land in the local
  *     keystore — never in the client's MCP config, never in the agent's chat context.
  *   - Re-unlock after the key's TTL is one step, not a re-setup.
@@ -25,13 +25,13 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import axios from "axios";
 import { KeyStore } from "./keystore.js";
 import { fetchEncryptionConfig, deriveAndVerifyKey, setupNewEncryptionKey, verifyKeyB64 } from "./encryption.js";
-import { buildOnboardingStatsPayload } from "./onboarding-stats.js";
+import { runReport, buildStatsPayload } from "./report.js";
 import { cmdMigrate, applyAccountImportStatus, applyFastAccountImportStatus, 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 { parseSetupPreviewState } from "./setup-preview.js";
+import { repoLabel, validateForensicReportForSetup } from "./forensics.js";
 import { installSaveCheckpointHooks, installSourceSessionHooks } from "./hud/hooks.js";
-import { atomicWriteJsonObject, atomicWriteTextFile, readJsonObjectFile } from "./config-files.js";
 import { MCP_PACKAGE_LABEL, MCP_PACKAGE_NAME, MCP_PACKAGE_VERSION, MCP_UPDATE_ALL_COMMAND, MCP_UPDATE_COMMAND } from "./package-metadata.js";
 import { checkLatestUpdateStatus, compareSemver, readCachedUpdateStatus } from "./update-check.js";
 import { installHeadlessRuntimeSync, readHeadlessRuntimeInstallation, } from "./headless-runtime.js";
@@ -70,25 +70,15 @@ const CODEX_SKILL_NAMES = [
 function home(...p) {
     return path.join(os.homedir(), ...p);
 }
-function configuredProfileDirectory(envKey, fallbackName) {
-    const configured = process.env[envKey]?.trim();
+function codexHome() {
+    const configured = process.env.CODEX_HOME?.trim();
     if (!configured)
-        return home(fallbackName);
+        return home(".codex");
     if (configured === "~")
         return os.homedir();
-    if (configured.startsWith("~/") || configured.startsWith("~\\")) {
+    if (configured.startsWith(`~${path.sep}`))
         return path.join(os.homedir(), configured.slice(2));
-    }
-    if (!path.isAbsolute(configured)) {
-        throw new Error(`${envKey} must be an absolute path or start with ~/`);
-    }
-    return path.normalize(configured);
-}
-function codexHome() {
-    return configuredProfileDirectory("CODEX_HOME", ".codex");
-}
-function claudeConfigHome() {
-    return configuredProfileDirectory("CLAUDE_CONFIG_DIR", ".claude");
+    return path.resolve(configured);
 }
 function filesEqual(left, right) {
     try {
@@ -237,7 +227,7 @@ export function detectClients() {
         if (c.kind === "command")
             return fs.existsSync(c.detectDir);
         if (c.id === "claude-code")
-            return claudeCodeCliAvailable();
+            return fs.existsSync(home(".claude"));
         return false;
     });
 }
@@ -386,11 +376,11 @@ export function writeCodexConfig(configPath, entry, options = {}) {
         if (lines.slice(start, end).join("\n").trimEnd() === block)
             return "exists"; // already correct
         const next = [...lines.slice(0, start), ...block.split("\n"), ...lines.slice(end)];
-        atomicWriteTextFile(configPath, next.join("\n").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, ""));
+        fs.writeFileSync(configPath, next.join("\n").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, ""));
         return "wrote"; // replaced a stale entry → caller tells the user to restart Codex
     }
     const sep = content ? (content.endsWith("\n") ? "\n" : "\n\n") : "";
-    atomicWriteTextFile(configPath, content + sep + block + "\n");
+    fs.appendFileSync(configPath, sep + block + "\n");
     return "wrote";
 }
 /**
@@ -411,7 +401,7 @@ function echomemGuidanceBlock() {
         "- EchoMem's local SessionStart hook automatically binds each new Codex or Claude Code conversation to its real source-session ID. Use `bind_source_session` with a fresh UUID only as a compatibility fallback when the hook is unavailable or reports that the session is unbound.",
         "- Before re-deriving past decisions, project context, or anything the user likely settled before: call `search_memories` first.",
         '- If the final user-facing answer materially relies on one or more EchoMem memories, end it with a compact `EchoMem sources:` list containing only the memories actually used. Link each memory key to its canonical `https://echoknows.com/memory/<memory-id>` URL. Do not cite memories that were merely retrieved, and omit the section when no memory informed the answer.',
-        "- Before the final response for a task that produced a durable decision, confirmed preference, implementation, resolved bug, commit, passing verification, release, or project milestone: call `save_conversation`. This private checkpoint does not require a separate user request. Do not save secrets, credentials, incidental chatter, or trivial read-only work. If a qualifying save fails because the encrypted vault is locked, relay the bridge's unlock instruction; for this standalone runtime, use `echomem-mcp unlock`. Never silently skip it.",
+        "- Before the final response for a task that produced a durable decision, confirmed preference, implementation, resolved bug, commit, passing verification, release, or project milestone: call `save_conversation`. This private checkpoint does not require a separate user request. Do not save secrets, credentials, incidental chatter, or trivial read-only work. If a qualifying save fails because the encrypted vault is locked, tell the user to open Echo Desktop and unlock the vault there; on a headless system, use `echomem-mcp unlock`. Never silently skip it.",
         '- After `save_conversation` succeeds and returns one or more saved memory IDs, make the save visible in the final user-facing answer with a compact `EchoMem saved:` list containing every memory created by that call. Link each memory key to its canonical `https://echoknows.com/memory/<memory-id>` URL. This save receipt is separate from `EchoMem sources:` and does not imply the newly saved memories informed the answer.',
         "- For a user with a company group, call `request_group_session_sharing` near conversation start or after a qualifying private save. On the first call in a conversation, omit `groupSharingScopeId` so EchoMem mints a fresh opaque scope. Reuse that exact scope only in this conversation for later get/request/set/save calls, and never persist it as memory. If multiple groups are returned, reuse the same scope and call once per `groupId`. Relay the tool's exact text question and call `set_group_session_sharing` only after an explicit Yes/No. Silence leaves that group's state unset; never infer an answer. Saves sync eligible memories to every approved group; a No keeps them private for that group.",
         "- If the user pastes a session carryover/checkpoint: it may reference `get_checkpoint_by_context` — use it to pull the checkpoint/decision trail when you need more than the snapshot.",
@@ -422,7 +412,7 @@ function echomemGuidanceBlock() {
         "- Group sharing is scoped to an opaque id carried only in the current conversation, not to the MCP transport session. Membership is rechecked for each sync. Flagged memories are withheld from automatic conversation sync and remain private.",
         "- If a user asks to create a group, call `create_memory_group`; if they ask for a code to share, call `create_group_invite` and return the secret invite code only to that user. Never save the invite code to memory or include it in logs, analytics, summaries, or unrelated output.",
         "- If a user supplies an `echo_grp_...` code and explicitly asks to join, call `join_memory_group`. Joining never authorizes publishing by itself and must not move a user out of another group. After joining, continue into the profile-and-publication preview instead of leaving title or responsibility blank.",
-        "- For requests such as “prepare my recent work memories,” “upload work from this ticket,” or “publish work since my last sync,” call `prepare_group_publication` first. This is a no-publication preview. For encrypted accounts, relay the bridge's local unlock instruction if the tool reports that the key is required.",
+        "- For requests such as “prepare my recent work memories,” “upload work from this ticket,” or “publish work since my last sync,” call `prepare_group_publication` first. This is a no-publication preview. For encrypted accounts, tell the user to open Echo Desktop and unlock the vault there if the tool reports that the key is required.",
         "- After preparing, select only exact candidate memory IDs that match the user's stated scope and exclude already-published or exact-content duplicates. Use the candidate evidence to draft a concise title and responsibility summary for the current member, but label both as proposals rather than facts.",
         "- Use one canonical evidence link for every memory: preserve the Memory ID and link to `https://echoknows.com/memory/<memory-id>`. The site resolves the authorized representation: an owner is sent to their private timeline, while current group/friend access opens an authorized publication snapshot or public memory. The visible Markdown label should use the memory key, not the raw URL or UUID.",
         "- If the user asks to flag memories about a sensitive topic, search their own memories first, show the exact matches with owner-only personal links, and ask them to confirm. Only then call `flag_memories_for_publication_attention`; flagging does not publish, decrypt, change visibility, or retract an existing group snapshot.",
@@ -447,56 +437,41 @@ export function writeAgentsMemoryGuidance(filePath) {
         const current = content.slice(start, end + AGENTS_MD_END.length);
         if (current === block)
             return "exists";
-        atomicWriteTextFile(filePath, content.slice(0, start) + block + content.slice(end + AGENTS_MD_END.length));
+        fs.writeFileSync(filePath, content.slice(0, start) + block + content.slice(end + AGENTS_MD_END.length));
         return "updated";
     }
     const sep = content ? (content.endsWith("\n") ? "\n" : "\n\n") : "";
-    atomicWriteTextFile(filePath, content + sep + block + "\n");
+    fs.appendFileSync(filePath, sep + block + "\n");
     return "wrote";
 }
-/**
- * Refresh marker-owned guidance for users upgrading an existing standalone MCP install.
- * This intentionally does not create global memory files: setup owns first installation,
- * while server startup only migrates guidance that EchoMem already installed.
- */
-export function refreshInstalledMemoryGuidance() {
-    let candidates;
+/** Merge the EchoMem entry into a JSON client's `mcpServers` map without clobbering siblings. */
+export function writeJsonClientConfig(configPath, entry, options = {}) {
+    let config = {};
     try {
-        candidates = [
-            path.join(codexHome(), "AGENTS.md"),
-            path.join(claudeConfigHome(), "CLAUDE.md"),
-        ];
+        config = JSON.parse(fs.readFileSync(configPath, "utf8"));
     }
     catch {
-        return;
-    }
-    for (const filePath of candidates) {
-        try {
-            const content = fs.readFileSync(filePath, "utf8");
-            const start = content.indexOf(AGENTS_MD_BEGIN);
-            const end = content.indexOf(AGENTS_MD_END);
-            if (start >= 0 && end > start)
-                writeAgentsMemoryGuidance(filePath);
-        }
-        catch {
-            // Missing, unreadable, or externally managed files are left untouched.
-        }
+        /* fresh config */
     }
-}
-/** Merge the EchoMem entry into a JSON client's `mcpServers` map without clobbering siblings. */
-export function writeJsonClientConfig(configPath, entry, options = {}) {
-    const config = readJsonObjectFile(configPath, "MCP client configuration");
-    const servers = objectRecord(config.mcpServers) ?? {};
-    config.mcpServers = servers;
-    if (!options.forceHeadless && validDesktopManagedEntry(servers.echomem)) {
+    config.mcpServers = config.mcpServers || {};
+    if (!options.forceHeadless && validDesktopManagedEntry(config.mcpServers.echomem)) {
         return "desktop-managed";
     }
-    servers.echomem = entry;
-    atomicWriteJsonObject(configPath, config);
+    config.mcpServers.echomem = entry;
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
     return "wrote";
 }
 function readClaudeCodeConfigFile(configPath) {
-    return readJsonObjectFile(configPath, "Claude Code user configuration");
+    try {
+        const parsed = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
 }
 function echoMemEntryFromServers(value) {
     return objectRecord(objectRecord(value)?.echomem);
@@ -530,48 +505,65 @@ function claudeCodeLocalEchoMemProjects(configPath) {
         .map(([projectPath]) => projectPath)
         .sort();
 }
-/**
- * Run Claude Code without assuming its launcher is a native executable. npm installs expose
- * `claude.cmd` on Windows, and Node cannot execute .cmd/.bat launchers through execFileSync
- * directly. Resolve the command with `where.exe` and route command files through ComSpec while
- * keeping native .exe installations on the direct exec path.
- */
-function execClaudeCodeSync(args, options) {
-    if (process.platform !== "win32")
-        return execFileSync("claude", args, options);
-    let command = "claude";
+function versionedClaudeCodeExecutables(root, executable) {
+    let versions;
     try {
-        const resolved = execFileSync("where.exe", ["claude"], {
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-            timeout: 3000,
-            windowsHide: true,
-        })
-            .split(/\r?\n/)
-            .map((candidate) => candidate.trim())
-            .find(Boolean);
-        if (resolved)
-            command = resolved;
+        versions = fs.readdirSync(root, { withFileTypes: true });
     }
     catch {
-        // Preserve the normal command-not-found failure below so callers can report it consistently.
-    }
-    if (/\.(cmd|bat)$/i.test(command)) {
-        const shellCommand = [escapeWindowsCmdCommand(command), ...args.map(escapeWindowsCmdArgument)].join(" ");
-        const spawnOptions = {
-            ...options,
-            windowsHide: true,
-            windowsVerbatimArguments: true,
-        };
-        const result = spawnSync(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", `"${shellCommand}"`], spawnOptions);
-        if (result.error)
-            throw result.error;
-        if (result.status !== 0) {
-            throw new Error(result.stderr?.trim() || `Claude Code exited with status ${result.status ?? "unknown"}.`);
+        return [];
+    }
+    return versions
+        .filter((entry) => entry.isDirectory())
+        .sort((left, right) => right.name.localeCompare(left.name, undefined, { numeric: true }))
+        .map((entry) => path.join(root, entry.name, executable))
+        .filter((candidate) => fs.existsSync(candidate));
+}
+/**
+ * Return every safe Claude Code launcher location worth trying. Claude Desktop bundles the CLI,
+ * but Windows Store/MSIX installs expose its real files below the package LocalCache instead of
+ * the caller's ordinary APPDATA/PATH view.
+ */
+export function claudeCodeCommandCandidates(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? os.homedir();
+    const candidates = [];
+    const configured = env.CLAUDE_CODE_EXECUTABLE?.trim();
+    if (configured)
+        candidates.push(configured);
+    candidates.push("claude");
+    if (platform === "win32") {
+        const appData = env.APPDATA?.trim() || path.join(homeDir, "AppData", "Roaming");
+        const localAppData = env.LOCALAPPDATA?.trim() || path.join(homeDir, "AppData", "Local");
+        candidates.push(...versionedClaudeCodeExecutables(path.join(appData, "Claude", "claude-code"), "claude.exe"), ...versionedClaudeCodeExecutables(path.join(localAppData, "Claude", "claude-code"), "claude.exe"));
+        const packagesRoot = path.join(localAppData, "Packages");
+        try {
+            for (const entry of fs.readdirSync(packagesRoot, { withFileTypes: true })) {
+                if (!entry.isDirectory() || !/^Claude_/i.test(entry.name))
+                    continue;
+                candidates.push(...versionedClaudeCodeExecutables(path.join(packagesRoot, entry.name, "LocalCache", "Roaming", "Claude", "claude-code"), "claude.exe"));
+            }
+        }
+        catch {
+            /* A non-Store install has no Packages directory. */
+        }
+        const executionAlias = path.join(localAppData, "Microsoft", "WindowsApps", "claude.exe");
+        if (fs.existsSync(executionAlias))
+            candidates.push(executionAlias);
+    }
+    else if (platform === "darwin") {
+        for (const candidate of [
+            "/Applications/Claude.app/Contents/Resources/claude",
+            path.join(homeDir, "Applications", "Claude.app", "Contents", "Resources", "claude"),
+            "/opt/homebrew/bin/claude",
+            "/usr/local/bin/claude",
+        ]) {
+            if (fs.existsSync(candidate))
+                candidates.push(candidate);
         }
-        return result.stdout || "";
     }
-    return execFileSync(command, args, { ...options, windowsHide: true });
+    return [...new Set(candidates)];
 }
 function escapeWindowsCmdCommand(value) {
     return value.replace(/([()\][%!^"`<>&|;, *?])/g, "^$1");
@@ -583,25 +575,53 @@ function escapeWindowsCmdArgument(value) {
     escaped = `"${escaped}"`;
     return escaped.replace(/([()\][%!^"`<>&|;, *?])/g, "^$1");
 }
-export function claudeCodeCliAvailable() {
-    try {
-        execClaudeCodeSync(["--version"], {
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-            timeout: 3000,
-        });
-        return true;
+function execClaudeCodeSync(args, options, commandCandidates) {
+    let candidates = commandCandidates ? [...commandCandidates] : claudeCodeCommandCandidates();
+    if (process.platform === "win32" && !commandCandidates) {
+        try {
+            const pathMatches = execFileSync("where.exe", ["claude"], {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 3000,
+                windowsHide: true,
+            }).split(/\r?\n/).map((candidate) => candidate.trim()).filter(Boolean);
+            candidates = [...new Set([...pathMatches, ...candidates])];
+        }
+        catch {
+            /* The bundled Desktop candidates below remain available. */
+        }
     }
-    catch {
-        return false;
+    let lastError = new Error("Claude Code CLI was not found.");
+    for (const command of candidates) {
+        try {
+            if (process.platform === "win32" && /\.(cmd|bat)$/i.test(command)) {
+                const shellCommand = [escapeWindowsCmdCommand(command), ...args.map(escapeWindowsCmdArgument)].join(" ");
+                const spawnOptions = {
+                    ...options,
+                    windowsHide: true,
+                    windowsVerbatimArguments: true,
+                };
+                const result = spawnSync(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", `"${shellCommand}"`], spawnOptions);
+                if (result.error)
+                    throw result.error;
+                if (result.status !== 0) {
+                    throw new Error(result.stderr?.trim() || `Claude Code exited with status ${result.status ?? "unknown"}.`);
+                }
+                return result.stdout || "";
+            }
+            return execFileSync(command, args, process.platform === "win32" ? { ...options, windowsHide: true } : options);
+        }
+        catch (error) {
+            lastError = error;
+        }
     }
+    throw lastError;
 }
 export function writeClaudeCodeConfig(entry, options = {}) {
     // EchoMem belongs at user scope so every Claude Code project resolves the same durable runtime.
     // Older CLI versions wrote local/project entries, which take precedence over user scope and can
     // keep launching a deleted npm cache or stale runtime. Migrate those only after user scope is safe.
     const configPath = options.configPath ?? home(".claude.json");
-    let failureReason;
     const emptyResult = () => ({
         state: "unavailable",
         removedLocalProjects: [],
@@ -609,7 +629,6 @@ export function writeClaudeCodeConfig(entry, options = {}) {
         failedLocalProjects: [],
         restoredPreviousUserEntry: false,
         preservedDesktopManaged: false,
-        failureReason,
     });
     const runClaude = (args, cwd) => {
         try {
@@ -618,12 +637,10 @@ export function writeClaudeCodeConfig(entry, options = {}) {
                 encoding: "utf8",
                 stdio: ["ignore", "pipe", "pipe"],
                 timeout: 10000,
-            });
-            failureReason = undefined;
+            }, options.claudeCommands);
             return true;
         }
-        catch (error) {
-            failureReason = commandFailureMessage(error);
+        catch {
             return false;
         }
     };
@@ -642,10 +659,8 @@ export function writeClaudeCodeConfig(entry, options = {}) {
         if (previousUserEntry && !removeUser())
             return emptyResult();
         if (!addUser(desiredUserEntry)) {
-            const addFailureReason = failureReason;
             if (previousUserEntry)
                 restoredPreviousUserEntry = addUser(previousUserEntry);
-            failureReason = addFailureReason;
             return { ...emptyResult(), restoredPreviousUserEntry };
         }
     }
@@ -859,7 +874,7 @@ function inspectClientConfig(client, desiredVersion) {
     };
 }
 function inspectClaudeCodeConfig(client, desiredVersion) {
-    if (!fs.existsSync(claudeConfigHome()) && !claudeCodeCliAvailable())
+    if (!fs.existsSync(home(".claude")))
         return null;
     try {
         const output = execClaudeCodeSync(["mcp", "list"], {
@@ -942,23 +957,6 @@ function openBrowser(url) {
     }
 }
 function openClaudeDesktop() {
-    if (process.platform === "win32") {
-        try {
-            spawn(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", "start \"\" \"claude://\""], {
-                detached: true,
-                stdio: "ignore",
-                windowsHide: true,
-            }).unref();
-            return { ok: true, message: "Opened Claude Desktop. The prompt is copied - paste it into Claude." };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                message: "Could not auto-open Claude Desktop. The prompt is copied - open Claude Desktop and paste it.",
-                detail: commandFailureMessage(error),
-            };
-        }
-    }
     if (process.platform !== "darwin") {
         return { ok: false, message: "Could not auto-open Claude on this system. The prompt is copied - open Claude Desktop and paste it." };
     }
@@ -990,11 +988,12 @@ function openClaudeDesktop() {
     };
 }
 const LOCAL_SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const LOCAL_COWORK_SESSION_ID_RE = /^local_[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 // `claude --resume <id>` only finds sessions that belong to the current project directory, so
 // recover the session's original cwd from its transcript before resuming.
 function claudeSessionCwd(sessionId) {
     try {
-        const projectsDir = path.join(claudeConfigHome(), "projects");
+        const projectsDir = path.join(os.homedir(), ".claude", "projects");
         for (const dir of fs.readdirSync(projectsDir)) {
             const file = path.join(projectsDir, dir, `${sessionId}.jsonl`);
             if (!fs.existsSync(file))
@@ -1020,40 +1019,20 @@ function shellQuote(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function openExistingAgentSession(source, sessionId) {
-    if (!LOCAL_SESSION_ID_RE.test(sessionId))
+    const validSessionId = source === "claude-desktop"
+        ? LOCAL_COWORK_SESSION_ID_RE.test(sessionId)
+        : LOCAL_SESSION_ID_RE.test(sessionId);
+    if (!validSessionId)
         return { ok: false, message: "The local session identifier is invalid." };
+    if (source !== "claude-desktop" && process.platform !== "darwin") {
+        return { ok: false, message: "Opening local Codex and Claude Code sessions is currently available on macOS." };
+    }
     try {
         if (source === "codex") {
-            const url = `codex://threads/${sessionId}`;
-            if (process.platform === "win32") {
-                spawn(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", `start "" "${url}"`], {
-                    detached: true,
-                    stdio: "ignore",
-                    windowsHide: true,
-                }).unref();
-            }
-            else if (process.platform === "darwin") {
-                execFileSync("open", [url], { stdio: "pipe" });
-            }
-            else {
-                return { ok: false, message: "Opening local Codex sessions is not supported on this system yet." };
-            }
+            execFileSync("open", [`codex://threads/${sessionId}`], { stdio: "pipe" });
             return { ok: true, message: "Opened the original session in Codex." };
         }
         if (source === "claude-code") {
-            if (process.platform === "win32") {
-                const cwd = claudeSessionCwd(sessionId);
-                spawn(process.env.ComSpec || "cmd.exe", ["/d", "/k", `claude --resume ${sessionId}`], {
-                    cwd: cwd && fs.existsSync(cwd) ? cwd : process.cwd(),
-                    detached: true,
-                    stdio: "ignore",
-                    windowsHide: false,
-                }).unref();
-                return { ok: true, message: "Opened the original Claude Code session in a terminal." };
-            }
-            if (process.platform !== "darwin") {
-                return { ok: false, message: "Opening local Claude Code sessions is not supported on this system yet." };
-            }
             const claude = firstExisting(["/opt/homebrew/bin/claude", "/usr/local/bin/claude"]) || "claude";
             const cwd = claudeSessionCwd(sessionId);
             const resume = `${claude} --resume ${sessionId}`;
@@ -1064,6 +1043,23 @@ function openExistingAgentSession(source, sessionId) {
             ], { stdio: "pipe" });
             return { ok: true, message: "Opened the original Claude Code session in Terminal." };
         }
+        if (source === "claude-desktop") {
+            const url = `claude://claude.ai/claude-code-desktop/${sessionId}`;
+            if (process.platform === "win32") {
+                spawn(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", `start "" "${url}"`], {
+                    detached: true,
+                    stdio: "ignore",
+                    windowsHide: true,
+                }).unref();
+            }
+            else if (process.platform === "darwin") {
+                execFileSync("open", [url], { stdio: "pipe" });
+            }
+            else {
+                return { ok: false, message: "Opening local Cowork sessions is not supported on this system yet." };
+            }
+            return { ok: true, message: "Opened the original Cowork session in Claude Desktop." };
+        }
         return { ok: false, message: "Unsupported agent session source." };
     }
     catch (error) {
@@ -1104,7 +1100,8 @@ function migratableFromDiscovery(disc) {
         pending: disc.pending.length,
         pendingTotal: disc.pendingTotal,
         pendingCodex,
-        pendingClaudeCode: disc.pendingClaudeCode ?? disc.pending.length - pendingCodex,
+        pendingClaudeCode: disc.pendingClaudeCode ?? disc.pending.filter((s) => s.source === "claude-code").length,
+        pendingCowork: disc.pendingCowork ?? disc.pending.filter((s) => s.source === "claude-desktop").length,
         alreadyMigrated: disc.alreadyMigrated,
         skippedActive: disc.skippedActive,
         limited: disc.limited,
@@ -1123,7 +1120,8 @@ function sessionsFromDiscovery(disc) {
     return {
         total: disc.sessions.length,
         codex: disc.codexCount,
-        claudeCode: disc.claudeCount,
+        claudeCode: disc.claudeCodeCount,
+        cowork: disc.coworkCount,
     };
 }
 function migratableFromFastSummary(summary) {
@@ -1132,6 +1130,7 @@ function migratableFromFastSummary(summary) {
         pendingTotal: summary.pendingTotal,
         pendingCodex: summary.pendingCodex,
         pendingClaudeCode: summary.pendingClaudeCode,
+        pendingCowork: summary.pendingCowork,
         alreadyMigrated: summary.alreadyMigrated,
         skippedActive: summary.skippedActive,
         eta: summary.eta,
@@ -1224,7 +1223,7 @@ function withTimeout(promise, ms, code, onTimeout) {
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const LOCAL_ASSET_TYPES = {
+const CITY_ASSET_TYPES = {
     ".html": "text/html; charset=utf-8",
     ".js": "text/javascript; charset=utf-8",
     ".json": "application/json; charset=utf-8",
@@ -1233,11 +1232,39 @@ const LOCAL_ASSET_TYPES = {
     ".png": "image/png",
     ".svg": "image/svg+xml",
 };
-function repoLabel(cwd) {
-    if (!cwd)
-        return "";
-    const normalized = cwd.replace(/[\\/]+$/, "");
-    return path.basename(normalized) || normalized;
+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));
+    // Archives stay in the checkout for recovery, but must never become a localhost UI surface.
+    const normalizedRel = rel.replace(/\\/g, "/");
+    if (normalizedRel === "archive" || normalizedRel.startsWith("archive/")) {
+        res.writeHead(404).end("not found");
+        return true;
+    }
+    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 hudAssetsRoot() {
     return fileURLToPath(new URL("../assets/hud/", import.meta.url));
@@ -1256,7 +1283,7 @@ function serveHudAsset(reqPath, res) {
         return true;
     }
     res.writeHead(200, {
-        "Content-Type": LOCAL_ASSET_TYPES[path.extname(filePath)] || "application/octet-stream",
+        "Content-Type": CITY_ASSET_TYPES[path.extname(filePath)] || "application/octet-stream",
         "Cache-Control": "no-store",
     });
     fs.createReadStream(filePath).pipe(res);
@@ -1433,6 +1460,61 @@ export function discoverMigratableFastOffThread(opts = {}) {
         });
     });
 }
+/** Build the full local-history dashboard payload away from the callback server's event loop.
+ * `collect()` can synchronously parse hundreds of JSONL files for tens of seconds; doing that on
+ * the bridge thread prevents even localhost actions such as account switch from receiving a reply. */
+export function buildCollectedStatsPayloadOffThread(inject) {
+    const reportUrl = runtimeModuleUrl("report");
+    const serializedInject = JSON.stringify(inject);
+    const code = `
+    import { parentPort } from "node:worker_threads";
+    import { collect, buildStatsPayload } from ${JSON.stringify(reportUrl)};
+
+    try {
+      const payload = await buildStatsPayload(collect(), ${serializedInject});
+      parentPort?.postMessage({ ok: true, payload });
+    } 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;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            void worker.terminate();
+            if (result.ok)
+                resolve(result.payload);
+            else
+                reject(result.error);
+        };
+        worker.once("message", (message) => {
+            const msg = message;
+            if (msg.ok === true) {
+                finish({ ok: true, payload: msg.payload });
+                return;
+            }
+            const error = new Error(typeof msg.message === "string" ? msg.message : "Full local stats worker failed");
+            if (typeof msg.stack === "string")
+                error.stack = msg.stack;
+            finish({ ok: false, error });
+        });
+        worker.once("error", (error) => {
+            finish({ ok: false, error });
+        });
+        worker.once("exit", (code) => {
+            if (settled)
+                return;
+            finish({ ok: false, error: new Error(`Full local stats worker exited (code ${code}) without a result`) });
+        });
+    });
+}
 export function createLocalDiscoveryCache(loaders = {}) {
     const loadQuick = loaders.loadQuick ?? (() => discoverMigratableFastOffThread());
     const loadExact = loaders.loadExact ?? (() => discoverMigratableSessionsOffThread());
@@ -1481,6 +1563,45 @@ export function createLocalDiscoveryCache(loaders = {}) {
         },
     };
 }
+function forensicStageLabel(stage) {
+    if (stage === "reading-transcripts")
+        return "Reading transcript files";
+    if (stage === "building-summary")
+        return "Building scan summary";
+    if (stage === "classifying-repeated-context")
+        return "Classifying repeated context";
+    if (stage === "finalizing-report")
+        return "Finalizing report";
+    return "Starting local scan";
+}
+/** 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). */
+export function buildForensicReportOffThread(onProgress, options = {}) {
+    let lastProgress = null;
+    const recordProgress = (progress) => {
+        lastProgress = progress;
+        onProgress?.(progress);
+    };
+    return runForensicReportWorker(recordProgress, options).catch(async (primaryError) => {
+        if (options.failOpen === false)
+            throw primaryError;
+        const failureCode = errorCode(primaryError) || "REPORT_BUILD_FAILED";
+        console.error(`[echomem] local scan degraded after ${failureCode}; continuing without local-history analysis`);
+        onProgress?.({
+            done: lastProgress?.done || 0,
+            total: lastProgress?.total || 0,
+            stage: "finalizing-report",
+            detail: "finishing setup without optional local-history analysis",
+            overall: 0.99,
+            stageDone: 0,
+            stageTotal: 0,
+        });
+        return runForensicReportWorker(undefined, {
+            timeoutMs: 30_000,
+            maxOldGenerationSizeMb: Math.max(64, options.maxOldGenerationSizeMb || 0),
+        }, [], failureCode);
+    });
+}
 function errorCode(error) {
     return error && typeof error === "object" && "code" in error
         ? String(error.code || "")
@@ -1498,8 +1619,9 @@ export function completeOptionalStatsPayload(payload, reason, countsTrusted) {
         generatedFrom: ["~/.codex/sessions", "~/.claude/projects"],
         llmCallsUsed: 0,
         transcriptsUploaded: false,
-        sessions: { total: 0, codex: 0, claudeCode: 0 },
+        sessions: { total: 0, codex: 0, claudeCode: 0, cowork: 0 },
         migratable: { pending: 0, alreadyMigrated: 0 },
+        memoriesCaptured: null,
     };
     const completed = payload && typeof payload === "object" && !Array.isArray(payload)
         ? { ...payload }
@@ -1512,11 +1634,155 @@ export function completeOptionalStatsPayload(payload, reason, countsTrusted) {
     };
     return completed;
 }
+function runForensicReportWorker(onProgress, options, sources, degradedReason) {
+    const forensicsUrl = runtimeModuleUrl("forensics");
+    const serializedSources = sources === undefined ? "undefined" : JSON.stringify(sources);
+    const serializedDegradedReason = JSON.stringify(degradedReason || "");
+    const code = `
+    import { parentPort } from "node:worker_threads";
+    import { buildForensicReport, validateForensicReportForSetup } from ${JSON.stringify(forensicsUrl)};
+    try {
+      const report = await buildForensicReport({
+        sources: ${serializedSources},
+        includeLegacyGoldenStandard: false,
+        onProgress: (done, total, stage, detail, overall, stageDone, stageTotal) => parentPort?.postMessage({
+          progress: { done, total, stage, detail, overall, stageDone, stageTotal },
+        }),
+      });
+      const degradedReason = ${serializedDegradedReason};
+      if (degradedReason) {
+        report.scanDiagnostics = {
+          degraded: true,
+          reason: degradedReason,
+          skippedSources: ["codex", "claude"],
+        };
+      }
+      const validation = validateForensicReportForSetup(report);
+      if (!validation.ok) {
+        const error = new Error(validation.message);
+        error.code = validation.code;
+        throw error;
+      }
+      parentPort?.postMessage({ ok: true, report });
+    } catch (error) {
+      parentPort?.postMessage({
+        ok: false,
+        message: error instanceof Error ? error.message : String(error),
+        code: error && typeof error === "object" && "code" in error ? String(error.code || "") : "",
+      });
+    }
+  `;
+    const requestedHeapMb = options.maxOldGenerationSizeMb;
+    const worker = new Worker(new URL(`data:text/javascript;charset=utf-8,${encodeURIComponent(code)}`), Number.isFinite(requestedHeapMb)
+        ? { resourceLimits: { maxOldGenerationSizeMb: Math.max(16, Math.floor(requestedHeapMb)) } }
+        : undefined);
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const requestedTimeoutMs = options.timeoutMs ?? 15 * 60_000;
+        const timeoutMs = Number.isFinite(requestedTimeoutMs) ? Math.max(1, requestedTimeoutMs) : 15 * 60_000;
+        const timeout = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            void worker.terminate();
+            const error = new Error(`Local forensic report timed out after ${timeoutMs}ms`);
+            error.code = "REPORT_SCAN_TIMEOUT";
+            reject(error);
+        }, timeoutMs);
+        timeout.unref?.();
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            void worker.terminate();
+            if (result.ok)
+                resolve(result.report);
+            else
+                reject(result.error);
+        };
+        worker.on("message", (message) => {
+            if (settled)
+                return;
+            const msg = message;
+            if (msg.progress) {
+                onProgress?.(msg.progress);
+                return;
+            }
+            if (msg.ok === true && msg.report && typeof msg.report === "object") {
+                finish({ ok: true, report: msg.report });
+                return;
+            }
+            const error = new Error(typeof msg.message === "string" ? msg.message : "Local forensic report failed");
+            if (typeof msg.code === "string" && msg.code)
+                error.code = msg.code;
+            finish({ ok: false, error });
+        });
+        worker.once("error", (error) => {
+            finish({ ok: false, error });
+        });
+        worker.once("exit", (code) => {
+            if (settled)
+                return;
+            finish({ ok: false, error: new Error(`Forensic report worker exited (code ${code}) without a result`) });
+        });
+    });
+}
 export function respondMigrate(res, body, status = 200) {
     if (res.writableEnded)
         return;
     res.writeHead(status, { "Content-Type": "application/json" }).end(JSON.stringify(body));
 }
+function safeForensicError(error) {
+    const code = error && typeof error === "object" && "code" in error
+        ? String(error.code || "")
+        : "";
+    if (code === "REPORT_SCAN_TIMEOUT") {
+        return {
+            code,
+            message: "The local workspace scan took too long and was stopped. No backup data was substituted. Rerun setup to retry.",
+        };
+    }
+    return {
+        code: "REPORT_BUILD_FAILED",
+        message: "EchoMem could not finish the local workspace scan. No backup data was substituted. Rerun setup to retry.",
+    };
+}
+function publicRunningForensicProgress(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const progress = value;
+    if (progress.status !== "running")
+        return null;
+    const safeCount = (candidate) => (typeof candidate === "number" && Number.isFinite(candidate) && candidate >= 0
+        ? Math.floor(candidate)
+        : 0);
+    const safeDuration = (candidate) => (typeof candidate === "number" && Number.isFinite(candidate) && candidate >= 0
+        ? candidate
+        : 0);
+    const safeFraction = (candidate) => (typeof candidate === "number" && Number.isFinite(candidate)
+        ? Math.min(1, Math.max(0, candidate))
+        : 0);
+    const total = safeCount(progress.total);
+    const stageTotal = safeCount(progress.stageTotal);
+    const rawStage = typeof progress.stage === "string" ? progress.stage : "starting";
+    const stage = ["starting", "reading-transcripts", "building-summary", "classifying-repeated-context", "finalizing-report"].includes(rawStage)
+        ? rawStage
+        : "starting";
+    return {
+        status: "running",
+        scanned: total > 0 ? Math.min(safeCount(progress.scanned), total) : 0,
+        total,
+        stage,
+        label: forensicStageLabel(stage),
+        stageDone: stageTotal > 0 ? Math.min(safeCount(progress.stageDone), stageTotal) : 0,
+        stageTotal,
+        overall: safeFraction(progress.overall),
+        elapsedMs: safeDuration(progress.elapsedMs),
+        stageElapsedMs: safeDuration(progress.stageElapsedMs),
+        updatedAt: safeDuration(progress.updatedAt) || Date.now(),
+    };
+}
 /**
  * Start the persistent localhost bridge used by the setup page. It sends/verifies OTP through the
  * hosted API, accepts the local passphrase, serves local Wrapped stats, and holds the /migrate
@@ -1529,11 +1795,12 @@ export function startCallbackServer(opts = {}) {
         : `${Math.ceil(timeoutMs / 1000)} seconds`;
     const dashboardTimeoutMs = 4 * 60 * 60 * 1000;
     const expectedNonce = opts.nonce;
+    const scanId = opts.scanId ?? randomUUID();
     const flow = opts.flow ?? "onboarding";
     const isLoginFlow = flow === "login";
     // A login screen must not be blocked by a local-history permission. That permission belongs to
     // onboarding and is intentionally enforced separately below.
-    const requiresLocalHistoryConsent = opts.requireLocalHistoryConsent === true && !isLoginFlow;
+    const requiresReportConsent = opts.requireReportConsent === true && !isLoginFlow;
     return new Promise((resolveOuter, rejectOuter) => {
         const onToken = deferred();
         const setupExit = deferred();
@@ -1546,7 +1813,7 @@ export function startCallbackServer(opts = {}) {
         let activeDeviceToken = opts.initialToken?.token || "";
         let activeAccountEmail = "";
         let pendingLocalAuth = null;
-        let localHistoryConsentGranted = !requiresLocalHistoryConsent;
+        let reportConsentGranted = !requiresReportConsent;
         let progress = { status: "idle", total: 0, completed: 0, running: 0, queued: 0, failed: 0, extracted: 0 };
         let migrateStarted = false;
         let tokenRefreshHandler = null;
@@ -1613,7 +1880,7 @@ export function startCallbackServer(opts = {}) {
         const handleCallback = (res, token, key, nonce) => {
             if (!checkNonce(nonce))
                 return void text(res, 403, "bad nonce");
-            if (requiresLocalHistoryConsent && !localHistoryConsentGranted) {
+            if (requiresReportConsent && !reportConsentGranted) {
                 return void json(res, 403, {
                     error: "LOCAL_HISTORY_CONSENT_REQUIRED",
                     message: "Allow local history access in the setup page before connecting EchoMem.",
@@ -1643,7 +1910,7 @@ export function startCallbackServer(opts = {}) {
                 text(res, 403, "bad nonce");
                 return true;
             }
-            if (requiresLocalHistoryConsent && !localHistoryConsentGranted) {
+            if (requiresReportConsent && !reportConsentGranted) {
                 json(res, 403, {
                     error: "LOCAL_HISTORY_CONSENT_REQUIRED",
                     message: "Allow local history access in the setup page before connecting EchoMem.",
@@ -1670,7 +1937,8 @@ export function startCallbackServer(opts = {}) {
             armTimeout();
         };
         const isOnboardingOnlyRoute = (route) => [
-            "/local-history-consent",
+            "/report-consent",
+            "/report",
             "/stats",
             "/billing-status",
             "/billing-checkout",
@@ -1863,6 +2131,10 @@ export function startCallbackServer(opts = {}) {
                         message: "Run `echomem-mcp init` to access local-history onboarding.",
                     });
                 }
+                if ((route === "/city" || route.startsWith("/city/")) && req.method === "GET") {
+                    serveRepoCityAsset(route, res);
+                    return;
+                }
                 if (route.startsWith("/hud-assets/") && req.method === "GET") {
                     serveHudAsset(route, res);
                     return;
@@ -1900,13 +2172,8 @@ export function startCallbackServer(opts = {}) {
                         localOnly: true,
                         localAuth: true,
                         workspacePath: process.cwd(),
-                        consentRequired: requiresLocalHistoryConsent,
-                        consentGranted: localHistoryConsentGranted,
-                        platform: process.platform,
-                        capabilities: {
-                            openClaudeDesktop: process.platform === "darwin" || process.platform === "win32",
-                            openAgentSessions: process.platform === "darwin" || process.platform === "win32",
-                        },
+                        consentRequired: requiresReportConsent,
+                        consentGranted: reportConsentGranted,
                     });
                     return;
                 }
@@ -2010,7 +2277,7 @@ export function startCallbackServer(opts = {}) {
                 if (route === "/stats" && req.method === "GET") {
                     if (!checkNonce(url.searchParams.get("nonce") || undefined))
                         return void text(res, 403, "bad nonce");
-                    if (requiresLocalHistoryConsent && !localHistoryConsentGranted) {
+                    if (requiresReportConsent && !reportConsentGranted) {
                         return void json(res, 403, {
                             error: "LOCAL_HISTORY_CONSENT_REQUIRED",
                             message: "Allow local history access before continuing setup.",
@@ -2026,7 +2293,7 @@ export function startCallbackServer(opts = {}) {
                     res.setHeader("Cache-Control", "no-store, max-age=0");
                     if (!checkNonce(url.searchParams.get("nonce") || undefined))
                         return void text(res, 403, "bad nonce");
-                    if (requiresLocalHistoryConsent && !localHistoryConsentGranted) {
+                    if (requiresReportConsent && !reportConsentGranted) {
                         return void json(res, 403, {
                             error: "LOCAL_HISTORY_CONSENT_REQUIRED",
                             message: "Allow local history access before continuing setup.",
@@ -2150,7 +2417,7 @@ export function startCallbackServer(opts = {}) {
                     }
                     if (!checkNonce(asString(body.nonce)))
                         return void text(res, 403, "bad nonce");
-                    if (requiresLocalHistoryConsent && !localHistoryConsentGranted) {
+                    if (requiresReportConsent && !reportConsentGranted) {
                         return void json(res, 403, {
                             error: "LOCAL_HISTORY_CONSENT_REQUIRED",
                             message: "Allow local history access before managing an onboarding plan.",
@@ -2216,10 +2483,114 @@ export function startCallbackServer(opts = {}) {
                     }
                     return;
                 }
+                if (route === "/report" && req.method === "GET") {
+                    // Local forensic "Context Doctor" report — computed locally, served BEFORE auth (scan-first).
+                    res.setHeader("Cache-Control", "no-store");
+                    if (!checkNonce(url.searchParams.get("nonce") || undefined))
+                        return void text(res, 403, "bad nonce");
+                    if (requiresReportConsent && !reportConsentGranted) {
+                        return void json(res, 403, {
+                            error: "LOCAL_HISTORY_CONSENT_REQUIRED",
+                            message: "Allow local history access before starting the local scan.",
+                        });
+                    }
+                    let payload;
+                    try {
+                        payload = opts.getReport ? opts.getReport() : null;
+                    }
+                    catch {
+                        return void json(res, 500, {
+                            schemaVersion: 1,
+                            kind: "failed",
+                            mode: "production",
+                            scanId,
+                            error: {
+                                code: "REPORT_STATE_UNAVAILABLE",
+                                message: "EchoMem could not read the local scan state. No backup data was substituted. Rerun setup to retry.",
+                            },
+                        });
+                    }
+                    if (payload == null) {
+                        // 202 carries scan progress so the page can show a live "scanned N/total" indicator.
+                        let prog;
+                        try {
+                            prog = opts.getReportProgress ? opts.getReportProgress() : {
+                                status: "running",
+                                scanned: 0,
+                                total: 0,
+                                stage: "starting",
+                                label: "Starting local scan",
+                                elapsedMs: 0,
+                                stageElapsedMs: 0,
+                                updatedAt: Date.now(),
+                            };
+                        }
+                        catch {
+                            return void json(res, 500, {
+                                schemaVersion: 1,
+                                kind: "failed",
+                                mode: "production",
+                                scanId,
+                                error: {
+                                    code: "REPORT_STATE_UNAVAILABLE",
+                                    message: "EchoMem could not read the local scan state. No backup data was substituted. Rerun setup to retry.",
+                                },
+                            });
+                        }
+                        if (prog && typeof prog === "object" && prog.status === "failed") {
+                            return void json(res, 500, {
+                                schemaVersion: 1,
+                                kind: "failed",
+                                mode: "production",
+                                scanId,
+                                error: safeForensicError(prog.error),
+                            });
+                        }
+                        const publicProgress = publicRunningForensicProgress(prog);
+                        if (!publicProgress) {
+                            return void json(res, 500, {
+                                schemaVersion: 1,
+                                kind: "failed",
+                                mode: "production",
+                                scanId,
+                                error: {
+                                    code: "REPORT_STATE_INVALID",
+                                    message: "EchoMem received an invalid local scan state. No backup data was substituted. Rerun setup to retry.",
+                                },
+                            });
+                        }
+                        return void json(res, 202, {
+                            schemaVersion: 1,
+                            kind: "scanning",
+                            mode: "production",
+                            scanId,
+                            progress: publicProgress,
+                        });
+                    }
+                    const validation = validateForensicReportForSetup(payload);
+                    if (!validation.ok) {
+                        console.error(`[echomem] local report validation failed: ${validation.code} — ${validation.message}`);
+                        return void json(res, 500, {
+                            schemaVersion: 1,
+                            kind: "failed",
+                            mode: "production",
+                            scanId,
+                            error: { code: validation.code, message: validation.message },
+                        });
+                    }
+                    json(res, 200, {
+                        schemaVersion: 1,
+                        kind: validation.kind,
+                        mode: "production",
+                        scanId,
+                        report: validation.report,
+                    });
+                    return;
+                }
                 if (route === "/progress" && req.method === "GET") {
                     if (!checkNonce(url.searchParams.get("nonce") || undefined))
                         return void text(res, 403, "bad nonce");
-                    if (requiresLocalHistoryConsent && !localHistoryConsentGranted) {
+                    if (requiresReportConsent && !reportConsentGranted) {
                         return void json(res, 403, {
                             error: "LOCAL_HISTORY_CONSENT_REQUIRED",
                             message: "Allow local history access before continuing setup.",
@@ -2228,7 +2599,7 @@ export function startCallbackServer(opts = {}) {
                     json(res, 200, progress);
                     return;
                 }
-                if (route === "/local-history-consent" && req.method === "POST") {
+                if (route === "/report-consent" && req.method === "POST") {
                     let body;
                     try {
                         body = await readJsonBody(req);
@@ -2240,7 +2611,8 @@ export function startCallbackServer(opts = {}) {
                     if (!checkNonce(asString(body.nonce)))
                         return void text(res, 403, "bad nonce");
                     const allowed = body.allowed === true;
-                    localHistoryConsentGranted = allowed;
+                    reportConsentGranted = allowed;
+                    opts.onReportConsent?.(allowed);
                     json(res, 200, { ok: true, allowed });
                     return;
                 }
@@ -2299,7 +2671,7 @@ export function startCallbackServer(opts = {}) {
                     }
                     if (!checkNonce(asString(body.nonce)))
                         return void text(res, 403, "bad nonce");
-                    if (requiresLocalHistoryConsent && !localHistoryConsentGranted) {
+                    if (requiresReportConsent && !reportConsentGranted) {
                         return void json(res, 403, {
                             error: "LOCAL_HISTORY_CONSENT_REQUIRED",
                             message: "Allow local history access before starting extraction.",
@@ -2561,7 +2933,6 @@ async function cmdSetup(flags) {
     // --dev is already an explicit request to replace the managed runtime with a checkout.
     const forceHeadless = flags["force-headless"] === true || typeof flags.dev === "string";
     const configurationFailures = [];
-    const configuredTargets = [];
     if (targets.length === 0) {
         console.log("No client auto-detected. Add this MCP server entry manually:\n");
         console.log(JSON.stringify({ echomem: entry }, null, 2));
@@ -2569,91 +2940,66 @@ async function cmdSetup(flags) {
     }
     else {
         for (const c of targets) {
-            try {
-                if (c.kind === "json") {
-                    const result = writeJsonClientConfig(c.configPath, entry, { forceHeadless });
-                    if (result === "desktop-managed") {
-                        console.log(`✅ Kept the valid externally managed EchoMem entry for ${c.label}: ${c.configPath}`);
-                    }
-                    else {
-                        console.log(`✅ Wrote EchoMem MCP entry to ${c.label}: ${c.configPath}`);
-                    }
-                    configuredTargets.push(c);
-                }
-                else if (c.kind === "command") {
-                    const result = writeCodexConfig(c.configPath, entry, { forceHeadless });
-                    if (result === "wrote")
-                        console.log(`✅ Wrote EchoMem MCP entry to ${c.label}: ${c.configPath} — start a new Codex session to load it.`);
-                    else if (result === "desktop-managed")
-                        console.log(`✅ Kept the valid externally managed EchoMem entry for ${c.label}: ${c.configPath}`);
-                    else
-                        console.log(`✅ ${c.label} already has the EchoMem MCP entry: ${c.configPath}`);
-                    configuredTargets.push(c);
+            if (c.kind === "json") {
+                const result = writeJsonClientConfig(c.configPath, entry, { forceHeadless });
+                if (result === "desktop-managed") {
+                    console.log(`✅ Kept the valid Echo Desktop-managed EchoMem entry for ${c.label}: ${c.configPath}`);
                 }
                 else {
-                    const result = c.id === "claude-code"
-                        ? writeClaudeCodeConfig(entry, { forceHeadless })
-                        : "unavailable";
-                    if (result !== "unavailable" && result.state === "wrote") {
-                        if (result.preservedDesktopManaged) {
-                            console.log(`✅ Kept the valid externally managed EchoMem user entry for ${c.label}.`);
-                        }
-                        else {
-                            console.log(`✅ Wrote EchoMem MCP entry to ${c.label} via \`claude mcp add-json\` — start a new Claude Code session to load it.`);
-                        }
-                        if (result.removedLocalProjects.length > 0) {
-                            console.log(`✅ Removed ${result.removedLocalProjects.length} stale Claude Code project-local EchoMem ${result.removedLocalProjects.length === 1 ? "entry" : "entries"}.`);
-                        }
-                        if (result.skippedLocalProjects.length > 0) {
-                            console.log(`ℹ️  Ignored ${result.skippedLocalProjects.length} EchoMem local ${result.skippedLocalProjects.length === 1 ? "entry" : "entries"} for deleted project directories; they cannot shadow the user entry.`);
-                        }
-                        configuredTargets.push(c);
+                    console.log(`✅ Wrote EchoMem MCP entry to ${c.label}: ${c.configPath}`);
+                }
+            }
+            else if (c.kind === "command") {
+                const result = writeCodexConfig(c.configPath, entry, { forceHeadless });
+                if (result === "wrote")
+                    console.log(`✅ Wrote EchoMem MCP entry to ${c.label}: ${c.configPath} — start a new Codex session to load it.`);
+                else if (result === "desktop-managed")
+                    console.log(`✅ Kept the valid Echo Desktop-managed EchoMem entry for ${c.label}: ${c.configPath}`);
+                else
+                    console.log(`✅ ${c.label} already has the EchoMem MCP entry: ${c.configPath}`);
+            }
+            else {
+                const result = c.id === "claude-code"
+                    ? writeClaudeCodeConfig(entry, { forceHeadless })
+                    : "unavailable";
+                if (result !== "unavailable" && result.state === "wrote") {
+                    if (result.preservedDesktopManaged) {
+                        console.log(`✅ Kept the valid Echo Desktop-managed EchoMem user entry for ${c.label}.`);
                     }
                     else {
-                        const failedProjects = result === "unavailable" ? [] : result.failedLocalProjects;
-                        const reason = result === "unavailable" ? undefined : result.failureReason;
-                        configurationFailures.push({
-                            client: c,
-                            reason: failedProjects.length > 0
-                                ? `${c.label} still has project-local EchoMem overrides in: ${failedProjects.join(", ")}`
-                                : `${c.label} user-scoped EchoMem entry could not be verified${reason ? `: ${reason}` : ""}`,
-                        });
+                        console.log(`✅ Wrote EchoMem MCP entry to ${c.label} via \`claude mcp add-json\` — start a new Claude Code session to load it.`);
+                    }
+                    if (result.removedLocalProjects.length > 0) {
+                        console.log(`✅ Removed ${result.removedLocalProjects.length} stale Claude Code project-local EchoMem ${result.removedLocalProjects.length === 1 ? "entry" : "entries"}.`);
+                    }
+                    if (result.skippedLocalProjects.length > 0) {
+                        console.log(`ℹ️  Ignored ${result.skippedLocalProjects.length} EchoMem local ${result.skippedLocalProjects.length === 1 ? "entry" : "entries"} for deleted project directories; they cannot shadow the user entry.`);
                     }
                 }
-            }
-            catch (error) {
-                configurationFailures.push({
-                    client: c,
-                    reason: `${c.label} configuration was left unchanged: ${error instanceof Error ? error.message : String(error)}`,
-                });
+                else {
+                    const failedProjects = result === "unavailable" ? [] : result.failedLocalProjects;
+                    configurationFailures.push(failedProjects.length > 0
+                        ? `${c.label} still has project-local EchoMem overrides in: ${failedProjects.join(", ")}`
+                        : `${c.label} user-scoped EchoMem entry could not be verified`);
+                }
             }
         }
     }
     if (configurationFailures.length > 0) {
-        const continueOnClientError = flags["continue-on-client-error"] === true;
-        const failureMessage = [
-            continueOnClientError
-                ? "EchoMem could not configure every detected client."
-                : "EchoMem MCP configuration is incomplete; onboarding was stopped before login/import.",
-            ...configurationFailures.map((failure) => `- ${failure.reason}`),
-            ...configurationFailures.map((failure) => `Retry ${failure.client.label} with: ${MCP_UPDATE_COMMAND} --client ${failure.client.id}`),
-        ].join("\n");
-        if (continueOnClientError) {
-            console.log(`⚠️  ${failureMessage}`);
-            console.log("Continuing with the clients that connected successfully. You can repair the remaining client later.");
-        }
-        else {
-            throw new Error(failureMessage);
-        }
+        throw new Error([
+            "EchoMem MCP configuration is incomplete; onboarding was stopped before login/import.",
+            ...configurationFailures.map((failure) => `- ${failure}`),
+            `Retry with: ${MCP_UPDATE_COMMAND} --client claude-code`,
+        ].join("\n"));
     }
     if (!flags["no-agents-md"]) {
-        writeMemoryGuidanceForTargets(configuredTargets);
+        writeMemoryGuidanceForTargets(targets);
     }
     if (!flags["no-codex-skills"]) {
-        writeCodexSkillsForTargets(configuredTargets);
+        writeCodexSkillsForTargets(targets);
     }
     if (flags["no-save-hooks"] !== true) {
-        writeLifecycleHooksForTargets(configuredTargets);
+        writeLifecycleHooksForTargets(targets);
     }
     console.log("");
     if (flags["skip-login"] || flags["no-login"]) {
@@ -2665,14 +3011,14 @@ async function cmdSetup(flags) {
         await cmdLogin(flags);
     }
     if (flags["with-hud"]) {
-        console.log("ℹ️  The standalone EchoMem HUD has been retired. Use `echomem-mcp status` to inspect this installation.");
+        console.log("ℹ️  The standalone EchoMem HUD has been retired. Echo Desktop now owns setup and status.");
     }
 }
 /**
  * `echomem-mcp init` — the one-command install. Configures EVERY coding agent installed on this
  * machine (Codex + Claude Code + Claude Desktop, not just auto-detected ones), installs EchoMem's
  * Codex skills and writes the AGENTS.md memory guidance. One browser
- * bridge then runs permission → login → plan if needed → extraction in that order.
+ * bridge then runs permission → report → login → plan if needed → extraction in that order.
  * `setup`/`login`/`update` remain granular primitives; init picks the full product defaults.
  */
 async function cmdInit(flags) {
@@ -2681,13 +3027,12 @@ async function cmdInit(flags) {
     await cmdSetup({
         ...flags,
         all: true,
-        "continue-on-client-error": true,
         "skip-login": true,
         "with-hud": false,
         "init-quiet": true,
         "install-save-hooks": flags["no-save-hooks"] !== true,
     });
-    // 2. Start one ordered onboarding bridge. A fresh device logs in only after consent.
+    // 2. Start one ordered onboarding bridge. A fresh device logs in only after consent + report.
     console.log("");
     if (!flags["skip-login"] && !flags["no-login"] && !await cmdOnboarding(flags)) {
         console.log("\nEchoMem is configured, but onboarding did not finish. Run `echomem-mcp init` again when you are ready.");
@@ -2695,8 +3040,8 @@ async function cmdInit(flags) {
     }
     console.log("");
     console.log("🎉 EchoMem is ready.");
-    console.log("   • MCP memory is configured for the coding agents that connected successfully.");
-    console.log("   • Use `echomem-mcp status` to inspect this device, and `login`, `unlock`, or `update` to manage it.");
+    console.log("   • MCP memory is configured for every coding agent installed on this machine.");
+    console.log("   • Echo Desktop shows connection status and manages this device credential.");
     console.log('   • Try it now: ask your agent — "search my EchoMem for what I\'ve been working on and recap it."');
 }
 /**
@@ -2710,7 +3055,7 @@ function writeMemoryGuidanceForTargets(targets) {
         if (t.id === "codex" && t.kind === "command")
             files.set(path.join(t.detectDir, "AGENTS.md"), "Codex");
         if (t.id === "claude-code" || t.id === "claude-desktop")
-            files.set(path.join(claudeConfigHome(), "CLAUDE.md"), "Claude");
+            files.set(home(".claude", "CLAUDE.md"), "Claude");
     }
     for (const [file, label] of files) {
         try {
@@ -2745,28 +3090,22 @@ function writeCodexSkillsForTargets(targets) {
     }
 }
 function writeLifecycleHooksForTargets(targets) {
-    const clients = [];
+    const clients = new Set();
     if (targets.some((target) => target.id === "codex"))
-        clients.push("codex");
+        clients.add("codex");
     if (targets.some((target) => target.id === "claude-code"))
-        clients.push("claude-code");
-    if (clients.length === 0) {
+        clients.add("claude-code");
+    if (clients.size === 0) {
         console.log("ℹ️  No hook-capable Codex or Claude Code client was detected; private-save checkpoint hooks were not installed.");
         return;
     }
-    for (const client of clients) {
-        try {
-            const sourcePaths = installSourceSessionHooks(client);
-            const savePaths = installSaveCheckpointHooks(client);
-            const paths = [...new Set([...sourcePaths, ...savePaths])];
-            console.log(`✅ Installed EchoMem source-session and private-save hooks for ${client}:\n${paths.map((p) => `   - ${p}`).join("\n")}`);
-            if (client === "codex") {
-                console.log("   Codex: start a new session and run /hooks once to review and trust the hook.");
-            }
-        }
-        catch (error) {
-            console.log(`ℹ️  Could not install EchoMem hooks for ${client}: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    const mode = clients.size === 2 ? "both" : [...clients][0];
+    const sourcePaths = installSourceSessionHooks(mode);
+    const savePaths = installSaveCheckpointHooks(mode);
+    const paths = [...new Set([...sourcePaths, ...savePaths])];
+    console.log(`✅ Installed EchoMem source-session and private-save hooks:\n${paths.map((p) => `   - ${p}`).join("\n")}`);
+    if (clients.has("codex")) {
+        console.log("   Codex: start a new session and run /hooks once to review and trust the hook.");
     }
 }
 async function cmdUpdate(flags) {
@@ -2782,7 +3121,7 @@ function selectSetupTargets(requested, all) {
                 return fs.existsSync(path.dirname(client.configPath));
             if (client.kind === "command")
                 return fs.existsSync(client.detectDir);
-            return client.id === "claude-code" && claudeCodeCliAvailable();
+            return client.id === "claude-code" && fs.existsSync(home(".claude"));
         });
     }
     return requested ? knownClients().filter((client) => client.id === requested) : detectClients();
@@ -2818,7 +3157,7 @@ async function cmdLogin(flags) {
         return true;
     }
     // Browser path: this bridge does only account/device authentication. It intentionally exposes
-    // no local-history routes; `init` owns local-history consent and optional extraction.
+    // no local-history routes; `init` owns scan consent, reporting, and optional extraction.
     console.log("Opening your browser to connect this device locally…");
     const { port, nonce } = localBridgeOptions(flags);
     const srv = await startCallbackServer({ port, nonce, flow: "login" });
@@ -2846,7 +3185,7 @@ async function cmdLogin(flags) {
 }
 /**
  * The local-history onboarding flow. Existing device credentials are reused when available; a
- * fresh device stays in this same bridge and asks for login only after permission.
+ * fresh device stays in this same bridge and asks for login only after permission and report.
  */
 async function cmdOnboarding(flags) {
     const store = new KeyStore();
@@ -2858,17 +3197,149 @@ async function cmdOnboarding(flags) {
     console.log("Opening your browser for EchoMem onboarding…");
     const { port, nonce } = localBridgeOptions(flags);
     let stats = null;
+    let forensicReport = null;
+    let forensicConsent = "pending";
+    let forensicScanStarted = false;
+    const forensicStartedAt = Date.now();
+    let forensicStageStartedAt = forensicStartedAt;
+    let forensicStage = "starting";
+    let forensicOverall = 0;
+    let forensicProgress = {
+        status: "running",
+        scanned: 0,
+        total: 0,
+        stage: forensicStage,
+        label: forensicStageLabel(forensicStage),
+        stageDone: 0,
+        stageTotal: 0,
+        overall: 0,
+        elapsedMs: 0,
+        stageElapsedMs: 0,
+        updatedAt: forensicStartedAt,
+    };
     const srv = await startCallbackServer({
         port,
         nonce,
         flow: "onboarding",
         initialToken,
-        requireLocalHistoryConsent: true,
+        requireReportConsent: true,
+        getStats: () => stats,
+        getReport: () => forensicReport,
+        getReportProgress: () => {
+            if (forensicProgress.status !== "running")
+                return forensicProgress;
+            const now = Date.now();
+            const sinceWorkerUpdate = Math.max(0, now - forensicProgress.updatedAt);
+            return {
+                ...forensicProgress,
+                elapsedMs: forensicProgress.elapsedMs + sinceWorkerUpdate,
+                stageElapsedMs: forensicProgress.stageElapsedMs + sinceWorkerUpdate,
+                updatedAt: now,
+            };
+        },
+        onReportConsent: (allowed) => {
+            if (!allowed) {
+                forensicConsent = "declined";
+                forensicProgress = {
+                    status: "failed",
+                    scanned: 0,
+                    total: 0,
+                    stage: "failed",
+                    label: "Local scan skipped",
+                    stageDone: 0,
+                    stageTotal: 0,
+                    overall: 0,
+                    elapsedMs: Date.now() - forensicStartedAt,
+                    stageElapsedMs: Date.now() - forensicStageStartedAt,
+                    updatedAt: Date.now(),
+                    error: {
+                        code: "REPORT_SCAN_DECLINED",
+                        message: "Local file analysis was skipped. EchoMem can still connect, save conversations, and import memories.",
+                    },
+                };
+                return;
+            }
+            forensicConsent = "allowed";
+            const now = Date.now();
+            forensicStage = "starting";
+            forensicStageStartedAt = now;
+            forensicOverall = 0;
+            forensicProgress = {
+                status: "running",
+                scanned: 0,
+                total: 0,
+                stage: forensicStage,
+                label: forensicStageLabel(forensicStage),
+                stageDone: 0,
+                stageTotal: 0,
+                overall: 0,
+                elapsedMs: now - forensicStartedAt,
+                stageElapsedMs: 0,
+                updatedAt: now,
+            };
+            startForensicScan();
+        },
     });
     const localSetupUrl = `http://127.0.0.1:${srv.port}/setup?nonce=${nonce}`;
     openBrowser(localSetupUrl);
     console.log(`If it didn't open, visit:\n  ${localSetupUrl}\n`);
     console.log("Waiting for local-history onboarding for up to 15 minutes…");
+    const startForensicScan = () => {
+        if (forensicScanStarted || forensicConsent !== "allowed")
+            return;
+        forensicScanStarted = true;
+        // Build the local forensic "Context Doctor" report off-thread only after explicit consent.
+        buildForensicReportOffThread((progress) => {
+            const now = Date.now();
+            const nextStage = progress.stage || forensicStage;
+            if (nextStage !== forensicStage) {
+                forensicStage = nextStage;
+                forensicStageStartedAt = now;
+                console.log(`Local scan: ${forensicStageLabel(forensicStage)}…`);
+            }
+            // Latched, so a caller that ever reports a smaller fraction cannot walk the bar backwards.
+            forensicOverall = Math.max(forensicOverall, typeof progress.overall === "number" && Number.isFinite(progress.overall) ? progress.overall : 0);
+            forensicProgress = {
+                status: "running",
+                scanned: progress.done,
+                total: progress.total,
+                stage: forensicStage,
+                label: forensicStageLabel(forensicStage),
+                detail: progress.detail,
+                stageDone: typeof progress.stageDone === "number" && Number.isFinite(progress.stageDone)
+                    ? Math.max(0, Math.floor(progress.stageDone))
+                    : 0,
+                stageTotal: typeof progress.stageTotal === "number" && Number.isFinite(progress.stageTotal)
+                    ? Math.max(0, Math.floor(progress.stageTotal))
+                    : 0,
+                overall: forensicOverall,
+                elapsedMs: now - forensicStartedAt,
+                stageElapsedMs: now - forensicStageStartedAt,
+                updatedAt: now,
+            };
+        })
+            .then((r) => {
+            forensicReport = r;
+        })
+            .catch((e) => {
+            const now = Date.now();
+            forensicProgress = {
+                status: "failed",
+                scanned: forensicProgress.scanned,
+                total: forensicProgress.total,
+                stage: "failed",
+                label: "Local scan failed",
+                stageDone: forensicProgress.stageDone,
+                stageTotal: forensicProgress.stageTotal,
+                overall: forensicOverall,
+                elapsedMs: now - forensicStartedAt,
+                stageElapsedMs: now - forensicStageStartedAt,
+                updatedAt: now,
+                error: safeForensicError(e),
+            };
+            console.error(`Could not build the local report: ${e instanceof Error ? e.message : String(e)}`);
+        });
+    };
     let token;
     let key;
     try {
@@ -2956,10 +3427,12 @@ async function cmdOnboarding(flags) {
         let sessionSummary = {
             total: quick.sessions,
             codex: quick.codexCount,
-            claudeCode: quick.claudeCount,
+            claudeCode: quick.claudeCodeCount,
+            cowork: quick.coworkCount,
         };
-        stats = buildOnboardingStatsPayload({
+        stats = await buildStatsPayload([], {
             partial: true,
+            skipMemoryCount: true,
             sessions: sessionSummary,
             migratable,
             discovery: { phase: "quick", exact: false },
@@ -2991,10 +3464,12 @@ async function cmdOnboarding(flags) {
             sessionSummary = {
                 total: cloudSummary.sessions,
                 codex: cloudSummary.codexCount,
-                claudeCode: cloudSummary.claudeCount,
+                claudeCode: cloudSummary.claudeCodeCount,
+                cowork: cloudSummary.coworkCount,
             };
-            const cloudPayload = buildOnboardingStatsPayload({
+            const cloudPayload = await buildStatsPayload([], {
                 partial: true,
+                skipMemoryCount: true,
                 sessions: sessionSummary,
                 migratable,
                 discovery: { phase: "account", exact: false },
@@ -3027,10 +3502,12 @@ async function cmdOnboarding(flags) {
                 sessionSummary = {
                     total: unavailableSummary.sessions,
                     codex: unavailableSummary.codexCount,
-                    claudeCode: unavailableSummary.claudeCount,
+                    claudeCode: unavailableSummary.claudeCodeCount,
+                    cowork: unavailableSummary.coworkCount,
                 };
-                const unavailablePayload = buildOnboardingStatsPayload({
+                const unavailablePayload = await buildStatsPayload([], {
                     partial: true,
+                    skipMemoryCount: true,
                     sessions: sessionSummary,
                     migratable,
                     discovery: { phase: "account", exact: false },
@@ -3066,8 +3543,9 @@ async function cmdOnboarding(flags) {
             migratable = migratableFromDiscovery(initialExact);
             latestPendingEstimate = migratable.pending;
             sessionSummary = sessionsFromDiscovery(initialExact);
-            const partialPayload = withCandidateSessions(buildOnboardingStatsPayload({
+            const partialPayload = withCandidateSessions(await buildStatsPayload([], {
                 partial: true,
+                skipMemoryCount: true,
                 sessions: sessionSummary,
                 migratable,
                 discovery: { phase: "exact", exact: true },
@@ -3115,10 +3593,12 @@ async function cmdOnboarding(flags) {
                 migratable = migratableFromDiscovery(reconciled);
                 latestPendingEstimate = migratable.pending;
                 sessionSummary = sessionsFromDiscovery(reconciled);
-                const reconciledPayload = withCandidateSessions(buildOnboardingStatsPayload({
+                const reconciledPayload = withCandidateSessions(await buildStatsPayload([], {
+                    partial: true,
+                    skipMemoryCount: true,
                     sessions: sessionSummary,
                     migratable,
-                    discovery: { phase: "full", exact: true },
+                    discovery: { phase: "exact", exact: true },
                 }), reconciled);
                 if (generation !== refreshGeneration)
                     return;
@@ -3133,11 +3613,20 @@ async function cmdOnboarding(flags) {
                     failed: 0,
                     extracted: 0,
                 });
+                const fullPayload = withCandidateSessions(await buildCollectedStatsPayloadOffThread({
+                    sessions: sessionSummary,
+                    migratable,
+                    discovery: { phase: "full", exact: true },
+                }), reconciled);
+                if (generation !== refreshGeneration)
+                    return;
+                stats = fullPayload;
+                srv.setStats(fullPayload);
             })().catch((e) => {
                 if (generation !== refreshGeneration)
                     return;
-                console.error(`[echomem] optional account reconciliation unavailable; continuing (${errorCode(e) || "ACCOUNT_RECONCILIATION_FAILED"})`);
-                publishOptionalStatsFallback(generation, "ACCOUNT_RECONCILIATION_FAILED", true);
+                console.error(`[echomem] optional full local-history stats unavailable; continuing (${errorCode(e) || "FULL_STATS_FAILED"})`);
+                publishOptionalStatsFallback(generation, "FULL_STATS_FAILED", true);
             });
             return initialExact;
         }).catch((e) => {
@@ -3597,7 +4086,7 @@ Usage:
   echomem-mcp                       Run the MCP server (stdio; default — used by your editor)
   echomem-mcp setup [--client X]    Detect editor, write its MCP config, then connect this device
   echomem-mcp setup --skip-login    Write MCP config without opening login/browser
-  echomem-mcp setup --force-headless  Explicitly replace a valid externally managed entry
+  echomem-mcp setup --force-headless  Explicitly replace valid Echo Desktop-managed entries
   echomem-mcp setup --no-codex-skills  Skip installing the bundled EchoMem Codex skills
   echomem-mcp update --all          Install this bridge durably + repoint detected clients; no login/browser
   echomem-mcp update --client X     Repoint one MCP client; no login/browser
@@ -3608,6 +4097,7 @@ Usage:
   echomem-mcp status                Show token/key/clients
   echomem-mcp doctor [--no-network] Diagnose configured client bridge versions
   echomem-mcp logout                Remove stored credentials
+  echomem-mcp report [--json]       Your AI coding memory audit (local, no login, $0)
   echomem-mcp migrate [--since D]   Import your existing Codex/Claude history into your memory
   echomem-mcp migrate --estimate    Estimate migration size/time metadata without uploading transcripts
   echomem-mcp migrate --max-chars N Import only sessions up to N assembled text chars
@@ -3659,6 +4149,9 @@ export async function runCli(argv) {
         case "logout":
             cmdLogout();
             return true;
+        case "report":
+            await runReport(flags);
+            return true;
         case "migrate":
             await cmdMigrate(flags);
             return true;