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 守护进程 (packages/cli/src/serve, qwen serve)
  │ 启动
  ▼
ACP 子进程 (qwen --acp, 每工作区单个进程)
  │
  QwenAgent (acpAgent.ts)
  ├── McpTransportPool ◄── 新增，工作区范围，1 个实例
  │     ├── entries: Map<ConnectionId, PoolEntry>
  │     ├── spawnInFlight: Map<ConnectionId, Promise<PoolEntry>>
  │     ├── workspaceContext（绑定到守护进程工作区）
  │     └── budget guardrails（PR 14 状态机，已升级到工作区）
  │
  └── sessions: Map<sessionId, Session>
        └── Session.Config → ToolRegistry → McpClientManager(pool?)
                                                     │
                                            ┌────────┴────────┐
                                            │ 注入池           │
                                            ▼                 ▼
                                pool.acquire(name,cfg,sid)   传统进程内
                                  → 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（每会话，每服务器）
  ├─ 构造函数(toolRegistry, promptRegistry, sessionId, serverName, cfg)
  ├─ applyTools(snapshot) → void   （按 include/exclude 过滤，修饰信任）
  ├─ 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：反向索引，releaseSession 为 O(refs) 而不是 O(entries)。 */
  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(此会话的 refs)，不是 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; // 最后释放后的优雅等待时间
const MAX_IDLE_MS_DEFAULT = 5 * 60_000; // 硬性上限（防御排空定时器取消循环）

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, // 覆盖超过 25 万进程的异常主机
  });
  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: 每个会话的信任副本（不修改共享的 snapshot）
      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 discover 完成和 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; // 被另一次 reconnect 取代
    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,                          // 新增——该名称下有 N 个池条目
  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 REMOVED — 池直接广播
}

{
  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'`）下，由于预算事件在工作区级别扇出，
 * 该计数器会在所有附加会话中同时递增。
 * 使用 `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 {
  // 新增：通过桥接的 extMethod 直接查询池，而不是 bootstrap 会话
  accounting = await this.bridge.client.getMcpPoolAccounting();
} catch (err) {
  // 回退到传统的 bootstrap 会话路径，用于非池守护进程
  const manager = config.getToolRegistry()?.getMcpClientManager();
  if (manager) accounting = manager.getMcpClientAccounting();
}

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

session-A 活动，持有 entry-X 的引用
session-A 断开连接（无显式关闭）→ 最终 killSession → pool.releaseSession(A) → entry-X.refs.size === 0 → 排空计时器启动（30 秒）
session-A 在 30 秒内恢复 → 新的 newSessionConfig → pool.acquire 返回 entry-X → attach 取消排空
session-A 在 30 秒后恢复 → entry-X 已关闭 → 池生成新条目（冷启动）

POST /workspace/mcp/reload-all
  → 对于每个会话：重新加载设置，交换 Config.mcpServers
  → 对于不再被引用的 entry：安排逐出

1. 设置 acceptingNewSessions = false；拒绝新的 POST /session
2. 对于每个进行中的 prompt：发送取消信号，等待完成（现有 PR 11 生命周期）
3. 对于每个会话：触发 close → pool.releaseSession(sid)
4. await pool.drainAll({ force: true, timeoutMs: 10_000 })   ← 绕过 30 秒 grace
   ├── 对于每个 entry：取消排空 + 健康检查定时器，标记为 draining
   ├── 对于每个 entry 并行：listDescendantPids → SIGTERM 子进程
   ├── 对于每个 entry 并行：client.disconnect()
   └── Promise.race 与 timeoutMs；超时后的条目接收 SIGKILL
5. 桥接通道关闭
6. 进程退出

async drainAll(opts?: {
  force?: boolean;       // 默认为 false；true 绕过 30 秒 grace 定时器
  timeoutMs?: number;    // 默认为 10000；墙上时钟预算；超时后 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 行）
  mcp-pool-key.ts              # fingerprint + canonicalize 辅助函数（约 150 行）
  mcp-pool-entry.ts            # PoolEntry：refcount + drain + health + generation（约 500 行）
  session-mcp-view.ts          # SessionMcpView：过滤 + 注册 tools/prompts（约 200 行）
  mcp-pool-events.ts           # PoolEvent 区分联合（约 80 行）
  pid-descendants.ts           # 跨平台 listDescendantPids（约 150 行，含测试）

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

packages/core/src/tools/mcp-client.ts            # discoverAndReturn() 拆分；connectToMcpServer 统一
packages/core/src/tools/mcp-client-manager.ts    # 可选的 pool 参数；预算状态条件化
packages/core/src/tools/tool-registry.ts         # 从 config 将 pool 传入 McpClientManager
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           # 传递 --mcp-pool-transports + budget env 给 ACP 子进程
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'; // 新增——旧守护进程上不存在（默认为 '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): 共享 MCP 传输池（工作空间作用域）[F2]
 
根据 #4175 分支策略（2026-05-19）的单一功能内聚 PR。
替代原计划中的 Wave 5 PR 23 + 子 PR F2-1..F2-4。
 
### 范围
 
~4100 LOC 生产代码 + ~1900 LOC 测试，分布在 6 个原子提交中。
使用 `git log -p HEAD~6..HEAD` 逐提交进行审查。
 
### 设计文档
 
参见 `docs/design/f2-mcp-transport-pool.md` (v2.1)。
 
### 预审查专项 agent（参照 PR 21 模式）
 
在开启 PR 前已合并到第一个提交中：
 
- code-reviewer：N 项发现，全部采纳
- silent-failure-hunter：N 项发现，全部采纳
- type-design-analyzer：N 项发现，全部采纳
 
### 关闭
 
（无 — #4175 中的 F2 条目保持开启，直到 PR 合并到主批次）
 
### 关联
 
- #3803 第 #3 条决策更新（codeagents PR <链接>）
- PR 14b (#4271 已合并) — 预算防护基础；F2 将其作用域升级为工作空间
- F1 (#4319 已合并) — acp-bridge 包；F2 依赖于注入接缝
 
### 向后兼容性
 
- 独立 `qwen`（非守护模式）：不构造池；保留现有行为
- 守护模式 `qwen serve --no-mcp-pool`：禁用开关恢复为每会话模式
- SDK：所有新字段均为增量添加（`entryCount`、`scope?`）；`EVENT_SCHEMA_VERSION` 保持为 1
- 旧版 SDK 客户端：根据 PR 14 契约忽略未知的 `scope: 'workspace'`
- 旧版守护程序：SDK 消费者可以检测到 `mcp_workspace_pool` 能力缺失并回退
 
### 测试计划
 
- [ ] 池键：环境变量的稳定性，下标的发散性，每会话过滤器排除
- [ ] 生命周期：3 个会话共享，优雅释放，并发获取去重，生成失败槽位释放
- [ ] 工具 + Prompts 双向广播，每会话信任复制，附加时快照重放
- [ ] 生成防护：重新连接前的处理器不会覆盖重新连接后的快照
- [ ] 崩溃 + 重连（stdio 退避 5s × 3 和 HTTP 退避 1/2/4/8/16s × 5）
- [ ] 后代进程 pid 扫描：Linux/macOS 的 pgrep 递归，Windows PowerShell CIM
- [ ] 工作空间作用域的预算：4 个会话 × 预算=2 → 最多 3 个（不是 12）；广播到所有已附加的会话
- [ ] 在释放窗口内恢复 LoadSession：复用池条目，无冷启动
- [ ] 热配置重载：新旧条目共存；旧条目自然释放
- [ ] 重启路由：`?entryIndex=` 选择性；保留旧版单条目响应形状
- [ ] 重连期间正在进行的工具调用：`MCPCallInterruptedError` 拒绝
- [ ] 独立 qwen：所有现有的 mcp-client-manager 测试保持不变