mslxdff 0.1.180 → 0.1.183

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.180",
+  "version": "0.1.183",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/cli/commands/daemon.js

@@ -1,14 +1,27 @@
 import { existsSync, writeFileSync } from "node:fs";
-import { startDaemon, stopDaemon, readPid, readPidVersion, isPidAlive, pidFile, logFile } from "../../daemon.js";
+import { startDaemon, stopDaemon, readPid, readPidVersion, isPidAlive, pidFile, logFile, waitPidGone, reapGhostDaemons } from "../../daemon.js";
 import { setPort } from "../../state.js";
 import { logDir, eventsFile, callsFile, errorsFile } from "../../logs.js";
 import { effectivePort, waitForHealth, stopDaemonIfOutdated, compareSemver, argValue } from "../policy.js";
 import { printStatus } from "../status.js";
 import { compatFetch, timeoutSignal } from "../../compat.js";
+import { findDaemons, fmtAlive } from "../../runtime/proc-info.js";
+
+/** 停 daemon 并**等它真死**：只发 SIGTERM 就起新的会留下幽灵（隧道子进程把事件循环钉住，见 daemon.js waitPidGone）。 */
+async function stopDaemonHard(reason) {
+  const pid = readPid();
+  const r = stopDaemon({ reason });
+  if (pid && r.stopped) {
+    const g = await waitPidGone(pid);
+    if (!g.died) console.log(`⚠ 旧 daemon (pid ${pid}) 等了 ${Math.round(g.waitedMs / 1000)}s 仍没退（已补 SIGKILL）—— 若仍在世，它会和新的抢端口`);
+    else if (g.forced) console.log(`旧 daemon (pid ${pid}) 未响应 SIGTERM，已 SIGKILL（等了 ${Math.round(g.waitedMs / 1000)}s）`);
+  }
+  return r;
+}
 
 export async function handleStop(args) {
   if (!(args.includes("-stop") || args.includes("--stop"))) return false;
-  const { stopped, pid, reason } = stopDaemon();
+  const { stopped, pid, reason } = await stopDaemonHard("stop");
   if (stopped) {
     console.log(`mslxdff daemon stopped (pid ${pid})`);
   } else {
@@ -23,14 +36,17 @@ export async function handleRestart(args, VERSION) {
   const alive = pid ? isPidAlive(pid) : false;
   if (alive) {
     console.log(`restarting daemon (pid ${pid})...`);
-    stopDaemon({ reason: "restart" });
-    await new Promise((r) => setTimeout(r, 300));
+    await stopDaemonHard("restart");
   } else if (pid) {
     console.log(`daemon pid ${pid} is stale (not running) — starting fresh...`);
     try { stopDaemon({ reason: "restart" }); } catch {}
   } else {
-    console.log(`daemon not running — starting...`);
+    console.log("daemon not running — starting...");
   }
+  // 结构性盲区收口：不在 daemon.pid 里的 daemon 永远杀不到（真机：Oct16 起的旧 daemon 活了一整天，
+  // 与新版互杀 warp-pool 端口；两边日志格式交错才暴露）。起新的之前先清干净。
+  const ghosts = await reapGhostDaemons({ log: (m) => console.log(m) });
+  if (ghosts.length) console.log(`已清掉 ${ghosts.length} 个不在册的 daemon（pid ${ghosts.map((g) => g.pid).join(", ")}）`);
   const port = effectivePort(args);
   const spawnedPid = startDaemon([]);
   await waitForHealth(port, 4000);
@@ -39,7 +55,12 @@ export async function handleRestart(args, VERSION) {
     const r = await compatFetch(`http://127.0.0.1:${port}/health`, { signal: timeoutSignal(1200) });
     ok = r.ok;
   } catch {}
-  if (ok) console.log(`mslxdff v${VERSION} restarted as a background daemon (pid ${spawnedPid})`);
+  // 诚实报错：/health 可能由**残留的旧 daemon** 应答（它也在监听同一个端口），所以不能只看 health
+  const leftover = findDaemons({ self: spawnedPid });
+  const leftTxt = leftover.map((g) => `pid ${g.pid}（已运行 ${fmtAlive(g.aliveSec)}）`).join("；");
+  if (leftover.length) {
+    console.log(`⚠ 仍有 ${leftover.length} 个旧 daemon 在跑：${leftTxt} —— 它们会和新的抢出口池端口，请 kill 掉`);
+  } else if (ok) console.log(`mslxdff v${VERSION} restarted as a background daemon (pid ${spawnedPid})`);
   else console.log(`mslxdff v${VERSION} restarted (pid ${spawnedPid}) — health check pending (http://127.0.0.1:${port}/health)`);
   console.log(`endpoint:   http://localhost:${port}/v1`);
   console.log(`log:        ${logFile()}`);

package/src/daemon.js

@@ -4,6 +4,7 @@ import { join, dirname } from "node:path";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { writeExitMarker } from "./runtime/lifecycle-forensics.js";
+import { aliveSec, findDaemons, fmtAlive } from "./runtime/proc-info.js";
 
 export function daemonDir() {
   return process.env.MSLXDFF_DAEMON_DIR || join(os.homedir(), ".config", "mslxdff");
@@ -110,3 +111,85 @@ export function stopDaemon({ reason = "stop" } = {}) {
   if (killFailed) return { stopped: false, pid, reason: "EPERM — process kill denied (try running terminal as Administrator, or use restart-daemon.bat)" };
   return { stopped: true, pid, stale: !victimAlive };
 }
+
+/**
+ * 等目标进程真的死掉，超时补 SIGKILL。返回 { died, forced, waitedMs }。
+ * 为什么必须有：只发 SIGTERM 就 spawn 新 daemon，会留下「收到信号但退不出去」的幽灵
+ * （隧道子进程把事件循环钉住）——它不在 daemon.pid 里，从此 `-restart` 结构性碰不到它。
+ */
+export async function waitPidGone(pid, { timeoutMs = 5000, killWaitMs = 2000, stepMs = 100, kill = process.kill, isAlive = isPidAlive, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) } = {}) {
+  const t0 = Date.now();
+  while (isAlive(pid) && Date.now() - t0 < timeoutMs) await sleep(stepMs);
+  if (!isAlive(pid)) return { died: true, forced: false, waitedMs: Date.now() - t0 };
+  try { kill(pid, "SIGKILL"); } catch {}
+  const t1 = Date.now();
+  while (isAlive(pid) && Date.now() - t1 < killWaitMs) await sleep(stepMs);
+  return { died: !isAlive(pid), forced: true, waitedMs: Date.now() - t0 };
+}
+
+/**
+ * 清「不在 daemon.pid 里的」幽灵 daemon —— `-restart` 的结构性盲区
+ *（真机事故：旧 daemon 活了一整天，与新版互杀 warp-pool 端口，两边日志格式交错才暴露）。
+ * 先 SIGTERM 全清 → 等 5s → 仍活着的 SIGKILL。返回**确实清掉**的清单（供调用方诚实汇报）。
+ */
+export async function reapGhostDaemons({ self = process.pid, list = () => findDaemons({ self }), kill = process.kill, log = () => {}, isAlive = isPidAlive, settleMs = 5000, killWaitMs = 2000, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) } = {}) {
+  const ghosts = list();
+  if (!ghosts.length) return [];
+  for (const g of ghosts) log(`[daemon] 发现不在册的 daemon pid=${g.pid}（父 ${g.ppid}，已运行 ${fmtAlive(g.aliveSec)}）—— -restart 杀不到它，清掉`);
+  for (const g of ghosts) { try { kill(g.pid, "SIGTERM"); } catch {} }
+  const t0 = Date.now();
+  while (Date.now() - t0 < settleMs && ghosts.some((g) => isAlive(g.pid))) await sleep(100);
+  const stuck = ghosts.filter((g) => isAlive(g.pid));
+  for (const g of stuck) { try { kill(g.pid, "SIGKILL"); } catch {} }
+  const t1 = Date.now();
+  while (Date.now() - t1 < killWaitMs && stuck.some((g) => isAlive(g.pid))) await sleep(100);
+  return ghosts.filter((g) => !isAlive(g.pid));
+}
+
+/**
+ * 接管：内存里若还有**别的** mslxdff daemon，先把比我们旧的那批请出去。
+ * 为什么必须有（用户点名要求 + 真机 2026-10-17 事故）：`-restart` 只认 `daemon.pid`，
+ * 不在册的 daemon（SIGTERM 后没真退出、pid 文件又被删掉的那个）会活一整天，与新版互抢
+ * warp-pool 的 4 个端口——日志里只能看到「起一条死一条」，看不出是两个 daemon 在互杀。
+ * 判据：比自己早启动 ≥ `minAgeMs` 的一律清（SIGTERM → 等 → SIGKILL）；与本次启动几乎同时的不动
+ * （谁该活由 8989 的 bind 决定，`server-lifecycle` 的 EADDRINUSE 自愈会收口），避免两边互杀。
+ * 全程不抛（接管失败绝不能挡住启动）。
+ * @returns {Promise<{killed:number[], skipped:number[], remaining:number[]}>}
+ */
+export async function takeoverOlderDaemons({
+  self = process.pid,
+  list = () => findDaemons({ self }),
+  kill = process.kill,
+  isAlive = isPidAlive,
+  log = () => {},
+  minAgeMs = 3000,
+  settleMs = 5000,
+  killWaitMs = 2000,
+  myAliveSec = undefined,
+  sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
+} = {}) {
+  const sibs = list();
+  if (!sibs.length) return { killed: [], skipped: [], remaining: [] };
+  const mine = myAliveSec === undefined ? aliveSec(self) : myAliveSec;
+  // 取不到运行时长（非 Linux / 读不到 /proc）时保守处理：一律当成「旧的」，因为只允许一个 daemon 活着
+  const isOlder = (d) => mine == null || d.aliveSec == null || (d.aliveSec - mine) * 1000 >= minAgeMs;
+  const older = sibs.filter(isOlder);
+  const skipped = sibs.filter((d) => !isOlder(d));
+
+  for (const d of older) log(`[daemon] 内存里还有别的 mslxdff daemon：pid ${d.pid}（父 ${d.ppid}，已运行 ${fmtAlive(d.aliveSec)}，比本进程旧）—— 先请它退出，否则两个 daemon 会抢同一批端口（warp-pool 起一条死一条的真因）`);
+  for (const d of older) { try { kill(d.pid, "SIGTERM"); } catch {} }
+  const t0 = Date.now();
+  while (Date.now() - t0 < settleMs && older.some((d) => isAlive(d.pid))) await sleep(100);
+  const stuck = older.filter((d) => isAlive(d.pid));
+  for (const d of stuck) log(`[daemon] pid ${d.pid} 收到 SIGTERM 后 ${Math.round((Date.now() - t0) / 1000)}s 仍没退，补 SIGKILL`);
+  for (const d of stuck) { try { kill(d.pid, "SIGKILL"); } catch {} }
+  const t1 = Date.now();
+  while (Date.now() - t1 < killWaitMs && stuck.some((d) => isAlive(d.pid))) await sleep(100);
+
+  const remaining = older.filter((d) => isAlive(d.pid));
+  const killed = older.filter((d) => !isAlive(d.pid)).map((d) => d.pid);
+  for (const d of skipped) log(`[daemon] ⚠ 同机还有 pid ${d.pid}（与本次启动几乎同时，不是旧的）—— 不动它，由 8989 的 bind 决定谁活`);
+  if (remaining.length) log(`[daemon] ⚠ 请不走：pid ${remaining.map((d) => d.pid).join(",")}（SIGKILL 都没用，可能是僵尸或权限不足）—— 它仍会抢端口，请手动 kill -9`);
+  else if (killed.length) log(`[daemon] ✓ 已请走 ${killed.length} 个旧 daemon（pid ${killed.join(",")}），本进程独占`);
+  return { killed, skipped: skipped.map((d) => d.pid), remaining: remaining.map((d) => d.pid) };
+}

package/src/runtime/bootstrap.js

@@ -14,6 +14,17 @@ const logs = { appendCall, appendError, appendEvent, appendTimeline, appendModel
 export async function startDaemonMain(VERSION) {
   const { installLifecycleLog } = await import("./lifecycle-log.js");
   installLifecycleLog({ version: VERSION, logs });
+  // 接管：内存里若还有旧的 mslxdff daemon，先请它退出。它不在 daemon.pid 里（-restart 结构性碰不到它），
+  // 两个 daemon 会互抢 warp-pool 的端口（真机 2026-10-17：旧 daemon 活了一整天，日志只显示「起一条死一条」）。
+  // 必须早于 setupProviders —— 那一步才建池抢端口。debug 前台有自己的收口逻辑，不在这里抢。
+  if (process.env.MSLXDFF_DAEMON === "1" && process.env.MSLXDFF_DEBUG !== "1") {
+    try {
+      const { takeoverOlderDaemons } = await import("../daemon.js");
+      await takeoverOlderDaemons({ log: (m) => console.log(m) });
+    } catch (e) {
+      console.log(`[daemon] 接管旧 daemon 失败（不阻断启动）：${String(e?.message || e)}`);
+    }
+  }
   const ctx = await setupProviders();
   const { srv, bus } = await startServerLifecycle({ VERSION, ...ctx, logs });
   void srv;

package/src/runtime/proc-info.js

@@ -0,0 +1,137 @@
+// 进程取证层（Linux /proc 只读）——2026-10-17 组长 VPS「幽灵 daemon 互杀」事故后新增。
+//
+// 事故：两个 daemon 同时活着（一个从昨天起活了一整天），都管同一份 warp-pool 目录，
+// 把对方的 wireproxy 当「上一代残留」杀掉 ⇒ 无限互杀、池永远不稳。三处都缺「读 /proc 说事实」的能力：
+//   ① 日志不知道「同机还有几个 daemon」（只能靠人肉 ps 才发现）；
+//   ② 清理不知道「这个 wireproxy 的父进程还活着（= 另一个 daemon 的活隧道）」；
+//   ③ 「SIGKILL 都清不掉」其实是**僵尸**（state=Z，kill 对它无效，但 kill(pid,0) 仍返回成功）。
+// 放 runtime 而不是 warp-pool：daemon 与 warp-pool 都要用，放 warp-pool 会让 daemon 反向依赖它。
+// 非 Linux 一律返回空 —— 读不到 /proc 就别猜（不在别的平台做危险推断）。
+import { readFileSync, readdirSync } from "node:fs";
+
+/** /proc/<pid>/cmdline 是 NUL 分隔的字节串；切成参数数组（丢掉结尾空串）。 */
+export function parseCmdline(buf) {
+  return String(buf == null ? "" : buf).split("\0").filter((s) => s !== "");
+}
+
+/**
+ * /proc/<pid>/stat → 我们关心的三格。
+ * 格式 `pid (comm) state ppid ... starttime`：comm 里可能有空格和括号 ⇒ 从**最后一个** `)` 之后切，
+ * 否则 comm 带括号的进程会让后面所有字段错位。
+ * @returns {{state:string, ppid:number, startTicks:number} | null}
+ */
+export function parseStat(raw) {
+  const s = String(raw == null ? "" : raw);
+  const cut = s.lastIndexOf(")");
+  if (cut < 0) return null;
+  const f = s.slice(cut + 1).trim().split(/\s+/);
+  if (f.length < 20) return null;
+  return { state: String(f[0] || ""), ppid: Number(f[1]) || 0, startTicks: Number(f[19]) || 0 };
+}
+
+/** 僵尸：已死、等父进程收尸。kill 对它无效，但 kill(pid, 0) 仍返回成功 ⇒ 必须单独判。 */
+export function isZombie(state) {
+  return String(state || "").toUpperCase() === "Z";
+}
+
+/** 进程是否还在（信号 0 = 只做存在性检查，不真发信号）。 */
+export function pidAlive(pid, kill = process.kill) {
+  try {
+    kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function defaultPids() {
+  try {
+    return readdirSync("/proc").filter((f) => /^\d+$/.test(f)).map(Number);
+  } catch {
+    return [];
+  }
+}
+
+export function defaultCmdline(pid) {
+  try {
+    return parseCmdline(readFileSync(`/proc/${pid}/cmdline`));
+  } catch {
+    return [];
+  }
+}
+
+export function defaultStat(pid) {
+  try {
+    return parseStat(readFileSync(`/proc/${pid}/stat`, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/** 本机已开机秒数（/proc/uptime 第一列）；读不到返回 0。 */
+export function uptimeSec() {
+  try {
+    const n = Number(String(readFileSync("/proc/uptime", "utf8")).trim().split(/\s+/)[0]);
+    return Number.isFinite(n) ? n : 0;
+  } catch {
+    return 0;
+  }
+}
+
+/** 进程已运行秒数 = 开机秒数 − starttime/USER_HZ（Linux USER_HZ 恒为 100）。取不到返回 null。 */
+export function aliveSec(pid, { uptime = uptimeSec, stat = defaultStat } = {}) {
+  const st = stat(pid);
+  const up = uptime();
+  if (!st || !(up > 0) || !(st.startTicks > 0)) return null;
+  return Math.max(0, Math.round(up - st.startTicks / 100));
+}
+
+/** argv 看起来是我们的 daemon：带 `--daemon`，且有参数以 `mslxdff` / `mslxdff.js` 结尾。 */
+export function isDaemonArgv(argv) {
+  const list = Array.isArray(argv) ? argv : [];
+  return list.includes("--daemon") && list.some((a) => /(^|[\\/])mslxdff(\.js)?$/i.test(String(a)));
+}
+
+/** 「已运行 6h12m」这种人话时长（取证日志用）。 */
+export function fmtAlive(sec) {
+  if (!Number.isFinite(sec)) return "运行时长未知";
+  const s = Math.max(0, Math.round(sec));
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.floor(s / 60)}m`;
+  return `${Math.floor(s / 3600)}h${Math.floor((s % 3600) / 60)}m`;
+}
+
+/**
+ * 同机其它我们的 daemon（排除 self）。
+ * 「不在 daemon.pid 里的 daemon」是 `-restart` 的结构性盲区 —— 必须能列出来，才谈得上清理与告警。
+ * @returns {Array<{pid:number, ppid:number, state:string, aliveSec:number|null}>}
+ */
+export function findDaemons({ self = 0, pids = defaultPids, cmdline = defaultCmdline, stat = defaultStat, uptime = uptimeSec } = {}) {
+  const out = [];
+  for (const pid of pids()) {
+    if (pid === self) continue;
+    if (!isDaemonArgv(cmdline(pid))) continue;
+    const st = stat(pid);
+    out.push({
+      pid,
+      ppid: st ? st.ppid : 0,
+      state: st ? st.state : "",
+      aliveSec: aliveSec(pid, { uptime, stat: () => st }),
+    });
+  }
+  return out;
+}
+
+/**
+ * 该进程的父进程是不是**另一个活着的 mslxdff daemon**？
+ * 是 ⇒ 这不是「上一代残留」，是**别人的活隧道**（清了就是互杀）。
+ * 自家子进程（ppid=self）、孤儿（ppid<=1 或父进程已死）、读不到 stat 都返回 null（照旧清）。
+ * @returns {{pid:number, aliveSec:number|null} | null}
+ */
+export function otherDaemonParent(pid, { self = process.pid, stat = defaultStat, cmdline = defaultCmdline, kill = process.kill, uptime = uptimeSec } = {}) {
+  const st = stat(pid);
+  if (!st || st.ppid <= 1 || st.ppid === self) return null;
+  if (!pidAlive(st.ppid, kill)) return null;
+  if (!isDaemonArgv(cmdline(st.ppid))) return null;
+  return { pid: st.ppid, aliveSec: aliveSec(st.ppid, { uptime, stat }) };
+}

package/src/server.js

@@ -38,9 +38,18 @@ export function startServer({ router, signals = true, host, onBeforeClose }, por
     // 关停留痕（Linux 有效：可捕获 SIGTERM/SIGINT 并记录）。Windows 注意：process.kill 的
     // SIGTERM 实为 TerminateProcess 强杀，被杀的 JS 进程收不到该事件，此处不会触发——
     // Windows 的"谁杀了我"靠 src/daemon.js stopDaemon() 的杀者留痕 + 最后一条 heartbeat。
+    let stopping = false;
     const onSignal = (sig) => {
+      if (stopping) return;
+      stopping = true;
       try { console.log(`[lifecycle] ${sig} received — shutting down (pid ${process.pid}, uptime ${Math.round(process.uptime())}s)`); } catch {}
-      close();
+      // 关停必须**真的退出**：warp-pool 的 wireproxy 子进程 stdio 是 pipe，活着的子进程会把事件循环钉住；
+      // 只 close() server（放开 8989）会留下「不监听端口却还活着」的幽灵 daemon
+      //（真机 2026-10-17：Oct16 起的幽灵与新版互杀 warp-pool 端口一整天，且它不在 daemon.pid 里，-restart 永远碰不到）。
+      // process.exit 会跑 exit 钩子（warp-pool 杀隧道、lifecycle 写遗书），故清理不会被跳过。
+      const hard = setTimeout(() => { try { console.log(`[lifecycle] ${sig} 优雅关停 8s 未完成 — 强制退出`); } catch {} process.exit(0); }, 8000);
+      hard.unref?.();
+      close().then(() => process.exit(0), (e) => { try { console.log(`[lifecycle] 关停抛错：${String(e?.message || e)}`); } catch {} process.exit(1); });
     };
     process.on("SIGINT", () => onSignal("SIGINT"));
     process.on("SIGTERM", () => onSignal("SIGTERM"));

package/src/warp-pool/health.js

@@ -1,5 +1,6 @@
 // warp-pool · 节点健康：主动探活（经隧道打上游 models，不烧 token）+ 失败冷却 + 连续失败触发重拨换 IP。
 import { probeTunnel } from "./wireproxy.js";
+import { fmtHealth, fmtHeartbeat, dur, MARK } from "./report.js";
 
 export function createHealthMonitor({
   dispatcher,
@@ -7,41 +8,81 @@ export function createHealthMonitor({
   probePath = "/zen/v1/models",
   unhealthyAfter = 3,
   intervalMs = 60_000,
+  heartbeatEvery = 10,
+  infoOf = null,
+  cooldownMs = 600_000,
   onExhausted = null,
   probe = probeTunnel,
   headers = {},
+  now = Date.now,
   log = () => {},
 } = {}) {
   let timer = null;
   let rounds = 0;
+  let ticks = 0;
+  let lastAllDownAt = "";
+  /** @type {Map<number, boolean>} 每端口上一轮通不通（用来只在「状态变化」时打日志） */
+  const lastOk = new Map();
+  const stamp = () => new Date(now()).toISOString().slice(11, 19);
 
-  /** 跑一轮全池探活。返回 { checked, healthy }。 */
+  /**
+   * 跑一轮全池探活。日志纪律：**只在「状态有变化」「全池不通」「心跳点」时打**——每分钟一行会把日志淹掉。
+   * 每个不通的节点都要报全：HTTP 状态、错误原文、耗时、连续第几次、冷却多久（这样才不用靠猜）。
+   */
   async function tick() {
     if (!dispatcher) return { checked: 0, healthy: 0 };
     const list = dispatcher.entries();
     let healthy = 0;
+    let slowestMs = 0;
+    const problems = [];
+    const changes = [];
     for (const e of list) {
       const r = await probe({ port: e.port, baseUrl, path: probePath, headers }).catch((err) => ({
         ok: false,
         error: String(err?.message || err),
       }));
+      if (Number(r.ms) > slowestMs) slowestMs = Number(r.ms);
       if (r.ok) {
         dispatcher.markOk(e.index);
         healthy += 1;
-      } else {
-        dispatcher.markFailure(e.index);
+        if (lastOk.get(e.port) === false) changes.push(`:${e.port} 恢复（HTTP ${r.status}，${dur(r.ms)}）`);
+        lastOk.set(e.port, true);
+        continue;
       }
+      dispatcher.markFailure(e.index);
+      if (lastOk.get(e.port) !== false) {
+        changes.push(`:${e.port} 掉线（HTTP ${r.status || 0}${r.error ? ` ${String(r.error).slice(0, 80)}` : ""}）`);
+      }
+      lastOk.set(e.port, false);
+      problems.push({ port: e.port, status: r.status, error: r.error, ms: r.ms, fails: Number(e.fails || 0) + 1, cooldownMs });
     }
-    if (list.length > 0 && healthy === 0) {
+    const allDown = list.length > 0 && healthy === 0;
+    ticks += 1;
+    if (allDown) {
       rounds += 1;
-      log(`[warp-pool] 全池 ${list.length} 个节点均不可用（连续第 ${rounds} 轮）`);
-      if (rounds >= 2 && typeof onExhausted === "function") {
-        rounds = 0;
-        await onExhausted().catch((e) => log(`[warp-pool] 重拨失败：${String(e?.message || e)}`));
-      }
+      lastAllDownAt = stamp();
     } else {
       rounds = 0;
     }
+    if (changes.length || allDown || ticks % heartbeatEvery === 0) {
+      log(fmtHealth({ healthy, total: list.length, slowestMs, problems }));
+    }
+    for (const c of changes) log(`[warp-pool] ${MARK.warn} 状态变化：${c}`);
+    if (ticks % heartbeatEvery === 0) {
+      const extra = typeof infoOf === "function" ? infoOf() || {} : {};
+      log(fmtHeartbeat({
+        alive: extra.alive ?? list.length,
+        total: list.length,
+        pooled: extra.pooled ?? list.length,
+        exits: extra.exits || [],
+        cooling: list.filter((e) => Number(e.cooldownUntil) > now()).length,
+        lastAllDown: lastAllDownAt,
+      }));
+    }
+    if (allDown && rounds >= 2 && typeof onExhausted === "function") {
+      rounds = 0;
+      await onExhausted().catch((e) => log(`[warp-pool] 重拨失败：${String(e?.message || e)}`));
+    }
     return { checked: list.length, healthy };
   }
 

package/src/warp-pool/index.js

@@ -8,8 +8,10 @@ import { ensureDir, loadNodes, removeNode, saveNode } from "./nodes.js";
 import { registerWarpDevice } from "./register.js";
 import { ensureBinary, probeTunnel, resolveAsset, startTunnel, writeTunnelConf } from "./wireproxy.js";
 import { createReviver, labelExits, tailReason } from "./revive.js";
-import { portInUse, reclaimPort, waitPortFree } from "./ports.js";
+import { portInUse, portOwner, reclaimPort, waitPortFree } from "./ports.js";
+import { fmtConf, fmtExit, fmtPool, fmtPoolEmpty, fmtProbe, fmtProbeGiveUp, fmtPortBlocked, fmtSiblings, fmtSpawn, startupReport } from "./report.js";
 import { wireRotation } from "./identity.js";
+import { findDaemons } from "../runtime/proc-info.js";
 
 /** 重拨节流：连续失败指数退避。网络不通的机器绝不能让重注册把 CF 刷到 429。 */
 const REDIAL_MIN_GAP_MS = 5 * 60_000;
@@ -95,25 +97,26 @@ export function createWarpPool({
   async function bringUp(node) {
     if (tunnels.has(node.port)) return; // 已归我们管：绝不再清残留（reclaim 会把自己这条隧道当残留杀掉）
     await reclaim({ dir: cfg.dir, port: node.port, log }); // 清上一代孤儿（daemon 被强杀时子进程不会自己退）
-    writeTunnelConf(cfg.dir, node);
+    const { conf, bytes } = writeTunnelConf(cfg.dir, node);
+    log(fmtConf({ port: node.port, conf, bytes }));
     // SIGTERM 之后套接字要几百毫秒才释放，这期间连得上 ≠ 别人的进程占着——先等它真空出来再判
     if (!(await waitFree(node.port, { inUse }))) {
-      throw new Error(`端口 :${node.port} 被非本池进程占着，拒绝再起（硬起只会 bind 失败、无限重启刷屏）；查明：ss -ltnp | grep :${node.port}`);
+      const owner = await portOwner({ dir: cfg.dir, port: node.port }).catch(() => ({ ours: [], others: [] }));
+      throw new Error(fmtPortBlocked({ port: node.port, ...owner }));
     }
     const t = start({
       binPath,
       dir: cfg.dir,
       port: node.port,
       log,
-      onExit: ({ port, code, signal, tail }) => {
+      onExit: ({ port, code, signal, tail, pid, aliveMs }) => {
         tunnels.delete(port);
-        const why = tailReason(tail) || "进程没留下任何输出";
-        log(`[warp-pool] :${port} 隧道意外退出（退出码 ${code}${signal ? `，信号 ${signal}` : ""}）：${why}`);
+        log(fmtExit({ port, code, signal, pid, aliveMs, tail: tailReason(tail) }));
         if (!closed) void reviver.onExit(port); // 收摊中就别复活了，否则退出过程里又 spawn 出一批孤儿
       },
     });
     tunnels.set(node.port, t);
-    log(`[warp-pool] :${node.port} 隧道已起：HTTP 代理 http://127.0.0.1:${node.port} → 经 WARP 出网（pid ${t.pid ?? "?"}）`);
+    log(fmtSpawn({ port: node.port, pid: t.pid, binPath, conf }));
   }
 
   // 429 ＝ 上游按出口 IP 计的名额耗尽 ⇒ 换一台设备的身份换出口（换身份＝换桶）。
@@ -140,17 +143,20 @@ export function createWarpPool({
     await wait(PROBE_SETTLE_MS);
     for (const n of list) {
       if (!tunnels.has(n.port)) continue;
+      const url = `${String(baseUrl).replace(/\/+$/, "")}${cfg.probePath}`;
       let r = { ok: false };
       for (let i = 1; i <= PROBE_ATTEMPTS; i++) {
+        const t0 = now();
         r = await probe({ port: n.port, baseUrl, path: cfg.probePath });
+        const ms = Number.isFinite(r.ms) ? r.ms : now() - t0;
+        log(fmtProbe({ port: n.port, attempt: i, attempts: PROBE_ATTEMPTS, url, ok: r.ok, status: r.status, error: r.error, ms }));
         if (r.ok) break;
         if (i < PROBE_ATTEMPTS) await wait(PROBE_SETTLE_MS);
       }
       if (r.ok) {
         live.push(n);
-        log(`[warp-pool] :${n.port} 探通（HTTP ${r.status}），进池`);
       } else {
-        log(`[warp-pool] :${n.port} 探了 ${PROBE_ATTEMPTS} 次都不通（${r.status || r.error || "?"}），不进池：进池会把请求挂到超时，比直连更糟`);
+        log(fmtProbeGiveUp({ port: n.port, attempts: PROBE_ATTEMPTS, url }));
       }
     }
     return live;
@@ -171,7 +177,10 @@ export function createWarpPool({
 
     // 1. 复用磁盘上已注册的节点
     let nodes = loadNodes(cfg.dir, cfg.ports);
-    log(`[warp-pool] 复用磁盘上已注册的身份 ${nodes.length}/${cfg.count} 个（端口 ${cfg.ports.join(", ")}；缺的现场注册）`);
+    await startupReport({ cfg, nodes, binPath, ownerOf: (port) => portOwner({ dir: cfg.dir, port }), log });
+    // 同机其它 daemon：两个 daemon 会互相把对方的活隧道当「残留」杀掉（真机事故根因），必须一开池就报出来
+    const siblings = findDaemons({ self: process.pid });
+    if (siblings.length) log(fmtSiblings({ list: siblings }));
 
     // 2. 补足：逐个注册（拉长间隔，避免 CF 注册限流与同网段撞车）
     const used = new Set(nodes.map((n) => n.port));
@@ -204,13 +213,13 @@ export function createWarpPool({
     const live = await probeGate(nodes);
     if (live.length) {
       await dispatcher.setNodes(live.map((n) => ({ port: n.port, uri: `http://127.0.0.1:${n.port}` })));
-      log(`[warp-pool] 出口池就绪：${live.length} 条隧道可用（选路策略 ${cfg.strategy}${cfg.rotate ? "，撞 429 会自动换身份换出口" : ""}）`);
+      // 出口取证：一次拿到每个端口的真实出口，既喂给轮换器做「换没换动」的比对，也直接写进池结论那一行
+      const exits = await labelExits({ ports: live.map((n) => n.port), log });
+      rotator.noteExits(exits);
+      log(fmtPool({ pooled: live.length, total: nodes.length, exits }));
     } else {
-      log("[warp-pool] 没有一条隧道探通 ⇒ 池为空，全部请求照旧直连（不影响可用性，只是没多出口）");
+      log(fmtPoolEmpty({ total: nodes.length, ports: cfg.ports }));
     }
-
-    // 5. 出口取证：把每台设备的真实出口地址打进日志（免费版 WARP 的 IPv4 是共享 NAT，N 台设备很可能折叠成同一个出口）
-    if (live.length) rotator.noteExits(await labelExits({ ports: live.map((n) => n.port), log }));
   }
 
   const monitor = createHealthMonitor({
@@ -218,6 +227,8 @@ export function createWarpPool({
     baseUrl,
     probePath: cfg.probePath,
     log,
+    infoOf: () => ({ alive: tunnels.size, pooled: dispatcher.size, exits: rotator ? rotator.stats() : [] }),
+    cooldownMs: cfg.cooldownMs,
     onExhausted: async () => {
       // 重拨 = 重新注册换出口。只重拨「进程已死」的隧道：全活却全挂 = 网络路径问题，重注册只会把 CF 刷到 429
       const plan = redialPlan({ ports: cfg.ports, alivePorts: [...tunnels.keys()], lastRedialAt, redialGapMs, now });

package/src/warp-pool/ports.js

@@ -1,17 +1,18 @@
-// warp-pool · 端口占用与「上一代进程残留」清理（2026-10-16 组长 VPS 真机事故后新增）。
+// warp-pool · 端口占用与「上一代进程残留」清理（2026-10-16 真机事故后新增；2026-10-17 七次修订）。
 //
-// 事故：daemon 被强杀（WMI TerminateProcess / taskkill /F）时 `process.once("exit")` 钩子不执行，
-// wireproxy 子进程变成孤儿，继续占着 127.0.0.1:10800+ 这些端口。新 daemon 再起隧道就 bind 失败
-// （wireproxy 立刻退出 code=1），而旧代码把「spawn 成功」当成「复活成功」⇒ 无限重启、日志刷屏、
-// 且该端口的隧道永远起不来。治本是「起隧道前先把自家残留清掉」，并「端口被别人占着就别硬起」。
-import { readFileSync, readdirSync } from "node:fs";
+// 事故一（0.1.179）：daemon 被强杀时 `process.once("exit")` 钩子不执行，wireproxy 子进程变孤儿继续占着端口。
+// 事故二（七次修订，真机铁证）：**两个 daemon 同时活着**（一个从昨天起活了一整天），两者都用同一份
+//   `node-<port>.conf` 判「本池残留」⇒ 互相把对方的**活隧道**当残留杀掉 ⇒ 无限互杀、池永远不稳。
+// 两条教训写进判据：
+//   ① 父进程是**另一个活着的 daemon** ⇒ 那不是残留，是「别人的活隧道」，清了就是互杀 ⇒ 不许清，只报出来；
+//   ② 「SIGKILL 都清不掉」多半是**僵尸**（state=Z：kill 无效，但 kill(pid,0) 仍返回成功）⇒ 僵尸算已死。
 import { connect } from "node:net";
+import { defaultCmdline, defaultPids, defaultStat, isZombie, otherDaemonParent, parseCmdline, pidAlive } from "../runtime/proc-info.js";
 import { nodePaths } from "./nodes.js";
+import { fmtReclaim } from "./report.js";
 
-/** /proc/<pid>/cmdline 是 NUL 分隔的字节串；切成参数数组（丢掉结尾空串）。 */
-export function parseCmdline(buf) {
-  return String(buf == null ? "" : buf).split("\0").filter((s) => s !== "");
-}
+// /proc 读取层已上移到 runtime/proc-info.js（daemon 侧也要用同一套判据）；这里原样再导出，既有调用方路径不变。
+export { parseCmdline, pidAlive };
 
 /**
  * 该进程是不是「正在跑我们这条 conf」的 wireproxy。
@@ -24,37 +25,13 @@ export function isOurWireproxy(argv, conf) {
   return isBin && list.includes(conf);
 }
 
-function defaultPids() {
-  try {
-    return readdirSync("/proc").filter((f) => /^\d+$/.test(f)).map(Number);
-  } catch {
-    return [];
-  }
-}
-
-function defaultCmdline(pid) {
-  try {
-    return parseCmdline(readFileSync(`/proc/${pid}/cmdline`));
-  } catch {
-    return [];
-  }
-}
-
-/** 进程是否还在（信号 0 = 只做存在性检查，不真发信号）。 */
-export function pidAlive(pid, kill = process.kill) {
-  try {
-    kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 /**
- * 清掉「占着该端口那条 conf」的上一代 wireproxy。返回被清理的 pid 列表。
- * 非 Linux 直接返回 []（读不到 /proc，别拿别的平台做危险猜测）。
- * @param {{ dir: string, port: number, log?: Function, platform?: string,
- *           pids?: Function, cmdline?: Function, kill?: Function, sleep?: Function, waitRounds?: number }} opts
+ * 清掉占着该端口那条 conf 的**真残留**：自家丢引用的子进程、父进程已死的孤儿。
+ * 不动的三类：僵尸（kill 无效，也不是真占用者）、**父进程是另一个活 daemon 的活隧道**（清了就是互杀）、
+ * argv 不匹配的别人的进程。
+ * 非 Linux 直接返回空（读不到 /proc，别拿别的平台做危险猜测）。
+ * @returns {Promise<{scanned:number, killed:number[], zombies:number[],
+ *           foreign:Array<{pid:number,ppid:number,aliveSec:number|null}>, waitedMs:number, gone:boolean}>}
  */
 export async function reclaimPort({
   dir,
@@ -63,31 +40,58 @@ export async function reclaimPort({
   platform = process.platform,
   pids = defaultPids,
   cmdline = defaultCmdline,
+  stat = defaultStat,
   kill = process.kill,
   sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
   waitRounds = 15,
 } = {}) {
-  if (platform !== "linux") return [];
-  const conf = nodePaths(dir, port).conf;
-  const targets = pids().filter((pid) => isOurWireproxy(cmdline(pid), conf));
-  if (!targets.length) return [];
+  const startedAt = Date.now();
+  const shape = (scanned, killed, zombies, foreign) => ({
+    scanned,
+    killed,
+    zombies,
+    foreign,
+    waitedMs: Date.now() - startedAt,
+    gone: !killed.some((p) => pidAlive(p, kill)),
+  });
+  if (platform !== "linux") return shape(0, [], [], []);
 
-  log(
-    `[warp-pool] 端口 :${port} 发现上一代 wireproxy 残留（pid ${targets.join(", ")}）：` +
-      `daemon 被强杀时子进程不会自己退出，它会一直占着端口让新隧道 bind 失败。先清掉再起。`,
-  );
-  for (const pid of targets) {
-    try {
-      kill(pid, "SIGTERM");
-    } catch {}
+  const conf = nodePaths(dir, port).conf;
+  const all = pids();
+  const zombies = [];
+  const foreign = [];
+  const targets = [];
+  for (const pid of all) {
+    if (!isOurWireproxy(cmdline(pid), conf)) continue;
+    const st = stat(pid);
+    if (st && isZombie(st.state)) {
+      zombies.push(pid);
+      continue;
+    }
+    const other = otherDaemonParent(pid, { stat, cmdline, kill });
+    if (other) {
+      foreign.push({ pid, ppid: other.pid, aliveSec: other.aliveSec });
+      continue;
+    }
+    targets.push(pid);
   }
-  for (let i = 0; i < waitRounds && targets.some((p) => pidAlive(p, kill)); i++) await sleep(100);
-  for (const pid of targets.filter((p) => pidAlive(p, kill))) {
-    try {
-      kill(pid, "SIGKILL");
-    } catch {}
+
+  if (targets.length) {
+    for (const pid of targets) {
+      try {
+        kill(pid, "SIGTERM");
+      } catch {}
+    }
+    for (let i = 0; i < waitRounds && targets.some((p) => pidAlive(p, kill)); i++) await sleep(100);
+    for (const pid of targets.filter((p) => pidAlive(p, kill))) {
+      try {
+        kill(pid, "SIGKILL");
+      } catch {}
+    }
   }
-  return targets;
+  const r = shape(all.length, targets, zombies, foreign);
+  log(fmtReclaim({ port, ...r }));
+  return r;
 }
 
 /** 该端口是否已有人在监听（TCP 连得上 = 占用；连不上/被拒 = 空闲）。 */
@@ -120,3 +124,37 @@ export async function waitPortFree(port, { inUse = portInUse, sleep = (ms) => ne
   }
   return !(await inUse(port));
 }
+
+/**
+ * 端口占用者取证：谁在监听——本池残留？另一个 daemon 的活隧道？僵尸？别人的进程？还是空闲。
+ * 「孤儿占端口」「两个 daemon 互杀」这两类事故唯一能一眼看出结论的读数：只报「占用 / 拒绝再起」是查不出问题的。
+ * @returns {Promise<{busy:boolean, ours:number[], zombies:number[],
+ *           foreign:Array<{pid:number,ppid:number,aliveSec:number|null}>, others:Array<{pid:number,name:string}>}>}
+ */
+export async function portOwner({ dir, port, platform = process.platform, pids = defaultPids, cmdline = defaultCmdline, stat = defaultStat, kill = process.kill, inUse = portInUse } = {}) {
+  const busy = await inUse(port);
+  const out = { busy, ours: [], zombies: [], foreign: [], others: [] };
+  if (!busy || platform !== "linux") return out;
+  const conf = nodePaths(dir, port).conf;
+  for (const pid of pids()) {
+    const argv = cmdline(pid);
+    if (!argv.length) continue;
+    if (isOurWireproxy(argv, conf)) {
+      const st = stat(pid);
+      if (st && isZombie(st.state)) {
+        out.zombies.push(pid);
+        continue;
+      }
+      const other = otherDaemonParent(pid, { stat, cmdline, kill });
+      if (other) {
+        out.foreign.push({ pid, ppid: other.pid, aliveSec: other.aliveSec });
+        continue;
+      }
+      out.ours.push(pid);
+      continue;
+    }
+    // 非 root 看不到别人的 listen 表，退一步：命令行里带着这个端口号的进程也值得报出来
+    if (argv.some((a) => String(a).includes(`:${port}`))) out.others.push({ pid, name: String(argv[0]).split("/").pop() });
+  }
+  return out;
+}

package/src/warp-pool/report.js

@@ -0,0 +1,177 @@
+// warp-pool · 日志与自检报告（2026-10-16 四轮返工后新增；2026-10-17 七次修订补「同机其它 daemon」）。
+//
+// 为什么单独一个模块（五轮返工的教训）：日志若只说「失败了」、不说「谁干的、为什么」，就只能靠猜——
+// 第 1 轮猜孤儿占端口、第 2 轮分不清旧 daemon 子进程与刚被杀还没释放的套接字、第 3 轮分不清握手未完成与上游拒绝、
+// 第 4~5 轮对着「退出 / 已复活」循环完全看不出真凶是**同机另一个 daemon**（两边都把对方的活隧道当残留杀）。
+// 故把可判定信息一次摆全：配置快照、**同机其它 daemon**、端口占用者（pid+ppid+命令行+本池残留/别人的活隧道/僵尸）、
+// 身份文件、每条隧道完整生命周期（清理→写配置→spawn pid→探活耗时/状态/错误→退出码/信号/存活时长/末行）、池子结论与「下一步敲什么命令」。
+import { fmtAlive } from "../runtime/proc-info.js";
+export const MARK = { step: "▸", ok: "✓", fail: "✗", warn: "⚠" };
+
+const KB = (n) => (n >= 1024 * 1024 ? `${(n / 1024 / 1024).toFixed(1)}MB` : `${Math.round(n / 1024)}KB`);
+
+/** 人类可读时长：412ms / 1.8s / 2m3s。 */
+export function dur(ms) {
+  const n = Number(ms);
+  if (!Number.isFinite(n) || n < 0) return "?";
+  if (n < 1000) return `${Math.round(n)}ms`;
+  if (n < 60_000) return `${(n / 1000).toFixed(1)}s`;
+  return `${Math.floor(n / 60_000)}m${Math.round((n % 60_000) / 1000)}s`;
+}
+
+/** 配置快照：一行说清这次到底按什么参数在跑。 */
+export function fmtConfig(cfg) {
+  return `[warp-pool] ${MARK.step} 启动自检：开关=${cfg.enabled ? "开" : "关"} 模式=${cfg.mode} 端口=${cfg.ports.join(",")} 策略=${cfg.strategy} 轮换=${cfg.rotate ? "开" : "关"} 冷却=${Math.round(cfg.cooldownMs / 1000)}s`;
+}
+
+/** 目录与二进制（带体积，顺手能看出二进制是不是被下坏了）。 */
+export function fmtEnv({ dir, binPath, binSize }) {
+  const bin = binPath ? `${binPath}（${binSize ? KB(binSize) : "体积未知"}）` : "未就绪";
+  return `[warp-pool] ${MARK.step} 目录=${dir} 二进制=${bin}`;
+}
+
+/** 身份文件盘点：哪个端口有 id+token+私钥，哪个缺。 */
+export function fmtIdentities(nodes, ports) {
+  const have = new Set(nodes.map((n) => n.port));
+  const parts = ports.map((p) => `:${p}${have.has(p) ? " ✓" : " ✗缺"}`);
+  return `[warp-pool] ${MARK.step} 身份文件 ${nodes.length}/${ports.length}：${parts.join(" ")}（✓=有 id+token+私钥，✗缺=现场注册）`;
+}
+
+/** 「另一个 daemon(pid 1558055，已运行 6h12m) 的活隧道 pid 33」——两个 daemon 互杀这类事故唯一能一眼看出结论的读数。 */
+export function fmtForeign(foreign = []) {
+  return (foreign || []).map((f) => `另一个 daemon(pid ${f.ppid}${f.aliveSec != null ? `，已运行 ${fmtAlive(f.aliveSec)}` : ""}) 的活隧道 pid ${f.pid}`).join("；");
+}
+
+/** 单端口占用者：区分「本池残留」「另一个 daemon 的活隧道」「僵尸」「别人的进程」「空闲」——两轮返工缺的就是这一行。 */
+export function fmtPortState({ port, busy, ours = [], zombies = [], foreign = [], others = [] }) {
+  if (!busy) return `[warp-pool]     :${port} 空闲`;
+  if (foreign.length) return `[warp-pool]     :${port} 被 ${fmtForeign(foreign)} 占着：那是**别人的活隧道**，本进程不碰它（清了就是和另一个 daemon 互杀）`;
+  if (ours.length) return `[warp-pool]     :${port} 被 pid ${ours.join(",")} 占：本池 wireproxy 残留（上一代 daemon 留下的孤儿）→ 起隧道前清理`;
+  if (zombies.length) return `[warp-pool]     :${port} 有本池僵尸 pid ${zombies.join(",")}（已死等收尸：kill 无效，也不再占端口）`;
+  const who = others.length ? others.map((o) => `pid ${o.pid} ${o.name}`).join("、") : "未知进程";
+  return `[warp-pool]     :${port} 被 ${who} 占：非本池进程 → 不碰它，这个端口本轮跳过（查明：ss -ltnp | grep :${port}）`;
+}
+
+/** 清理残留的结果：扫了多少进程、命中谁、等了多久、清掉没、以及「另一个 daemon 占着」这种不该动的情形。 */
+export function fmtReclaim({ port, scanned, killed = [], zombies = [], foreign = [], waitedMs = 0, gone = true }) {
+  const parts = [`扫 ${scanned} 个进程`];
+  if (killed.length) parts.push(`命中本池残留 pid ${killed.join(",")} → ${gone ? "已清掉" : "清不掉（SIGTERM/SIGKILL 都试过）"}`);
+  else parts.push("无本池残留");
+  if (zombies.length) parts.push(`僵尸 pid ${zombies.join(",")}（已死等收尸，kill 无效）`);
+  if (foreign.length) parts.push(`${MARK.warn} ${fmtForeign(foreign)}——不碰它（清了就是和另一个 daemon 互杀）`);
+  const wait = killed.length ? `（等了 ${dur(waitedMs)}）` : "";
+  return `[warp-pool] :${port} ${MARK.step} 清理残留：${parts.join("；")}${wait}`;
+}
+
+/** 写出的 WireGuard 配置（体积能看出是不是缺字段：缺私钥那次就是 338B vs 373B）。 */
+export function fmtConf({ port, conf, bytes }) {
+  return `[warp-pool] :${port} ${MARK.step} 写配置 ${conf}（${bytes}B，0600）`;
+}
+
+/** 起隧道：pid + 完整命令行，事后可 `ps -p <pid>` 对账。 */
+export function fmtSpawn({ port, pid, binPath, conf }) {
+  return `[warp-pool] :${port} ${MARK.step} 起隧道 pid=${pid ?? "?"}：${binPath} -c ${conf}`;
+}
+
+/** 探活单次：URL、状态、耗时、错误原文——第 3 轮返工缺的就是「到底哪一步不通」。 */
+export function fmtProbe({ port, attempt, attempts, url, ok, status, error, ms }) {
+  const head = `[warp-pool] :${port} ${ok ? MARK.ok : MARK.fail} 探活 ${attempt}/${attempts}：GET ${url} 经 127.0.0.1:${port}`;
+  const tail = ok
+    ? `HTTP ${status}（${dur(ms)}）→ 进池`
+    : `HTTP ${status || 0}（${dur(ms)}）${error ? ` 错误=${String(error).slice(0, 160)}` : ""} → 稍后重试`;
+  return `${head} → ${tail}`;
+}
+
+/** 探活彻底失败：说清「不进池」的后果与自检命令，而不是只丢一句「没探通」。 */
+export function fmtProbeGiveUp({ port, attempts, url }) {
+  return `[warp-pool] :${port} ${MARK.fail} 探活 ${attempts} 次都不通 ⇒ 不进池（进程可能在跑但隧道转不动流量，进池会把请求挂到超时，比直连更糟）。自检：curl --proxy http://127.0.0.1:${port} ${url}`;
+}
+
+/** 隧道退出：退出码/信号/存活时长/pid/是否外部终止/stderr 末行（含「谁杀的」这一层推断）。 */
+export function fmtExit({ port, code, signal, pid, aliveMs, tail }) {
+  const how = signal ? `信号 ${signal}` : `退出码 ${code}`;
+  const killed = signal ? "本进程未调用 stop ⇒ 外部终止（别人杀了它 / 系统回收）" : "进程自行退出（多为配置被拒或端口被占）";
+  return `[warp-pool] :${port} ${MARK.fail} 隧道退出：${how}｜存活 ${aliveMs == null ? "?" : dur(aliveMs)}｜pid ${pid ?? "?"}｜${killed}｜末行="${tail || "没有输出"}"`;
+}
+
+/** 端口最终被占着、拒绝硬起时，把「另一个 daemon 的活隧道 / 本池残留 / 僵尸 / 别人的进程 / 套接字还没释放」分开说。 */
+export function fmtPortBlocked({ port, ours = [], zombies = [], foreign = [], others = [] }) {
+  const foreignTxt = foreign.length ? `${fmtForeign(foreign)}（清了就是互杀，故本进程不碰）——先停掉那个 daemon：kill ${[...new Set(foreign.map((f) => f.ppid))].join(" ")}` : "";
+  const oursTxt = ours.length ? `本池残留 pid ${ours.join(",")}（SIGTERM/SIGKILL 都没清掉）` : "";
+  const zombieTxt = zombies.length ? `本池僵尸 pid ${zombies.join(",")}（已死等收尸，不占端口）` : "";
+  const othTxt = others.length ? others.map((o) => `pid ${o.pid} ${o.name}`).join("、") : "";
+  const who = [foreignTxt, oursTxt, zombieTxt, othTxt].filter(Boolean).join("；") || "未知进程（已等套接字释放仍连得上）";
+  return `[warp-pool] :${port} ${MARK.fail} 端口被 ${who} 占着，拒绝再起（硬起只会 bind 失败、无限重启刷屏）。查明：ss -ltnp | grep :${port}`;
+}
+
+/** 池子结论：入池几个、各端口出口是什么、几种不同地址——一句话判断「WARP 到底有没有在用」。 */
+export function fmtPool({ pooled, total, exits }) {
+  const head = `[warp-pool] ${MARK.step} 出口池就绪：${pooled}/${total} 条入池`;
+  const ipOf = new Map();
+  for (const g of exits || []) for (const p of g.nodes || []) if (g.ip) ipOf.set(p, g.ip);
+  if (!ipOf.size) return `${head}｜出口地址未知（CF trace 取证失败，不影响使用）`;
+  const table = [...ipOf.entries()].map(([p, ip]) => `:${p}=${ip}`).join(" ");
+  return `${head}｜出口：${table}｜不同地址 ${new Set(ipOf.values()).size} 个`;
+}
+
+/** 池空告警：最容易被误读成「功能在跑」，必须把结论与逐条自检命令一起说。 */
+export function fmtPoolEmpty({ total, ports }) {
+  return `[warp-pool] ${MARK.warn} 没有一条隧道探通 ⇒ 池为空，全部请求照旧直连（不影响可用性，但 WARP 出口等于没启用）。逐条自检：for p in ${ports.join(" ")}; do echo -n ":$p "; curl -s --max-time 8 --proxy http://127.0.0.1:$p https://cloudflare.com/cdn-cgi/trace | grep '^ip='; done`;
+}
+
+/** 健康检查一轮：只在状态变化/心跳时打（每分钟一行会把日志淹掉）。 */
+export function fmtHealth({ healthy, total, slowestMs, problems = [] }) {
+  if (!problems.length) return `[warp-pool] ${MARK.ok} 健康检查：${healthy}/${total} 通（最慢 ${dur(slowestMs)}）`;
+  const detail = problems
+    .map((p) => `:${p.port} 第 ${p.fails} 次不通（HTTP ${p.status || 0}${p.error ? ` ${String(p.error).slice(0, 80)}` : ""}，${dur(p.ms)}）冷却 ${Math.round(p.cooldownMs / 1000)}s`)
+    .join("；");
+  return `[warp-pool] ${MARK.warn} 健康检查：${healthy}/${total} 通｜不通：${detail}`;
+}
+
+/** 心跳：一行给全部关键状态，省得「日志翻半天不知道现在啥情况」。 */
+export function fmtHeartbeat({ alive, total, pooled, exits, cooling, lastAllDown }) {
+  const ips = [...new Set((exits || []).map((e) => e.ip).filter(Boolean))];
+  return `[warp-pool] ${MARK.step} 心跳：隧道 ${alive}/${total} 活｜入池 ${pooled}｜出口 ${ips.length ? `${ips.length} 种（${ips.join(",")}）` : "未知"}｜冷却中 ${cooling}｜全池不通 ${lastAllDown || "未发生"}`;
+}
+
+/** 同机其它 daemon：两个 daemon 抢同一批端口会互杀（真机事故根因），必须一次说清并给出精确 kill 命令。 */
+export function fmtSiblings({ list = [] } = {}) {
+  if (!list.length) return "";
+  const who = list.map((d) => `pid ${d.pid}（父 ${d.ppid}${d.aliveSec != null ? `，已运行 ${fmtAlive(d.aliveSec)}` : ""}）`).join("；");
+  return `[warp-pool] ${MARK.warn} 同机还有 ${list.length} 个别的 mslxdff daemon 在跑：${who} —— 它也在管同一个出口池目录，两边会把对方的隧道当「残留」杀掉（本池每个 conf 只允许一个拥有者）。先停掉它：kill ${list.map((d) => d.pid).join(" ")}`;
+}
+
+/**
+ * 启动自检块：一次性把「这次按什么参数跑、二进制在哪多大、磁盘上有几个身份、端口分别被谁占着」打全。
+ * 第 1 轮返工只看到「退出 code=1 / 已复活」循环，就是缺这一块——真因（孤儿占端口）当时只能靠猜。
+ * @param {{ cfg: object, nodes: Array<object>, binPath?: string, binSize?: number,
+ *           ownerOf: (port:number)=>Promise<{busy:boolean, ours:number[], zombies:number[], foreign:Array<object>, others:Array<{pid:number,name:string}>}>,
+ *           log?: Function }} opts
+ */
+export async function startupReport({ cfg, nodes, binPath = "", binSize = 0, ownerOf, log = () => {} }) {
+  log(fmtConfig(cfg));
+  log(fmtEnv({ dir: cfg.dir, binPath, binSize }));
+  log(fmtIdentities(nodes, cfg.ports));
+  const states = [];
+  for (const port of cfg.ports) {
+    try {
+      states.push({ port, ...(await ownerOf(port)) });
+    } catch (e) {
+      states.push({ port, busy: false, ours: [], zombies: [], foreign: [], others: [], error: String(e?.message || e) });
+    }
+  }
+  const busy = states.filter((s) => s.busy);
+  log(`[warp-pool] ${MARK.step} 端口体检：${busy.length} 个被占 / ${states.length} 个端口`);
+  for (const s of states) log(fmtPortState(s));
+  // 另一个 daemon 占着端口 = 两个 daemon 互杀（真机事故根因）：必须单独大声报，并给出精确 kill 命令
+  const foreign = busy.flatMap((s) => s.foreign || []);
+  if (foreign.length) {
+    const pids = [...new Set(foreign.map((f) => f.ppid))];
+    log(`[warp-pool] ${MARK.warn} ${foreign.length} 个端口被 ${fmtForeign(foreign)} 占着 —— 那不是残留，本进程不碰它（清了就是互杀）。若那是上一代的 daemon：kill ${pids.join(" ")}`);
+  }
+  const orphans = busy.filter((s) => (s.ours || []).length).length;
+  if (orphans) log(`[warp-pool] ${MARK.warn} 有 ${orphans} 个端口被本池残留占着（上一代 daemon 被强杀留下的孤儿）——起隧道前逐个清理，日志会写清 pid`);
+  const zombies = busy.filter((s) => (s.zombies || []).length).length;
+  if (zombies) log(`[warp-pool] ${MARK.step} 有 ${zombies} 个端口上还有本池僵尸进程（已死等收尸：kill 无效，也不再占端口，无需处理）`);
+  return states;
+}

package/src/warp-pool/wireproxy.js

@@ -93,16 +93,19 @@ function runCommand(cmd, args, { log = () => {} } = {}) {
 export function writeTunnelConf(dir, node) {
   if (!node?.privateKey) throw new Error(`节点 :${node?.port} 缺 WireGuard 私钥，拒绝写出一份跑不起来的配置`);
   const { conf } = nodePaths(dir, node.port);
-  return writeSecret(conf, renderWireproxyConf({ ...node, port: node.port }));
+  const text = renderWireproxyConf({ ...node, port: node.port });
+  writeSecret(conf, text);
+  return { conf, bytes: Buffer.byteLength(text) };
 }
 
 /**
  * 启动一条隧道。返回 { port, conf, stop() }。
  * 进程退出即视为隧道失效（不自动重启：由 health 层决策重拨换 IP）。
  */
-export function startTunnel({ binPath: exe, dir, port, log = () => {}, onExit = () => {} } = {}) {
+export function startTunnel({ binPath: exe, dir, port, log = () => {}, onExit = () => {}, now = Date.now } = {}) {
   const { conf } = nodePaths(dir, port);
   const child = spawn(exe, ["-c", conf], { stdio: ["ignore", "pipe", "pipe"] });
+  const startedAt = now();
   let tail = "";
   const keepTail = (d) => {
     tail = (tail + String(d)).slice(-800);
@@ -112,7 +115,7 @@ export function startTunnel({ binPath: exe, dir, port, log = () => {}, onExit =
 
   let stopped = false;
   child.on("exit", (code, signal) => {
-    if (!stopped) onExit({ port, code, signal, tail });
+    if (!stopped) onExit({ port, code, signal, tail, pid: child.pid, aliveMs: now() - startedAt });
   });
 
   return {
@@ -139,18 +142,20 @@ export function startTunnel({ binPath: exe, dir, port, log = () => {}, onExit =
 export async function probeTunnel({ port, baseUrl = "https://opencode.ai", path = "/zen/v1/models", fetchImpl = compatFetch, timeoutMs = 8000, headers = {}, wantText = false } = {}) {
   const { ProxyAgent } = getUndici();
   const agent = new ProxyAgent({ uri: `http://127.0.0.1:${port}`, connections: 2, keepAliveTimeout: 10_000 });
+  const url = `${String(baseUrl).replace(/\/+$/, "")}${path}`;
+  const t0 = Date.now();
   try {
-    const res = await fetchImpl(`${String(baseUrl).replace(/\/+$/, "")}${path}`, {
+    const res = await fetchImpl(url, {
       headers,
       signal: AbortSignal.timeout(timeoutMs),
       dispatcher: agent,
     });
-    const base = { ok: res.ok, status: res.status };
+    const base = { ok: res.ok, status: res.status, ms: Date.now() - t0, url };
     if (!wantText) return base;
     const text = await res.text().catch(() => "");
     return { ...base, text: String(text).slice(0, 2000) };
   } catch (e) {
-    return { ok: false, status: 0, error: String(e?.message || e) };
+    return { ok: false, status: 0, error: String(e?.message || e), ms: Date.now() - t0, url };
   } finally {
     try { await agent.close(); } catch {}
   }