dsh-lark-bot 0.8.3 → 0.9.0

package/README.md

@@ -87,10 +87,15 @@ npx dsh-lark-bot@latest setup --profile dsh-lark
 ```
 
 `setup` 会自动完成：发现本机 dsh → 预批准 pnpm 构建策略 → 执行标准的
-`dsh plugin --profile dsh-lark add dsh-lark-bot`。
+`dsh plugin --profile dsh-lark add dsh-lark-bot`，并**默认同时安装「安全网守护」**——系统级
+常驻、dsh 全部下线后仍保留飞书救援入口（核心能力之一，见下文「安全网守护」一节）。
+一条命令即完成全部安装。
 
 `setup` automatically: locates your dsh install → pre-approves pnpm's build policy → runs the
-standard `dsh plugin --profile dsh-lark add dsh-lark-bot`.
+standard `dsh plugin --profile dsh-lark add dsh-lark-bot`, and **also installs the safety-net
+guardian by default** — a system-level resident process that keeps the Feishu rescue entrance
+alive even when dsh is fully down (one of the core features; see "Safety-net guardian" below).
+One command installs everything.
 
 ### 2. 启动并扫码绑定 | Start and bind with one scan
 
@@ -190,6 +195,11 @@ run in that scope carries the role instructions, and the role model wins below t
 dsh 工具（SDK / ACP 两种 runtime 均可装配）：agent 完成任务后可主动向其他群 / 话题发消息并
 @ 指定成员，桥接进程通过 127.0.0.1 本地回调端口 + 随机 token 校验，不暴露公网。
 
+**任务中向你提问（问答卡）**：agent 需要你拍板、确认或补充缺失信息时，会通过
+`lark_ask_user` 工具主动向当前会话弹一张**问答卡**（单选 / 多选 / 自由文本），
+你回答后任务自动继续——无需额外命令。问答卡等待期间任务不会被运行超时打断。
+（与 `/ask` 的“你主动发结构化问题”方向相反：这是 agent 主动来问你。）
+
 **Outbound mentions & cross-session notify**: the outbound contract supports `mentions` and
 cross-chat/thread sends; `/notify <scope|chatId> <text>` pushes a report to another session
 (admin). The agent also gets a built-in `lark_notify` dsh tool (wired into both SDK and ACP
@@ -197,8 +207,14 @@ runtime profiles): after a task finishes it can push messages to other groups/to
 members. The bridge listens on 127.0.0.1 with a random per-boot token — nothing is exposed to the
 public network.
 
-**安全网守护（Safe-mode guardian）**：可选安装一个独立于 dsh 进程、系统级常驻的最小守护进程
-（Linux systemd user unit / macOS LaunchAgent / Windows 启动项）。dsh 正常运行时守护保持静默；
+**Mid-task questions (question cards)**: when the agent needs a decision, confirmation, or
+missing information, it proactively sends a **question card** to the current chat via the
+`lark_ask_user` tool (single choice / multi choice / free text) and resumes automatically once
+you answer — no extra command needed. The run-timeout watchdog pauses while a card is waiting.
+(This is the opposite direction of `/ask`, which is you asking the agent.)
+
+**安全网守护（Safe-mode guardian）**：默认随 `setup` 一起安装的、独立于 dsh 进程、系统级常驻的
+最小守护进程（Linux systemd user unit / macOS LaunchAgent / Windows 启动项）。dsh 正常运行时守护保持静默；
 一旦 dsh 进程下线或无法 boot（例如某个第三方插件破坏了整个 profile 组合），守护自动接管飞书
 通道，用户无需接触命令行即可发送控制信号自救：
 
@@ -212,12 +228,13 @@ public network.
 全程不需要命令行；dsh 恢复后守护自动断开并回归静默。安装：
 
 ```bash
-npx dsh-lark-bot@latest setup --profile dsh-lark --guardian
-# 或已安装后单独安装：dsh-lark-bot guardian install
+# 随 setup 默认安装（无需额外参数）；已安装后也可单独安装 / 重装：
+dsh-lark-bot guardian install --dsh-profile dsh-lark
 ```
+不需要守护时，安装时加 `--no-guardian` 跳过；单独卸载用 `dsh-lark-bot guardian uninstall`。
 
-**Safety-net guardian**: optionally install a minimal system-level resident process that is
-independent of the dsh process. While dsh runs, the guardian stays silent; once dsh goes down or
+**Safety-net guardian**: a minimal system-level resident process installed **by default with
+`setup`**, independent of the dsh process. While dsh runs, the guardian stays silent; once dsh goes down or
 fails to boot (e.g. a third-party plugin breaks the whole profile composition), the guardian
 takes over the Feishu channel so you can self-heal without touching the command line:
 
@@ -234,9 +251,10 @@ No command line is needed for the whole rescue flow; once dsh is back, the guard
 channel automatically. Install:
 
 ```bash
-npx dsh-lark-bot@latest setup --profile dsh-lark --guardian
-# or later: dsh-lark-bot guardian install
+# Installed by default with setup (no extra flag); can also be installed / refreshed later:
+dsh-lark-bot guardian install --dsh-profile dsh-lark
 ```
+Pass `--no-guardian` to setup to skip it; remove it later with `dsh-lark-bot guardian uninstall`.
 
 ### 模型 / Provider / 凭据管理 | Models / Providers / Credentials
 
@@ -285,21 +303,25 @@ npx dsh-lark-bot@latest setup --profile dsh-lark
 ```
 
 `setup` 自动完成：定位本机 dsh → 预批准 pnpm 构建策略（protobufjs）→ 执行标准
-`dsh plugin --profile dsh-lark add dsh-lark-bot`。加 `--guardian` 会同时安装「安全网守护」
-（见「安全网守护」一节）。已安装时重复执行即升级到最新版。
+`dsh plugin --profile dsh-lark add dsh-lark-bot`，并**默认同时安装「安全网守护」**
+（见「安全网守护」一节；不需要时加 `--no-guardian` 跳过）。已安装时重复执行即升级到最新版。
 
 `setup` locates your dsh, pre-approves pnpm's build policy (protobufjs) and runs the standard
-`dsh plugin --profile dsh-lark add dsh-lark-bot`. Adding `--guardian` also installs the
-safety-net guardian (see "Safety-net guardian" above). Re-running it upgrades to the latest version.
+`dsh plugin --profile dsh-lark add dsh-lark-bot`. It **also installs the safety-net guardian by
+default** (see "Safety-net guardian" above; pass `--no-guardian` to skip). Re-running it upgrades
+to the latest version.
 
 ### 升级 | Upgrade
 
 - 插件本体：重跑 `setup`（或 `dsh plugin --profile <name> add dsh-lark-bot`）拉取 npm 最新版。
+- 安全网守护：随 `setup` 一起安装 / 升级（幂等重装），也可单独 `dsh-lark-bot guardian install`。
 - CLI 工具（可选）：`npm i -g dsh-lark-bot@latest`；使用 `npx` 时无需全局安装。
 - 升级后重启 profile：`dsh --profile dsh-lark`。
 
 - Plugin: re-run `setup` (or `dsh plugin --profile <name> add dsh-lark-bot`) to pull the latest
   npm release.
+- Safety-net guardian: installed / upgraded together with `setup` (idempotent), or standalone via
+  `dsh-lark-bot guardian install`.
 - CLI tool (optional): `npm i -g dsh-lark-bot@latest`; not needed when using `npx`.
 - Restart the profile after upgrading: `dsh --profile dsh-lark`.
 
@@ -391,7 +413,7 @@ tasks and session archival.
   对应 runtime 并自动重建。
 - 桥接引擎作为 dsh 插件在 dsh 进程内运行，agent 执行使用官方 dsh SDK runtime 子进程
   （嵌套 runtime 是有意取舍，用于按工作区隔离的 runtime 池与 scope 内并行 run）。
-  唯一的进程级例外是可选安装的「安全网守护」——它独立于 dsh / Cordis 常驻，仅在 dsh
+  唯一的进程级例外是默认安装的「安全网守护」——它独立于 dsh / Cordis 常驻，仅在 dsh
   下线后接管飞书通道，正常运行时保持静默。
 - 飞书文档评论、富文本回复为规划中能力，尚未实现。
 - pnpm ≥ 10 的构建脚本策略由 `setup` 自动处理；手动 `dsh plugin add` 时若报
@@ -493,7 +515,7 @@ This tool runs **locally**; before installing, be aware that it accesses:
 - **dsh 配置**：`/model` `/providers` `/provider` `/key` 命令按 dsh 官方存储协议读写
   `~/.dsh/settings.yaml` 与 `~/.dsh/.credentials.yaml`（仅管理员可写；settings 只存 `apiKeyEnv`
   引用，凭据文件权限 0600、目录 0700，字面密钥不进入 settings 或聊天记录）。
-- **安全网守护（可选）**：安装后为系统级常驻进程，读取 `~/.dsh-lark/config.json` 中的飞书
+- **安全网守护（默认随 `setup` 安装）**：系统级常驻进程，读取 `~/.dsh-lark/config.json` 中的飞书
   凭据；dsh 下线时接管同一 bot 的飞书长连接并扫描本机进程（仅 `ps` 命令行，不读内存）；
   `/safemode` 时在 `~/.dsh/profiles/<profile>-safe` 创建仅核心的 dsh profile 并逐条执行
   `dsh --profile <safe> "<prompt>"` 子进程。
@@ -548,11 +570,12 @@ Common issues:
   is reachable; with an existing App ID/Secret you can skip scanning via `--app-id` /
   `--app-secret`.
 
-桥接引擎日志写入 `~/.dsh-lark/profiles/<profile>/logs/bot.log`（JSON Lines）；dsh 宿主日志走
-dsh 自己的日志体系。
+桥接引擎日志以 JSON Lines 输出到 stderr（由 dsh 宿主进程捕获；`logs/bot.log` 是 0.6.0
+独立服务时代的遗留路径，0.7.0 起不再写入）；dsh 宿主日志走 dsh 自己的日志体系。
 
-The bridge engine logs to `~/.dsh-lark/profiles/<profile>/logs/bot.log` (JSON Lines); the dsh
-host uses its own logging.
+The bridge engine logs JSON Lines to stderr (captured by the dsh host; `logs/bot.log` is a
+leftover path from the 0.6.0 standalone-service era and is no longer written since 0.7.0); the
+dsh host uses its own logging.
 
 **回滚 / Rollback**：`dsh plugin --profile dsh-lark remove dsh-lark-bot` 后重装固定版本即可
 （如 `dsh plugin --profile dsh-lark add dsh-lark-bot@0.6.0`）；`~/.dsh-lark` 状态独立于插件
@@ -673,7 +696,7 @@ See "Community Listings" in the next section for ecosystem registration status.
 
 核心思路：**飞书通道与 agent 后端解耦**。桥接层复刻 `lark-channel-bridge` 的成熟做法（WebSocket 长连接 + 流式卡片 + 会话路由），agent 后端通过 adapter 抽象，默认挂接官方 DeepSeek Harness SDK（`DSH_LARK_ADAPTER=sdk`），可选 ACP 审批模式与 legacy headless。
 
-可选「安全网守护」（`src/guardian/`）独立于 dsh 进程常驻：dsh 在线时静默，下线时接管飞书
+默认安装的「安全网守护」（`src/guardian/`）独立于 dsh 进程常驻：dsh 在线时静默，下线时接管飞书
 通道接收 `/safemode` 控制信号，以仅核心 profile（`dsh-base` + `dsh-headless`）拉起受限对话
 用于自愈，`/safemode exit` 重启完整 profile 并交还通道。
 

package/SECURITY.md

@@ -37,7 +37,7 @@
    `/invite admin <open_id>` 定义）；查看类命令（`/model`、`/providers`、`/key list`）开放。
 10. **本地回调隔离**：`lark_notify` 工具的回调服务只绑定 `127.0.0.1`，每次启动生成随机
     token 鉴权（不落盘、不进日志），请求体限 1MB；`/notify` 与角色 / 配置写命令同为管理员操作。
-11. **安全网守护（可选安装）**：
+11. **安全网守护（默认随 `setup` 安装）**：
     - 守护是独立于 dsh / Cordis 的最小进程，只读取本地状态与进程命令行（`ps`，不读内存），
       不导入任何 dsh 代码、不监听公网端口；
     - dsh 在线时守护**不连接飞书**（同 app 长连接仅允许单连接，避免抢占正常通道）；仅在
@@ -54,7 +54,8 @@
 - 飞书凭据明文保存在本机配置文件；日志与卡片不输出真实密钥。
 - 桥接引擎在 dsh 宿主进程内运行，凭据与 `DSH_LARK_*` 环境直接随 dsh 进程提供，无独立服务
   环境快照文件；敏感值不进日志与卡片。
-- 后台运行日志写入 `~/.dsh-lark/profiles/<profile>/logs/bot.log`（JSON Lines，密钥字段脱敏后输出）。
+- 桥接引擎日志以 JSON Lines 输出到 stderr（由 dsh 宿主进程捕获），密钥字段脱敏后输出；
+  `logs/bot.log` 是 0.6.0 独立服务时代的遗留路径，0.7.0 起不再写入。
 - 聊天命令管理的 dsh 配置按官方存储协议写入：`~/.dsh/settings.yaml`（只存 `apiKeyEnv`
   引用，不落字面密钥）与 `~/.dsh/.credentials.yaml`（目录 0700、文件 0600）。bot 永不回显
   密钥值；群聊中粘贴密钥会对群成员可见，建议私聊使用或改用环境变量 / dsh Web 页面录入。

package/dist/cli.js

@@ -226,6 +226,14 @@ function acpPatchYaml(provider, model) {
     "      config:",
     "        endpoint: !!js process.env.DSH_LARK_NOTIFY_URL",
     "        token: !!js process.env.DSH_LARK_NOTIFY_TOKEN",
+    "",
+    // Question-card tool (same contract as the SDK runtime).
+    "- insert:",
+    "    - id: lark-ask",
+    `      name: '${own.name}/ask'`,
+    "      config:",
+    "        endpoint: !!js process.env.DSH_LARK_ASK_URL",
+    "        token: !!js process.env.DSH_LARK_NOTIFY_TOKEN",
     ""
   ].join("\n");
 }
@@ -1323,6 +1331,15 @@ function patchYamlFor() {
     "      config:",
     "        endpoint: !!js process.env.DSH_LARK_NOTIFY_URL",
     "        token: !!js process.env.DSH_LARK_NOTIFY_TOKEN",
+    "",
+    // Question-card tool: the agent asks the user for decisions / missing
+    // information; the bridge shows a card and returns the answer.
+    "- insert:",
+    "    - id: lark-ask",
+    `      name: '${own.name}/ask'`,
+    "      config:",
+    "        endpoint: !!js process.env.DSH_LARK_ASK_URL",
+    "        token: !!js process.env.DSH_LARK_NOTIFY_TOKEN",
     ""
   ].join("\n");
 }
@@ -2194,6 +2211,28 @@ var PendingQueue = class {
 import { randomUUID as randomUUID3 } from "crypto";
 var QuestionRegistry = class {
   pending = /* @__PURE__ */ new Map();
+  settledListeners = /* @__PURE__ */ new Map();
+  /** Number of question cards currently awaiting an answer in a scope. */
+  pendingCount(scope) {
+    let count = 0;
+    for (const key of this.pending.keys()) {
+      if (key.startsWith(`${scope}:`)) count += 1;
+    }
+    return count;
+  }
+  /** Subscribe to question settlements in a scope; returns an unsubscribe. */
+  onSettled(scope, listener) {
+    const listeners = this.settledListeners.get(scope) ?? /* @__PURE__ */ new Set();
+    listeners.add(listener);
+    this.settledListeners.set(scope, listeners);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) this.settledListeners.delete(scope);
+    };
+  }
+  notifySettled(scope) {
+    for (const listener of this.settledListeners.get(scope) ?? []) listener();
+  }
   register(scope, input) {
     const id = `question-${randomUUID3().replaceAll("-", "")}`;
     const full = { ...input, id };
@@ -2208,6 +2247,7 @@ var QuestionRegistry = class {
     pending.settled = true;
     this.pending.delete(`${scope}:${id}`);
     pending.resolve(answer);
+    this.notifySettled(scope);
     return true;
   }
   settleAll(scope) {
@@ -2220,6 +2260,7 @@ var QuestionRegistry = class {
       pending.resolve(void 0);
       count += 1;
     }
+    if (count > 0) this.notifySettled(scope);
     return count;
   }
   get(scope, id) {
@@ -2879,12 +2920,26 @@ async function runAgentBatch(input) {
           }
         };
         let timeoutTimer;
+        let armTimeout;
         const timeoutPromise = timeoutMs > 0 ? new Promise((resolve5) => {
-          timeoutTimer = setTimeout(() => {
-            timedOut = true;
-            void run.stop();
-            resolve5();
-          }, timeoutMs);
+          armTimeout = () => {
+            timeoutTimer = setTimeout(() => {
+              if (timedOut) return;
+              if (input.questions?.pendingCount(input.scope)) {
+                armTimeout?.();
+                return;
+              }
+              timedOut = true;
+              void run.stop();
+              resolve5();
+            }, timeoutMs);
+          };
+          armTimeout();
+        }) : void 0;
+        const unsubscribeSettled = timeoutPromise ? input.questions?.onSettled(input.scope, () => {
+          if (timedOut) return;
+          if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
+          armTimeout?.();
         }) : void 0;
         try {
           if (timeoutPromise) {
@@ -2896,6 +2951,7 @@ async function runAgentBatch(input) {
           await controller.update(renderCard(state, density));
         } finally {
           if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
+          unsubscribeSettled?.();
         }
       },
       replyOptions
@@ -4655,6 +4711,7 @@ var NotifyServer = class {
   token;
   deps;
   url;
+  askUrl;
   constructor(deps) {
     this.deps = deps;
     this.token = deps.token;
@@ -4670,6 +4727,7 @@ var NotifyServer = class {
       server.listen(this.deps.port ?? 0, "127.0.0.1", () => {
         const address = server.address();
         this.url = `http://127.0.0.1:${String(address.port)}/notify`;
+        this.askUrl = `http://127.0.0.1:${String(address.port)}/ask`;
         resolve5();
       });
     });
@@ -4690,12 +4748,38 @@ var NotifyServer = class {
       res.end(`${JSON.stringify(body)}
 `);
     };
-    if (req.method !== "POST" || req.url !== "/notify") {
-      respond(404, { ok: false, error: "not found" });
-      return;
-    }
     try {
       const body = await readBody(req);
+      if (req.method !== "POST") {
+        respond(404, { ok: false, error: "not found" });
+        return;
+      }
+      if (req.url === "/ask") {
+        if (!this.deps.ask) {
+          respond(404, { ok: false, error: "ask channel is not wired" });
+          return;
+        }
+        const payload = JSON.parse(body);
+        if (payload.token !== this.token) {
+          respond(401, { ok: false, error: "invalid token" });
+          return;
+        }
+        if (!payload.sessionId || !payload.question?.trim()) {
+          respond(400, { ok: false, error: "sessionId and question are required" });
+          return;
+        }
+        const result = await this.deps.ask(payload);
+        if (!result.ok) {
+          respond(404, { ok: false, ...result.error === void 0 ? {} : { error: result.error } });
+          return;
+        }
+        respond(200, { ok: true, ...result.answer === void 0 ? {} : { answer: result.answer } });
+        return;
+      }
+      if (req.url !== "/notify") {
+        respond(404, { ok: false, error: "not found" });
+        return;
+      }
       const message = JSON.parse(body);
       if (message.token !== this.token) {
         respond(401, { ok: false, error: "invalid token" });
@@ -4739,6 +4823,46 @@ function generateNotifyToken() {
   return `dsh-lark-${randomBytes2(18).toString("hex")}`;
 }
 
+// src/notify/ask-handler.ts
+function buildAskHandler(deps) {
+  return async (payload) => {
+    const scope = deps.sessions.scopeForSession(payload.sessionId);
+    if (!scope) {
+      return { ok: false, error: `unknown session: ${payload.sessionId}` };
+    }
+    const destination = deps.scopeDirectory.resolve(scope);
+    if (!destination) {
+      return { ok: false, error: `unknown scope: ${scope}` };
+    }
+    const kind = payload.kind ?? (payload.options && payload.options.length > 0 ? "single" : "text");
+    const input = {
+      kind,
+      question: payload.question,
+      ...payload.options && payload.options.length > 0 ? { options: payload.options } : {}
+    };
+    const { id, promise } = deps.questions.register(scope, input);
+    try {
+      await deps.channel.sendCard(
+        destination.chatId,
+        renderQuestionCard({ ...input, id }),
+        destination.threadId ? { threadId: destination.threadId } : void 0
+      );
+    } catch (error) {
+      log.fail("ask-card", error, { scope });
+      deps.questions.settleAll(scope);
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+    const answer = await promise;
+    if (answer === void 0) {
+      return { ok: false, error: "question cancelled" };
+    }
+    return { ok: true, answer };
+  };
+}
+
 // src/config/access-manager.ts
 var AccessManager = class {
   constructor(store, profileName) {
@@ -4892,6 +5016,8 @@ ${safeContent}`
 import { readFile as readFile6 } from "fs/promises";
 var SessionStore = class {
   data = { chats: {} };
+  /** Live session-id → scope index (used by the agent question-card router). */
+  sessionScopes = /* @__PURE__ */ new Map();
   saving = Promise.resolve();
   pendingArchive = Promise.resolve();
   path;
@@ -4929,8 +5055,22 @@ var SessionStore = class {
       cwd,
       messages: existing?.messages ?? []
     };
+    if (sessionId) this.sessionScopes.set(sessionId, scopeId);
     this.schedulePersist();
   }
+  /**
+   * Reverse lookup used by the bridge question-card router: map a live dsh
+   * session id back to its bridge scope. Falls back to a scan of the loaded
+   * records (e.g. after a fresh load before any live run registered).
+   */
+  scopeForSession(sessionId) {
+    const direct = this.sessionScopes.get(sessionId);
+    if (direct !== void 0) return direct;
+    for (const [scope, record] of Object.entries(this.data.chats)) {
+      if (record.sessionId === sessionId) return scope;
+    }
+    return void 0;
+  }
   historyFor(scopeId, cwd) {
     const record = this.data.chats[scopeId];
     return record && record.cwd === cwd ? record.messages : [];
@@ -5599,7 +5739,19 @@ async function startBridgeEngine(options) {
         ...destination.threadId ? { threadId: destination.threadId } : {},
         ...payload.mentions ? { mentions: payload.mentions } : {}
       });
-    }
+    },
+    ask: buildAskHandler({
+      sessions,
+      scopeDirectory,
+      questions,
+      channel: {
+        sendCard: async (chatId, card, options2) => {
+          if (!streaming) throw new Error("bridge channel is not ready");
+          if (!streaming.sendCard) throw new Error("bridge channel does not support cards");
+          await streaming.sendCard(chatId, card, options2);
+        }
+      }
+    })
   });
   process.env.DSH_LARK_NOTIFY_TOKEN = notifyToken;
   const pending = new PendingQueue(
@@ -5696,6 +5848,7 @@ async function startBridgeEngine(options) {
   larkChannel = bridge.channel;
   await notifyServer.start();
   process.env.DSH_LARK_NOTIFY_URL = notifyServer.url ?? "";
+  process.env.DSH_LARK_ASK_URL = notifyServer.askUrl ?? "";
   const heartbeat = startHeartbeat(
     paths.profilePath(profileName, "guardian", "heartbeat.json"),
     process.pid,
@@ -6136,6 +6289,7 @@ async function runSetup(options = {}) {
       "\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 installGuardianService = options.guardian !== false;
   const profileDir = join13(dshHome, "profiles", profile);
   await mkdir12(profileDir, { recursive: true });
   await approveBuilds(profileDir);
@@ -6144,7 +6298,7 @@ async function runSetup(options = {}) {
 `
   );
   await runDshPlugin(bin, profile, packageSpec);
-  if (options.guardian) {
+  if (installGuardianService) {
     const install = options.installGuardianFn ?? installGuardian;
     const guardianResult = await install({
       env: loadRuntimeEnv(process.env),
@@ -6169,13 +6323,14 @@ 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 ? [
+      ...installGuardianService ? [
         "",
-        "\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"
+        "\u5B89\u5168\u7F51\u5B88\u62A4\u5DF2\u9ED8\u8BA4\u5B89\u88C5\uFF1Adsh \u5168\u90E8\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",
+        "\u4E0D\u9700\u8981\u65F6\u53EF\u8DF3\u8FC7\u5B89\u88C5\uFF1Anpx dsh-lark-bot@latest setup --no-guardian"
       ] : [
         "",
-        "\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"
+        "\u63D0\u793A\uFF1A\u672C\u6B21\u672A\u5B89\u88C5\u5B89\u5168\u7F51\u5B88\u62A4\uFF08--no-guardian\uFF09\u3002\u9700\u8981\u65F6\u968F\u65F6\u6267\u884C dsh-lark-bot guardian install\u3002"
       ],
       ""
     ].join("\n")
@@ -7107,10 +7262,10 @@ 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)").option("--guardian", "also install the safety-net guardian service").action(async (opts) => {
+  ).option("--profile <name>", "dsh profile to install into (default: dsh-lark)").option("--guardian", "install the safety-net guardian service (installed by default; compatibility)").option("--no-guardian", "skip installing the safety-net guardian service (installed by default)").action(async (opts) => {
     await runSetup({
       ...opts.profile ? { profile: opts.profile } : {},
-      ...opts.guardian ? { guardian: true } : {}
+      guardian: opts.guardian !== false
     });
   });
   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) => {