dsh-lark-bot 0.19.12 → 0.19.13

package/dist/cli.js

@@ -825,14 +825,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) {
@@ -2502,11 +2502,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 [
     {
@@ -3682,6 +3682,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"),
@@ -6910,7 +6911,7 @@ var PermissionPolicyStore = class {
 
 // src/bot/notification-preference-store.ts
 import { readFile as readFile19 } 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;
@@ -6939,7 +6940,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];
@@ -6984,6 +6985,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
   };
 }
@@ -7460,6 +7462,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}\``,
@@ -7876,8 +7879,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));
@@ -7943,8 +7946,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) {
@@ -10967,7 +10970,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 });
 }
@@ -11005,6 +11008,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);
@@ -11016,6 +11020,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);
@@ -11034,50 +11040,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 readFile23 } 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 readFile23(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}-${slugify2(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 slugify2(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;
@@ -11091,10 +11344,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 });
 }
 
@@ -11281,7 +11534,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" },
@@ -11359,6 +11613,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",
@@ -11420,7 +11675,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
   });
@@ -11429,7 +11684,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."
@@ -11458,11 +11713,11 @@ function groupAppLink(chatId) {
 async function handleNewGroup(args, ctx) {
   const name = args.trim();
   if (!name) {
-    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 (name.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(name.length)}\uFF09\u3002`,
       `The group name is too long (limit ${String(MAX_GROUP_NAME_LENGTH)} characters; received ${String(name.length)}).`
@@ -11470,11 +11725,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 {
@@ -11485,7 +11740,7 @@ async function handleNewGroup(args, ctx) {
       inviteUserIds: [ctx.senderId],
       userIdType: "open_id"
     });
-    await reply7(
+    await reply8(
       ctx,
       [
         `\u2705 \u5DF2\u521B\u5EFA\u7FA4\u804A\uFF1A**${name}**`,
@@ -11504,13 +11759,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, "~");
@@ -11518,13 +11773,13 @@ async function handleCd(args, ctx) {
   const cwd = resolve5(expanded);
   const target = await stat8(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).` : ""}`
@@ -11544,7 +11799,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}\``,
@@ -11561,29 +11816,29 @@ async function handleWs(args, ctx) {
   }
   if (sub === "save") {
     if (!name) {
-      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(name, current);
-    await reply7(ctx, `\u5DF2\u4FDD\u5B58\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}** \u2192 \`${current}\``, `Saved workspace: **${name}** \u2192 \`${current}\``);
+    await reply8(ctx, `\u5DF2\u4FDD\u5B58\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}** \u2192 \`${current}\``, `Saved workspace: **${name}** \u2192 \`${current}\``);
     return;
   }
   if (sub === "use") {
     if (!name) {
-      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(name);
     if (!cwd) {
-      await reply7(ctx, `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**`, `Workspace not found: **${name}**`);
+      await reply8(ctx, `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**`, `Workspace not found: **${name}**`);
       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(name);
-    await reply7(
+    await reply8(
       ctx,
       `\u5DF2\u5207\u6362\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}** \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 **${name}** \u2192 \`${cwd}\`; its independent session will resume.${interrupted > 0 ? ` Interrupted ${String(interrupted)} running task(s) in the previous workspace (session data was preserved).` : ""}`
@@ -11592,14 +11847,14 @@ async function handleWs(args, ctx) {
   }
   if (sub === "remove") {
     if (!name) {
-      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(name);
-    await reply7(ctx, removed ? `\u5DF2\u5220\u9664\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**` : `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**`, removed ? `Removed workspace: **${name}**` : `Workspace not found: **${name}**`);
+    await reply8(ctx, removed ? `\u5DF2\u5220\u9664\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**` : `\u672A\u627E\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF1A**${name}**`, removed ? `Removed workspace: **${name}**` : `Workspace not found: **${name}**`);
     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;
@@ -11646,6 +11901,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,
@@ -11688,16 +11944,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.`
@@ -11705,16 +11961,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.`
@@ -11741,25 +11997,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({
@@ -11774,9 +12030,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;
@@ -11793,7 +12049,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."
@@ -11807,21 +12063,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."
@@ -11831,18 +12087,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;
@@ -11850,11 +12106,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.`
@@ -11864,19 +12120,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**",
@@ -11923,7 +12179,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."
@@ -11934,7 +12190,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."
@@ -11943,27 +12199,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).`
@@ -11972,16 +12228,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+/);
@@ -11993,7 +12249,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).`
@@ -12001,21 +12257,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.`
@@ -12025,7 +12281,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.`
@@ -12034,21 +12290,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) {
@@ -12065,7 +12321,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.`
@@ -12073,18 +12329,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."
@@ -12094,11 +12350,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;
@@ -12120,18 +12376,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**",
@@ -12149,7 +12405,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>`"
@@ -12158,39 +12414,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;
@@ -12243,20 +12499,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")) {
@@ -12264,7 +12520,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;
@@ -12275,37 +12531,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."
@@ -12335,6 +12591,7 @@ var handlers = {
   "/role": handleRole,
   "/notify": handleNotify,
   "/notifications": handleNotifications,
+  "/channels": handleChannels,
   "/replies": handleReplies,
   "/retention": handleRetention,
   "/archive": handleArchive,
@@ -12814,24 +13071,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;
@@ -12839,12 +13098,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();
@@ -12854,6 +13113,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";
@@ -14056,7 +14322,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;
@@ -14191,6 +14458,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 } : {},
@@ -15555,6 +15824,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;
@@ -15563,21 +15837,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);
@@ -15588,10 +15893,196 @@ 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 {
@@ -15651,8 +16142,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;
@@ -15787,7 +16278,7 @@ async function onboardPersonalAgent(deps = {}) {
 }
 
 // src/media/attachments.ts
-import { mkdir as mkdir16, readFile as readFile23, rename as rename3, rm as rm9, stat as stat9 } from "fs/promises";
+import { mkdir as mkdir16, readFile as readFile24, rename as rename3, rm as rm9, stat as stat9 } from "fs/promises";
 import { join as join23 } from "path";
 var MAX_TEXT_FILE_BYTES = 256e3;
 function assertSafeMediaName(mediaDir, destination) {
@@ -15828,7 +16319,7 @@ async function prepareAttachments(channel, message, mediaDir) {
       result.textFileNotes.push(`[attachment: ${resource.fileName ?? resource.fileKey}] ${destination}`);
       continue;
     }
-    const content = await readFile23(destination, "utf8");
+    const content = await readFile24(destination, "utf8");
     const safeContent = truncateUtf8Safe(content, MAX_TEXT_FILE_BYTES);
     result.textFileNotes.push(
       `[attachment: ${resource.fileName ?? resource.fileKey}]
@@ -15839,7 +16330,7 @@ ${safeContent}`
 }
 
 // src/session/store.ts
-import { readFile as readFile24 } from "fs/promises";
+import { readFile as readFile25 } from "fs/promises";
 var MAX_CONTEXT_SNAPSHOTS_PER_WORKSPACE = 32;
 var SessionStore = class {
   constructor(path) {
@@ -15854,7 +16345,7 @@ var SessionStore = class {
   pendingArchive = Promise.resolve();
   async load() {
     try {
-      const raw = JSON.parse(await readFile24(this.path, "utf8"));
+      const raw = JSON.parse(await readFile25(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();
@@ -15951,13 +16442,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();
   }
@@ -16173,7 +16664,7 @@ function normalizeContextSnapshot(value) {
 }
 
 // src/session/projection-store.ts
-import { readFile as readFile25 } from "fs/promises";
+import { readFile as readFile26 } from "fs/promises";
 import { randomUUID as randomUUID11 } from "crypto";
 var MAX_RECENT_MESSAGES = 64;
 var MAX_PROMPT_CORRELATIONS = 64;
@@ -16187,7 +16678,7 @@ var SessionProjectionStore = class {
   saving = Promise.resolve();
   async load() {
     try {
-      const parsed = JSON.parse(await readFile25(this.path, "utf8"));
+      const parsed = JSON.parse(await readFile26(this.path, "utf8"));
       const bindings = Object.fromEntries(
         Object.values(parsed.bindings ?? {}).flatMap((value) => {
           const normalized = normalizeBinding(value);
@@ -16399,7 +16890,7 @@ function normalizeCorrelation(value) {
 // src/session/archive.ts
 import { execFile as execFile2 } from "child_process";
 import { randomBytes as randomBytes3 } from "crypto";
-import { access, mkdir as mkdir17, readdir as readdir3, readFile as readFile26, unlink, writeFile as writeFile8 } from "fs/promises";
+import { access, mkdir as mkdir17, readdir as readdir3, readFile as readFile27, unlink, writeFile as writeFile8 } from "fs/promises";
 import { join as join24 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile2);
@@ -16581,8 +17072,8 @@ var SessionArchive = class {
       const jsonlPath = join24(scopeDir, `${id}.jsonl`);
       const markdownPath = join24(scopeDir, `${id}.md`);
       const [jsonl, markdown2] = await Promise.all([
-        readFile26(jsonlPath, "utf8"),
-        readFile26(markdownPath, "utf8")
+        readFile27(jsonlPath, "utf8"),
+        readFile27(markdownPath, "utf8")
       ]);
       const [first = "", ...rest] = jsonl.split("\n");
       const header = JSON.parse(first);
@@ -16697,7 +17188,7 @@ async function defaultRunGit(args, cwd) {
 }
 async function readArchiveHeader(jsonlPath) {
   try {
-    const raw = await readFile26(jsonlPath, "utf8");
+    const raw = await readFile27(jsonlPath, "utf8");
     const firstLine = raw.split("\n", 1)[0];
     if (!firstLine) return void 0;
     const header = JSON.parse(firstLine);
@@ -16747,7 +17238,7 @@ async function defaultCopyRulesFile(source, target) {
   await mkdir18(dirname16(target), { recursive: true });
   await copyFile(source, target);
 }
-function slugify2(scope) {
+function slugify3(scope) {
   const slug = scope.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^[.]+/, "").replace(/^-+|-+$/g, "").slice(0, 64);
   return slug || "session";
 }
@@ -16763,7 +17254,7 @@ var GitWorktreeManager = class {
   async ensure(scope, base) {
     const isGit = await this.isGitRepository(base);
     if (!isGit) return { cwd: base, created: false };
-    const scopeSlug = slugify2(scope);
+    const scopeSlug = slugify3(scope);
     const project = createHash2("sha256").update(base).digest("hex").slice(0, 10);
     const slug = `${scopeSlug}-${project}`;
     const target = join25(this.options.worktreesRoot, slug);
@@ -16800,7 +17291,7 @@ var GitWorktreeManager = class {
   }
   /** Owning main worktree for the legacy scope-only linked worktree. */
   async legacyWorkspaceBase(scope) {
-    const legacyTarget = join25(this.options.worktreesRoot, slugify2(scope));
+    const legacyTarget = join25(this.options.worktreesRoot, slugify3(scope));
     if (!await exists2(legacyTarget)) return void 0;
     try {
       const output = await this.runGit(["worktree", "list", "--porcelain"], legacyTarget);
@@ -16832,7 +17323,7 @@ async function samePath(left, right) {
 }
 
 // src/workspace/store.ts
-import { readFile as readFile27 } from "fs/promises";
+import { readFile as readFile28 } from "fs/promises";
 var WorkspaceStore = class {
   data = { chats: {}, named: {}, lastUsed: {} };
   saving = Promise.resolve();
@@ -16842,7 +17333,7 @@ var WorkspaceStore = class {
   }
   async load() {
     try {
-      const raw = await readFile27(this.path, "utf8");
+      const raw = await readFile28(this.path, "utf8");
       const parsed = JSON.parse(raw);
       this.data = {
         chats: parsed.chats ?? {},
@@ -16961,7 +17452,7 @@ var UpdateNotifier = class {
 };
 
 // src/bot/fleet-store.ts
-import { mkdir as mkdir19, readFile as readFile28 } from "fs/promises";
+import { mkdir as mkdir19, readFile as readFile29 } from "fs/promises";
 import { dirname as dirname17 } from "path";
 function validBotInstanceName(name) {
   return /^[a-z][a-z0-9-]{0,31}$/u.test(name);
@@ -16974,7 +17465,7 @@ var BotFleetStore = class {
   data = { schemaVersion: 1, bots: {} };
   async load() {
     try {
-      const parsed = JSON.parse(await readFile28(this.path, "utf8"));
+      const parsed = JSON.parse(await readFile29(this.path, "utf8"));
       this.data = {
         schemaVersion: 1,
         bots: Object.fromEntries(
@@ -17102,7 +17593,7 @@ function isFleetEntry(value) {
 }
 
 // src/bot/handoff-guard.ts
-import { mkdir as mkdir20, readFile as readFile29 } from "fs/promises";
+import { mkdir as mkdir20, readFile as readFile30 } from "fs/promises";
 import { dirname as dirname18 } from "path";
 var BotHandoffGuard = class {
   constructor(path) {
@@ -17143,7 +17634,7 @@ var BotHandoffGuard = class {
   }
   async read() {
     try {
-      const parsed = JSON.parse(await readFile29(this.path, "utf8"));
+      const parsed = JSON.parse(await readFile30(this.path, "utf8"));
       return { schemaVersion: 1, chats: parsed.chats ?? {} };
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
@@ -17169,7 +17660,7 @@ init_dsh_runtime();
 import { homedir as homedir16 } from "os";
 
 // src/bot/job-ledger.ts
-import { readFile as readFile30, rename as rename4 } from "fs/promises";
+import { readFile as readFile31, rename as rename4 } from "fs/promises";
 var EMPTY_COUNTS = {
   queued: 0,
   running: 0,
@@ -17192,7 +17683,7 @@ var JobLedger = class {
     if (this.path === ":memory:") return;
     let raw;
     try {
-      raw = await readFile30(this.path, "utf8");
+      raw = await readFile31(this.path, "utf8");
     } catch (error) {
       if (error.code === "ENOENT") return;
       throw error;
@@ -17933,7 +18424,7 @@ 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 mkdir21, readFile as readFile31, rm as rm10 } from "fs/promises";
+import { chmod, mkdir as mkdir21, readFile as readFile32, rm as rm10 } from "fs/promises";
 import { dirname as dirname19, join as join26 } from "path";
 init_own_package();
 init_process();
@@ -17963,7 +18454,7 @@ function guardianUpdateFailureHint(code) {
 }
 async function loadState(file) {
   try {
-    const parsed = JSON.parse(await readFile31(file, "utf8"));
+    const parsed = JSON.parse(await readFile32(file, "utf8"));
     return parsed.schemaVersion === 1 && typeof parsed.id === "string" ? parsed : void 0;
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
@@ -18359,6 +18850,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));
@@ -18381,6 +18874,7 @@ async function startBridgeEngine(options) {
     isolationStore.load(),
     permissionPolicies.load(),
     notificationPreferences.load(),
+    notificationChannels.load(),
     replyPolicies.load(),
     executionModes.load(),
     languagePolicies.load()
@@ -18450,7 +18944,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,
@@ -18741,6 +19236,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,
@@ -19003,6 +19501,7 @@ function notificationPreferenceFor(value) {
   return {
     events: value === "all" ? ["completed", "failed", "approval"] : ["completed", "failed"],
     mentionUserIds: [],
+    sinks: [],
     approvalReminderMs: 10 * 6e4
   };
 }
@@ -19038,7 +19537,7 @@ function waitForShutdown() {
 init_dsh_runtime();
 init_own_package();
 import { spawn as spawn8 } from "child_process";
-import { mkdir as mkdir23, readFile as readFile32, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir23, readFile as readFile33, writeFile as writeFile9 } from "fs/promises";
 import { homedir as homedir17 } from "os";
 import { join as join28 } from "path";
 import { parse } from "yaml";
@@ -19119,7 +19618,7 @@ async function approveBuilds(profileDir) {
   const workspaceFile = join28(profileDir, "pnpm-workspace.yaml");
   let existing = "";
   try {
-    existing = await readFile32(workspaceFile, "utf8");
+    existing = await readFile33(workspaceFile, "utf8");
   } catch {
   }
   const allowBuilds = [
@@ -19147,8 +19646,8 @@ async function preserveInstalledPnpmVersion(profileDir) {
   let modulesText;
   try {
     [packageText, modulesText] = await Promise.all([
-      readFile32(packageFile, "utf8"),
-      readFile32(modulesFile, "utf8")
+      readFile33(packageFile, "utf8"),
+      readFile33(modulesFile, "utf8")
     ]);
   } catch {
     return;