F2: 共享 MCP 传输连接池 — 设计文档 v2.2

acpAgent.newSession(sessionId)
  → newSessionConfig(cwd, mcpServers)                  // acpAgent.ts:1771
  → loadCliConfig → new Config → config.initialize()
  → ToolRegistry ctor → new McpClientManager(config, ...)   // tool-registry.ts:199
  → for (name, cfg) in config.getMcpServers():
      new McpClient(name, cfg, toolRegistry, promptRegistry, workspaceContext, ...)
      → client.connect() → client.discover(config)

HTTP daemon (packages/cli/src/serve, qwen serve)
  │ 生成
  ▼
ACP child (qwen --acp, 每工作区单进程)
  │
  QwenAgent (acpAgent.ts)
  ├── McpTransportPool ◄── 新增，工作区级，1 个实例
  │     ├── entries: Map<ConnectionId, PoolEntry>
  │     ├── spawnInFlight: Map<ConnectionId, Promise<PoolEntry>>
  │     ├── workspaceContext (绑定到 daemon 工作区)
  │     └── budget 守护机制（PR 14 状态机，升级为工作区级）
  │
  └── sessions: Map<sessionId, Session>
        └── Session.Config → ToolRegistry → McpClientManager(pool?)
                                                     │
                                            ┌────────┴────────┐
                                            │ pool 已注入      │
                                            ▼                 ▼
                                pool.acquire(name,cfg,sid)   legacy in-process
                                  → SessionMcpView            (独立 qwen)
                                    .applyTools/Prompts
                                    (过滤 + 注册到
                                     会话自己的注册表)

McpTransportPool
  ├─ acquire(name, cfg, sid) → PooledConnection
  ├─ release(connectionId, sid) → void
  ├─ releaseSession(sid) → void   (会话拆除时批量释放)
  ├─ restartByName(name) → RestartResult[]
  ├─ getAccounting() → McpClientAccounting   (工作区级)
  ├─ getBudgetMode/Budget()
  ├─ drainAll() → Promise<void>   (关闭)
  └─ onBudgetEvent: (event) => void   (由 QwenAgent 设置)

PoolEntry（内部）
  ├─ refs: Set<sessionId>
  ├─ client: McpClient
  ├─ toolsSnapshot: DiscoveredMCPTool[]
  ├─ promptsSnapshot: Prompt[]
  ├─ generation: number   (重连时递增；陈旧事件守卫)
  ├─ state: 'spawning' | 'active' | 'draining' | 'closed' | 'failed'
  ├─ drainTimer?: NodeJS.Timeout
  ├─ healthMonitor: { intervalTimer, consecutiveFailures, isReconnecting }
  ├─ subscribers: Map<sid, SessionMcpView>
  ├─ attach(sid, view) → PooledConnection
  └─ detach(sid) → void

PooledConnection（返回给调用方的句柄）
  ├─ id: ConnectionId
  ├─ on('toolsChanged' | 'promptsChanged' | 'disconnected' | 'reconnected' | 'failed', cb)
  ├─ callTool(name, args, { sessionId }) → CallToolResult
  ├─ readResource(uri, { sessionId, signal })
  └─ release()

SessionMcpView（每会话、每服务器）
  ├─ ctor(toolRegistry, promptRegistry, sessionId, serverName, cfg)
  ├─ applyTools(snapshot) → void   (按 include/exclude 过滤，附加 trust)
  ├─ applyPrompts(snapshot) → void
  └─ teardown() → void   (移除其注册项)

type PoolKey = string; // sha256 十六进制，前 16 个字符已足够（在实际 N 规模下无碰撞）
type ConnectionId = `${serverName}::${PoolKey}`;
 
function fingerprint(cfg: MCPServerConfig): PoolKey {
  const canonical = {
    transport: mcpTransportOf(cfg),
    command: cfg.command ?? null,
    args: cfg.args ?? [],
    cwd: cfg.cwd ?? null,
    env: sortedEntries(cfg.env ?? {}), // [[k,v],...] 按 k 排序
    url: cfg.url ?? null,
    httpUrl: cfg.httpUrl ?? null,
    headers: sortedEntries(cfg.headers ?? {}),
    timeout: cfg.timeout ?? null,
    oauth: canonicalOAuth(cfg.oauth),
  };
  return sha256(JSON.stringify(canonical)).slice(0, 16);
}
 
/**
 * V21-9：规范化功能等价的 OAuth 配置，使其折叠为相同指纹。
 * `{enabled: false}`、`undefined`、`null` 和 `{}` 均表示"无 OAuth"→ 均返回 `null`。
 */
function canonicalOAuth(o?: OAuthConfig | null): OAuthConfig | null {
  if (!o || !o.enabled) return null;
  return {
    enabled: true,
    clientId: o.clientId ?? null,
    scopes: o.scopes ? [...o.scopes].sort() : null,
    authorizationUrl: o.authorizationUrl ?? null,
    tokenUrl: o.tokenUrl ?? null,
  };
}
 
// 排除字段（每会话过滤器，不属于传输层）：
//   includeTools, excludeTools, trust, description, extensionName

const POOLED_TRANSPORTS_DEFAULT = new Set(['stdio', 'websocket']);
 
function isPoolable(cfg: MCPServerConfig, opts: PoolOptions): boolean {
  if (isSdkMcpServerConfig(cfg)) return false;
  const transport = mcpTransportOf(cfg);
  return opts.pooledTransports.has(transport);
}

class McpTransportPool {
  private entries = new Map<ConnectionId, PoolEntry>();
  private spawnInFlight = new Map<ConnectionId, Promise<PoolEntry>>();
 
  /** V21-2：反向索引，O(本会话引用数) 的 releaseSession，而非 O(所有条目)。 */
  private sessionToEntries = new Map<string, Set<ConnectionId>>();
 
  async acquire(
    name: string,
    cfg: MCPServerConfig,
    sid: string,
  ): Promise<PooledConnection> {
    if (!isPoolable(cfg, this.opts)) {
      return this.createUnpooledConnection(name, cfg, sid);
    }
    const id: ConnectionId = `${name}::${fingerprint(cfg)}`;
 
    if (this.entries.has(id)) {
      this.indexAttach(sid, id);
      return this.entries.get(id)!.attach(sid);
    }
    let inFlight = this.spawnInFlight.get(id);
    if (!inFlight) {
      const slot = this.tryReserveSlot(name);
      if (slot === 'refused') {
        throw new BudgetExhaustedError(
          name,
          this.clientBudget!,
          this.reservedSlots.size,
        );
      }
      inFlight = this.spawnEntry(name, cfg, id)
        .catch((err) => {
          // V21-4：生成失败时释放预留槽。若无此修复，
          // 槽会泄漏直到健康监控释放路径运行
          //（但由于没有条目可监控，该路径永远不会运行）。
          if (slot === 'reserved') this.releaseSlotName(name);
          throw err;
        })
        .finally(() => this.spawnInFlight.delete(id));
      this.spawnInFlight.set(id, inFlight);
    }
    const entry = await inFlight;
    this.indexAttach(sid, id);
    return entry.attach(sid);
  }
 
  release(id: ConnectionId, sid: string): void {
    const entry = this.entries.get(id);
    if (!entry) return;
    entry.detach(sid);
    this.indexDetach(sid, id);
    if (entry.refs.size === 0) entry.startDrainTimer(this.opts.drainDelayMs);
  }
 
  /** V21-2：O(本会话引用数)，而非 O(所有条目)。 */
  releaseSession(sid: string): void {
    const ids = this.sessionToEntries.get(sid);
    if (!ids) return;
    for (const id of ids) {
      const entry = this.entries.get(id);
      if (!entry) continue;
      entry.detach(sid);
      if (entry.refs.size === 0) entry.startDrainTimer(this.opts.drainDelayMs);
    }
    this.sessionToEntries.delete(sid);
  }
 
  private indexAttach(sid: string, id: ConnectionId): void {
    let ids = this.sessionToEntries.get(sid);
    if (!ids) {
      ids = new Set();
      this.sessionToEntries.set(sid, ids);
    }
    ids.add(id);
  }
 
  private indexDetach(sid: string, id: ConnectionId): void {
    const ids = this.sessionToEntries.get(sid);
    if (!ids) return;
    ids.delete(id);
    if (ids.size === 0) this.sessionToEntries.delete(sid);
  }
}

const DRAIN_DELAY_MS_DEFAULT = 30_000; // 最后一次 release 后的宽限期
const MAX_IDLE_MS_DEFAULT = 5 * 60_000; // 硬上限（防御 drain 取消循环）

spawning ──生成成功──► active ──最后一次 detach──► draining ──超时──► closed
   │                     │                         │
   │                     │                         └──attach──► active（取消计时器）
   生成失败─────────────►failed
                          │
                          └──手动重启──► spawning

// packages/core/src/tools/pid-descendants.ts
export async function listDescendantPids(rootPid: number): Promise<number[]> {
  if (!Number.isInteger(rootPid) || rootPid <= 0) return [];
  try {
    if (process.platform === 'win32')
      return await listDescendantPidsWin(rootPid);
    return await listDescendantPidsUnix(rootPid);
  } catch {
    return []; // OS 回收孤儿进程；连接池关闭仍继续。
  }
}
 
async function listDescendantPidsUnix(root: number): Promise<number[]> {
  let tree: Map<number, number[]> | undefined;
  try {
    tree = await snapshotProcessTreeUnix(); // ps -A -o pid=,ppid=
  } catch {
    /* 回退到备用方案 */
  }
  if (tree) return walkDescendants(tree, root); // O(后代数)，1 次 fork
  return await listDescendantPidsUnixPgrepFallback(root); // 传统 BFS
}
 
async function snapshotProcessTreeUnix(): Promise<Map<number, number[]>> {
  // -A: 所有进程（POSIX，等价于 -e，但在 BSD 上无歧义）。
  // -o pid=,ppid=: pid + ppid 列，尾部 `=` 抑制表头。
  const { stdout } = await execFile('ps', ['-A', '-o', 'pid=,ppid='], {
    timeout: 2000,
    maxBuffer: 8 * 1024 * 1024, // 覆盖进程数超过 250k 的极端主机
  });
  const childrenByPpid = new Map<number, number[]>();
  for (const line of stdout.split('\n')) {
    const m = line.trim().match(/^(\d+)\s+(\d+)$/);
    if (!m) continue;
    /* 解析，推入 childrenByPpid */
  }
  return childrenByPpid;
}
 
// Windows：单次 Get-CimInstance Win32_Process | ConvertTo-Csv 快照
// 获取所有 (ProcessId, ParentProcessId) 行 + 内存遍历；逐 pid
// `Get-CimInstance -Filter "ParentProcessId=$p"` 保留为回退。

// packages/core/src/tools/mcp-client.ts — 将 discover 拆分为纯函数
async discoverAndReturn(cliConfig: Config): Promise<{
  tools: DiscoveredMCPTool[];
  prompts: Prompt[];
}> {
  if (this.status !== MCPServerStatus.CONNECTED) throw new Error('Client is not connected.');
  try {
    const [prompts, tools] = await Promise.all([
      discoverPrompts(this.serverName, this.client, /* 无注册表 */),
      discoverTools(this.client, this.serverConfig, this.serverName, this.debugMode, this.workspaceContext),
    ]);
    if (prompts.length === 0 && tools.length === 0) {
      throw new Error('No prompts or tools found on the server.');
    }
    return { tools, prompts };
  } catch (e) {
    this.updateStatus(MCPServerStatus.DISCONNECTED);
    throw e;
  }
}
 
// 保留传统 discover()，委托给 discoverAndReturn + 注册（供独立 qwen 使用）
async discover(cliConfig: Config): Promise<void> {
  const { tools, prompts } = await this.discoverAndReturn(cliConfig);
  for (const t of tools) this.toolRegistry.registerTool(t);
  for (const p of prompts) this.promptRegistry.registerPrompt(p);
}

class SessionMcpView {
  applyTools(snapshot: DiscoveredMCPTool[]) {
    this.sessionToolRegistry.removeToolsByServer(this.serverName);
    for (const tool of snapshot) {
      if (!this.passesFilter(tool)) continue;
      // C7：每会话复制 trust（不修改共享快照）
      const localTool = tool.withTrust(this.cfg.trust);
      this.sessionToolRegistry.registerTool(localTool);
    }
  }
  applyPrompts(snapshot: Prompt[]) {
    this.sessionPromptRegistry.removePromptsByServer(this.serverName);
    for (const p of snapshot) this.sessionPromptRegistry.registerPrompt(p);
  }
}

class PoolEntry {
  attach(sid: string): PooledConnection {
    this.refs.add(sid);
    this.cancelDrainTimer();
    const view = new SessionMcpView(...);
    this.subscribers.set(sid, view);
    // 立即回放当前快照，确保订阅者不会错过
    // 在 in-flight 发现完成到 attach 之间落地的更新。
    if (this.state === 'active') {
      view.applyTools(this.toolsSnapshot);
      view.applyPrompts(this.promptsSnapshot);
    }
    return this.makeHandle(sid, view);
  }
}

class PoolEntry {
  private generation = 0;
 
  private async reconnect(): Promise<void> {
    this.generation += 1;
    const myGen = this.generation;
    await this.client.disconnect();
    await this.client.connect();
    if (myGen !== this.generation) return; // 已被另一次重连取代
    const snap = await this.client.discoverAndReturn(this.cfg);
    if (myGen !== this.generation) return;
    this.toolsSnapshot = snap.tools;
    this.promptsSnapshot = snap.prompts;
    this.fanOut('toolsChanged');
    this.fanOut('promptsChanged');
  }
 
  private onServerToolsListChanged = () => {
    const myGen = this.generation;
    this.client
      .discoverAndReturn(this.cfg)
      .then((snap) => {
        if (myGen !== this.generation) return;
        this.toolsSnapshot = snap.tools;
        this.fanOut('toolsChanged');
      })
      .catch(/* 吞掉 + 记录日志 */);
  };
}

class PoolEntry {
  updateStatus(s: MCPServerStatus) {
    this.localStatus = s;
    const aggregated = this.pool.aggregateStatusByName(this.serverName);
    updateMCPServerStatus(this.serverName, aggregated);
  }
}
 
class McpTransportPool {
  aggregateStatusByName(name: string): MCPServerStatus {
    // 任意 CONNECTED ⇒ CONNECTED
    // 否则任意 CONNECTING ⇒ CONNECTING
    // 否则 DISCONNECTED
    const entries = [...this.entries.values()].filter(
      (e) => e.serverName === name,
    );
    if (entries.some((e) => e.localStatus === CONNECTED)) return CONNECTED;
    if (entries.some((e) => e.localStatus === CONNECTING)) return CONNECTING;
    return DISCONNECTED;
  }
}

{
  kind: 'mcp_server',
  name: 'github',
  status: 'ok',
  mcpStatus: 'connected',
  entryCount: 2,                          // 新增 — 该名称对应的连接池条目数
  entrySummary?: [                        // 新增 — 不透明的每条目细分
    { entryIndex: 0, refs: 2, status: 'connected' },
    { entryIndex: 1, refs: 1, status: 'connecting' },
  ],
  ...
}

async newSessionConfig(...) {
  const config = await loadCliConfig(...);
  if (this.mcpPool) config.setMcpTransportPool(this.mcpPool);
  // ...现有的 setMcpBudgetEventCallback 已移除——连接池直接处理广播
}

{
  kind: 'mcp_budget',
  scope: 'workspace',          // 新值（PR 14 v1 返回 'session'）
  liveCount: 5,
  clientBudget: 10,
  budgetMode: 'enforce',
  status: 'ok',
}

class QwenAgent {
  constructor() {
    this.mcpPool = new McpTransportPool({
      onBudgetEvent: (event) => this.broadcastBudgetEvent(event),
    });
  }
 
  private broadcastBudgetEvent(event: McpBudgetEvent) {
    for (const [sid, session] of this.sessions) {
      const enriched = {
        ...event,
        scope: 'workspace' as const,
        sessionId: sid,
      };
      session.connection
        .extNotification('qwen/notify/session/mcp-budget-event', enriched)
        .catch((err) =>
          debugLogger.debug('budget event delivery failed', { sid, err }),
        );
    }
  }
}

export function isWorkspaceScopedBudgetEvent(
  e: DaemonMcpGuardrailEvent,
): boolean;

/**
 * 会话已观察到的 `mcp_budget_warning` 事件计数。
 * 在 F2（`scope: 'workspace'`）下，该值会在所有连接的会话中同时递增，
 * 因为 budget 事件在工作区级扇出。
 * 使用 `isWorkspaceScopedBudgetEvent(lastMcpBudgetWarning)`
 * 检查最近一次事件的 scope。
 */
mcpBudgetWarningCount: number;

type RestartResult = {
  entryIndex: number;        // V21-7：不透明索引，非原始指纹
  restarted: boolean;
  durationMs?: number;
  reason?: string;           // 'budget_would_exceed' | 'not_connected' | 'in_flight'
};
POST /workspace/mcp/:server/restart → { entries: RestartResult[] }

class PoolEntry {
  private restartInFlight?: Promise<void>;
  async restart(): Promise<void> {
    if (this.restartInFlight) return this.restartInFlight;
    this.restartInFlight = this.doRestart().finally(() => {
      this.restartInFlight = undefined;
    });
    return this.restartInFlight;
  }
}

class MCPCallInterruptedError extends Error {
  readonly serverName: string;
  readonly entryIndex: number;
  readonly clientGeneration: number;   // 重连前的版本号
  readonly args: unknown;              // 原始参数，供调用方在安全时重试
  constructor(serverName, entryIndex, clientGeneration, args) { ... }
}

// httpAcpBridge.ts:733 buildWorkspaceMcpStatus — 替换数据源
let accounting: McpClientAccounting | undefined;
try {
  // 新：通过 bridge extMethod 直接查询连接池，而非引导会话
  accounting = await this.bridge.client.getMcpPoolAccounting();
} catch (err) {
  // 回退到非连接池 daemon 的传统引导会话路径
  const manager = config.getToolRegistry()?.getMcpClientManager();
  if (manager) accounting = manager.getMcpClientAccounting();
}

class QwenAgent {
  getMcpPoolAccounting(): McpClientAccounting | undefined {
    return this.mcpPool?.getAccounting();
  }
}

会话 A 活跃，持有条目 X 引用
会话 A 断开（无显式关闭）→ 最终 killSession → pool.releaseSession(A) → 条目 X.refs.size === 0 → drain 计时器启动（30s）
会话 A 在 30s 内 resume → 新 newSessionConfig → pool.acquire 返回条目 X → attach 取消 drain
会话 A 在 30s 后 resume → 条目 X 已关闭 → 连接池生成新条目（冷启动）

POST /workspace/mcp/reload-all
  → 对每个会话：重载配置，替换 Config.mcpServers
  → 对每个不再被引用的条目：调度驱逐

1. 设置 acceptingNewSessions = false；拒绝新的 POST /session
2. 对每个 in-flight prompt：发送取消信号，等待完成（现有 PR 11 生命周期）
3. 对每个会话：触发关闭 → pool.releaseSession(sid)
4. await pool.drainAll({ force: true, timeoutMs: 10_000 })   ← 绕过 30s 宽限期
   ├── 对每个条目：取消 drain + 健康计时器，标记为 draining
   ├── 对每个条目（并行）：listDescendantPids → SIGTERM 子进程
   ├── 对每个条目（并行）：client.disconnect()
   └── Promise.race vs timeoutMs；超时的条目发送 SIGKILL
5. Bridge 通道关闭
6. 进程退出

async drainAll(opts?: {
  force?: boolean;       // 默认 false；true 绕过 30s 宽限计时器
  timeoutMs?: number;    // 默认 10_000；挂钟预算；超时后对残留条目发送 SIGKILL
}): Promise<DrainResult>;
 
type DrainResult = {
  drained: number;       // 正常断开的条目数
  forced: number;        // 超时后发送 SIGKILL 的条目数
  errors: Array<{ entryIndex: number; serverName: string; error: string }>;
};

packages/core/src/tools/
  mcp-transport-pool.ts        # McpTransportPool 主体（约 700 LOC）
  mcp-pool-key.ts              # fingerprint + 规范化辅助函数（约 150 LOC）
  mcp-pool-entry.ts            # PoolEntry：引用计数 + drain + 健康 + 版本（约 500 LOC）
  session-mcp-view.ts          # SessionMcpView：过滤 + 注册 tools/prompts（约 200 LOC）
  mcp-pool-events.ts           # PoolEvent 判别联合类型（约 80 LOC）
  pid-descendants.ts           # listDescendantPids 跨平台（约 150 LOC，含测试）

packages/core/src/tools/
  mcp-transport-pool.test.ts   # 约 900 LOC
  mcp-pool-entry.test.ts       # 约 400 LOC
  session-mcp-view.test.ts     # 约 250 LOC
  mcp-pool-key.test.ts         # 约 150 LOC
  pid-descendants.test.ts      # 约 200 LOC（Unix + Windows 条件跳过）

packages/core/src/tools/mcp-client.ts            # discoverAndReturn() 拆分；connectToMcpServer 统一
packages/core/src/tools/mcp-client-manager.ts    # 可选 pool 参数；budget 状态条件化
packages/core/src/tools/tool-registry.ts         # 从 config 向 McpClientManager 穿透 pool
packages/core/src/config/config.ts               # setMcpTransportPool / getMcpTransportPool
packages/cli/src/acp-integration/acpAgent.ts     # QwenAgent.mcpPool 构建；broadcastBudgetEvent；
                                                 # newSessionConfig 将 pool 注入 Config；
                                                 # killSession 调用 pool.releaseSession
packages/cli/src/serve/run-qwen-serve.ts           # 向 ACP child 传递 --mcp-pool-transports + budget env
packages/cli/src/serve/httpAcpBridge.ts          # buildWorkspaceMcpStatus 读取 pool；
                                                 # restartMcpServer extMethod 返回 RestartResult[]
packages/cli/src/serve/capabilities.ts           # 广播 mcp_workspace_pool
packages/sdk/src/daemon/mcpEvents.ts             # scope? 可选字段；isWorkspaceScopedBudgetEvent 辅助函数

// @qwen-code/sdk — 仅增量添加
export interface DaemonMcpBudgetWarningData {
  // 现有字段...
  scope?: 'workspace' | 'session'; // 新增 — 旧 daemon 不存在此字段（视为 'session'）
}
 
export interface DaemonMcpChildRefusedBatchData {
  // 现有字段...
  scope?: 'workspace' | 'session';
}
 
export interface ServeWorkspaceMcpServerStatus {
  // 现有字段...
  entryCount?: number;
  entrySummary?: Array<{
    fingerprint: string;
    refs: number;
    status: MCPServerStatus;
  }>;
}
 
export function isWorkspaceScopedBudgetEvent(
  e: DaemonMcpGuardrailEvent,
): boolean;

## feat(serve): shared MCP transport pool (workspace-scoped) [F2]
 
Single feature-cohesive PR per #4175 branching strategy (2026-05-19).
Replaces what was originally planned as Wave 5 PR 23 + sub-PRs F2-1..F2-4.
 
### Scope
 
~4100 LOC production + ~1900 LOC tests across 6 atomic commits.
Step through with `git log -p HEAD~6..HEAD` for commit-by-commit review.
 
### Design doc
 
See `docs/design/f2-mcp-transport-pool.md` (v2.1).
 
### Pre-review specialist agents (per PR 21 pattern)
 
Folded into first commit before opening:
 
- code-reviewer: N findings, all adopted
- silent-failure-hunter: N findings, all adopted
- type-design-analyzer: N findings, all adopted
 
### Closes
 
(none — F2 entry in #4175 stays open until PR merges into main batch)
 
### Related
 
- #3803 decision #3 update (codeagents PR <link>)
- PR 14b (#4271 merged) — budget guardrail base; F2 graduates scope to workspace
- F1 (#4319 merged) — acp-bridge package; F2 depends on injection seams
 
### Backward compatibility
 
- Standalone `qwen` (non-daemon): pool not constructed; existing behavior preserved
- Daemon `qwen serve --no-mcp-pool`: kill switch falls back to per-session
- SDK: all new fields additive (`entryCount`, `scope?`); EVENT_SCHEMA_VERSION stays at 1
- Old SDK clients: unknown `scope: 'workspace'` ignored per PR 14 contract
- Old daemons: SDK consumers can detect absence of `mcp_workspace_pool` capability and fall back
 
### Test plan
 
- [ ] Pool key: env permutation stability, header divergence, per-session filter exclusion
- [ ] Lifecycle: 3-session sharing, drain grace, concurrent acquire dedupe, spawn failure slot release
- [ ] Tools + Prompts dual fan-out, per-session trust copy, snapshot replay on attach
- [ ] Generation guard: pre-reconnect handler doesn't overwrite post-reconnect snapshot
- [ ] Crash + reconnect with stdio backoff (5s × 3) and HTTP backoff (1/2/4/8/16s × 5)
- [ ] Descendant pid sweep: Linux/macOS pgrep recursion, Windows PowerShell CIM
- [ ] Budget at workspace scope: 4 sessions × budget=2 → 3 max (not 12); fan-out to all attached
- [ ] LoadSession resume within drain window: pool entry reused, no cold start
- [ ] Hot config reload: old/new entries coexist; old drains naturally
- [ ] Restart route: `?entryIndex=` selectivity; legacy single-entry response shape preserved
- [ ] In-flight tool call during reconnect: `MCPCallInterruptedError` rejection
- [ ] Standalone qwen: all existing mcp-client-manager tests pass unchanged