@echomem/mcp 1.4.7 → 1.4.9

package/dist/index.js

@@ -273,6 +273,23 @@ function lastUserMessageFromConversationText(value) {
     flush();
     return lastUser || undefined;
 }
+function formatMessagesForIngest(messages) {
+    return messages
+        .map((message) => {
+        const content = message.content.trim();
+        if (!content)
+            return "";
+        const role = message.role.toLowerCase();
+        const label = role === "user" || role === "human"
+            ? "User"
+            : role === "system"
+                ? "System"
+                : "Assistant";
+        return `## ${label}\n\n${content}`;
+    })
+        .filter(Boolean)
+        .join("\n\n---\n\n");
+}
 function normalizeRetrievalCandidate(value, fallbackRank) {
     if (!isRecord(value))
         return null;
@@ -645,7 +662,7 @@ class EchoMemApiClient {
         return { success: true, tuned: true, answer: String(data.answer || data.response || "").trim(), memories };
     }
     async searchMemories(args) {
-        const parsed = searchMemoriesSchema.parse(args);
+        const parsed = searchMemoriesSchema.parse(args ?? {});
         const query = parsed.query?.trim();
         const limit = parsed.limit ?? parsed.k ?? 10;
         const threshold = parsed.threshold ?? 0.1;
@@ -693,10 +710,10 @@ class EchoMemApiClient {
         return data;
     }
     async saveConversation(args) {
-        const parsed = saveConversationSchema.parse(args);
+        const parsed = saveConversationSchema.parse(args ?? {});
         let rawData = parsed.conversation?.trim() || "";
         if (!rawData && parsed.messages?.length) {
-            rawData = parsed.messages.map((m) => `${m.role}: ${m.content}`).join("\n\n");
+            rawData = formatMessagesForIngest(parsed.messages);
         }
         if (!rawData) {
             throw new McpError(ErrorCode.InvalidParams, "Either conversation or messages is required.");
@@ -724,7 +741,7 @@ class EchoMemApiClient {
         return response.data;
     }
     async deleteMemory(args) {
-        const parsed = deleteMemorySchema.parse(args);
+        const parsed = deleteMemorySchema.parse(args ?? {});
         const enc = await this.encState();
         const memory = await this.fetchMemoryById(parsed.memoryId, enc);
         if (!memory) {
@@ -768,7 +785,7 @@ class EchoMemApiClient {
         };
     }
     async getMemoriesByTimeRange(args) {
-        const parsed = timeRangeSchema.parse(args);
+        const parsed = timeRangeSchema.parse(args ?? {});
         const enc = await this.encState();
         const response = await this.axios.post("/api/extension/memories/time-range", {
             startDate: parsed.startDate,
@@ -778,7 +795,7 @@ class EchoMemApiClient {
         return enc.enabled ? await this.decryptResult(response.data, enc.key) : response.data;
     }
     async getMemoriesByContext(args) {
-        const parsed = getByContextSchema.parse(args);
+        const parsed = getByContextSchema.parse(args ?? {});
         const enc = await this.encState();
         const response = await this.axios.post("/api/extension/memories/by-context", {
             contextId: parsed.contextId,
@@ -787,7 +804,7 @@ class EchoMemApiClient {
         return enc.enabled ? await this.decryptResult(response.data, enc.key) : response.data;
     }
     async searchMemoriesByKeywords(args) {
-        const parsed = keywordsSchema.parse(args);
+        const parsed = keywordsSchema.parse(args ?? {});
         const enc = await this.encState();
         const response = await this.axios.post("/api/extension/memories/keywords", {
             keywords: parsed.keywords,
@@ -796,7 +813,7 @@ class EchoMemApiClient {
         return enc.enabled ? await this.decryptResult(response.data, enc.key) : response.data;
     }
     async listFriends(args) {
-        listFriendsSchema.parse(args);
+        listFriendsSchema.parse(args ?? {});
         try {
             const response = await this.axios.get("/api/extension/social/friends");
             return response.data;
@@ -806,7 +823,7 @@ class EchoMemApiClient {
         }
     }
     async searchUsers(args) {
-        const parsed = searchUsersSchema.parse(args);
+        const parsed = searchUsersSchema.parse(args ?? {});
         try {
             const response = await this.axios.post("/api/extension/social/users/search", {
                 query: parsed.query,
@@ -819,7 +836,7 @@ class EchoMemApiClient {
         }
     }
     async sendFriendRequest(args) {
-        const parsed = sendFriendRequestSchema.parse(args);
+        const parsed = sendFriendRequestSchema.parse(args ?? {});
         try {
             const response = await this.axios.post("/api/extension/social/friend-requests", {
                 receiverUserId: parsed.targetUserId,
@@ -831,7 +848,7 @@ class EchoMemApiClient {
         }
     }
     async searchOthersMemories(args) {
-        const parsed = othersSchema.parse(args);
+        const parsed = othersSchema.parse(args ?? {});
         try {
             const response = await this.axios.post("/api/extension/social/public-memories/search", {
                 query: parsed.query,
@@ -855,7 +872,7 @@ class EchoMemApiClient {
         }
     }
     async getPublicMemory(args) {
-        const parsed = publicMemorySchema.parse(args);
+        const parsed = publicMemorySchema.parse(args ?? {});
         try {
             const response = await this.axios.get(`/api/extension/social/public-memories/${encodeURIComponent(parsed.memoryId)}?requestId=${encodeURIComponent(this.sessionId)}&source=mcp_friend_public_memory_fetch`);
             return response.data;
@@ -1026,6 +1043,8 @@ class EchoMemMCPServer {
                         return await this.handleTimeRange(request.params.arguments);
                     case canonicalToolNames.getByContext:
                         return await this.handleGetByContext(request.params.arguments);
+                    case canonicalToolNames.checkpointByContext:
+                        return await this.handleGetCheckpointByContext(request.params.arguments);
                     case canonicalToolNames.keywords:
                         return await this.handleKeywords(request.params.arguments);
                     case canonicalToolNames.friends:
@@ -1254,7 +1273,7 @@ Details: ${m.details || "N/A"}`)
         return { content: [{ type: "text", text }] };
     }
     async handleTimeRange(args) {
-        const parsed = timeRangeSchema.parse(args);
+        const parsed = timeRangeSchema.parse(args ?? {});
         const { success, memories, error } = await this.client.getMemoriesByTimeRange(args);
         if (!success)
             throw new Error(`EchoMem API Error: ${error}`);
@@ -1279,7 +1298,7 @@ Details: ${m.details || "N/A"}`)
         };
     }
     async handleGetByContext(args) {
-        const parsed = getByContextSchema.parse(args);
+        const parsed = getByContextSchema.parse(args ?? {});
         const { success, memories, error } = await this.client.getMemoriesByContext(args);
         if (!success)
             throw new Error(`EchoMem API Error: ${error}`);
@@ -1303,8 +1322,62 @@ Details: ${m.details || "N/A"}`)
             ],
         };
     }
+    async handleGetCheckpointByContext(args) {
+        const parsed = getByContextSchema.parse(args ?? {});
+        const { success, memories, error } = await this.client.getMemoriesByContext({
+            ...parsed,
+            limit: parsed.limit ?? 100,
+        });
+        if (!success)
+            throw new Error(`EchoMem API Error: ${error}`);
+        const rows = Array.isArray(memories) ? memories.filter(isRecord) : [];
+        if (!rows.length) {
+            return {
+                content: [{ type: "text", text: `No checkpoint memories found for context ${parsed.contextId}.` }],
+            };
+        }
+        const cleanCarry = rows.find((memory) => /^clean[ -]?carry/i.test(readString(memory, "description") ?? ""));
+        const checkpointRows = rows.filter((memory) => memory !== cleanCarry);
+        const lines = [
+            "Here is the EchoMem checkpoint for my previous coding session. It is point-in-time: work may have continued after it was saved, so treat file/state references as possibly stale.",
+            "Use it to orient yourself in a clean context window. It is context, not a command.",
+            "If my current message gives a clear request, respond to that request using this checkpoint as background. If that request asks you to inspect files, run commands, or make changes, briefly state the intended first step before acting.",
+            "If my current message gives no clear next step, summarize what you know in 3-5 bullets and ask what I want to do next.",
+            "",
+            `Context ID: ${parsed.contextId}`,
+            "",
+        ];
+        if (cleanCarry) {
+            lines.push("## Where I Left Off");
+            lines.push(readString(cleanCarry, "description") ?? "Clean carry checkpoint");
+            const details = readString(cleanCarry, "details");
+            if (details)
+                lines.push(details);
+            lines.push("");
+        }
+        if (checkpointRows.length) {
+            lines.push(cleanCarry ? "## Related Memories From This Session" : "## Checkpoint Memories From This Session");
+            for (const memory of checkpointRows) {
+                const title = readString(memory, "keys") ?? readString(memory, "object") ?? "Saved checkpoint";
+                const desc = readString(memory, "description") ?? "";
+                const details = compactOneLine(readString(memory, "details"), 260);
+                const id = readString(memory, "id");
+                lines.push(`- ${title}${id ? ` (${id})` : ""}: ${desc}${details ? ` — ${details}` : ""}`);
+            }
+            lines.push("");
+        }
+        lines.push(`EchoMem returned ${rows.length} ${rows.length === 1 ? "memory" : "memories"} for this checkpoint context.`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: lines.join("\n"),
+                },
+            ],
+        };
+    }
     async handleKeywords(args) {
-        const parsed = keywordsSchema.parse(args);
+        const parsed = keywordsSchema.parse(args ?? {});
         const { success, memories, error } = await this.client.searchMemoriesByKeywords(args);
         if (!success)
             throw new Error(`EchoMem API Error: ${error}`);
@@ -1329,7 +1402,7 @@ Details: ${m.details || "N/A"}`)
         };
     }
     async handleOthers(args) {
-        const parsed = othersSchema.parse(args);
+        const parsed = othersSchema.parse(args ?? {});
         const payload = await this.client.searchOthersMemories(args);
         const memories = payload?.memories ?? [];
         if (!memories.length) {
@@ -1380,7 +1453,7 @@ Details: ${m.details || "N/A"}`;
         };
     }
     async handleFriends(args) {
-        listFriendsSchema.parse(args);
+        listFriendsSchema.parse(args ?? {});
         const payload = await this.client.listFriends(args);
         const friends = Array.isArray(payload?.friends) ? payload.friends : [];
         if (!friends.length) {
@@ -1411,7 +1484,7 @@ Details: ${m.details || "N/A"}`;
         };
     }
     async handleSearchUsers(args) {
-        const parsed = searchUsersSchema.parse(args);
+        const parsed = searchUsersSchema.parse(args ?? {});
         const payload = await this.client.searchUsers(args);
         const users = Array.isArray(payload?.users) ? payload.users : [];
         if (!users.length) {
@@ -1444,7 +1517,7 @@ Details: ${m.details || "N/A"}`;
         };
     }
     async handleSendFriendRequest(args) {
-        sendFriendRequestSchema.parse(args);
+        sendFriendRequestSchema.parse(args ?? {});
         const payload = await this.client.sendFriendRequest(args);
         const result = isRecord(payload) ? payload : {};
         const targetUser = isRecord(result.targetUser) ? result.targetUser : {};
@@ -1477,7 +1550,7 @@ Details: ${m.details || "N/A"}`;
         };
     }
     async handlePublicMemory(args) {
-        const parsed = publicMemorySchema.parse(args);
+        const parsed = publicMemorySchema.parse(args ?? {});
         const payload = await this.client.getPublicMemory(args);
         const memory = payload?.memory;
         if (!memory) {
@@ -1505,7 +1578,7 @@ Details: ${m.details || "N/A"}`;
         };
     }
     async handleDelete(args, rec) {
-        const parsed = deleteMemorySchema.parse(args);
+        const parsed = deleteMemorySchema.parse(args ?? {});
         if (rec) {
             rec.memory_id_hash = hashText(parsed.memoryId);
             rec.delete_confirmed = parsed.confirmed;
@@ -1564,10 +1637,35 @@ Details: ${m.details || "N/A"}`;
 async function main() {
     // Subcommands (setup/login/unlock/status/logout/help) run and exit; no subcommand → serve.
     const handled = await runCli(process.argv.slice(2));
-    if (handled)
-        return;
+    if (handled) {
+        // These are one-shot commands: the work is finished here. Force exit so a stray open handle —
+        // e.g. a not-yet-timed-out keep-alive socket from the local setup server, or a detached child's
+        // inherited descriptor — can't leave the terminal hanging after setup/migrate completes.
+        process.exit(process.exitCode ?? 0);
+    }
     const store = new KeyStore();
-    if (!store.getToken()) {
+    // Serve mode is meant to be SPAWNED by the MCP client (editor), which drives us over a piped stdin.
+    // A human who runs the bare server in a terminal instead gets a process that blocks forever on stdio
+    // with no output — indistinguishable from a hang ("wtf, it's stuck"). A TTY on stdin means no editor
+    // is on the other end: say so loudly and point at the command they almost certainly meant.
+    if (process.stdin.isTTY) {
+        const connected = Boolean(store.getToken());
+        console.error([
+            "",
+            "⚠️  You started the EchoMem MCP server directly in a terminal.",
+            "",
+            "   This is a background server that waits for your editor to connect over",
+            "   stdio. It is NOT frozen — a blank, unresponsive terminal is exactly what",
+            "   a running stdio server looks like.",
+            "",
+            connected
+                ? "   Your editor launches this for you; you don't need to run it by hand."
+                : "   To connect this device, press Ctrl+C and run:",
+            connected ? "   Press Ctrl+C to stop it." : "       echomem-mcp init",
+            "",
+        ].join("\n"));
+    }
+    else if (!store.getToken()) {
         // No token yet — DON'T exit. Start the server so the editor keeps the bridge alive; tools return
         // a "run login" nudge until `login` writes the token, then the next call picks it up (no restart).
         console.error("EchoMem: not connected yet — run `echomem-mcp login` to connect this device.");

package/dist/local-data-paths.js

@@ -0,0 +1,87 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function normalizedHomeDir(homeDir) {
+    const value = homeDir.trim();
+    if (!value || !path.isAbsolute(value))
+        return null;
+    return path.normalize(value);
+}
+function expandCurrentUserHome(value, homeDir) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed === "~")
+        return homeDir;
+    if (trimmed.startsWith(`~${path.sep}`) || trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
+        return path.join(homeDir, trimmed.slice(2));
+    }
+    // Do not guess another user's home (~alice) or resolve a relative path against the MCP process cwd.
+    if (trimmed.startsWith("~") || !path.isAbsolute(trimmed))
+        return null;
+    return path.normalize(trimmed);
+}
+function configuredRoot(envKey, defaultDirName, opts = {}) {
+    const homeDir = normalizedHomeDir(opts.homeDir ?? os.homedir());
+    if (!homeDir)
+        return null;
+    const env = opts.env ?? process.env;
+    const configured = env[envKey];
+    if (typeof configured === "string" && configured.trim()) {
+        // An explicit profile override is authoritative. If it is invalid, callers must not silently
+        // scan the default profile, which may belong to a different account or contain stale history.
+        return expandCurrentUserHome(configured, homeDir);
+    }
+    return path.join(homeDir, defaultDirName);
+}
+/** Resolve an existing directory only after confirming it is a readable/searchable directory. */
+export function resolveReadableDirectory(candidate) {
+    if (!candidate)
+        return null;
+    try {
+        const real = fs.realpathSync(candidate);
+        if (!fs.statSync(real).isDirectory())
+            return null;
+        fs.accessSync(real, fs.constants.R_OK | fs.constants.X_OK);
+        return real;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve every readable Codex transcript root under one authoritative CODEX_HOME profile.
+ * Active sessions come first. archived_sessions is additive historical data, not a fallback to a
+ * different profile. If both names resolve to the same directory, keep it once as active.
+ */
+export function resolveCodexSessionRoots(opts = {}) {
+    const root = configuredRoot("CODEX_HOME", ".codex", opts);
+    if (!root)
+        return [];
+    const candidates = [
+        { kind: "active", child: "sessions", priority: 0 },
+        { kind: "archived", child: "archived_sessions", priority: 1 },
+    ];
+    const roots = [];
+    const seenRealpaths = new Set();
+    for (const candidate of candidates) {
+        const resolved = resolveReadableDirectory(path.join(root, candidate.child));
+        if (!resolved || seenRealpaths.has(resolved))
+            continue;
+        seenRealpaths.add(resolved);
+        roots.push({ kind: candidate.kind, path: resolved, priority: candidate.priority });
+    }
+    return roots;
+}
+/**
+ * Backward-compatible active-only resolver. Historical scanners should use
+ * resolveCodexSessionRoots/discoverCodexSessionFiles so archived sessions are not omitted.
+ */
+export function resolveCodexSessionsDir(opts = {}) {
+    return resolveCodexSessionRoots(opts).find((root) => root.kind === "active")?.path ?? null;
+}
+/** Claude Code state lives under CLAUDE_CONFIG_DIR (default ~/.claude); transcripts are in projects. */
+export function resolveClaudeProjectsDir(opts = {}) {
+    const root = configuredRoot("CLAUDE_CONFIG_DIR", ".claude", opts);
+    return resolveReadableDirectory(root ? path.join(root, "projects") : null);
+}

package/dist/migrate.js

@@ -19,13 +19,13 @@
  * NOTE: client-pull — the queue advances only while the bridge runs; there is no server-side worker.
  */
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import crypto from "node:crypto";
 import readline from "node:readline";
 import axios from "axios";
 import { KeyStore, echoConfigDir } from "./keystore.js";
 import { fetchEncryptionConfig } from "./encryption.js";
+import { resolveClaudeProjectsDir, resolveCodexSessionsDir } from "./local-data-paths.js";
 import { walk, eachLine } from "./report.js";
 const API_BASE = (process.env.ECHO_API_BASE_URL || "https://echo-mem-chrome.vercel.app").replace(/\/$/, "");
 const RATE_MAX = 28; // stay under the import-jobs /run limit of 30 / 60s
@@ -187,17 +187,21 @@ export function normalizeCwd(cwd) {
 /** Discover every local session, newest first (by first-turn timestamp). */
 export function discoverSessions() {
     const out = [];
-    const codexRoot = path.join(os.homedir(), ".codex", "sessions");
-    for (const f of walk(codexRoot, (p) => /rollout-.*\.jsonl$/.test(p), () => false)) {
-        const s = assembleCodex(f);
-        if (s)
-            out.push(s);
+    const codexRoot = resolveCodexSessionsDir();
+    if (codexRoot) {
+        for (const f of walk(codexRoot, (p) => /rollout-.*\.jsonl$/.test(p), () => false)) {
+            const s = assembleCodex(f);
+            if (s)
+                out.push(s);
+        }
     }
-    const claudeRoot = path.join(os.homedir(), ".claude", "projects");
-    for (const f of walk(claudeRoot, (p) => p.endsWith(".jsonl"), (name) => name === "subagents" || name === "workflows")) {
-        const s = assembleClaude(f);
-        if (s)
-            out.push(s);
+    const claudeRoot = resolveClaudeProjectsDir();
+    if (claudeRoot) {
+        for (const f of walk(claudeRoot, (p) => p.endsWith(".jsonl"), (name) => name === "subagents" || name === "workflows")) {
+            const s = assembleClaude(f);
+            if (s)
+                out.push(s);
+        }
     }
     out.sort((a, b) => String(b.firstTs || "").localeCompare(String(a.firstTs || "")));
     return out;
@@ -283,24 +287,28 @@ function fastSessionInfo(file, source) {
 }
 function fastSessionEntries(opts = {}) {
     const out = [];
-    const codexRoot = opts.codexRoot ?? path.join(os.homedir(), ".codex", "sessions");
-    for (const filePath of walk(codexRoot, (p) => /rollout-.*\.jsonl$/.test(p), () => false)) {
-        const stat = statSafe(filePath);
-        const info = fastSessionInfo(filePath, "codex");
-        // Include if we found text OR a real session id (big sessions can have their first text turn beyond
-        // the 1MB probe window — gating only on text dropped them entirely; exact discovery refines later).
-        // We require a real key so the fast/exact conversationKey match (no sha16 fallback mismatch).
-        if (info.hasTextTurn || info.hasRealKey)
-            out.push({ filePath, source: "codex", conversationKey: info.conversationKey, size: stat.size, mtimeMs: stat.mtimeMs });
+    const codexRoot = opts.codexRoot ?? resolveCodexSessionsDir();
+    if (codexRoot) {
+        for (const filePath of walk(codexRoot, (p) => /rollout-.*\.jsonl$/.test(p), () => false)) {
+            const stat = statSafe(filePath);
+            const info = fastSessionInfo(filePath, "codex");
+            // Include if we found text OR a real session id (big sessions can have their first text turn beyond
+            // the 1MB probe window — gating only on text dropped them entirely; exact discovery refines later).
+            // We require a real key so the fast/exact conversationKey match (no sha16 fallback mismatch).
+            if (info.hasTextTurn || info.hasRealKey)
+                out.push({ filePath, source: "codex", conversationKey: info.conversationKey, size: stat.size, mtimeMs: stat.mtimeMs });
+        }
     }
-    const claudeRoot = opts.claudeRoot ?? path.join(os.homedir(), ".claude", "projects");
-    for (const filePath of walk(claudeRoot, (p) => p.endsWith(".jsonl"), (name) => name === "subagents" || name === "workflows")) {
-        const stat = statSafe(filePath);
-        const info = fastSessionInfo(filePath, "claude-code");
-        // Same rule as codex: include on text OR a real session id so large sessions aren't undercounted,
-        // while keeping the key stable (claude-code sessionId appears on every line, so hasRealKey is reliable).
-        if (info.hasTextTurn || info.hasRealKey)
-            out.push({ filePath, source: "claude-code", conversationKey: info.conversationKey, size: stat.size, mtimeMs: stat.mtimeMs });
+    const claudeRoot = opts.claudeRoot ?? resolveClaudeProjectsDir();
+    if (claudeRoot) {
+        for (const filePath of walk(claudeRoot, (p) => p.endsWith(".jsonl"), (name) => name === "subagents" || name === "workflows")) {
+            const stat = statSafe(filePath);
+            const info = fastSessionInfo(filePath, "claude-code");
+            // Same rule as codex: include on text OR a real session id so large sessions aren't undercounted,
+            // while keeping the key stable (claude-code sessionId appears on every line, so hasRealKey is reliable).
+            if (info.hasTextTurn || info.hasRealKey)
+                out.push({ filePath, source: "claude-code", conversationKey: info.conversationKey, size: stat.size, mtimeMs: stat.mtimeMs });
+        }
     }
     return out;
 }
@@ -644,6 +652,7 @@ export function estimateMigrationEtaFromLengths(lengths, skippedActive = 0, opts
     };
 }
 export function summarizeFastMigratableDiscovery(discovery) {
+    const pendingCodex = discovery.pendingCodex ?? discovery.pending.filter((s) => s.source === "codex").length;
     return {
         sessions: discovery.sessions.length,
         pending: discovery.pending.length,
@@ -652,6 +661,8 @@ export function summarizeFastMigratableDiscovery(discovery) {
         skippedActive: discovery.skippedActive,
         codexCount: discovery.codexCount,
         claudeCount: discovery.claudeCount,
+        pendingCodex,
+        pendingClaudeCode: discovery.pendingClaudeCode ?? discovery.pending.length - pendingCodex,
         eta: estimateMigrationEtaFromLengths(discovery.pending.map((s) => s.size), discovery.skippedActive, {
             secondsPerSession: measuredSecondsPerSession() ?? undefined,
         }),
@@ -690,6 +701,7 @@ export function discoverMigratableFastDiscovery(opts = {}) {
     });
     const pending = opts.limit && opts.limit > 0 ? pendingAll.slice(0, opts.limit) : pendingAll;
     const codexCount = sessions.filter((s) => s.source === "codex").length;
+    const pendingCodex = pending.filter((s) => s.source === "codex").length;
     return {
         sessions,
         pending,
@@ -699,6 +711,8 @@ export function discoverMigratableFastDiscovery(opts = {}) {
         limited: pending.length < pendingAll.length,
         codexCount,
         claudeCount: sessions.length - codexCount,
+        pendingCodex,
+        pendingClaudeCode: pending.length - pendingCodex,
     };
 }
 export function discoverMigratableSummaryFast(opts = {}) {
@@ -757,6 +771,7 @@ export function discoverMigratableSessions(opts = {}) {
     });
     const pending = opts.limit && opts.limit > 0 ? pendingAll.slice(0, opts.limit) : pendingAll;
     const codexCount = sessions.filter((s) => s.source === "codex").length;
+    const pendingCodex = pending.filter((s) => s.source === "codex").length;
     return {
         sessions,
         pending,
@@ -766,6 +781,8 @@ export function discoverMigratableSessions(opts = {}) {
         limited: pending.length < pendingAll.length,
         codexCount,
         claudeCount: sessions.length - codexCount,
+        pendingCodex,
+        pendingClaudeCode: pending.length - pendingCodex,
     };
 }
 /**
@@ -787,6 +804,7 @@ export function discoverPendingSessionsTargeted(processedKeys, opts = {}) {
         if (s)
             pending.push(s);
     }
+    const pendingCodex = pending.filter((s) => s.source === "codex").length;
     return {
         sessions: pending,
         pending,
@@ -796,6 +814,8 @@ export function discoverPendingSessionsTargeted(processedKeys, opts = {}) {
         limited: filtered.limited,
         codexCount: filtered.codexCount,
         claudeCount: filtered.claudeCount,
+        pendingCodex,
+        pendingClaudeCode: pending.length - pendingCodex,
         accountChecked: filtered.accountChecked,
         accountCheckFailed: filtered.accountCheckFailed,
         accountCheckUnavailable: filtered.accountCheckUnavailable,
@@ -808,6 +828,7 @@ export function applyAccountImportStatus(discovery, processedKeys, opts = {}) {
     const skippedActive = discovery.sessions.length - selectableSessions.length;
     const pendingAll = selectableSessions.filter((s) => !processedKeys.has(s.conversationKey));
     const pending = opts.limit && opts.limit > 0 ? pendingAll.slice(0, opts.limit) : pendingAll;
+    const pendingCodex = pending.filter((s) => s.source === "codex").length;
     return {
         ...discovery,
         pending,
@@ -815,6 +836,8 @@ export function applyAccountImportStatus(discovery, processedKeys, opts = {}) {
         alreadyMigrated: selectableSessions.length - pendingAll.length,
         skippedActive,
         limited: pending.length < pendingAll.length,
+        pendingCodex,
+        pendingClaudeCode: pending.length - pendingCodex,
         accountChecked: true,
         accountCheckFailed: false,
         accountCheckUnavailable: false,
@@ -827,6 +850,7 @@ export function applyFastAccountImportStatus(discovery, processedKeys, opts = {}
     const skippedActive = discovery.sessions.length - selectableSessions.length;
     const pendingAll = selectableSessions.filter((s) => !processedKeys.has(s.conversationKey));
     const pending = opts.limit && opts.limit > 0 ? pendingAll.slice(0, opts.limit) : pendingAll;
+    const pendingCodex = pending.filter((s) => s.source === "codex").length;
     return {
         ...discovery,
         pending,
@@ -834,6 +858,8 @@ export function applyFastAccountImportStatus(discovery, processedKeys, opts = {}
         alreadyMigrated: selectableSessions.length - pendingAll.length,
         skippedActive,
         limited: pending.length < pendingAll.length,
+        pendingCodex,
+        pendingClaudeCode: pending.length - pendingCodex,
         accountChecked: true,
         accountCheckFailed: false,
         accountCheckUnavailable: false,
@@ -1226,7 +1252,7 @@ export async function cmdMigrate(flags) {
                 : "This account is ENCRYPTED but the vault is locked. Run `echomem-mcp unlock`, then re-run migrate.");
         }
         else if (code === "FORBIDDEN_SCOPE") {
-            console.error("This device token cannot import history. Re-connect this device with `echomem-mcp setup`.");
+            console.error("This device token cannot import history. Re-connect this device with `echomem-mcp login`.");
         }
         else {
             console.error(c.red(`Could not start the import: ${responseMessage(e)}`));