@xmemo/client 0.4.166 → 0.4.169

package/README.md

@@ -193,6 +193,27 @@ configure MCP only. Use `--dry-run` to preview without writing config or profile
 files, and `--profile-target <path>` to choose a different behavior profile
 target.
 
+### Uninstall
+
+Remove the XMemo MCP server entry from one or all detected client configs:
+
+```bash
+xmemo uninstall --all --dry-run
+xmemo uninstall --all --yes
+xmemo uninstall cursor --yes
+xmemo uninstall --all --yes --profiles
+```
+
+`xmemo uninstall --all` scans the same clients as `setup --all` and removes only
+the `XMemo` entry (and legacy names such as `memory_os`) from each detected
+config file. Other MCP servers are preserved. By default it shows a summary and
+asks for confirmation; pass `--yes` (or `-y`) to skip the prompt, or `--dry-run`
+to preview without modifying files.
+
+Pass `--profiles` to also remove installed behavior profiles (Codex `AGENTS.md`,
+Cursor memory profile, etc.). Identity files and credentials are not removed, so
+a later `xmemo setup --all` can re-enable XMemo with the same agent instance ID.
+
 Default behavior profile targets:
 
 ```text

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmemo/client",
-  "version": "0.4.166",
+  "version": "0.4.169",
   "description": "Privacy-first CLI and MCP setup helper for XMemo.",
   "mcpName": "io.github.yonro/xmemo",
   "type": "module",
@@ -17,7 +17,7 @@
   ],
   "scripts": {
     "lint": "node scripts/check-js.mjs",
-    "test": "node --test",
+    "test": "node --test \"test/**/*.test.js\"",
     "pack:dry-run": "npm pack --dry-run",
     "prepublishOnly": "npm run lint && npm test && npm run pack:dry-run"
   },

package/src/cli.js

@@ -16,6 +16,7 @@ import {
 import { mcpCommand } from './commands/mcp.js';
 import { profileCommand } from './commands/profile.js';
 import { setupCommand } from './commands/setup.js';
+import { uninstallCommand } from './commands/uninstall.js';
 import { updateCommand } from './commands/update.js';
 import { envCommand, writePrivacy } from './config/env.js';
 import { UsageError } from './core/errors.js';
@@ -56,6 +57,10 @@ export async function run(args, io = defaultIo()) {
       return await setupCommand(args.slice(1), io);
     }
 
+    if (command === 'uninstall') {
+      return await uninstallCommand(args.slice(1), io);
+    }
+
     if (command === 'login') {
       return await loginCommand(args.slice(1), io);
     }

package/src/commands/setup.js

@@ -8,6 +8,10 @@ import { baseUrlOption } from '../network/base-url.js';
 import {
   DEFAULT_PROXY_PORT
 } from '../core/constants.js';
+import {
+  autoScanClientIds,
+  detectedSetupTargets
+} from '../mcp/clients/scan.js';
 import {
   buildSetupPlan,
   ensureDiscoveryService
@@ -24,7 +28,7 @@ import {
   supportedMcpClients
 } from '../mcp/clients.js';
 import { mergeCopilotMcpConfig } from '../mcp/proxy/copilot.js';
-import { detectClient } from '../mcp/clients/detect.js';
+
 import {
   agentIdentity,
   envReferenceIdentity
@@ -66,6 +70,7 @@ export async function setupCommand(args, io) {
   }
 
   const dryRun = hasFlag(optionArgs, '--dry-run') || hasFlag(optionArgs, '--preview');
+  const force = hasFlag(optionArgs, '--force');
   const writeConfig = !dryRun && (hasFlag(optionArgs, '--write') || hasFlag(optionArgs, '--yes') || shortClientSetup || (setupAll && (hasFlag(optionArgs, '--write') || hasFlag(optionArgs, '--yes'))));
   const timeoutMs = parsePositiveInteger(optionValue(optionArgs, '--timeout-ms') ?? '5000', '--timeout-ms');
 
@@ -92,49 +97,48 @@ export async function setupCommand(args, io) {
 
   if (setupAll) {
     setupPlan.detectedClients = [];
-    const scanIds = ['codex', 'cursor', 'copilot-cli', 'gemini-cli', 'antigravity', 'antigravity-ide', 'antigravity2', 'antigravity-cli', 'windsurf', 'cline', 'continue', 'claude-desktop', 'qwen', 'opencode', 'trae', 'trae-solo'];
-    for (const scanId of scanIds) {
-      const detection = await detectClient(scanId, io.env, MCP_CLIENTS);
-      if (detection.detected) {
-        let clientPlan;
-        if (scanId === 'copilot-cli') {
-          const proxyPort = parsePositiveInteger(optionValue(optionArgs, '--port') ?? String(DEFAULT_PROXY_PORT), '--port');
-          clientPlan = copilotSetupPlan(setupPlan.mcpUrl, proxyPort, io.env);
-          clientPlan.configPath = detection.path;
-          if (writeConfig) {
-            await mergeCopilotMcpConfig(clientPlan.configPath, clientPlan.proxyUrl);
-            clientPlan.written = true;
-          }
-        } else {
-          const client = MCP_CLIENTS.get(scanId);
-          const identity = writeConfig ? await agentIdentity(scanId, io.env) : envReferenceIdentity(scanId);
-          clientPlan = clientSetupPlan(scanId, client, setupPlan.mcpUrl, io.env, identity);
-          clientPlan.configPath = detection.path;
-          if (writeConfig) {
-            await client.writeConfig(clientPlan.configPath, setupPlan.mcpUrl, identity);
-            clientPlan.written = true;
-            if (profileClientConfig(scanId)) {
-              const installProfile = hasFlag(optionArgs, '--yes') || hasFlag(optionArgs, '--profile');
-              if (installProfile) {
-                const profileTarget = defaultProfileTarget(scanId, io.env);
-                const profileResult = await profileInstallResult(scanId, profileTarget, { write: true });
-                clientPlan.behaviorProfile = profileResult;
-                if (scanId === 'codex') {
-                  clientPlan.codexProfile = profileResult;
-                }
+    const scanIds = autoScanClientIds(MCP_CLIENTS);
+    const targets = await detectedSetupTargets(scanIds, io.env, MCP_CLIENTS);
+    for (const target of targets) {
+      const scanId = target.clientId;
+      let clientPlan;
+      if (scanId === 'copilot-cli') {
+        const proxyPort = parsePositiveInteger(optionValue(optionArgs, '--port') ?? String(DEFAULT_PROXY_PORT), '--port');
+        clientPlan = copilotSetupPlan(setupPlan.mcpUrl, proxyPort, io.env);
+        clientPlan.configPath = target.configPath;
+        if (writeConfig) {
+          await mergeCopilotMcpConfig(clientPlan.configPath, clientPlan.proxyUrl, force);
+          clientPlan.written = true;
+        }
+      } else {
+        const client = MCP_CLIENTS.get(scanId);
+        const identity = writeConfig ? await agentIdentity(scanId, io.env) : envReferenceIdentity(scanId);
+        clientPlan = clientSetupPlan(scanId, client, setupPlan.mcpUrl, io.env, identity);
+        clientPlan.configPath = target.configPath;
+        if (writeConfig) {
+          await client.writeConfig(clientPlan.configPath, setupPlan.mcpUrl, identity, { force });
+          clientPlan.written = true;
+          if (profileClientConfig(scanId)) {
+            const installProfile = hasFlag(optionArgs, '--yes') || hasFlag(optionArgs, '--profile');
+            if (installProfile) {
+              const profileTarget = defaultProfileTarget(scanId, io.env);
+              const profileResult = await profileInstallResult(scanId, profileTarget, { write: true });
+              clientPlan.behaviorProfile = profileResult;
+              if (scanId === 'codex') {
+                clientPlan.codexProfile = profileResult;
               }
             }
           }
         }
-        setupPlan.detectedClients.push(clientPlan);
       }
+      setupPlan.detectedClients.push(clientPlan);
     }
   } else if (clientId) {
     if (clientId === 'copilot-cli') {
       const proxyPort = parsePositiveInteger(optionValue(optionArgs, '--port') ?? String(DEFAULT_PROXY_PORT), '--port');
       setupPlan.selectedClient = copilotSetupPlan(setupPlan.mcpUrl, proxyPort, io.env);
       if (writeConfig) {
-        await mergeCopilotMcpConfig(setupPlan.selectedClient.configPath, setupPlan.selectedClient.proxyUrl);
+        await mergeCopilotMcpConfig(setupPlan.selectedClient.configPath, setupPlan.selectedClient.proxyUrl, force);
         setupPlan.selectedClient.written = true;
       }
     } else {
@@ -146,7 +150,7 @@ export async function setupCommand(args, io) {
       const identity = writeConfig ? await agentIdentity(clientId, io.env) : envReferenceIdentity(clientId);
       setupPlan.selectedClient = clientSetupPlan(clientId, client, setupPlan.mcpUrl, io.env, identity);
       if (writeConfig) {
-        await client.writeConfig(setupPlan.selectedClient.configPath, setupPlan.mcpUrl, identity);
+        await client.writeConfig(setupPlan.selectedClient.configPath, setupPlan.mcpUrl, identity, { force });
         setupPlan.selectedClient.written = true;
       }
 

package/src/commands/uninstall.js

@@ -0,0 +1,238 @@
+import { hasFlag, optionValue } from '../core/args.js';
+import {
+  MCP_SERVER_NAME
+} from '../core/constants.js';
+import { UsageError } from '../core/errors.js';
+import { writeLine } from '../core/io.js';
+import { MCP_CLIENTS } from '../mcp/clients.js';
+import {
+  autoScanClientIds,
+  existingUninstallTargets
+} from '../mcp/clients/scan.js';
+import { removeCopilotMcpConfig } from '../mcp/proxy/copilot.js';
+import {
+  profileClientConfig,
+  profileUninstallResult
+} from '../config/profile.js';
+import {
+  normalizeSetupClientId,
+  positionalClientArg,
+  supportedSetupClientIds
+} from '../ui/setup.js';
+import { confirmUninstall, writeUninstallSummary } from '../ui/uninstall.js';
+
+export async function uninstallCommand(args, io) {
+  const positionalClientId = positionalClientArg(args, MCP_CLIENTS);
+  const optionArgs = positionalClientId ? args.slice(1) : args;
+  const uninstallAll = hasFlag(optionArgs, '--all');
+  const outputJson = hasFlag(optionArgs, '--json');
+
+  let clientId = null;
+  try {
+    clientId = normalizeSetupClientId(positionalClientId ?? optionValue(optionArgs, '--client'), MCP_CLIENTS);
+  } catch (error) {
+    if (!uninstallAll) {
+      throw error;
+    }
+  }
+
+  if (uninstallAll && clientId) {
+    throw new UsageError('Cannot specify both --all and a specific client.');
+  }
+
+  if (!uninstallAll && !clientId) {
+    throw new UsageError(`Uninstall requires --all, --client <${supportedSetupClientIds(MCP_CLIENTS).join('|')}>, or a positional client id.`);
+  }
+
+  const dryRun = hasFlag(optionArgs, '--dry-run') || hasFlag(optionArgs, '--preview');
+  const skipConfirm = hasFlag(optionArgs, '--yes') || hasFlag(optionArgs, '-y');
+  const removeProfiles = hasFlag(optionArgs, '--profiles');
+  const profileTargetOverride = optionValue(optionArgs, '--target') ?? optionValue(optionArgs, '--profile-target');
+
+  if (uninstallAll && profileTargetOverride) {
+    throw new UsageError('Cannot specify --target or --profile-target with --all.');
+  }
+
+  const targetIds = uninstallAll ? autoScanClientIds(MCP_CLIENTS) : [clientId];
+  let targets = await existingUninstallTargets(targetIds, io.env, MCP_CLIENTS);
+
+  if (targets.length === 0 && removeProfiles && !uninstallAll) {
+    const client = MCP_CLIENTS.get(clientId);
+    targets.push({
+      clientId,
+      label: client?.label ?? clientId,
+      configPath: null,
+      configKind: 'none'
+    });
+  }
+
+  const previewOptions = {
+    removeProfiles,
+    profileTargetOverride,
+    preview: true
+  };
+  const plan = await buildUninstallPlan(targets, io, previewOptions);
+
+  if (dryRun || (outputJson && !skipConfirm)) {
+    if (outputJson) {
+      writeLine(io.stdout, JSON.stringify(plan, null, 2));
+    } else {
+      writeUninstallSummary(plan, io);
+    }
+    return plan.errors.length > 0 ? 1 : 0;
+  }
+
+  if (plan.removed.length === 0 && plan.errors.length === 0) {
+    if (outputJson) {
+      writeLine(io.stdout, JSON.stringify(plan, null, 2));
+    } else {
+      writeUninstallSummary(plan, io);
+    }
+    return 0;
+  }
+
+  if (!outputJson) {
+    writeUninstallSummary(plan, io);
+  }
+
+  if (!skipConfirm) {
+    if (io.stdin.isTTY === false) {
+      throw new UsageError('Uninstall requires --yes or --dry-run when stdin is not interactive.');
+    }
+    const confirmed = await confirmUninstall(plan, io);
+    if (!confirmed) {
+      writeLine(io.stdout, 'Uninstall cancelled.');
+      return 0;
+    }
+  }
+
+  const result = await buildUninstallPlan(targets, io, {
+    removeProfiles,
+    profileTargetOverride,
+    preview: false
+  });
+  if (outputJson) {
+    writeLine(io.stdout, JSON.stringify(result, null, 2));
+  } else {
+    writeUninstallSummary(result, io);
+  }
+  return result.errors.length > 0 ? 1 : 0;
+}
+
+async function buildUninstallPlan(targets, io, options) {
+  const plan = {
+    dryRun: options.preview,
+    write: !options.preview,
+    profiles: options.removeProfiles,
+    removed: [],
+    skipped: [],
+    errors: []
+  };
+
+  for (const target of targets) {
+    const configResult = await removeConfigForTarget(target, options.preview);
+    const entry = {
+      id: target.clientId,
+      label: target.label,
+      configPath: target.configPath,
+      configStatus: configResult.status,
+      removedNames: configResult.removedNames ?? []
+    };
+
+    if (configResult.status === 'removed') {
+      entry.configChanged = true;
+    } else if (configResult.status === 'not_found' || configResult.status === 'missing') {
+      entry.configChanged = false;
+    } else if (configResult.status === 'error') {
+      entry.error = configResult.error;
+      plan.errors.push({
+        id: target.clientId,
+        label: target.label,
+        configPath: target.configPath,
+        phase: 'config',
+        error: configResult.error
+      });
+    }
+
+    if (options.removeProfiles) {
+      const profileResult = await removeProfileForTarget(target, io.env, options);
+      entry.profilePath = profileResult.targetPath;
+      entry.profileStatus = profileResult.status;
+      if (profileResult.status === 'removed') {
+        entry.profileChanged = true;
+      } else if (profileResult.status === 'not_found') {
+        entry.profileChanged = false;
+      } else if (profileResult.status === 'error') {
+        entry.profileError = profileResult.error;
+        plan.errors.push({
+          id: target.clientId,
+          label: target.label,
+          profilePath: profileResult.targetPath,
+          phase: 'profile',
+          error: profileResult.error
+        });
+      }
+    }
+
+    if (configResult.status === 'removed' ||
+        (options.removeProfiles && entry.profileStatus === 'removed')) {
+      plan.removed.push(entry);
+    } else if (configResult.status === 'not_found' || configResult.status === 'missing') {
+      if (!options.removeProfiles || entry.profileStatus !== 'removed') {
+        plan.skipped.push(entry);
+      }
+    }
+  }
+
+  return plan;
+}
+
+async function removeConfigForTarget(target, preview) {
+  if (!target.configPath) {
+    return { status: 'not_found', reason: 'no_config_path' };
+  }
+
+  try {
+    let result;
+    if (target.clientId === 'copilot-cli') {
+      result = await removeCopilotMcpConfig(target.configPath, { preview });
+    } else {
+      const client = MCP_CLIENTS.get(target.clientId);
+      if (!client || !client.removeConfig) {
+        return { status: 'not_found', reason: 'unsupported' };
+      }
+      result = await client.removeConfig(target.configPath, { preview });
+    }
+
+    if (result.removed) {
+      return { status: 'removed', removedNames: result.removedNames ?? [MCP_SERVER_NAME] };
+    }
+    if (result.reason === 'manual-edit-required') {
+      return { status: 'error', error: 'Config shape requires manual edit to remove XMemo safely.' };
+    }
+    return { status: result.reason ?? 'not_found' };
+  } catch (error) {
+    return { status: 'error', error: error.message };
+  }
+}
+
+async function removeProfileForTarget(target, env, options) {
+  const profileConfig = profileClientConfig(target.clientId);
+  if (!profileConfig) {
+    return { status: 'not_found', reason: 'unsupported', targetPath: null };
+  }
+
+  const targetPath = options.profileTargetOverride
+    ? options.profileTargetOverride
+    : profileConfig.defaultTarget(env);
+
+  try {
+    const result = await profileUninstallResult(target.clientId, targetPath, { write: !options.preview });
+    if (result.changed) {
+      return { status: 'removed', targetPath: result.targetPath };
+    }
+    return { status: 'not_found', targetPath: result.targetPath };
+  } catch (error) {
+    return { status: 'error', targetPath, error: error.message };
+  }
+}

package/src/mcp/clients/registry.js

@@ -7,7 +7,8 @@ export function createMcpClients(deps) {
     label: 'Codex',
     defaultConfigPath: deps.defaultCodexConfigPath,
     buildSnippet: deps.codexTomlSnippet,
-    writeConfig: deps.appendTomlServerConfig,
+    writeConfig: (configPath, mcpUrl, identity, options = {}) => deps.appendTomlServerConfig(configPath, mcpUrl, identity, options.force),
+    removeConfig: (configPath, options = {}) => deps.removeTomlServerConfig(configPath, options),
     configKind: 'toml'
   });
 
@@ -15,7 +16,8 @@ export function createMcpClients(deps) {
     label: 'Grok',
     defaultConfigPath: deps.defaultGrokConfigPath,
     buildSnippet: deps.grokTomlSnippet,
-    writeConfig: deps.appendGrokServerConfig,
+    writeConfig: (configPath, mcpUrl, identity, options = {}) => deps.appendGrokServerConfig(configPath, mcpUrl, identity, options.force),
+    removeConfig: (configPath, options = {}) => deps.removeTomlServerConfig(configPath, options),
     configKind: 'toml'
   });
 
@@ -38,7 +40,8 @@ function jsonClient(definition, deps) {
     label: definition.label,
     defaultConfigPath: deps[definition.defaultConfigPath],
     buildSnippet: (mcpUrl, identity) => deps.jsonClientSnippet(definition.id, mcpUrl, identity),
-    writeConfig: (configPath, mcpUrl, identity) => deps.mergeJsonClientMcpConfig(definition.id, configPath, mcpUrl, identity),
+    writeConfig: (configPath, mcpUrl, identity, options = {}) => deps.mergeJsonClientMcpConfig(definition.id, configPath, mcpUrl, identity, options.force),
+    removeConfig: (configPath, options = {}) => deps.removeJsonClientMcpConfig(definition.id, configPath, options),
     configKind: definition.configKind,
     authentication: definition.authentication
   };
@@ -49,7 +52,8 @@ function hermesClient(deps) {
     label: 'Hermes',
     defaultConfigPath: deps.defaultHermesConfigPath,
     buildSnippet: deps.hermesYamlSnippet,
-    writeConfig: deps.mergeHermesMcpConfig,
+    writeConfig: (configPath, mcpUrl, identity, options = {}) => deps.mergeHermesMcpConfig(configPath, mcpUrl, identity, options.force),
+    removeConfig: (configPath, options = {}) => deps.removeHermesMcpConfig(configPath, options),
     configKind: 'yaml'
   };
 }

package/src/mcp/clients/scan.js

@@ -0,0 +1,109 @@
+import os from 'node:os';
+import path from 'node:path';
+
+import { fileExists } from '../../core/runtime.js';
+import { defaultCopilotConfigPath } from '../identity/paths.js';
+import { supportedMcpClientIds } from './registry.js';
+
+export function autoScanClientIds(mcpClients) {
+  return [...supportedMcpClientIds(mcpClients), 'copilot-cli'];
+}
+
+export function clientConfigPathCandidates(clientId, env, mcpClients) {
+  const candidates = [];
+
+  if (clientId === 'copilot-cli' || clientId === 'copilot') {
+    if (process.platform === 'win32' && env.APPDATA) {
+      candidates.push(path.join(env.APPDATA, 'Code', 'User', 'mcp.json'));
+    } else {
+      const home = env.HOME || os.homedir();
+      if (process.platform === 'darwin') {
+        candidates.push(path.join(home, 'Library', 'Application Support', 'Code', 'User', 'mcp.json'));
+      }
+      candidates.push(path.join(home, '.config', 'Code', 'User', 'mcp.json'));
+    }
+    candidates.push(defaultCopilotConfigPath(env));
+    return candidates;
+  }
+
+  if (clientId === 'cline') {
+    if (process.platform === 'win32' && env.APPDATA) {
+      candidates.push(path.join(env.APPDATA, 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'));
+    } else {
+      const home = env.HOME || os.homedir();
+      if (process.platform === 'darwin') {
+        candidates.push(path.join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'));
+      }
+      candidates.push(path.join(home, '.config', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'));
+    }
+  }
+
+  const client = mcpClients.get(clientId);
+  if (client) {
+    candidates.push(client.defaultConfigPath(env));
+  }
+
+  return candidates;
+}
+
+export async function detectedSetupTargets(clientIds, env, mcpClients) {
+  const targets = [];
+  const seen = new Set();
+
+  for (const clientId of clientIds) {
+    const candidates = clientConfigPathCandidates(clientId, env, mcpClients);
+    for (const configPath of candidates) {
+      const resolved = path.resolve(configPath);
+      if (seen.has(resolved)) {
+        continue;
+      }
+      if (await fileExists(configPath) || await fileExists(path.dirname(configPath))) {
+        seen.add(resolved);
+        targets.push(buildTarget(clientId, resolved, mcpClients));
+        break;
+      }
+    }
+  }
+
+  return targets;
+}
+
+export async function existingUninstallTargets(clientIds, env, mcpClients) {
+  const targets = [];
+  const seen = new Set();
+
+  for (const clientId of clientIds) {
+    const candidates = clientConfigPathCandidates(clientId, env, mcpClients);
+    for (const configPath of candidates) {
+      const resolved = path.resolve(configPath);
+      if (seen.has(resolved)) {
+        continue;
+      }
+      if (await fileExists(configPath)) {
+        seen.add(resolved);
+        targets.push(buildTarget(clientId, resolved, mcpClients));
+      }
+    }
+  }
+
+  return targets;
+}
+
+function buildTarget(clientId, configPath, mcpClients) {
+  if (clientId === 'copilot-cli') {
+    return {
+      clientId,
+      label: 'Copilot CLI',
+      configPath,
+      configKind: 'local-proxy'
+    };
+  }
+
+  const client = mcpClients.get(clientId);
+  return {
+    clientId,
+    label: client?.label ?? clientId,
+    configPath,
+    configKind: client?.configKind ?? 'json'
+  };
+}

package/src/mcp/clients.js

@@ -2,16 +2,19 @@ import {
   appendTomlServerConfig,
   appendGrokServerConfig,
   codexTomlSnippet,
-  grokTomlSnippet
+  grokTomlSnippet,
+  removeTomlServerConfig
 } from './formats/toml.js';
 import {
   hermesYamlSnippet,
-  mergeHermesMcpConfig
+  mergeHermesMcpConfig,
+  removeHermesMcpConfig
 } from './formats/yaml.js';
 import {
   JSON_MCP_CLIENT_DEFINITIONS,
   jsonClientSnippet,
-  mergeJsonClientMcpConfig
+  mergeJsonClientMcpConfig,
+  removeJsonClientMcpConfig
 } from './formats/json.js';
 import {
   defaultAntigravity2ConfigPath,
@@ -49,14 +52,17 @@ export const MCP_CLIENTS = createMcpClients({
   defaultCodexConfigPath,
   codexTomlSnippet,
   appendTomlServerConfig,
+  removeTomlServerConfig,
   defaultGrokConfigPath,
   grokTomlSnippet,
   appendGrokServerConfig,
   defaultHermesConfigPath,
   hermesYamlSnippet,
   mergeHermesMcpConfig,
+  removeHermesMcpConfig,
   jsonClientSnippet,
   mergeJsonClientMcpConfig,
+  removeJsonClientMcpConfig,
   defaultCursorConfigPath,
   defaultGeminiConfigPath,
   defaultAntigravityConfigPath,

package/src/mcp/formats/json.js

@@ -16,7 +16,7 @@ import {
   readTextIfExists
 } from '../../core/runtime.js';
 import { envReferenceIdentity } from '../identity/device.js';
-import { existingJsonMcpServerName } from '../core/names.js';
+import { existingJsonMcpServerName, knownMcpServerNames } from '../core/names.js';
 
 export const JSON_MCP_CLIENT_DEFINITIONS = Object.freeze([
   httpClientDefinition('cursor', 'Cursor', 'defaultCursorConfigPath', { urlKey: 'url', authentication: 'env-bearer' }),
@@ -118,14 +118,14 @@ export function jsonClientServerConfig(clientId, mcpUrl, identity) {
   return serverConfigFromDefinition(definition, mcpUrl, resolvedIdentity);
 }
 
-export async function mergeJsonClientMcpConfig(clientId, configPath, mcpUrl, identity) {
+export async function mergeJsonClientMcpConfig(clientId, configPath, mcpUrl, identity, force = false) {
   const definition = requireJsonMcpClientDefinition(clientId);
   const serverConfig = serverConfigFromDefinition(definition, mcpUrl, identity);
   await mergeJsonSectionConfig(configPath, definition.section, serverConfig, definition.section, (parsed) => {
     if (definition.mergeExperimentalModelContextProtocolServers && isPlainObject(parsed.experimental)) {
       mergeExperimentalModelContextProtocolServers(parsed, serverConfig, mcpUrl);
     }
-  });
+  }, force);
 }
 
 function requireJsonMcpClientDefinition(clientId) {
@@ -236,7 +236,96 @@ function mcpRemoteCommandJsonServerConfig(mcpUrl, identity) {
   };
 }
 
-async function mergeJsonSectionConfig(configPath, sectionName, serverConfig, duplicatePath = sectionName, afterMerge) {
+export async function removeJsonClientMcpConfig(clientId, configPath, options = {}) {
+  const definition = requireJsonMcpClientDefinition(clientId);
+  const existing = await readTextIfExists(configPath);
+  if (existing.trim().length === 0) {
+    return { removed: false, reason: 'missing' };
+  }
+
+  const parsed = parseJsonConfig(existing, configPath);
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+
+  let removed = false;
+  const removedUrls = [];
+
+  const section = parsed[definition.section];
+  if (isPlainObject(section)) {
+    for (const name of knownMcpServerNames()) {
+      if (name in section) {
+        const entryUrl = xMemoEntryUrl(section[name]);
+        if (entryUrl) {
+          removedUrls.push(entryUrl);
+        }
+        delete section[name];
+        removed = true;
+      }
+    }
+  }
+
+  if (definition.mergeExperimentalModelContextProtocolServers && isPlainObject(parsed.experimental)) {
+    const servers = parsed.experimental.modelContextProtocolServers;
+    if (Array.isArray(servers)) {
+      const originalLength = servers.length;
+      parsed.experimental.modelContextProtocolServers = servers.filter((entry) => !isXMemoExperimentalEntry(entry, removedUrls));
+      if (parsed.experimental.modelContextProtocolServers.length !== originalLength) {
+        removed = true;
+      }
+    }
+  }
+
+  if (!removed) {
+    return { removed: false, reason: 'not-found' };
+  }
+
+  if (!options.preview) {
+    await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+    await bestEffortChmod(configPath, 0o600);
+  }
+  return { removed: true };
+}
+
+function xMemoEntryUrl(entry) {
+  if (!isPlainObject(entry)) {
+    return null;
+  }
+  if (isPlainObject(entry.transport) && typeof entry.transport.url === 'string') {
+    return entry.transport.url;
+  }
+  if (typeof entry.url === 'string') {
+    return entry.url;
+  }
+  return null;
+}
+
+function isXMemoExperimentalEntry(entry, removedUrls = []) {
+  if (!isPlainObject(entry)) {
+    return false;
+  }
+  const transport = entry.transport;
+  if (!isPlainObject(transport)) {
+    return false;
+  }
+  if (typeof transport.url === 'string') {
+    if (transport.url.includes('xmemo.dev')) {
+      return true;
+    }
+    if (removedUrls.includes(transport.url)) {
+      return true;
+    }
+  }
+  const headers = transport.headers;
+  if (isPlainObject(headers)) {
+    if (headers[AGENT_ID_HEADER] || headers[AGENT_INSTANCE_HEADER]) {
+      return true;
+    }
+  }
+  return false;
+}
+
+async function mergeJsonSectionConfig(configPath, sectionName, serverConfig, duplicatePath = sectionName, afterMerge, force = false) {
   const existing = await readTextIfExists(configPath);
   const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
   if (!isPlainObject(parsed)) {
@@ -246,8 +335,8 @@ async function mergeJsonSectionConfig(configPath, sectionName, serverConfig, dup
     parsed[sectionName] = {};
   }
   const existingName = existingJsonMcpServerName(parsed[sectionName]);
-  if (existingName) {
-    throw new UsageError(`MCP config already contains ${duplicatePath}.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  if (existingName && !force) {
+    throw new UsageError(`MCP config already contains ${duplicatePath}.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions, or use --force to overwrite.`);
   }
   parsed[sectionName][MCP_SERVER_NAME] = serverConfig;
   afterMerge?.(parsed);

package/src/mcp/formats/toml.js

@@ -47,17 +47,20 @@ ${AGENT_INSTANCE_HEADER} = "${escapeTomlString(agentInstanceId)}"
 `;
 }
 
-export async function appendGrokServerConfig(configPath, mcpUrl, identity) {
+export async function appendGrokServerConfig(configPath, mcpUrl, identity, force = false) {
   const snippet = grokTomlSnippet(mcpUrl, identity);
-  const existing = await readTextIfExists(configPath);
+  let existing = await readTextIfExists(configPath);
   const existingName = existingTomlMcpServerName(existing);
   if (existingName) {
-    throw new UsageError(`MCP config already contains [mcp_servers.${existingName}]. Edit ${configPath} manually to avoid duplicate server definitions.`);
+    if (!force) {
+      throw new UsageError(`MCP config already contains [mcp_servers.${existingName}]. Edit ${configPath} manually to avoid duplicate server definitions, or use --force to overwrite.`);
+    }
+    existing = removeTomlServerBlocks(existing, knownMcpServerNames());
   }
 
   await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
   const prefix = existing.trim().length === 0 ? '' : '\n\n';
-  await fs.appendFile(configPath, `${prefix}${snippet}`, { mode: 0o600 });
+  await fs.writeFile(configPath, `${existing.trimEnd()}${prefix}${snippet}\n`, { mode: 0o600 });
   await bestEffortChmod(configPath, 0o600);
 }
 
@@ -127,17 +130,40 @@ export async function codexSmokeReport(configPath, env) {
   };
 }
 
-export async function appendTomlServerConfig(configPath, mcpUrl, identity) {
-  const snippet = codexTomlSnippet(mcpUrl, identity);
+export async function removeTomlServerConfig(configPath, options = {}) {
   const existing = await readTextIfExists(configPath);
+  if (existing.trim().length === 0) {
+    return { removed: false, reason: 'missing' };
+  }
+
+  const names = knownMcpServerNames();
+  const hasAny = names.some((name) => existing.includes(`[mcp_servers.${name}]`));
+  if (!hasAny) {
+    return { removed: false, reason: 'not-found' };
+  }
+
+  if (!options.preview) {
+    const updated = removeTomlServerBlocks(existing, names);
+    await fs.writeFile(configPath, updated ? `${updated.trimEnd()}\n` : '', { mode: 0o600 });
+    await bestEffortChmod(configPath, 0o600);
+  }
+  return { removed: true };
+}
+
+export async function appendTomlServerConfig(configPath, mcpUrl, identity, force = false) {
+  const snippet = codexTomlSnippet(mcpUrl, identity);
+  let existing = await readTextIfExists(configPath);
   const existingName = existingTomlMcpServerName(existing);
   if (existingName) {
-    throw new UsageError(`MCP config already contains [mcp_servers.${existingName}]. Edit ${configPath} manually to avoid duplicate server definitions.`);
+    if (!force) {
+      throw new UsageError(`MCP config already contains [mcp_servers.${existingName}]. Edit ${configPath} manually to avoid duplicate server definitions, or use --force to overwrite.`);
+    }
+    existing = removeTomlServerBlocks(existing, knownMcpServerNames());
   }
 
   await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
   const prefix = existing.trim().length === 0 ? '' : '\n\n';
-  await fs.appendFile(configPath, `${prefix}${snippet}`, { mode: 0o600 });
+  await fs.writeFile(configPath, `${existing.trimEnd()}${prefix}${snippet}\n`, { mode: 0o600 });
   await bestEffortChmod(configPath, 0o600);
 }
 
@@ -176,6 +202,28 @@ function tomlServerBlock(content, serverName) {
   return block.join('\n');
 }
 
+function removeTomlServerBlocks(content, names) {
+  const lines = content.split(/\r?\n/);
+  const result = [];
+  let skipping = false;
+
+  for (const line of lines) {
+    const tableMatch = line.match(/^\s*\[([^\]]+)\]\s*$/);
+    if (tableMatch) {
+      const tableName = tableMatch[1].trim();
+      skipping = names.some((name) => {
+        const prefix = `mcp_servers.${name}`;
+        return tableName === prefix || tableName.startsWith(`${prefix}.`);
+      });
+    }
+    if (!skipping) {
+      result.push(line);
+    }
+  }
+
+  return result.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd();
+}
+
 function tomlStringValue(block, key) {
   const pattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"((?:\\\\.|[^"\\\\])*)"\\s*$`, 'm');
   const match = block.match(pattern);

package/src/mcp/formats/yaml.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 
 import {
   AGENT_INSTANCE_ENV_VAR,
+  LEGACY_MCP_SERVER_NAMES,
   MCP_SERVER_NAME,
   TOKEN_ENV_VAR
 } from '../../core/constants.js';
@@ -33,11 +34,116 @@ export function hermesYamlSnippet(mcpUrl, identity = envReferenceIdentity('herme
 `;
 }
 
-export async function mergeHermesMcpConfig(configPath, mcpUrl, identity) {
+export async function removeHermesMcpConfig(configPath, options = {}) {
+  const existing = await readTextIfExists(configPath);
+  if (existing.trim().length === 0) {
+    return { removed: false, reason: 'missing' };
+  }
+
+  const names = [MCP_SERVER_NAME, ...LEGACY_MCP_SERVER_NAMES];
+  const lines = existing.split(/\r?\n/);
+  const mcpIndex = lines.findIndex((line) => line.trim().startsWith('mcp_servers:'));
+  if (mcpIndex === -1) {
+    return { removed: false, reason: 'not-found' };
+  }
+
+  if (isFlowStyleMcpServersLine(lines[mcpIndex])) {
+    return { removed: false, reason: 'manual-edit-required' };
+  }
+
+  const serverBaseIndent = indentOf(lines[mcpIndex + 1]);
+  if (serverBaseIndent === null) {
+    return { removed: false, reason: 'not-found' };
+  }
+
+  let removed = false;
+  let index = mcpIndex + 1;
+  while (index < lines.length) {
+    const line = lines[index];
+    const lineIndent = indentOf(line);
+    if (lineIndent === null) {
+      index += 1;
+      continue;
+    }
+    if (lineIndent < serverBaseIndent) {
+      break;
+    }
+    if (lineIndent === serverBaseIndent) {
+      const match = names.find((name) => line.trim() === `${name}:` || line.trim().startsWith(`${name}:`));
+      if (match) {
+        if (hasUnbalancedFlow(line)) {
+          return { removed: false, reason: 'manual-edit-required' };
+        }
+        const start = index;
+        let end = index + 1;
+        for (; end < lines.length; end += 1) {
+          const nextIndent = indentOf(lines[end]);
+          if (nextIndent === null) {
+            continue;
+          }
+          if (nextIndent <= serverBaseIndent) {
+            break;
+          }
+        }
+        lines.splice(start, end - start);
+        removed = true;
+        index = start;
+        continue;
+      }
+    }
+    index += 1;
+  }
+
+  if (!removed) {
+    return { removed: false, reason: 'not-found' };
+  }
+
+  if (!options.preview) {
+    const updated = lines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd();
+    await fs.writeFile(configPath, updated ? `${updated}\n` : '', { mode: 0o600 });
+    await bestEffortChmod(configPath, 0o600);
+  }
+  return { removed: true };
+}
+
+function isFlowStyleMcpServersLine(line) {
+  const afterKey = line.split('mcp_servers:')[1] ?? '';
+  return /[\{\[]/.test(afterKey);
+}
+
+function hasUnbalancedFlow(line) {
+  const flowChars = line.replace(/[^\{\}\[\]\(\)]/g, '');
+  const pairs = { ')': '(', '}': '{', ']': '[' };
+  let depth = 0;
+  for (const char of flowChars) {
+    if (Object.values(pairs).includes(char)) {
+      depth += 1;
+    } else if (pairs[char]) {
+      depth -= 1;
+      if (depth < 0) {
+        return true;
+      }
+    }
+  }
+  return depth !== 0;
+}
+
+function indentOf(line) {
+  const match = line.match(/^(\s*)\S/);
+  if (!match) {
+    return null;
+  }
+  return match[1].length;
+}
+
+export async function mergeHermesMcpConfig(configPath, mcpUrl, identity, force = false) {
   const existing = await readTextIfExists(configPath);
 
   if (existing.includes(`${MCP_SERVER_NAME}:`) || existing.includes('memory_os:') || existing.includes('memory-os:')) {
-    throw new UsageError(`MCP config already contains ${MCP_SERVER_NAME} in mcp_servers. Edit ${configPath} manually to avoid duplicate server definitions.`);
+    if (!force) {
+      throw new UsageError(`MCP config already contains ${MCP_SERVER_NAME} in mcp_servers. Edit ${configPath} manually to avoid duplicate server definitions, or use --force to overwrite.`);
+    }
+    throw new UsageError(`--force overwrite is not yet supported for Hermes YAML configs. Edit ${configPath} manually.`);
   }
 
   await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });

package/src/mcp/proxy/copilot.js

@@ -9,10 +9,45 @@ import {
   parseJsonConfig,
   readTextIfExists
 } from '../../core/runtime.js';
-import { existingJsonMcpServerName } from '../core/names.js';
+import { existingJsonMcpServerName, knownMcpServerNames } from '../core/names.js';
 export { mcpProxyCommand } from './server.js';
 
-export async function mergeCopilotMcpConfig(configPath, proxyUrl) {
+export async function removeCopilotMcpConfig(configPath, options = {}) {
+  const existing = await readTextIfExists(configPath);
+  if (existing.trim().length === 0) {
+    return { removed: false, reason: 'missing' };
+  }
+
+  const parsed = parseJsonConfig(existing, configPath);
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`Copilot MCP JSON config must be an object: ${configPath}`);
+  }
+
+  if (!isPlainObject(parsed.mcpServers)) {
+    return { removed: false, reason: 'not-found' };
+  }
+
+  let removed = false;
+  for (const name of knownMcpServerNames()) {
+    if (name in parsed.mcpServers) {
+      delete parsed.mcpServers[name];
+      removed = true;
+    }
+  }
+
+  if (!removed) {
+    return { removed: false, reason: 'not-found' };
+  }
+
+  if (!options.preview) {
+    await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+    await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+    await bestEffortChmod(configPath, 0o600);
+  }
+  return { removed: true };
+}
+
+export async function mergeCopilotMcpConfig(configPath, proxyUrl, force = false) {
   const existing = await readTextIfExists(configPath);
   const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
 
@@ -25,8 +60,8 @@ export async function mergeCopilotMcpConfig(configPath, proxyUrl) {
   }
 
   const existingName = existingJsonMcpServerName(parsed.mcpServers);
-  if (existingName) {
-    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  if (existingName && !force) {
+    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions, or use --force to overwrite.`);
   }
 
   parsed.mcpServers[MCP_SERVER_NAME] = copilotLocalProxyServerConfig(proxyUrl);

package/src/ui/help.js

@@ -14,14 +14,24 @@ export function writeHelp(io) {
   writeLine(io.stdout, `Official package: ${PACKAGE_NAME} | Legacy command: ${LEGACY_COMMAND_NAME}`);
   writeLine(io.stdout, '');
   writeLine(io.stdout, '💡 CORE ONBOARDING & SETUP COMMANDS:');
-  writeLine(io.stdout, `  ${COMMAND_NAME} setup --all [--write] [--profile]`);
+  writeLine(io.stdout, `  ${COMMAND_NAME} setup --all [--write] [--profile] [--force]`);
   writeLine(io.stdout, `      Auto-detects all local client installations (Cursor, VS Code, Continue, Trae, etc.).`);
   writeLine(io.stdout, `      Merges XMemo MCP configs. Pass --profile to auto-inject workspace prompt rules.`);
   writeLine(io.stdout, `      *Dry-run by default unless --write (or --yes/-y) is specified for safety.*`);
+  writeLine(io.stdout, `      Pass --force to overwrite an existing mcpServers.XMemo entry.`);
   writeLine(io.stdout, '');
-  writeLine(io.stdout, `  ${COMMAND_NAME} setup <client-id> [--url <url>] [--no-profile] [--json]`);
+  writeLine(io.stdout, `  ${COMMAND_NAME} setup <client-id> [--url <url>] [--no-profile] [--json] [--force]`);
   writeLine(io.stdout, `      Runs interactive setup wizard for a single client (e.g. cursor, gemini, antigravity).`);
   writeLine(io.stdout, `      Detects active workspace to auto-inject project-scoped instruction rules.`);
+  writeLine(io.stdout, `      Pass --force to overwrite an existing mcpServers.XMemo entry.`);
+  writeLine(io.stdout, '');
+  writeLine(io.stdout, `  ${COMMAND_NAME} uninstall --all [--yes] [--profiles] [--dry-run]`);
+  writeLine(io.stdout, `      Removes the XMemo MCP server entry from every detected client config.`);
+  writeLine(io.stdout, `      Use --profiles to also remove installed behavior profiles.`);
+  writeLine(io.stdout, `      Dry-run by default unless --yes (or -y) is specified.`);
+  writeLine(io.stdout, '');
+  writeLine(io.stdout, `  ${COMMAND_NAME} uninstall <client-id> [--yes] [--profiles] [--dry-run]`);
+  writeLine(io.stdout, `      Removes the XMemo MCP server entry from a single client config.`);
   writeLine(io.stdout, '');
   writeLine(io.stdout, `  ${COMMAND_NAME} login [--from-stdin] [--base-url <url>]`);
   writeLine(io.stdout, `      Starts secure OAuth2 browser-based device login flow to register the CLI.`);

package/src/ui/setup.js

@@ -223,6 +223,16 @@ export function writeSetupSummary(plan, io) {
         if (plan.tokenPortalUrl) {
           writeLine(io.stdout, `     (Token portal: ${plan.tokenPortalUrl})`);
         }
+      } else if (cid === 'kimi-code') {
+        writeLine(io.stdout, `💡 Next steps for ${plan.selectedClient.label}:`);
+        writeLine(io.stdout, '  1. Restart Kimi Code to load the new MCP configuration.');
+        writeLine(io.stdout, `  2. Make sure ${TOKEN_ENV_VAR} is exported in the SAME environment that starts Kimi Code.`);
+        writeLine(io.stdout, `     Kimi Code reads the token from process.env['${TOKEN_ENV_VAR}'] via bearerTokenEnvVar.`);
+        writeLine(io.stdout, `     Example (PowerShell): $env:${TOKEN_ENV_VAR}='<your-token>'; kimi`);
+        writeLine(io.stdout, `     Example (bash):       export ${TOKEN_ENV_VAR}=<your-token> && kimi`);
+        if (plan.tokenPortalUrl) {
+          writeLine(io.stdout, `     (Token portal: ${plan.tokenPortalUrl})`);
+        }
       } else if (usesClientOAuth(cid)) {
         writeLine(io.stdout, `💡 Next steps for ${plan.selectedClient.label}:`);
         writeLine(io.stdout, '  1. When the agent starts or first makes an XMemo tool call, a browser window will automatically pop up requesting OAuth authorization.');

package/src/ui/uninstall.js

@@ -0,0 +1,92 @@
+import {
+  COMMAND_NAME,
+  PRODUCT_NAME
+} from '../core/constants.js';
+import { writeLine } from '../core/io.js';
+
+export async function confirmUninstall(plan, io) {
+  const targets = plan.removed.length;
+  if (targets === 0) {
+    return false;
+  }
+
+  const prompt = plan.dryRun
+    ? `${PRODUCT_NAME} would remove entries from ${targets} client config(s). Continue? [y/N]`
+    : `Remove ${PRODUCT_NAME} entries from ${targets} client config(s)? [y/N]`;
+  writeLine(io.stdout, prompt);
+  const answer = (await readLine(io.stdin)).trim().toLowerCase();
+  return answer === 'y' || answer === 'yes';
+}
+
+async function readLine(stdin) {
+  let input = '';
+  for await (const chunk of stdin) {
+    input += chunk;
+    if (input.includes('\n')) {
+      break;
+    }
+  }
+  return input.split(/\r?\n/, 1)[0] ?? '';
+}
+
+export function writeUninstallSummary(plan, io) {
+  writeLine(io.stdout, `${PRODUCT_NAME} uninstall summary`);
+
+  if (plan.dryRun) {
+    writeLine(io.stdout, '  (dry run — no files were modified)');
+  }
+
+  if (plan.profiles) {
+    writeLine(io.stdout, '  Behavior profiles: included in removal');
+  }
+
+  if (plan.removed.length === 0 && plan.skipped.length === 0 && plan.errors.length === 0) {
+    writeLine(io.stdout, '  No local client configurations were detected.');
+    return;
+  }
+
+  if (plan.removed.length > 0) {
+    writeLine(io.stdout, '');
+    writeLine(io.stdout, `${plan.dryRun ? 'Would remove' : 'Removed'} from ${plan.removed.length} client(s):`);
+    for (const entry of plan.removed) {
+      writeLine(io.stdout, `  [✔] ${entry.label}`);
+      writeLine(io.stdout, `      Config: ${entry.configPath}`);
+      if ('profilePath' in entry && entry.profilePath) {
+        const profileStatus = entry.profileStatus === 'removed' ? 'removed' : 'not found';
+        writeLine(io.stdout, `      Profile: ${entry.profilePath} (${profileStatus})`);
+      }
+    }
+  }
+
+  if (plan.skipped.length > 0) {
+    writeLine(io.stdout, '');
+    writeLine(io.stdout, `Skipped ${plan.skipped.length} client(s) (XMemo entry not found):`);
+    for (const entry of plan.skipped) {
+      writeLine(io.stdout, `  [ ] ${entry.label}`);
+      writeLine(io.stdout, `      Config: ${entry.configPath}`);
+      if (entry.configStatus) {
+        writeLine(io.stdout, `      Reason: ${entry.configStatus}`);
+      }
+    }
+  }
+
+  if (plan.errors.length > 0) {
+    writeLine(io.stdout, '');
+    writeLine(io.stdout, `Encountered ${plan.errors.length} error(s):`);
+    for (const error of plan.errors) {
+      writeLine(io.stdout, `  [✘] ${error.label} (${error.phase})`);
+      writeLine(io.stdout, `      Path: ${error.configPath ?? error.profilePath}`);
+      writeLine(io.stdout, `      Error: ${error.error}`);
+    }
+  }
+
+  if (!plan.dryRun && plan.removed.length > 0) {
+    writeLine(io.stdout, '');
+    writeLine(io.stdout, 'Restart your IDEs or reload their MCP configurations to apply the changes.');
+  }
+
+  if (plan.removed.length === 0 && plan.skipped.length > 0 && plan.errors.length === 0) {
+    writeLine(io.stdout, '');
+    writeLine(io.stdout, `Run \`${COMMAND_NAME} setup --all --write\` to re-install if needed.`);
+  }
+}