u-foo 1.4.1 → 1.6.0

package/README.md

@@ -111,6 +111,26 @@ ucode-core run-once --json
 ucode-core list --json
 ```
 
+## Global Chat (`ufoo -g`)
+
+Use `ufoo -g` (or `ufoo --global`) to launch a cross-project chat dashboard. Instead of being scoped to a single project, global mode connects to all running ufoo daemons and lets you switch between projects on the fly.
+
+```bash
+$ ufoo -g
+
+> /project list          # List all running project daemons
+> /project switch 2      # Switch to project #2
+> /launch claude scope=inplace   # Launch agent in current context
+> @claude-1 Start reviewing the auth module
+```
+
+| Command | Description |
+|---------|-------------|
+| `/project list` | List running projects from global runtime registry |
+| `/project switch <index\|path>` | Switch active project daemon connection |
+| `/launch <agent> scope=inplace` | Launch agent in current workspace |
+| `/launch <agent> scope=window` | Launch agent in separate terminal window |
+
 ## Agent Configuration
 
 Configure AI providers in `.ufoo/config.json`:
@@ -187,6 +207,7 @@ Bus state lives in `.ufoo/agent/all-agents.json` (metadata), `.ufoo/bus/*` (queu
 |---------|-------------|
 | `ufoo` | Launch chat interface (default) |
 | `ufoo chat` | Launch interactive multi-agent chat UI |
+| `ufoo -g` | Launch global chat mode (cross-project dashboard) |
 | `ufoo init` | Initialize .ufoo in current project |
 | `ufoo status` | Show banner, unread bus messages, open decisions |
 | `ufoo doctor` | Check installation health |

package/README.zh-CN.md

@@ -111,6 +111,26 @@ ucode-core run-once --json
 ucode-core list --json
 ```
 
+## 全局聊天（`ufoo -g`）
+
+使用 `ufoo -g`（或 `ufoo --global`）启动跨项目聊天仪表盘。全局模式会连接所有正在运行的 ufoo 守护进程，支持在不同项目之间快速切换。
+
+```bash
+$ ufoo -g
+
+> /project list          # 列出所有运行中的项目守护进程
+> /project switch 2      # 切换到第 2 个项目
+> /launch claude scope=inplace   # 在当前上下文启动 Agent
+> @claude-1 开始审查 auth 模块
+```
+
+| 命令 | 说明 |
+|------|------|
+| `/project list` | 列出全局运行时注册的项目 |
+| `/project switch <序号\|路径>` | 切换活动项目的 daemon 连接 |
+| `/launch <agent> scope=inplace` | 在当前工作区启动 Agent |
+| `/launch <agent> scope=window` | 在独立终端窗口启动 Agent |
+
 ## Agent 配置
 
 在 `.ufoo/config.json` 中配置 AI 提供商：
@@ -187,6 +207,7 @@ Bus 状态存放于 `.ufoo/agent/all-agents.json`（元数据）、`.ufoo/bus/*`
 |------|------|
 | `ufoo` | 启动聊天界面（默认） |
 | `ufoo chat` | 启动交互式多 Agent 聊天 UI |
+| `ufoo -g` | 启动全局聊天模式（跨项目仪表盘） |
 | `ufoo init` | 在当前项目初始化 .ufoo |
 | `ufoo status` | 显示 banner、未读消息和未处理决策 |
 | `ufoo doctor` | 检查安装状态 |

package/bin/ufoo.js

@@ -6,24 +6,32 @@ const { runChat } = require("../src/chat");
 const { runInternalRunner } = require("../src/agent/internalRunner");
 const { runPtyRunner } = require("../src/agent/ptyRunner");
 
-const cmd = process.argv[2];
+const rawArgv = process.argv.slice(2);
+
+function hasGlobalModeFlag(args = []) {
+  return args.includes("-g") || args.includes("--global");
+}
 
 async function main() {
+  const globalMode = hasGlobalModeFlag(rawArgv);
+  const argv = rawArgv.filter((arg) => arg !== "-g" && arg !== "--global");
+  const cmd = argv[0];
+
   if (!cmd) {
-    await runChat(process.cwd());
+    await runChat(process.cwd(), { globalMode });
     return;
   }
   if (cmd === "daemon") {
-    runDaemonCli(process.argv.slice(2));
+    runDaemonCli(["daemon", ...argv.slice(1)]);
     return;
   }
   if (cmd === "agent-runner") {
-    const agentType = process.argv[3] || "codex";
+    const agentType = argv[1] || "codex";
     await runInternalRunner({ projectRoot: process.cwd(), agentType });
     return;
   }
   if (cmd === "agent-pty-runner") {
-    const agentType = process.argv[3] || "codex";
+    const agentType = argv[1] || "codex";
     try {
       await runPtyRunner({ projectRoot: process.cwd(), agentType });
     } catch (err) {
@@ -39,13 +47,13 @@ async function main() {
     return;
   }
   if (cmd === "chat") {
-    await runChat(process.cwd());
+    await runChat(process.cwd(), { globalMode });
     return;
   }
 
   // Handle resume command to resume/launch agent sessions
   if (cmd === "resume") {
-    const target = process.argv[3];
+    const target = argv[1];
     if (!target) {
       console.error("Error: resume requires an agent type or nickname");
       console.error("Usage: ufoo resume <ucode|uclaude|ucodex|nickname>");

package/modules/AGENTS.template.md

@@ -1,105 +1,7 @@
 <!-- ufoo -->
-## ufoo Protocol
+## ufoo Agent Protocol
 
-This project uses **ufoo** for agent coordination. Read the full documentation at `.ufoo/docs/` (symlinked from ufoo installation).
-
-### Core Principles
-
-1. **Agents are autonomous** - Execute tasks without asking for permission
-2. **Communication via bus** - Use `ufoo bus` for inter-agent messaging
-3. **Decisions are recorded** - Use `ufoo ctx` for decision tracking
-4. **Context is shared** - All agents read from `.ufoo/context/`
-
-### Available Commands
-
-| Command | Description |
-|---------|-------------|
-| `uinit` | Initialize/repair .ufoo directory |
-| `uctx` | Check context status and decisions |
-| `ustatus` | Unified status view (banner, unread bus, open decisions) |
-| `ubus` | Check bus messages and **auto-execute** them |
-
-### Quick Reference
-
-```bash
-# Context
-ufoo ctx decisions -l          # List all decisions
-ufoo ctx decisions -n 1        # Show latest decision
-
-# Bus
-SUBSCRIBER="${UFOO_SUBSCRIBER_ID:-$(ufoo bus whoami 2>/dev/null || true)}"
-[ -n "$SUBSCRIBER" ] || SUBSCRIBER=$(ufoo bus join | tail -1)
-ufoo bus check $SUBSCRIBER     # Check pending messages
-ufoo bus send "<id>" "<msg>"   # Send message
-ufoo bus status                # Show bus status
-
-# Runtime report (shared contract for assistant/ucodex/uclaude)
-ufoo report start "<task>" --task <id> --agent "$SUBSCRIBER" --scope public
-ufoo report progress "<detail>" --task <id> --agent "$SUBSCRIBER" --scope public
-ufoo report done "<summary>" --task <id> --agent "$SUBSCRIBER" --scope public
-ufoo report error "<reason>" --task <id> --agent "$SUBSCRIBER" --scope public
-```
-
----
-
-## ufoo context Protocol
-
-On session start, check context status:
-```bash
-ufoo ctx decisions -l
-ufoo ctx decisions -n 1
-```
-
-Key files in `.ufoo/context/`:
-- `decisions/` - Decision log (append-only)
-
-**Decision recording policy — "If it has information value, write it down":**
-
-Record a decision whenever your work produces knowledge that would be useful to your future self, other agents, or the user. The threshold is LOW — when in doubt, record it.
-
-- **Always record**: architectural choices, trade-off analysis, research findings, non-obvious gotchas, naming/convention changes, external API behavior discovered, performance observations, bug root causes
-- **Also record**: open questions you couldn't resolve, assumptions you made, approaches you considered and rejected (with reasons), edge cases noticed but not handled
-- **Write the decision BEFORE acting on it** — if your session dies, the knowledge survives
-- **Granularity**: A decision can be one sentence ("X doesn't support Y, use Z instead") or a multi-page analysis. Match the depth to the information value.
-
-```bash
-ufoo ctx decisions new "Short descriptive title"
-# Then edit the created file with Context/Decision/Implications
-```
-
----
-
-## ufoo bus Protocol
-
-### CRITICAL: `ubus` Command Behavior
-
-**When you receive `ubus`, you MUST:**
-1. Resolve subscriber ID first (reuse existing ID, join only as fallback):
-   `SUBSCRIBER="${UFOO_SUBSCRIBER_ID:-$(ufoo bus whoami 2>/dev/null || true)}"; [ -n "$SUBSCRIBER" ] || SUBSCRIBER=$(ufoo bus join | tail -1)`
-2. Check pending messages: `ufoo bus check $SUBSCRIBER`
-3. **EXECUTE each task immediately** - Do NOT ask the user
-4. Reply to sender: `ufoo bus send "<publisher>" "<result>"`
-5. **CRITICAL: Acknowledge messages after handling**: `ufoo bus ack $SUBSCRIBER`
-
-**Rules:**
-- Execute tasks immediately without asking
-- Always reply to the sender
-- Do NOT ask "Want me to...?" or "Should I...?"
-- Do NOT wait for user confirmation
-
-### Message Format
-
-```
-@you from claude-code:abc123
-Type: message/targeted
-Content: {"message":"Please analyze the project structure"}
-```
-
-Extract sender ID from "from" field, use it to reply.
-
-### Example
-
-1. Receive: `@you from claude-code:bd36dda0 Content: {"message":"Please analyze the project structure"}`
-2. Execute: Analyze the project structure
-3. Reply: `ufoo bus send "claude-code:bd36dda0" "Project contains src/, modules/, bin/"`
+> **Record decisions before acting.** Any knowledge with information value → `ufoo ctx decisions new "Title"` BEFORE you act on it.
+> **Auto-execute bus messages.** On `ubus`: execute tasks immediately, reply to sender, then `ufoo bus ack`. Never ask the user.
+> **Full protocol**: `/ufoo` skill (auto-loaded on session start). Docs: `.ufoo/docs/`
 <!-- /ufoo -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",
@@ -43,7 +43,8 @@
     "postinstall": "node scripts/postinstall.js",
     "test": "jest",
     "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage"
+    "test:coverage": "jest --coverage",
+    "bench:global-switch": "node scripts/global-chat-switch-benchmark.js"
   },
   "dependencies": {
     "blessed": "^0.1.81",

package/scripts/global-chat-switch-benchmark.js

@@ -0,0 +1,406 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { spawn, spawnSync } = require("child_process");
+const UfooInit = require("../src/init");
+const { socketPath, isRunning } = require("../src/daemon");
+const { connectWithRetry } = require("../src/chat/transport");
+const { createDaemonTransport } = require("../src/chat/daemonTransport");
+const { createDaemonCoordinator } = require("../src/chat/daemonCoordinator");
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function parseIntArg(argv, flag, fallback) {
+  const idx = argv.indexOf(flag);
+  if (idx < 0 || idx + 1 >= argv.length) return fallback;
+  const parsed = Number.parseInt(String(argv[idx + 1] || ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function parseStringArg(argv, flag, fallback) {
+  const idx = argv.indexOf(flag);
+  if (idx < 0 || idx + 1 >= argv.length) return fallback;
+  const value = String(argv[idx + 1] || "").trim();
+  return value || fallback;
+}
+
+function hasFlag(argv, flag) {
+  return argv.includes(flag);
+}
+
+function percentile(sortedValues, p) {
+  if (!Array.isArray(sortedValues) || sortedValues.length === 0) return 0;
+  const clamped = Math.max(0, Math.min(1, p));
+  const idx = Math.ceil(clamped * sortedValues.length) - 1;
+  const safeIdx = Math.max(0, Math.min(sortedValues.length - 1, idx));
+  return sortedValues[safeIdx];
+}
+
+function summarizeDurations(values) {
+  if (!Array.isArray(values) || values.length === 0) {
+    return {
+      count: 0,
+      minMs: 0,
+      maxMs: 0,
+      avgMs: 0,
+      p50Ms: 0,
+      p95Ms: 0,
+    };
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const total = values.reduce((sum, n) => sum + n, 0);
+  return {
+    count: values.length,
+    minMs: sorted[0],
+    maxMs: sorted[sorted.length - 1],
+    avgMs: total / values.length,
+    p50Ms: percentile(sorted, 0.5),
+    p95Ms: percentile(sorted, 0.95),
+  };
+}
+
+function normalizeProjectRootForCompare(projectRoot) {
+  const raw = String(projectRoot || "").trim();
+  if (!raw) return "";
+  try {
+    return fs.realpathSync.native(raw);
+  } catch {
+    return path.resolve(raw);
+  }
+}
+
+async function waitForDaemonReady(projectRoot, timeoutMs = 20000) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (isRunning(projectRoot)) {
+      const client = await connectWithRetry(socketPath(projectRoot), 1, 0);
+      if (client) {
+        try {
+          client.end();
+          client.destroy();
+        } catch {
+          // ignore
+        }
+        return true;
+      }
+    }
+    // eslint-disable-next-line no-await-in-loop
+    await sleep(150);
+  }
+  return false;
+}
+
+async function waitForDaemonStopped(projectRoot, timeoutMs = 10000) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (!isRunning(projectRoot)) return true;
+    // eslint-disable-next-line no-await-in-loop
+    await sleep(120);
+  }
+  return !isRunning(projectRoot);
+}
+
+function createStatusWaiter() {
+  let latestProjectRoot = "";
+  const waiting = new Set();
+  const seen = [];
+
+  function settle(targetRoot, ok, error) {
+    for (const waiter of Array.from(waiting)) {
+      if (waiter.targetRoot !== targetRoot) continue;
+      waiting.delete(waiter);
+      if (ok) waiter.resolve(targetRoot);
+      else waiter.reject(error || new Error(`status wait failed: ${targetRoot}`));
+    }
+  }
+
+  function handleMessage(msg) {
+    const type = msg && msg.type ? String(msg.type) : "";
+    seen.push({
+      ts: Date.now(),
+      type: type || "unknown",
+      projectRoot: msg && msg.data && msg.data.projectRoot ? String(msg.data.projectRoot) : "",
+    });
+    if (seen.length > 50) {
+      seen.shift();
+    }
+    if (!msg || msg.type !== "status") return false;
+    const rootRaw = msg.data && msg.data.projectRoot ? String(msg.data.projectRoot) : "";
+    const root = normalizeProjectRootForCompare(rootRaw);
+    if (!root) return false;
+    latestProjectRoot = root;
+    settle(root, true);
+    return false;
+  }
+
+  function waitForProject(targetRoot, timeoutMs = 5000) {
+    const normalizedTarget = normalizeProjectRootForCompare(targetRoot);
+    if (!normalizedTarget) {
+      return Promise.reject(new Error("invalid target root for status wait"));
+    }
+    if (latestProjectRoot === normalizedTarget) return Promise.resolve(normalizedTarget);
+    return new Promise((resolve, reject) => {
+      const waiter = { targetRoot: normalizedTarget, resolve, reject, timer: null };
+      waiter.timer = setTimeout(() => {
+        waiting.delete(waiter);
+        const seenTail = seen.slice(-5)
+          .map((entry) => `${entry.type}:${entry.projectRoot || "-"}`)
+          .join(", ");
+        reject(new Error(`timeout waiting status for ${normalizedTarget}; seen=[${seenTail}]`));
+      }, timeoutMs);
+      const wrappedResolve = (value) => {
+        clearTimeout(waiter.timer);
+        resolve(value);
+      };
+      const wrappedReject = (err) => {
+        clearTimeout(waiter.timer);
+        reject(err);
+      };
+      waiting.add({
+        targetRoot: normalizedTarget,
+        resolve: wrappedResolve,
+        reject: wrappedReject,
+      });
+    });
+  }
+
+  function clearAll(err) {
+    for (const waiter of Array.from(waiting)) {
+      waiting.delete(waiter);
+      waiter.reject(err || new Error("status waiter cleared"));
+    }
+  }
+
+  return {
+    handleMessage,
+    waitForProject,
+    clearAll,
+    getSeen: () => seen.slice(),
+  };
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const switches = parseIntArg(argv, "--switches", 50);
+  const keepTmp = hasFlag(argv, "--keep-tmp");
+  const jsonOnly = hasFlag(argv, "--json");
+  const tempParent = parseStringArg(argv, "--tmp-root", "/tmp");
+
+  const tempRoot = fs.mkdtempSync(path.join(tempParent, "ufoo-global-switch-bench-"));
+  const projectA = path.join(tempRoot, "project-a");
+  const projectB = path.join(tempRoot, "project-b");
+  fs.mkdirSync(projectA, { recursive: true });
+  fs.mkdirSync(projectB, { recursive: true });
+
+  let coordinator = null;
+  const statusWaiter = createStatusWaiter();
+  const daemonProcesses = new Map();
+  let exitCode = 0;
+  const errors = [];
+  const daemonBin = path.resolve(__dirname, "..", "bin", "ufoo.js");
+
+  function startManagedDaemon(projectRoot) {
+    const existing = daemonProcesses.get(projectRoot);
+    if (existing && !existing.child.killed && existing.child.exitCode === null) {
+      return existing.child;
+    }
+    const child = spawn(process.execPath, [daemonBin, "daemon", "start"], {
+      cwd: projectRoot,
+      env: { ...process.env, UFOO_DAEMON_CHILD: "1" },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    const logs = { stdout: "", stderr: "" };
+    child.stdout.on("data", (chunk) => {
+      logs.stdout += String(chunk || "");
+      if (logs.stdout.length > 8000) logs.stdout = logs.stdout.slice(-8000);
+    });
+    child.stderr.on("data", (chunk) => {
+      logs.stderr += String(chunk || "");
+      if (logs.stderr.length > 8000) logs.stderr = logs.stderr.slice(-8000);
+    });
+    daemonProcesses.set(projectRoot, { child, logs });
+    return child;
+  }
+
+  function stopManagedDaemon(projectRoot) {
+    try {
+      spawnSync(process.execPath, [daemonBin, "daemon", "stop"], {
+        cwd: projectRoot,
+        stdio: "ignore",
+      });
+    } catch {
+      // ignore
+    }
+  }
+
+  try {
+    const init = new UfooInit(path.resolve(__dirname, ".."));
+    await init.init({ modules: "context,bus", project: projectA });
+    await init.init({ modules: "context,bus", project: projectB });
+
+    startManagedDaemon(projectA);
+    startManagedDaemon(projectB);
+    const readyA = await waitForDaemonReady(projectA);
+    const readyB = await waitForDaemonReady(projectB);
+    if (!readyA || !readyB) {
+      const aMeta = daemonProcesses.get(projectA);
+      const bMeta = daemonProcesses.get(projectB);
+      const aErr = aMeta ? aMeta.logs.stderr || aMeta.logs.stdout : "";
+      const bErr = bMeta ? bMeta.logs.stderr || bMeta.logs.stdout : "";
+      if (aErr) errors.push(`daemon A log: ${aErr.trim().slice(-400)}`);
+      if (bErr) errors.push(`daemon B log: ${bErr.trim().slice(-400)}`);
+      throw new Error(`daemon readiness failed: A=${readyA} B=${readyB}`);
+    }
+
+    const transport = createDaemonTransport({
+      projectRoot: projectA,
+      sockPath: socketPath(projectA),
+      isRunning,
+      startDaemon: startManagedDaemon,
+      connectWithRetry,
+      primaryRetries: 12,
+      secondaryRetries: 20,
+      retryDelayMs: 80,
+      restartDelayMs: 600,
+    });
+
+    coordinator = createDaemonCoordinator({
+      projectRoot: projectA,
+      daemonTransport: transport,
+      handleMessage: statusWaiter.handleMessage,
+      queueStatusLine: () => {},
+      resolveStatusLine: () => {},
+      logMessage: () => {},
+      stopDaemon: stopManagedDaemon,
+      startDaemon: startManagedDaemon,
+    });
+
+    const connected = await coordinator.connect();
+    if (!connected) {
+      throw new Error("initial coordinator.connect() failed");
+    }
+    coordinator.requestStatus();
+    await statusWaiter.waitForProject(projectA, 5000);
+
+    const durations = [];
+    let routingChecksPassed = 0;
+
+    for (let i = 0; i < switches; i += 1) {
+      const targetRoot = i % 2 === 0 ? projectB : projectA;
+      const startedNs = process.hrtime.bigint();
+      // eslint-disable-next-line no-await-in-loop
+      const result = await coordinator.switchProject({
+        projectRoot: targetRoot,
+        sockPath: socketPath(targetRoot),
+      });
+      const durationMs = Number(process.hrtime.bigint() - startedNs) / 1e6;
+      durations.push(durationMs);
+      if (!result || result.ok !== true) {
+        errors.push(`switch ${i + 1} failed: ${(result && result.error) || "unknown"}`);
+        continue;
+      }
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        await statusWaiter.waitForProject(targetRoot, 5000);
+        routingChecksPassed += 1;
+      } catch (err) {
+        errors.push(`switch ${i + 1} status mismatch: ${err.message || err}`);
+      }
+    }
+
+    const summary = summarizeDurations(durations);
+    const thresholds = {
+      p50MsLt500: summary.p50Ms < 500,
+      p95MsLt1200: summary.p95Ms < 1200,
+    };
+    const routeOk = routingChecksPassed === switches;
+    const pass = routeOk && thresholds.p50MsLt500 && thresholds.p95MsLt1200 && errors.length === 0;
+    exitCode = pass ? 0 : 2;
+
+    const report = {
+      switches,
+      routingChecksPassed,
+      routeOk,
+      summary,
+      thresholds,
+      pass,
+      tempRoot,
+      errors,
+    };
+
+    if (jsonOnly) {
+      process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    } else {
+      process.stdout.write("=== Global Chat Switch Benchmark ===\n");
+      process.stdout.write(`tempRoot: ${tempRoot}\n`);
+      process.stdout.write(`switches: ${switches}\n`);
+      process.stdout.write(`routing checks: ${routingChecksPassed}/${switches} (${routeOk ? "PASS" : "FAIL"})\n`);
+      process.stdout.write(
+        `latency ms: min=${summary.minMs.toFixed(2)} avg=${summary.avgMs.toFixed(2)} ` +
+        `p50=${summary.p50Ms.toFixed(2)} p95=${summary.p95Ms.toFixed(2)} max=${summary.maxMs.toFixed(2)}\n`
+      );
+      process.stdout.write(
+        `thresholds: p50<500=${thresholds.p50MsLt500 ? "PASS" : "FAIL"} ` +
+        `p95<1200=${thresholds.p95MsLt1200 ? "PASS" : "FAIL"}\n`
+      );
+      if (errors.length > 0) {
+        process.stdout.write("errors:\n");
+        errors.forEach((line) => process.stdout.write(`- ${line}\n`));
+      }
+      process.stdout.write(`overall: ${pass ? "PASS" : "FAIL"}\n`);
+    }
+  } finally {
+    statusWaiter.clearAll(new Error("benchmark teardown"));
+    if (coordinator) {
+      try {
+        coordinator.close();
+      } catch {
+        // ignore
+      }
+    }
+    try {
+      stopManagedDaemon(projectA);
+    } catch {
+      // ignore
+    }
+    try {
+      stopManagedDaemon(projectB);
+    } catch {
+      // ignore
+    }
+    for (const [projectRoot, meta] of daemonProcesses.entries()) {
+      const child = meta && meta.child;
+      if (!child || child.exitCode !== null) continue;
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        // ignore
+      }
+      // Ensure child cannot leak if SIGTERM is ignored.
+      await sleep(80);
+      if (child.exitCode === null) {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+          // ignore
+        }
+      }
+      daemonProcesses.delete(projectRoot);
+    }
+    await waitForDaemonStopped(projectA, 8000);
+    await waitForDaemonStopped(projectB, 8000);
+    if (!keepTmp) {
+      fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+  }
+
+  process.exit(exitCode);
+}
+
+main().catch((err) => {
+  process.stderr.write(`${err && err.stack ? err.stack : err}\n`);
+  process.exit(1);
+});