dsh-lark-bot 0.7.0 → 0.8.0

package/dist/cli.js

@@ -64,7 +64,7 @@ var init_dsh_compat = __esm({
       sdkServer: "0.1.0-rc.6",
       acp: "0.1.0-rc.6",
       node: ">=22.19.0",
-      verifiedAt: "2026-08-14"
+      verifiedAt: "2026-08-15"
     };
   }
 });
@@ -1498,7 +1498,13 @@ var DEFAULTS = {
   scopeConcurrency: 2,
   retentionMsgs: 40,
   archiveMax: 50,
-  archiveMaxAgeDays: 90
+  archiveMaxAgeDays: 90,
+  heartbeatMs: 5e3,
+  guardianPollMs: 2e3,
+  guardianStaleMs: 15e3,
+  guardianEngineDeadMs: 12e4,
+  guardianProfile: "dsh-lark",
+  guardianBridgeProfile: "default"
 };
 function nonEmpty(value) {
   const trimmed = value?.trim();
@@ -1584,6 +1590,15 @@ function parseMinOneInt(value, fallback, name) {
   }
   return parsed;
 }
+function parsePositiveIntMin(value, fallback, name) {
+  const raw = value?.trim();
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new Error(`${name} must be a positive integer, got "${raw}"`);
+  }
+  return parsed;
+}
 function loadRuntimeEnv(source = process.env) {
   const homeOverride = nonEmpty(source.DSH_LARK_HOME);
   const workspace = nonEmpty(source.DSH_LARK_WORKSPACE);
@@ -1634,7 +1649,30 @@ function loadRuntimeEnv(source = process.env) {
       "DSH_LARK_ARCHIVE_MAX_AGE_DAYS"
     ),
     accessDefaultDeny: parseBoolean(source.DSH_LARK_ACCESS_DEFAULT_DENY, false),
-    eventFreshnessMs: parseFreshness(source.DSH_LARK_EVENT_FRESHNESS_MS)
+    eventFreshnessMs: parseFreshness(source.DSH_LARK_EVENT_FRESHNESS_MS),
+    heartbeatMs: parsePositiveIntMin(
+      source.DSH_LARK_HEARTBEAT_MS,
+      DEFAULTS.heartbeatMs,
+      "DSH_LARK_HEARTBEAT_MS"
+    ),
+    guardianDisabled: parseBoolean(source.DSH_LARK_GUARDIAN_DISABLED, false),
+    guardianProfile: nonEmpty(source.DSH_LARK_GUARDIAN_PROFILE) ?? DEFAULTS.guardianProfile,
+    guardianBridgeProfile: nonEmpty(source.DSH_LARK_GUARDIAN_BRIDGE_PROFILE) ?? DEFAULTS.guardianBridgeProfile,
+    guardianPollMs: parsePositiveIntMin(
+      source.DSH_LARK_GUARDIAN_POLL_MS,
+      DEFAULTS.guardianPollMs,
+      "DSH_LARK_GUARDIAN_POLL_MS"
+    ),
+    guardianStaleMs: parsePositiveIntMin(
+      source.DSH_LARK_GUARDIAN_STALE_MS,
+      DEFAULTS.guardianStaleMs,
+      "DSH_LARK_GUARDIAN_STALE_MS"
+    ),
+    guardianEngineDeadMs: parsePositiveIntMin(
+      source.DSH_LARK_GUARDIAN_ENGINE_DEAD_MS,
+      DEFAULTS.guardianEngineDeadMs,
+      "DSH_LARK_GUARDIAN_ENGINE_DEAD_MS"
+    )
   };
 }
 
@@ -1660,9 +1698,9 @@ async function writeFileAtomic(target, data, options = {}) {
   }
 }
 async function rmSilently(path) {
-  const { rm: rm2 } = await import("fs/promises");
+  const { rm: rm3 } = await import("fs/promises");
   try {
-    await rm2(path, { force: true });
+    await rm3(path, { force: true });
   } catch {
   }
 }
@@ -5391,6 +5429,59 @@ var WorkspaceStore = class {
   }
 };
 
+// src/guardian/heartbeat.ts
+import { readFile as readFile9 } from "fs/promises";
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 5e3;
+async function readHeartbeat(file) {
+  try {
+    const raw = await readFile9(file, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.pid !== "number" || typeof parsed.startedAt !== "string" || typeof parsed.ts !== "number") {
+      return void 0;
+    }
+    return {
+      pid: parsed.pid,
+      startedAt: parsed.startedAt,
+      ts: parsed.ts
+    };
+  } catch {
+    return void 0;
+  }
+}
+function heartbeatAgeMs(payload, now = Date.now()) {
+  return Math.max(0, now - payload.ts);
+}
+function isHeartbeatFresh(payload, maxAgeMs, now = Date.now()) {
+  if (payload === void 0) return false;
+  return heartbeatAgeMs(payload, now) < maxAgeMs;
+}
+function startHeartbeat(file, pid, intervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let stopped = false;
+  const beat = async () => {
+    if (stopped) return;
+    const payload = { pid, startedAt, ts: Date.now() };
+    try {
+      await writeFileAtomic(file, `${JSON.stringify(payload)}
+`, {
+        mode: 384
+      });
+    } catch {
+    }
+  };
+  void beat();
+  const timer = setInterval(() => {
+    void beat();
+  }, intervalMs);
+  timer.unref?.();
+  return {
+    stop() {
+      stopped = true;
+      clearInterval(timer);
+    }
+  };
+}
+
 // src/cli/commands/run.ts
 var DEBOUNCE_MS = 600;
 async function ensureBotProfile(store, options) {
@@ -5605,6 +5696,11 @@ async function startBridgeEngine(options) {
   larkChannel = bridge.channel;
   await notifyServer.start();
   process.env.DSH_LARK_NOTIFY_URL = notifyServer.url ?? "";
+  const heartbeat = startHeartbeat(
+    paths.profilePath(profileName, "guardian", "heartbeat.json"),
+    process.pid,
+    env.heartbeatMs
+  );
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   log.info("cli", "started", {
     profile: profileName,
@@ -5629,6 +5725,7 @@ async function startBridgeEngine(options) {
     stop: async () => {
       if (stopped) return;
       stopped = true;
+      heartbeat.stop();
       await notifyServer.stop();
       await bridge.disconnect();
       await adapter.dispose?.();
@@ -5672,29 +5769,396 @@ function waitForShutdown() {
 // src/cli/commands/setup.ts
 init_dsh_runtime();
 init_own_package();
-import { spawn as spawn5 } from "child_process";
-import { mkdir as mkdir10, readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
+import { spawn as spawn6 } from "child_process";
+import { mkdir as mkdir12, readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { join as join13 } from "path";
+
+// src/guardian/install.ts
+init_own_package();
+import { mkdir as mkdir11, readFile as readFile11, rm as rm2, writeFile as writeFile6 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join12 } from "path";
+
+// src/guardian/process.ts
+import { spawn as spawn5 } from "child_process";
+function hasProfileFlag(cmdline, dshProfile) {
+  const pattern = new RegExp(
+    `(?:^|\\s)--profile(?:\\s+|=)${escapeRegExp(dshProfile)}(?:\\s|$)`
+  );
+  return pattern.test(cmdline);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function looksLikeDshProcess(cmdline) {
+  return cmdline.includes("@deepseek-ai/dsh") || /(?:^|\s)dsh(?:\.exe)?(?:\s|$)/.test(cmdline);
+}
+function matchProfileProcess(cmdline, dshProfile) {
+  return hasProfileFlag(cmdline, dshProfile) && looksLikeDshProcess(cmdline);
+}
+async function listProcesses() {
+  if (process.platform === "win32") {
+    return listProcessesWindows();
+  }
+  return listProcessesPosix();
+}
+async function listProcessesPosix() {
+  const { stdout } = await captureOutput("ps", ["-axo", "pid=,args="], 1e4);
+  const result = [];
+  for (const line of stdout.split("\n")) {
+    const match = /^\s*(\d+)\s+(.+)$/.exec(line);
+    if (match) {
+      result.push({ pid: Number(match[1]), cmdline: match[2] ?? "" });
+    }
+  }
+  return result;
+}
+async function listProcessesWindows() {
+  const { stdout } = await captureOutput(
+    "powershell.exe",
+    [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      "Get-CimInstance Win32_Process | Select-Object ProcessId, CommandLine | ConvertTo-Csv -NoTypeInformation"
+    ],
+    1e4
+  );
+  const result = [];
+  for (const line of stdout.split("\n").slice(1)) {
+    const [pid, ...rest] = line.trim().split(",");
+    const numeric = Number(pid?.replace(/"/g, ""));
+    if (Number.isInteger(numeric) && rest.length > 0) {
+      result.push({ pid: numeric, cmdline: rest.join(",").replace(/^"|"$/g, "") });
+    }
+  }
+  return result;
+}
+async function captureOutput(command, args, timeoutMs = 3e4) {
+  return new Promise((resolve5) => {
+    const child = spawn5(command, [...args], {
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", () => {
+      resolve5({ code: 1, stdout: "", stderr });
+    });
+    child.on("close", (code) => {
+      resolve5({ code: code ?? 1, stdout, stderr });
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      resolve5({ code: 1, stdout, stderr });
+    }, timeoutMs);
+    child.once("close", () => clearTimeout(timer));
+  });
+}
+async function findProfileProcess(dshProfile) {
+  const processes = await listProcesses();
+  return processes.find((entry) => matchProfileProcess(entry.cmdline, dshProfile));
+}
+function spawnDetached(command, args, env = process.env) {
+  const child = spawn5(command, [...args], {
+    detached: process.platform !== "win32",
+    stdio: "ignore",
+    windowsHide: true,
+    env: { ...env }
+  });
+  if (child.pid !== void 0 && process.platform !== "win32") {
+    child.unref();
+  }
+  return { pid: child.pid };
+}
+
+// src/guardian/state.ts
+import { readFile as readFile10 } from "fs/promises";
+import { dirname as dirname6 } from "path";
+import { mkdir as mkdir10 } from "fs/promises";
+var DEFAULT_DSH_PROFILE = "dsh-lark";
+var DEFAULT_BRIDGE_PROFILE = "default";
+function defaultSafeProfile(dshProfile) {
+  return `${dshProfile}-safe`;
+}
+function newGuardianState(input) {
+  const dshProfile = input.dshProfile ?? DEFAULT_DSH_PROFILE;
+  return {
+    schemaVersion: 1,
+    dshProfile,
+    bridgeProfile: input.bridgeProfile ?? DEFAULT_BRIDGE_PROFILE,
+    safeProfile: defaultSafeProfile(dshProfile),
+    profileSeenUp: false,
+    mode: "standby",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function loadGuardianState(file, fallback) {
+  try {
+    const raw = await readFile10(file, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.schemaVersion !== 1) return fallback;
+    const dshProfile = typeof parsed.dshProfile === "string" ? parsed.dshProfile : fallback.dshProfile;
+    const bridgeProfile = typeof parsed.bridgeProfile === "string" ? parsed.bridgeProfile : fallback.bridgeProfile;
+    return {
+      schemaVersion: 1,
+      dshProfile,
+      bridgeProfile,
+      safeProfile: typeof parsed.safeProfile === "string" ? parsed.safeProfile : defaultSafeProfile(dshProfile),
+      profileSeenUp: parsed.profileSeenUp === true || fallback.profileSeenUp === true,
+      mode: parsed.mode === "takeover" || parsed.mode === "safe" ? parsed.mode : "standby",
+      relaunchedPid: typeof parsed.relaunchedPid === "number" ? parsed.relaunchedPid : void 0,
+      updatedAt: parsed.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch {
+    return fallback;
+  }
+}
+async function saveGuardianState(file, state) {
+  const next = { ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await mkdir10(dirname6(file), { recursive: true });
+  await writeFileAtomic(file, `${JSON.stringify(next, null, 2)}
+`, { mode: 384 });
+}
+
+// src/guardian/install.ts
+var GUARDIAN_LABEL = "dsh-lark-guardian";
+function guardianCliEntry() {
+  return join12(ownPackageInfo().root, "dist", "cli.js");
+}
+function serviceDirectory(platform, root) {
+  switch (platform) {
+    case "linux":
+      return join12(root, ".config", "systemd", "user");
+    case "darwin":
+      return join12(root, "Library", "LaunchAgents");
+    case "win32":
+      return join12(
+        process.env.APPDATA ?? join12(root, "AppData", "Roaming"),
+        "Microsoft",
+        "Windows",
+        "Start Menu",
+        "Programs",
+        "Startup"
+      );
+    default:
+      return join12(root, ".dsh-lark", "guardian");
+  }
+}
+function systemdUnit(nodeBin, cliEntry, env = {}) {
+  const envLines = Object.entries(env).map(([key, value]) => `Environment=${key}=${value}`).join("\n");
+  return [
+    "[Unit]",
+    "Description=dsh-lark-bot safety-net guardian (Feishu rescue when dsh is down)",
+    "After=network-online.target",
+    "Wants=network-online.target",
+    "",
+    "[Service]",
+    "Type=simple",
+    `ExecStart=${nodeBin} ${cliEntry} guardian run`,
+    "Restart=on-failure",
+    "RestartSec=5",
+    ...envLines ? [envLines] : [],
+    "",
+    "[Install]",
+    "WantedBy=default.target",
+    ""
+  ].join("\n");
+}
+function launchdPlist(nodeBin, cliEntry, label = `io.dsh-lark.${GUARDIAN_LABEL}`, logPath = "/tmp/dsh-lark-guardian.log") {
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    "<dict>",
+    `  <key>Label</key><string>${label}</string>`,
+    "  <key>ProgramArguments</key>",
+    "  <array>",
+    `    <string>${nodeBin}</string>`,
+    `    <string>${cliEntry}</string>`,
+    "    <string>guardian</string>",
+    "    <string>run</string>",
+    "  </array>",
+    "  <key>RunAtLoad</key><true/>",
+    "  <key>KeepAlive</key><true/>",
+    `  <key>StandardOutPath</key><string>${logPath}</string>`,
+    `  <key>StandardErrorPath</key><string>${logPath}</string>`,
+    "</dict>",
+    "</plist>",
+    ""
+  ].join("\n");
+}
+function windowsStartupCmd(nodeBin, cliEntry) {
+  return [
+    "@echo off",
+    "REM dsh-lark-bot safety-net guardian - keep the Feishu rescue entrance alive.",
+    `start "" /b "${nodeBin}" "${cliEntry}" guardian run`,
+    ""
+  ].join("\r\n");
+}
+function defaultRun(command, args) {
+  return captureOutput(command, args, 3e4);
+}
+async function installGuardian(options) {
+  const messages = [];
+  const root = options.rootOverride ?? homedir6();
+  const dshProfile = options.dshProfile ?? options.env.guardianProfile;
+  const bridgeProfile = options.bridgeProfile ?? options.env.guardianBridgeProfile;
+  const stateFile = join12(root, ".dsh-lark", "guardian.json");
+  const fallback = newGuardianState({ dshProfile, bridgeProfile });
+  const existing = await loadGuardianState(stateFile, fallback);
+  const state = {
+    ...existing,
+    dshProfile: existing.dshProfile === dshProfile ? existing.dshProfile : dshProfile,
+    bridgeProfile: existing.bridgeProfile === bridgeProfile ? existing.bridgeProfile : bridgeProfile,
+    safeProfile: existing.safeProfile || `${dshProfile}-safe`
+  };
+  await saveGuardianState(stateFile, state);
+  messages.push(`\u5B88\u62A4\u72B6\u6001\u5DF2\u5199\u5165 ${stateFile}\uFF08dsh profile=${state.dshProfile}\uFF09`);
+  if (options.dryRun) {
+    return { ok: true, messages };
+  }
+  const nodeBin = process.execPath;
+  const cliEntry = guardianCliEntry();
+  const directory = serviceDirectory(process.platform, root);
+  await mkdir11(directory, { recursive: true });
+  if (process.platform === "linux") {
+    const unitPath = join12(directory, `${GUARDIAN_LABEL}.service`);
+    await writeFile6(
+      unitPath,
+      systemdUnit(nodeBin, cliEntry, { DSH_LARK_GUARDIAN_DISABLED: "0" }),
+      "utf8"
+    );
+    messages.push(`systemd user unit \u5DF2\u5199\u5165 ${unitPath}`);
+    const run = options.run ?? defaultRun;
+    const reload = await run("systemctl", ["--user", "daemon-reload"]);
+    const enable = await run("systemctl", ["--user", "enable", "--now", `${GUARDIAN_LABEL}.service`]);
+    if (reload.code === 0 && enable.code === 0) {
+      messages.push("\u5B88\u62A4\u670D\u52A1\u5DF2\u542F\u7528\u5E76\u542F\u52A8\uFF08systemctl --user\uFF09\u3002");
+    } else {
+      messages.push(
+        "\u672A\u80FD\u81EA\u52A8\u542F\u7528\u670D\u52A1\uFF08\u53EF\u80FD\u9700\u8981\u56FE\u5F62\u4F1A\u8BDD / systemd user \u5B9E\u4F8B\uFF09\u3002\u8BF7\u624B\u52A8\u6267\u884C\uFF1A"
+      );
+      messages.push(`  systemctl --user daemon-reload && systemctl --user enable --now ${GUARDIAN_LABEL}.service`);
+      return { ok: false, messages };
+    }
+  } else if (process.platform === "darwin") {
+    const label = `io.dsh-lark.${GUARDIAN_LABEL}`;
+    const plistPath = join12(directory, `${label}.plist`);
+    await writeFile6(plistPath, launchdPlist(nodeBin, cliEntry), "utf8");
+    messages.push(`launchd LaunchAgent \u5DF2\u5199\u5165 ${plistPath}`);
+    const run = options.run ?? defaultRun;
+    const uid = typeof options.userOverride === "string" ? options.userOverride : String(process.getuid?.() ?? 501);
+    const bootstrap = await run("launchctl", ["bootstrap", `gui/${uid}`, plistPath]);
+    if (bootstrap.code === 0) {
+      messages.push("\u5B88\u62A4\u670D\u52A1\u5DF2\u52A0\u8F7D\uFF08launchctl bootstrap\uFF09\u3002");
+    } else {
+      messages.push(
+        "\u672A\u80FD\u81EA\u52A8\u52A0\u8F7D LaunchAgent\u3002\u8BF7\u624B\u52A8\u6267\u884C\uFF08\u6216\u6539\u7528\u65E7\u7248 launchctl load -w\uFF09\uFF1A"
+      );
+      messages.push(`  launchctl bootstrap gui/${uid} ${plistPath}`);
+      return { ok: false, messages };
+    }
+  } else if (process.platform === "win32") {
+    const cmdPath = join12(directory, `${GUARDIAN_LABEL}.cmd`);
+    await writeFile6(cmdPath, windowsStartupCmd(nodeBin, cliEntry), "utf8");
+    messages.push(`Windows \u542F\u52A8\u9879\u5DF2\u5199\u5165 ${cmdPath}\uFF08\u767B\u5F55\u540E\u81EA\u52A8\u5E38\u9A7B\uFF09\u3002`);
+  } else {
+    const fallbackPath = join12(directory, `${GUARDIAN_LABEL}.sh`);
+    await writeFile6(
+      fallbackPath,
+      `#!/bin/sh
+exec "${nodeBin}" "${cliEntry}" guardian run
+`,
+      "utf8"
+    );
+    messages.push(
+      `\u5F53\u524D\u5E73\u53F0\u4E0D\u652F\u6301\u81EA\u52A8\u6CE8\u518C\u670D\u52A1\uFF1B\u5DF2\u5199\u5165\u542F\u52A8\u811A\u672C ${fallbackPath}\uFF0C\u8BF7\u6309\u9700\u914D\u7F6E\u5E38\u9A7B\u3002`
+    );
+  }
+  return { ok: true, messages };
+}
+async function uninstallGuardian(options) {
+  const messages = [];
+  const root = options.rootOverride ?? homedir6();
+  const run = options.run ?? defaultRun;
+  if (process.platform === "linux") {
+    await run("systemctl", ["--user", "disable", "--now", `${GUARDIAN_LABEL}.service`]);
+    const unitPath = join12(root, ".config", "systemd", "user", `${GUARDIAN_LABEL}.service`);
+    await rm2(unitPath, { force: true });
+    await run("systemctl", ["--user", "daemon-reload"]);
+    messages.push("systemd user unit \u5DF2\u79FB\u9664\u5E76\u505C\u6B62\u3002");
+  } else if (process.platform === "darwin") {
+    const label = `io.dsh-lark.${GUARDIAN_LABEL}`;
+    const plistPath = join12(root, "Library", "LaunchAgents", `${label}.plist`);
+    const uid = typeof options.userOverride === "string" ? options.userOverride : String(process.getuid?.() ?? 501);
+    await run("launchctl", ["bootout", `gui/${uid}`, plistPath]);
+    await rm2(plistPath, { force: true });
+    messages.push("launchd LaunchAgent \u5DF2\u79FB\u9664\u3002");
+  } else if (process.platform === "win32") {
+    const startupDir = join12(
+      process.env.APPDATA ?? join12(root, "AppData", "Roaming"),
+      "Microsoft",
+      "Windows",
+      "Start Menu",
+      "Programs",
+      "Startup"
+    );
+    await rm2(join12(startupDir, `${GUARDIAN_LABEL}.cmd`), { force: true });
+    messages.push("Windows \u542F\u52A8\u9879\u5DF2\u79FB\u9664\u3002");
+  } else {
+    const fallbackPath = join12(root, ".dsh-lark", "guardian", `${GUARDIAN_LABEL}.sh`);
+    await rm2(fallbackPath, { force: true });
+    messages.push("\u542F\u52A8\u811A\u672C\u5DF2\u79FB\u9664\u3002");
+  }
+  messages.push("\u5B88\u62A4\u72B6\u6001\u6587\u4EF6\uFF08~/.dsh-lark/guardian.json\uFF09\u5DF2\u4FDD\u7559\uFF0C\u53EF\u968F\u65F6\u91CD\u65B0\u5B89\u88C5\u3002");
+  return { ok: true, messages };
+}
+
+// src/cli/commands/setup.ts
 async function runSetup(options = {}) {
   const profile = options.profile ?? "dsh-lark";
   const own = ownPackageInfo();
   const packageSpec = options.packageSpec ?? process.env.DSH_LARK_SETUP_PACKAGE ?? own.name;
-  const dshHome = options.dshHome ?? resolveDshHome(homedir6(), process.env);
-  const bin = options.bin ?? discoverDshBin(homedir6(), process.env);
+  const dshHome = options.dshHome ?? resolveDshHome(homedir7(), process.env);
+  const bin = options.bin ?? discoverDshBin(homedir7(), process.env);
   if (!bin) {
     throw new Error(
       "\u672A\u627E\u5230\u672C\u673A dsh \u5B89\u88C5\uFF08`@deepseek-ai/dsh`\uFF09\u3002\u8BF7\u5148\u5B89\u88C5 DeepSeek Harness\uFF0C\u518D\u8FD0\u884C\u672C\u547D\u4EE4\u3002"
     );
   }
-  const profileDir = join12(dshHome, "profiles", profile);
-  await mkdir10(profileDir, { recursive: true });
+  const profileDir = join13(dshHome, "profiles", profile);
+  await mkdir12(profileDir, { recursive: true });
   await approveBuilds(profileDir);
   process.stdout.write(
     `\u6B63\u5728\u628A ${packageSpec} \u5B89\u88C5\u5230 dsh profile \`${profile}\`\uFF08$DSH_HOME=${dshHome}\uFF09...
 `
   );
   await runDshPlugin(bin, profile, packageSpec);
+  if (options.guardian) {
+    const install = options.installGuardianFn ?? installGuardian;
+    const guardianResult = await install({
+      env: loadRuntimeEnv(process.env),
+      dshProfile: profile
+    });
+    for (const message of guardianResult.messages) {
+      process.stdout.write(`${message}
+`);
+    }
+    if (!guardianResult.ok) {
+      process.stdout.write(
+        "\n\u6CE8\u610F\uFF1Aguardian \u670D\u52A1\u672A\u5B8C\u5168\u542F\u7528\uFF0C\u8BF7\u6309\u4E0A\u65B9\u63D0\u793A\u624B\u52A8\u6267\u884C\uFF1B\u4E5F\u53EF\u7A0D\u540E\u91CD\u8DD1 `dsh-lark-bot guardian install`\u3002\n"
+      );
+    }
+  }
   process.stdout.write(
     [
       "",
@@ -5704,13 +6168,21 @@ async function runSetup(options = {}) {
       "",
       "\u9996\u6B21\u542F\u52A8\u4F1A\u5728\u7EC8\u7AEF\u6253\u5370\u4E8C\u7EF4\u7801\uFF0C\u7528\u98DE\u4E66 / Lark \u626B\u7801\u5B8C\u6210\u4E00\u6B21\u6027\u7ED1\u5B9A\uFF1B",
       "\u7ED1\u5B9A\u540E dsh \u5373\u4EE5\u6807\u51C6\u63D2\u4EF6\u65B9\u5F0F\u52A0\u8F7D dsh-lark-bot \u7684\u6865\u63A5\u5F15\u64CE\u3002",
+      ...options.guardian ? [
+        "",
+        "\u5B89\u5168\u7F51\u5B88\u62A4\u5DF2\u5B89\u88C5\uFF1Adsh \u4E0B\u7EBF\u540E\u4ECD\u53EF\u901A\u8FC7\u98DE\u4E66\u53D1\u9001 /safemode \u8FDB\u5165\u4EC5\u6838\u5FC3\u5B89\u5168\u6A21\u5F0F\u81EA\u6551\u3002",
+        "\u67E5\u770B\u72B6\u6001\uFF1Adsh-lark-bot guardian status"
+      ] : [
+        "",
+        "\u63D0\u793A\uFF1A\u53EF\u52A0 --guardian \u540C\u65F6\u5B89\u88C5\u300C\u5B89\u5168\u7F51\u5B88\u62A4\u300D\uFF08dsh \u5168\u90E8\u4E0B\u7EBF\u540E\u7684\u98DE\u4E66\u6551\u63F4\u901A\u9053\uFF09\u3002"
+      ],
       ""
     ].join("\n")
   );
 }
 function runDshPlugin(bin, profile, packageSpec) {
   return new Promise((resolve5, reject) => {
-    const child = spawn5(
+    const child = spawn6(
       "node",
       [bin, "plugin", "--profile", profile, "add", packageSpec],
       { stdio: "inherit" }
@@ -5723,10 +6195,10 @@ function runDshPlugin(bin, profile, packageSpec) {
   });
 }
 async function approveBuilds(profileDir) {
-  const workspaceFile = join12(profileDir, "pnpm-workspace.yaml");
+  const workspaceFile = join13(profileDir, "pnpm-workspace.yaml");
   let existing = "";
   try {
-    existing = await readFile9(workspaceFile, "utf8");
+    existing = await readFile12(workspaceFile, "utf8");
   } catch {
   }
   const allowBuilds = [
@@ -5745,7 +6217,876 @@ allowBuilds:
     existing = existing.replace(/(allowBuilds:\s*\n)/, `$1  ${allowBuilds}
 `);
   }
-  await writeFile6(workspaceFile, existing, "utf8");
+  await writeFile7(workspaceFile, existing, "utf8");
+}
+
+// src/cli/commands/guardian.ts
+import { join as join16 } from "path";
+
+// src/guardian/service.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import { homedir as homedir8 } from "os";
+import { join as join15 } from "path";
+import { createLarkChannel as createLarkChannel2 } from "@larksuite/channel";
+init_dsh_runtime();
+
+// src/guardian/control.ts
+var COMMAND_RE = /^\/(safemode)(?:\s+(.+))?$/i;
+function parseGuardianCommand(text) {
+  const trimmed = text.trim();
+  const match = COMMAND_RE.exec(trimmed);
+  if (!match) return void 0;
+  const argument = match[2]?.trim().toLowerCase() ?? "";
+  switch (argument) {
+    case "":
+    case "start":
+    case "enter":
+      return { kind: "safemode", argument };
+    case "status":
+      return { kind: "safemode-status", argument };
+    case "plugins":
+    case "list":
+      return { kind: "safemode-plugins", argument };
+    case "exit":
+    case "quit":
+    case "leave":
+    case "restore":
+      return { kind: "safemode-exit", argument };
+    case "help":
+    case "?":
+      return { kind: "safemode-help", argument };
+    default:
+      return { kind: "safemode-help", argument };
+  }
+}
+var SAFEMODE_HELP = [
+  "/safemode \u2014 \u8FDB\u5165\u4EC5\u6838\u5FC3\u5B89\u5168\u6A21\u5F0F\uFF08dsh \u4E3B\u6838\u5FC3 + \u5B98\u65B9 headless\uFF0C\u4E0D\u52A0\u8F7D\u4EFB\u4F55\u7B2C\u4E09\u65B9\u63D2\u4EF6\uFF09",
+  "/safemode status \u2014 \u67E5\u770B\u5B88\u62A4\u72B6\u6001",
+  "/safemode plugins \u2014 \u5217\u51FA\u6545\u969C profile \u5DF2\u5B89\u88C5\u7684\u63D2\u4EF6",
+  "/safemode exit \u2014 \u9000\u51FA\u5B89\u5168\u6A21\u5F0F\uFF0C\u91CD\u542F\u5B8C\u6574 profile \u5E76\u4EA4\u8FD8\u98DE\u4E66\u901A\u9053",
+  "",
+  "\u5B89\u5168\u6A21\u5F0F\u4E0B\u53D1\u9001\u666E\u901A\u6D88\u606F\u5373\u53EF\u4E0E dsh \u6838\u5FC3\u5BF9\u8BDD\uFF0C\u8FDB\u884C\u5B9A\u4F4D / \u4FEE\u590D / \u7981\u7528\u635F\u574F\u63D2\u4EF6\u7684\u81EA\u6108\u64CD\u4F5C\u3002"
+].join("\n");
+var SAFEMODE_HELP_EN = [
+  "/safemode \u2014 enter core-only safe mode (dsh core + official headless, no third-party plugins)",
+  "/safemode status \u2014 show guardian state",
+  "/safemode plugins \u2014 list plugins installed into the broken profile",
+  "/safemode exit \u2014 leave safe mode, relaunch the full profile and hand the channel back",
+  "",
+  "In safe mode, send normal messages to converse with the dsh core for self-healing."
+].join("\n");
+function safemodeHelpText() {
+  return `${SAFEMODE_HELP}
+
+${SAFEMODE_HELP_EN}`;
+}
+
+// src/guardian/safe-profile.ts
+init_dsh_runtime();
+import { mkdir as mkdir13, writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { join as join14 } from "path";
+var SAFE_CORE_BUNDLES = [
+  "@deepseek-ai/dsh-base",
+  "@deepseek-ai/dsh-headless"
+];
+function safeProfileName(dshProfile) {
+  return `${dshProfile}-safe`;
+}
+function safeProfileRoot(home, dshProfile, env) {
+  return join14(resolveDshHome(home, env), "profiles", safeProfileName(dshProfile));
+}
+async function ensureSafeProfile(options) {
+  const root = safeProfileRoot(options.home, options.dshProfile, options.env);
+  const name = safeProfileName(options.dshProfile);
+  await mkdir13(root, { recursive: true });
+  let created = false;
+  const manifest = join14(root, "package.json");
+  if (!existsSync6(manifest)) {
+    await writeFile8(
+      manifest,
+      `${JSON.stringify(
+        {
+          name: `dsh-profile-${name}`,
+          private: true,
+          dependencies: {},
+          dsh: {
+            profile: {
+              bundles: [...SAFE_CORE_BUNDLES]
+            }
+          }
+        },
+        null,
+        2
+      )}
+`,
+      "utf8"
+    );
+    created = true;
+  }
+  const rootConfig = join14(root, "cordis.yml");
+  if (!existsSync6(rootConfig)) {
+    await writeFile8(
+      rootConfig,
+      "# dsh profile root - an empty entry list; the tree is composed as patches.\n[]\n",
+      "utf8"
+    );
+    created = true;
+  }
+  const userPatch = join14(root, "cordis.patch.yml");
+  if (!existsSync6(userPatch)) {
+    await writeFile8(userPatch, "[]\n", "utf8");
+    created = true;
+  }
+  const workspace = join14(root, "pnpm-workspace.yaml");
+  if (!existsSync6(workspace)) {
+    await writeFile8(
+      workspace,
+      [
+        "packages:",
+        "  - .",
+        "",
+        "",
+        "nodeLinker: hoisted",
+        "autoInstallPeers: false",
+        ""
+      ].join("\n"),
+      "utf8"
+    );
+    created = true;
+  }
+  return { root, created };
+}
+async function defaultRun2(command, args) {
+  const { spawn: spawn7 } = await import("child_process");
+  return new Promise((resolve5) => {
+    const child = spawn7(command, [...args], { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (error) => {
+      resolve5({ code: 1, stdout, stderr: `${error.message}
+` });
+    });
+    child.on("close", (code) => {
+      resolve5({ code: code ?? 1, stdout, stderr });
+    });
+  });
+}
+async function probeSafeProfile(options) {
+  const run = options.run ?? defaultRun2;
+  const profile = safeProfileName(options.dshProfile);
+  const result = await run(options.bin, ["--profile", profile, "--dump-config"]);
+  if (result.code === 0) {
+    return { ok: true, stdout: result.stdout, stderr: result.stderr };
+  }
+  const tail = result.stderr.trim().split("\n").slice(-5).join("\n");
+  return {
+    ok: false,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    error: tail || `dsh --profile ${profile} --dump-config exited with code ${result.code}`
+  };
+}
+
+// src/guardian/service.ts
+var MAX_TRANSCRIPT_ENTRIES = 30;
+var SAFE_RUN_TIMEOUT_MS = 10 * 6e4;
+var GuardianService = class {
+  options;
+  state;
+  channel;
+  safeAdapter;
+  transcripts = /* @__PURE__ */ new Map();
+  downStreak = 0;
+  lastHeartbeatFreshAt;
+  timer;
+  ticking = false;
+  stopped = false;
+  dshBin;
+  config;
+  eventFreshnessMs;
+  activeMessages = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.options = {
+      pollMs: options.pollMs ?? 2e3,
+      staleMs: options.staleMs ?? 15e3,
+      engineDeadMs: options.engineDeadMs ?? 12e4,
+      takeoverGracePolls: options.takeoverGracePolls ?? 2,
+      sendDelayMs: options.sendDelayMs ?? 600,
+      stateFile: options.stateFile,
+      configFile: options.configFile,
+      heartbeatFile: options.heartbeatFile,
+      home: options.home,
+      dshProfile: options.dshProfile,
+      bridgeProfile: options.bridgeProfile,
+      safeProfile: options.safeProfile,
+      ...defined({
+        env: options.env,
+        createChannel: options.createChannel,
+        adapter: options.adapter,
+        findProcess: options.findProcess,
+        spawnDetachedFn: options.spawnDetachedFn,
+        probeSafeProfileFn: options.probeSafeProfileFn,
+        runPluginList: options.runPluginList,
+        dshBin: options.dshBin,
+        saveState: options.saveState,
+        logger: options.logger,
+        now: options.now
+      })
+    };
+    this.state = newGuardianState({
+      dshProfile: options.dshProfile,
+      bridgeProfile: options.bridgeProfile
+    });
+    this.eventFreshnessMs = parseFreshness2(this.options.env?.DSH_LARK_EVENT_FRESHNESS_MS);
+  }
+  get mode() {
+    return this.state.mode;
+  }
+  async start() {
+    const loaded = await loadGuardianState(this.options.stateFile, this.state);
+    if (loaded.dshProfile !== this.options.dshProfile) {
+      this.state = loaded;
+    } else {
+      this.state = loaded;
+    }
+    await this.loadContext();
+    await this.save();
+    await this.tick();
+    this.timer = setInterval(() => {
+      void this.tick();
+    }, this.options.pollMs);
+    this.timer.unref?.();
+    this.log().info("guardian", "started", {
+      dshProfile: this.state.dshProfile,
+      bridgeProfile: this.state.bridgeProfile,
+      mode: this.state.mode,
+      pollMs: this.options.pollMs
+    });
+  }
+  async stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+    await Promise.allSettled([...this.activeMessages]);
+    await this.disconnectChannel();
+    await this.safeAdapter?.dispose?.();
+    this.log().info("guardian", "stopped", {});
+  }
+  snapshot() {
+    return {
+      mode: this.state.mode,
+      dshProfile: this.state.dshProfile,
+      bridgeProfile: this.state.bridgeProfile,
+      safeProfile: this.state.safeProfile,
+      profileSeenUp: this.state.profileSeenUp,
+      dshUp: this.dshUp,
+      heartbeatAgeMs: this.lastHeartbeatAgeMs,
+      channelConnected: this.channel !== void 0,
+      pid: process.pid,
+      dshBin: this.dshBin,
+      relaunchedPid: this.state.relaunchedPid,
+      updatedAt: this.state.updatedAt
+    };
+  }
+  dshUp = false;
+  lastHeartbeatAgeMs;
+  log() {
+    return this.options.logger ?? log;
+  }
+  async loadContext() {
+    const store = new ConfigStore(this.options.configFile);
+    await store.load();
+    this.config = store.getProfile(this.state.bridgeProfile);
+    this.dshBin = this.options.dshBin ?? discoverDshBin(this.options.home, this.options.env ?? process.env);
+  }
+  async save() {
+    if (this.options.saveState) {
+      await this.options.saveState(this.state);
+      return;
+    }
+    await saveGuardianState(this.options.stateFile, this.state);
+  }
+  async setMode(mode) {
+    if (this.state.mode === mode) return;
+    this.state.mode = mode;
+    await this.save();
+  }
+  async setSeenUp() {
+    if (this.state.profileSeenUp) return;
+    this.state.profileSeenUp = true;
+    await this.save();
+  }
+  async tick() {
+    if (this.stopped || this.ticking) return;
+    this.ticking = true;
+    try {
+      const heartbeat = await readHeartbeat(this.options.heartbeatFile);
+      const now = (this.options.now ?? Date.now)();
+      const heartbeatFresh = isHeartbeatFresh(heartbeat, this.options.staleMs, now);
+      this.lastHeartbeatAgeMs = heartbeat ? heartbeatAgeMs(heartbeat, now) : void 0;
+      if (heartbeatFresh) this.lastHeartbeatFreshAt = now;
+      const processFound = await (this.options.findProcess ?? findProfileProcess)(
+        this.state.dshProfile
+      );
+      const processAlive = processFound !== void 0;
+      const engineDead = this.lastHeartbeatFreshAt !== void 0 && now - this.lastHeartbeatFreshAt > this.options.engineDeadMs;
+      const up = heartbeatFresh || processAlive && !engineDead;
+      this.dshUp = up;
+      if (up) {
+        this.downStreak = 0;
+        await this.setSeenUp();
+        if (this.state.mode !== "standby" || this.channel !== void 0) {
+          await this.disconnectChannel();
+          this.transcripts.clear();
+          await this.setMode("standby");
+        }
+        return;
+      }
+      if (!this.state.profileSeenUp) return;
+      this.downStreak += 1;
+      if (this.downStreak < this.options.takeoverGracePolls) return;
+      await this.ensureChannel();
+    } catch (error) {
+      this.log().fail("guardian", error);
+    } finally {
+      this.ticking = false;
+    }
+  }
+  async ensureChannel() {
+    if (this.channel !== void 0) return;
+    const config = this.config ?? await this.reloadConfig();
+    if (!config) {
+      this.log().warn("guardian", "no-bridge-profile", {
+        bridgeProfile: this.state.bridgeProfile
+      });
+      return;
+    }
+    const create = this.options.createChannel ?? createLarkChannel2;
+    const channel = create({
+      appId: config.accounts.appId,
+      appSecret: config.accounts.appSecret,
+      domain: config.tenant === "lark" ? "https://open.larksuite.com" : "https://open.feishu.cn",
+      source: "dsh-lark-bot-guardian",
+      policy: {
+        dmMode: config.access.allowedUsers.length ? "allowlist" : "open",
+        requireMention: true,
+        respondToMentionAll: false,
+        ...config.access.allowedUsers.length ? { dmAllowlist: config.access.allowedUsers } : {},
+        ...config.access.allowedChats.length ? { groupAllowlist: config.access.allowedChats } : {}
+      },
+      safety: {
+        chatQueue: { enabled: false }
+      },
+      outbound: {
+        streamThrottleMs: 400
+      },
+      includeRawEvent: true,
+      resolveChatMode: true,
+      handshakeTimeoutMs: 8e3,
+      httpTimeoutMs: 3e4,
+      respectProxyEnv: true
+    });
+    channel.on({
+      message: (msg) => this.track(this.handleMessage(msg)),
+      error: (error) => {
+        this.log().fail("guardian-channel", error);
+      },
+      reconnecting: () => {
+        this.log().warn("guardian-channel", "reconnecting", {});
+      },
+      reconnected: () => {
+        this.log().info("guardian-channel", "reconnected", {});
+      }
+    });
+    try {
+      await channel.connect();
+      this.channel = channel;
+      if (this.state.mode !== "safe") await this.setMode("takeover");
+      this.log().info("guardian", "channel-taken-over", {
+        dshProfile: this.state.dshProfile
+      });
+    } catch (error) {
+      this.log().fail("guardian-channel", error);
+    }
+  }
+  async reloadConfig() {
+    await this.loadContext();
+    return this.config;
+  }
+  async disconnectChannel() {
+    const channel = this.channel;
+    this.channel = void 0;
+    if (!channel) return;
+    try {
+      await channel.disconnect();
+    } catch (error) {
+      this.log().fail("guardian-channel", error);
+    }
+    if (this.state.mode !== "standby") {
+      await this.setMode("standby");
+    }
+  }
+  scopeFor(msg) {
+    if (msg.chatMode === "topic" && msg.threadId) return `${msg.chatId}:${msg.threadId}`;
+    return msg.chatId;
+  }
+  authorized(msg) {
+    const access3 = this.config?.access;
+    if (!access3) return false;
+    const controllers = access3.admins.length > 0 ? access3.admins : access3.allowedUsers;
+    return controllers.includes(msg.senderId);
+  }
+  async sendMarkdown(chatId, markdown2, replyTo) {
+    if (!this.channel) return;
+    try {
+      await this.channel.send(
+        chatId,
+        { markdown: markdown2 },
+        replyTo ? { replyTo } : void 0
+      );
+    } catch (error) {
+      this.log().fail("guardian-send", error);
+    }
+  }
+  async handleMessage(msg) {
+    if (!this.authorized(msg)) {
+      this.log().warn("guardian", "unauthorized-message-dropped", {
+        senderId: msg.senderId,
+        scope: this.scopeFor(msg)
+      });
+      return;
+    }
+    if (this.eventFreshnessMs > 0 && !isEventFresh(msg.createTime, this.eventFreshnessMs)) {
+      this.log().warn("guardian", "stale-message-dropped", {
+        ageMs: Date.now() - msg.createTime
+      });
+      return;
+    }
+    const scope = this.scopeFor(msg);
+    const control = parseGuardianCommand(msg.content);
+    if (control) {
+      await this.handleControl(control.kind, msg);
+      return;
+    }
+    if (this.state.mode === "safe") {
+      await this.runSafeTask(scope, msg);
+      return;
+    }
+    await this.sendMarkdown(
+      msg.chatId,
+      [
+        "dsh \u672A\u5728\u8FD0\u884C\uFF0C\u5B88\u62A4\u8FDB\u7A0B\u5DF2\u63A5\u7BA1\u98DE\u4E66\u901A\u9053\u3002",
+        "",
+        "\u53D1\u9001 `/safemode` \u8FDB\u5165\u4EC5\u6838\u5FC3\u5B89\u5168\u6A21\u5F0F\uFF08dsh \u4E3B\u6838\u5FC3 + \u5B98\u65B9 headless\uFF0C\u4E0D\u52A0\u8F7D\u4EFB\u4F55\u7B2C\u4E09\u65B9\u63D2\u4EF6\uFF09\uFF0C",
+        "\u6216\u53D1\u9001 `/safemode status` \u67E5\u770B\u72B6\u6001\u3002"
+      ].join("\n"),
+      msg.messageId
+    );
+  }
+  track(promise) {
+    this.activeMessages.add(promise);
+    void promise.finally(() => {
+      this.activeMessages.delete(promise);
+    });
+    return promise;
+  }
+  async handleControl(kind, msg) {
+    switch (kind) {
+      case "safemode":
+        await this.enterSafeMode(msg);
+        return;
+      case "safemode-status":
+        await this.sendStatus(msg);
+        return;
+      case "safemode-plugins":
+        await this.sendPluginList(msg);
+        return;
+      case "safemode-exit":
+        await this.exitSafeMode(msg);
+        return;
+      case "safemode-help":
+        await this.sendMarkdown(msg.chatId, safemodeHelpText(), msg.messageId);
+        return;
+    }
+  }
+  async enterSafeMode(msg) {
+    if (this.state.mode === "safe") {
+      await this.sendMarkdown(
+        msg.chatId,
+        "\u5DF2\u5728\u5B89\u5168\u6A21\u5F0F\u4E2D\u3002\u53D1\u9001\u666E\u901A\u6D88\u606F\u4E0E dsh \u6838\u5FC3\u5BF9\u8BDD\uFF1B`/safemode exit` \u9000\u51FA\u3002",
+        msg.messageId
+      );
+      return;
+    }
+    await this.sendMarkdown(
+      msg.chatId,
+      "\u6B63\u5728\u8FDB\u5165\u5B89\u5168\u6A21\u5F0F\uFF1A\u4EC5\u6302\u8F7D dsh \u4E3B\u6838\u5FC3\uFF08`dsh-base` + `dsh-headless`\uFF09\uFF0C\u4E0D\u52A0\u8F7D\u4EFB\u4F55\u7B2C\u4E09\u65B9\u63D2\u4EF6\u2026",
+      msg.messageId
+    );
+    try {
+      await ensureSafeProfile({
+        home: this.options.home,
+        dshProfile: this.state.dshProfile,
+        env: this.options.env ?? process.env
+      });
+      const bin = this.dshBin;
+      if (!bin) {
+        await this.sendMarkdown(
+          msg.chatId,
+          "\u672A\u627E\u5230\u672C\u673A dsh \u5B89\u88C5\uFF0C\u65E0\u6CD5\u8FDB\u5165\u5B89\u5168\u6A21\u5F0F\u3002\u8BF7\u5148\u786E\u8BA4 `dsh` \u53EF\u7528\u3002",
+          msg.messageId
+        );
+        return;
+      }
+      const probe = await (this.options.probeSafeProfileFn ?? probeSafeProfile)({
+        bin,
+        dshProfile: this.state.dshProfile,
+        home: this.options.home,
+        env: this.options.env ?? process.env
+      });
+      if (!probe.ok) {
+        await this.sendMarkdown(
+          msg.chatId,
+          [
+            "\u5B89\u5168\u6A21\u5F0F\u5C31\u7EEA\u68C0\u67E5\u5931\u8D25\uFF08dsh \u6838\u5FC3\u65E0\u6CD5\u89E3\u6790\uFF09\uFF1A",
+            "",
+            "```",
+            (probe.error ?? "unknown error").slice(0, 1500),
+            "```"
+          ].join("\n"),
+          msg.messageId
+        );
+        return;
+      }
+      this.safeAdapter ??= this.options.adapter ?? new DshAdapter({
+        command: "node",
+        args: [bin, "--profile", this.state.safeProfile],
+        stopGraceMs: 5e3
+      });
+      await this.setMode("safe");
+      await this.sendMarkdown(
+        msg.chatId,
+        [
+          "\u5B89\u5168\u6A21\u5F0F\u5DF2\u5C31\u7EEA\uFF1Adsh \u4E3B\u6838\u5FC3\u8FD0\u884C\u4E2D\uFF0C\u7B2C\u4E09\u65B9\u63D2\u4EF6\u672A\u52A0\u8F7D\u3002",
+          "",
+          "\u73B0\u5728\u53EF\u4EE5\u76F4\u63A5\u5BF9\u8BDD\u8FDB\u884C\u81EA\u6108\uFF08\u5B9A\u4F4D / \u4FEE\u590D / \u7981\u7528\u635F\u574F\u63D2\u4EF6\uFF09\uFF0C\u4F8B\u5982\uFF1A",
+          "- \u201C\u5217\u51FA\u5F53\u524D profile \u5B89\u88C5\u7684\u63D2\u4EF6\u5E76\u68C0\u67E5\u54EA\u4E2A\u6700\u8FD1\u53D8\u574F\u201D",
+          "- \u201C\u7528 `/safemode plugins` \u67E5\u770B\u63D2\u4EF6\u6E05\u5355\u201D",
+          "- \u4FEE\u590D\u5B8C\u6210\u540E\u53D1\u9001 `/safemode exit` \u91CD\u542F\u5B8C\u6574 profile\u3002"
+        ].join("\n"),
+        msg.messageId
+      );
+    } catch (error) {
+      await this.sendMarkdown(
+        msg.chatId,
+        `\u8FDB\u5165\u5B89\u5168\u6A21\u5F0F\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`,
+        msg.messageId
+      );
+    }
+  }
+  async sendStatus(msg) {
+    const snapshot = this.snapshot();
+    await this.sendMarkdown(
+      msg.chatId,
+      [
+        `\u6A21\u5F0F\uFF1A${snapshot.mode}`,
+        `dsh profile\uFF1A${snapshot.dshProfile}`,
+        `\u5B89\u5168 profile\uFF1A${snapshot.safeProfile}`,
+        `dsh \u662F\u5426\u5728\u7EBF\uFF1A${snapshot.dshUp ? "\u662F" : "\u5426"}`,
+        `\u5FC3\u8DF3\u9F84\uFF1A${snapshot.heartbeatAgeMs === void 0 ? "\u65E0" : `${snapshot.heartbeatAgeMs}ms`}`,
+        `\u98DE\u4E66\u901A\u9053\uFF1A${snapshot.channelConnected ? "\u5B88\u62A4\u5DF2\u63A5\u7BA1" : "\u672A\u8FDE\u63A5"}`,
+        `dsh bin\uFF1A${snapshot.dshBin ?? "\u672A\u53D1\u73B0"}`,
+        `\u5B88\u62A4 pid\uFF1A${snapshot.pid}`,
+        `\u5DF2\u89C2\u5BDF\u8FC7 dsh \u8FD0\u884C\uFF1A${snapshot.profileSeenUp ? "\u662F" : "\u5426"}`
+      ].join("\n"),
+      msg.messageId
+    );
+  }
+  async sendPluginList(msg) {
+    const bin = this.dshBin;
+    if (!bin) {
+      await this.sendMarkdown(
+        msg.chatId,
+        "\u672A\u627E\u5230\u672C\u673A dsh \u5B89\u88C5\uFF0C\u65E0\u6CD5\u5217\u51FA\u63D2\u4EF6\u3002",
+        msg.messageId
+      );
+      return;
+    }
+    const run = this.options.runPluginList ?? defaultRunPluginList;
+    const result = await run(bin, this.state.dshProfile);
+    const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+    await this.sendMarkdown(
+      msg.chatId,
+      [
+        `profile \`${this.state.dshProfile}\` \u5DF2\u5B89\u88C5\u7684\u63D2\u4EF6\uFF08\u4F9D\u8D56\u6E05\u5355\uFF09\uFF1A`,
+        "",
+        "```",
+        (output || "\uFF08\u7A7A\uFF09").slice(0, 3e3),
+        "```"
+      ].join("\n"),
+      msg.messageId
+    );
+  }
+  async exitSafeMode(msg) {
+    if (this.state.mode !== "safe") {
+      await this.sendMarkdown(
+        msg.chatId,
+        "\u5F53\u524D\u4E0D\u5728\u5B89\u5168\u6A21\u5F0F\uFF0C\u65E0\u9700\u9000\u51FA\u3002",
+        msg.messageId
+      );
+      return;
+    }
+    const bin = this.dshBin;
+    if (!bin) {
+      await this.sendMarkdown(
+        msg.chatId,
+        "\u672A\u627E\u5230\u672C\u673A dsh \u5B89\u88C5\uFF0C\u65E0\u6CD5\u91CD\u542F\u5B8C\u6574 profile\u3002",
+        msg.messageId
+      );
+      return;
+    }
+    const spawn7 = this.options.spawnDetachedFn ?? spawnDetached;
+    const spawned = spawn7("node", [bin, "--profile", this.state.dshProfile]);
+    if (spawned.pid !== void 0) this.state.relaunchedPid = spawned.pid;
+    await this.save();
+    await this.sendMarkdown(
+      msg.chatId,
+      [
+        `\u6B63\u5728\u9000\u51FA\u5B89\u5168\u6A21\u5F0F\u5E76\u91CD\u542F\u5B8C\u6574 profile\uFF08\`${this.state.dshProfile}\`\uFF09\u2026`,
+        "\u5B88\u62A4\u8FDB\u7A0B\u5C06\u65AD\u5F00\u98DE\u4E66\u8FDE\u63A5\u5E76\u628A\u901A\u9053\u4EA4\u8FD8\u7ED9 dsh \u6865\u63A5\u5F15\u64CE\u3002"
+      ].join("\n"),
+      msg.messageId
+    );
+    await delay(this.options.sendDelayMs);
+    this.transcripts.clear();
+    await this.disconnectChannel();
+  }
+  async runSafeTask(scope, msg) {
+    const adapter = this.safeAdapter;
+    if (!adapter) {
+      await this.sendMarkdown(
+        msg.chatId,
+        "\u5B89\u5168\u6A21\u5F0F\u672A\u5C31\u7EEA\uFF0C\u8BF7\u5148\u53D1\u9001 `/safemode`\u3002",
+        msg.messageId
+      );
+      return;
+    }
+    const transcript = this.transcripts.get(scope) ?? [];
+    const prompt = buildSafePrompt(transcript, msg.content);
+    await this.sendMarkdown(
+      msg.chatId,
+      "\uFF08\u5B89\u5168\u6A21\u5F0F \xB7 dsh \u6838\u5FC3\u5904\u7406\u4E2D\u2026\uFF09",
+      msg.messageId
+    );
+    const run = adapter.run({
+      runId: randomUUID5(),
+      prompt,
+      cwd: this.config?.workspaces.default,
+      sessionId: void 0,
+      model: void 0,
+      images: void 0,
+      stopGraceMs: 5e3
+    });
+    const textParts = [];
+    let finalText;
+    let errorText;
+    let terminal = false;
+    try {
+      for await (const event of run.events) {
+        if (event.type === "text" && event.delta) textParts.push(event.delta);
+        if (event.type === "final_text") finalText = event.content;
+        if (event.type === "error") {
+          errorText = event.message;
+          terminal = true;
+        }
+        if (event.type === "done") terminal = true;
+      }
+    } catch (error) {
+      errorText = error instanceof Error ? error.message : String(error);
+      terminal = true;
+    }
+    if (!terminal) {
+      await run.waitForExit(SAFE_RUN_TIMEOUT_MS);
+    }
+    if (errorText) {
+      await this.sendMarkdown(
+        msg.chatId,
+        `\uFF08\u5B89\u5168\u6A21\u5F0F \xB7 dsh \u6838\u5FC3\u9519\u8BEF\uFF09
+${errorText.slice(0, 2e3)}`,
+        msg.messageId
+      );
+      return;
+    }
+    const answer = finalText ?? textParts.join("").trim();
+    if (!answer) {
+      await this.sendMarkdown(
+        msg.chatId,
+        "\uFF08\u5B89\u5168\u6A21\u5F0F \xB7 dsh \u6838\u5FC3\u672A\u8FD4\u56DE\u5185\u5BB9\uFF09",
+        msg.messageId
+      );
+      return;
+    }
+    await this.sendMarkdown(msg.chatId, answer, msg.messageId);
+    this.transcripts.set(scope, pushTranscript(transcript, [
+      { role: "user", content: msg.content },
+      { role: "assistant", content: answer }
+    ]));
+  }
+};
+function buildSafePrompt(transcript, current) {
+  if (transcript.length === 0) return current;
+  const history = transcript.map((entry) => `${entry.role === "user" ? "\u7528\u6237" : "\u52A9\u624B"}: ${entry.content}`).join("\n");
+  return [
+    "\u4EE5\u4E0B\u662F\u672C\u6B21\u5B89\u5168\u6A21\u5F0F\u5BF9\u8BDD\u7684\u4E0A\u4E0B\u6587\uFF08\u7528\u4E8E\u8FDE\u7EED\u6027\uFF0C\u4E0D\u662F\u65B0\u4EFB\u52A1\u6307\u4EE4\uFF09\uFF1A",
+    "",
+    history,
+    "",
+    `\u7528\u6237: ${current}`
+  ].join("\n");
+}
+function pushTranscript(existing, entries) {
+  return [...existing, ...entries].slice(-MAX_TRANSCRIPT_ENTRIES);
+}
+async function defaultRunPluginList(bin, dshProfile) {
+  return captureOutput("node", [bin, "plugin", "--profile", dshProfile, "list"], 6e4);
+}
+function delay(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+function parseFreshness2(value) {
+  const raw = value?.trim();
+  if (!raw) return 6e5;
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : 6e5;
+}
+function defined(input) {
+  const output = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0) output[key] = value;
+  }
+  return output;
+}
+function guardianLayoutFor(env, bridgeProfile) {
+  const paths = resolveAppPaths(env.home);
+  return {
+    paths,
+    stateFile: join15(paths.root, "guardian.json"),
+    heartbeatFile: paths.profilePath(bridgeProfile, "guardian", "heartbeat.json"),
+    configFile: paths.configFile
+  };
+}
+async function buildGuardianService(env, overrides = {}) {
+  const paths = resolveAppPaths(env.home);
+  const stateFile = join15(paths.root, "guardian.json");
+  const fallback = newGuardianState({
+    dshProfile: env.guardianProfile,
+    bridgeProfile: env.guardianBridgeProfile
+  });
+  const state = await loadGuardianState(stateFile, fallback);
+  return new GuardianService({
+    stateFile,
+    configFile: paths.configFile,
+    heartbeatFile: paths.profilePath(state.bridgeProfile, "guardian", "heartbeat.json"),
+    home: homedir8(),
+    env: process.env,
+    dshProfile: state.dshProfile,
+    bridgeProfile: state.bridgeProfile,
+    safeProfile: state.safeProfile,
+    pollMs: env.guardianPollMs,
+    staleMs: env.guardianStaleMs,
+    engineDeadMs: env.guardianEngineDeadMs,
+    ...overrides
+  });
+}
+
+// src/cli/commands/guardian.ts
+function envWithOverrides(options) {
+  const env = loadRuntimeEnv(process.env);
+  if (options.dshProfile) env.guardianProfile = options.dshProfile;
+  if (options.bridgeProfile) env.guardianBridgeProfile = options.bridgeProfile;
+  return env;
+}
+function printLines(lines) {
+  process.stdout.write(`${lines.join("\n")}
+`);
+}
+async function runGuardian(options = {}) {
+  const env = envWithOverrides(options);
+  if (env.guardianDisabled) {
+    printLines(["\u5B89\u5168\u7F51\u5B88\u62A4\u5DF2\u7981\u7528\uFF08DSH_LARK_GUARDIAN_DISABLED=1\uFF09\uFF0C\u8FDB\u7A0B\u9000\u51FA\u3002"]);
+    return;
+  }
+  const service = await buildGuardianService(env);
+  await service.start();
+  printLines([
+    `\u5B89\u5168\u7F51\u5B88\u62A4\u8FD0\u884C\u4E2D\uFF08pid=${process.pid}\uFF0Cdsh profile=${service.snapshot().dshProfile}\uFF09\u3002`,
+    "dsh \u6B63\u5E38\u8FD0\u884C\u65F6\u4FDD\u6301\u9759\u9ED8\uFF1Bdsh \u4E0B\u7EBF\u540E\u81EA\u52A8\u63A5\u7BA1\u98DE\u4E66\u901A\u9053\uFF0C\u7B49\u5F85 /safemode \u63A7\u5236\u4FE1\u53F7\u3002"
+  ]);
+  await waitForShutdown2();
+  await service.stop();
+}
+async function installGuardianCommand(options = {}) {
+  const env = envWithOverrides(options);
+  const result = await installGuardian({ env, ...options.dshProfile ? { dshProfile: options.dshProfile } : {} });
+  printResult(result);
+  if (!result.ok) process.exitCode = 1;
+}
+async function uninstallGuardianCommand(options = {}) {
+  const env = envWithOverrides(options);
+  const result = await uninstallGuardian({ env });
+  printResult(result);
+}
+async function statusGuardianCommand(options = {}) {
+  const env = envWithOverrides(options);
+  const paths = resolveAppPaths(env.home);
+  const fallback = newGuardianState({
+    dshProfile: env.guardianProfile,
+    bridgeProfile: env.guardianBridgeProfile
+  });
+  const state = await loadGuardianState(join16(paths.root, "guardian.json"), fallback);
+  const layout = guardianLayoutFor(env, state.bridgeProfile);
+  const heartbeat = await readHeartbeat(layout.heartbeatFile);
+  const processFound = await findProfileProcess(state.dshProfile);
+  const up = isHeartbeatFresh(heartbeat, env.guardianStaleMs) || processFound !== void 0;
+  printLines([
+    "\u5B89\u5168\u7F51\u5B88\u62A4\u72B6\u6001",
+    "---------------",
+    `\u6A21\u5F0F\uFF1A${state.mode}`,
+    `dsh profile\uFF1A${state.dshProfile}`,
+    `\u5B89\u5168 profile\uFF1A${state.safeProfile}`,
+    `\u6865\u63A5 profile\uFF1A${state.bridgeProfile}`,
+    `dsh \u662F\u5426\u5728\u7EBF\uFF1A${up ? "\u662F" : "\u5426"}${processFound ? `\uFF08pid ${processFound.pid}\uFF09` : ""}`,
+    `\u5FC3\u8DF3\u9F84\uFF1A${heartbeat ? `${heartbeatAgeMs(heartbeat)}ms` : "\u65E0"}`,
+    `\u5DF2\u89C2\u5BDF\u8FC7 dsh \u8FD0\u884C\uFF1A${state.profileSeenUp ? "\u662F" : "\u5426"}`,
+    `\u5B88\u62A4\u8FDB\u7A0B pid\uFF1A${process.pid}`,
+    `\u72B6\u6001\u6587\u4EF6\uFF1A${layout.stateFile}`,
+    `\u5FC3\u8DF3\u6587\u4EF6\uFF1A${layout.heartbeatFile}`
+  ]);
+}
+function printResult(result) {
+  for (const message of result.messages) {
+    process.stdout.write(`${message}
+`);
+  }
+}
+function waitForShutdown2() {
+  return new Promise((resolve5) => {
+    const shutdown = () => {
+      process.off("SIGINT", shutdown);
+      process.off("SIGTERM", shutdown);
+      resolve5();
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
 }
 
 // src/cli.ts
@@ -5762,8 +7103,11 @@ function buildProgram() {
   program.name("dsh-lark-bot").description("Bridge DeepSeek Harness into Feishu / Lark").version(packageVersion(), "-v, --version");
   program.command("setup").description(
     "Install this package as a standard dsh profile bundle (single install path)"
-  ).option("--profile <name>", "dsh profile to install into (default: dsh-lark)").action(async (opts) => {
-    await runSetup({ ...opts.profile ? { profile: opts.profile } : {} });
+  ).option("--profile <name>", "dsh profile to install into (default: dsh-lark)").option("--guardian", "also install the safety-net guardian service").action(async (opts) => {
+    await runSetup({
+      ...opts.profile ? { profile: opts.profile } : {},
+      ...opts.guardian ? { guardian: true } : {}
+    });
   });
   program.command("doctor").description("Run local diagnostics").option("--profile <name>", "profile name").option("--workspace <path>", "initial working directory").option("--app-id <id>", "existing Lark/Feishu app id").option("--app-secret <secret>", "existing Lark/Feishu app secret").option("--tenant <tenant>", "feishu or lark").action(async (opts) => {
     await runDoctor({ ...opts, version: packageVersion() });
@@ -5773,6 +7117,21 @@ function buildProgram() {
   ).action(async (opts) => {
     await runBot(opts);
   });
+  const guardian = program.command("guardian").description(
+    "Safety-net guardian: a minimal process independent of dsh that keeps the Feishu rescue entrance alive"
+  );
+  guardian.command("run").description("Run the guardian in the foreground (system service entry point)").option("--dsh-profile <name>", "dsh profile to watch / relaunch (default from state)").option("--bridge-profile <name>", "bridge state profile with Feishu credentials").action(async (opts) => {
+    await runGuardian(opts);
+  });
+  guardian.command("install").description("Install the guardian as a system-level resident service").option("--dsh-profile <name>", "dsh profile to watch / relaunch (default: dsh-lark)").option("--bridge-profile <name>", "bridge state profile (default: default)").action(async (opts) => {
+    await installGuardianCommand(opts);
+  });
+  guardian.command("uninstall").description("Remove the system service entry (state file is kept)").action(async () => {
+    await uninstallGuardianCommand();
+  });
+  guardian.command("status").description("Show guardian / dsh / safe-mode state").option("--dsh-profile <name>", "dsh profile to inspect").option("--bridge-profile <name>", "bridge state profile to inspect").action(async (opts) => {
+    await statusGuardianCommand(opts);
+  });
   return program;
 }
 async function main(argv = process.argv) {