npm - dsh-lark-bot - Versions diffs - 0.19.11 → 0.19.13 - Mend

dsh-lark-bot 0.19.11 → 0.19.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/plugin.js CHANGED Viewed

@@ -296,6 +296,16 @@ var init_profile_package = __esm({
   }
 });
+// src/adapters/model-choice.ts
+function resolveModelChoice(preferenceModel, envModel) {
+  return preferenceModel?.trim() || envModel;
+}
+var init_model_choice = __esm({
+  "src/adapters/model-choice.ts"() {
+    "use strict";
+  }
+});
 // src/adapters/dsh/acp-runtime.ts
 import { spawn as spawn4 } from "cross-spawn";
 import { existsSync as existsSync4, realpathSync as realpathSync3 } from "fs";
@@ -658,7 +668,7 @@ async function buildAcpAgentAdapter(env, preferences) {
     home: homedir2(),
     env: process.env,
     provider: env.provider,
-    model: preferences.model ?? env.model,
+    model: resolveModelChoice(preferences.model, env.model),
     ...env.dshExplicit ? { command: env.dshCommand, args: env.dshArgs } : {}
   };
   const ensure = await ensureAcpProfile(runtimeOptions);
@@ -671,7 +681,7 @@ async function buildAcpAgentAdapter(env, preferences) {
   return new AcpDshAdapter({
     launch,
     provider: env.provider,
-    model: preferences.model ?? env.model
+    model: resolveModelChoice(preferences.model, env.model)
   });
 }
 var AcpDshAdapter;
@@ -680,6 +690,7 @@ var init_acp_adapter = __esm({
     "use strict";
     init_acp_runtime();
     init_event_channel();
+    init_model_choice();
     AcpDshAdapter = class {
       id = "dsh-acp";
       displayName = "DeepSeek Harness (ACP)";
@@ -806,14 +817,14 @@ var init_acp_adapter = __esm({
             return;
           }
           if (response.usage) {
-            const usage3 = {
+            const usage4 = {
               type: "usage",
               ...typeof response.usage.inputTokens === "number" ? { inputTokens: response.usage.inputTokens } : {},
               ...typeof response.usage.outputTokens === "number" ? { outputTokens: response.usage.outputTokens } : {},
               ...typeof response.usage.cachedReadTokens === "number" ? { cacheReadTokens: response.usage.cachedReadTokens } : {},
               ...typeof response.usage.cachedWriteTokens === "number" ? { cacheWriteTokens: response.usage.cachedWriteTokens } : {}
             };
-            channel.push(usage3);
+            channel.push(usage4);
           }
         })().catch((error) => {
           if (!stopRequested.value) {
@@ -1463,7 +1474,7 @@ var DshProviderManager = class {
     try {
       catalogProviders = await this.catalog.listProviders();
     } catch (error) {
-      log.warn("model-catalog", "refresh-failed", {
+      log.info("model-catalog", "refresh-failed", {
         error: error instanceof Error ? error.message : String(error)
       });
     }
@@ -2242,11 +2253,11 @@ function translateToolResult(data) {
 }
 function translateAssistantMessage(data) {
   if (!isRecord3(data) || !isRecord3(data.usage)) return [];
-  const usage3 = data.usage;
-  const inputTokens = typeof usage3.inputTokens === "number" ? usage3.inputTokens : void 0;
-  const outputTokens = typeof usage3.outputTokens === "number" ? usage3.outputTokens : void 0;
-  const cacheReadTokens = typeof usage3.cacheReadTokens === "number" ? usage3.cacheReadTokens : void 0;
-  const cacheWriteTokens = typeof usage3.cacheWriteTokens === "number" ? usage3.cacheWriteTokens : void 0;
+  const usage4 = data.usage;
+  const inputTokens = typeof usage4.inputTokens === "number" ? usage4.inputTokens : void 0;
+  const outputTokens = typeof usage4.outputTokens === "number" ? usage4.outputTokens : void 0;
+  const cacheReadTokens = typeof usage4.cacheReadTokens === "number" ? usage4.cacheReadTokens : void 0;
+  const cacheWriteTokens = typeof usage4.cacheWriteTokens === "number" ? usage4.cacheWriteTokens : void 0;
   if (inputTokens === void 0 && outputTokens === void 0 && cacheReadTokens === void 0 && cacheWriteTokens === void 0) return [];
   return [
     {
@@ -3201,6 +3212,7 @@ var WebDshAdapter = class {
 };
 // src/adapters/index.ts
+init_model_choice();
 async function resolveAdapterRoute(input, source) {
   const provider = input.provider?.trim() || void 0;
   const model = input.model?.trim() || void 0;
@@ -3220,7 +3232,7 @@ async function resolveAdapterRoute(input, source) {
   return void 0;
 }
 async function buildAgentAdapter(env, preferences = { stopGraceMs: void 0, model: void 0 }) {
-  const configuredModel = preferences.model ?? env.model;
+  const configuredModel = resolveModelChoice(preferences.model, env.model);
   const managedRoute = env.adapterMode === "sdk" || env.adapterMode === "acp" ? await resolveAdapterRoute(
     { provider: env.provider, model: configuredModel },
     new DshProviderManager({ env: process.env })
@@ -3252,7 +3264,7 @@ async function buildAgentAdapter(env, preferences = { stopGraceMs: void 0, model
       return new WebDshAdapter({
         baseUrl: env.webBaseUrl,
         provider: env.provider,
-        model: preferences.model ?? env.model
+        model: resolveModelChoice(preferences.model, env.model)
       });
     }
     case "sdk":
@@ -3997,7 +4009,7 @@ var PermissionPolicyStore = class {
 // src/bot/notification-preference-store.ts
 import { readFile as readFile7 } from "fs/promises";
-var EVENTS = /* @__PURE__ */ new Set(["completed", "failed", "approval"]);
+var EVENTS = /* @__PURE__ */ new Set(["completed", "failed", "approval", "urgent"]);
 var NotificationPreferenceStore = class {
   constructor(path) {
     this.path = path;
@@ -4026,7 +4038,7 @@ var NotificationPreferenceStore = class {
   get(scope) {
     const value = this.data.scopes[scope];
     if (value === void 0 || value === false) return void 0;
-    return { ...value, events: [...value.events], mentionUserIds: [...value.mentionUserIds] };
+    return { ...value, events: [...value.events], mentionUserIds: [...value.mentionUserIds], sinks: [...value.sinks] };
   }
   resolve(scope, fallback) {
     const value = this.data.scopes[scope];
@@ -4071,6 +4083,7 @@ function normalizePreference(value) {
     ...typeof input.target === "string" && input.target.trim() ? { target: input.target.trim() } : {},
     events,
     mentionUserIds: [...new Set((input.mentionUserIds ?? []).filter((id) => typeof id === "string" && id.trim().length > 0).map((id) => id.trim()))],
+    sinks: [...new Set((input.sinks ?? []).filter((id) => typeof id === "string" && id.trim().length > 0).map((id) => id.trim()))],
     approvalReminderMs
   };
 }
@@ -4547,6 +4560,7 @@ function statusCardMarkdownFor(input, locale) {
     zh ? `\u{1F39A}\uFE0F **\u6267\u884C\u6A21\u5F0F**\uFF1A\`${input.executionMode ?? "balanced"}\`` : `\u{1F39A}\uFE0F **Execution mode**: \`${input.executionMode ?? "balanced"}\``,
     zh ? `\u{1F6E1}\uFE0F **\u5DE5\u5177\u6743\u9650**\uFF1A\`${input.permissionPolicy ?? "ask"}\`` : `\u{1F6E1}\uFE0F **Tool permission**: \`${input.permissionPolicy ?? "ask"}\``,
     ...input.notificationPreference ? [zh ? `\u{1F514} **\u4E3B\u52A8\u63D0\u9192**\uFF1A\`${input.notificationPreference.events.join(",")}\` \u2192 \`${input.notificationPreference.target ?? "current"}\`\uFF08\u5BA1\u6279 ${String(input.notificationPreference.approvalReminderMs / 6e4)} \u5206\u949F\uFF09` : `\u{1F514} **Notifications**: \`${input.notificationPreference.events.join(",")}\` \u2192 \`${input.notificationPreference.target ?? "current"}\` (approval ${String(input.notificationPreference.approvalReminderMs / 6e4)} min)`] : [zh ? "\u{1F515} **\u4E3B\u52A8\u63D0\u9192**\uFF1A\u5173\u95ED" : "\u{1F515} **Notifications**: off"],
+    ...input.notificationChannels && input.notificationChannels.length > 0 ? [zh ? `\u{1F4E4} **\u51FA\u7AD9\u6E20\u9053**\uFF1A\`${input.notificationChannels.join(",")}\`` : `\u{1F4E4} **Outbound channels**: \`${input.notificationChannels.join(",")}\``] : [],
     ...input.replyPolicy ? [zh ? `\u{1F4E8} **\u56DE\u590D\u7B56\u7565**\uFF1A${input.replyPolicyConfigured ? "\u81EA\u5B9A\u4E49" : "\u9ED8\u8BA4"} \xB7 \u5408\u5E76 ${String(input.replyPolicy.mergeWindowMs / 1e3)} \u79D2 \xB7 \u6BCF\u6279 ${String(input.replyPolicy.maxBatchSize)} \xB7 \u95F4\u9694 ${String(input.replyPolicy.minIntervalMs / 1e3)} \u79D2 \xB7 \u53BB\u91CD ${String(input.replyPolicy.dedupeWindowMs / 1e3)} \u79D2` : `\u{1F4E8} **Reply policy**: ${input.replyPolicyConfigured ? "custom" : "default"} \xB7 merge ${String(input.replyPolicy.mergeWindowMs / 1e3)}s \xB7 batch ${String(input.replyPolicy.maxBatchSize)} \xB7 interval ${String(input.replyPolicy.minIntervalMs / 1e3)}s \xB7 dedupe ${String(input.replyPolicy.dedupeWindowMs / 1e3)}s`] : [],
     ...input.role ? [`\u{1F3AD} **role**\uFF1A${input.role}`] : [],
     `\u{1F516} **version**\uFF1A\`${input.version}\``,
@@ -4963,8 +4977,8 @@ function renderStandard(state, now, locale, maxTools) {
   } else if (state.terminal === "done" && !hasAnswer(state)) {
     elements.push(noteMd(zh ? "_\uFF08\u672A\u8FD4\u56DE\u5185\u5BB9\uFF09_" : "_(No content returned)_"));
   } else if (state.terminal === "done") {
-    const usage3 = usageLine(state);
-    if (usage3) elements.push(noteMd(usage3));
+    const usage4 = usageLine(state);
+    if (usage4) elements.push(noteMd(usage4));
   }
   if (state.finalDeliveryError) {
     elements.push(finalDeliveryFailureLine(locale));
@@ -5030,8 +5044,8 @@ function renderDetailed(state, now, locale, maxTools) {
   } else if (state.terminal === "error") {
     elements.push(runFailureLine(locale));
   } else if (state.terminal === "done") {
-    const usage3 = usageLine(state);
-    if (usage3) elements.push(noteMd(usage3));
+    const usage4 = usageLine(state);
+    if (usage4) elements.push(noteMd(usage4));
     if (!hasAnswer(state)) elements.push(noteMd(zh ? "_\uFF08\u672A\u8FD4\u56DE\u5185\u5BB9\uFF09_" : "_(No content returned)_"));
   }
   if (state.finalDeliveryError) {
@@ -8054,7 +8068,7 @@ async function handleNotify(args, ctx) {
 }
 // src/commands/notifications.ts
-var ALL_EVENTS = ["completed", "failed", "approval"];
+var ALL_EVENTS = ["completed", "failed", "approval", "urgent"];
 async function reply5(ctx, zh, en) {
   await ctx.channel.sendMarkdown(ctx.chatId, bilingualMarkdown(zh, en), { replyTo: ctx.messageId });
 }
@@ -8092,6 +8106,7 @@ async function handleNotifications(args, ctx) {
   let events = [...ALL_EVENTS];
   let mentionUserIds = ctx.senderId ? [ctx.senderId] : [];
   let reminderMinutes = 10;
+  let sinks = [];
   for (const token of tokens.slice(1)) {
     if (token.startsWith("events=")) {
       const requested = token.slice(7).split(",").filter(Boolean);
@@ -8103,6 +8118,8 @@ async function handleNotifications(args, ctx) {
     } else if (token.startsWith("remind=")) {
       reminderMinutes = Number(token.slice(7));
       if (!Number.isInteger(reminderMinutes) || reminderMinutes < 1 || reminderMinutes > 1440) return usage(ctx);
+    } else if (token.startsWith("sinks=")) {
+      sinks = token.slice(6).split(",").map((id) => id.trim()).filter(Boolean);
     } else if (!target) {
       target = token === "current" ? void 0 : token;
     } else return usage(ctx);
@@ -8121,50 +8138,297 @@ async function handleNotifications(args, ctx) {
     ...target ? { target } : {},
     events,
     mentionUserIds: [...new Set(mentionUserIds)],
-    approvalReminderMs: reminderMinutes * 6e4
+    approvalReminderMs: reminderMinutes * 6e4,
+    sinks: [...new Set(sinks)]
   };
   await store.set(ctx.scope, value);
   await reply5(ctx, `\u5DF2\u5F00\u542F\u3002${describe(value, true)}`, `Enabled. ${describe(value, false)}`);
 }
 function describe(value, zh) {
   const minutes = value.approvalReminderMs / 6e4;
-  return zh ? `\u4E3B\u52A8\u63D0\u9192\uFF1A**\u5F00\u542F** \xB7 \u4E8B\u4EF6 \`${value.events.join(",")}\` \xB7 \u76EE\u6807 \`${value.target ?? "current"}\` \xB7 @ \`${value.mentionUserIds.join(",") || "none"}\` \xB7 \u5BA1\u6279\u63D0\u9192 ${String(minutes)} \u5206\u949F\u3002` : `Proactive notifications: **on** \xB7 events \`${value.events.join(",")}\` \xB7 target \`${value.target ?? "current"}\` \xB7 mentions \`${value.mentionUserIds.join(",") || "none"}\` \xB7 approval reminder ${String(minutes)} min.`;
+  const sinks = value.sinks.join(",") || "none";
+  return zh ? `\u4E3B\u52A8\u63D0\u9192\uFF1A**\u5F00\u542F** \xB7 \u4E8B\u4EF6 \`${value.events.join(",")}\` \xB7 \u76EE\u6807 \`${value.target ?? "current"}\` \xB7 @ \`${value.mentionUserIds.join(",") || "none"}\` \xB7 \u6E20\u9053 \`${sinks}\` \xB7 \u5BA1\u6279\u63D0\u9192 ${String(minutes)} \u5206\u949F\u3002` : `Proactive notifications: **on** \xB7 events \`${value.events.join(",")}\` \xB7 target \`${value.target ?? "current"}\` \xB7 mentions \`${value.mentionUserIds.join(",") || "none"}\` \xB7 channels \`${sinks}\` \xB7 approval reminder ${String(minutes)} min.`;
 }
 async function usage(ctx) {
   await reply5(
     ctx,
-    "\u7528\u6CD5\uFF1A`/notifications [show|off|default|on [current|scope|chatId] [events=completed,failed,approval] [mentions=self,ou_x|none] [remind=10]]`",
-    "Usage: `/notifications [show|off|default|on [current|scope|chatId] [events=completed,failed,approval] [mentions=self,ou_x|none] [remind=10]]`"
+    "\u7528\u6CD5\uFF1A`/notifications [show|off|default|on [current|scope|chatId] [events=completed,failed,approval,urgent] [mentions=self,ou_x|none] [sinks=channelId1,channelId2] [remind=10]]`",
+    "Usage: `/notifications [show|off|default|on [current|scope|chatId] [events=completed,failed,approval,urgent] [mentions=self,ou_x|none] [sinks=channelId1,channelId2] [remind=10]]`"
+  );
+}
+// src/notify/sinks/channel-store.ts
+import { readFile as readFile11 } from "fs/promises";
+var SINK_TYPES = ["telegram", "wecom"];
+var NotificationChannelStore = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  data = { schemaVersion: 1, channels: {} };
+  saving = Promise.resolve();
+  async load() {
+    try {
+      const parsed = JSON.parse(await readFile11(this.path, "utf8"));
+      const channels = {};
+      for (const [id, value] of Object.entries(parsed.channels ?? {})) {
+        const normalized = normalizeChannel(id, value);
+        if (normalized) channels[id] = normalized;
+      }
+      this.data = { schemaVersion: 1, channels };
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      this.data = { schemaVersion: 1, channels: {} };
+    }
+  }
+  list() {
+    return Object.values(this.data.channels).map((channel) => ({ ...channel }));
+  }
+  get(id) {
+    const channel = this.data.channels[id];
+    return channel ? { ...channel } : void 0;
+  }
+  async add(channel) {
+    const normalized = normalizeChannel(channel.id, channel);
+    if (!normalized) throw new Error("invalid notification channel");
+    await this.mutate(() => {
+      this.data.channels[normalized.id] = normalized;
+    });
+  }
+  async update(id, patch) {
+    const existing = this.data.channels[id];
+    if (!existing) return false;
+    const next = normalizeChannel(id, { ...existing, ...patch });
+    if (!next) return false;
+    await this.mutate(() => {
+      this.data.channels[id] = next;
+    });
+    return true;
+  }
+  async setEnabled(id, enabled) {
+    return this.update(id, { enabled });
+  }
+  async remove(id) {
+    const existing = this.data.channels[id];
+    if (!existing) return false;
+    await this.mutate(() => {
+      delete this.data.channels[id];
+    });
+    return true;
+  }
+  async flush() {
+    await this.saving;
+  }
+  async mutate(fn) {
+    const snapshot = JSON.stringify(this.data, null, 2) + "\n";
+    const previous = JSON.stringify(this.data);
+    fn();
+    this.saving = this.saving.then(async () => {
+      await writeFileAtomic(this.path, snapshot, { mode: 384 });
+    }).catch((error) => {
+      try {
+        this.data = JSON.parse(previous);
+      } catch {
+      }
+      log.fail("notification-channels", error, { step: "persist" });
+      throw error;
+    });
+    await this.saving;
+  }
+};
+function normalizeChannel(id, value) {
+  if (!value || typeof value !== "object" || !id.trim()) return void 0;
+  const input = value;
+  const type = input.type;
+  if (type !== "telegram" && type !== "wecom") return void 0;
+  const label2 = typeof input.label === "string" ? input.label.trim() : "";
+  const destination = typeof input.destination === "string" ? input.destination.trim() : "";
+  const secret = typeof input.secret === "string" ? input.secret.trim() : "";
+  if (!label2 || !destination || !secret) return void 0;
+  const mentionMap = {};
+  if (input.mentionMap && typeof input.mentionMap === "object") {
+    for (const [from, to] of Object.entries(input.mentionMap)) {
+      if (typeof to === "string" && to.trim()) mentionMap[from] = to.trim();
+    }
+  }
+  return {
+    id: id.trim(),
+    type,
+    label: label2,
+    destination,
+    secret,
+    enabled: input.enabled !== false,
+    ...Object.keys(mentionMap).length > 0 ? { mentionMap } : {}
+  };
+}
+// src/notify/sinks/types.ts
+var SINK_HTTP_TIMEOUT_MS = 1e4;
+function maskChannel(channel, includeId = true) {
+  const id = includeId ? `${channel.id} \xB7 ` : "";
+  const dest = maskSecret(channel.destination);
+  return `${id}${channel.type} \xB7 ${channel.label} \u2192 ${dest}`;
+}
+function maskSecret(value) {
+  if (!value) return "(unset)";
+  if (value.length <= 6) return `${value[0]}{redacted}`;
+  return `${value.slice(0, 3)}\u2026${value.slice(-3)}`;
+}
+// src/commands/channels.ts
+async function reply6(ctx, zh, en) {
+  await ctx.channel.sendMarkdown(ctx.chatId, bilingualMarkdown(zh, en), { replyTo: ctx.messageId });
+}
+function requireAdmin3(ctx) {
+  if (ctx.accessManager.isAdmin(ctx.senderId)) return true;
+  void reply6(ctx, "\u4EC5\u7BA1\u7406\u5458\u53EF\u7BA1\u7406\u901A\u77E5\u6E20\u9053\u3002", "Only admins can manage notification channels.");
+  return false;
+}
+async function handleChannels(args, ctx) {
+  if (!requireAdmin3(ctx)) return;
+  const store = ctx.notificationChannels;
+  if (!store) {
+    await reply6(ctx, "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u672A\u542F\u7528\u901A\u77E5\u6E20\u9053\u7BA1\u7406\u3002", "Notification channel management is unavailable in this runtime.");
+    return;
+  }
+  const [sub, ...rest] = args.trim().split(/\s+/);
+  switch (sub) {
+    case "list":
+      return listChannels(ctx, store);
+    case "show": {
+      const id = rest[0];
+      if (!id) return usage2(ctx);
+      const channel = store.get(id);
+      if (!channel) return notFound(ctx, id);
+      return showChannel(ctx, channel);
+    }
+    case "add":
+      return addChannel(ctx, store, rest.join(" "));
+    case "remove": {
+      const id = rest[0];
+      if (!id) return usage2(ctx);
+      const ok = await store.remove(id);
+      return ok ? reply6(ctx, `\u5DF2\u79FB\u9664\u901A\u77E5\u6E20\u9053 \`${id}\`\u3002`, `Removed notification channel \`${id}\`.`) : notFound(ctx, id);
+    }
+    case "enable":
+    case "disable": {
+      const id = rest[0];
+      if (!id) return usage2(ctx);
+      const enabled = sub === "enable";
+      const ok = await store.setEnabled(id, enabled);
+      if (!ok) return notFound(ctx, id);
+      return reply6(ctx, `\u5DF2${enabled ? "\u542F\u7528" : "\u505C\u7528"}\u901A\u77E5\u6E20\u9053 \`${id}\`\u3002`, `${enabled ? "Enabled" : "Disabled"} notification channel \`${id}\`.`);
+    }
+    default:
+      return usage2(ctx);
+  }
+}
+async function listChannels(ctx, store) {
+  const channels = store.list();
+  if (channels.length === 0) {
+    await reply6(ctx, "\u5C1A\u672A\u914D\u7F6E\u4EFB\u4F55\u901A\u77E5\u6E20\u9053\u3002\u7528 `/channels add telegram|wecom <label> --destination <\u76EE\u6807> --secret <\u5BC6\u94A5>` \u6DFB\u52A0\u3002", "No notification channels yet. Use `/channels add telegram|wecom <label> --destination <target> --secret <token>` to add one.");
+    return;
+  }
+  const lines = channels.map((channel) => `- ${channel.enabled ? "\u{1F7E2}" : "\u26AA\uFE0F"} \`${channel.id}\` \u2014 ${channel.type} \xB7 ${channel.label} \xB7 ${maskSecret(channel.destination)}`);
+  await reply6(ctx, ["**\u5DF2\u914D\u7F6E\u901A\u77E5\u6E20\u9053**", "", ...lines].join("\n"), ["**Configured notification channels**", "", ...lines].join("\n"));
+}
+async function showChannel(ctx, channel) {
+  const zh = `**${channel.id}**
+- \u7C7B\u578B\uFF1A\`${channel.type}\`
+- \u540D\u79F0\uFF1A${channel.label}
+- \u76EE\u6807\uFF1A\`${maskSecret(channel.destination)}\`
+- \u72B6\u6001\uFF1A${channel.enabled ? "\u542F\u7528" : "\u505C\u7528"}
+- \u5BC6\u94A5\uFF1A\`${maskSecret(channel.secret)}\``;
+  const en = `**${channel.id}**
+- Type: \`${channel.type}\`
+- Label: ${channel.label}
+- Target: \`${maskSecret(channel.destination)}\`
+- Status: ${channel.enabled ? "enabled" : "disabled"}
+- Secret: \`${maskSecret(channel.secret)}\``;
+  await reply6(ctx, zh, en);
+}
+async function addChannel(ctx, store, raw) {
+  const parsed = parseAddArgs(raw);
+  if (!parsed || !parsed.type || !parsed.label || !parsed.destination || !parsed.secret) {
+    await usage2(ctx);
+    return;
+  }
+  if (!SINK_TYPES.includes(parsed.type)) {
+    await reply6(ctx, `\u4E0D\u652F\u6301\u7684\u6E20\u9053\u7C7B\u578B\uFF1A\`${parsed.type}\`\u3002\u53EF\u7528\uFF1A\`${SINK_TYPES.join("|")}\`\u3002`, `Unsupported channel type: \`${parsed.type}\`. Available: \`${SINK_TYPES.join("|")}\`.`);
+    return;
+  }
+  const id = parsed.id ?? `${parsed.type}-${slugify(parsed.label)}`;
+  if (store.get(id)) {
+    await reply6(ctx, `\u901A\u77E5\u6E20\u9053 \`${id}\` \u5DF2\u5B58\u5728\u3002\u7528 \`/channels remove ${id}\` \u5220\u9664\u540E\u91CD\u5EFA\u3002`, `Notification channel \`${id}\` already exists. Remove it first with \`/channels remove ${id}\`.`);
+    return;
+  }
+  const channel = {
+    id,
+    type: parsed.type,
+    label: parsed.label,
+    destination: parsed.destination,
+    secret: parsed.secret,
+    enabled: true
+  };
+  await store.add(channel);
+  await reply6(ctx, `\u5DF2\u6DFB\u52A0\u901A\u77E5\u6E20\u9053 ${maskChannel(channel)}\u3002`, `Added notification channel ${maskChannel(channel)}.`);
+}
+async function notFound(ctx, id) {
+  await reply6(ctx, `\u672A\u627E\u5230\u901A\u77E5\u6E20\u9053 \`${id}\`\u3002\u7528 \`/channels list\` \u67E5\u770B\u3002`, `Unknown notification channel \`${id}\`. Use \`/channels list\`.`);
+}
+async function usage2(ctx) {
+  await reply6(
+    ctx,
+    "\u7528\u6CD5\uFF1A`/channels list|show <id>|add <telegram|wecom> <label> [--id <id>] --destination <\u76EE\u6807> --secret <\u5BC6\u94A5>|remove <id>|enable <id>|disable <id>`",
+    "Usage: `/channels list|show <id>|add <telegram|wecom> <label> [--id <id>] --destination <target> --secret <token>|remove <id>|enable <id>|disable <id>`"
   );
 }
+function parseAddArgs(raw) {
+  if (!raw.trim()) return void 0;
+  const idMatch = raw.match(/--id\s+(\S+)/);
+  const destMatch = raw.match(/--destination\s+(\S+)/);
+  const secretMatch = raw.match(/--secret\s+(\S+)/);
+  const positionals = raw.replace(/\s*--id\s+\S+/, " ").replace(/\s*--destination\s+\S+/, " ").replace(/\s*--secret\s+\S+/, " ").trim().split(/\s+/).filter(Boolean);
+  const [type, label2] = positionals;
+  return {
+    ...idMatch ? { id: idMatch[1] } : {},
+    ...type ? { type } : {},
+    ...label2 ? { label: label2 } : {},
+    ...destMatch ? { destination: destMatch[1] } : {},
+    ...secretMatch ? { secret: secretMatch[1] } : {}
+  };
+}
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "channel";
+}
 // src/commands/replies.ts
 async function handleReplies(args, ctx) {
   const store = ctx.replyPolicies;
-  if (!store) return reply6(ctx, "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u672A\u542F\u7528\u56DE\u590D\u7B56\u7565\u3002", "Reply policies are unavailable in this runtime.");
+  if (!store) return reply7(ctx, "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u672A\u542F\u7528\u56DE\u590D\u7B56\u7565\u3002", "Reply policies are unavailable in this runtime.");
   const tokens = args.trim().split(/\s+/).filter(Boolean);
-  if (tokens.length === 0 || tokens[0] === "show") return reply6(ctx, describe2(store.get(ctx.scope), store.isConfigured(ctx.scope), true), describe2(store.get(ctx.scope), store.isConfigured(ctx.scope), false));
-  if (!await canManageReplies(ctx)) return reply6(ctx, "\u4EC5 profile \u7BA1\u7406\u5458\u6216\u5F53\u524D\u7FA4\u7684\u7FA4\u4E3B/\u7FA4\u7BA1\u7406\u5458\u53EF\u4FEE\u6539\u56DE\u590D\u7B56\u7565\u3002", "Only profile admins or the current group owner/managers can change reply policies.");
+  if (tokens.length === 0 || tokens[0] === "show") return reply7(ctx, describe2(store.get(ctx.scope), store.isConfigured(ctx.scope), true), describe2(store.get(ctx.scope), store.isConfigured(ctx.scope), false));
+  if (!await canManageReplies(ctx)) return reply7(ctx, "\u4EC5 profile \u7BA1\u7406\u5458\u6216\u5F53\u524D\u7FA4\u7684\u7FA4\u4E3B/\u7FA4\u7BA1\u7406\u5458\u53EF\u4FEE\u6539\u56DE\u590D\u7B56\u7565\u3002", "Only profile admins or the current group owner/managers can change reply policies.");
   if (tokens[0] === "default") {
     await store.set(ctx.scope, void 0);
-    return reply6(ctx, "\u5DF2\u6062\u590D\u9ED8\u8BA4\u5373\u65F6\u56DE\u590D\u4E0E\u4EC5 messageId \u53BB\u91CD\u3002", "Restored immediate replies and message-ID-only deduplication.");
+    return reply7(ctx, "\u5DF2\u6062\u590D\u9ED8\u8BA4\u5373\u65F6\u56DE\u590D\u4E0E\u4EC5 messageId \u53BB\u91CD\u3002", "Restored immediate replies and message-ID-only deduplication.");
   }
-  if (tokens[0] !== "set") return usage2(ctx);
+  if (tokens[0] !== "set") return usage3(ctx);
   const policy = { ...store.get(ctx.scope) };
   for (const token of tokens.slice(1)) {
     const [key, raw, extra] = token.split("=");
-    if (!raw || extra !== void 0) return usage2(ctx);
+    if (!raw || extra !== void 0) return usage3(ctx);
     const seconds = Number(raw);
-    if (!Number.isInteger(seconds)) return usage2(ctx);
+    if (!Number.isInteger(seconds)) return usage3(ctx);
     if (key === "merge" && seconds >= 0 && seconds <= 300) policy.mergeWindowMs = seconds * 1e3;
     else if (key === "batch" && seconds >= 1 && seconds <= 20) policy.maxBatchSize = seconds;
     else if (key === "interval" && seconds >= 0 && seconds <= 3600) policy.minIntervalMs = seconds * 1e3;
     else if (key === "dedupe" && seconds >= 0 && seconds <= 3600) policy.dedupeWindowMs = seconds * 1e3;
-    else return usage2(ctx);
+    else return usage3(ctx);
   }
-  if (tokens.length === 1) return usage2(ctx);
+  if (tokens.length === 1) return usage3(ctx);
   await store.set(ctx.scope, policy);
-  await reply6(ctx, `\u5DF2\u8BBE\u7F6E\u3002${describe2(policy, true, true)}`, `Updated. ${describe2(policy, true, false)}`);
+  await reply7(ctx, `\u5DF2\u8BBE\u7F6E\u3002${describe2(policy, true, true)}`, `Updated. ${describe2(policy, true, false)}`);
 }
 async function canManageReplies(ctx) {
   if (ctx.accessManager.isAdmin(ctx.senderId)) return true;
@@ -8178,10 +8442,10 @@ async function canManageReplies(ctx) {
 function describe2(policy, configured, zh) {
   return zh ? `\u56DE\u590D\u7B56\u7565\uFF1A**${configured ? "\u81EA\u5B9A\u4E49" : "\u9ED8\u8BA4"}** \xB7 \u5408\u5E76 ${String(policy.mergeWindowMs / 1e3)} \u79D2 \xB7 \u6BCF\u6279 ${String(policy.maxBatchSize)} \u4E2A\u4EFB\u52A1 \xB7 \u95F4\u9694 ${String(policy.minIntervalMs / 1e3)} \u79D2 \xB7 \u8FD1\u4F3C\u53BB\u91CD ${String(policy.dedupeWindowMs / 1e3)} \u79D2\u3002` : `Reply policy: **${configured ? "custom" : "default"}** \xB7 merge ${String(policy.mergeWindowMs / 1e3)}s \xB7 ${String(policy.maxBatchSize)} tasks/batch \xB7 interval ${String(policy.minIntervalMs / 1e3)}s \xB7 near-dedupe ${String(policy.dedupeWindowMs / 1e3)}s.`;
 }
-async function usage2(ctx) {
-  await reply6(ctx, "\u7528\u6CD5\uFF1A`/replies [show|default|set merge=\u79D2 batch=\u6570\u91CF interval=\u79D2 dedupe=\u79D2]`", "Usage: `/replies [show|default|set merge=seconds batch=count interval=seconds dedupe=seconds]`");
+async function usage3(ctx) {
+  await reply7(ctx, "\u7528\u6CD5\uFF1A`/replies [show|default|set merge=\u79D2 batch=\u6570\u91CF interval=\u79D2 dedupe=\u79D2]`", "Usage: `/replies [show|default|set merge=seconds batch=count interval=seconds dedupe=seconds]`");
 }
-async function reply6(ctx, zh, en) {
+async function reply7(ctx, zh, en) {
   await ctx.channel.sendMarkdown(ctx.chatId, bilingualMarkdown(zh, en), { replyTo: ctx.messageId });
 }
@@ -8416,7 +8680,8 @@ var COMMAND_CATALOG = [
   { names: ["/isolation"], area: "policy", zh: "`[group|topic|member]` \u2014 \u7FA4\u4F1A\u8BDD\u9694\u79BB\uFF08\u8BBE\u7F6E\u9700\u7BA1\u7406\u5458\uFF09", en: "`[group|topic|member]` \u2014 group isolation (admin to set)" },
   { names: ["/role"], area: "configuration", zh: "`list|show|set|clear|save|remove \u2026` \u2014 \u7BA1\u7406\u89D2\u8272", en: "`list|show|set|clear|save|remove \u2026` \u2014 manage roles" },
   { names: ["/notify"], area: "communication", zh: "`<scope|chatId> <text>` / `list` \u2014 \u8DE8\u4F1A\u8BDD\u901A\u77E5\uFF08\u53D1\u9001\u9700\u7BA1\u7406\u5458\uFF09", en: "`<scope|chatId> <text>` / `list` \u2014 cross-session notification (admin to send)" },
-  { names: ["/notifications"], area: "communication", zh: "`[show|off|on \u2026]` \u2014 scope \u63D0\u9192\u7B56\u7565", en: "`[show|off|on \u2026]` \u2014 scope notification policy" },
+  { names: ["/notifications"], area: "communication", zh: "`[show|off|on \u2026]` \u2014 scope \u63D0\u9192\u7B56\u7565\uFF08\u652F\u6301 `sinks=`\uFF09", en: "`[show|off|on \u2026]` \u2014 scope notification policy (supports `sinks=`)" },
+  { names: ["/channels"], area: "configuration", zh: "`list|show|add|remove|enable|disable \u2026` \u2014 \u7BA1\u7406\u51FA\u7AD9\u901A\u77E5\u6E20\u9053\uFF08\u7BA1\u7406\u5458\uFF09", en: "`list|show|add|remove|enable|disable \u2026` \u2014 manage outbound notification channels (admin)" },
   { names: ["/replies"], area: "communication", zh: "`[show|default|set \u2026]` \u2014 \u56DE\u590D\u5408\u5E76\u3001\u9891\u7387\u4E0E\u53BB\u91CD", en: "`[show|default|set \u2026]` \u2014 reply batching, rate, and deduplication" },
   { names: ["/retention"], area: "session", zh: "`[N|default]` \u2014 \u4F1A\u8BDD\u4FDD\u7559\u6761\u6570", en: "`[N|default]` \u2014 retained live-message count" },
   { names: ["/archive"], area: "session", zh: "`[note]|send|list|clean \u2026` \u2014 \u7BA1\u7406\u5F52\u6863", en: "`[note]|send|list|clean \u2026` \u2014 manage archives" },
@@ -8499,6 +8764,7 @@ var HELP = [
   "- `/notify <scope|chatId> <text>` \u2014 \u8DE8\u4F1A\u8BDD\u53D1\u9001\u901A\u77E5\uFF08\u7BA1\u7406\u5458\uFF09",
   "- `/notify list` \u2014 \u67E5\u770B\u5DF2\u6CE8\u518C scope",
   "- `/notifications [show|off|on \u2026]` \u2014 \u914D\u7F6E\u5F53\u524D scope \u7684\u5B8C\u6210 / \u5931\u8D25 / \u5BA1\u6279\u63D0\u9192",
+  "- `/channels [list|show|add|remove|enable|disable \u2026]` \u2014 \u7BA1\u7406\u51FA\u7AD9\u901A\u77E5\u6E20\u9053\uFF08\u7BA1\u7406\u5458\uFF09\uFF0C\u8F6C\u53D1\u5230\u5FAE\u4FE1 / Telegram \u7B49",
   "- `/replies [show|default|set \u2026]` \u2014 \u914D\u7F6E\u56DE\u590D\u5408\u5E76\u3001\u9891\u7387\u4E0E\u8FD1\u4F3C\u53BB\u91CD\uFF08profile \u7BA1\u7406\u5458\u6216\u5F53\u524D\u7FA4\u7BA1\u7406\u5458\u53EF\u4FEE\u6539\uFF09",
   "- `/retention [N|default]` \u2014 \u67E5\u770B\u6216\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u4FDD\u7559\u6D88\u606F\u6761\u6570\uFF08\u8D85\u51FA\u81EA\u52A8\u5F52\u6863\uFF09",
   "- `/archive [note]`\u3001`/archive send <id> [scope|chatId]`\u3001`/archive list [N]`\u3001`/archive clean` \u2014 \u5F52\u6863\u5E76\u4E0A\u4F20 / \u91CD\u53D1\u6216\u8F6C\u53D1 / \u67E5\u770B / \u6E05\u7406",
@@ -8560,7 +8826,7 @@ var HELP_EN = [
   "- `/invite user|admin|group <id>` \u2014 manage access allowlists",
   "- `/help` \u2014 show this help"
 ].join("\n");
-async function reply7(ctx, zhCn, enUs) {
+async function reply8(ctx, zhCn, enUs) {
   await ctx.channel.sendMarkdown(ctx.chatId, enUs === void 0 ? zhCn : bilingualMarkdown(zhCn, enUs, ctx.languagePolicies?.get().plain), {
     replyTo: ctx.messageId
   });
@@ -8569,7 +8835,7 @@ async function handleNew(_args, ctx) {
   const cwd = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
   const interrupted = await ctx.activeRuns.interruptWorkspace(ctx.scope, cwd);
   ctx.sessions.clear(ctx.scope, cwd);
-  await reply7(
+  await reply8(
     ctx,
     interrupted > 0 ? `\u5DF2\u4E2D\u65AD ${String(interrupted)} \u4E2A\u4EFB\u52A1\u5E76\u5F00\u59CB\u65B0\u4F1A\u8BDD\u3002` : "\u5DF2\u5F00\u59CB\u65B0\u4F1A\u8BDD\u3002",
     interrupted > 0 ? `Interrupted ${String(interrupted)} task(s) and started a new session.` : "Started a new session."
@@ -8598,11 +8864,11 @@ function groupAppLink(chatId) {
 async function handleNewGroup(args, ctx) {
   const name2 = args.trim();
   if (!name2) {
-    await reply7(ctx, "\u7528\u6CD5\uFF1A`/newg <\u7FA4\u540D>` \u2014 \u81EA\u52A8\u65B0\u5EFA\u7FA4\u804A\u5E76\u5F00\u59CB\u65B0\u4F1A\u8BDD", "Usage: `/newg <name>` \u2014 create a group and start a new session");
+    await reply8(ctx, "\u7528\u6CD5\uFF1A`/newg <\u7FA4\u540D>` \u2014 \u81EA\u52A8\u65B0\u5EFA\u7FA4\u804A\u5E76\u5F00\u59CB\u65B0\u4F1A\u8BDD", "Usage: `/newg <name>` \u2014 create a group and start a new session");
     return;
   }
   if (name2.length > MAX_GROUP_NAME_LENGTH) {
-    await reply7(
+    await reply8(
       ctx,
       `\u7FA4\u540D\u8FC7\u957F\uFF08\u4E0A\u9650 ${String(MAX_GROUP_NAME_LENGTH)} \u5B57\u7B26\uFF0C\u5F53\u524D ${String(name2.length)}\uFF09\u3002`,
       `The group name is too long (limit ${String(MAX_GROUP_NAME_LENGTH)} characters; received ${String(name2.length)}).`
@@ -8610,11 +8876,11 @@ async function handleNewGroup(args, ctx) {
     return;
   }
   if (!ctx.channel.createChat) {
-    await reply7(ctx, "\u5F53\u524D\u6E20\u9053\u4E0D\u652F\u6301\u81EA\u52A8\u5EFA\u7FA4\u3002", "This channel cannot create groups automatically.");
+    await reply8(ctx, "\u5F53\u524D\u6E20\u9053\u4E0D\u652F\u6301\u81EA\u52A8\u5EFA\u7FA4\u3002", "This channel cannot create groups automatically.");
     return;
   }
   if (!ctx.senderId) {
-    await reply7(ctx, "\u65E0\u6CD5\u8BC6\u522B\u53D1\u9001\u8005 open_id\uFF0C\u4E0D\u80FD\u81EA\u52A8\u5EFA\u7FA4\u3002", "The sender open_id is unavailable, so the group cannot be created automatically.");
+    await reply8(ctx, "\u65E0\u6CD5\u8BC6\u522B\u53D1\u9001\u8005 open_id\uFF0C\u4E0D\u80FD\u81EA\u52A8\u5EFA\u7FA4\u3002", "The sender open_id is unavailable, so the group cannot be created automatically.");
     return;
   }
   try {
@@ -8625,7 +8891,7 @@ async function handleNewGroup(args, ctx) {
       inviteUserIds: [ctx.senderId],
       userIdType: "open_id"
     });
-    await reply7(
+    await reply8(
       ctx,
       [
         `\u2705 \u5DF2\u521B\u5EFA\u7FA4\u804A\uFF1A**${name2}**`,
@@ -8644,13 +8910,13 @@ async function handleNewGroup(args, ctx) {
     );
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    await reply7(ctx, `\u274C \u5EFA\u7FA4\u5931\u8D25\uFF1A\`${message}\``, `\u274C Failed to create the group: \`${message}\``);
+    await reply8(ctx, `\u274C \u5EFA\u7FA4\u5931\u8D25\uFF1A\`${message}\``, `\u274C Failed to create the group: \`${message}\``);
   }
 }
 async function handleCd(args, ctx) {
   const path = args.trim();
   if (!path) {
-    await reply7(ctx, "\u7528\u6CD5\uFF1A`/cd <path>`", "Usage: `/cd <path>`");
+    await reply8(ctx, "\u7528\u6CD5\uFF1A`/cd <path>`", "Usage: `/cd <path>`");
     return;
   }
   const normalized = path.replace(/^～/u, "~");
@@ -8658,13 +8924,13 @@ async function handleCd(args, ctx) {
   const cwd = resolve3(expanded);
   const target = await stat2(cwd).catch(() => void 0);
   if (!target?.isDirectory()) {
-    await reply7(ctx, `\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u76EE\u5F55\uFF1A\`${cwd}\`\u3002`, `The path does not exist or is not a directory: \`${cwd}\`.`);
+    await reply8(ctx, `\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u76EE\u5F55\uFF1A\`${cwd}\`\u3002`, `The path does not exist or is not a directory: \`${cwd}\`.`);
     return;
   }
   const previous = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
   const interrupted = cwd === previous ? 0 : await ctx.activeRuns.interruptWorkspace(ctx.scope, previous);
   ctx.workspaces.setCwd(ctx.scope, cwd);
-  await reply7(
+  await reply8(
     ctx,
     `\u5DF2\u5207\u6362\u5DE5\u4F5C\u76EE\u5F55\uFF1A\`${cwd}\`\uFF1B\u8BE5\u5DE5\u4F5C\u533A\u7684\u4F1A\u8BDD\u4F1A\u72EC\u7ACB\u6062\u590D\u3002${interrupted > 0 ? `\u5DF2\u4E2D\u65AD\u539F\u5DE5\u4F5C\u533A ${String(interrupted)} \u4E2A\u8FD0\u884C\u4E2D\u4EFB\u52A1\uFF08\u4F1A\u8BDD\u6570\u636E\u4FDD\u7559\uFF09\u3002` : ""}`,
     `Switched workspace to \`${cwd}\`; its independent session will resume.${interrupted > 0 ? ` Interrupted ${String(interrupted)} running task(s) in the previous workspace (session data was preserved).` : ""}`
@@ -8684,7 +8950,7 @@ async function handleWs(args, ctx) {
     const lines = Object.entries(named).map(
       ([key, value]) => `- **${key}** \u2192 \`${value}\`${value === current ? " \u2190 \u5F53\u524D" : ""}`
     );
-    await reply7(
+    await reply8(
       ctx,
       [
         `\u5F53\u524D cwd\uFF1A\`${current}\``,
@@ -8701,29 +8967,29 @@ async function handleWs(args, ctx) {
   }
   if (sub === "save") {
     if (!name2) {
-      await reply7(ctx, "\u7528\u6CD5\uFF1A`/ws save <name>`", "Usage: `/ws save <name>`");
+      await reply8(ctx, "\u7528\u6CD5\uFF1A`/ws save <name>`", "Usage: `/ws save <name>`");
       return;
     }
     const current = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
     ctx.workspaces.saveNamed(name2, current);
-    await reply7(ctx, `\u5DF2\u4FDD\u5B58\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name2}** \u2192 \`${current}\``, `Saved workspace: **${name2}** \u2192 \`${current}\``);
+    await reply8(ctx, `\u5DF2\u4FDD\u5B58\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name2}** \u2192 \`${current}\``, `Saved workspace: **${name2}** \u2192 \`${current}\``);
     return;
   }
   if (sub === "use") {
     if (!name2) {
-      await reply7(ctx, "\u7528\u6CD5\uFF1A`/ws use <name>`", "Usage: `/ws use <name>`");
+      await reply8(ctx, "\u7528\u6CD5\uFF1A`/ws use <name>`", "Usage: `/ws use <name>`");
       return;
     }
     const cwd = ctx.workspaces.getNamed(name2);
     if (!cwd) {
-      await reply7(ctx, `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name2}**`, `Workspace not found: **${name2}**`);
+      await reply8(ctx, `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name2}**`, `Workspace not found: **${name2}**`);
       return;
     }
     const previous = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
     const interrupted = cwd === previous ? 0 : await ctx.activeRuns.interruptWorkspace(ctx.scope, previous);
     ctx.workspaces.setCwd(ctx.scope, cwd);
     ctx.workspaces.touchNamed(name2);
-    await reply7(
+    await reply8(
       ctx,
       `\u5DF2\u5207\u6362\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name2}** \u2192 \`${cwd}\`\uFF1B\u8BE5\u5DE5\u4F5C\u533A\u7684\u4F1A\u8BDD\u4F1A\u72EC\u7ACB\u6062\u590D\u3002${interrupted > 0 ? `\u5DF2\u4E2D\u65AD\u539F\u5DE5\u4F5C\u533A ${String(interrupted)} \u4E2A\u8FD0\u884C\u4E2D\u4EFB\u52A1\uFF08\u4F1A\u8BDD\u6570\u636E\u4FDD\u7559\uFF09\u3002` : ""}`,
       `Switched to workspace **${name2}** \u2192 \`${cwd}\`; its independent session will resume.${interrupted > 0 ? ` Interrupted ${String(interrupted)} running task(s) in the previous workspace (session data was preserved).` : ""}`
@@ -8732,14 +8998,14 @@ async function handleWs(args, ctx) {
   }
   if (sub === "remove") {
     if (!name2) {
-      await reply7(ctx, "\u7528\u6CD5\uFF1A`/ws remove <name>`", "Usage: `/ws remove <name>`");
+      await reply8(ctx, "\u7528\u6CD5\uFF1A`/ws remove <name>`", "Usage: `/ws remove <name>`");
       return;
     }
     const removed = ctx.workspaces.removeNamed(name2);
-    await reply7(ctx, removed ? `\u5DF2\u5220\u9664\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name2}**` : `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name2}**`, removed ? `Removed workspace: **${name2}**` : `Workspace not found: **${name2}**`);
+    await reply8(ctx, removed ? `\u5DF2\u5220\u9664\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name2}**` : `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name2}**`, removed ? `Removed workspace: **${name2}**` : `Workspace not found: **${name2}**`);
     return;
   }
-  await reply7(ctx, "\u672A\u77E5 `/ws` \u5B50\u547D\u4EE4\uFF0C\u8BF7\u4F7F\u7528 list / save / use / remove\u3002", "Unknown `/ws` subcommand. Use list / save / use / remove.");
+  await reply8(ctx, "\u672A\u77E5 `/ws` \u5B50\u547D\u4EE4\uFF0C\u8BF7\u4F7F\u7528 list / save / use / remove\u3002", "Unknown `/ws` subcommand. Use list / save / use / remove.");
 }
 async function statusCardInputFor(ctx) {
   const cwd = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
@@ -8786,6 +9052,7 @@ async function statusCardInputFor(ctx) {
     permissionPolicy: ctx.permissionPolicies?.get(ctx.scope) ?? "ask",
     executionMode: ctx.executionModes?.get(ctx.scope) ?? "balanced",
     ...notificationPreference ? { notificationPreference } : {},
+    ...ctx.notificationSinks ? { notificationChannels: ctx.notificationSinks.enabledChannels().map((channel) => channel.id) } : {},
     ...replyPolicy ? { replyPolicy, replyPolicyConfigured: ctx.replyPolicies?.isConfigured(ctx.scope) ?? false } : {},
     role: role ? `\`${role.id}\` (${role.name})` : void 0,
     metrics,
@@ -8828,16 +9095,16 @@ async function handleStatus(_args, ctx) {
     } catch {
     }
   }
-  await reply7(ctx, bilingualMarkdown(statusCardMarkdown(input), statusCardMarkdownEnglish(input)));
+  await reply8(ctx, bilingualMarkdown(statusCardMarkdown(input), statusCardMarkdownEnglish(input)));
 }
 async function handleIsolation(args, ctx) {
   if (ctx.chatMode === "p2p") {
-    await reply7(ctx, "\u5F53\u524D\u662F\u79C1\u804A\uFF0Cscope \u5DF2\u6309\u4F1A\u8BDD\u5929\u7136\u9694\u79BB\uFF0C\u65E0\u9700\u8BBE\u7F6E\u3002", "This is a direct chat; its scope is already isolated, so no setting is needed.");
+    await reply8(ctx, "\u5F53\u524D\u662F\u79C1\u804A\uFF0Cscope \u5DF2\u6309\u4F1A\u8BDD\u5929\u7136\u9694\u79BB\uFF0C\u65E0\u9700\u8BBE\u7F6E\u3002", "This is a direct chat; its scope is already isolated, so no setting is needed.");
     return;
   }
   const mode = args.trim().toLowerCase();
   if (!mode) {
-    await reply7(
+    await reply8(
       ctx,
       `\u5F53\u524D\u7FA4\u4F1A\u8BDD\u9694\u79BB\u6A21\u5F0F\uFF1A**${ctx.isolationStore?.get(ctx.chatId) ?? "topic"}**\u3002\u53EF\u7528 \`/isolation group|topic|member\` \u5207\u6362\u3002`,
       `Current group isolation mode: **${ctx.isolationStore?.get(ctx.chatId) ?? "topic"}**. Use \`/isolation group|topic|member\` to switch.`
@@ -8845,16 +9112,16 @@ async function handleIsolation(args, ctx) {
     return;
   }
   if (mode !== "group" && mode !== "topic" && mode !== "member") {
-    await reply7(ctx, "\u7528\u6CD5\uFF1A`/isolation group|topic|member`", "Usage: `/isolation group|topic|member`");
+    await reply8(ctx, "\u7528\u6CD5\uFF1A`/isolation group|topic|member`", "Usage: `/isolation group|topic|member`");
     return;
   }
-  if (!requireAdmin3(ctx)) return;
+  if (!requireAdmin4(ctx)) return;
   if (!ctx.isolationStore) {
-    await reply7(ctx, "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u672A\u542F\u7528\u7FA4\u804A\u9694\u79BB\u7B56\u7565\u5B58\u50A8\u3002", "Group isolation policy storage is not enabled in this runtime.");
+    await reply8(ctx, "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u672A\u542F\u7528\u7FA4\u804A\u9694\u79BB\u7B56\u7565\u5B58\u50A8\u3002", "Group isolation policy storage is not enabled in this runtime.");
     return;
   }
   ctx.isolationStore.set(ctx.chatId, mode);
-  await reply7(
+  await reply8(
     ctx,
     `\u5DF2\u5C06\u672C\u7FA4\u9694\u79BB\u6A21\u5F0F\u8BBE\u4E3A **${mode}**\uFF0C\u4ECE\u4E0B\u4E00\u6761\u6D88\u606F\u8D77\u751F\u6548\u3002\u5DF2\u6709 group / topic / member scope \u4E0E\u4F1A\u8BDD\u6570\u636E\u5747\u4FDD\u7559\uFF0C\u5207\u56DE\u540E\u53EF\u7EE7\u7EED\u4F7F\u7528\u3002`,
     `Set this group\u2019s isolation mode to **${mode}**. It takes effect on the next message; existing group/topic/member scopes and session data are preserved.`
@@ -8881,25 +9148,25 @@ async function handleVersion(_args, ctx) {
     lines.push("\u6700\u65B0\u7248\u672C\u67E5\u8BE2\u6682\u4E0D\u53EF\u7528\uFF08\u7F51\u7EDC / registry \u5F02\u5E38\uFF09\u3002");
     english.push("Latest-version lookup is unavailable (network or registry error).");
   }
-  await reply7(ctx, lines.join("\n"), english.join("\n"));
+  await reply8(ctx, lines.join("\n"), english.join("\n"));
 }
 async function handleUpgrade(_args, ctx) {
-  if (!requireAdmin3(ctx)) return;
+  if (!requireAdmin4(ctx)) return;
   if (!ctx.senderId || !ctx.channelUpdates) {
-    await reply7(ctx, "\u5F53\u524D\u8FD0\u884C\u65B9\u5F0F\u4E0D\u652F\u6301\u98DE\u4E66\u5185\u66F4\u65B0\u3002", "In-chat updates are unavailable in this runtime.");
+    await reply8(ctx, "\u5F53\u524D\u8FD0\u884C\u65B9\u5F0F\u4E0D\u652F\u6301\u98DE\u4E66\u5185\u66F4\u65B0\u3002", "In-chat updates are unavailable in this runtime.");
     return;
   }
   const result = await ctx.channelUpdates.check({ scope: ctx.scope, actorId: ctx.senderId });
   if (result.kind === "unavailable") {
-    await reply7(ctx, "\u6682\u65F6\u65E0\u6CD5\u67E5\u8BE2 npm \u6700\u65B0\u7248\u672C\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", "The latest npm version is temporarily unavailable. Try again later.");
+    await reply8(ctx, "\u6682\u65F6\u65E0\u6CD5\u67E5\u8BE2 npm \u6700\u65B0\u7248\u672C\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", "The latest npm version is temporarily unavailable. Try again later.");
     return;
   }
   if (result.kind === "current") {
-    await reply7(ctx, `\u2705 \u5F53\u524D\u5DF2\u662F\u6700\u65B0\u7248\u672C\uFF1A\`${result.current}\`\u3002`, `\u2705 Already up to date: \`${result.current}\`.`);
+    await reply8(ctx, `\u2705 \u5F53\u524D\u5DF2\u662F\u6700\u65B0\u7248\u672C\uFF1A\`${result.current}\`\u3002`, `\u2705 Already up to date: \`${result.current}\`.`);
     return;
   }
   if (!ctx.channel.sendCard) {
-    await reply7(ctx, "\u5F53\u524D\u6E20\u9053\u65E0\u6CD5\u53D1\u9001\u66F4\u65B0\u786E\u8BA4\u5361\uFF0C\u672A\u6267\u884C\u4EFB\u4F55\u66F4\u65B0\u3002", "This channel cannot send an update confirmation card. Nothing was changed.");
+    await reply8(ctx, "\u5F53\u524D\u6E20\u9053\u65E0\u6CD5\u53D1\u9001\u66F4\u65B0\u786E\u8BA4\u5361\uFF0C\u672A\u6267\u884C\u4EFB\u4F55\u66F4\u65B0\u3002", "This channel cannot send an update confirmation card. Nothing was changed.");
     return;
   }
   await ctx.channel.sendCard(ctx.chatId, renderUpdateCard({
@@ -8914,9 +9181,9 @@ async function handleUpgrade(_args, ctx) {
   });
 }
 async function handleDoctor(_args, ctx) {
-  if (!requireAdmin3(ctx)) return;
+  if (!requireAdmin4(ctx)) return;
   if (!ctx.createDiagnosticBundle || !ctx.channel.sendFile) {
-    await reply7(ctx, "\u5F53\u524D\u6E20\u9053\u4E0D\u652F\u6301\u751F\u6210\u6216\u53D1\u9001\u8BCA\u65AD\u6587\u4EF6\u3002", "Diagnostic generation or file delivery is unavailable in this channel.");
+    await reply8(ctx, "\u5F53\u524D\u6E20\u9053\u4E0D\u652F\u6301\u751F\u6210\u6216\u53D1\u9001\u8BCA\u65AD\u6587\u4EF6\u3002", "Diagnostic generation or file delivery is unavailable in this channel.");
     return;
   }
   let file;
@@ -8933,7 +9200,7 @@ async function handleDoctor(_args, ctx) {
       ...status.jobs ? { jobs: status.jobs } : {}
     }), ctx.diagnosticTimeoutMs?.generate ?? DOCTOR_GENERATE_TIMEOUT_MS);
   } catch {
-    await reply7(
+    await reply8(
       ctx,
       "\u26A0\uFE0F \u8BCA\u65AD\u5305\u751F\u6210\u5931\u8D25\u3002\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF1B\u82E5\u6301\u7EED\u5931\u8D25\uFF0C\u8BF7\u5728\u672C\u673A\u8FD0\u884C `dsh-lark-bot doctor`\u3002",
       "\u26A0\uFE0F Failed to generate the diagnostic bundle. Retry later; if it keeps failing, run `dsh-lark-bot doctor` locally."
@@ -8947,21 +9214,21 @@ async function handleDoctor(_args, ctx) {
     }), ctx.diagnosticTimeoutMs?.upload ?? DOCTOR_UPLOAD_TIMEOUT_MS);
   } catch (error) {
     if (error instanceof OperationTimeoutError) {
-      await reply7(
+      await reply8(
         ctx,
         "\u26A0\uFE0F \u8BCA\u65AD\u5305\u4E0A\u4F20\u7B49\u5F85\u8D85\u65F6\uFF0C\u7ED3\u679C\u672A\u77E5\uFF1A\u6587\u4EF6\u4ECD\u53EF\u80FD\u7A0D\u540E\u5230\u8FBE\u3002\u8BF7\u5148\u68C0\u67E5\u5F53\u524D\u804A\u5929\uFF0C\u4E0D\u8981\u7ACB\u5373\u91CD\u8BD5\u3002",
         "\u26A0\uFE0F Diagnostic upload timed out with an unknown result: the file may still arrive later. Check this chat before retrying."
       );
       return;
     }
-    await reply7(
+    await reply8(
       ctx,
       "\u26A0\uFE0F \u8BCA\u65AD\u5305\u53D1\u9001\u5931\u8D25\u3002\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF1B\u82E5\u6301\u7EED\u5931\u8D25\uFF0C\u8BF7\u5728\u672C\u673A\u8FD0\u884C `dsh-lark-bot doctor`\u3002",
       "\u26A0\uFE0F Failed to send the diagnostic bundle. Retry later; if it keeps failing, run `dsh-lark-bot doctor` locally."
     );
     return;
   }
-  await reply7(
+  await reply8(
     ctx,
     "\u2705 \u8131\u654F\u8BCA\u65AD\u5305\u5DF2\u751F\u6210\u5E76\u53D1\u9001\uFF0C\u53EF\u76F4\u63A5\u4E0B\u8F7D\u8F6C\u53D1\u7ED9\u7EF4\u62A4\u8005\u3002",
     "\u2705 The redacted diagnostic bundle was generated and sent. You can download and forward it to a maintainer."
@@ -8971,18 +9238,18 @@ async function handleResume(_args, ctx) {
   const cwd = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
   const history = ctx.sessions.historyFor(ctx.scope, cwd);
   if (history.length === 0) {
-    await reply7(ctx, "\u5F53\u524D\u4F1A\u8BDD\u6CA1\u6709\u5386\u53F2\u4E0A\u4E0B\u6587\u3002", "This session has no conversation history.");
+    await reply8(ctx, "\u5F53\u524D\u4F1A\u8BDD\u6CA1\u6709\u5386\u53F2\u4E0A\u4E0B\u6587\u3002", "This session has no conversation history.");
     return;
   }
   const recent = history.slice(-6).map((message) => {
     const speaker = message.role === "user" ? "\u{1F464}" : "\u{1F916}";
     return `${speaker} ${message.content.slice(0, 300)}`;
   });
-  await reply7(ctx, [`\u5F53\u524D scope\uFF1A\`${ctx.scope}\``, "", ...recent].join("\n"), [`Current scope: \`${ctx.scope}\``, "", ...recent].join("\n"));
+  await reply8(ctx, [`\u5F53\u524D scope\uFF1A\`${ctx.scope}\``, "", ...recent].join("\n"), [`Current scope: \`${ctx.scope}\``, "", ...recent].join("\n"));
 }
 async function handleJobs(args, ctx) {
   if (!ctx.jobs) {
-    await reply7(ctx, "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u672A\u542F\u7528\u6301\u4E45\u4EFB\u52A1\u8D26\u672C\u3002", "The durable job ledger is not enabled in this runtime.");
+    await reply8(ctx, "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u672A\u542F\u7528\u6301\u4E45\u4EFB\u52A1\u8D26\u672C\u3002", "The durable job ledger is not enabled in this runtime.");
     return;
   }
   const cwd = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
@@ -8990,11 +9257,11 @@ async function handleJobs(args, ctx) {
   const records = ctx.jobs.list(ctx.scope, cwd, 20);
   if (sub === "retry") {
     if (!id) {
-      await reply7(ctx, "\u7528\u6CD5\uFF1A`/jobs retry <\u6D88\u606FID>`", "Usage: `/jobs retry <message-id>`");
+      await reply8(ctx, "\u7528\u6CD5\uFF1A`/jobs retry <\u6D88\u606FID>`", "Usage: `/jobs retry <message-id>`");
       return;
     }
     const queued = await ctx.requeueJob?.(id, ctx.scope, cwd);
-    await reply7(
+    await reply8(
       ctx,
       queued ? `\u267B\uFE0F \u5DF2\u5C06\u4EFB\u52A1 **${id}** \u91CD\u65B0\u5165\u961F\u3002\u91CD\u590D\u6267\u884C\u53EF\u80FD\u91CD\u590D\u5916\u90E8\u526F\u4F5C\u7528\uFF0C\u8BF7\u7559\u610F\u539F\u4EFB\u52A1 checkpoint\u3002` : `\u65E0\u6CD5\u91CD\u8BD5 **${id}**\uFF1A\u53EA\u5141\u8BB8\u91CD\u8BD5\u5F53\u524D workspace \u5185\u7684 failed / interrupted \u4EFB\u52A1\u3002`,
       queued ? `\u267B\uFE0F Requeued job **${id}**. Retrying may repeat external side effects; review the original checkpoint.` : `Cannot retry **${id}**: only failed or interrupted jobs in the current workspace are eligible.`
@@ -9004,19 +9271,19 @@ async function handleJobs(args, ctx) {
   if (sub === "show") {
     const record = id ? ctx.jobs.get(id, ctx.scope, cwd) : void 0;
     if (!record) {
-      await reply7(ctx, `\u5F53\u524D workspace \u672A\u627E\u5230\u4EFB\u52A1\uFF1A**${id ?? ""}**`, `Job not found in this workspace: **${id ?? ""}**`);
+      await reply8(ctx, `\u5F53\u524D workspace \u672A\u627E\u5230\u4EFB\u52A1\uFF1A**${id ?? ""}**`, `Job not found in this workspace: **${id ?? ""}**`);
       return;
     }
-    await reply7(ctx, jobDetail(record, "zh"), jobDetail(record, "en"));
+    await reply8(ctx, jobDetail(record, "zh"), jobDetail(record, "en"));
     return;
   }
   if (sub && sub !== "list") {
-    await reply7(ctx, "\u7528\u6CD5\uFF1A`/jobs [list|show <\u6D88\u606FID>|retry <\u6D88\u606FID>]`", "Usage: `/jobs [list|show <message-id>|retry <message-id>]`");
+    await reply8(ctx, "\u7528\u6CD5\uFF1A`/jobs [list|show <\u6D88\u606FID>|retry <\u6D88\u606FID>]`", "Usage: `/jobs [list|show <message-id>|retry <message-id>]`");
     return;
   }
   const counts = ctx.jobs.counts(ctx.scope, cwd);
   const rows = records.slice(0, 10);
-  await reply7(
+  await reply8(
     ctx,
     [
       "**\u4EFB\u52A1\u5BF9\u8D26**",
@@ -9063,7 +9330,7 @@ async function handleStop(_args, ctx) {
   });
   let stopped = 0;
   for (const scope of scopes) stopped += await ctx.activeRuns.interrupt(scope);
-  await reply7(
+  await reply8(
     ctx,
     stopped > 0 ? `\u5DF2\u8BF7\u6C42\u7EC8\u6B62\u5F53\u524D\u53CA\u5207\u6362\u524D\u9694\u79BB scope \u7684\u5168\u90E8 ${String(stopped)} \u4E2A\u4EFB\u52A1\u3002` : "\u5F53\u524D\u53CA\u5207\u6362\u524D\u9694\u79BB scope \u5747\u6CA1\u6709\u8FD0\u884C\u4E2D\u7684\u4EFB\u52A1\u3002",
     stopped > 0 ? `Requested termination of all ${String(stopped)} task(s) in the current and previously selected isolation scopes.` : "No tasks are running in the current or previously selected isolation scopes."
@@ -9074,7 +9341,7 @@ async function handleTimeout(args, ctx) {
   const effectiveMs = ctx.runPolicies.get(ctx.scope) ?? ctx.defaultRunTimeoutMs;
   if (!input) {
     const minutes2 = effectiveMs > 0 ? Math.round(effectiveMs / 6e4) : 0;
-    await reply7(
+    await reply8(
       ctx,
       minutes2 > 0 ? `\u5F53\u524D\u4F1A\u8BDD\u7A7A\u95F2\u8D85\u65F6\uFF1A\u6301\u7EED\u65E0\u6D3B\u52A8\u4E8B\u4EF6 ${minutes2} \u5206\u949F\u624D\u7EC8\u6B62\u3002\u53EF\u7528 \`/timeout <N|off|default>\` \u8C03\u6574\u3002` : "\u5F53\u524D\u4F1A\u8BDD\u7A7A\u95F2\u8D85\u65F6\uFF1A\u5173\u95ED\u3002",
       minutes2 > 0 ? `Session idle timeout: stop after ${minutes2} minutes without activity events. Use \`/timeout <N|off|default>\` to change it.` : "Session idle timeout: off."
@@ -9083,27 +9350,27 @@ async function handleTimeout(args, ctx) {
   }
   if (input === "off") {
     ctx.runPolicies.set(ctx.scope, 0);
-    await reply7(ctx, "\u5DF2\u5173\u95ED\u5F53\u524D\u4F1A\u8BDD\u7A7A\u95F2\u8D85\u65F6\u3002", "Disabled the session idle timeout.");
+    await reply8(ctx, "\u5DF2\u5173\u95ED\u5F53\u524D\u4F1A\u8BDD\u7A7A\u95F2\u8D85\u65F6\u3002", "Disabled the session idle timeout.");
     return;
   }
   if (input === "default") {
     ctx.runPolicies.clear(ctx.scope);
-    await reply7(ctx, "\u5DF2\u6062\u590D\u9ED8\u8BA4\u7A7A\u95F2\u8D85\u65F6\u3002", "Restored the default idle timeout.");
+    await reply8(ctx, "\u5DF2\u6062\u590D\u9ED8\u8BA4\u7A7A\u95F2\u8D85\u65F6\u3002", "Restored the default idle timeout.");
     return;
   }
   const minutes = Number(input);
   if (!Number.isInteger(minutes) || minutes <= 0) {
-    await reply7(ctx, "\u7528\u6CD5\uFF1A`/timeout <N|off|default>`\uFF0CN \u4E3A\u5927\u4E8E 0 \u7684\u5206\u949F\u6570\u3002", "Usage: `/timeout <N|off|default>`, where N is a positive number of minutes.");
+    await reply8(ctx, "\u7528\u6CD5\uFF1A`/timeout <N|off|default>`\uFF0CN \u4E3A\u5927\u4E8E 0 \u7684\u5206\u949F\u6570\u3002", "Usage: `/timeout <N|off|default>`, where N is a positive number of minutes.");
     return;
   }
   ctx.runPolicies.set(ctx.scope, minutes * 6e4);
-  await reply7(ctx, `\u5DF2\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u7A7A\u95F2\u8D85\u65F6\uFF1A\u6301\u7EED\u65E0\u6D3B\u52A8\u4E8B\u4EF6 ${minutes} \u5206\u949F\u624D\u7EC8\u6B62\u3002`, `Set the session idle timeout to ${minutes} minutes without activity events.`);
+  await reply8(ctx, `\u5DF2\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u7A7A\u95F2\u8D85\u65F6\uFF1A\u6301\u7EED\u65E0\u6D3B\u52A8\u4E8B\u4EF6 ${minutes} \u5206\u949F\u624D\u7EC8\u6B62\u3002`, `Set the session idle timeout to ${minutes} minutes without activity events.`);
 }
 async function handleConcurrency(args, ctx) {
   const input = args.trim();
   const effective = ctx.concurrencyStore.get(ctx.scope) ?? ctx.defaultScopeConcurrency;
   if (!input) {
-    await reply7(
+    await reply8(
       ctx,
       `\u5F53\u524D scope \u7684\u5E76\u884C\u4EFB\u52A1\u6570\uFF1A**${String(effective)}**\u3002\u53EF\u7528 \`/concurrency <N|default>\` \u8C03\u6574\uFF08N \u2265 1\uFF09\u3002`,
       `Parallel tasks for this scope: **${String(effective)}**. Use \`/concurrency <N|default>\` to change it (N \u2265 1).`
@@ -9112,16 +9379,16 @@ async function handleConcurrency(args, ctx) {
   }
   if (input === "default") {
     ctx.concurrencyStore.clear(ctx.scope);
-    await reply7(ctx, `\u5DF2\u6062\u590D\u9ED8\u8BA4\u5E76\u884C\u4EFB\u52A1\u6570\uFF08${String(ctx.defaultScopeConcurrency)}\uFF09\u3002`, `Restored the default parallel-task limit (${String(ctx.defaultScopeConcurrency)}).`);
+    await reply8(ctx, `\u5DF2\u6062\u590D\u9ED8\u8BA4\u5E76\u884C\u4EFB\u52A1\u6570\uFF08${String(ctx.defaultScopeConcurrency)}\uFF09\u3002`, `Restored the default parallel-task limit (${String(ctx.defaultScopeConcurrency)}).`);
     return;
   }
   const n = Number(input);
   if (!Number.isInteger(n) || n < 1) {
-    await reply7(ctx, "\u7528\u6CD5\uFF1A`/concurrency <N|default>`\uFF0CN \u4E3A\u5927\u4E8E\u7B49\u4E8E 1 \u7684\u6574\u6570\u3002", "Usage: `/concurrency <N|default>`, where N is an integer of at least 1.");
+    await reply8(ctx, "\u7528\u6CD5\uFF1A`/concurrency <N|default>`\uFF0CN \u4E3A\u5927\u4E8E\u7B49\u4E8E 1 \u7684\u6574\u6570\u3002", "Usage: `/concurrency <N|default>`, where N is an integer of at least 1.");
     return;
   }
   ctx.concurrencyStore.set(ctx.scope, n);
-  await reply7(ctx, `\u5DF2\u8BBE\u7F6E\u5F53\u524D scope \u7684\u5E76\u884C\u4EFB\u52A1\u6570\uFF1A**${String(n)}**\u3002`, `Set parallel tasks for this scope to **${String(n)}**.`);
+  await reply8(ctx, `\u5DF2\u8BBE\u7F6E\u5F53\u524D scope \u7684\u5E76\u884C\u4EFB\u52A1\u6570\uFF1A**${String(n)}**\u3002`, `Set parallel tasks for this scope to **${String(n)}**.`);
 }
 async function handlePermission(args, ctx) {
   const [rawPolicy = "", rawTarget = "", ...extra] = args.trim().split(/\s+/);
@@ -9133,7 +9400,7 @@ async function handlePermission(args, ctx) {
   };
   if (!input) {
     const current = ctx.permissionPolicies?.get(ctx.scope) ?? "ask";
-    await reply7(
+    await reply8(
       ctx,
       `\u5F53\u524D scope \u7684\u5DE5\u5177\u6743\u9650\u7B56\u7565\uFF1A**${labels[current].zh}**\uFF08\`${current}\`\uFF09\u3002\u53EF\u7528 \`/permission ask|allow|deny\` \u8C03\u6574\uFF08\u4EC5\u7BA1\u7406\u5458\uFF09\u3002`,
       `Tool permission policy for this scope: **${labels[current].en}** (\`${current}\`). Use \`/permission ask|allow|deny\` to change it (admin only).`
@@ -9141,21 +9408,21 @@ async function handlePermission(args, ctx) {
     return;
   }
   if (input !== "ask" && input !== "allow" && input !== "deny" || extra.length > 0) {
-    await reply7(ctx, "\u7528\u6CD5\uFF1A`/permission [ask|allow|deny] [scope]`", "Usage: `/permission [ask|allow|deny] [scope]`");
+    await reply8(ctx, "\u7528\u6CD5\uFF1A`/permission [ask|allow|deny] [scope]`", "Usage: `/permission [ask|allow|deny] [scope]`");
     return;
   }
-  if (!requireAdmin3(ctx)) return;
+  if (!requireAdmin4(ctx)) return;
   if (!ctx.permissionPolicies) {
-    await reply7(ctx, "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u672A\u542F\u7528\u5DE5\u5177\u6743\u9650\u7B56\u7565\u5B58\u50A8\u3002", "Tool permission policy storage is not enabled in this runtime.");
+    await reply8(ctx, "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u672A\u542F\u7528\u5DE5\u5177\u6743\u9650\u7B56\u7565\u5B58\u50A8\u3002", "Tool permission policy storage is not enabled in this runtime.");
     return;
   }
   const targetScope = rawTarget || ctx.scope;
   if (targetScope !== ctx.chatId && !targetScope.startsWith(`${ctx.chatId}:`)) {
-    await reply7(ctx, "\u53EA\u80FD\u4FEE\u6539\u5F53\u524D\u804A\u5929\u5185\u7684 scope\u3002\u8BF7\u4ECE\u76EE\u6807\u4F1A\u8BDD `/status` \u590D\u5236\u5B8C\u6574 scope\u3002", "You can only modify a scope in the current chat. Copy the full scope from the target session\u2019s `/status`.");
+    await reply8(ctx, "\u53EA\u80FD\u4FEE\u6539\u5F53\u524D\u804A\u5929\u5185\u7684 scope\u3002\u8BF7\u4ECE\u76EE\u6807\u4F1A\u8BDD `/status` \u590D\u5236\u5B8C\u6574 scope\u3002", "You can only modify a scope in the current chat. Copy the full scope from the target session\u2019s `/status`.");
     return;
   }
   await ctx.permissionPolicies.set(targetScope, input);
-  await reply7(
+  await reply8(
     ctx,
     `\u5DF2\u5C06 scope \`${targetScope}\` \u7684\u5DE5\u5177\u6743\u9650\u7B56\u7565\u8BBE\u4E3A **${labels[input].zh}**\uFF08\`${input}\`\uFF09\uFF0C\u4ECE\u4E0B\u4E00\u6B21\u5DE5\u5177\u5BA1\u6279\u8D77\u751F\u6548\u3002\u8BA1\u5212\u5BA1\u6279\u4ECD\u4F1A\u7167\u5E38\u6267\u884C\u3002`,
     `Set scope \`${targetScope}\`'s tool permission policy to **${labels[input].en}** (\`${input}\`). It applies to the next tool approval; plan approval remains enforced.`
@@ -9165,7 +9432,7 @@ async function handleDensity(args, ctx) {
   const input = args.trim().toLowerCase();
   if (!input) {
     const current = ctx.densityStore?.get(ctx.scope) ?? "standard";
-    await reply7(
+    await reply8(
       ctx,
       `\u5F53\u524D\u5361\u7247\u5BC6\u5EA6\uFF1A**${current}**\u3002\u53EF\u7528 \`/density compact|standard|detailed\` \u8C03\u6574\u3002`,
       `Current card density: **${current}**. Use \`/density compact|standard|detailed\` to change it.`
@@ -9174,21 +9441,21 @@ async function handleDensity(args, ctx) {
   }
   if (input === "default") {
     ctx.densityStore?.clear(ctx.scope);
-    await reply7(ctx, "\u5DF2\u6062\u590D\u9ED8\u8BA4\u5361\u7247\u5BC6\u5EA6\u3002", "Restored the default card density.");
+    await reply8(ctx, "\u5DF2\u6062\u590D\u9ED8\u8BA4\u5361\u7247\u5BC6\u5EA6\u3002", "Restored the default card density.");
     return;
   }
   const density = parseCardDensity(input);
   if (!density) {
-    await reply7(ctx, "\u7528\u6CD5\uFF1A`/density [compact|standard|detailed|default]`", "Usage: `/density [compact|standard|detailed|default]`");
+    await reply8(ctx, "\u7528\u6CD5\uFF1A`/density [compact|standard|detailed|default]`", "Usage: `/density [compact|standard|detailed|default]`");
     return;
   }
   ctx.densityStore?.set(ctx.scope, density);
-  await reply7(ctx, `\u5DF2\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u5361\u7247\u5BC6\u5EA6\uFF1A**${density}**\u3002`, `Set this session\u2019s card density to **${density}**.`);
+  await reply8(ctx, `\u5DF2\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u5361\u7247\u5BC6\u5EA6\uFF1A**${density}**\u3002`, `Set this session\u2019s card density to **${density}**.`);
 }
 async function handleExecutionMode(args, ctx) {
   const input = args.trim().toLowerCase();
   if (!ctx.executionModes) {
-    await reply7(ctx, "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u672A\u542F\u7528\u6267\u884C\u6A21\u5F0F\u5B58\u50A8\u3002", "Execution mode storage is unavailable in this runtime.");
+    await reply8(ctx, "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u672A\u542F\u7528\u6267\u884C\u6A21\u5F0F\u5B58\u50A8\u3002", "Execution mode storage is unavailable in this runtime.");
     return;
   }
   if (!input) {
@@ -9205,7 +9472,7 @@ async function handleExecutionMode(args, ctx) {
       } catch {
       }
     }
-    await reply7(
+    await reply8(
       ctx,
       `\u5F53\u524D\u6267\u884C\u6A21\u5F0F\uFF1A**${current}**\u3002\u53EF\u7528 \`/mode quick|balanced|deep\` \u5207\u6362\uFF1B\u4E0B\u4E00\u8F6E\u751F\u6548\u3002`,
       `Current execution mode: **${current}**. Use \`/mode quick|balanced|deep\`; changes apply next turn.`
@@ -9213,18 +9480,18 @@ async function handleExecutionMode(args, ctx) {
     return;
   }
   if (input !== "quick" && input !== "balanced" && input !== "deep") {
-    await reply7(ctx, "\u7528\u6CD5\uFF1A`/mode [quick|balanced|deep]`", "Usage: `/mode [quick|balanced|deep]`");
+    await reply8(ctx, "\u7528\u6CD5\uFF1A`/mode [quick|balanced|deep]`", "Usage: `/mode [quick|balanced|deep]`");
     return;
   }
   await ctx.executionModes.set(ctx.scope, input);
-  await reply7(
+  await reply8(
     ctx,
     `\u5DF2\u5C06\u5F53\u524D\u4F1A\u8BDD\u6267\u884C\u6A21\u5F0F\u8BBE\u4E3A **${input}**\uFF0C\u4ECE\u4E0B\u4E00\u8F6E\u751F\u6548\uFF1B\u6B63\u5728\u8FD0\u884C\u7684\u4EFB\u52A1\u4E0E\u73B0\u6709\u4E0A\u4E0B\u6587\u4E0D\u53D7\u5F71\u54CD\u3002`,
     `Set this session\u2019s execution mode to **${input}** for the next turn. Active work and existing context are unchanged.`
   );
 }
 async function handleEffortAlias(args, ctx) {
-  await reply7(
+  await reply8(
     ctx,
     "`/effort` \u662F `/mode` \u7684\u517C\u5BB9\u522B\u540D\uFF0C\u53EA\u63A7\u5236\u4EFB\u52A1\u6267\u884C\u5F3A\u5EA6\uFF1B\u6A21\u578B\u63A8\u7406\u6863\u4F4D\u7531\u6A21\u578B\u9002\u914D\u5668\u51B3\u5B9A\u3002",
     "`/effort` is a compatibility alias for `/mode`; it controls task execution intensity, not the model reasoning-effort setting."
@@ -9234,11 +9501,11 @@ async function handleEffortAlias(args, ctx) {
 async function handleAsk(args, ctx) {
   const question = args.trim();
   if (!question) {
-    await reply7(ctx, "\u7528\u6CD5\uFF1A`/ask <\u95EE\u9898>`", "Usage: `/ask <question>`");
+    await reply8(ctx, "\u7528\u6CD5\uFF1A`/ask <\u95EE\u9898>`", "Usage: `/ask <question>`");
     return;
   }
   if (!ctx.questions) {
-    await reply7(ctx, "\u95EE\u7B54\u5361\u672A\u542F\u7528\uFF08\u8BF7\u786E\u8BA4 questions \u5DF2\u63A5\u7EBF\uFF09\u3002", "Question cards are disabled (check the questions integration).");
+    await reply8(ctx, "\u95EE\u7B54\u5361\u672A\u542F\u7528\uFF08\u8BF7\u786E\u8BA4 questions \u5DF2\u63A5\u7EBF\uFF09\u3002", "Question cards are disabled (check the questions integration).");
     return;
   }
   const cwd = ctx.workspaces.cwdFor(ctx.scope) ?? ctx.defaultWorkspace;
@@ -9260,18 +9527,18 @@ async function handleAsk(args, ctx) {
   if (answer !== void 0) {
     const text = Array.isArray(answer) ? answer.join("\u3001") : answer;
     ctx.sessions.recordExchange(ctx.scope, cwd, [text], void 0);
-    await reply7(ctx, "\u5DF2\u8BB0\u5F55\u4F60\u7684\u56DE\u7B54\uFF0C\u5E76\u5199\u5165\u4F1A\u8BDD\u4E0A\u4E0B\u6587\u3002", "Recorded your answer in the session context.");
+    await reply8(ctx, "\u5DF2\u8BB0\u5F55\u4F60\u7684\u56DE\u7B54\uFF0C\u5E76\u5199\u5165\u4F1A\u8BDD\u4E0A\u4E0B\u6587\u3002", "Recorded your answer in the session context.");
   } else {
-    await reply7(ctx, "\u672A\u6536\u5230\u56DE\u7B54\uFF08\u5361\u7247\u53EF\u80FD\u5DF2\u8D85\u65F6\u6216\u88AB\u5FFD\u7565\uFF09\u3002", "No answer was received (the card may have expired or been ignored).");
+    await reply8(ctx, "\u672A\u6536\u5230\u56DE\u7B54\uFF08\u5361\u7247\u53EF\u80FD\u5DF2\u8D85\u65F6\u6216\u88AB\u5FFD\u7565\uFF09\u3002", "No answer was received (the card may have expired or been ignored).");
   }
 }
 async function handleInvite(args, ctx) {
   const [kind, ...rest] = args.trim().split(/\s+/);
   const id = rest.join(" ").trim();
-  if (kind !== "list" && !requireAdmin3(ctx)) return;
+  if (kind !== "list" && !requireAdmin4(ctx)) return;
   if (kind === "list") {
     const snapshot = ctx.accessManager.snapshot();
-    await reply7(
+    await reply8(
       ctx,
       [
         "**\u8BBF\u95EE\u767D\u540D\u5355**",
@@ -9289,7 +9556,7 @@ async function handleInvite(args, ctx) {
     return;
   }
   if (!kind || !id) {
-    await reply7(
+    await reply8(
       ctx,
       "\u7528\u6CD5\uFF1A`/invite user|admin|group <id>`\u3001`/invite list`\u3001`/invite remove user|group <id>`",
       "Usage: `/invite user|admin|group <id>`, `/invite list`, or `/invite remove user|group <id>`"
@@ -9298,39 +9565,39 @@ async function handleInvite(args, ctx) {
   }
   if (kind === "user") {
     await ctx.accessManager.addUser(id);
-    await reply7(ctx, `\u5DF2\u5141\u8BB8\u7528\u6237\uFF1A\`${id}\``, `Allowed user: \`${id}\``);
+    await reply8(ctx, `\u5DF2\u5141\u8BB8\u7528\u6237\uFF1A\`${id}\``, `Allowed user: \`${id}\``);
     return;
   }
   if (kind === "admin") {
     await ctx.accessManager.addAdmin(id);
-    await reply7(ctx, `\u5DF2\u8BBE\u4E3A\u7BA1\u7406\u5458\uFF1A\`${id}\``, `Granted admin access to: \`${id}\``);
+    await reply8(ctx, `\u5DF2\u8BBE\u4E3A\u7BA1\u7406\u5458\uFF1A\`${id}\``, `Granted admin access to: \`${id}\``);
     return;
   }
   if (kind === "group") {
     await ctx.accessManager.addChat(id);
-    await reply7(ctx, `\u5DF2\u5141\u8BB8\u7FA4\u804A\uFF1A\`${id}\``, `Allowed group chat: \`${id}\``);
+    await reply8(ctx, `\u5DF2\u5141\u8BB8\u7FA4\u804A\uFF1A\`${id}\``, `Allowed group chat: \`${id}\``);
     return;
   }
   if (kind === "remove") {
     const [sub, target] = rest;
     if (sub === "user" && target) {
       await ctx.accessManager.removeUser(target);
-      await reply7(ctx, `\u5DF2\u79FB\u9664\u7528\u6237\uFF1A\`${target}\``, `Removed user: \`${target}\``);
+      await reply8(ctx, `\u5DF2\u79FB\u9664\u7528\u6237\uFF1A\`${target}\``, `Removed user: \`${target}\``);
       return;
     }
     if (sub === "group" && target) {
       await ctx.accessManager.removeChat(target);
-      await reply7(ctx, `\u5DF2\u79FB\u9664\u7FA4\u804A\uFF1A\`${target}\``, `Removed group chat: \`${target}\``);
+      await reply8(ctx, `\u5DF2\u79FB\u9664\u7FA4\u804A\uFF1A\`${target}\``, `Removed group chat: \`${target}\``);
       return;
     }
-    await reply7(ctx, "\u7528\u6CD5\uFF1A`/invite remove user <id>` \u6216 `/invite remove group <chatId>`", "Usage: `/invite remove user <id>` or `/invite remove group <chatId>`");
+    await reply8(ctx, "\u7528\u6CD5\uFF1A`/invite remove user <id>` \u6216 `/invite remove group <chatId>`", "Usage: `/invite remove user <id>` or `/invite remove group <chatId>`");
     return;
   }
-  await reply7(ctx, "\u672A\u77E5 `/invite` \u7C7B\u578B\uFF0C\u8BF7\u4F7F\u7528 user / admin / group / list / remove\u3002", "Unknown `/invite` type. Use user / admin / group / list / remove.");
+  await reply8(ctx, "\u672A\u77E5 `/invite` \u7C7B\u578B\uFF0C\u8BF7\u4F7F\u7528 user / admin / group / list / remove\u3002", "Unknown `/invite` type. Use user / admin / group / list / remove.");
 }
-function requireAdmin3(ctx) {
+function requireAdmin4(ctx) {
   if (!ctx.accessManager.isAdmin(ctx.senderId)) {
-    void reply7(ctx, "\u4EC5\u7BA1\u7406\u5458\u53EF\u6267\u884C\u8BE5\u64CD\u4F5C\u3002", "Only admins can perform this operation.");
+    void reply8(ctx, "\u4EC5\u7BA1\u7406\u5458\u53EF\u6267\u884C\u8BE5\u64CD\u4F5C\u3002", "Only admins can perform this operation.");
     return false;
   }
   return true;
@@ -9383,20 +9650,20 @@ async function handleKeyDispatch(args, ctx) {
   await handleKey(args, ctx);
 }
 async function handleHelp(_args, ctx) {
-  await reply7(ctx, renderCommandHelp("zh"), renderCommandHelp("en"));
+  await reply8(ctx, renderCommandHelp("zh"), renderCommandHelp("en"));
 }
 async function handleLanguage(args, ctx) {
   if (!ctx.languagePolicies) {
-    await reply7(ctx, "\u5F53\u524D\u8FD0\u884C\u65F6\u672A\u542F\u7528\u8BED\u8A00\u7B56\u7565\u3002", "Language policy is unavailable in this runtime.");
+    await reply8(ctx, "\u5F53\u524D\u8FD0\u884C\u65F6\u672A\u542F\u7528\u8BED\u8A00\u7B56\u7565\u3002", "Language policy is unavailable in this runtime.");
     return;
   }
   const [action = "show", field, value] = args.trim().split(/\s+/);
   if (action === "show") {
     const policy = ctx.languagePolicies.get();
-    await reply7(ctx, `\u8BED\u8A00\u7B56\u7565\uFF1AUI=\u6309\u67E5\u770B\u8005\uFF1B\u666E\u901A\u6587\u672C=${policy.plain}\uFF1BAgent=${policy.agent}`, `Language policy: UI=per viewer; plain=${policy.plain}; agent=${policy.agent}`);
+    await reply8(ctx, `\u8BED\u8A00\u7B56\u7565\uFF1AUI=\u6309\u67E5\u770B\u8005\uFF1B\u666E\u901A\u6587\u672C=${policy.plain}\uFF1BAgent=${policy.agent}`, `Language policy: UI=per viewer; plain=${policy.plain}; agent=${policy.agent}`);
     return;
   }
-  if (!requireAdmin3(ctx)) return;
+  if (!requireAdmin4(ctx)) return;
   if (action === "set" && field === "plain" && (value === "bilingual" || value === "zh" || value === "en")) {
     await ctx.languagePolicies.set({ plain: value });
   } else if (action === "set" && field === "agent" && (value === "auto" || value === "zh" || value === "en")) {
@@ -9404,7 +9671,7 @@ async function handleLanguage(args, ctx) {
   } else if (action === "reset" && (field === void 0 || field === "all" || field === "plain" || field === "agent")) {
     await ctx.languagePolicies.reset(field ?? "all");
   } else {
-    await reply7(ctx, "\u7528\u6CD5\uFF1A`/language show|set plain <bilingual|zh|en>|set agent <auto|zh|en>|reset [plain|agent|all]`", "Usage: `/language show|set plain <bilingual|zh|en>|set agent <auto|zh|en>|reset [plain|agent|all]`");
+    await reply8(ctx, "\u7528\u6CD5\uFF1A`/language show|set plain <bilingual|zh|en>|set agent <auto|zh|en>|reset [plain|agent|all]`", "Usage: `/language show|set plain <bilingual|zh|en>|set agent <auto|zh|en>|reset [plain|agent|all]`");
     return;
   }
   process.env.DSH_LARK_REPLY_LANG = ctx.languagePolicies.get().plain;
@@ -9415,37 +9682,37 @@ function parseSecretTarget(value) {
 }
 async function handleSecret(args, ctx) {
   if (!ctx.secretService) {
-    await reply7(ctx, "\u5F53\u524D\u8FD0\u884C\u65F6\u672A\u542F\u7528\u5B89\u5168\u5BC6\u94A5\u91C7\u96C6\u3002", "Secure secret collection is unavailable in this runtime.");
+    await reply8(ctx, "\u5F53\u524D\u8FD0\u884C\u65F6\u672A\u542F\u7528\u5B89\u5168\u5BC6\u94A5\u91C7\u96C6\u3002", "Secure secret collection is unavailable in this runtime.");
     return;
   }
   const [action, targetRaw, referenceRaw, ...purposeParts] = args.trim().split(/\s+/);
   const target = parseSecretTarget(targetRaw);
   const reference = referenceRaw?.trim();
   if (!target || !reference || !["status", "set", "remove"].includes(action ?? "")) {
-    await reply7(ctx, "\u7528\u6CD5\uFF1A`/secret status|set|remove <dsh-credential|app-secret> <\u5F15\u7528>`", "Usage: `/secret status|set|remove <dsh-credential|app-secret> <reference>`");
+    await reply8(ctx, "\u7528\u6CD5\uFF1A`/secret status|set|remove <dsh-credential|app-secret> <\u5F15\u7528>`", "Usage: `/secret status|set|remove <dsh-credential|app-secret> <reference>`");
     return;
   }
-  if (action !== "status" && !requireAdmin3(ctx)) return;
+  if (action !== "status" && !requireAdmin4(ctx)) return;
   if (action === "status") {
     const configured = await ctx.secretService.configured(target, reference);
-    await reply7(ctx, `${target} \`${reference}\`\uFF1A${configured ? "\u5DF2\u914D\u7F6E" : "\u672A\u914D\u7F6E"}`, `${target} \`${reference}\`: ${configured ? "configured" : "not configured"}`);
+    await reply8(ctx, `${target} \`${reference}\`\uFF1A${configured ? "\u5DF2\u914D\u7F6E" : "\u672A\u914D\u7F6E"}`, `${target} \`${reference}\`: ${configured ? "configured" : "not configured"}`);
     return;
   }
   if (action === "remove") {
     const removed = await ctx.secretService.remove(target, reference);
-    await reply7(ctx, removed ? "\u2705 \u5BC6\u94A5\u5DF2\u5220\u9664\u3002" : "\u8BE5\u5F15\u7528\u672A\u914D\u7F6E\u5BC6\u94A5\u3002", removed ? "\u2705 Secret removed." : "No secret is configured for that reference.");
+    await reply8(ctx, removed ? "\u2705 \u5BC6\u94A5\u5DF2\u5220\u9664\u3002" : "\u8BE5\u5F15\u7528\u672A\u914D\u7F6E\u5BC6\u94A5\u3002", removed ? "\u2705 Secret removed." : "No secret is configured for that reference.");
     return;
   }
   if (!ctx.senderId) {
-    await reply7(ctx, "\u65E0\u6CD5\u8BC6\u522B\u64CD\u4F5C\u8005\uFF0C\u4E0D\u80FD\u6253\u5F00\u5B89\u5168\u8868\u5355\u3002", "The operator cannot be identified, so the secure form cannot be opened.");
+    await reply8(ctx, "\u65E0\u6CD5\u8BC6\u522B\u64CD\u4F5C\u8005\uFF0C\u4E0D\u80FD\u6253\u5F00\u5B89\u5168\u8868\u5355\u3002", "The operator cannot be identified, so the secure form cannot be opened.");
     return;
   }
   await ctx.secretService.request({ scope: ctx.scope, chatId: ctx.chatId, ...ctx.threadId ? { threadId: ctx.threadId } : {}, ownerId: ctx.senderId, target, reference, purpose: purposeParts.join(" ") || "Configure a protected value" });
-  await reply7(ctx, "\u5DF2\u53D1\u9001\u4EC5\u9650\u4F60\u63D0\u4EA4\u7684\u5B89\u5168\u8868\u5355\uFF1B\u8BF7\u52FF\u5728\u666E\u901A\u6D88\u606F\u4E2D\u7C98\u8D34\u5BC6\u94A5\u3002", "A secure owner-only form was sent. Do not paste the secret into ordinary chat.");
+  await reply8(ctx, "\u5DF2\u53D1\u9001\u4EC5\u9650\u4F60\u63D0\u4EA4\u7684\u5B89\u5168\u8868\u5355\uFF1B\u8BF7\u52FF\u5728\u666E\u901A\u6D88\u606F\u4E2D\u7C98\u8D34\u5BC6\u94A5\u3002", "A secure owner-only form was sent. Do not paste the secret into ordinary chat.");
 }
 async function handleSessionProjection(args, ctx) {
   if (!ctx.sessionProjection) {
-    await reply7(
+    await reply8(
       ctx,
       "\u5F53\u524D adapter \u672A\u63D0\u4F9B DSH session \u6295\u5F71\uFF1B\u8BF7\u4F7F\u7528 `web` adapter \u5E76\u786E\u8BA4 Web host \u53EF\u7528\u3002",
       "The current adapter does not provide DSH session projection; use the `web` adapter and ensure the Web host is reachable."
@@ -9475,6 +9742,7 @@ var handlers = {
   "/role": handleRole,
   "/notify": handleNotify,
   "/notifications": handleNotifications,
+  "/channels": handleChannels,
   "/replies": handleReplies,
   "/retention": handleRetention,
   "/archive": handleArchive,
@@ -9954,24 +10222,26 @@ var GroupMessagePoller = class {
 // src/bridge/reconnect-notifier.ts
 var ReconnectNotifier = class {
-  constructor(channel, directory, now = Date.now, reconciliation) {
+  constructor(channel, directory, now = Date.now, reconciliation, onFault) {
     this.channel = channel;
     this.directory = directory;
     this.now = now;
     this.reconciliation = reconciliation;
+    this.onFault = onFault;
   }
   channel;
   directory;
   now;
   reconciliation;
+  onFault;
   startedAt;
   async reconnecting() {
     if (this.startedAt !== void 0) return;
     this.startedAt = this.now();
-    await this.send(
-      "\u26A0\uFE0F \u673A\u5668\u4EBA\u8FDE\u63A5\u4E0D\u7A33\u5B9A\uFF0C\u6B63\u5728\u81EA\u52A8\u91CD\u8FDE\uFF1B\u671F\u95F4\u7684\u65B0\u6D88\u606F\u53EF\u80FD\u5EF6\u8FDF\u5904\u7406\u3002",
-      "\u26A0\uFE0F The bot connection is unstable and reconnecting automatically. New messages may be delayed."
-    );
+    const zhCn = "\u26A0\uFE0F \u673A\u5668\u4EBA\u8FDE\u63A5\u4E0D\u7A33\u5B9A\uFF0C\u6B63\u5728\u81EA\u52A8\u91CD\u8FDE\uFF1B\u671F\u95F4\u7684\u65B0\u6D88\u606F\u53EF\u80FD\u5EF6\u8FDF\u5904\u7406\u3002";
+    const enUs = "\u26A0\uFE0F The bot connection is unstable and reconnecting automatically. New messages may be delayed.";
+    await this.send(zhCn, enUs);
+    await this.fault(this.directory?.recentDestination()?.scope, { zh: zhCn, en: enUs });
   }
   async reconnected() {
     if (this.startedAt === void 0) return;
@@ -9979,12 +10249,12 @@ var ReconnectNotifier = class {
     this.startedAt = void 0;
     const target = this.directory?.recentDestination();
     const summary = target ? this.reconciliation?.(target.scope) : void 0;
-    await this.send(
-      `\u2705 \u673A\u5668\u4EBA\u8FDE\u63A5\u5DF2\u6062\u590D\uFF08\u4E2D\u65AD\u7EA6 ${formatDuration(elapsed)}\uFF09\u3002${summary ? `
-${summary.zhCn}` : ""}`,
-      `\u2705 The bot connection recovered after about ${formatDurationEnglish(elapsed)}.${summary ? `
-${summary.enUs}` : ""}`
-    );
+    const zhCn = `\u2705 \u673A\u5668\u4EBA\u8FDE\u63A5\u5DF2\u6062\u590D\uFF08\u4E2D\u65AD\u7EA6 ${formatDuration(elapsed)}\uFF09\u3002${summary ? `
+${summary.zhCn}` : ""}`;
+    const enUs = `\u2705 The bot connection recovered after about ${formatDurationEnglish(elapsed)}.${summary ? `
+${summary.enUs}` : ""}`;
+    await this.send(zhCn, enUs);
+    await this.fault(target?.scope, { zh: zhCn, en: enUs });
   }
   async send(zhCn, enUs) {
     const target = this.directory?.recentDestination();
@@ -9994,6 +10264,13 @@ ${summary.enUs}` : ""}`
       ...target.threadId ? { threadId: target.threadId } : {}
     });
   }
+  async fault(scope, title) {
+    if (!scope || !this.onFault) return;
+    try {
+      await this.onFault(scope, title);
+    } catch (error) {
+    }
+  }
 };
 function formatDurationEnglish(ms) {
   if (ms < 1e3) return "less than 1 second";
@@ -11196,7 +11473,8 @@ async function startChannel(deps) {
         zhCn: `\u8D26\u672C\u5BF9\u8D26\uFF1Aqueued ${counts.queued} \xB7 running ${counts.running} \xB7 interrupted ${counts.interrupted} \xB7 failed ${counts.failed}\uFF1B\u8BE6\u60C5\u89C1 \`/jobs\`\u3002`,
         enUs: `Ledger reconciliation: queued ${counts.queued} \xB7 running ${counts.running} \xB7 interrupted ${counts.interrupted} \xB7 failed ${counts.failed}; use \`/jobs\` for details.`
       };
-    } : void 0
+    } : void 0,
+    deps.faultNotifier
   );
   const isolationStore = deps.isolationStore ?? EMPTY_ISOLATION_STORE;
   let groupPoller;
@@ -11331,6 +11609,8 @@ async function startChannel(deps) {
       ...deps.permissionPolicies ? { permissionPolicies: deps.permissionPolicies } : {},
       ...deps.notificationPreferences ? { notificationPreferences: deps.notificationPreferences } : {},
       ...deps.defaultNotificationPreference ? { defaultNotificationPreference: deps.defaultNotificationPreference } : {},
+      ...deps.notificationChannels ? { notificationChannels: deps.notificationChannels } : {},
+      ...deps.notificationSinks ? { notificationSinks: deps.notificationSinks } : {},
       ...deps.replyPolicies ? { replyPolicies: deps.replyPolicies } : {},
       ...deps.executionModes ? { executionModes: deps.executionModes } : {},
       ...deps.languagePolicies ? { languagePolicies: deps.languagePolicies } : {},
@@ -12053,7 +12333,7 @@ function attachRunCardAnchors(channel, anchors) {
 }
 // src/bridge/scope-directory.ts
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 var ScopeDirectory = class {
   data = { entries: {} };
   saving = Promise.resolve();
@@ -12063,7 +12343,7 @@ var ScopeDirectory = class {
   }
   async load() {
     try {
-      const raw = await readFile11(this.path, "utf8");
+      const raw = await readFile12(this.path, "utf8");
       const parsed = JSON.parse(raw);
       this.data = { entries: parsed.entries ?? {} };
     } catch (error) {
@@ -12804,6 +13084,11 @@ var NotificationDispatcher = class {
   setDefaultPreference(preference) {
     this.defaultPreference = clonePreference(preference);
   }
+  /**
+   * Primary notification path: send to Feishu (default first-class route) and,
+   * when the scope preference lists extra channels, fan out to those sinks.
+   * Returns `false` when the event is disabled or no Feishu destination exists.
+   */
   async notify(scope, event, detail) {
     const preference = this.deps.preferences.resolve(scope, this.defaultPreference);
     if (!preference?.events.includes(event)) return false;
@@ -12812,21 +13097,52 @@ var NotificationDispatcher = class {
       log.warn("notification", "target-unavailable", { scope, target: preference.target });
       return false;
     }
-    const title = event === "completed" ? ["\u2705 \u4EFB\u52A1\u5DF2\u5B8C\u6210", "\u2705 Task completed"] : event === "failed" ? ["\u26A0\uFE0F \u4EFB\u52A1\u6267\u884C\u5931\u8D25", "\u26A0\uFE0F Task failed"] : ["\u23F3 \u4EFB\u52A1\u4ECD\u5728\u7B49\u5F85\u64CD\u4F5C\u5BA1\u6279", "\u23F3 Task is still waiting for tool approval"];
+    const title = titleForEvent(event);
     try {
-      await this.deps.send(destination.chatId, bilingualMarkdown(
-        `${title[0]}\uFF08scope \`${scope}\`\uFF09${detail ? `\uFF1A${detail}` : ""}`,
-        `${title[1]} (scope \`${scope}\`)${detail ? `: ${detail}` : ""}`
-      ), {
+      await this.deps.send(destination.chatId, renderFeishuBody(title, scope, detail), {
         ...destination.threadId ? { threadId: destination.threadId } : {},
         ...destination.messageId ? { replyTo: destination.messageId } : {},
         ...preference.mentionUserIds.length > 0 ? { mentions: preference.mentionUserIds.map((userId) => ({ userId })) } : {}
       });
-      return true;
     } catch (error) {
       log.warn("notification", "send-failed", { scope, event, error });
       return false;
     }
+    if (preference.sinks.length > 0) {
+      await this.broadcastSinks(preference.sinks, scope, event, title, detail);
+    }
+    return true;
+  }
+  /**
+   * Safety-net / fault class notification (issue #113): broadcast to every
+   * enabled outbound sink regardless of the per-scope opt-in, so a crash /
+   * reconnect / heartbeat anomaly is seen even when a scope has not enabled
+   * proactive Feishu reminders. When the scope preference explicitly enables
+   * the `urgent` event it is also sent to Feishu.
+   */
+  async notifyUrgent(scope, title, detail) {
+    const channels = this.deps.sinks?.enabledChannels() ?? [];
+    if (channels.length > 0) {
+      await this.broadcastSinks(
+        channels.map((channel) => channel.id),
+        scope,
+        "urgent",
+        title,
+        detail
+      );
+    }
+    const preference = this.deps.preferences.resolve(scope, this.defaultPreference);
+    if (!preference?.events.includes("urgent")) return;
+    const destination = preference.target ? this.deps.scopeDirectory.resolve(preference.target) ?? this.deps.scopeDirectory.resolveChat(preference.target) : this.deps.scopeDirectory.resolve(scope);
+    if (!destination) return;
+    try {
+      await this.deps.send(destination.chatId, renderFeishuBody(title, scope, detail), {
+        ...destination.threadId ? { threadId: destination.threadId } : {},
+        ...destination.messageId ? { replyTo: destination.messageId } : {}
+      });
+    } catch (error) {
+      log.warn("notification", "urgent-send-failed", { scope, error });
+    }
   }
   scheduleApprovalReminder(scope, toolName) {
     const preference = this.deps.preferences.resolve(scope, this.defaultPreference);
@@ -12837,11 +13153,197 @@ var NotificationDispatcher = class {
     timer.unref?.();
     return () => clearTimeout(timer);
   }
+  async broadcastSinks(channelIds, scope, event, title, detail) {
+    if (!this.deps.sinks || channelIds.length === 0) return;
+    try {
+      const outcome = await this.deps.sinks.broadcast(channelIds, {
+        scope,
+        event,
+        title,
+        ...detail === void 0 ? {} : { detail }
+      });
+      if (outcome.failures.length > 0) {
+        log.warn("notification", "sink-failures", { scope, event, failures: outcome.failures });
+      }
+    } catch (error) {
+      log.warn("notification", "sink-broadcast-error", { scope, event, error });
+    }
+  }
 };
+function titleForEvent(event) {
+  switch (event) {
+    case "completed":
+      return { zh: "\u2705 \u4EFB\u52A1\u5DF2\u5B8C\u6210", en: "\u2705 Task completed" };
+    case "failed":
+      return { zh: "\u26A0\uFE0F \u4EFB\u52A1\u6267\u884C\u5931\u8D25", en: "\u26A0\uFE0F Task failed" };
+    case "approval":
+      return { zh: "\u23F3 \u4EFB\u52A1\u4ECD\u5728\u7B49\u5F85\u64CD\u4F5C\u5BA1\u6279", en: "\u23F3 Task is still waiting for tool approval" };
+    case "urgent":
+      return { zh: "\u{1F534} \u7A81\u53D1 / \u6545\u969C", en: "\u{1F534} Urgent / fault" };
+  }
+}
+function renderFeishuBody(title, scope, detail) {
+  return bilingualMarkdown(
+    `${title.zh}\uFF08scope \`${scope}\`\uFF09${detail ? `\uFF1A${detail}` : ""}`,
+    `${title.en} (scope \`${scope}\`)${detail ? `: ${detail}` : ""}`
+  );
+}
 function clonePreference(preference) {
-  return preference ? { ...preference, events: [...preference.events], mentionUserIds: [...preference.mentionUserIds] } : void 0;
+  return preference ? { ...preference, events: [...preference.events], mentionUserIds: [...preference.mentionUserIds], sinks: [...preference.sinks] } : void 0;
 }
+// src/notify/sinks/http.ts
+async function postJson(url, body3) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), SINK_HTTP_TIMEOUT_MS);
+  timer.unref?.();
+  try {
+    return await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: body3,
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+// src/notify/sinks/text.ts
+function renderSinkText(message) {
+  const zhLine = `${message.title.zh}\uFF08scope \`${message.scope}\`\uFF09${message.detail ? `\uFF1A${message.detail}` : ""}`;
+  const enLine = `${message.title.en} (scope \`${message.scope}\`)${message.detail ? `: ${message.detail}` : ""}`;
+  return `${stripMarkdown(zhLine)}
+${stripMarkdown(enLine)}`;
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function stripMarkdown(value) {
+  return value.replaceAll("`", "").replaceAll("**", "").replaceAll("*", "");
+}
+// src/notify/sinks/telegram.ts
+var TelegramSink = class {
+  constructor(baseUrl = "https://api.telegram.org") {
+    this.baseUrl = baseUrl;
+  }
+  baseUrl;
+  type = "telegram";
+  async send(channel, message) {
+    const token = channel.secret;
+    if (!token) {
+      log.warn("sink:telegram", "missing-token", { channel: channel.id });
+      return false;
+    }
+    const url = `${this.baseUrl}/bot${encodeURIComponent(token)}/sendMessage`;
+    const body3 = JSON.stringify({
+      chat_id: channel.destination,
+      text: escapeHtml(renderSinkText(message)),
+      parse_mode: "HTML",
+      disable_web_page_preview: true
+    });
+    try {
+      const response = await postJson(url, body3);
+      const payload = await response.json();
+      if (!response.ok || payload.ok !== true) {
+        log.warn("sink:telegram", "send-failed", {
+          channel: channel.id,
+          error: payload.description ?? `http ${response.status}`
+        });
+        return false;
+      }
+      return true;
+    } catch (error) {
+      log.warn("sink:telegram", "send-error", { channel: channel.id, error });
+      return false;
+    }
+  }
+};
+// src/notify/sinks/wecom.ts
+var WeComSink = class {
+  constructor(baseUrl = "https://qyapi.weixin.qq.com") {
+    this.baseUrl = baseUrl;
+  }
+  baseUrl;
+  type = "wecom";
+  async send(channel, message) {
+    const key = channel.destination;
+    if (!key) {
+      log.warn("sink:wecom", "missing-key", { channel: channel.id });
+      return false;
+    }
+    const url = `${this.baseUrl}/cgi-bin/webhook/send?key=${encodeURIComponent(key)}`;
+    const body3 = JSON.stringify({
+      msgtype: "text",
+      text: { content: renderSinkText(message) }
+    });
+    try {
+      const response = await postJson(url, body3);
+      const payload = await response.json();
+      if (!response.ok || payload.errcode !== 0) {
+        log.warn("sink:wecom", "send-failed", {
+          channel: channel.id,
+          error: payload.errmsg ?? `http ${response.status}`
+        });
+        return false;
+      }
+      return true;
+    } catch (error) {
+      log.warn("sink:wecom", "send-error", { channel: channel.id, error });
+      return false;
+    }
+  }
+};
+// src/notify/sinks/registry.ts
+var OutboundSinkRegistry = class {
+  constructor(store, sinks = [new TelegramSink(), new WeComSink()]) {
+    this.store = store;
+    this.sinks = sinks;
+  }
+  store;
+  sinks;
+  /** Resolve only the enabled channels referenced by `channelIds`. */
+  channelsForIds(channelIds) {
+    const seen = new Set(channelIds);
+    return this.store.list().filter((channel) => channel.enabled && seen.has(channel.id));
+  }
+  /** Channels currently enabled (for `/status` and `/channels`). */
+  enabledChannels() {
+    return this.store.list().filter((channel) => channel.enabled);
+  }
+  /** Best-effort fan-out; a failing channel never blocks the others. */
+  async broadcast(channelIds, message) {
+    const channelIdsToSend = [...new Set(channelIds)];
+    const channels = this.channelsForIds(channelIdsToSend);
+    const failures = [];
+    let delivered = 0;
+    for (const channel of channels) {
+      const sink = this.sinkFor(channel.type);
+      if (!sink) {
+        log.warn("sinks", "unsupported-type", { channel: channel.id, type: channel.type });
+        failures.push(channel.id);
+        continue;
+      }
+      let ok = false;
+      try {
+        ok = await sink.send(channel, message);
+      } catch (error) {
+        log.warn("sinks", "channel-send-error", { channel: channel.id, error });
+      }
+      if (ok) delivered += 1;
+      else failures.push(channel.id);
+    }
+    return { delivered, failures, total: channels.length };
+  }
+  sinkFor(type) {
+    return this.sinks.find((sink) => sink.type === type);
+  }
+};
 // src/bridge/reply-dispatcher.ts
 var ReplyDispatcher = class {
   constructor(deps) {
@@ -12900,8 +13402,8 @@ var ReplyDispatcher = class {
     }
   }
 };
-function replyRoute(reply8) {
-  return `${reply8.chatId}\0${reply8.options?.threadId ?? ""}`;
+function replyRoute(reply9) {
+  return `${reply9.chatId}\0${reply9.options?.threadId ?? ""}`;
 }
 function mergedMarkdown(batch) {
   if (batch.length === 1) return batch[0].markdown;
@@ -12952,6 +13454,7 @@ function resolveAppPaths(root = defaultHome()) {
     jobsFile: (profile) => profilePath(profile, "jobs.json"),
     permissionPoliciesFile: (profile) => profilePath(profile, "permission-policies.json"),
     notificationPreferencesFile: (profile) => profilePath(profile, "notification-preferences.json"),
+    notificationChannelsFile: (profile) => profilePath(profile, "notification-channels.json"),
     replyPoliciesFile: (profile) => profilePath(profile, "reply-policies.json"),
     executionModesFile: (profile) => profilePath(profile, "execution-modes.json"),
     languagePoliciesFile: (profile) => profilePath(profile, "language-policy.json"),
@@ -13305,11 +13808,11 @@ function loadRuntimeEnv(source = process.env) {
 }
 // src/config/profile-store.ts
-import { mkdir as mkdir7, readFile as readFile13 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile14 } from "fs/promises";
 import { dirname as dirname8 } from "path";
 // src/platform/file-lock.ts
-import { open as open3, mkdir as mkdir6, readFile as readFile12, readdir as readdir2, rm as rm3, rmdir, stat as stat3, utimes } from "fs/promises";
+import { open as open3, mkdir as mkdir6, readFile as readFile13, readdir as readdir2, rm as rm3, rmdir, stat as stat3, utimes } from "fs/promises";
 import { randomUUID as randomUUID10 } from "crypto";
 import { dirname as dirname7, join as join12 } from "path";
 var RETRY_MS = 10;
@@ -13393,7 +13896,7 @@ async function olderThan(path, thresholdMs) {
 }
 async function readLease(path) {
   try {
-    const value = JSON.parse(await readFile12(path, "utf8"));
+    const value = JSON.parse(await readFile13(path, "utf8"));
     return typeof value.pid === "number" && typeof value.token === "string" && typeof value.createdAt === "number" ? value : void 0;
   } catch {
     return void 0;
@@ -13421,7 +13924,7 @@ var ConfigStore = class {
       return this.data;
     }
     try {
-      const raw = await readFile13(this.path, "utf8");
+      const raw = await readFile14(this.path, "utf8");
       const parsed = JSON.parse(raw);
       this.data = {
         schemaVersion: 1,
@@ -13589,7 +14092,7 @@ async function onboardPersonalAgent(deps = {}) {
 }
 // src/media/attachments.ts
-import { mkdir as mkdir8, readFile as readFile14, rename as rename2, rm as rm4, stat as stat4 } from "fs/promises";
+import { mkdir as mkdir8, readFile as readFile15, rename as rename2, rm as rm4, stat as stat4 } from "fs/promises";
 import { join as join13 } from "path";
 var MAX_TEXT_FILE_BYTES = 256e3;
 function assertSafeMediaName(mediaDir, destination) {
@@ -13630,7 +14133,7 @@ async function prepareAttachments(channel, message, mediaDir) {
       result.textFileNotes.push(`[attachment: ${resource.fileName ?? resource.fileKey}] ${destination}`);
       continue;
     }
-    const content2 = await readFile14(destination, "utf8");
+    const content2 = await readFile15(destination, "utf8");
     const safeContent = truncateUtf8Safe(content2, MAX_TEXT_FILE_BYTES);
     result.textFileNotes.push(
       `[attachment: ${resource.fileName ?? resource.fileKey}]
@@ -13641,7 +14144,7 @@ ${safeContent}`
 }
 // src/session/store.ts
-import { readFile as readFile15 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 var MAX_CONTEXT_SNAPSHOTS_PER_WORKSPACE = 32;
 var SessionStore = class {
   constructor(path) {
@@ -13656,7 +14159,7 @@ var SessionStore = class {
   pendingArchive = Promise.resolve();
   async load() {
     try {
-      const raw = JSON.parse(await readFile15(this.path, "utf8"));
+      const raw = JSON.parse(await readFile16(this.path, "utf8"));
       const legacy = raw.schema !== 2 || !isObject(raw.workspaces);
       this.data = legacy ? migrateLegacy(raw) : normalizeV2(raw.workspaces);
       this.legacyScopes = legacy ? new Set(Object.keys(this.data.workspaces)) : /* @__PURE__ */ new Set();
@@ -13753,13 +14256,13 @@ var SessionStore = class {
   fullHistoryFor(scopeId, cwd) {
     return this.historyFor(scopeId, cwd);
   }
-  recordUsage(scopeId, cwd, usage3) {
+  recordUsage(scopeId, cwd, usage4) {
     const state = this.ensureState(scopeId, cwd);
     const next = { ...state.metrics };
-    addMetric(next, "inputTokens", usage3.inputTokens);
-    addMetric(next, "outputTokens", usage3.outputTokens);
-    addMetric(next, "cacheReadTokens", usage3.cacheReadTokens);
-    addMetric(next, "cacheWriteTokens", usage3.cacheWriteTokens);
+    addMetric(next, "inputTokens", usage4.inputTokens);
+    addMetric(next, "outputTokens", usage4.outputTokens);
+    addMetric(next, "cacheReadTokens", usage4.cacheReadTokens);
+    addMetric(next, "cacheWriteTokens", usage4.cacheWriteTokens);
     state.metrics = next;
     this.schedulePersist();
   }
@@ -13975,7 +14478,7 @@ function normalizeContextSnapshot(value) {
 }
 // src/session/projection-store.ts
-import { readFile as readFile16 } from "fs/promises";
+import { readFile as readFile17 } from "fs/promises";
 import { randomUUID as randomUUID11 } from "crypto";
 var MAX_RECENT_MESSAGES = 64;
 var MAX_PROMPT_CORRELATIONS = 64;
@@ -13989,7 +14492,7 @@ var SessionProjectionStore = class {
   saving = Promise.resolve();
   async load() {
     try {
-      const parsed = JSON.parse(await readFile16(this.path, "utf8"));
+      const parsed = JSON.parse(await readFile17(this.path, "utf8"));
       const bindings = Object.fromEntries(
         Object.values(parsed.bindings ?? {}).flatMap((value) => {
           const normalized = normalizeBinding(value);
@@ -14201,7 +14704,7 @@ function normalizeCorrelation(value) {
 // src/session/archive.ts
 import { execFile } from "child_process";
 import { randomBytes as randomBytes3 } from "crypto";
-import { access, mkdir as mkdir9, readdir as readdir3, readFile as readFile17, unlink, writeFile as writeFile5 } from "fs/promises";
+import { access, mkdir as mkdir9, readdir as readdir3, readFile as readFile18, unlink, writeFile as writeFile5 } from "fs/promises";
 import { join as join14 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
@@ -14383,8 +14886,8 @@ var SessionArchive = class {
       const jsonlPath = join14(scopeDir, `${id}.jsonl`);
       const markdownPath = join14(scopeDir, `${id}.md`);
       const [jsonl, markdown2] = await Promise.all([
-        readFile17(jsonlPath, "utf8"),
-        readFile17(markdownPath, "utf8")
+        readFile18(jsonlPath, "utf8"),
+        readFile18(markdownPath, "utf8")
       ]);
       const [first = "", ...rest] = jsonl.split("\n");
       const header = JSON.parse(first);
@@ -14499,7 +15002,7 @@ async function defaultRunGit(args, cwd) {
 }
 async function readArchiveHeader(jsonlPath) {
   try {
-    const raw = await readFile17(jsonlPath, "utf8");
+    const raw = await readFile18(jsonlPath, "utf8");
     const firstLine = raw.split("\n", 1)[0];
     if (!firstLine) return void 0;
     const header = JSON.parse(firstLine);
@@ -14549,7 +15052,7 @@ async function defaultCopyRulesFile(source, target) {
   await mkdir10(dirname9(target), { recursive: true });
   await copyFile(source, target);
 }
-function slugify(scope) {
+function slugify2(scope) {
   const slug = scope.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^[.]+/, "").replace(/^-+|-+$/g, "").slice(0, 64);
   return slug || "session";
 }
@@ -14565,7 +15068,7 @@ var GitWorktreeManager = class {
   async ensure(scope, base) {
     const isGit = await this.isGitRepository(base);
     if (!isGit) return { cwd: base, created: false };
-    const scopeSlug = slugify(scope);
+    const scopeSlug = slugify2(scope);
     const project = createHash2("sha256").update(base).digest("hex").slice(0, 10);
     const slug = `${scopeSlug}-${project}`;
     const target = join15(this.options.worktreesRoot, slug);
@@ -14602,7 +15105,7 @@ var GitWorktreeManager = class {
   }
   /** Owning main worktree for the legacy scope-only linked worktree. */
   async legacyWorkspaceBase(scope) {
-    const legacyTarget = join15(this.options.worktreesRoot, slugify(scope));
+    const legacyTarget = join15(this.options.worktreesRoot, slugify2(scope));
     if (!await exists2(legacyTarget)) return void 0;
     try {
       const output = await this.runGit(["worktree", "list", "--porcelain"], legacyTarget);
@@ -14634,7 +15137,7 @@ async function samePath(left, right) {
 }
 // src/workspace/store.ts
-import { readFile as readFile18 } from "fs/promises";
+import { readFile as readFile19 } from "fs/promises";
 var WorkspaceStore = class {
   data = { chats: {}, named: {}, lastUsed: {} };
   saving = Promise.resolve();
@@ -14644,7 +15147,7 @@ var WorkspaceStore = class {
   }
   async load() {
     try {
-      const raw = await readFile18(this.path, "utf8");
+      const raw = await readFile19(this.path, "utf8");
       const parsed = JSON.parse(raw);
       this.data = {
         chats: parsed.chats ?? {},
@@ -14716,7 +15219,7 @@ var WorkspaceStore = class {
 };
 // src/guardian/heartbeat.ts
-import { readFile as readFile19 } from "fs/promises";
+import { readFile as readFile20 } from "fs/promises";
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 5e3;
 function startHeartbeat(file, pid, intervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS, getChannelHealth) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -14797,7 +15300,7 @@ var UpdateNotifier = class {
 };
 // src/bot/fleet-store.ts
-import { mkdir as mkdir11, readFile as readFile20 } from "fs/promises";
+import { mkdir as mkdir11, readFile as readFile21 } from "fs/promises";
 import { dirname as dirname10 } from "path";
 function validBotInstanceName(name2) {
   return /^[a-z][a-z0-9-]{0,31}$/u.test(name2);
@@ -14810,7 +15313,7 @@ var BotFleetStore = class {
   data = { schemaVersion: 1, bots: {} };
   async load() {
     try {
-      const parsed = JSON.parse(await readFile20(this.path, "utf8"));
+      const parsed = JSON.parse(await readFile21(this.path, "utf8"));
       this.data = {
         schemaVersion: 1,
         bots: Object.fromEntries(
@@ -14938,7 +15441,7 @@ function isFleetEntry(value) {
 }
 // src/bot/handoff-guard.ts
-import { mkdir as mkdir12, readFile as readFile21 } from "fs/promises";
+import { mkdir as mkdir12, readFile as readFile22 } from "fs/promises";
 import { dirname as dirname11 } from "path";
 var BotHandoffGuard = class {
   constructor(path) {
@@ -14979,7 +15482,7 @@ var BotHandoffGuard = class {
   }
   async read() {
     try {
-      const parsed = JSON.parse(await readFile21(this.path, "utf8"));
+      const parsed = JSON.parse(await readFile22(this.path, "utf8"));
       return { schemaVersion: 1, chats: parsed.chats ?? {} };
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
@@ -15005,7 +15508,7 @@ init_dsh_runtime();
 import { homedir as homedir14 } from "os";
 // src/bot/job-ledger.ts
-import { readFile as readFile22, rename as rename3 } from "fs/promises";
+import { readFile as readFile23, rename as rename3 } from "fs/promises";
 var EMPTY_COUNTS = {
   queued: 0,
   running: 0,
@@ -15028,7 +15531,7 @@ var JobLedger = class {
     if (this.path === ":memory:") return;
     let raw;
     try {
-      raw = await readFile22(this.path, "utf8");
+      raw = await readFile23(this.path, "utf8");
     } catch (error) {
       if (error.code === "ENOENT") return;
       throw error;
@@ -15604,21 +16107,91 @@ function projectDiagnosticLogs(lines) {
 }
 // src/service/manager.ts
-import { mkdir as mkdir19, readFile as readFile27, rename as rename4, rm as rm9, stat as stat8 } from "fs/promises";
-import { dirname as dirname16, join as join22 } from "path";
+import { mkdir as mkdir19, readFile as readFile28, rename as rename4, rm as rm9, stat as stat8 } from "fs/promises";
+import { dirname as dirname17, join as join22 } from "path";
 import { homedir as homedir13 } from "os";
 init_dsh_runtime();
 // src/guardian/install.ts
-init_own_package();
-init_dsh_runtime();
-import { mkdir as mkdir14, readFile as readFile24, rm as rm5, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir14, readFile as readFile25, rm as rm5, writeFile as writeFile6 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
 import { homedir as homedir9 } from "os";
-import { delimiter, dirname as dirname13, join as join16 } from "path";
+import { dirname as dirname14, join as join16 } from "path";
+// src/platform/path.ts
+import { delimiter, dirname as dirname12 } from "path";
+function sanitizeServicePath(nodeBin, inheritedPath = process.env.PATH) {
+  const entries = [dirname12(nodeBin), ...inheritedPath?.split(delimiter) ?? []];
+  const seen = /* @__PURE__ */ new Set();
+  return entries.filter((entry) => {
+    if (!entry) return false;
+    const normalized = entry.replaceAll("\\", "/");
+    if (normalized.includes("/node_modules/.bin") || /\/_npx(?:\/|$)/.test(normalized) || /\/guardian\/update-worker\/npm-cache(?:\/|$)/.test(normalized)) {
+      return false;
+    }
+    if (seen.has(entry)) return false;
+    seen.add(entry);
+    return true;
+  }).join(delimiter);
+}
+// src/guardian/install.ts
+init_own_package();
+init_dsh_runtime();
 // src/guardian/process.ts
 import { spawn as spawn5 } from "child_process";
+function commandTokens(cmdline) {
+  const tokens = [];
+  let token = "";
+  let quote;
+  const input = cmdline.trim();
+  for (let index = 0; index < input.length; index += 1) {
+    const character = input[index] ?? "";
+    const next = input[index + 1];
+    if (character === "\\" && quote === void 0 && next !== void 0 && /[\s\\"']/u.test(next)) {
+      token += next;
+      index += 1;
+    } else if (character === "\\" && quote === '"' && next === '"') {
+      token += next;
+      index += 1;
+    } else if (quote !== void 0) {
+      if (character === quote) quote = void 0;
+      else token += character;
+    } else if (character === '"' || character === "'") {
+      quote = character;
+    } else if (/\s/u.test(character)) {
+      if (token !== "") {
+        tokens.push(token);
+        token = "";
+      }
+    } else {
+      token += character;
+    }
+  }
+  if (token !== "") tokens.push(token);
+  return tokens;
+}
+function isGuardianCliEntry(token) {
+  const normalized = token.replace(/\\/gu, "/").toLowerCase();
+  return normalized.endsWith("/dist/cli.js") && (normalized.includes("/dsh-lark-bot/") || normalized.includes("/dsh-feishu-bot/"));
+}
+function hasOnlyGuardianRunOptions(tokens) {
+  for (let index = 0; index < tokens.length; index += 2) {
+    if (tokens[index] !== "--dsh-profile" && tokens[index] !== "--bridge-profile") return false;
+    if (tokens[index + 1] === void 0 || tokens[index + 1]?.startsWith("--")) return false;
+  }
+  return true;
+}
+function matchGuardianProcess(cmdline) {
+  const tokens = commandTokens(cmdline);
+  const cliIndex = tokens.findIndex(isGuardianCliEntry);
+  if (cliIndex < 1) return false;
+  const executable = tokens[cliIndex - 1]?.replace(/\\/gu, "/").split("/").pop()?.toLowerCase();
+  if (executable !== "node" && executable !== "node.exe") return false;
+  if (tokens[cliIndex + 1] !== "guardian" || tokens[cliIndex + 2] !== "run") return false;
+  return hasOnlyGuardianRunOptions(tokens.slice(cliIndex + 3));
+}
 function hasProfileFlag(cmdline, dshProfile) {
   const pattern = new RegExp(
     `(?:^|\\s)--profile(?:\\s+|=)${escapeRegExp(dshProfile)}(?:\\s|$)`
@@ -15645,12 +16218,18 @@ async function listProcesses(platform = process.platform, run = captureOutput) {
   return listProcessesPosix(run);
 }
 async function listProcessesPosix(run) {
-  const { stdout } = await run("ps", ["-axo", "pid=,args="], 1e4);
+  const { stdout } = await run("ps", ["-axo", "pid=,ppid=,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] ?? "" });
+    const match = /^\s*(\d+)\s+(\d+)\s+(.+)$/.exec(line);
+    if (!match) continue;
+    const pid = Number(match[1]);
+    const ppid = Number(match[2]);
+    if (!Number.isInteger(pid) || pid <= 0) continue;
+    if (Number.isInteger(ppid) && ppid > 0) {
+      result.push({ pid, ppid, cmdline: match[3] ?? "" });
+    } else {
+      result.push({ pid, cmdline: match[3] ?? "" });
     }
   }
   return result;
@@ -15662,7 +16241,7 @@ async function listProcessesWindows(run) {
       "-NoProfile",
       "-NonInteractive",
       "-Command",
-      "Get-CimInstance Win32_Process | Select-Object ProcessId, CommandLine | ConvertTo-Json -Compress"
+      "Get-CimInstance Win32_Process | Select-Object ProcessId, ParentProcessId, CommandLine | ConvertTo-Json -Compress"
     ],
     1e4
   );
@@ -15673,8 +16252,11 @@ async function listProcessesWindows(run) {
       if (typeof row !== "object" || row === null) return [];
       const record = row;
       const pid = Number(record.ProcessId);
+      const ppid = Number(record.ParentProcessId);
       const cmdline = record.CommandLine;
-      return Number.isInteger(pid) && pid > 0 && typeof cmdline === "string" ? [{ pid, cmdline }] : [];
+      if (!Number.isInteger(pid) || pid <= 0 || typeof cmdline !== "string") return [];
+      if (Number.isInteger(ppid) && ppid > 0) return [{ pid, ppid, cmdline }];
+      return [{ pid, cmdline }];
     });
   } catch {
     return [];
@@ -15722,8 +16304,8 @@ async function findProfileProcess(dshProfile) {
 }
 // src/guardian/state.ts
-import { readFile as readFile23 } from "fs/promises";
-import { dirname as dirname12 } from "path";
+import { readFile as readFile24 } from "fs/promises";
+import { dirname as dirname13 } from "path";
 import { mkdir as mkdir13 } from "fs/promises";
 // src/guardian/install.ts
@@ -15743,7 +16325,7 @@ function resolveGuardianCliEntry(dshProfile, root, env = process.env) {
 // src/service/command.ts
 import { execFile as execFile3 } from "child_process";
-import { basename as basename4, dirname as dirname14, join as join17 } from "path";
+import { basename as basename4, dirname as dirname15, join as join17 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var runCommand = (command, args, options) => new Promise((resolve6) => {
   execFile3(
@@ -15769,21 +16351,21 @@ function resolveCliJsPath(metaUrl = import.meta.url) {
   const current = fileURLToPath2(metaUrl);
   const name2 = basename4(current);
   if (name2 === "cli.js" || name2 === "cli.mjs" || name2 === "cli.cjs") return current;
-  return join17(dirname14(current), "..", "dist", "cli.js");
+  return join17(dirname15(current), "..", "dist", "cli.js");
 }
-function slugify2(value) {
+function slugify3(value) {
   const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   return slug || "default";
 }
 function serviceNameFor(profile) {
-  return `dsh-lark-engine-${slugify2(profile)}`;
+  return `dsh-lark-engine-${slugify3(profile)}`;
 }
 function launchdLabelFor(profile) {
-  return `io.dsh-lark.engine.${slugify2(profile)}`;
+  return `io.dsh-lark.engine.${slugify3(profile)}`;
 }
 // src/service/env-snapshot.ts
-import { readFile as readFile25 } from "fs/promises";
+import { readFile as readFile26 } from "fs/promises";
 var EXTRA_KEYS = ["PATH", "HOME", "DEEPSEEK_API_KEY", "DSH_HOME"];
 var INTERNAL_KEYS = /* @__PURE__ */ new Set([
   "DSH_LARK_NOTIFY_URL",
@@ -15812,6 +16394,9 @@ function snapshotServiceEnv(source = process.env, extraKeys = [], inherited = {}
       }
     }
   }
+  if (typeof env.PATH === "string" && env.PATH.length > 0) {
+    env.PATH = sanitizeServicePath(process.execPath, env.PATH);
+  }
   return env;
 }
 function formatEnvFile(env) {
@@ -15852,7 +16437,7 @@ async function writeServiceEnv(file, env) {
 }
 async function readServiceEnv(file) {
   try {
-    return parseEnvFile(await readFile25(file, "utf8"));
+    return parseEnvFile(await readFile26(file, "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") return {};
     throw error;
@@ -16164,7 +16749,7 @@ var LaunchdServiceController = class {
 // src/service/portable.ts
 import { spawn as spawn6 } from "child_process";
-import { mkdir as mkdir17, readFile as readFile26, rm as rm8, stat as stat7, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir17, readFile as readFile27, rm as rm8, stat as stat7, writeFile as writeFile7 } from "fs/promises";
 import { homedir as homedir12 } from "os";
 import { join as join20 } from "path";
 function defaultAutostartDir() {
@@ -16199,8 +16784,8 @@ function buildDesktopEntry(spec) {
 async function readLinuxProcessIdentity(pid) {
   try {
     const [statText, cmdlineText] = await Promise.all([
-      readFile26(`/proc/${pid}/stat`, "utf8"),
-      readFile26(`/proc/${pid}/cmdline`, "utf8")
+      readFile27(`/proc/${pid}/stat`, "utf8"),
+      readFile27(`/proc/${pid}/cmdline`, "utf8")
     ]);
     const close = statText.lastIndexOf(") ");
     if (close < 0) return void 0;
@@ -16231,7 +16816,7 @@ function isProcessAlive(pid) {
 }
 async function readSupervisorStatus(file) {
   try {
-    return JSON.parse(await readFile26(file, "utf8"));
+    return JSON.parse(await readFile27(file, "utf8"));
   } catch {
     return void 0;
   }
@@ -16397,7 +16982,7 @@ var PortableServiceController = class {
 // src/service/windows-task.ts
 import { mkdir as mkdir18, writeFile as writeFile8 } from "fs/promises";
-import { dirname as dirname15, join as join21 } from "path";
+import { dirname as dirname16, join as join21 } from "path";
 function psQuote(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
@@ -16408,7 +16993,7 @@ function buildScheduledTaskScript(action, spec) {
     `$arguments = ${psQuote(spec.commandArgs.map((arg) => `"${arg.replace(/"/g, '\\"')}"`).join(" "))}`,
     `$log = ${psQuote(spec.logFile)}`,
     `$profile = ${psQuote(spec.profile)}`,
-    `$workDir = ${psQuote(dirname15(spec.commandPath))}`
+    `$workDir = ${psQuote(dirname16(spec.commandPath))}`
   ].join("\n");
   const install = [
     `$inner = '"' + $command + '" ' + $arguments + ' >> "' + $log + '" 2>&1'`,
@@ -16606,7 +17191,7 @@ var ServiceManager = class {
   async readIntent() {
     try {
       const parsed = JSON.parse(
-        await readFile27(this.paths.serviceIntentFile(this.profile), "utf8")
+        await readFile28(this.paths.serviceIntentFile(this.profile), "utf8")
       );
       if (parsed.schemaVersion !== 1 || !["running", "stopped"].includes(parsed.desiredState ?? "")) {
         return void 0;
@@ -16626,14 +17211,14 @@ var ServiceManager = class {
   }
   async withLifecycleLock(operation) {
     const lockDir = this.paths.serviceLockDir(this.profile);
-    await mkdir19(dirname16(lockDir), { recursive: true });
+    await mkdir19(dirname17(lockDir), { recursive: true });
     try {
       await mkdir19(lockDir);
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       let ownerPid;
       try {
-        const owner = JSON.parse(await readFile27(join22(lockDir, "owner.json"), "utf8"));
+        const owner = JSON.parse(await readFile28(join22(lockDir, "owner.json"), "utf8"));
         if (typeof owner.pid === "number") ownerPid = owner.pid;
       } catch {
       }
@@ -16666,11 +17251,39 @@ var ServiceManager = class {
     if (serviceStatus.state === "running") return;
     const process2 = await this.findProcess(this.profile);
     if (process2) {
+      if (await this.isGuardianSpawned(process2)) {
+        await this.stopGuardianSpawnedProcess(process2.pid);
+        return;
+      }
       throw new Error(
         `\u68C0\u6D4B\u5230\u672A\u53D7\u7BA1\u7684 dsh --profile ${this.profile}\uFF08pid ${process2.pid}\uFF09\u3002\u8BF7\u5148\u5728\u539F\u7EC8\u7AEF\u505C\u6B62\u5B83\uFF0C\u518D\u91CD\u8BD5\u3002`
       );
     }
   }
+  /** True when the profile process was spawned by the resident guardian. */
+  async isGuardianSpawned(process2) {
+    const ppid = process2.ppid;
+    if (!ppid) return false;
+    const parent = (await listProcesses()).find((entry) => entry.pid === ppid);
+    return parent !== void 0 && matchGuardianProcess(parent.cmdline);
+  }
+  /** Best-effort stop of a guardian-spawned profile process (grace, then kill). */
+  async stopGuardianSpawnedProcess(pid) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      return;
+    }
+    const deadline = Date.now() + 5e3;
+    while (Date.now() < deadline && isPidAlive2(pid)) {
+      await new Promise((resolve6) => setTimeout(resolve6, 100));
+    }
+    if (!isPidAlive2(pid)) return;
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
   async buildSpec(requireProfile = false) {
     const previous = await this.readMetadata();
     const dshBin = this.dshBinOverride ?? discoverDshBin(this.home, this.sourceEnv) ?? previous?.dshBin;
@@ -16759,7 +17372,7 @@ var ServiceManager = class {
   }
   async readMetadata() {
     try {
-      const parsed = JSON.parse(await readFile27(this.metadataFile(), "utf8"));
+      const parsed = JSON.parse(await readFile28(this.metadataFile(), "utf8"));
       if (parsed.schemaVersion !== 2 || typeof parsed.profile !== "string") return void 0;
       return parsed;
     } catch {
@@ -16767,8 +17380,8 @@ var ServiceManager = class {
     }
   }
   async prepareFiles(spec, platform) {
-    await mkdir19(dirname16(spec.logFile), { recursive: true });
-    await mkdir19(dirname16(spec.envFile), { recursive: true });
+    await mkdir19(dirname17(spec.logFile), { recursive: true });
+    await mkdir19(dirname17(spec.envFile), { recursive: true });
     await writeServiceEnv(spec.envFile, spec.env);
     if (platform === "win32-task") {
       try {
@@ -16861,7 +17474,7 @@ var ServiceManager = class {
   async logs(lines = 100) {
     const path = this.paths.serviceLogFile(this.profile);
     try {
-      const content2 = await readFile27(path, "utf8");
+      const content2 = await readFile28(path, "utf8");
       return { path, text: content2.split(/\r?\n/).slice(-Math.max(1, lines)).join("\n") };
     } catch (error) {
       if (error.code === "ENOENT") return { path, text: "" };
@@ -17036,8 +17649,8 @@ init_own_package();
 // src/guardian/update-handoff.ts
 import { createHash as createHash3, randomUUID as randomUUID13 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { chmod, mkdir as mkdir20, readFile as readFile28, rm as rm10 } from "fs/promises";
-import { dirname as dirname17, join as join23 } from "path";
+import { chmod, mkdir as mkdir20, readFile as readFile29, rm as rm10 } from "fs/promises";
+import { dirname as dirname18, join as join23 } from "path";
 init_own_package();
 function guardianUpdateFailureHint(code) {
   switch (code) {
@@ -17065,7 +17678,7 @@ function guardianUpdateFailureHint(code) {
 }
 async function loadState(file) {
   try {
-    const parsed = JSON.parse(await readFile28(file, "utf8"));
+    const parsed = JSON.parse(await readFile29(file, "utf8"));
     return parsed.schemaVersion === 1 && typeof parsed.id === "string" ? parsed : void 0;
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
@@ -17073,7 +17686,7 @@ async function loadState(file) {
   }
 }
 async function saveState(file, state) {
-  await mkdir20(dirname17(file), { recursive: true });
+  await mkdir20(dirname18(file), { recursive: true });
   await writeFileAtomic(file, `${JSON.stringify(state, null, 2)}
 `, { mode: 384 });
 }
@@ -17350,6 +17963,8 @@ async function startBridgeEngine(options) {
   const isolationStore = new IsolationStore(paths.profilePath(profileName, "isolation.json"));
   const permissionPolicies = new PermissionPolicyStore(paths.permissionPoliciesFile(profileName));
   const notificationPreferences = new NotificationPreferenceStore(paths.notificationPreferencesFile(profileName));
+  const notificationChannels = new NotificationChannelStore(paths.notificationChannelsFile(profileName));
+  const notificationSinks = new OutboundSinkRegistry(notificationChannels);
   const replyPolicies = new ReplyPolicyStore(paths.replyPoliciesFile(profileName));
   const executionModes = new ExecutionModeStore(paths.executionModesFile(profileName));
   const languagePolicies = new LanguagePolicyStore(paths.languagePoliciesFile(profileName));
@@ -17372,6 +17987,7 @@ async function startBridgeEngine(options) {
     isolationStore.load(),
     permissionPolicies.load(),
     notificationPreferences.load(),
+    notificationChannels.load(),
     replyPolicies.load(),
     executionModes.load(),
     languagePolicies.load()
@@ -17441,7 +18057,8 @@ async function startBridgeEngine(options) {
     send: async (chatId, markdown2, options2) => {
       if (!streaming) throw new Error("bridge channel is not ready");
       await streaming.sendMarkdown(chatId, markdown2, options2);
-    }
+    },
+    sinks: notificationSinks
   });
   const replyDispatcher = new ReplyDispatcher({
     policies: replyPolicies,
@@ -17732,6 +18349,9 @@ async function startBridgeEngine(options) {
     approvals,
     permissionPolicies,
     notificationPreferences,
+    notificationChannels,
+    notificationSinks,
+    faultNotifier: (scope, title, detail) => notificationDispatcher.notifyUrgent(scope, title, detail),
     ...defaultNotificationPreference ? { defaultNotificationPreference: { ...defaultNotificationPreference, events: [...defaultNotificationPreference.events] } } : {},
     replyPolicies,
     executionModes,
@@ -17994,6 +18614,7 @@ function notificationPreferenceFor(value) {
   return {
     events: value === "all" ? ["completed", "failed", "approval"] : ["completed", "failed"],
     mentionUserIds: [],
+    sinks: [],
     approvalReminderMs: 10 * 6e4
   };
 }