@echomem/mcp 1.4.41 → 1.4.42

package/dist/index.js

@@ -1096,6 +1096,8 @@ class EchoMemApiClient {
                 kPerUser: parsed.kPerUser,
                 similarityThreshold: parsed.similarityThreshold,
                 timeFrameDays: parsed.timeFrameDays,
+                workspaceId: parsed.workspaceId ?? parsed.groupId,
+                scope: parsed.scope,
                 requestId: this.sessionId,
                 source: "mcp_friend_public_memory_search",
             });
@@ -1108,7 +1110,14 @@ class EchoMemApiClient {
     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`);
+            const workspaceId = parsed.workspaceId ?? parsed.groupId;
+            const query = new URLSearchParams({
+                requestId: this.sessionId,
+                source: "mcp_friend_public_memory_fetch",
+            });
+            if (workspaceId)
+                query.set("workspaceId", workspaceId);
+            const response = await this.axios.get(`/api/extension/social/public-memories/${encodeURIComponent(parsed.memoryId)}?${query.toString()}`);
             return response.data;
         }
         catch (error) {
@@ -1131,9 +1140,13 @@ class EchoMemApiClient {
         }
     }
     async getGroupContext(args) {
-        groupContextSchema.parse(args ?? {});
+        const parsed = groupContextSchema.parse(args ?? {});
         try {
-            const response = await this.axios.get("/api/extension/social/groups/current");
+            const workspaceId = parsed.workspaceId ?? parsed.groupId;
+            const path = workspaceId
+                ? `/api/extension/social/groups/current?workspaceId=${encodeURIComponent(workspaceId)}`
+                : "/api/extension/social/groups/current";
+            const response = await this.axios.get(path);
             return response.data;
         }
         catch (error) {
@@ -1197,6 +1210,7 @@ class EchoMemApiClient {
         const enc = await this.encState();
         try {
             const response = await this.axios.post(`/api/extension/social/groups/current/memories/${encodeURIComponent(parsed.memoryId)}/publish`, {
+                workspaceId: parsed.workspaceId ?? parsed.groupId,
                 acknowledgedFlaggedMemoryIds: parsed.acknowledgedFlaggedMemoryIds,
             }, {
                 headers: enc.enabled && enc.key ? { "X-Encryption-Key": enc.key } : undefined,
@@ -1212,6 +1226,7 @@ class EchoMemApiClient {
         const enc = await this.encState();
         try {
             const response = await this.axios.post("/api/extension/social/groups/current/memories/publish-batch", {
+                workspaceId: parsed.workspaceId ?? parsed.groupId,
                 memoryIds: parsed.memoryIds,
                 contextId: parsed.contextId,
                 selectionReason: parsed.selectionReason,
@@ -1995,6 +2010,28 @@ Details: ${m.details || "N/A"}`)
     async handleOthers(args) {
         const parsed = othersSchema.parse(args ?? {});
         const payload = await this.client.searchOthersMemories(args);
+        if (payload?.requiresWorkspaceSelection === true) {
+            const availableWorkspaces = Array.isArray(payload?.availableWorkspaces)
+                ? payload.availableWorkspaces.filter(isRecord)
+                : [];
+            const choices = availableWorkspaces
+                .map((workspace) => `${readString(workspace, "name") ?? "Unnamed workspace"} (${readString(workspace, "id") ?? "unknown id"})`)
+                .join(", ");
+            return {
+                content: [{
+                        type: "text",
+                        text: `You belong to ${availableWorkspaces.length} workspaces: ${choices}. Ask the user which workspace's teammates to search, then call search_others_memories again with workspaceId set to one of those ids. (To search a specific friend instead, pass that person as target.)`,
+                    }],
+            };
+        }
+        if (payload?.groupScopeUnavailable === true) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "You are not in a company workspace, so there are no teammates to search. To search friends instead, call search_others_memories again with scope \"friends\", or pass a specific person as target.",
+                    }],
+            };
+        }
         const memories = payload?.memories ?? [];
         const authenticatedViewer = isRecord(payload?.authenticatedViewer)
             ? payload.authenticatedViewer
@@ -2216,6 +2253,20 @@ Details: ${m.details || "N/A"}`;
     async handleGroupContext(args) {
         groupContextSchema.parse(args ?? {});
         const payload = await this.client.getGroupContext(args);
+        if (payload?.requiresWorkspaceSelection === true) {
+            const availableWorkspaces = Array.isArray(payload?.availableWorkspaces)
+                ? payload.availableWorkspaces.filter(isRecord)
+                : [];
+            const choices = availableWorkspaces
+                .map((workspace) => `${readString(workspace, "name") ?? "Unnamed workspace"} (${readString(workspace, "id") ?? "unknown id"})`)
+                .join(", ");
+            return {
+                content: [{
+                        type: "text",
+                        text: `You belong to ${availableWorkspaces.length} workspaces: ${choices}. Ask the user which workspace to show context for, then call get_group_context again with workspaceId set to one of those ids.`,
+                    }],
+            };
+        }
         const group = isRecord(payload?.group) ? payload.group : null;
         const participants = Array.isArray(payload?.participants)
             ? payload.participants.filter(isRecord)

package/dist/setup.js

@@ -416,13 +416,70 @@ export function writeJsonClientConfig(configPath, entry) {
     fs.mkdirSync(path.dirname(configPath), { recursive: true });
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
 }
-export function writeClaudeCodeConfig(entry) {
-    // EchoMem is a memory server that should load in EVERY Claude Code project, so it belongs at
-    // `user` scope (~/.claude.json, all projects) rather than `local` scope (the current project only).
-    const addArguments = ["mcp", "add-json", "-s", "user", "echomem", JSON.stringify(entry)];
-    const removeFromScope = (scope) => {
+function readClaudeCodeConfigFile(configPath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function echoMemEntryFromServers(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const entry = value.echomem;
+    return entry && typeof entry === "object" && !Array.isArray(entry)
+        ? entry
+        : undefined;
+}
+function claudeEntriesMatch(actual, expected) {
+    if (!actual || actual.command !== expected.command)
+        return false;
+    const actualArgs = Array.isArray(actual.args) ? actual.args : [];
+    const expectedArgs = Array.isArray(expected.args) ? expected.args : [];
+    if (actualArgs.length !== expectedArgs.length || actualArgs.some((value, index) => value !== expectedArgs[index])) {
+        return false;
+    }
+    const expectedEnv = expected.env;
+    if (!expectedEnv || typeof expectedEnv !== "object" || Array.isArray(expectedEnv))
+        return true;
+    const actualEnv = actual.env;
+    if (!actualEnv || typeof actualEnv !== "object" || Array.isArray(actualEnv))
+        return false;
+    return Object.entries(expectedEnv).every(([key, value]) => actualEnv[key] === value);
+}
+function claudeCodeLocalEchoMemProjects(configPath) {
+    const projects = readClaudeCodeConfigFile(configPath).projects;
+    if (!projects || typeof projects !== "object" || Array.isArray(projects))
+        return [];
+    return Object.entries(projects)
+        .filter(([, value]) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return false;
+        return Boolean(echoMemEntryFromServers(value.mcpServers));
+    })
+        .map(([projectPath]) => projectPath)
+        .sort();
+}
+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");
+    const emptyResult = () => ({
+        state: "unavailable",
+        removedLocalProjects: [],
+        skippedLocalProjects: [],
+        failedLocalProjects: [],
+        restoredPreviousUserEntry: false,
+    });
+    const runClaude = (args, cwd) => {
         try {
-            execFileSync("claude", ["mcp", "remove", "echomem", "-s", scope], {
+            execFileSync("claude", args, {
+                cwd,
                 encoding: "utf8",
                 stdio: ["ignore", "pipe", "pipe"],
                 timeout: 10000,
@@ -433,39 +490,61 @@ export function writeClaudeCodeConfig(entry) {
             return false;
         }
     };
-    // Older builds installed EchoMem at `local` scope. Left in place it would shadow the user-scoped
-    // entry and keep launching the stale command, so drop it first. Best-effort: `local` is per-project,
-    // so this only clears the directory setup runs from — a no-op (ignored) when nothing is there.
-    removeFromScope("local");
-    try {
-        execFileSync("claude", addArguments, {
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "pipe"],
-            timeout: 10000,
-        });
-        return "wrote";
-    }
-    catch (error) {
-        const stderr = error.stderr;
-        const detail = Buffer.isBuffer(stderr) ? stderr.toString("utf8") : String(stderr ?? "");
-        if (!detail.includes("already exists"))
-            return "unavailable";
-    }
-    // Claude Code's CLI will not replace a same-name server. Once the replacement entry is fully
-    // constructed, remove only EchoMem and immediately re-add it; sibling MCP servers remain.
-    try {
-        if (!removeFromScope("user"))
-            return "unavailable";
-        execFileSync("claude", addArguments, {
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "pipe"],
-            timeout: 10000,
-        });
-        return "wrote";
+    const addUser = (value) => runClaude([
+        "mcp", "add-json", "-s", "user", "echomem", JSON.stringify(value),
+    ]);
+    const removeUser = () => runClaude(["mcp", "remove", "echomem", "-s", "user"]);
+    const before = readClaudeCodeConfigFile(configPath);
+    const previousUserEntry = echoMemEntryFromServers(before.mcpServers);
+    let restoredPreviousUserEntry = false;
+    // Avoid interrupting active/new sessions when the correct global entry is already installed.
+    if (!claudeEntriesMatch(previousUserEntry, entry)) {
+        if (previousUserEntry && !removeUser())
+            return emptyResult();
+        if (!addUser(entry)) {
+            if (previousUserEntry)
+                restoredPreviousUserEntry = addUser(previousUserEntry);
+            return { ...emptyResult(), restoredPreviousUserEntry };
+        }
     }
-    catch {
-        return "unavailable";
+    const installedUserEntry = echoMemEntryFromServers(readClaudeCodeConfigFile(configPath).mcpServers);
+    if (!claudeEntriesMatch(installedUserEntry, entry)) {
+        return { ...emptyResult(), restoredPreviousUserEntry };
+    }
+    const removedLocalProjects = [];
+    const skippedLocalProjects = [];
+    const failedLocalProjects = [];
+    for (const projectPath of claudeCodeLocalEchoMemProjects(configPath)) {
+        // A deleted directory cannot currently shadow user scope. Do not recreate it or hand-edit
+        // ~/.claude.json, which also contains Claude account/session state.
+        if (!fs.existsSync(projectPath)) {
+            skippedLocalProjects.push(projectPath);
+            continue;
+        }
+        let projectCwd = projectPath;
+        try {
+            projectCwd = fs.realpathSync(projectPath);
+        }
+        catch {
+            /* The existence check above already established the safe fallback path. */
+        }
+        if (runClaude(["mcp", "remove", "echomem", "-s", "local"], projectCwd)) {
+            removedLocalProjects.push(projectPath);
+        }
+        else {
+            failedLocalProjects.push(projectPath);
+        }
     }
+    const remainingActiveProjects = claudeCodeLocalEchoMemProjects(configPath)
+        .filter((projectPath) => fs.existsSync(projectPath));
+    const unresolved = [...new Set([...failedLocalProjects, ...remainingActiveProjects])].sort();
+    return {
+        state: unresolved.length > 0 ? "needs-repair" : "wrote",
+        removedLocalProjects,
+        skippedLocalProjects,
+        failedLocalProjects: unresolved,
+        restoredPreviousUserEntry,
+    };
 }
 function readJsonClientEntry(configPath) {
     try {
@@ -2668,6 +2747,7 @@ async function cmdSetup(flags) {
     const entry = buildServerEntry({ devEntryPath: typeof flags.dev === "string" ? flags.dev : undefined });
     const requested = typeof flags.client === "string" ? flags.client : undefined;
     const targets = selectSetupTargets(requested, Boolean(flags.all));
+    const configurationFailures = [];
     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));
@@ -2688,15 +2768,31 @@ async function cmdSetup(flags) {
             }
             else {
                 const result = c.id === "claude-code" ? writeClaudeCodeConfig(entry) : "unavailable";
-                if (result === "wrote") {
+                if (result !== "unavailable" && result.state === "wrote") {
                     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.`);
+                    }
                 }
                 else {
-                    console.log(`ℹ️  ${c.label}: ${c.note}\n   entry: ${JSON.stringify(entry)}`);
+                    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) {
+        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(targets);
     }

package/dist/v1-contract.js

@@ -165,6 +165,42 @@ const triggerMetadataSchema = {
     triggerMessage: z.string().optional(),
     triggerMessageRole: z.string().optional(),
 };
+// Canonical workspace selector for tools that act inside a company workspace.
+// `workspaceId` is the current name; `groupId` is the legacy alias kept working
+// so existing prompts keep functioning. Handlers normalize with
+// normalizeWorkspaceId (workspaceId ?? groupId). Required only when the user
+// belongs to more than one workspace; a single-workspace user may omit it.
+const WORKSPACE_SELECTOR_DESCRIPTION = "Workspace to act in. Required when the user belongs to more than one workspace; omit it when they have a single workspace. If omitted with multiple workspaces, the tool returns the available workspaces so you can ask the user which to use.";
+const workspaceSelectorSchema = {
+    workspaceId: z.string().uuid().optional().describe(WORKSPACE_SELECTOR_DESCRIPTION),
+    groupId: z.string().uuid().optional().describe("Legacy alias for workspaceId."),
+};
+// The advertised JSON-Schema counterpart of workspaceSelectorSchema. Tool
+// inputSchemas are hand-written, so the selector must be injected into every
+// workspace-scoped tool's properties or clients never learn they can pass it.
+const workspaceSelectorProperties = {
+    workspaceId: { type: "string", description: WORKSPACE_SELECTOR_DESCRIPTION },
+    groupId: { type: "string", description: "Legacy alias for workspaceId." },
+};
+const WORKSPACE_SCOPED_TOOL_NAMES = new Set([
+    canonicalToolNames.others,
+    canonicalToolNames.publicMemory,
+    canonicalToolNames.groupContext,
+    canonicalToolNames.createGroupInvite,
+    canonicalToolNames.prepareGroupPublication,
+    canonicalToolNames.updateGroupProfile,
+    canonicalToolNames.publishToGroup,
+    canonicalToolNames.publishBatchToGroup,
+]);
+function injectWorkspaceSelector(specs) {
+    for (const spec of specs) {
+        if (!WORKSPACE_SCOPED_TOOL_NAMES.has(spec.name))
+            continue;
+        const existing = spec.inputSchema.properties ?? {};
+        spec.inputSchema.properties = { ...workspaceSelectorProperties, ...existing };
+    }
+    return specs;
+}
 export const searchMemoriesSchema = z.object({
     ...triggerMetadataSchema,
     query: z.string().trim().min(1).optional(),
@@ -235,6 +271,8 @@ export const sendFriendRequestSchema = z.object({
 });
 export const othersSchema = z.object({
     ...triggerMetadataSchema,
+    ...workspaceSelectorSchema,
+    scope: z.enum(["group", "friends"]).optional(),
     query: z.string().trim().optional().default(""),
     limit: z.number().int().min(1).max(50).optional().default(10),
     target: z.string().optional(),
@@ -249,6 +287,7 @@ export const othersSchema = z.object({
 });
 export const publicMemorySchema = z.object({
     ...triggerMetadataSchema,
+    ...workspaceSelectorSchema,
     memoryId: z.string().min(1),
 });
 export const recordMemoryCitationsSchema = z.object({
@@ -258,6 +297,7 @@ export const recordMemoryCitationsSchema = z.object({
 });
 export const groupContextSchema = z.object({
     ...triggerMetadataSchema,
+    ...workspaceSelectorSchema,
 });
 export const getGroupSessionSharingSchema = z.object({
     ...triggerMetadataSchema,
@@ -282,6 +322,7 @@ export const createGroupSchema = z.object({
 });
 export const createGroupInviteSchema = z.object({
     ...triggerMetadataSchema,
+    ...workspaceSelectorSchema,
     expiresInDays: z.number().int().min(1).max(30).optional(),
     maxUses: z.number().int().min(1).max(100).optional(),
 });
@@ -294,6 +335,7 @@ export const joinGroupSchema = z.object({
 });
 export const prepareGroupPublicationSchema = z.object({
     ...triggerMetadataSchema,
+    ...workspaceSelectorSchema,
     scope: z.enum(["bootstrap", "since_last_scan", "context", "time_range"]).default("since_last_scan"),
     contextId: z.string().min(1).optional(),
     startAt: z.string().optional(),
@@ -310,6 +352,7 @@ export const flagPublicationAttentionSchema = z.object({
 });
 export const updateGroupProfileSchema = z.object({
     ...triggerMetadataSchema,
+    ...workspaceSelectorSchema,
     displayName: z.string().min(1).max(120).optional(),
     title: z.string().min(1).max(160),
     responsibilitySummary: z.string().min(1).max(1000),
@@ -325,11 +368,13 @@ export const completeGroupPublicationSchema = z.object({
 });
 export const publishToGroupSchema = z.object({
     ...triggerMetadataSchema,
+    ...workspaceSelectorSchema,
     memoryId: z.string().min(1),
     acknowledgedFlaggedMemoryIds: z.array(z.string().min(1)).max(1).optional(),
 });
 export const publishBatchToGroupSchema = z.object({
     ...triggerMetadataSchema,
+    ...workspaceSelectorSchema,
     memoryIds: z.array(z.string().min(1)).min(1).max(50),
     contextId: z.string().min(1).optional(),
     selectionReason: z.string().max(500).optional(),
@@ -573,10 +618,15 @@ export function listToolSpecs(opts = {}) {
         {
             name: canonicalToolNames.others,
             title: "Search teammates' and friends' memories",
-            description: `PEER-MEMORY SEARCH for public memories owned by accepted friends or company-group members—not the user's own memories. Pass query for a topic; omit it only when intentionally browsing peer memories, and optionally use target to scope a person. Do not use this tool for the user's private memories or the EchoMem user directory. EchoMem identifies the caller from the EchoMem credential and has already excluded only that authenticated user's own memories. Present every returned owner; never filter again using a Claude account, host profile, git identity, or inference. For onboarding and division-of-work questions, call get_group_context first. Returned memories are recorded in memory_views for the owners. ${memoryCitationInstruction}${groupMapSection}`,
+            description: `PEER-MEMORY SEARCH for public memories owned by accepted friends or company-group members—not the user's own memories. Pass query for a topic. Set scope to pick the audience — 'group' (only workspace teammates) or 'friends' (only friends) — or target for one person; scope defaults to teammates. Do not use this tool for the user's private memories or the EchoMem user directory. EchoMem identifies the caller from the EchoMem credential and has already excluded only that authenticated user's own memories. Present every returned owner; never filter again using a Claude account, host profile, git identity, or inference. For onboarding and division-of-work questions, call get_group_context first. Returned memories are recorded in memory_views for the owners. ${memoryCitationInstruction}${groupMapSection}`,
             inputSchema: {
                 type: "object",
                 properties: {
+                    scope: {
+                        type: "string",
+                        enum: ["group", "friends"],
+                        description: "Audience to search. 'group' = only the named workspace's teammates (you'll be asked which if the user is in several and names none). 'friends' = only accepted friends. For one specific person, omit scope and pass target instead. Omitting scope defaults to the group/teammates audience.",
+                    },
                     query: {
                         type: "string",
                         description: "Optional peer-memory topic. Omit only for an intentional broad browse; never send this field as conversation.",
@@ -584,7 +634,7 @@ export function listToolSpecs(opts = {}) {
                     limit: { type: "integer", minimum: 1, maximum: 50, default: 10 },
                     target: {
                         type: "string",
-                        description: "Accessible friend or group-member user id or exact display name. Prefer this for @Name asks.",
+                        description: "Accessible friend or group-member user id or exact display name. Prefer this for @Name asks or a single specific person.",
                     },
                     ownerUserId: {
                         type: "string",
@@ -1021,5 +1071,5 @@ export function listToolSpecs(opts = {}) {
             },
         },
     ];
-    return tools.map(decorateLocalToolSpec);
+    return injectWorkspaceSelector(tools).map(decorateLocalToolSpec);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@echomem/mcp",
-  "version": "1.4.41",
+  "version": "1.4.42",
   "description": "EchoMem MCP bridge: cloud-first memory tools and the Agent Doctor workspace forensics report (cost ledger + 3D repo city)",
   "main": "dist/index.js",
   "type": "module",
@@ -33,7 +33,7 @@
     "test:ui": "npm run build && node test/setup-ui.test.mjs",
     "test:onboarding-resilience": "npm run build && node test/onboarding-resilience.test.mjs",
     "test:billing-ui": "npm run build && node test/setup-ui.test.mjs billing",
-    "test": "npm run build && node test/source-session.test.mjs && node test/source-session-hook.test.mjs && node test/local-data-paths.test.mjs && node test/crypto.test.mjs && node test/integration.test.mjs && node test/onboarding-resilience.test.mjs && node test/local-auth.test.mjs && node test/retrieval-only.test.mjs && node test/no-restart.test.mjs && node test/report.test.mjs && node test/forensics.test.mjs && node test/canonical-golden.test.mjs && node test/tools.test.mjs && node test/group-map.test.mjs && node test/update-check.test.mjs && node test/headless-runtime.test.mjs && node test/claude-code-config.test.mjs && node test/delete.test.mjs && node test/low-touch-tools.test.mjs && node test/migrate.test.mjs && node test/restart-recovery.test.mjs && node test/save-checkpoint-hook.test.mjs",
+    "test": "npm run build && node test/source-session.test.mjs && node test/source-session-hook.test.mjs && node test/local-data-paths.test.mjs && node test/crypto.test.mjs && node test/integration.test.mjs && node test/onboarding-resilience.test.mjs && node test/local-auth.test.mjs && node test/retrieval-only.test.mjs && node test/no-restart.test.mjs && node test/report.test.mjs && node test/forensics.test.mjs && node test/canonical-golden.test.mjs && node test/tools.test.mjs && node test/workspace-selector.test.mjs && node test/group-map.test.mjs && node test/update-check.test.mjs && node test/headless-runtime.test.mjs && node test/claude-code-config.test.mjs && node test/delete.test.mjs && node test/low-touch-tools.test.mjs && node test/migrate.test.mjs && node test/restart-recovery.test.mjs && node test/save-checkpoint-hook.test.mjs",
     "prepack": "npm run build && node scripts/bundle-city.mjs"
   },
   "dependencies": {