mslxdff 0.1.160 → 0.1.161

package/src/runtime/bootstrap.js

@@ -1,45 +1,45 @@
-import { appendCall, appendError, appendEvent, appendTimeline } from "../logs.js";
-import { setupProviders } from "./providers-setup.js";
-import { startServerLifecycle } from "./server-lifecycle.js";
-import { appendModelTrace } from "../model-trace.js";
-import { startGroupSync } from "./group-sync.js";
-import { startBroadband } from "./broadband.js";
-
-const logs = { appendCall, appendError, appendEvent, appendTimeline, appendModelTrace };
-
-/**
- * daemon 启动门面 — 仅编排：组装世界 → 服务生命周期 → 群组同步 → 宽带中继 → 自更新。
- * 重活下沉 providers-setup / server-lifecycle / group-sync / broadband(-stream)。
- */
-export async function startDaemonMain(VERSION) {
-  const { installLifecycleLog } = await import("./lifecycle-log.js");
-  installLifecycleLog({ version: VERSION, logs });
-  const ctx = await setupProviders();
-  const { srv, bus } = await startServerLifecycle({ VERSION, ...ctx, logs });
-  void srv;
-  startGroupSync({ peers: ctx.peers, groups: ctx.groups });
-  startBroadband({ token: ctx.token, upstream: ctx.upstream });
-
-  const { setupAutoUpdate } = await import("./auto-update.js");
-  setupAutoUpdate({ VERSION, bus, logs });
-
-  const { setupWorkbuddyCheckin } = await import("./workbuddy-checkin.js");
-  void setupWorkbuddyCheckin({ bus, logs }).catch((e) => {
-    try { logs.appendEvent({ ts: Date.now(), type: "workbuddy-checkin-setup-failed", error: String(e?.message || e).slice(0, 200) }); } catch {}
-  });
-
-  const { setupTraeworkCheckin } = await import("./traework-checkin.js");
-  void setupTraeworkCheckin({ bus, logs }).catch((e) => {
-    try { logs.appendEvent({ ts: Date.now(), type: "traework-checkin-setup-failed", error: String(e?.message || e).slice(0, 200) }); } catch {}
-  });
-
-  const { setupQoderCheckin } = await import("./qoder-checkin.js");
-  void setupQoderCheckin({ bus, logs }).catch((e) => {
-    try { logs.appendEvent({ ts: Date.now(), type: "qoder-checkin-setup-failed", error: String(e?.message || e).slice(0, 200) }); } catch {}
-  });
-
-  const { setupWorkbuddyGrowth } = await import("./workbuddy-growth.js");
-  void setupWorkbuddyGrowth({ bus, logs }).catch((e) => {
-    try { logs.appendEvent({ ts: Date.now(), type: "workbuddy-growth-setup-failed", error: String(e?.message || e).slice(0, 200) }); } catch {}
-  });
-}
+import { appendCall, appendError, appendEvent, appendTimeline } from "../logs.js";
+import { setupProviders } from "./providers-setup.js";
+import { startServerLifecycle } from "./server-lifecycle.js";
+import { appendModelTrace } from "../model-trace.js";
+import { startGroupSync } from "./group-sync.js";
+import { startBroadband } from "./broadband.js";
+
+const logs = { appendCall, appendError, appendEvent, appendTimeline, appendModelTrace };
+
+/**
+ * daemon 启动门面 — 仅编排：组装世界 → 服务生命周期 → 群组同步 → 宽带中继 → 自更新。
+ * 重活下沉 providers-setup / server-lifecycle / group-sync / broadband(-stream)。
+ */
+export async function startDaemonMain(VERSION) {
+  const { installLifecycleLog } = await import("./lifecycle-log.js");
+  installLifecycleLog({ version: VERSION, logs });
+  const ctx = await setupProviders();
+  const { srv, bus } = await startServerLifecycle({ VERSION, ...ctx, logs });
+  void srv;
+  startGroupSync({ peers: ctx.peers, groups: ctx.groups });
+  startBroadband({ token: ctx.token, upstream: ctx.upstream });
+
+  const { setupAutoUpdate } = await import("./auto-update.js");
+  setupAutoUpdate({ VERSION, bus, logs });
+
+  const { setupWorkbuddyCheckin } = await import("./workbuddy-checkin.js");
+  void setupWorkbuddyCheckin({ bus, logs }).catch((e) => {
+    try { logs.appendEvent({ ts: Date.now(), type: "workbuddy-checkin-setup-failed", error: String(e?.message || e).slice(0, 200) }); } catch {}
+  });
+
+  const { setupTraeworkCheckin } = await import("./traework-checkin.js");
+  void setupTraeworkCheckin({ bus, logs }).catch((e) => {
+    try { logs.appendEvent({ ts: Date.now(), type: "traework-checkin-setup-failed", error: String(e?.message || e).slice(0, 200) }); } catch {}
+  });
+
+  const { setupQoderCheckin } = await import("./qoder-checkin.js");
+  void setupQoderCheckin({ bus, logs }).catch((e) => {
+    try { logs.appendEvent({ ts: Date.now(), type: "qoder-checkin-setup-failed", error: String(e?.message || e).slice(0, 200) }); } catch {}
+  });
+
+  const { setupWorkbuddyGrowth } = await import("./workbuddy-growth.js");
+  void setupWorkbuddyGrowth({ bus, logs }).catch((e) => {
+    try { logs.appendEvent({ ts: Date.now(), type: "workbuddy-growth-setup-failed", error: String(e?.message || e).slice(0, 200) }); } catch {}
+  });
+}

package/src/runtime/lifecycle-forensics.js

@@ -0,0 +1,116 @@
+// daemon 上一次死亡的验尸官 —— 死亡证明从来不能由死者开：Windows 的关机/TerminateProcess
+// 不给被杀进程跑任何 JS 的机会，硬死在遗言层面是零痕迹的（见 crosscut 叶"四种死法"）。
+// 所以抓捕靠三方各出一块拼图：
+//   ① 杀者留牌：stopDaemon / autostart 清场等"我方所杀"在动手前写 daemon.exit-marker
+//      （带死者 pid/版本/意图）——反正 Windows 下被杀者说不出话，牌只能杀者挂；
+//   ② 活体信标：daemon 心跳同步写 daemon.alive，钉死"最后一次确证活着"的时刻（死亡窗口下界）；
+//   ③ 开机验尸：新进程在 installLifecycleLog（早于 writePid 覆盖 pid 文件）读
+//      pid/alive/marker + os.uptime() 回推本机开机时刻，纯函数分桶，结论落 errors.log。
+// 分类恒给 diedBetween（死亡窗口）与 detail（中文归因），unknown/reboot/kill 各归各桶，
+// 宁可报"不可解释的强杀"也不假装干净。全部 IO 吞异常——验尸失败绝不挡启动。
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import os from "node:os";
+
+const SLACK_MS = 15_000; // 时钟/顺序抖动容差：牌的 at 不早于最后心跳−slack 才算"死于本牌"
+
+export function aliveFile(dir) { return join(dir, "daemon.alive"); }
+export function markerFile(dir) { return join(dir, "daemon.exit-marker"); }
+export function pidPath(dir) { return join(dir, "daemon.pid"); }
+
+function readJsonSafe(file) {
+  try { return JSON.parse(readFileSync(file, "utf8")); } catch { return null; }
+}
+function writeJsonSafe(file, obj) {
+  try {
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(obj), { mode: 0o600 });
+    return true;
+  } catch { return false; }
+}
+
+/** 活体信标：{pid, version, at, uptimeMs, rssMb}。daemon 模式专属写（debug 前台不碰，防污染死亡窗口）。 */
+export function writeAlive(dir, info) { return writeJsonSafe(aliveFile(dir), { at: Date.now(), ...info }); }
+export function readAlive(dir) { return readJsonSafe(aliveFile(dir)); }
+
+/** 杀者牌：动手前写，必须自带死者身份（stopDaemon 随后会 unlink pid 文件）。 */
+export function writeExitMarker(dir, { reason, prevPid, prevVersion = null, byPid = process.pid, code = null, at } = {}) {
+  return writeJsonSafe(markerFile(dir), { reason, prevPid, prevVersion, byPid, code, at: at ?? Date.now() });
+}
+/** 读后即删：一张牌只许生效一代，防止下代异常死亡被旧牌误导归因。 */
+export function consumeExitMarker(dir) {
+  const m = readJsonSafe(markerFile(dir));
+  try { if (m) unlinkSync(markerFile(dir)); } catch {}
+  return m;
+}
+
+export function readPidFrom(dir) {
+  try {
+    const n = Number(String(readFileSync(pidPath(dir), "utf8")).trim().split("\n")[0]);
+    return Number.isInteger(n) && n > 0 ? n : null;
+  } catch { return null; }
+}
+export function readPidVersionFrom(dir) {
+  try {
+    const l = String(readFileSync(pidPath(dir), "utf8")).split("\n");
+    return l.length > 1 && l[1].trim() ? l[1].trim() : null;
+  } catch { return null; }
+}
+
+/** 开机时刻 = now − 整机 uptime。重启后它是硬事实，任何进程都伪造不了。 */
+export function bootTimeMs(now = Date.now()) {
+  try { return now - Math.round(os.uptime() * 1000); } catch { return null; }
+}
+
+/**
+ * 纯函数分桶（可测，不碰 fs）：
+ *  none             无前任痕迹（首装 / uninstall 清干净后）
+ *  clean-exit       死者自己跑完了 exit 钩子（Linux 信号优雅退出 / process.exit）
+ *  killed-by-cli    新鲜杀者牌：via=stop|restart|upgrade|debug-takeover|uninstall|autostart-cleanup…
+ *  reboot           无牌，但开机时刻晚于最后信标 → 整机重启带走
+ *  holder-alive     旧 pid 仍活（抢端口/接管现场）
+ *  unknown          有旧 pid 无信标（早于验尸功能的旧版本残留），死亡窗口给不出
+ *  unexplained-kill 机器没重启、无牌、信标戛然而止 → taskkill/任务管理器/硬杀
+ */
+export function classifyPrevExit({ prevPid = null, prevVersion = null, alive = null, marker = null, bootAtMs = null, now = Date.now(), selfPid = 0, prevStillRunning = false } = {}) {
+  const lastAlive = Number.isFinite(alive?.at) ? alive.at : null;
+  if (!prevPid && !alive && !marker) return { verdict: "none", detail: "无前任 daemon 痕迹" };
+  const freshMarker = marker && Number.isFinite(marker.at) && (lastAlive == null || marker.at >= lastAlive - SLACK_MS);
+  if (freshMarker && marker.reason === "process-exit") {
+    return { verdict: "clean-exit", prevPid: marker.prevPid ?? prevPid, prevVersion: marker.prevVersion ?? prevVersion, at: marker.at, diedBetween: [lastAlive, marker.at], detail: `前任进程自写遗书正常退出 (pid=${marker.prevPid ?? prevPid} exit code=${marker.code ?? "?"})` };
+  }
+  if (freshMarker) {
+    return { verdict: "killed-by-cli", via: marker.reason, prevPid: marker.prevPid ?? prevPid, prevVersion: marker.prevVersion ?? prevVersion, byPid: marker.byPid ?? null, at: marker.at, diedBetween: [lastAlive, marker.at], detail: `被 CLI/清理方 (pid=${marker.byPid ?? "?"}) 以 ${marker.reason} 名义主动杀死` };
+  }
+  if (lastAlive != null && bootAtMs != null && bootAtMs > lastAlive + SLACK_MS) {
+    return { verdict: "reboot", prevPid, prevVersion, lastAliveAt: lastAlive, bootAt: bootAtMs, diedBetween: [lastAlive, bootAtMs], detail: "死者零遗言，且本机开机时刻晚于最后心跳 → 整机重启带走（Windows 关机不跑 exit 钩子，属预期盲区，靠本桶收口）" };
+  }
+  if (prevPid && prevStillRunning && prevPid !== selfPid) {
+    return { verdict: "holder-alive", prevPid, prevVersion, detail: `旧 pid=${prevPid} 仍在世（抢端口/接管现场，本进程=${selfPid}）` };
+  }
+  if (lastAlive == null) {
+    return { verdict: "unknown", prevPid, prevVersion, detail: "有旧 pid 无活体信标（前任早于验尸功能上线），只能确认已死" };
+  }
+  return { verdict: "unexplained-kill", prevPid, prevVersion, lastAliveAt: lastAlive, diedBetween: [lastAlive, now], detail: "机器未重启、无杀者牌、信标戛然而止：taskkill/任务管理器/硬杀或断电级崩溃（exit 钩子未跑）" };
+}
+
+function defaultIsPidAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch (err) { return err.code !== "ESRCH"; }
+}
+
+/** 开机验尸入口：读齐三方证据 → 收牌（读后即删）→ 分桶。collect 与 report 一起回，供调用方落日志。 */
+export function collectAutopsy({ dir, selfPid = process.pid, now = Date.now(), isPidAliveFn } = {}) {
+  const prevPid = readPidFrom(dir);
+  const alive = readAlive(dir);
+  const input = {
+    prevPid,
+    prevVersion: readPidVersionFrom(dir),
+    alive,
+    marker: consumeExitMarker(dir),
+    bootAtMs: bootTimeMs(now),
+    now,
+    selfPid,
+    prevStillRunning: !!prevPid && prevPid !== selfPid ? (isPidAliveFn ?? defaultIsPidAlive)(prevPid) : false,
+  };
+  return { input, report: classifyPrevExit(input) };
+}

package/src/runtime/lifecycle-log.js

@@ -3,8 +3,11 @@
 //   被信号杀（有 `SIGTERM received` 行）、崩溃（有 uncaughtException 行）、
 //   被 SIGKILL/任务管理器杀（只有未送达的 exit 行 → 看最后一条 heartbeat 定位死亡时刻）、
 //   OOM 积累（heartbeat 的 rss 曲线）。
+// 验尸三件套（详见 src/runtime/lifecycle-forensics.js）：daemon.alive 活体信标 + daemon.exit-marker 杀者牌 + 开机分桶 → errors.log(type=daemon-exit)。
 // 顶层异常只记录不退出（代理服务无持久状态，活着比干净退出更有价值；异常多为请求级漏网）。
 import { appendEvent } from "../logs.js";
+import { daemonDir } from "../daemon.js";
+import { collectAutopsy, writeAlive, writeExitMarker } from "./lifecycle-forensics.js";
 
 const HEARTBEAT_MS = Math.max(60_000, Number(process.env.MSLXDFF_HEARTBEAT_MS) || 30 * 60 * 1000);
 
@@ -39,25 +42,45 @@ export function installLifecycleLog({ version, bus, logs } = {}) {
   }));
   emit("lifecycle-start", { pid: process.pid, ppid: process.ppid, version, node: process.version });
 
+  // 开机验尸：上一次死亡归因（七桶），结论落 errors.log 供事后排查——必须赶在 server-lifecycle writePid 覆盖旧 pid 文件之前
+  const dir = daemonDir();
+  const isDaemon = process.env.MSLXDFF_DAEMON === "1";
+  try {
+    const { report } = collectAutopsy({ dir, selfPid: process.pid });
+    if (report.verdict !== "none") {
+      const w = report.diedBetween && report.diedBetween[0] ? ` window=${new Date(report.diedBetween[0]).toISOString()}..${report.diedBetween[1] ? new Date(report.diedBetween[1]).toISOString() : "?"}` : "";
+      log(`[lifecycle] autopsy prev-run verdict=${report.verdict}${w} ${report.detail}`);
+      try { logs?.appendError?.({ type: "daemon-exit", model: "daemon", status: 0, verdict: report.verdict, via: report.via ?? null, prevPid: report.prevPid ?? null, prevVersion: report.prevVersion ?? null, byPid: report.byPid ?? null, lastAliveAt: report.lastAliveAt ?? null, diedBetween: report.diedBetween ?? null, bootAt: report.bootAt ?? null, detail: report.detail }); } catch {}
+      emit("lifecycle-autopsy", { verdict: report.verdict, via: report.via ?? null, prevPid: report.prevPid ?? null });
+    }
+  } catch {}
+  // 活体信标：启动即写一条，死亡窗口下界不必等 30min 心跳
+  if (isDaemon) { try { writeAlive(dir, { pid: process.pid, version, uptimeMs: 0, rssMb: rssMb() }); } catch {} }
+
   process.on("uncaughtException", (e) => {
     const detail = String(e?.stack || e?.message || e).slice(0, 2000);
     log(`[lifecycle] uncaughtException (kept running): ${detail}`);
     emit("lifecycle-uncaught", { detail: detail.slice(0, 500) });
+    try { logs?.appendError?.({ type: "daemon-uncaught", model: "daemon", status: 0, message: `uncaughtException (kept running): ${detail.slice(0, 400)}` }); } catch {}
   });
   process.on("unhandledRejection", (r) => {
     const detail = String(r?.stack || r?.message || r).slice(0, 2000);
     log(`[lifecycle] unhandledRejection (kept running): ${detail}`);
     emit("lifecycle-unhandled-rejection", { detail: detail.slice(0, 500) });
+    try { logs?.appendError?.({ type: "daemon-unhandled", model: "daemon", status: 0, message: `unhandledRejection (kept running): ${detail.slice(0, 400)}` }); } catch {}
   });
   process.on("exit", (code) => {
     const uptimeSec = Math.round((Date.now() - t0) / 1000);
     log(`[lifecycle] exit code=${code} uptime=${uptimeSec}s rss=${rssMb()}mb`);
+    // 遗书：exit 钩子跑得动 = 非硬杀（Linux 信号善终 / process.exit）；Windows 强杀场景永远看不到这行，缺它本身就是证据
+    try { writeExitMarker(dir, { reason: "process-exit", prevPid: process.pid, prevVersion: version, byPid: process.pid, code }); } catch {}
   });
   process.on("SIGHUP", () => log(`[lifecycle] SIGHUP received (ignored, pid ${process.pid})`));
 
   const hb = setInterval(() => {
     // 心跳只落 daemon.log（不写 events.log：48 条/天，避免污染结构化事件流）
     log(lifecycleHeartbeatLine({ pid: process.pid, uptimeMin: Math.round((Date.now() - t0) / 60000), rssMb: rssMb() }));
+    if (isDaemon) { try { writeAlive(dir, { pid: process.pid, version, uptimeMs: Date.now() - t0, rssMb: rssMb() }); } catch {} }
   }, HEARTBEAT_MS);
   hb.unref?.();
   return { heartbeatMs: HEARTBEAT_MS };

package/src/runtime/provider-gate.js

@@ -1,33 +1,34 @@
-// 定制 provider 启用门禁（纯函数 + auth 号型名单），从 providers-setup.js 拆出以守住 ≤10KB 体积门。
-// 背景：门禁曾要求 `baseUrl && keys` 两者皆有，导致 qoder（keys 有、baseUrl 空）被静默跳过 ——
-// 表现为 /v1/models 无该供应商模型、`-models` 挑不到、网关报 `Model qoder/x is not supported`。
-// Note: auth 号型不要求 baseUrl 是硬约束（旧门禁 baseUrl&&keys 曾静默跳过整家 qoder）— 见 .agents/notes/implemented/bug-fix/2026-09-21-auth-doc-provider-gate.md
-
-/** 凭证在 auth 目录、无需 baseUrl 的「auth 号型」定制供应商（端点由各自 constants 决定）。 */
-export const AUTH_DOC_PROVIDER_IDS = ["workbuddy", "traework", "qoder", "qwenwork"];
-
-/**
- * - auth 号型：keys 或 auths 或 auth 目录有号 → 启用（baseUrl 可空）
- * - 其他定制（cline/codearts/插件注册）：有 keys → 启用（baseUrl 可空，端点由工厂决定）
- */
-export function shouldEnableCustomProvider(gid, { keys = [], auths = [], hasAuthDocs = false } = {}) {
-  if (AUTH_DOC_PROVIDER_IDS.includes(gid)) return keys.length > 0 || auths.length > 0 || hasAuthDocs;
-  return keys.length > 0;
-}
-
-/** 按 gid 载入各自 account-store 并列出落盘账号（失败/无目录 → 空数组，不抛）。 */
-export async function loadAuthDocs(gid) {
-  try {
-    const store = gid === "workbuddy"
-      ? await import("../providers/workbuddy/account-store.js")
-      : gid === "traework"
-        ? await import("../providers/traework/account-store.js")
-        : gid === "qwenwork"
-          ? await import("../providers/qwenwork/account-store.js")
-          : await import("../providers/qoder/account-store.js");
-    return store.listAccountDocs();
-    return store.listAccountDocs();
-  } catch {
-    return [];
-  }
-}
+// 定制 provider 启用门禁（纯函数 + auth 号型名单），从 providers-setup.js 拆出以守住 ≤10KB 体积门。
+// 背景：门禁曾要求 `baseUrl && keys` 两者皆有，导致 qoder（keys 有、baseUrl 空）被静默跳过 ——
+// 表现为 /v1/models 无该供应商模型、`-models` 挑不到、网关报 `Model qoder/x is not supported`。
+// Note: auth 号型不要求 baseUrl 是硬约束（旧门禁 baseUrl&&keys 曾静默跳过整家 qoder）— 见 .agents/notes/implemented/bug-fix/2026-09-21-auth-doc-provider-gate.md
+
+/** 凭证在 auth 目录、无需 baseUrl 的「auth 号型」定制供应商（端点由各自 constants 决定）。 */
+export const AUTH_DOC_PROVIDER_IDS = ["workbuddy", "traework", "qoder", "qwenwork", "globalqwenwork"];
+
+/**
+ * - auth 号型：keys 或 auths 或 auth 目录有号 → 启用（baseUrl 可空）
+ * - 其他定制（cline/codearts/插件注册）：有 keys → 启用（baseUrl 可空，端点由工厂决定）
+ */
+export function shouldEnableCustomProvider(gid, { keys = [], auths = [], hasAuthDocs = false } = {}) {
+  if (AUTH_DOC_PROVIDER_IDS.includes(gid)) return keys.length > 0 || auths.length > 0 || hasAuthDocs;
+  return keys.length > 0;
+}
+
+/** 按 gid 载入各自 account-store 并列出落盘账号（失败/无目录 → 空数组，不抛）。 */
+export async function loadAuthDocs(gid) {
+  try {
+    const store = gid === "workbuddy"
+      ? await import("../providers/workbuddy/account-store.js")
+      : gid === "traework"
+        ? await import("../providers/traework/account-store.js")
+        : gid === "qwenwork"
+          ? await import("../providers/qwenwork/account-store.js")
+          : gid === "globalqwenwork"
+            ? await import("../providers/globalqwenwork/account-store.js")
+            : await import("../providers/qoder/account-store.js");
+    return store.listAccountDocs();
+  } catch {
+    return [];
+  }
+}