feat(mcp): reconcile MCP servers live on settings change

integration-tests/cli/_daemon-harness.ts

@@ -41,6 +41,10 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { DaemonClient, type SubscribeOptions } from '@qwen-code/sdk';
+import {
+  hashMcpServerConfig,
+  type MCPServerConfig,
+} from '@qwen-code/qwen-code-core';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -234,6 +238,41 @@ export function writeWorkspaceSettings(
   return settingsPath;
 }
 
+/**
+ * Pre-approve gated (workspace / project scope, #4615) MCP servers for
+ * `workspaceCwd` so the daemon's `qwen --acp` child connects them instead of
+ * skipping them as pending-approval. Servers declared in `.qwen/settings.json`
+ * are workspace-scoped and therefore gated: absent a stored approval, discovery
+ * skips them BEFORE any spawn, which makes the MCP-amplification suite time out
+ * waiting for grandchildren that never appear.
+ *
+ * Writes a standalone approvals file (NOT the developer's global
+ * `~/.qwen/mcpApprovals.json`) under the workspace and returns the env that
+ * points the daemon — and, by inheritance, its acp child — at it. Pass the
+ * returned env to `spawnDaemon({ env })`. The approval hash binds to the same
+ * behavioral fields the child hashes (`scope` is provenance-only and excluded),
+ * so the plain settings config is sufficient. Mirrors the pre-approval pattern
+ * in `simple-mcp-server.test.ts`.
+ */
+export function approveWorkspaceMcpServers(
+  workspaceCwd: string,
+  servers: Record<string, MCPServerConfig>,
+): Record<string, string> {
+  const approvalsPath = path.join(workspaceCwd, '.qwen', 'mcpApprovals.json');
+  const project: Record<string, { hash: string; status: 'approved' }> = {};
+  for (const [name, config] of Object.entries(servers)) {
+    project[name] = { hash: hashMcpServerConfig(config), status: 'approved' };
+  }
+  // Key by the canonical (realpath) workspace, NOT `path.resolve`: the daemon
+  // canonicalizes `--workspace` (e.g. macOS `/var` → `/private/var`) and the
+  // acp child looks approvals up under that resolved path. Keying by the
+  // un-resolved temp path would miss, leaving the servers pending.
+  const root = fs.realpathSync(workspaceCwd);
+  fs.mkdirSync(path.dirname(approvalsPath), { recursive: true });
+  fs.writeFileSync(approvalsPath, JSON.stringify({ [root]: project }, null, 2));
+  return { QWEN_CODE_MCP_APPROVALS_PATH: approvalsPath };
+}
+
 /**
  * One-shot RSS read via `ps -o rss= -p <pid>`. Returns megabytes (rounded
  * to 1 decimal). Returns NaN if the process is gone or `ps` errored — call

integration-tests/cli/qwen-serve-baseline.test.ts

@@ -46,6 +46,7 @@ import {
   countDescendants,
   percentiles,
   writeWorkspaceSettings,
+  approveWorkspaceMcpServers,
   gitHead,
   makeTempWorkspace,
   sleep,
@@ -386,13 +387,15 @@ async function measureRssAtSessionCount(sessionCount: number): Promise<{
         const ws = makeTempWorkspace('mcp');
         let daemon: SpawnedDaemon | undefined;
         try {
-          writeWorkspaceSettings(ws, {
-            mcpServers: {
-              idle1: { command: 'node', args: [IDLE_MCP_PATH] },
-              idle2: { command: 'node', args: [IDLE_MCP_PATH] },
-            },
-          });
-          daemon = await spawnDaemon({ workspaceCwd: ws });
+          const mcpServers = {
+            idle1: { command: 'node', args: [IDLE_MCP_PATH] },
+            idle2: { command: 'node', args: [IDLE_MCP_PATH] },
+          };
+          writeWorkspaceSettings(ws, { mcpServers });
+          // Workspace-scoped servers are gated (#4615); pre-approve so the
+          // daemon's acp child connects them instead of skipping as pending.
+          const env = approveWorkspaceMcpServers(ws, mcpServers);
+          daemon = await spawnDaemon({ workspaceCwd: ws, env });
 
           await daemon.client.createOrAttachSession({ workspaceCwd: ws });
           const at1 = await waitForMcpGrandchildren(
@@ -475,13 +478,15 @@ async function measureRssAtSessionCount(sessionCount: number): Promise<{
         const ws = makeTempWorkspace('mcp-counter');
         let daemon: SpawnedDaemon | undefined;
         try {
-          writeWorkspaceSettings(ws, {
-            mcpServers: {
-              idle1: { command: 'node', args: [IDLE_MCP_PATH] },
-              idle2: { command: 'node', args: [IDLE_MCP_PATH] },
-            },
-          });
-          daemon = await spawnDaemon({ workspaceCwd: ws });
+          const mcpServers = {
+            idle1: { command: 'node', args: [IDLE_MCP_PATH] },
+            idle2: { command: 'node', args: [IDLE_MCP_PATH] },
+          };
+          writeWorkspaceSettings(ws, { mcpServers });
+          // Workspace-scoped servers are gated (#4615); pre-approve so the
+          // daemon's acp child connects them instead of skipping as pending.
+          const env = approveWorkspaceMcpServers(ws, mcpServers);
+          daemon = await spawnDaemon({ workspaceCwd: ws, env });
           await daemon.client.createOrAttachSession({ workspaceCwd: ws });
 
           // Wait until the OS sees the full pooled set

packages/cli/package.json

@@ -62,6 +62,7 @@
     "diff": "^7.0.0",
     "dotenv": "^17.1.0",
     "express": "^5.2.1",
+    "fast-deep-equal": "^3.1.3",
     "fzf": "^0.5.2",
     "glob": "^10.5.0",
     "highlight.js": "^11.11.1",

packages/cli/src/config/config.ts

@@ -1885,10 +1885,16 @@ export async function loadCliConfig(
     toolCallCommand: bareMode ? undefined : settings.tools?.callCommand,
     mcpServerCommand: bareMode ? undefined : settings.mcp?.serverCommand,
     mcpServers,
+    topTierMcpServers,
     pendingMcpServers,
     allowedMcpServers: allowedMcpServers
       ? Array.from(allowedMcpServers)
       : undefined,
+    // The flag ONLY (not the settings-derived list) — the hot-reload upper
+    // bound. Undefined when `--allowed-mcp-server-names` was not passed.
+    cliAllowedMcpServerNames: argv.allowedMcpServerNames
+      ? argv.allowedMcpServerNames.filter(Boolean)
+      : undefined,
     excludedMcpServers: excludedMcpServers
       ? Array.from(excludedMcpServers)
       : undefined,