@echomem/mcp 1.4.6 → 1.4.8

package/dist/index.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
 import axios from "axios";
 import { ZodError } from "zod";
-import { canonicalToolNames, deleteMemorySchema, getByContextSchema, keywordsSchema, listToolSpecs, othersSchema, resolveCanonicalToolName, saveConversationSchema, searchMemoriesSchema, timeRangeSchema, } from "./v1-contract.js";
+import { canonicalToolNames, deleteMemorySchema, getByContextSchema, keywordsSchema, listFriendsSchema, listToolSpecs, othersSchema, publicMemorySchema, resolveCanonicalToolName, saveConversationSchema, searchMemoriesSchema, searchUsersSchema, sendFriendRequestSchema, timeRangeSchema, } from "./v1-contract.js";
 import { KeyStore } from "./keystore.js";
 import { EventLogger, hashText } from "./events.js";
 import { buildReportText } from "./report.js";
@@ -15,7 +15,6 @@ import { runCli } from "./setup.js";
 import { MCP_PACKAGE_VERSION, MCP_SERVER_INSTRUCTIONS } from "./package-metadata.js";
 import { checkLatestUpdateStatus, formatUpdateNotice, formatUpdateStatusText, startBackgroundUpdateCheck, } from "./update-check.js";
 const ECHO_API_BASE_URL = process.env.ECHO_API_BASE_URL || "https://echo-mem-chrome.vercel.app";
-const MEMORY_FEED_API_URL = process.env.MEMORY_FEED_API_URL || "https://memory-feed.vercel.app";
 /** Thrown when no API token is present yet — the model gets a "run login" nudge, not a hard error. */
 class NoTokenError extends Error {
 }
@@ -274,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;
@@ -379,6 +395,22 @@ function inputAnalyticsForTool(canonicalName, args) {
                 keyword_count: Array.isArray(a.keywords) ? a.keywords.length : 0,
                 limit: numberArg(a, "limit"),
             };
+        case canonicalToolNames.searchUsers: {
+            const query = readString(a, "query");
+            const queryAnalytics = safeTextAnalytics("query", query);
+            return {
+                ...queryAnalytics,
+                query_preview_safe: queryAnalytics.query_preview,
+                query_length: query?.length ?? 0,
+                limit: numberArg(a, "limit"),
+            };
+        }
+        case canonicalToolNames.sendFriendRequest: {
+            const targetUserId = readString(a, "targetUserId");
+            return {
+                target_user_id_hash: targetUserId ? hashText(targetUserId) : undefined,
+            };
+        }
         case canonicalToolNames.others: {
             const query = readString(a, "query");
             const queryAnalytics = safeTextAnalytics("query", query);
@@ -386,6 +418,13 @@ function inputAnalyticsForTool(canonicalName, args) {
                 ...queryAnalytics,
                 query_preview_safe: queryAnalytics.query_preview,
                 query_length: query?.length ?? 0,
+                limit: numberArg(a, "limit"),
+            };
+        }
+        case canonicalToolNames.publicMemory: {
+            const memoryId = readString(a, "memoryId");
+            return {
+                memory_id_hash: memoryId ? hashText(memoryId) : undefined,
             };
         }
         default:
@@ -623,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;
@@ -671,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.");
@@ -702,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) {
@@ -746,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,
@@ -756,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,
@@ -765,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,
@@ -773,21 +812,73 @@ class EchoMemApiClient {
         });
         return enc.enabled ? await this.decryptResult(response.data, enc.key) : response.data;
     }
+    async listFriends(args) {
+        listFriendsSchema.parse(args ?? {});
+        try {
+            const response = await this.axios.get("/api/extension/social/friends");
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`list_friends failed against ${ECHO_API_BASE_URL}: ${describeError(error)}`);
+        }
+    }
+    async searchUsers(args) {
+        const parsed = searchUsersSchema.parse(args ?? {});
+        try {
+            const response = await this.axios.post("/api/extension/social/users/search", {
+                query: parsed.query,
+                limit: parsed.limit,
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`search_users failed against ${ECHO_API_BASE_URL}: ${describeError(error)}`);
+        }
+    }
+    async sendFriendRequest(args) {
+        const parsed = sendFriendRequestSchema.parse(args ?? {});
+        try {
+            const response = await this.axios.post("/api/extension/social/friend-requests", {
+                receiverUserId: parsed.targetUserId,
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`send_friend_request failed against ${ECHO_API_BASE_URL}: ${describeError(error)}`);
+        }
+    }
     async searchOthersMemories(args) {
-        const parsed = othersSchema.parse(args);
+        const parsed = othersSchema.parse(args ?? {});
         try {
-            const response = await axios.post(`${MEMORY_FEED_API_URL.replace(/\/$/, "")}/api/search/public`, {
+            const response = await this.axios.post("/api/extension/social/public-memories/search", {
                 query: parsed.query,
-                excludedMemoryIds: [],
-            }, {
-                headers: {
-                    "Content-Type": "application/json",
-                },
+                limit: parsed.limit,
+                target: parsed.target,
+                ownerUserId: parsed.ownerUserId,
+                ownerName: parsed.ownerName,
+                targetFriendIds: parsed.targetFriendIds,
+                targetFriendNames: parsed.targetFriendNames,
+                recordAccess: parsed.recordAccess,
+                kPerUser: parsed.kPerUser,
+                similarityThreshold: parsed.similarityThreshold,
+                timeFrameDays: parsed.timeFrameDays,
+                requestId: this.sessionId,
+                source: "mcp_friend_public_memory_search",
             });
             return response.data;
         }
         catch (error) {
-            throw new Error(`search_others_memories failed against ${MEMORY_FEED_API_URL}: ${describeError(error)}`);
+            throw new Error(`search_others_memories failed against ${ECHO_API_BASE_URL}: ${describeError(error)}`);
+        }
+    }
+    async getPublicMemory(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;
+        }
+        catch (error) {
+            throw new Error(`get_public_memory failed against ${ECHO_API_BASE_URL}: ${describeError(error)}`);
         }
     }
 }
@@ -952,10 +1043,20 @@ 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:
+                        return await this.handleFriends(request.params.arguments);
+                    case canonicalToolNames.searchUsers:
+                        return await this.handleSearchUsers(request.params.arguments);
+                    case canonicalToolNames.sendFriendRequest:
+                        return await this.handleSendFriendRequest(request.params.arguments);
                     case canonicalToolNames.others:
                         return await this.handleOthers(request.params.arguments);
+                    case canonicalToolNames.publicMemory:
+                        return await this.handlePublicMemory(request.params.arguments);
                     case canonicalToolNames.delete:
                         return await this.handleDelete(request.params.arguments, rec);
                     default:
@@ -1172,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}`);
@@ -1197,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}`);
@@ -1221,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}`);
@@ -1247,32 +1402,183 @@ 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) {
+            const scope = parsed.ownerUserId
+                ? ` for friend ${parsed.ownerUserId}`
+                : parsed.ownerName
+                    ? ` for friend ${parsed.ownerName}`
+                    : parsed.target
+                        ? ` for friend ${parsed.target}`
+                        : parsed.targetFriendIds?.length
+                            ? ` for ${parsed.targetFriendIds.length} selected friends`
+                            : parsed.targetFriendNames?.length
+                                ? ` for ${parsed.targetFriendNames.length} named friends`
+                                : "";
+            const queryLabel = parsed.query?.trim() ? ` matching the query: ${parsed.query}` : "";
             return {
-                content: [{ type: "text", text: `No others' memories found matching the query: ${parsed.query}` }],
+                content: [{ type: "text", text: `No others' public memories found${scope}${queryLabel}` }],
             };
         }
+        const metadata = [
+            typeof payload?.friendCount === "number" ? `friendCount=${payload.friendCount}` : "",
+            typeof payload?.searchedFriendCount === "number" ? `searchedFriendCount=${payload.searchedFriendCount}` : "",
+            typeof payload?.memoryViewsInserted === "number" ? `memoryViewsInserted=${payload.memoryViewsInserted}` : "",
+        ].filter(Boolean).join(", ");
         const formattedResults = memories
-            .map((m, idx) => `[${idx + 1}] User Name: ${m.user_name || "Anonymous"}
+            .map((m, idx) => {
+            const score = typeof m.final_score === "number"
+                ? m.final_score
+                : typeof m.similarity_score === "number"
+                    ? m.similarity_score
+                    : undefined;
+            return `[${idx + 1}] Memory ID: ${m.id || "unknown"}
+User ID: ${m.user_id || "unknown"}
+User Name: ${m.username || m.user_name || m.name || "Anonymous"}
 Time: ${m.time} | Location: ${m.location}
 Category: ${m.category} | Object: ${m.object}
-Description: ${m.description}
-Details: ${m.details || "N/A"}`)
+${typeof score === "number" ? `Score: ${score}\n` : ""}Description: ${m.description}
+Details: ${m.details || "N/A"}`;
+        })
             .join("\n\n");
         return {
             content: [
                 {
                     type: "text",
-                    text: `Found ${memories.length} others' memories:\n\n${formattedResults}`,
+                    text: `Found ${memories.length} others' public memories${metadata ? ` (${metadata})` : ""}:\n\n${formattedResults}`,
                 },
             ],
         };
     }
+    async handleFriends(args) {
+        listFriendsSchema.parse(args ?? {});
+        const payload = await this.client.listFriends(args);
+        const friends = Array.isArray(payload?.friends) ? payload.friends : [];
+        if (!friends.length) {
+            return {
+                content: [{ type: "text", text: "No accepted EchoMem friends found." }],
+            };
+        }
+        const formatted = friends
+            .map((friend, idx) => {
+            const name = typeof friend.name === "string" && friend.name.trim()
+                ? friend.name.trim()
+                : "Unnamed friend";
+            const userId = typeof friend.user_id === "string" ? friend.user_id : "unknown";
+            const publicMemoryCount = typeof friend.publicMemoryCount === "number"
+                ? friend.publicMemoryCount
+                : 0;
+            return `[${idx + 1}] ${name}\nUser ID: ${userId}\nPublic memories: ${publicMemoryCount}`;
+        })
+            .join("\n\n");
+        const total = typeof payload?.totalPublicMemoryCount === "number"
+            ? payload.totalPublicMemoryCount
+            : friends.reduce((sum, friend) => sum + (typeof friend.publicMemoryCount === "number" ? friend.publicMemoryCount : 0), 0);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Found ${friends.length} accepted friends (totalPublicMemoryCount=${total}):\n\n${formatted}`,
+                }],
+        };
+    }
+    async handleSearchUsers(args) {
+        const parsed = searchUsersSchema.parse(args ?? {});
+        const payload = await this.client.searchUsers(args);
+        const users = Array.isArray(payload?.users) ? payload.users : [];
+        if (!users.length) {
+            return {
+                content: [{ type: "text", text: `No EchoMem users found matching "${parsed.query}".` }],
+            };
+        }
+        const formatted = users
+            .map((user, idx) => {
+            const displayName = typeof user.displayName === "string" && user.displayName.trim()
+                ? user.displayName.trim()
+                : typeof user.username === "string" && user.username.trim()
+                    ? user.username.trim()
+                    : "Unnamed user";
+            const userId = typeof user.userId === "string" ? user.userId : "unknown";
+            const totalMemoryCount = typeof user.totalMemoryCount === "number" ? user.totalMemoryCount : 0;
+            const publicMemoryCount = typeof user.publicMemoryCount === "number" ? user.publicMemoryCount : 0;
+            const relationship = typeof user.relationshipStatus === "string" ? user.relationshipStatus : "none";
+            const pendingRequestId = typeof user.pendingRequestId === "string" && user.pendingRequestId
+                ? `\nPending request ID: ${user.pendingRequestId}`
+                : "";
+            return `[${idx + 1}] ${displayName}\nUser ID: ${userId}\nTotal memories: ${totalMemoryCount}\nPublic memories: ${publicMemoryCount}\nRelationship: ${relationship}${pendingRequestId}`;
+        })
+            .join("\n\n");
+        return {
+            content: [{
+                    type: "text",
+                    text: `Found ${users.length} EchoMem users matching "${parsed.query}":\n\n${formatted}\n\nUse send_friend_request with the exact User ID to send a pending friend request.`,
+                }],
+        };
+    }
+    async handleSendFriendRequest(args) {
+        sendFriendRequestSchema.parse(args ?? {});
+        const payload = await this.client.sendFriendRequest(args);
+        const result = isRecord(payload) ? payload : {};
+        const targetUser = isRecord(result.targetUser) ? result.targetUser : {};
+        const confirmation = isRecord(result.confirmation) ? result.confirmation : {};
+        const request = isRecord(result.request) ? result.request : {};
+        const created = result.created === true;
+        const displayName = readString(targetUser, "displayName") ?? readString(targetUser, "username") ?? "Unnamed user";
+        const userId = readString(targetUser, "userId") ?? "unknown";
+        const relationship = readString(targetUser, "relationshipStatus") ?? "pending_sent";
+        const requestId = readString(request, "id") ?? readString(targetUser, "pendingRequestId") ?? "unknown";
+        const status = readString(confirmation, "status") ?? "pending";
+        const requiresApproval = confirmation.requiresApproval === true;
+        const message = readString(confirmation, "message") ?? "Friend request is pending approval.";
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        created ? "Friend request sent." : "Friend request was not duplicated.",
+                        "",
+                        `Target: ${displayName}`,
+                        `Target User ID: ${userId}`,
+                        `Relationship: ${relationship}`,
+                        `Request ID: ${requestId}`,
+                        `Status: ${status}`,
+                        `Requires approval: ${requiresApproval ? "yes" : "no"}`,
+                        "",
+                        `Confirmation: ${message}`,
+                    ].join("\n"),
+                }],
+        };
+    }
+    async handlePublicMemory(args) {
+        const parsed = publicMemorySchema.parse(args ?? {});
+        const payload = await this.client.getPublicMemory(args);
+        const memory = payload?.memory;
+        if (!memory) {
+            return {
+                content: [{ type: "text", text: `Public memory ${parsed.memoryId} was not found or is not accessible.` }],
+            };
+        }
+        const text = [
+            `Memory ID: ${memory.id || parsed.memoryId}`,
+            `Owner User ID: ${memory.owner_user_id || memory.user_id || "Unknown"}`,
+            memory.time ? `Time: ${memory.time}` : "",
+            memory.location ? `Location: ${memory.location}` : "",
+            memory.category ? `Category: ${memory.category}` : "",
+            memory.object ? `Object: ${memory.object}` : "",
+            memory.emotion ? `Emotion: ${memory.emotion}` : "",
+            memory.keys ? `Keys: ${memory.keys}` : "",
+            `Description: ${memory.description || ""}`,
+            memory.details ? `Details: ${memory.details}` : "",
+            typeof payload.accessRecordsInserted === "number"
+                ? `Access records inserted: ${payload.accessRecordsInserted}`
+                : "",
+        ].filter(Boolean).join("\n");
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
     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;
@@ -1334,7 +1640,28 @@ async function main() {
     if (handled)
         return;
     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 setup",
+            "",
+        ].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/migrate.js

@@ -644,6 +644,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 +653,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 +693,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 +703,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 +763,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 +773,8 @@ export function discoverMigratableSessions(opts = {}) {
         limited: pending.length < pendingAll.length,
         codexCount,
         claudeCount: sessions.length - codexCount,
+        pendingCodex,
+        pendingClaudeCode: pending.length - pendingCodex,
     };
 }
 /**
@@ -787,6 +796,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 +806,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 +820,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 +828,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 +842,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 +850,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,