weacpx 0.1.6 → 0.2.0

package/dist/cli.js

@@ -47,6 +47,129 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/weixin/monitor/consumer-lock.ts
+import { mkdir as mkdir5, open as open2, readFile as readFile3, rm as rm4 } from "node:fs/promises";
+import { dirname as dirname4, join as join2 } from "node:path";
+import { homedir } from "node:os";
+function createWeixinConsumerLock(options = {}) {
+  const lockFilePath = options.lockFilePath ?? join2(homedir(), ".weacpx", "runtime", "weixin-consumer.lock.json");
+  const isProcessRunning = options.isProcessRunning ?? defaultIsProcessRunning2;
+  const onDiagnostic = options.onDiagnostic;
+  return {
+    async acquire(meta) {
+      await mkdir5(dirname4(lockFilePath), { recursive: true });
+      while (true) {
+        try {
+          const handle = await open2(lockFilePath, "wx");
+          try {
+            await handle.writeFile(`${JSON.stringify(meta, null, 2)}
+`, "utf8");
+          } finally {
+            await handle.close();
+          }
+          await onDiagnostic?.("lock_acquired", {
+            lockFilePath,
+            pid: meta.pid,
+            mode: meta.mode,
+            configPath: meta.configPath,
+            statePath: meta.statePath,
+            hostname: meta.hostname
+          });
+          return;
+        } catch (error) {
+          const code = error.code;
+          if (code !== "EEXIST") {
+            throw error;
+          }
+          await onDiagnostic?.("lock_exists", {
+            lockFilePath,
+            pid: meta.pid,
+            mode: meta.mode
+          });
+          const existing = await loadLockMetadata(lockFilePath);
+          if (!existing) {
+            await rm4(lockFilePath, { force: true });
+            await onDiagnostic?.("lock_invalid_removed", {
+              lockFilePath,
+              reason: "invalid_or_unreadable_metadata"
+            });
+            continue;
+          }
+          if (!isProcessRunning(existing.pid)) {
+            await rm4(lockFilePath, { force: true });
+            await onDiagnostic?.("lock_stale_removed", {
+              lockFilePath,
+              stalePid: existing.pid,
+              staleMode: existing.mode,
+              staleConfigPath: existing.configPath,
+              staleStatePath: existing.statePath,
+              reason: "owner_process_not_running"
+            });
+            continue;
+          }
+          await onDiagnostic?.("lock_active_conflict", {
+            lockFilePath,
+            activePid: existing.pid,
+            activeMode: existing.mode,
+            activeConfigPath: existing.configPath,
+            activeStatePath: existing.statePath,
+            requestedPid: meta.pid,
+            requestedMode: meta.mode
+          });
+          throw new ActiveWeixinConsumerLockError(lockFilePath, existing);
+        }
+      }
+    },
+    async release() {
+      await rm4(lockFilePath, { force: true });
+      await onDiagnostic?.("lock_released", {
+        lockFilePath
+      });
+    }
+  };
+}
+async function loadLockMetadata(path) {
+  try {
+    const raw = await readFile3(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.pid !== "number" || !parsed.mode || !parsed.configPath || !parsed.statePath) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function defaultIsProcessRunning2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var ActiveWeixinConsumerLockError;
+var init_consumer_lock = __esm(() => {
+  ActiveWeixinConsumerLockError = class ActiveWeixinConsumerLockError extends Error {
+    existing;
+    lockFilePath;
+    constructor(lockFilePath, existing) {
+      super([
+        "weacpx Weixin consumer is already running.",
+        `pid: ${existing.pid}`,
+        `mode: ${existing.mode}`,
+        `config: ${existing.configPath}`,
+        `state: ${existing.statePath}`,
+        "Try stopping the existing instance or close the foreground `weacpx run` process before starting a new one."
+      ].join(`
+`));
+      this.name = "ActiveWeixinConsumerLockError";
+      this.lockFilePath = lockFilePath;
+      this.existing = existing;
+    }
+  };
+});
+
 // node_modules/qrcode-terminal/vendor/QRCode/QRMode.js
 var require_QRMode = __commonJS((exports, module) => {
   module.exports = {
@@ -2428,6 +2551,25 @@ var init_media_download = __esm(() => {
   WEIXIN_MEDIA_MAX_BYTES = 100 * 1024 * 1024;
 });
 
+// src/weixin/messaging/execute-chat-turn.ts
+async function executeChatTurn(params) {
+  let usedReply = false;
+  const response = await params.agent.chat({
+    ...params.request,
+    reply: async (text) => {
+      const delivered = await params.onReplySegment?.(text);
+      if (delivered !== false) {
+        usedReply = true;
+      }
+    }
+  });
+  return {
+    text: usedReply ? undefined : response.text,
+    media: response.media,
+    usedReply
+  };
+}
+
 // src/weixin/messaging/inbound.ts
 function contextTokenKey(accountId, userId) {
   return `${accountId}:${userId}`;
@@ -2826,23 +2968,29 @@ var init_slash_commands = __esm(() => {
   init_send();
 });
 
-// src/weixin/messaging/process-message.ts
+// src/weixin/messaging/handle-weixin-message-turn.ts
 import crypto4 from "node:crypto";
 import fs6 from "node:fs/promises";
+import { tmpdir } from "node:os";
 import path9 from "node:path";
-async function saveMediaBuffer(buffer, contentType, subdir, _maxBytes, originalFilename) {
-  const dir = path9.join(MEDIA_TEMP_DIR, subdir ?? "");
-  await fs6.mkdir(dir, { recursive: true });
-  let ext = ".bin";
-  if (originalFilename) {
-    ext = path9.extname(originalFilename) || ".bin";
-  } else if (contentType) {
-    ext = getExtensionFromMime(contentType);
-  }
-  const name = `${Date.now()}-${crypto4.randomBytes(4).toString("hex")}${ext}`;
-  const filePath = path9.join(dir, name);
-  await fs6.writeFile(filePath, buffer);
-  return { path: filePath };
+function resolveMediaTempDir(customRoot) {
+  return customRoot ?? path9.join(tmpdir(), "weacpx", "media");
+}
+function createSaveMediaBuffer(mediaTempDir) {
+  return async function saveMediaBuffer(buffer, contentType, subdir, _maxBytes, originalFilename) {
+    const dir = path9.join(resolveMediaTempDir(mediaTempDir), subdir ?? "");
+    await fs6.mkdir(dir, { recursive: true });
+    let ext = ".bin";
+    if (originalFilename) {
+      ext = path9.extname(originalFilename) || ".bin";
+    } else if (contentType) {
+      ext = getExtensionFromMime(contentType);
+    }
+    const name = `${Date.now()}-${crypto4.randomBytes(4).toString("hex")}${ext}`;
+    const filePath = path9.join(dir, name);
+    await fs6.writeFile(filePath, buffer);
+    return { path: filePath };
+  };
 }
 function extractTextBody(itemList) {
   if (!itemList?.length)
@@ -2857,13 +3005,13 @@ function extractTextBody(itemList) {
 function findMediaItem(itemList) {
   if (!itemList?.length)
     return;
-  const direct = itemList.find((i) => i.type === MessageItemType.IMAGE && hasDownloadableMedia(i.image_item?.media)) ?? itemList.find((i) => i.type === MessageItemType.VIDEO && hasDownloadableMedia(i.video_item?.media)) ?? itemList.find((i) => i.type === MessageItemType.FILE && hasDownloadableMedia(i.file_item?.media)) ?? itemList.find((i) => i.type === MessageItemType.VOICE && hasDownloadableMedia(i.voice_item?.media) && !i.voice_item?.text);
+  const direct = itemList.find((item) => item.type === MessageItemType.IMAGE && hasDownloadableMedia(item.image_item?.media)) ?? itemList.find((item) => item.type === MessageItemType.VIDEO && hasDownloadableMedia(item.video_item?.media)) ?? itemList.find((item) => item.type === MessageItemType.FILE && hasDownloadableMedia(item.file_item?.media)) ?? itemList.find((item) => item.type === MessageItemType.VOICE && hasDownloadableMedia(item.voice_item?.media) && !item.voice_item?.text);
   if (direct)
     return direct;
-  const refItem = itemList.find((i) => i.type === MessageItemType.TEXT && i.ref_msg?.message_item && isMediaItem(i.ref_msg.message_item));
+  const refItem = itemList.find((item) => item.type === MessageItemType.TEXT && item.ref_msg?.message_item && isMediaItem(item.ref_msg.message_item));
   return refItem?.ref_msg?.message_item ?? undefined;
 }
-async function processOneMessage(full, deps) {
+async function handleWeixinMessageTurn(full, deps) {
   const receivedAt = Date.now();
   const textBody = extractTextBody(full.item_list);
   if (textBody.startsWith("/")) {
@@ -2891,7 +3039,7 @@ async function processOneMessage(full, deps) {
     try {
       const downloaded = await downloadMediaFromItem(mediaItem, {
         cdnBaseUrl: deps.cdnBaseUrl,
-        saveMedia: saveMediaBuffer,
+        saveMedia: createSaveMediaBuffer(deps.mediaTempDir),
         log: deps.log,
         errLog: deps.errLog,
         label: "inbound"
@@ -2914,26 +3062,31 @@ async function processOneMessage(full, deps) {
         };
       }
     } catch (err) {
-      logger.error(`media download failed: ${String(err)}`);
+      deps.errLog(`media download failed: ${String(err)}`);
     }
   }
   const to = full.from_user_id ?? "";
-  const reply = async (text) => {
+  const sendReplySegment = async (text) => {
+    const plainText = markdownToPlainText(text).trim();
+    if (plainText.length === 0) {
+      return false;
+    }
     try {
       await sendMessageWeixin({
         to,
-        text: markdownToPlainText(text),
+        text: plainText,
         opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken }
       });
+      return true;
     } catch (err) {
-      logger.error(`intermediate reply failed: ${String(err)}`);
+      deps.errLog(`intermediate reply failed: ${String(err)}`);
+      return false;
     }
   };
   const request = {
     conversationId: full.from_user_id ?? "",
     text: bodyFromItemList(full.item_list),
-    media,
-    reply
+    media
   };
   let typingTimer;
   const startTyping = () => {
@@ -2954,31 +3107,40 @@ async function processOneMessage(full, deps) {
     typingTimer = setInterval(startTyping, 1e4);
   }
   try {
-    const response = await deps.agent.chat(request);
-    if (response.media) {
+    const turn = await executeChatTurn({
+      agent: deps.agent,
+      request,
+      onReplySegment: sendReplySegment
+    });
+    if (turn.media) {
       let filePath;
-      const mediaUrl = response.media.url;
+      const mediaUrl = turn.media.url;
       if (mediaUrl.startsWith("http://") || mediaUrl.startsWith("https://")) {
-        filePath = await downloadRemoteImageToTemp(mediaUrl, path9.join(MEDIA_TEMP_DIR, "outbound"));
+        filePath = await downloadRemoteImageToTemp(mediaUrl, path9.join(resolveMediaTempDir(deps.mediaTempDir), "outbound"));
       } else {
         filePath = path9.isAbsolute(mediaUrl) ? mediaUrl : path9.resolve(mediaUrl);
       }
       await sendWeixinMediaFile({
         filePath,
         to,
-        text: response.text ? markdownToPlainText(response.text) : "",
+        text: turn.text ? markdownToPlainText(turn.text) : "",
         opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken },
         cdnBaseUrl: deps.cdnBaseUrl
       });
-    } else if (response.text) {
+    } else if (turn.text) {
+      const finalText = markdownToPlainText(turn.text).trim();
+      if (finalText.length === 0) {
+        return;
+      }
       await sendMessageWeixin({
         to,
-        text: markdownToPlainText(response.text),
+        text: finalText,
         opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken }
       });
     }
   } catch (err) {
-    logger.error(`processOneMessage: agent or send failed: ${err instanceof Error ? err.stack ?? err.message : JSON.stringify(err)}`);
+    const errorText = err instanceof Error ? err.stack ?? err.message : JSON.stringify(err);
+    deps.errLog(`handleWeixinMessageTurn: agent or send failed: ${errorText}`);
     sendWeixinErrorNotice({
       to,
       contextToken,
@@ -3003,14 +3165,13 @@ async function processOneMessage(full, deps) {
     }
   }
 }
-var MEDIA_TEMP_DIR = "/tmp/weixin-agent/media", hasDownloadableMedia = (m) => m?.encrypt_query_param || m?.full_url;
-var init_process_message = __esm(() => {
+var hasDownloadableMedia = (media) => media?.encrypt_query_param || media?.full_url;
+var init_handle_weixin_message_turn = __esm(() => {
   init_api();
   init_types();
   init_upload();
   init_media_download();
   init_mime();
-  init_logger();
   init_inbound();
   init_error_notice();
   init_send_media();
@@ -3138,7 +3299,7 @@ async function monitorWeixinProvider(opts) {
         aLog.info(`inbound: from=${full.from_user_id} types=${full.item_list?.map((i) => i.type).join(",") ?? "none"}`);
         const fromUserId = full.from_user_id ?? "";
         const cachedConfig = await configManager.getForUser(fromUserId, full.context_token);
-        await processOneMessage(full, {
+        await handleWeixinMessageTurn(full, {
           accountId,
           agent,
           baseUrl,
@@ -3180,7 +3341,7 @@ var init_monitor = __esm(() => {
   init_api();
   init_config_cache();
   init_session_guard();
-  init_process_message();
+  init_handle_weixin_message_turn();
   init_sync_buf();
   init_logger();
 });
@@ -3327,93 +3488,9 @@ var init_weixin_sdk = __esm(() => {
   init_weixin();
 });
 
-// src/config/agent-templates.ts
-function getAgentTemplate(name) {
-  const template = TEMPLATES[name];
-  if (!template) {
-    return null;
-  }
-  return {
-    ...template
-  };
-}
-function listAgentTemplates() {
-  return Object.keys(TEMPLATES);
-}
-var TEMPLATES;
-var init_agent_templates = __esm(() => {
-  TEMPLATES = {
-    codex: {
-      driver: "codex"
-    },
-    claude: {
-      driver: "claude"
-    }
-  };
-});
-
-// src/formatting/render-text.ts
-function renderHelpText() {
-  return [
-    "可用命令：",
-    "",
-    "先看这 3 个：",
-    "/ss new <agent> -d <path> - 新建会话",
-    "/use <alias> - 切会话",
-    "/status - 看状态",
-    "",
-    "Agent：",
-    "/agents - 看 Agent",
-    "/agent add <codex|claude> - 加 Agent",
-    "/agent rm <name> - 删 Agent",
-    "",
-    "工作区：",
-    "/workspaces - 看工作区",
-    "/workspace 或 /ws - 工作区命令",
-    "/ws new <name> -d <path> - 加工作区",
-    "/workspace rm <name> - 删工作区",
-    "",
-    "会话：",
-    "/sessions - 看会话",
-    "/session 或 /ss - 会话命令",
-    "/ss <agent> -d <path> - 快速新建",
-    "/ss new <agent> -d <path> - 新建会话",
-    "/ss new <alias> -a <name> --ws <name> - 指定配置新建",
-    "/ss attach <alias> -a <name> --ws <name> --name <transport-session> - 挂已有会话",
-    "/use <alias> - 切会话",
-    "/session reset 或 /clear - 清上下文",
-    "",
-    "权限：",
-    "/pm 或 /permission - 权限设置",
-    "/pm set <allow|read|deny> - 设审批级别",
-    "/pm auto [allow|deny|fail] - 设自动处理",
-    "",
-    "常用：",
-    "/status - 看状态",
-    "/cancel 或 /stop - 停当前任务"
-  ].join(`
-`);
-}
-function renderAgents(config) {
-  const names = Object.keys(config.agents);
-  if (names.length === 0) {
-    return "还没有注册任何 Agent。";
-  }
-  return ["已注册的 Agent：", ...names.map((name) => `- ${name}`)].join(`
-`);
-}
-function renderWorkspaces(config) {
-  const names = Object.entries(config.workspaces);
-  if (names.length === 0) {
-    return "还没有注册任何工作区。";
-  }
-  return ["已注册的工作区：", ...names.map(([name, workspace]) => `- ${name}: ${workspace.cwd}`)].join(`
-`);
-}
-
 // src/logging/app-logger.ts
-import { appendFile, mkdir as mkdir5, readdir, rename, rm as rm4, stat } from "node:fs/promises";
-import { basename, dirname as dirname4, join as join2 } from "node:path";
+import { appendFile, mkdir as mkdir6, readdir, rename, rm as rm5, stat } from "node:fs/promises";
+import { basename, dirname as dirname5, join as join3 } from "node:path";
 function createNoopAppLogger() {
   return {
     debug: async () => {},
@@ -3443,7 +3520,7 @@ function createAppLogger(options) {
       return;
     }
     const line = formatLogLine(now(), level, event, message, context);
-    await mkdir5(dirname4(options.filePath), { recursive: true });
+    await mkdir6(dirname5(options.filePath), { recursive: true });
     await rotateIfNeeded(options.filePath, Buffer.byteLength(line), options.maxSizeBytes, options.maxFiles);
     await appendFile(options.filePath, line, "utf8");
   }
@@ -3464,10 +3541,10 @@ async function rotateIfNeeded(filePath, incomingSize, maxSizeBytes, maxFiles) {
     return;
   }
   if (maxFiles <= 0) {
-    await rm4(filePath, { force: true });
+    await rm5(filePath, { force: true });
     return;
   }
-  await rm4(`${filePath}.${maxFiles}`, { force: true });
+  await rm5(`${filePath}.${maxFiles}`, { force: true });
   for (let index = maxFiles - 1;index >= 1; index -= 1) {
     const source = `${filePath}.${index}`;
     try {
@@ -3481,7 +3558,7 @@ async function rotateIfNeeded(filePath, incomingSize, maxSizeBytes, maxFiles) {
   await rename(filePath, `${filePath}.1`);
 }
 async function cleanupExpiredRotatedLogs(filePath, retentionDays, now) {
-  const parentDir = dirname4(filePath);
+  const parentDir = dirname5(filePath);
   const prefix = `${basename(filePath)}.`;
   const cutoff = now().getTime() - retentionDays * 24 * 60 * 60 * 1000;
   let files = [];
@@ -3497,10 +3574,10 @@ async function cleanupExpiredRotatedLogs(filePath, retentionDays, now) {
     if (!file.startsWith(prefix) || !/^\d+$/.test(file.slice(prefix.length))) {
       continue;
     }
-    const candidate = join2(parentDir, file);
+    const candidate = join3(parentDir, file);
     const details = await stat(candidate);
     if (details.mtime.getTime() < cutoff) {
-      await rm4(candidate, { force: true });
+      await rm5(candidate, { force: true });
     }
   }
 }
@@ -3532,16 +3609,16 @@ var init_app_logger = __esm(() => {
 });
 
 // src/transport/acpx-session-index.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { homedir } from "node:os";
+import { readFile as readFile4 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
 import { resolve } from "node:path";
 async function resolveSessionAgentCommandFromIndex(session) {
-  const home = process.env.HOME ?? homedir();
+  const home = process.env.HOME ?? homedir2();
   if (!home) {
     return;
   }
   try {
-    const raw = await readFile3(resolve(home, ".acpx", "sessions", "index.json"), "utf8");
+    const raw = await readFile4(resolve(home, ".acpx", "sessions", "index.json"), "utf8");
     const parsed = JSON.parse(raw);
     const targetCwd = resolve(session.cwd);
     const match = parsed.entries?.find((entry) => entry.name === session.transportSession && entry.cwd === targetCwd && typeof entry.agentCommand === "string" && entry.agentCommand.trim().length > 0);
@@ -3692,8 +3769,10 @@ function parseCommand(input) {
   }
   const parts = tokenizeCommand(trimmed);
   const command = normalizeCommand(parts[0] ?? "");
-  if (command === "/help")
+  if (command === "/help" && parts.length === 1)
     return { kind: "help" };
+  if (command === "/help" && parts.length === 2)
+    return { kind: "help", topic: parts[1] };
   if (command === "/agents")
     return { kind: "agents" };
   if (command === "/workspaces")
@@ -3708,6 +3787,10 @@ function parseCommand(input) {
     return { kind: "session.reset" };
   if (command === "/mode" && parts.length === 1)
     return { kind: "mode.show" };
+  if (command === "/replymode" && parts.length === 1)
+    return { kind: "replymode.show" };
+  if (command === "/config" && parts.length === 1)
+    return { kind: "config.show" };
   if (command === "/permission" && parts.length === 1)
     return { kind: "permission.status" };
   if (command === "/session" && parts.length === 1)
@@ -3731,12 +3814,21 @@ function parseCommand(input) {
       return { kind: "permission.auto.set", policy };
     }
   }
+  if (command === "/config" && parts[1] === "set" && parts.length === 4) {
+    return { kind: "config.set", path: parts[2] ?? "", value: parts[3] ?? "" };
+  }
   if (command === "/use" && parts[1]) {
     return { kind: "session.use", alias: parts[1] };
   }
   if (command === "/mode" && parts[1]) {
     return { kind: "mode.set", modeId: parts[1] };
   }
+  if (command === "/replymode" && parts[1] === "reset" && parts.length === 2) {
+    return { kind: "replymode.reset" };
+  }
+  if (command === "/replymode" && (parts[1] === "stream" || parts[1] === "final") && parts.length === 2) {
+    return { kind: "replymode.set", replyMode: parts[1] };
+  }
   if (command === "/agent" && parts[1] === "add" && parts[2]) {
     return { kind: "agent.add", template: parts[2] };
   }
@@ -3746,13 +3838,23 @@ function parseCommand(input) {
   if (command === "/workspace" && parts[1] === "new" && parts[2]) {
     const name = parts[2];
     let cwd = "";
+    let invalid = false;
     for (let index = 3;index < parts.length; index += 1) {
       if (parts[index] === "--cwd" || parts[index] === "-d") {
+        if (index + 1 >= parts.length) {
+          invalid = true;
+          break;
+        }
         cwd = parts[index + 1] ?? "";
         index += 1;
+        continue;
       }
+      invalid = true;
+      break;
+    }
+    if (!invalid && name.trim().length > 0 && cwd.trim().length > 0) {
+      return { kind: "workspace.new", name, cwd };
     }
-    return { kind: "workspace.new", name, cwd };
   }
   if (command === "/workspace" && parts[1] === "rm" && parts[2]) {
     return { kind: "workspace.rm", name: parts[2] };
@@ -3762,26 +3864,41 @@ function parseCommand(input) {
       const alias = parts[2];
       let agent = "";
       let workspace = "";
+      let invalid = false;
       for (let index = 3;index < parts.length; index += 1) {
         if (parts[index] === "--agent" || parts[index] === "-a") {
+          if (index + 1 >= parts.length) {
+            invalid = true;
+            break;
+          }
           agent = parts[index + 1] ?? "";
           index += 1;
+          continue;
         } else if (parts[index] === "--ws" || parts[index] === "-ws") {
+          if (index + 1 >= parts.length) {
+            invalid = true;
+            break;
+          }
           workspace = parts[index + 1] ?? "";
           index += 1;
+          continue;
         }
+        invalid = true;
+        break;
+      }
+      if (!invalid && alias.trim().length > 0 && agent.trim().length > 0 && workspace.trim().length > 0) {
+        return { kind: "session.new", alias, agent, workspace };
       }
-      return { kind: "session.new", alias, agent, workspace };
     }
-    const cwd = readFlagValue(parts, ["--cwd", "-d"]);
-    if (cwd) {
-      return { kind: "session.shortcut.new", agent: parts[2], cwd };
+    const shortcutTarget = readSessionShortcutTarget(parts, 3);
+    if (shortcutTarget) {
+      return { kind: "session.shortcut.new", agent: parts[2], ...shortcutTarget };
     }
   }
   if (command === "/session" && parts[1] && parts[1] !== "new" && parts[1] !== "attach" && parts[1] !== "reset") {
-    const cwd = readFlagValue(parts, ["--cwd", "-d"]);
-    if (cwd) {
-      return { kind: "session.shortcut", agent: parts[1], cwd };
+    const shortcutTarget = readSessionShortcutTarget(parts, 2);
+    if (shortcutTarget) {
+      return { kind: "session.shortcut", agent: parts[1], ...shortcutTarget };
     }
   }
   if (command === "/session" && parts[1] === "attach" && parts[2]) {
@@ -3789,19 +3906,39 @@ function parseCommand(input) {
     let agent = "";
     let workspace = "";
     let transportSession = "";
+    let invalid = false;
     for (let index = 3;index < parts.length; index += 1) {
       if (parts[index] === "--agent" || parts[index] === "-a") {
+        if (index + 1 >= parts.length) {
+          invalid = true;
+          break;
+        }
         agent = parts[index + 1] ?? "";
         index += 1;
+        continue;
       } else if (parts[index] === "--ws" || parts[index] === "-ws") {
+        if (index + 1 >= parts.length) {
+          invalid = true;
+          break;
+        }
         workspace = parts[index + 1] ?? "";
         index += 1;
+        continue;
       } else if (parts[index] === "--name") {
+        if (index + 1 >= parts.length) {
+          invalid = true;
+          break;
+        }
         transportSession = parts[index + 1] ?? "";
         index += 1;
+        continue;
       }
+      invalid = true;
+      break;
+    }
+    if (!invalid && alias.trim().length > 0 && agent.trim().length > 0 && workspace.trim().length > 0 && transportSession.trim().length > 0) {
+      return { kind: "session.attach", alias, agent, workspace, transportSession };
     }
-    return { kind: "session.attach", alias, agent, workspace, transportSession };
   }
   if (command.startsWith("/") && isRecognizedCommand(command)) {
     return { kind: "invalid", text: trimmed, recognizedCommand: command };
@@ -3811,13 +3948,42 @@ function parseCommand(input) {
 function hasAnyFlag(parts, flags) {
   return parts.some((part) => flags.includes(part));
 }
-function readFlagValue(parts, flags) {
-  for (let index = 0;index < parts.length; index += 1) {
-    if (flags.includes(parts[index] ?? "")) {
-      return parts[index + 1] ?? "";
+function readSessionShortcutTarget(parts, startIndex) {
+  let cwd = "";
+  let workspace = "";
+  let invalid = false;
+  for (let index = startIndex;index < parts.length; index += 1) {
+    if (parts[index] === "--cwd" || parts[index] === "-d") {
+      if (index + 1 >= parts.length || workspace) {
+        invalid = true;
+        break;
+      }
+      cwd = parts[index + 1] ?? "";
+      index += 1;
+      continue;
+    }
+    if (parts[index] === "--ws" || parts[index] === "-ws") {
+      if (index + 1 >= parts.length || cwd) {
+        invalid = true;
+        break;
+      }
+      workspace = parts[index + 1] ?? "";
+      index += 1;
+      continue;
     }
+    invalid = true;
+    break;
   }
-  return "";
+  if (invalid) {
+    return null;
+  }
+  if (cwd.trim().length > 0) {
+    return { cwd };
+  }
+  if (workspace.trim().length > 0) {
+    return { workspace };
+  }
+  return null;
 }
 function normalizeCommand(command) {
   if (command === "/ss")
@@ -3843,7 +4009,7 @@ function toPermissionMode(value) {
   return null;
 }
 function toNonInteractivePermission(value) {
-  if (value === "allow" || value === "deny" || value === "fail") {
+  if (value === "deny" || value === "fail") {
     return value;
   }
   return null;
@@ -3890,6 +4056,8 @@ var init_parse_command = __esm(() => {
     "/cancel",
     "/clear",
     "/mode",
+    "/replymode",
+    "/config",
     "/permission",
     "/session",
     "/workspace",
@@ -3898,431 +4066,1228 @@ var init_parse_command = __esm(() => {
   ]);
 });
 
-// src/commands/command-router.ts
-import { access } from "node:fs/promises";
-import { basename as basename2, normalize } from "node:path";
-import { homedir as homedir2 } from "node:os";
+// src/commands/config-clone.ts
+function cloneAppConfig(config) {
+  return {
+    transport: { ...config.transport },
+    logging: { ...config.logging },
+    wechat: { ...config.wechat },
+    agents: Object.fromEntries(Object.entries(config.agents).map(([name, agent]) => [name, { ...agent }])),
+    workspaces: Object.fromEntries(Object.entries(config.workspaces).map(([name, workspace]) => [name, { ...workspace }]))
+  };
+}
 
-class CommandRouter {
-  sessions;
-  transport;
-  config;
-  configStore;
-  resolveSessionAgentCommand;
-  logger;
-  constructor(sessions, transport, config, configStore, logger2, resolveSessionAgentCommand = resolveSessionAgentCommandFromIndex) {
-    this.sessions = sessions;
-    this.transport = transport;
-    this.config = config;
-    this.configStore = configStore;
-    this.resolveSessionAgentCommand = resolveSessionAgentCommand;
-    this.logger = logger2 ?? createNoopAppLogger();
+// src/commands/handlers/permission-handler.ts
+function handlePermissionStatus(context, title) {
+  return { text: renderPermissionStatus(context.config, title) };
+}
+async function handlePermissionModeSet(context, mode) {
+  if (!context.config || !context.configStore) {
+    return { text: "当前没有加载可写入的配置。" };
   }
-  async handle(chatKey, input, reply) {
-    const startedAt = Date.now();
-    const command = parseCommand(input);
-    await this.logger.debug("command.parsed", "parsed inbound command", {
-      chatKey,
-      kind: command.kind
-    });
-    return await this.executeCommand(chatKey, command.kind, startedAt, async () => {
-      switch (command.kind) {
-        case "invalid":
-          return {
-            text: [
-              "无法识别的命令格式。",
-              "",
-              "正确的会话创建格式：",
-              "/session new <别名> --agent <Agent名> --ws <工作区名>",
-              "",
-              "例如：",
-              "/session new demo --agent claude --ws weacpx"
-            ].join(`
+  const previous = cloneAppConfig(context.config);
+  const updated = await context.configStore.updateTransport({
+    permissionMode: mode
+  });
+  try {
+    await context.transport.updatePermissionPolicy?.(updated.transport);
+  } catch (error) {
+    await context.configStore.save(previous);
+    context.replaceConfig(previous);
+    throw error;
+  }
+  context.replaceConfig(updated);
+  return { text: renderPermissionStatus(context.config, "权限模式已更新：") };
+}
+function handlePermissionAutoStatus(context, title) {
+  return { text: renderPermissionStatus(context.config, title) };
+}
+async function handlePermissionAutoSet(context, policy) {
+  if (!context.config || !context.configStore) {
+    return { text: "当前没有加载可写入的配置。" };
+  }
+  const previous = cloneAppConfig(context.config);
+  const updated = await context.configStore.updateTransport({
+    nonInteractivePermissions: policy
+  });
+  try {
+    await context.transport.updatePermissionPolicy?.(updated.transport);
+  } catch (error) {
+    await context.configStore.save(previous);
+    context.replaceConfig(previous);
+    throw error;
+  }
+  context.replaceConfig(updated);
+  return { text: renderPermissionStatus(context.config, "非交互策略已更新：") };
+}
+function renderPermissionStatus(config, title) {
+  const permissionMode = config?.transport.permissionMode ?? "approve-all";
+  const nonInteractivePermissions = config?.transport.nonInteractivePermissions ?? "deny";
+  return [title, `- mode: ${permissionMode}`, `- auto: ${nonInteractivePermissions}`].join(`
+`);
+}
+var permissionHelp;
+var init_permission_handler = __esm(() => {
+  permissionHelp = {
+    topic: "permission",
+    aliases: ["pm"],
+    summary: "查看和修改 transport 权限策略。",
+    commands: [
+      { usage: "/pm 或 /permission", description: "查看当前权限模式" },
+      { usage: "/pm set <allow|read|deny>", description: "设置审批级别" },
+      { usage: "/pm auto", description: "查看当前非交互策略" },
+      { usage: "/pm auto <deny|fail>", description: "设置非交互策略" }
+    ],
+    examples: ["/pm set read", "/pm auto deny"]
+  };
+});
+
+// src/commands/handlers/config-handler.ts
+function handleConfigShow(context) {
+  const lines = ["支持修改的配置字段：", ...SUPPORTED_CONFIG_PATHS.map((path11) => `- ${path11}`)];
+  if (context.config) {
+    lines.push("", "示例：", "- /config set wechat.replyMode final", "- /config set logging.level debug");
+  }
+  return { text: lines.join(`
+`) };
+}
+async function handleConfigSet(context, path11, rawValue) {
+  if (!context.config || !context.configStore) {
+    return { text: "当前没有加载可写入的配置。" };
+  }
+  const previous = cloneAppConfig(context.config);
+  const updated = cloneAppConfig(context.config);
+  const result = applySupportedConfigUpdate(updated, path11, rawValue);
+  if ("error" in result) {
+    return { text: result.error };
+  }
+  await context.configStore.save(updated);
+  if (path11 === "transport.permissionMode" || path11 === "transport.nonInteractivePermissions") {
+    try {
+      await context.transport.updatePermissionPolicy?.(updated.transport);
+    } catch (error) {
+      await context.configStore.save(previous);
+      context.replaceConfig(previous);
+      throw error;
+    }
+  }
+  context.replaceConfig(updated);
+  return { text: `配置已更新：${path11} = ${result.renderedValue}` };
+}
+function applySupportedConfigUpdate(config, path11, rawValue) {
+  switch (path11) {
+    case "transport.type": {
+      const parsed = parseEnum(rawValue, ["acpx-cli", "acpx-bridge"]);
+      if (!parsed)
+        return { error: "transport.type 只支持：acpx-cli、acpx-bridge" };
+      config.transport.type = parsed;
+      return { renderedValue: parsed };
+    }
+    case "transport.command":
+      if (!rawValue.trim())
+        return { error: "transport.command 不能为空。" };
+      config.transport.command = rawValue;
+      return { renderedValue: rawValue };
+    case "transport.sessionInitTimeoutMs": {
+      const parsed = parsePositiveNumber(rawValue, "transport.sessionInitTimeoutMs");
+      if ("error" in parsed)
+        return parsed;
+      config.transport.sessionInitTimeoutMs = parsed.value;
+      return { renderedValue: String(parsed.value) };
+    }
+    case "transport.permissionMode": {
+      const parsed = parseEnum(rawValue, ["approve-all", "approve-reads", "deny-all"]);
+      if (!parsed)
+        return { error: "transport.permissionMode 只支持：approve-all、approve-reads、deny-all" };
+      config.transport.permissionMode = parsed;
+      return { renderedValue: parsed };
+    }
+    case "transport.nonInteractivePermissions": {
+      const parsed = parseEnum(rawValue, ["deny", "fail"]);
+      if (!parsed)
+        return { error: "transport.nonInteractivePermissions 只支持：deny、fail" };
+      config.transport.nonInteractivePermissions = parsed;
+      return { renderedValue: parsed };
+    }
+    case "logging.level": {
+      const parsed = parseEnum(rawValue, ["error", "info", "debug"]);
+      if (!parsed)
+        return { error: "logging.level 只支持：error、info、debug" };
+      config.logging.level = parsed;
+      return { renderedValue: parsed };
+    }
+    case "logging.maxSizeBytes": {
+      const parsed = parsePositiveNumber(rawValue, "logging.maxSizeBytes");
+      if ("error" in parsed)
+        return parsed;
+      config.logging.maxSizeBytes = parsed.value;
+      return { renderedValue: String(parsed.value) };
+    }
+    case "logging.maxFiles": {
+      const parsed = parsePositiveNumber(rawValue, "logging.maxFiles");
+      if ("error" in parsed)
+        return parsed;
+      config.logging.maxFiles = parsed.value;
+      return { renderedValue: String(parsed.value) };
+    }
+    case "logging.retentionDays": {
+      const parsed = parsePositiveNumber(rawValue, "logging.retentionDays");
+      if ("error" in parsed)
+        return parsed;
+      config.logging.retentionDays = parsed.value;
+      return { renderedValue: String(parsed.value) };
+    }
+    case "wechat.replyMode": {
+      const parsed = parseEnum(rawValue, ["stream", "final"]);
+      if (!parsed)
+        return { error: "wechat.replyMode 只支持：stream、final" };
+      config.wechat.replyMode = parsed;
+      return { renderedValue: parsed };
+    }
+  }
+  const agentMatch = path11.match(/^agents\.([^.]+)\.(driver|command)$/);
+  if (agentMatch) {
+    const [, name, field] = agentMatch;
+    if (!name || !field) {
+      return { error: `不支持修改这个配置路径：${path11}` };
+    }
+    const agent = config.agents[name];
+    if (!agent) {
+      return { error: `Agent「${name}」不存在，请先创建。` };
+    }
+    if (!rawValue.trim()) {
+      return { error: `${path11} 不能为空。` };
+    }
+    if (field === "driver") {
+      agent.driver = rawValue;
+    } else {
+      agent.command = rawValue;
+    }
+    return { renderedValue: rawValue };
+  }
+  const workspaceMatch = path11.match(/^workspaces\.([^.]+)\.(cwd|description)$/);
+  if (workspaceMatch) {
+    const [, name, field] = workspaceMatch;
+    if (!name || !field) {
+      return { error: `不支持修改这个配置路径：${path11}` };
+    }
+    const workspace = config.workspaces[name];
+    if (!workspace) {
+      return { error: `工作区「${name}」不存在，请先创建。` };
+    }
+    if (!rawValue.trim()) {
+      return { error: `${path11} 不能为空。` };
+    }
+    if (field === "cwd") {
+      workspace.cwd = rawValue;
+    } else {
+      workspace.description = rawValue;
+    }
+    return { renderedValue: rawValue };
+  }
+  return { error: `不支持修改这个配置路径：${path11}` };
+}
+function parseEnum(value, allowed) {
+  return allowed.includes(value) ? value : null;
+}
+function parsePositiveNumber(rawValue, path11) {
+  const value = Number(rawValue);
+  if (!Number.isFinite(value) || value <= 0) {
+    return { error: `${path11} 必须是正数。` };
+  }
+  return { value };
+}
+var SUPPORTED_CONFIG_PATHS, configHelp;
+var init_config_handler = __esm(() => {
+  SUPPORTED_CONFIG_PATHS = [
+    "transport.type",
+    "transport.command",
+    "transport.sessionInitTimeoutMs",
+    "transport.permissionMode",
+    "transport.nonInteractivePermissions",
+    "logging.level",
+    "logging.maxSizeBytes",
+    "logging.maxFiles",
+    "logging.retentionDays",
+    "wechat.replyMode",
+    "agents.<name>.driver",
+    "agents.<name>.command",
+    "workspaces.<name>.cwd",
+    "workspaces.<name>.description"
+  ];
+  configHelp = {
+    topic: "config",
+    aliases: [],
+    summary: "查看和修改受支持的配置字段。",
+    commands: [
+      { usage: "/config", description: "查看当前支持修改的配置路径" },
+      { usage: "/config set <path> <value>", description: "修改一个受支持的配置值" }
+    ],
+    examples: ["/config set wechat.replyMode final", "/config set logging.level debug"]
+  };
+});
+
+// src/commands/handlers/session-handler.ts
+async function handleSessions(context, chatKey) {
+  const sessions = await context.sessions.listSessions(chatKey);
+  if (sessions.length === 0) {
+    return { text: "还没有会话。请先执行 /session new <alias> --agent <name> --ws <name>。" };
+  }
+  return {
+    text: [
+      "会话列表：",
+      ...sessions.map((session) => `- ${session.alias} (${session.agent} @ ${session.workspace})${session.isCurrent ? " [当前]" : ""}`)
+    ].join(`
 `)
-          };
-        case "help":
-          return { text: renderHelpText() };
-        case "agents":
-          return { text: this.config ? renderAgents(this.config) : "No config loaded." };
-        case "agent.add": {
-          if (!this.config || !this.configStore) {
-            return { text: "当前没有加载可写入的配置。" };
-          }
-          const template = getAgentTemplate(command.template);
-          if (!template) {
-            return { text: `暂不支持这个 Agent 模板。当前可用：${listAgentTemplates().join("、")}` };
-          }
-          const updated = await this.configStore.upsertAgent(command.template, template);
-          this.replaceConfig(updated);
-          return { text: `Agent「${command.template}」已保存` };
-        }
-        case "agent.rm": {
-          if (!this.config || !this.configStore) {
-            return { text: "当前没有加载可写入的配置。" };
-          }
-          if (!this.config.agents[command.name]) {
-            return { text: "没有找到这个 Agent。" };
-          }
-          const updated = await this.configStore.removeAgent(command.name);
-          this.replaceConfig(updated);
-          return { text: `Agent「${command.name}」已删除` };
-        }
-        case "permission.status":
-          return { text: this.renderPermissionStatus("当前权限模式：") };
-        case "permission.mode.set": {
-          if (!this.config || !this.configStore) {
-            return { text: "当前没有加载可写入的配置。" };
-          }
-          const updated = await this.configStore.updateTransport({
-            permissionMode: command.mode
-          });
-          this.replaceConfig(updated);
-          return { text: this.renderPermissionStatus("权限模式已更新：") };
-        }
-        case "permission.auto.status":
-          return { text: this.renderPermissionStatus("当前非交互策略：") };
-        case "permission.auto.set": {
-          if (!this.config || !this.configStore) {
-            return { text: "当前没有加载可写入的配置。" };
-          }
-          const updated = await this.configStore.updateTransport({
-            nonInteractivePermissions: command.policy
-          });
-          this.replaceConfig(updated);
-          return { text: this.renderPermissionStatus("非交互策略已更新：") };
-        }
-        case "workspaces":
-          return { text: this.config ? renderWorkspaces(this.config) : "No config loaded." };
-        case "workspace.new": {
-          if (!this.config || !this.configStore) {
-            return { text: "当前没有加载可写入的配置。" };
-          }
-          const wsCwd = normalizePathForWorkspace(command.cwd);
-          if (!await pathExists(wsCwd)) {
-            return { text: `工作区路径不存在：${command.cwd}` };
-          }
-          const updated = await this.configStore.upsertWorkspace(command.name, wsCwd);
-          this.replaceConfig(updated);
-          return { text: `工作区「${command.name}」已保存` };
-        }
-        case "workspace.rm": {
-          if (!this.config || !this.configStore) {
-            return { text: "当前没有加载可写入的配置。" };
-          }
-          const updated = await this.configStore.removeWorkspace(command.name);
-          this.replaceConfig(updated);
-          return { text: `工作区「${command.name}」已删除` };
-        }
-        case "sessions": {
-          const sessions = await this.sessions.listSessions(chatKey);
-          if (sessions.length === 0) {
-            return { text: "还没有会话。请先执行 /session new <alias> --agent <name> --ws <name>。" };
-          }
-          return {
-            text: [
-              "会话列表：",
-              ...sessions.map((session) => `- ${session.alias} (${session.agent} @ ${session.workspace})${session.isCurrent ? " [当前]" : ""}`)
-            ].join(`
+  };
+}
+async function handleSessionNew(context, chatKey, alias, agent, workspace) {
+  const session = context.lifecycle.resolveSession(alias, agent, workspace, `${workspace}:${alias}`);
+  try {
+    await context.lifecycle.ensureTransportSession(session);
+    const exists = await context.lifecycle.checkTransportSession(session);
+    if (!exists) {
+      return context.recovery.renderSessionCreationVerificationError(session);
+    }
+  } catch (error) {
+    return context.recovery.renderSessionCreationError(session, error);
+  }
+  await context.sessions.attachSession(alias, agent, workspace, session.transportSession);
+  await context.lifecycle.refreshSessionTransportAgentCommand(alias);
+  await context.sessions.useSession(chatKey, alias);
+  await context.logger.info("session.created", "created and selected logical session", {
+    alias,
+    agent,
+    workspace
+  });
+  return { text: `会话「${alias}」已创建并切换` };
+}
+async function handleSessionShortcut(context, chatKey, agent, target, createNew) {
+  return await context.lifecycle.handleSessionShortcut(chatKey, agent, target, createNew);
+}
+async function handleSessionAttach(context, chatKey, alias, agent, workspace, transportSession) {
+  const attached = context.lifecycle.resolveSession(alias, agent, workspace, transportSession);
+  const exists = await context.lifecycle.checkTransportSession(attached);
+  if (!exists) {
+    return {
+      text: [
+        "没有找到可绑定的已有会话。",
+        `请确认会话名是否正确，然后重新执行：/session attach ${alias} --agent ${agent} --ws ${workspace} --name <会话名>`
+      ].join(`
 `)
-          };
-        }
-        case "session.new": {
-          const session = this.sessions.resolveSession(command.alias, command.agent, command.workspace, `${command.workspace}:${command.alias}`);
-          try {
-            await this.ensureTransportSession(session);
-            const exists = await this.checkTransportSession(session);
-            if (!exists) {
-              return this.renderSessionCreationVerificationError(session);
-            }
-          } catch (error) {
-            return this.renderSessionCreationError(session, error);
-          }
-          await this.sessions.attachSession(command.alias, command.agent, command.workspace, session.transportSession);
-          await this.refreshSessionTransportAgentCommand(command.alias);
-          await this.sessions.useSession(chatKey, command.alias);
-          await this.logger.info("session.created", "created and selected logical session", {
-            alias: command.alias,
-            agent: command.agent,
-            workspace: command.workspace
-          });
-          return { text: `会话「${command.alias}」已创建并切换` };
-        }
-        case "session.shortcut":
-          return await this.handleSessionShortcut(chatKey, command.agent, command.cwd, false);
-        case "session.shortcut.new":
-          return await this.handleSessionShortcut(chatKey, command.agent, command.cwd, true);
-        case "session.attach": {
-          const attached = this.sessions.resolveSession(command.alias, command.agent, command.workspace, command.transportSession);
-          const exists = await this.checkTransportSession(attached);
-          if (!exists) {
-            return {
-              text: [
-                "没有找到可绑定的已有会话。",
-                `请确认会话名是否正确，然后重新执行：/session attach ${command.alias} --agent ${command.agent} --ws ${command.workspace} --name <会话名>`
-              ].join(`
+    };
+  }
+  await context.sessions.attachSession(alias, agent, workspace, transportSession);
+  await context.lifecycle.refreshSessionTransportAgentCommand(alias);
+  await context.sessions.useSession(chatKey, alias);
+  await context.logger.info("session.attached", "attached existing transport session", {
+    alias,
+    agent,
+    workspace,
+    transportSession
+  });
+  return { text: `会话「${alias}」已绑定并切换` };
+}
+async function handleSessionUse(context, chatKey, alias) {
+  await context.sessions.useSession(chatKey, alias);
+  await context.logger.info("session.selected", "selected logical session", {
+    alias,
+    chatKey
+  });
+  return { text: `已切换到会话「${alias}」` };
+}
+async function handleModeShow(context, chatKey) {
+  const session = await context.sessions.getCurrentSession(chatKey);
+  if (!session) {
+    return { text: NO_CURRENT_SESSION_TEXT };
+  }
+  return {
+    text: [
+      "当前 mode：",
+      `- 会话：${session.alias}`,
+      `- mode：${session.modeId ?? "未设置"}`
+    ].join(`
 `)
-            };
-          }
-          await this.sessions.attachSession(command.alias, command.agent, command.workspace, command.transportSession);
-          await this.refreshSessionTransportAgentCommand(command.alias);
-          await this.sessions.useSession(chatKey, command.alias);
-          await this.logger.info("session.attached", "attached existing transport session", {
-            alias: command.alias,
-            agent: command.agent,
-            workspace: command.workspace,
-            transportSession: command.transportSession
-          });
-          return { text: `会话「${command.alias}」已绑定并切换` };
-        }
-        case "session.use":
-          await this.sessions.useSession(chatKey, command.alias);
-          await this.logger.info("session.selected", "selected logical session", {
-            alias: command.alias,
-            chatKey
-          });
-          return { text: `已切换到会话「${command.alias}」` };
-        case "mode.show": {
-          const session = await this.sessions.getCurrentSession(chatKey);
-          if (!session) {
-            return { text: "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。" };
-          }
-          return {
-            text: [
-              "当前 mode：",
-              `- 会话：${session.alias}`,
-              `- mode：${session.modeId ?? "未设置"}`
-            ].join(`
+  };
+}
+async function handleModeSet(context, chatKey, modeId) {
+  const session = await context.sessions.getCurrentSession(chatKey);
+  if (!session) {
+    return { text: NO_CURRENT_SESSION_TEXT };
+  }
+  await context.interaction.setModeTransportSession(session, modeId);
+  await context.sessions.setCurrentSessionMode(chatKey, modeId);
+  return { text: `已设置当前会话 mode：${modeId}` };
+}
+async function handleReplyModeShow(context, chatKey) {
+  const session = await context.sessions.getCurrentSession(chatKey);
+  if (!session) {
+    return { text: NO_CURRENT_SESSION_TEXT };
+  }
+  const globalDefault = context.config?.wechat.replyMode ?? "stream";
+  const sessionOverride = session.replyMode;
+  const effective = sessionOverride ?? globalDefault;
+  return {
+    text: [
+      "当前 reply mode：",
+      `- 会话：${session.alias}`,
+      `- 全局默认：${globalDefault}`,
+      `- 当前会话覆盖：${sessionOverride ?? "未设置"}`,
+      `- 当前生效：${effective}`
+    ].join(`
 `)
-          };
-        }
-        case "mode.set": {
-          const session = await this.sessions.getCurrentSession(chatKey);
-          if (!session) {
-            return { text: "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。" };
-          }
-          await this.setModeTransportSession(session, command.modeId);
-          await this.sessions.setCurrentSessionMode(chatKey, command.modeId);
-          return { text: `已设置当前会话 mode：${command.modeId}` };
-        }
-        case "status": {
-          const session = await this.sessions.getCurrentSession(chatKey);
-          if (!session) {
-            return { text: "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。" };
-          }
-          return {
-            text: [
-              "当前会话：",
-              `- 名称：${session.alias}`,
-              `- Agent：${session.agent}`,
-              `- 工作区：${session.workspace}`
-            ].join(`
+  };
+}
+async function handleReplyModeSet(context, chatKey, replyMode) {
+  const session = await context.sessions.getCurrentSession(chatKey);
+  if (!session) {
+    return { text: NO_CURRENT_SESSION_TEXT };
+  }
+  await context.sessions.setCurrentSessionReplyMode(chatKey, replyMode);
+  return { text: `已设置当前会话 reply mode：${replyMode}` };
+}
+async function handleReplyModeReset(context, chatKey) {
+  const session = await context.sessions.getCurrentSession(chatKey);
+  if (!session) {
+    return { text: NO_CURRENT_SESSION_TEXT };
+  }
+  await context.sessions.setCurrentSessionReplyMode(chatKey, undefined);
+  const globalDefault = context.config?.wechat.replyMode ?? "stream";
+  return { text: `已重置当前会话 reply mode，当前回退到全局默认：${globalDefault}` };
+}
+async function handleStatus(context, chatKey) {
+  const session = await context.sessions.getCurrentSession(chatKey);
+  if (!session) {
+    return { text: NO_CURRENT_SESSION_TEXT };
+  }
+  return {
+    text: [
+      "当前会话：",
+      `- 名称：${session.alias}`,
+      `- Agent：${session.agent}`,
+      `- 工作区：${session.workspace}`
+    ].join(`
 `)
-          };
-        }
-        case "cancel": {
-          const session = await this.sessions.getCurrentSession(chatKey);
-          if (!session) {
-            return { text: "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。" };
-          }
-          try {
-            const result = await this.cancelTransportSession(session);
-            return { text: result.message || "cancelled" };
-          } catch (error) {
-            return this.renderTransportError(session, error);
-          }
-        }
-        case "session.reset":
-          return await this.resetCurrentSession(chatKey);
-        case "prompt": {
-          const session = await this.sessions.getCurrentSession(chatKey);
-          if (!session) {
-            return { text: "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。" };
-          }
-          try {
-            const result = await this.promptTransportSession(session, command.text, reply);
-            return { text: result.text };
-          } catch (error) {
-            const recovered = await this.tryRecoverMissingSession(session, error);
-            if (recovered) {
-              const result = await this.promptTransportSession(recovered, command.text, reply);
-              return { text: result.text };
-            }
-            return this.renderTransportError(session, error);
-          }
-        }
+  };
+}
+async function handleCancel(context, chatKey) {
+  const session = await context.sessions.getCurrentSession(chatKey);
+  if (!session) {
+    return { text: NO_CURRENT_SESSION_TEXT };
+  }
+  try {
+    const result = await context.interaction.cancelTransportSession(session);
+    return { text: result.message || "cancelled" };
+  } catch (error) {
+    return context.recovery.renderTransportError(session, error);
+  }
+}
+async function handleSessionReset(context, chatKey) {
+  return await context.lifecycle.resetCurrentSession(chatKey);
+}
+async function handlePrompt(context, chatKey, text, reply) {
+  const session = await context.sessions.getCurrentSession(chatKey);
+  if (!session) {
+    return { text: NO_CURRENT_SESSION_TEXT };
+  }
+  try {
+    const effectiveReplyMode = session.replyMode ?? context.config?.wechat.replyMode ?? "stream";
+    const transportReply = effectiveReplyMode === "stream" ? reply : undefined;
+    const result = await context.interaction.promptTransportSession(session, text, transportReply);
+    return { text: result.text };
+  } catch (error) {
+    const recovered = await context.recovery.tryRecoverMissingSession(session, error);
+    if (recovered) {
+      const effectiveReplyMode = recovered.replyMode ?? context.config?.wechat.replyMode ?? "stream";
+      const transportReply = effectiveReplyMode === "stream" ? reply : undefined;
+      const result = await context.interaction.promptTransportSession(recovered, text, transportReply);
+      return { text: result.text };
+    }
+    return context.recovery.renderTransportError(session, error);
+  }
+}
+var NO_CURRENT_SESSION_TEXT = "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。", sessionHelp, modeHelp, replyModeHelp, statusHelp, cancelHelp;
+var init_session_handler = __esm(() => {
+  sessionHelp = {
+    topic: "session",
+    aliases: ["ss", "sessions"],
+    summary: "创建、恢复、切换和重置逻辑会话。",
+    commands: [
+      { usage: "/sessions", description: "查看当前会话列表" },
+      { usage: "/session 或 /ss", description: "查看会话列表" },
+      { usage: "/ss <agent> (-d <path> | --ws <name>)", description: "快速新建或复用一个会话" },
+      { usage: "/ss new <agent> (-d <path> | --ws <name>)", description: "强制新建会话" },
+      { usage: "/ss new <alias> -a <name> --ws <name>", description: "按指定配置新建会话" },
+      { usage: "/ss attach <alias> -a <name> --ws <name> --name <transport-session>", description: "绑定已有会话" },
+      { usage: "/use <alias>", description: "切换当前会话" },
+      { usage: "/session reset 或 /clear", description: "重置当前会话上下文" }
+    ],
+    examples: ["/ss codex -d /absolute/path/to/repo", "/use backend-fix", "/session reset"]
+  };
+  modeHelp = {
+    topic: "mode",
+    aliases: [],
+    summary: "查看或设置当前会话 mode。",
+    commands: [
+      { usage: "/mode", description: "查看当前会话已保存的 mode" },
+      { usage: "/mode <id>", description: "设置当前会话 mode" }
+    ],
+    examples: ["/mode", "/mode plan"]
+  };
+  replyModeHelp = {
+    topic: "replymode",
+    aliases: [],
+    summary: "查看或设置当前逻辑会话的回复输出模式。",
+    commands: [
+      { usage: "/replymode", description: "查看全局默认、当前覆盖和实际生效值" },
+      { usage: "/replymode stream", description: "当前会话使用流式回复" },
+      { usage: "/replymode final", description: "当前会话只发送最终文本" },
+      { usage: "/replymode reset", description: "清除当前会话覆盖并回退到全局默认" }
+    ],
+    examples: ["/replymode", "/replymode final"]
+  };
+  statusHelp = {
+    topic: "status",
+    aliases: [],
+    summary: "查看当前选中会话的状态。",
+    commands: [{ usage: "/status", description: "查看当前会话状态" }],
+    examples: ["/status"]
+  };
+  cancelHelp = {
+    topic: "cancel",
+    aliases: ["stop"],
+    summary: "取消当前会话里正在执行的任务。",
+    commands: [
+      { usage: "/cancel", description: "取消当前任务" },
+      { usage: "/stop", description: "取消当前任务（/cancel 别名）" }
+    ],
+    examples: ["/cancel"]
+  };
+});
+
+// src/commands/transport-diagnostics.ts
+function summarizeTransportError(message) {
+  return message.replace(/\s+/g, " ").trim().slice(0, 200);
+}
+function summarizeTransportDiagnostic(output) {
+  const trimmed = output.replace(/\s+/g, " ").trim();
+  if (trimmed.length === 0) {
+    return;
+  }
+  return trimmed.slice(0, 200);
+}
+function summarizeTransportDiagnosticTail(output) {
+  const trimmed = output.replace(/\s+/g, " ").trim();
+  if (trimmed.length === 0) {
+    return;
+  }
+  return trimmed.slice(-200);
+}
+function summarizeTransportNdjson(output, prefix) {
+  const lines = output.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (lines.length === 0) {
+    return {};
+  }
+  const methods = new Set;
+  let agentMessageChunkCount = 0;
+  let stopReason;
+  for (const line of lines) {
+    try {
+      const payload = JSON.parse(line);
+      if (typeof payload.method === "string" && payload.method.length > 0) {
+        methods.add(payload.method);
       }
-    });
+      if (payload.params?.update?.sessionUpdate === "agent_message_chunk") {
+        agentMessageChunkCount += 1;
+      }
+      if (typeof payload.result?.stopReason === "string" && payload.result.stopReason.length > 0) {
+        stopReason = payload.result.stopReason;
+      }
+    } catch {
+      continue;
+    }
   }
-  async clearSession(chatKey) {
-    await this.resetCurrentSession(chatKey);
+  const summary = {
+    [`${prefix}LineCount`]: lines.length
+  };
+  if (methods.size > 0) {
+    summary[`${prefix}Methods`] = [...methods].join(",");
   }
-  async handleSessionShortcut(chatKey, agent, cwdInput, createNew) {
-    if (!this.config || !this.configStore) {
-      return { text: "当前没有加载可写入的配置。" };
+  if (agentMessageChunkCount > 0) {
+    summary[`${prefix}AgentMessageChunkCount`] = agentMessageChunkCount;
+  }
+  if (stopReason) {
+    summary[`${prefix}StopReason`] = stopReason;
+  }
+  return summary;
+}
+function isPartialPromptOutputError(message) {
+  return message.includes("未收到最终回复");
+}
+
+// src/formatting/render-text.ts
+function renderAgents(config) {
+  const names = Object.keys(config.agents);
+  if (names.length === 0) {
+    return "还没有注册任何 Agent。";
+  }
+  return ["已注册的 Agent：", ...names.map((name) => `- ${name}`)].join(`
+`);
+}
+function renderWorkspaces(config) {
+  const names = Object.entries(config.workspaces);
+  if (names.length === 0) {
+    return "还没有注册任何工作区。";
+  }
+  return ["已注册的工作区：", ...names.map(([name, workspace]) => `- ${name}: ${workspace.cwd}`)].join(`
+`);
+}
+
+// src/config/agent-templates.ts
+function getAgentTemplate(name) {
+  const template = TEMPLATES[name];
+  if (!template) {
+    return null;
+  }
+  return {
+    ...template
+  };
+}
+function listAgentTemplates() {
+  return Object.keys(TEMPLATES);
+}
+var TEMPLATES;
+var init_agent_templates = __esm(() => {
+  TEMPLATES = {
+    codex: {
+      driver: "codex"
+    },
+    claude: {
+      driver: "claude"
     }
-    const cwd = normalizePathForWorkspace(cwdInput);
-    if (!await pathExists(cwd)) {
-      return { text: `工作区路径不存在：${cwdInput}` };
+  };
+});
+
+// src/commands/handlers/agent-handler.ts
+function handleAgents(context) {
+  return { text: context.config ? renderAgents(context.config) : "No config loaded." };
+}
+async function handleAgentAdd(context, templateName) {
+  if (!context.config || !context.configStore) {
+    return { text: "当前没有加载可写入的配置。" };
+  }
+  const template = getAgentTemplate(templateName);
+  if (!template) {
+    return { text: `暂不支持这个 Agent 模板。当前可用：${listAgentTemplates().join("、")}` };
+  }
+  const updated = await context.configStore.upsertAgent(templateName, template);
+  context.replaceConfig(updated);
+  return { text: `Agent「${templateName}」已保存` };
+}
+async function handleAgentRemove(context, agentName) {
+  if (!context.config || !context.configStore) {
+    return { text: "当前没有加载可写入的配置。" };
+  }
+  if (!context.config.agents[agentName]) {
+    return { text: "没有找到这个 Agent。" };
+  }
+  const updated = await context.configStore.removeAgent(agentName);
+  context.replaceConfig(updated);
+  return { text: `Agent「${agentName}」已删除` };
+}
+var agentHelp;
+var init_agent_handler = __esm(() => {
+  init_agent_templates();
+  agentHelp = {
+    topic: "agent",
+    aliases: ["agents"],
+    summary: "管理已注册的 Agent。",
+    commands: [
+      { usage: "/agents", description: "查看当前已注册的 Agent" },
+      { usage: "/agent add <codex|claude>", description: "添加内置 Agent 模板" },
+      { usage: "/agent rm <name>", description: "删除一个 Agent" }
+    ],
+    examples: ["/agent add claude", "/agent rm codex"]
+  };
+});
+
+// src/commands/handlers/workspace-handler.ts
+import { access } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { normalize } from "node:path";
+function handleWorkspaces(context) {
+  return { text: context.config ? renderWorkspaces(context.config) : "No config loaded." };
+}
+async function handleWorkspaceCreate(context, workspaceName, cwd) {
+  if (!context.config || !context.configStore) {
+    return { text: "当前没有加载可写入的配置。" };
+  }
+  const normalizedCwd = normalizePathForWorkspace(cwd);
+  if (!await pathExists(normalizedCwd)) {
+    return { text: `工作区路径不存在：${cwd}` };
+  }
+  const updated = await context.configStore.upsertWorkspace(workspaceName, normalizedCwd);
+  context.replaceConfig(updated);
+  return { text: `工作区「${workspaceName}」已保存` };
+}
+async function handleWorkspaceRemove(context, workspaceName) {
+  if (!context.config || !context.configStore) {
+    return { text: "当前没有加载可写入的配置。" };
+  }
+  const updated = await context.configStore.removeWorkspace(workspaceName);
+  context.replaceConfig(updated);
+  return { text: `工作区「${workspaceName}」已删除` };
+}
+async function pathExists(path11) {
+  try {
+    await access(path11);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizePathForWorkspace(path11) {
+  const expanded = path11.startsWith("~") ? homedir3() + path11.slice(1) : path11;
+  return normalize(expanded);
+}
+var workspaceHelp;
+var init_workspace_handler = __esm(() => {
+  workspaceHelp = {
+    topic: "workspace",
+    aliases: ["ws", "workspaces"],
+    summary: "管理已注册的工作区。",
+    commands: [
+      { usage: "/workspaces", description: "查看当前已注册的工作区" },
+      { usage: "/workspace 或 /ws", description: "查看工作区列表" },
+      { usage: "/ws new <name> -d <path>", description: "添加工作区" },
+      { usage: "/workspace rm <name>", description: "删除工作区" }
+    ],
+    examples: ['/ws new backend -d "/tmp/backend"', "/workspace rm backend"]
+  };
+});
+
+// src/commands/help/help-registry.ts
+function getHelpTopic(topic) {
+  return HELP_TOPIC_MAP.get(topic) ?? null;
+}
+function listHelpTopics() {
+  return HELP_TOPICS;
+}
+var HELP_TOPICS, HELP_TOPIC_MAP;
+var init_help_registry = __esm(() => {
+  init_agent_handler();
+  init_config_handler();
+  init_permission_handler();
+  init_session_handler();
+  init_workspace_handler();
+  HELP_TOPICS = [
+    sessionHelp,
+    workspaceHelp,
+    agentHelp,
+    permissionHelp,
+    configHelp,
+    modeHelp,
+    replyModeHelp,
+    statusHelp,
+    cancelHelp
+  ];
+  HELP_TOPIC_MAP = new Map;
+  for (const topic of HELP_TOPICS) {
+    HELP_TOPIC_MAP.set(topic.topic, topic);
+    for (const alias of topic.aliases) {
+      HELP_TOPIC_MAP.set(alias, topic);
     }
-    const workspace = await this.resolveShortcutWorkspace(cwd);
-    await this.logger.info("session.shortcut.workspace", "resolved shortcut workspace", {
+  }
+});
+
+// src/commands/handlers/help-handler.ts
+function handleHelp(topic) {
+  if (!topic) {
+    return { text: renderHelpIndex() };
+  }
+  const entry = getHelpTopic(topic);
+  if (!entry) {
+    return { text: renderUnknownHelpTopic(topic) };
+  }
+  return { text: renderHelpTopic(entry) };
+}
+function renderHelpIndex() {
+  const topics = listHelpTopics();
+  return [
+    "常用入口：",
+    "- /ss <agent> (-d <path> | --ws <name>) - 快速新建或切到会话",
+    "- /use <alias> - 切换当前会话",
+    "- /status - 查看当前会话状态",
+    "",
+    "顶级命令：",
+    ...topics.map((topic) => `- ${topic.topic} - ${topic.summary}`),
+    "",
+    "查看专题说明：",
+    "- /help <topic>",
+    "- 例如：/help ss、/help ws、/help pm"
+  ].join(`
+`);
+}
+function renderHelpTopic(topic) {
+  return [
+    `帮助主题：${topic.topic}`,
+    `说明：${topic.summary}`,
+    ...topic.aliases.length > 0 ? [`别名：${topic.aliases.join("、")}`] : [],
+    "",
+    "命令：",
+    ...topic.commands.map((command) => `- ${command.usage} - ${command.description}`),
+    ...topic.examples && topic.examples.length > 0 ? ["", "示例：", ...topic.examples.map((example) => `- ${example}`)] : []
+  ].join(`
+`);
+}
+function renderUnknownHelpTopic(topic) {
+  return [
+    `未知帮助主题：${topic}`,
+    "",
+    "可用主题：",
+    ...listHelpTopics().map((entry) => `- ${entry.topic}`)
+  ].join(`
+`);
+}
+var init_help_handler = __esm(() => {
+  init_help_registry();
+});
+
+// src/commands/handlers/session-shortcut-handler.ts
+import { access as access2 } from "node:fs/promises";
+import { basename as basename2, normalize as normalize2 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+async function handleSessionShortcutCommand(context, ops, chatKey, agent, target, createNew) {
+  if (!context.config || !context.configStore) {
+    return { text: "当前没有加载可写入的配置。" };
+  }
+  if (!context.config.agents[agent]) {
+    return { text: `agent "${agent}" is not registered` };
+  }
+  const workspace = await resolveShortcutWorkspace(context, target);
+  if ("error" in workspace) {
+    return { text: workspace.error };
+  }
+  await context.logger.info("session.shortcut.workspace", "resolved shortcut workspace", {
+    workspace: workspace.name,
+    cwd: workspace.cwd,
+    reused: workspace.reused
+  });
+  const baseAlias = `${workspace.name}:${agent}`;
+  const alias = createNew ? await allocateUniqueSessionAlias(context, baseAlias, chatKey) : baseAlias;
+  if (!createNew && await hasLogicalSession(context, alias, chatKey)) {
+    await context.sessions.useSession(chatKey, alias);
+    await context.logger.info("session.shortcut.reused", "reused existing logical session", {
+      alias,
       workspace: workspace.name,
-      cwd: workspace.cwd,
-      reused: workspace.reused
+      agent
     });
-    const baseAlias = `${workspace.name}:${agent}`;
-    const alias = createNew ? await this.allocateUniqueSessionAlias(baseAlias, chatKey) : baseAlias;
-    if (!createNew && await this.hasLogicalSession(alias, chatKey)) {
-      await this.sessions.useSession(chatKey, alias);
-      await this.logger.info("session.shortcut.reused", "reused existing logical session", {
-        alias,
-        workspace: workspace.name,
-        agent
-      });
+    return {
+      text: [
+        `已切换到会话「${alias}」`,
+        `- 复用工作区：${workspace.name}`,
+        `- 复用会话：${alias}`
+      ].join(`
+`)
+    };
+  }
+  const session = ops.resolveSession(alias, agent, workspace.name, `${workspace.name}:${alias}`);
+  try {
+    await ops.ensureTransportSession(session);
+    const exists = await ops.checkTransportSession(session);
+    if (!exists) {
+      return renderShortcutSessionCreationError(workspace, alias);
+    }
+  } catch {
+    return renderShortcutSessionCreationError(workspace, alias);
+  }
+  await context.sessions.attachSession(alias, agent, workspace.name, session.transportSession);
+  await ops.refreshSessionTransportAgentCommand(alias);
+  await context.sessions.useSession(chatKey, alias);
+  await context.logger.info("session.shortcut.created", "created new logical session from shortcut", {
+    alias,
+    workspace: workspace.name,
+    agent,
+    workspaceReused: workspace.reused
+  });
+  return {
+    text: [
+      `已创建并切换到会话「${alias}」`,
+      workspace.reused ? `- 复用工作区：${workspace.name}` : `- 新增工作区：${workspace.name} -> ${workspace.cwd}`,
+      `- 新增会话：${alias}`
+    ].join(`
+`)
+  };
+}
+async function resolveShortcutWorkspace(context, target) {
+  if (target.workspace) {
+    const workspace = context.config?.workspaces[target.workspace];
+    if (!workspace) {
+      return { error: `workspace "${target.workspace}" is not registered` };
+    }
+    return {
+      name: target.workspace,
+      cwd: workspace.cwd,
+      reused: true
+    };
+  }
+  const cwdInput = target.cwd ?? "";
+  const cwd = normalizePathForWorkspace2(cwdInput);
+  if (!await pathExists2(cwd)) {
+    return { error: `工作区路径不存在：${cwdInput}` };
+  }
+  const existingByPath = Object.entries(context.config?.workspaces ?? {}).find(([, workspace]) => sameWorkspacePath(workspace.cwd, cwd));
+  if (existingByPath) {
+    return {
+      name: existingByPath[0],
+      cwd: existingByPath[1].cwd,
+      reused: true
+    };
+  }
+  const workspaceName = allocateWorkspaceName(context, basename2(cwd));
+  const updated = await context.configStore.upsertWorkspace(workspaceName, cwd);
+  context.replaceConfig(updated);
+  return {
+    name: workspaceName,
+    cwd,
+    reused: false
+  };
+}
+function allocateWorkspaceName(context, baseName) {
+  if (!context.config?.workspaces[baseName]) {
+    return baseName;
+  }
+  let suffix = 2;
+  while (context.config.workspaces[`${baseName}-${suffix}`]) {
+    suffix += 1;
+  }
+  return `${baseName}-${suffix}`;
+}
+async function allocateUniqueSessionAlias(context, baseAlias, chatKey) {
+  if (!await hasLogicalSession(context, baseAlias, chatKey)) {
+    return baseAlias;
+  }
+  let suffix = 2;
+  while (await hasLogicalSession(context, `${baseAlias}-${suffix}`, chatKey)) {
+    suffix += 1;
+  }
+  return `${baseAlias}-${suffix}`;
+}
+async function hasLogicalSession(context, alias, chatKey) {
+  const sessions = await context.sessions.listSessions(chatKey);
+  return sessions.some((session) => session.alias === alias);
+}
+function renderShortcutSessionCreationError(workspace, alias) {
+  return {
+    text: [
+      `会话「${alias}」创建失败。`,
+      workspace.reused ? `- 复用工作区：${workspace.name}` : `- 已新增工作区：${workspace.name} -> ${workspace.cwd}`,
+      "- 会话未创建，请重试。"
+    ].join(`
+`)
+  };
+}
+async function pathExists2(path11) {
+  try {
+    await access2(path11);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizePathForWorkspace2(path11) {
+  const expanded = path11.startsWith("~") ? homedir4() + path11.slice(1) : path11;
+  return normalize2(expanded);
+}
+function sameWorkspacePath(left, right) {
+  const normalizedLeft = normalizePathForWorkspace2(left);
+  const normalizedRight = normalizePathForWorkspace2(right);
+  if (process.platform === "win32") {
+    return normalizedLeft.toLowerCase() === normalizedRight.toLowerCase();
+  }
+  return normalizedLeft === normalizedRight;
+}
+var init_session_shortcut_handler = () => {};
+
+// src/commands/handlers/session-recovery-handler.ts
+function renderTransportError(session, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("No acpx session found")) {
+    return {
+      text: [
+        `当前会话「${session.alias}」暂时不可用。`,
+        `请先在微信里重新执行：/session new ${session.alias} --agent ${session.agent} --ws ${session.workspace}`,
+        `如果你要绑定一个已有会话，再执行：/session attach ${session.alias} --agent ${session.agent} --ws ${session.workspace} --name <会话名>`
+      ].join(`
+`)
+    };
+  }
+  if (!isPartialPromptOutputError(message)) {
+    throw error;
+  }
+  return {
+    text: [
+      `当前会话「${session.alias}」执行中断，未收到最终回复。`,
+      "请直接重试；如果长时间无响应，可先发送 /cancel 后再重试。",
+      `错误信息：${summarizeTransportError(message)}`
+    ].join(`
+`)
+  };
+}
+function renderSessionCreationError(session, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("timed out") && message.includes("sessions new")) {
+    return renderSessionCreationFailure(session, message);
+  }
+  throw error;
+}
+function renderSessionCreationVerificationError(session) {
+  return renderSessionCreationFailure(session, "未检测到可用的后端会话。");
+}
+function renderSessionCreationFailure(session, detail) {
+  return {
+    text: [
+      "会话创建失败。",
+      `错误信息：${summarizeTransportError(detail)}`,
+      `如果你要先绑定一个已有会话，可以执行：/session attach ${session.alias} --agent ${session.agent} --ws ${session.workspace} --name <会话名>`
+    ].join(`
+`)
+  };
+}
+async function tryRecoverMissingSession(ops, session, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (!message.includes("No acpx session found")) {
+    return null;
+  }
+  const transportAgentCommand = await ops.resolveSessionAgentCommand(session);
+  if (!transportAgentCommand || transportAgentCommand === session.agentCommand) {
+    return null;
+  }
+  await ops.setSessionTransportAgentCommand(session.alias, transportAgentCommand);
+  return await ops.getSession(session.alias);
+}
+var init_session_recovery_handler = () => {};
+
+// src/commands/handlers/session-reset-handler.ts
+async function handleSessionResetCommand(context, ops, chatKey) {
+  const session = await context.sessions.getCurrentSession(chatKey);
+  if (!session) {
+    return { text: NO_CURRENT_SESSION_TEXT2 };
+  }
+  const resetSession = ops.resolveSession(session.alias, session.agent, session.workspace, buildResetTransportSessionName(session, ops.now()));
+  try {
+    await ops.ensureTransportSession(resetSession);
+    const exists = await ops.checkTransportSession(resetSession);
+    if (!exists) {
       return {
         text: [
-          `已切换到会话「${alias}」`,
-          `- 复用工作区：${workspace.name}`,
-          `- 复用会话：${alias}`
+          `会话「${session.alias}」重置失败。`,
+          "新的后端会话未创建成功，请稍后重试。"
         ].join(`
 `)
       };
     }
-    const session = this.sessions.resolveSession(alias, agent, workspace.name, `${workspace.name}:${alias}`);
-    try {
-      await this.ensureTransportSession(session);
-      const exists = await this.checkTransportSession(session);
-      if (!exists) {
-        return this.renderShortcutSessionCreationError(workspace, alias);
+  } catch (error) {
+    return renderTransportError(resetSession, error);
+  }
+  await context.sessions.attachSession(resetSession.alias, resetSession.agent, resetSession.workspace, resetSession.transportSession);
+  await ops.refreshSessionTransportAgentCommand(resetSession.alias);
+  await context.sessions.useSession(chatKey, resetSession.alias);
+  await context.logger.info("session.reset", "reset current logical session", {
+    alias: resetSession.alias,
+    agent: resetSession.agent,
+    workspace: resetSession.workspace,
+    transportSession: resetSession.transportSession,
+    chatKey
+  });
+  return { text: `会话「${resetSession.alias}」已重置` };
+}
+function buildResetTransportSessionName(session, now) {
+  return `${session.workspace}:${session.alias}:reset-${now}`;
+}
+var NO_CURRENT_SESSION_TEXT2 = "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。";
+var init_session_reset_handler = __esm(() => {
+  init_session_recovery_handler();
+});
+
+// src/commands/command-router.ts
+class CommandRouter {
+  sessions;
+  transport;
+  config;
+  configStore;
+  resolveSessionAgentCommand;
+  logger;
+  constructor(sessions, transport, config, configStore, logger2, resolveSessionAgentCommand = resolveSessionAgentCommandFromIndex) {
+    this.sessions = sessions;
+    this.transport = transport;
+    this.config = config;
+    this.configStore = configStore;
+    this.resolveSessionAgentCommand = resolveSessionAgentCommand;
+    this.logger = logger2 ?? createNoopAppLogger();
+  }
+  async handle(chatKey, input, reply) {
+    const startedAt = Date.now();
+    const command = parseCommand(input);
+    await this.logger.debug("command.parsed", "parsed inbound command", {
+      chatKey,
+      kind: command.kind
+    });
+    return await this.executeCommand(chatKey, command.kind, startedAt, async () => {
+      switch (command.kind) {
+        case "invalid":
+          return {
+            text: [
+              "无法识别的命令格式。",
+              "",
+              "正确的会话创建格式：",
+              "/session new <别名> --agent <Agent名> --ws <工作区名>",
+              "",
+              "例如：",
+              "/session new demo --agent claude --ws weacpx"
+            ].join(`
+`)
+          };
+        case "help":
+          return handleHelp(command.topic);
+        case "agents":
+          return handleAgents(this.createHandlerContext());
+        case "agent.add":
+          return await handleAgentAdd(this.createHandlerContext(), command.template);
+        case "agent.rm":
+          return await handleAgentRemove(this.createHandlerContext(), command.name);
+        case "permission.status":
+          return handlePermissionStatus(this.createHandlerContext(), "当前权限模式：");
+        case "permission.mode.set":
+          return await handlePermissionModeSet(this.createHandlerContext(), command.mode);
+        case "permission.auto.status":
+          return handlePermissionAutoStatus(this.createHandlerContext(), "当前非交互策略：");
+        case "permission.auto.set":
+          return await handlePermissionAutoSet(this.createHandlerContext(), command.policy);
+        case "config.show":
+          return handleConfigShow(this.createHandlerContext());
+        case "config.set":
+          return await handleConfigSet(this.createHandlerContext(), command.path, command.value);
+        case "workspaces":
+          return handleWorkspaces(this.createHandlerContext());
+        case "workspace.new":
+          return await handleWorkspaceCreate(this.createHandlerContext(), command.name, command.cwd);
+        case "workspace.rm":
+          return await handleWorkspaceRemove(this.createHandlerContext(), command.name);
+        case "sessions":
+          return await handleSessions(this.createSessionHandlerContext(), chatKey);
+        case "session.new":
+          return await handleSessionNew(this.createSessionHandlerContext(), chatKey, command.alias, command.agent, command.workspace);
+        case "session.shortcut":
+          return await handleSessionShortcut(this.createSessionHandlerContext(), chatKey, command.agent, command, false);
+        case "session.shortcut.new":
+          return await handleSessionShortcut(this.createSessionHandlerContext(), chatKey, command.agent, command, true);
+        case "session.attach":
+          return await handleSessionAttach(this.createSessionHandlerContext(), chatKey, command.alias, command.agent, command.workspace, command.transportSession);
+        case "session.use":
+          return await handleSessionUse(this.createSessionHandlerContext(), chatKey, command.alias);
+        case "mode.show":
+          return await handleModeShow(this.createSessionHandlerContext(), chatKey);
+        case "mode.set":
+          return await handleModeSet(this.createSessionHandlerContext(), chatKey, command.modeId);
+        case "replymode.show":
+          return await handleReplyModeShow(this.createSessionHandlerContext(), chatKey);
+        case "replymode.set":
+          return await handleReplyModeSet(this.createSessionHandlerContext(), chatKey, command.replyMode);
+        case "replymode.reset":
+          return await handleReplyModeReset(this.createSessionHandlerContext(), chatKey);
+        case "status":
+          return await handleStatus(this.createSessionHandlerContext(), chatKey);
+        case "cancel":
+          return await handleCancel(this.createSessionHandlerContext(), chatKey);
+        case "session.reset":
+          return await handleSessionReset(this.createSessionHandlerContext(), chatKey);
+        case "prompt":
+          return await handlePrompt(this.createSessionHandlerContext(), chatKey, command.text, reply);
       }
-    } catch {
-      return this.renderShortcutSessionCreationError(workspace, alias);
-    }
-    await this.sessions.attachSession(alias, agent, workspace.name, session.transportSession);
-    await this.refreshSessionTransportAgentCommand(alias);
-    await this.sessions.useSession(chatKey, alias);
-    await this.logger.info("session.shortcut.created", "created new logical session from shortcut", {
-      alias,
-      workspace: workspace.name,
-      agent,
-      workspaceReused: workspace.reused
     });
-    return {
-      text: [
-        `已创建并切换到会话「${alias}」`,
-        workspace.reused ? `- 复用工作区：${workspace.name}` : `- 新增工作区：${workspace.name} -> ${workspace.cwd}`,
-        `- 新增会话：${alias}`
-      ].join(`
-`)
-    };
   }
-  replaceConfig(updated) {
-    if (!this.config) {
-      return;
-    }
-    this.config.transport = { ...updated.transport };
-    this.config.agents = { ...updated.agents };
-    this.config.workspaces = { ...updated.workspaces };
-  }
-  renderPermissionStatus(title) {
-    const permissionMode = this.config?.transport.permissionMode ?? "approve-all";
-    const nonInteractivePermissions = this.config?.transport.nonInteractivePermissions ?? "fail";
-    return [title, `- mode: ${permissionMode}`, `- auto: ${nonInteractivePermissions}`].join(`
-`);
+  async clearSession(chatKey) {
+    await handleSessionResetCommand(this.createHandlerContext(), this.createSessionResetOps(), chatKey);
   }
-  renderTransportError(session, error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes("No acpx session found")) {
-      return {
-        text: [
-          `当前会话「${session.alias}」暂时不可用。`,
-          `请先在微信里重新执行：/session new ${session.alias} --agent ${session.agent} --ws ${session.workspace}`,
-          `如果你要绑定一个已有会话，再执行：/session attach ${session.alias} --agent ${session.agent} --ws ${session.workspace} --name <会话名>`
-        ].join(`
-`)
-      };
-    }
-    if (!isPartialPromptOutputError(message)) {
-      throw error;
-    }
+  createHandlerContext() {
     return {
-      text: [
-        `当前会话「${session.alias}」执行中断，未收到最终回复。`,
-        "请直接重试；如果长时间无响应，可先发送 /cancel 后再重试。",
-        `错误信息：${summarizeTransportError(message)}`
-      ].join(`
-`)
+      sessions: this.sessions,
+      transport: this.transport,
+      config: this.config,
+      configStore: this.configStore,
+      logger: this.logger,
+      replaceConfig: (updated) => this.replaceConfig(updated)
     };
   }
-  renderSessionCreationError(session, error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes("timed out") && message.includes("sessions new")) {
-      return this.renderSessionCreationVerificationError(session);
-    }
-    throw error;
+  createSessionHandlerContext() {
+    return {
+      ...this.createHandlerContext(),
+      lifecycle: this.createSessionLifecycleOps(),
+      interaction: this.createSessionInteractionOps(),
+      recovery: this.createSessionRenderRecoveryOps()
+    };
   }
-  renderSessionCreationVerificationError(session) {
+  createSessionLifecycleOps() {
     return {
-      text: [
-        "当前还不能直接在微信里创建新会话。",
-        `请先准备好一个已有会话，然后在微信里执行：/session attach ${session.alias} --agent ${session.agent} --ws ${session.workspace} --name <会话名>`
-      ].join(`
-`)
+      resolveSession: (alias, agent, workspace, transportSession) => this.sessions.resolveSession(alias, agent, workspace, transportSession),
+      ensureTransportSession: (session) => this.ensureTransportSession(session),
+      checkTransportSession: (session) => this.checkTransportSession(session),
+      handleSessionShortcut: (chatKey, agent, target, createNew) => handleSessionShortcutCommand(this.createHandlerContext(), this.createSessionShortcutOps(), chatKey, agent, target, createNew),
+      resetCurrentSession: (chatKey) => handleSessionResetCommand(this.createHandlerContext(), this.createSessionResetOps(), chatKey),
+      refreshSessionTransportAgentCommand: (alias) => this.refreshSessionTransportAgentCommand(alias)
     };
   }
-  async resolveShortcutWorkspace(cwd) {
-    const existingByPath = Object.entries(this.config?.workspaces ?? {}).find(([, workspace]) => sameWorkspacePath(workspace.cwd, cwd));
-    if (existingByPath) {
-      return {
-        name: existingByPath[0],
-        cwd: existingByPath[1].cwd,
-        reused: true
-      };
-    }
-    const baseName = basename2(cwd);
-    const workspaceName = this.allocateWorkspaceName(baseName, cwd);
-    const updated = await this.configStore.upsertWorkspace(workspaceName, cwd);
-    this.replaceConfig(updated);
+  createSessionInteractionOps() {
     return {
-      name: workspaceName,
-      cwd,
-      reused: false
+      setModeTransportSession: (session, modeId) => this.setModeTransportSession(session, modeId),
+      cancelTransportSession: (session) => this.cancelTransportSession(session),
+      promptTransportSession: (session, text, reply) => this.promptTransportSession(session, text, reply)
     };
   }
-  allocateWorkspaceName(baseName, cwd) {
-    if (!this.config?.workspaces[baseName]) {
-      return baseName;
-    }
-    let suffix = 2;
-    while (this.config.workspaces[`${baseName}-${suffix}`]) {
-      suffix += 1;
-    }
-    return `${baseName}-${suffix}`;
+  createSessionRenderRecoveryOps() {
+    return {
+      renderSessionCreationError: (session, error) => renderSessionCreationError(session, error),
+      renderSessionCreationVerificationError: (session) => renderSessionCreationVerificationError(session),
+      tryRecoverMissingSession: (session, error) => tryRecoverMissingSession(this.createSessionRecoveryOps(), session, error),
+      renderTransportError: (session, error) => renderTransportError(session, error)
+    };
   }
-  async allocateUniqueSessionAlias(baseAlias, chatKey) {
-    if (!await this.hasLogicalSession(baseAlias, chatKey)) {
-      return baseAlias;
-    }
-    let suffix = 2;
-    while (await this.hasLogicalSession(`${baseAlias}-${suffix}`, chatKey)) {
-      suffix += 1;
-    }
-    return `${baseAlias}-${suffix}`;
+  createSessionResetOps() {
+    return {
+      ensureTransportSession: (session) => this.ensureTransportSession(session),
+      checkTransportSession: (session) => this.checkTransportSession(session),
+      resolveSession: (alias, agent, workspace, transportSession) => this.sessions.resolveSession(alias, agent, workspace, transportSession),
+      refreshSessionTransportAgentCommand: (alias) => this.refreshSessionTransportAgentCommand(alias),
+      now: () => Date.now()
+    };
   }
-  async hasLogicalSession(alias, chatKey) {
-    const sessions = await this.sessions.listSessions(chatKey);
-    return sessions.some((session) => session.alias === alias);
+  createSessionRecoveryOps() {
+    return {
+      resolveSessionAgentCommand: (session) => this.resolveSessionAgentCommand(session),
+      setSessionTransportAgentCommand: (alias, command) => this.sessions.setSessionTransportAgentCommand(alias, command),
+      getSession: (alias) => this.sessions.getSession(alias)
+    };
   }
-  renderShortcutSessionCreationError(workspace, alias) {
+  createSessionShortcutOps() {
     return {
-      text: [
-        `会话「${alias}」创建失败。`,
-        workspace.reused ? `- 复用工作区：${workspace.name}` : `- 已新增工作区：${workspace.name} -> ${workspace.cwd}`,
-        "- 会话未创建，请重试。"
-      ].join(`
-`)
+      resolveSession: (alias, agent, workspace, transportSession) => this.sessions.resolveSession(alias, agent, workspace, transportSession),
+      ensureTransportSession: (session) => this.ensureTransportSession(session),
+      checkTransportSession: (session) => this.checkTransportSession(session),
+      refreshSessionTransportAgentCommand: (alias) => this.refreshSessionTransportAgentCommand(alias)
     };
   }
+  replaceConfig(updated) {
+    if (!this.config) {
+      return;
+    }
+    this.config.transport = { ...updated.transport };
+    this.config.logging = { ...updated.logging };
+    this.config.wechat = { ...updated.wechat };
+    this.config.agents = { ...updated.agents };
+    this.config.workspaces = { ...updated.workspaces };
+  }
   async executeCommand(chatKey, kind, startedAt, operation) {
     try {
       const response = await operation();
@@ -4345,42 +5310,6 @@ class CommandRouter {
   async ensureTransportSession(session) {
     await this.measureTransportCall("ensure_session", session, () => this.transport.ensureSession(session));
   }
-  async resetCurrentSession(chatKey) {
-    const session = await this.sessions.getCurrentSession(chatKey);
-    if (!session) {
-      return { text: "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。" };
-    }
-    const resetSession = this.sessions.resolveSession(session.alias, session.agent, session.workspace, this.buildResetTransportSessionName(session));
-    try {
-      await this.ensureTransportSession(resetSession);
-      const exists = await this.checkTransportSession(resetSession);
-      if (!exists) {
-        return {
-          text: [
-            `会话「${session.alias}」重置失败。`,
-            "新的后端会话未创建成功，请稍后重试。"
-          ].join(`
-`)
-        };
-      }
-    } catch (error) {
-      return this.renderTransportError(resetSession, error);
-    }
-    await this.sessions.attachSession(resetSession.alias, resetSession.agent, resetSession.workspace, resetSession.transportSession);
-    await this.refreshSessionTransportAgentCommand(resetSession.alias);
-    await this.sessions.useSession(chatKey, resetSession.alias);
-    await this.logger.info("session.reset", "reset current logical session", {
-      alias: resetSession.alias,
-      agent: resetSession.agent,
-      workspace: resetSession.workspace,
-      transportSession: resetSession.transportSession,
-      chatKey
-    });
-    return { text: `会话「${resetSession.alias}」已重置` };
-  }
-  buildResetTransportSessionName(session) {
-    return `${session.workspace}:${session.alias}:reset-${Date.now()}`;
-  }
   async checkTransportSession(session) {
     return await this.measureTransportCall("has_session", session, () => this.transport.hasSession(session));
   }
@@ -4404,18 +5333,6 @@ class CommandRouter {
     }
     await this.sessions.setSessionTransportAgentCommand(alias, transportAgentCommand);
   }
-  async tryRecoverMissingSession(session, error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (!message.includes("No acpx session found")) {
-      return null;
-    }
-    const transportAgentCommand = await this.resolveSessionAgentCommand(session);
-    if (!transportAgentCommand || transportAgentCommand === session.agentCommand) {
-      return null;
-    }
-    await this.sessions.setSessionTransportAgentCommand(session.alias, transportAgentCommand);
-    return await this.sessions.getSession(session.alias);
-  }
   async measureTransportCall(operation, session, callback) {
     const startedAt = Date.now();
     try {
@@ -4453,91 +5370,20 @@ class CommandRouter {
     }
   }
 }
-async function pathExists(path11) {
-  try {
-    await access(path11);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function normalizePathForWorkspace(path11) {
-  const expanded = path11.startsWith("~") ? homedir2() + path11.slice(1) : path11;
-  return normalize(expanded);
-}
-function sameWorkspacePath(left, right) {
-  const normalizedLeft = normalizePathForWorkspace(left);
-  const normalizedRight = normalizePathForWorkspace(right);
-  if (process.platform === "win32") {
-    return normalizedLeft.toLowerCase() === normalizedRight.toLowerCase();
-  }
-  return normalizedLeft === normalizedRight;
-}
-function summarizeTransportError(message) {
-  return message.replace(/\s+/g, " ").trim().slice(0, 200);
-}
-function summarizeTransportDiagnostic(output) {
-  const trimmed = output.replace(/\s+/g, " ").trim();
-  if (trimmed.length === 0) {
-    return;
-  }
-  return trimmed.slice(0, 200);
-}
-function summarizeTransportDiagnosticTail(output) {
-  const trimmed = output.replace(/\s+/g, " ").trim();
-  if (trimmed.length === 0) {
-    return;
-  }
-  return trimmed.slice(-200);
-}
-function summarizeTransportNdjson(output, prefix) {
-  const lines = output.split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0);
-  if (lines.length === 0) {
-    return {};
-  }
-  const methods = new Set;
-  let agentMessageChunkCount = 0;
-  let stopReason;
-  for (const line of lines) {
-    try {
-      const payload = JSON.parse(line);
-      if (typeof payload.method === "string" && payload.method.length > 0) {
-        methods.add(payload.method);
-      }
-      if (payload.params?.update?.sessionUpdate === "agent_message_chunk") {
-        agentMessageChunkCount += 1;
-      }
-      if (typeof payload.result?.stopReason === "string" && payload.result.stopReason.length > 0) {
-        stopReason = payload.result.stopReason;
-      }
-    } catch {
-      continue;
-    }
-  }
-  const summary = {
-    [`${prefix}LineCount`]: lines.length
-  };
-  if (methods.size > 0) {
-    summary[`${prefix}Methods`] = [...methods].join(",");
-  }
-  if (agentMessageChunkCount > 0) {
-    summary[`${prefix}AgentMessageChunkCount`] = agentMessageChunkCount;
-  }
-  if (stopReason) {
-    summary[`${prefix}StopReason`] = stopReason;
-  }
-  return summary;
-}
-function isPartialPromptOutputError(message) {
-  return message.includes("未收到最终回复");
-}
 var init_command_router = __esm(() => {
-  init_agent_templates();
   init_app_logger();
   init_acpx_session_index();
   init_prompt_output();
   init_parse_command();
+  init_permission_handler();
+  init_config_handler();
+  init_session_handler();
+  init_help_handler();
+  init_agent_handler();
+  init_workspace_handler();
+  init_session_shortcut_handler();
+  init_session_recovery_handler();
+  init_session_reset_handler();
 });
 
 // src/config/resolve-agent-command.ts
@@ -4556,12 +5402,12 @@ function isLegacyCodexCommand(command) {
 }
 
 // src/config/load-config.ts
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
 async function loadConfig(path11, options = {}) {
-  const raw = JSON.parse(await readFile4(path11, "utf8"));
+  const raw = JSON.parse(await readFile5(path11, "utf8"));
   return parseConfig(raw, options);
 }
 function parseConfig(raw, options = {}) {
@@ -4581,8 +5427,8 @@ function parseConfig(raw, options = {}) {
   if ("permissionMode" in transport && transport.permissionMode !== "approve-all" && transport.permissionMode !== "approve-reads" && transport.permissionMode !== "deny-all") {
     throw new Error("transport.permissionMode must be approve-all, approve-reads, or deny-all");
   }
-  if ("nonInteractivePermissions" in transport && transport.nonInteractivePermissions !== "allow" && transport.nonInteractivePermissions !== "deny" && transport.nonInteractivePermissions !== "fail") {
-    throw new Error("transport.nonInteractivePermissions must be allow, deny, or fail");
+  if ("nonInteractivePermissions" in transport && transport.nonInteractivePermissions !== "deny" && transport.nonInteractivePermissions !== "fail") {
+    throw new Error("transport.nonInteractivePermissions must be deny or fail");
   }
   if (!isRecord(raw.agents)) {
     throw new Error("agents must be an object");
@@ -4591,9 +5437,13 @@ function parseConfig(raw, options = {}) {
     throw new Error("workspaces must be an object");
   }
   const logging = raw.logging;
+  const wechat = raw.wechat;
   if (logging !== undefined && !isRecord(logging)) {
     throw new Error("logging must be an object");
   }
+  if (wechat !== undefined && !isRecord(wechat)) {
+    throw new Error("wechat must be an object");
+  }
   if (isRecord(logging) && "level" in logging && logging.level !== "error" && logging.level !== "info" && logging.level !== "debug") {
     throw new Error("logging.level must be error, info, or debug");
   }
@@ -4602,6 +5452,9 @@ function parseConfig(raw, options = {}) {
       throw new Error(`logging.${field} must be a positive number`);
     }
   }
+  if (isRecord(wechat) && "replyMode" in wechat && wechat.replyMode !== "stream" && wechat.replyMode !== "final") {
+    throw new Error("wechat.replyMode must be stream or final");
+  }
   for (const [name, agent] of Object.entries(raw.agents)) {
     if (!isRecord(agent) || typeof agent.driver !== "string" || agent.driver.length === 0) {
       throw new Error(`agent "${name}" must define a non-empty driver`);
@@ -4638,9 +5491,10 @@ function parseConfig(raw, options = {}) {
   }
   const transportType = transport.type === "acpx-cli" || transport.type === "acpx-bridge" ? transport.type : "acpx-bridge";
   const permissionMode = transport.permissionMode === "approve-all" || transport.permissionMode === "approve-reads" || transport.permissionMode === "deny-all" ? transport.permissionMode : DEFAULT_PERMISSION_MODE;
-  const nonInteractivePermissions = transport.nonInteractivePermissions === "allow" || transport.nonInteractivePermissions === "deny" || transport.nonInteractivePermissions === "fail" ? transport.nonInteractivePermissions : DEFAULT_NON_INTERACTIVE_PERMISSIONS;
+  const nonInteractivePermissions = transport.nonInteractivePermissions === "deny" || transport.nonInteractivePermissions === "fail" ? transport.nonInteractivePermissions : DEFAULT_NON_INTERACTIVE_PERMISSIONS;
   const loggingLevel = logging?.level;
   const resolvedLoggingLevel = loggingLevel === "error" || loggingLevel === "info" || loggingLevel === "debug" ? loggingLevel : options.defaultLoggingLevel ?? DEFAULT_LOGGING_CONFIG.level;
+  const replyMode = wechat?.replyMode === "stream" || wechat?.replyMode === "final" ? wechat.replyMode : DEFAULT_WECHAT_REPLY_MODE;
   return {
     transport: {
       ...typeof transport.command === "string" ? { command: transport.command } : {},
@@ -4655,11 +5509,14 @@ function parseConfig(raw, options = {}) {
       maxFiles: typeof logging?.maxFiles === "number" ? logging.maxFiles : DEFAULT_LOGGING_CONFIG.maxFiles,
       retentionDays: typeof logging?.retentionDays === "number" ? logging.retentionDays : DEFAULT_LOGGING_CONFIG.retentionDays
     },
+    wechat: {
+      replyMode
+    },
     agents,
     workspaces
   };
 }
-var DEFAULT_LOGGING_CONFIG, DEFAULT_PERMISSION_MODE = "approve-all", DEFAULT_NON_INTERACTIVE_PERMISSIONS = "fail";
+var DEFAULT_LOGGING_CONFIG, DEFAULT_PERMISSION_MODE = "approve-all", DEFAULT_NON_INTERACTIVE_PERMISSIONS = "deny", DEFAULT_WECHAT_REPLY_MODE = "stream";
 var init_load_config = __esm(() => {
   DEFAULT_LOGGING_CONFIG = {
     level: "info",
@@ -4670,8 +5527,8 @@ var init_load_config = __esm(() => {
 });
 
 // src/config/config-store.ts
-import { mkdir as mkdir6, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname5 } from "node:path";
+import { mkdir as mkdir7, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname6 } from "node:path";
 
 class ConfigStore {
   path;
@@ -4682,8 +5539,8 @@ class ConfigStore {
     return await loadConfig(this.path);
   }
   async save(config) {
-    await mkdir6(dirname5(this.path), { recursive: true });
-    await writeFile4(this.path, `${JSON.stringify(config, null, 2)}
+    await mkdir7(dirname6(this.path), { recursive: true });
+    await writeFile5(this.path, `${JSON.stringify(config, null, 2)}
 `, "utf8");
   }
   async upsertWorkspace(name, cwd, description) {
@@ -4723,13 +5580,22 @@ class ConfigStore {
     await this.save(config);
     return config;
   }
+  async updateWechat(wechat) {
+    const config = await this.load();
+    config.wechat = {
+      ...config.wechat,
+      ...wechat
+    };
+    await this.save(config);
+    return config;
+  }
 }
 var init_config_store = __esm(() => {
   init_load_config();
 });
 
 // src/config/ensure-config.ts
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 async function ensureConfigExists(path11) {
   try {
     await loadConfig(path11);
@@ -4743,7 +5609,10 @@ async function ensureConfigExists(path11) {
 }
 async function loadDefaultConfigTemplate() {
   const templatePath = new URL("../../config.example.json", import.meta.url);
-  const template = JSON.parse(await readFile5(templatePath, "utf8"));
+  return normalizeDefaultConfigTemplate(JSON.parse(await readFile6(templatePath, "utf8")));
+}
+function normalizeDefaultConfigTemplate(raw) {
+  const template = parseConfig(raw);
   return {
     ...template,
     agents: Object.fromEntries(Object.entries(template.agents).map(([name, agent]) => [
@@ -4888,6 +5757,23 @@ class SessionService {
     session.last_used_at = new Date().toISOString();
     await this.persist();
   }
+  async setCurrentSessionReplyMode(chatKey, replyMode) {
+    const currentAlias = this.state.chat_contexts[chatKey]?.current_session;
+    if (!currentAlias) {
+      throw new Error("no current session selected");
+    }
+    const session = this.state.sessions[currentAlias];
+    if (!session) {
+      throw new Error("no current session selected");
+    }
+    if (replyMode) {
+      session.reply_mode = replyMode;
+    } else {
+      delete session.reply_mode;
+    }
+    session.last_used_at = new Date().toISOString();
+    await this.persist();
+  }
   async getCurrentSession(chatKey) {
     const currentAlias = this.state.chat_contexts[chatKey]?.current_session;
     if (!currentAlias) {
@@ -4912,6 +5798,13 @@ class SessionService {
   }
   toResolvedSession(session) {
     const agentConfig = this.config.agents[session.agent];
+    if (!agentConfig) {
+      throw new Error(`session "${session.alias}" references agent "${session.agent}", but that agent is no longer registered`);
+    }
+    const workspaceConfig = this.config.workspaces[session.workspace];
+    if (!workspaceConfig) {
+      throw new Error(`session "${session.alias}" references workspace "${session.workspace}", but that workspace is no longer registered`);
+    }
     return {
       alias: session.alias,
       agent: session.agent,
@@ -4919,7 +5812,8 @@ class SessionService {
       workspace: session.workspace,
       transportSession: session.transport_session,
       modeId: session.mode_id,
-      cwd: this.config.workspaces[session.workspace].cwd
+      replyMode: session.reply_mode,
+      cwd: workspaceConfig.cwd
     };
   }
   async setSessionTransportAgentCommand(alias, transportAgentCommand) {
@@ -4951,6 +5845,7 @@ class SessionService {
       transport_session: transportSession,
       ...normalizedTransportAgentCommand ? { transport_agent_command: normalizedTransportAgentCommand } : existingSession?.transport_agent_command ? { transport_agent_command: existingSession.transport_agent_command } : {},
       mode_id: existingSession?.mode_id,
+      reply_mode: existingSession?.reply_mode,
       created_at: existingSession?.created_at ?? now,
       last_used_at: now
     };
@@ -4959,6 +5854,15 @@ class SessionService {
     return this.toResolvedSession(session);
   }
   validateSession(alias, agent, workspace) {
+    if (alias.trim().length === 0) {
+      throw new Error("session alias must be a non-empty string");
+    }
+    if (agent.trim().length === 0) {
+      throw new Error("agent must be a non-empty string");
+    }
+    if (workspace.trim().length === 0) {
+      throw new Error("workspace must be a non-empty string");
+    }
     if (!this.config.workspaces[workspace]) {
       throw new Error(`workspace "${workspace}" is not registered`);
     }
@@ -4978,8 +5882,28 @@ function createEmptyState() {
 }
 
 // src/state/state-store.ts
-import { mkdir as mkdir7, readFile as readFile6, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname6 } from "node:path";
+import { mkdir as mkdir8, readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname7 } from "node:path";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseState(raw, path11) {
+  if (!isRecord2(raw)) {
+    throw new Error(`state file "${path11}" must contain a JSON object`);
+  }
+  const sessions = raw.sessions;
+  if (!isRecord2(sessions)) {
+    throw new Error(`state file "${path11}" must contain an object field "sessions"`);
+  }
+  const chatContexts = raw.chat_contexts;
+  if (!isRecord2(chatContexts)) {
+    throw new Error(`state file "${path11}" must contain an object field "chat_contexts"`);
+  }
+  return {
+    sessions,
+    chat_contexts: chatContexts
+  };
+}
 
 class StateStore {
   path;
@@ -4988,11 +5912,19 @@ class StateStore {
   }
   async load() {
     try {
-      const content = await readFile6(this.path, "utf8");
+      const content = await readFile7(this.path, "utf8");
       if (content.trim() === "") {
         return createEmptyState();
       }
-      return JSON.parse(content);
+      let parsed;
+      try {
+        parsed = JSON.parse(content);
+      } catch (error) {
+        throw new Error(`failed to parse state file "${this.path}"`, {
+          cause: error
+        });
+      }
+      return parseState(parsed, this.path);
     } catch (error) {
       if (error.code === "ENOENT") {
         return createEmptyState();
@@ -5001,8 +5933,8 @@ class StateStore {
     }
   }
   async save(state) {
-    await mkdir7(dirname6(this.path), { recursive: true });
-    await writeFile5(this.path, JSON.stringify(state, null, 2));
+    await mkdir8(dirname7(this.path), { recursive: true });
+    await writeFile6(this.path, JSON.stringify(state, null, 2));
   }
 }
 var init_state_store = () => {};
@@ -5014,12 +5946,17 @@ __export(exports_run_console, {
 });
 async function runConsole(paths, deps) {
   const runtime = await deps.buildApp(paths);
+  const consumerLock = deps.consumerLock ?? deps.consumerLockFactory?.(runtime);
   const sdk = await deps.loadWeixinSdk();
   const setIntervalFn = deps.setInterval ?? ((fn, delay) => setInterval(fn, delay));
   const clearIntervalFn = deps.clearInterval ?? ((timer) => clearInterval(timer));
   const addProcessListener = deps.addProcessListener ?? ((signal, handler) => process.on(signal, handler));
   const removeProcessListener = deps.removeProcessListener ?? ((signal, handler) => process.off(signal, handler));
+  const processPid = deps.processPid ?? process.pid;
+  const now = deps.now ?? (() => new Date().toISOString());
+  const hostname = deps.hostname ?? (() => "");
   let heartbeatTimer = null;
+  let consumerLockAcquired = false;
   const shutdownController = new AbortController;
   const signalHandler = () => {
     shutdownController.abort();
@@ -5036,6 +5973,53 @@ async function runConsole(paths, deps) {
         deps.daemonRuntime?.heartbeat().catch(() => {});
       }, deps.heartbeatIntervalMs ?? 30000);
     }
+    if (consumerLock) {
+      const lockMeta = {
+        pid: processPid,
+        mode: deps.daemonRuntime ? "daemon" : "foreground",
+        startedAt: now(),
+        configPath: paths.configPath,
+        statePath: paths.statePath,
+        hostname: hostname() || undefined
+      };
+      await runtime.logger.info("weixin.consumer_lock.acquire_attempt", "attempting to acquire weixin consumer lock", {
+        pid: lockMeta.pid,
+        mode: lockMeta.mode,
+        configPath: lockMeta.configPath,
+        statePath: lockMeta.statePath,
+        hostname: lockMeta.hostname
+      });
+      try {
+        await consumerLock.acquire(lockMeta);
+        consumerLockAcquired = true;
+        await runtime.logger.info("weixin.consumer_lock.acquired", "acquired weixin consumer lock", {
+          pid: lockMeta.pid,
+          mode: lockMeta.mode,
+          configPath: lockMeta.configPath,
+          statePath: lockMeta.statePath
+        });
+      } catch (error) {
+        if (error instanceof ActiveWeixinConsumerLockError) {
+          await runtime.logger.error("weixin.consumer_lock.acquire_failed", "weixin consumer lock is already held by another process", {
+            conflictType: "active_lock_holder",
+            activePid: error.existing.pid,
+            activeMode: error.existing.mode,
+            activeConfigPath: error.existing.configPath,
+            activeStatePath: error.existing.statePath,
+            requestedPid: lockMeta.pid,
+            requestedMode: lockMeta.mode
+          });
+        } else {
+          await runtime.logger.error("weixin.consumer_lock.acquire_failed", "failed to acquire weixin consumer lock", {
+            conflictType: deps.daemonRuntime ? "daemon_startup_lock_failure" : "foreground_startup_lock_failure",
+            requestedPid: lockMeta.pid,
+            requestedMode: lockMeta.mode,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+        throw error;
+      }
+    }
     if (!sdk.isLoggedIn()) {
       console.log("[weacpx] 未检测到登录凭证，正在启动扫码登录...");
       await sdk.login();
@@ -5056,17 +6040,30 @@ async function runConsole(paths, deps) {
     if (deps.daemonRuntime) {
       await deps.daemonRuntime.stop();
     }
+    if (consumerLockAcquired) {
+      await consumerLock?.release();
+      await runtime.logger.info("weixin.consumer_lock.released", "released weixin consumer lock", {
+        pid: processPid
+      });
+    }
     if (disposeError) {
       throw disposeError;
     }
   }
 }
+var init_run_console = __esm(() => {
+  init_consumer_lock();
+});
 
 // src/transport/acpx-bridge/acpx-bridge-protocol.ts
 function encodeBridgeRequest(request) {
   return `${JSON.stringify(request)}
 `;
 }
+function encodeBridgePromptSegmentEvent(event) {
+  return `${JSON.stringify(event)}
+`;
+}
 
 // src/transport/acpx-bridge/acpx-bridge-client.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -5077,30 +6074,59 @@ class AcpxBridgeClient {
   writeLine;
   nextId = 1;
   pending = new Map;
+  terminalError = null;
   constructor(writeLine) {
     this.writeLine = writeLine;
   }
-  request(method, params) {
+  request(method, params, onEvent) {
+    if (this.terminalError) {
+      return Promise.reject(this.terminalError);
+    }
     const id = String(this.nextId);
     this.nextId += 1;
     return awaitable((resolve2, reject) => {
       this.pending.set(id, {
         resolve: (value) => resolve2(value),
-        reject
+        reject,
+        onEvent
       });
-      this.writeLine(encodeBridgeRequest({
-        id,
-        method,
-        params
-      }));
+      try {
+        const didWrite = this.writeLine(encodeBridgeRequest({
+          id,
+          method,
+          params
+        }));
+        if (didWrite === false) {
+          this.pending.delete(id);
+          reject(new Error("bridge write buffer is full"));
+        }
+      } catch (error) {
+        this.pending.delete(id);
+        reject(error);
+      }
     });
   }
   handleLine(line) {
-    const response = JSON.parse(line);
-    const pending = this.pending.get(response.id);
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const pending = this.pending.get(message.id);
     if (!pending) {
       return;
     }
+    if ("event" in message) {
+      if (message.event === "prompt.segment") {
+        pending.onEvent?.({
+          type: "prompt.segment",
+          text: message.text
+        });
+      }
+      return;
+    }
+    const response = message;
     this.pending.delete(response.id);
     if (response.ok) {
       pending.resolve(response.result);
@@ -5117,6 +6143,7 @@ class AcpxBridgeClient {
     pending.reject(new Error(response.error.message));
   }
   handleExit(error) {
+    this.terminalError = error;
     const pendingRequests = [...this.pending.values()];
     this.pending.clear();
     for (const pending of pendingRequests) {
@@ -5148,13 +6175,11 @@ async function spawnAcpxBridgeClient(options = {}) {
       ...process.env,
       WEACPX_BRIDGE_ACPX_COMMAND: options.acpxCommand ?? "acpx",
       WEACPX_BRIDGE_PERMISSION_MODE: options.permissionMode ?? "approve-all",
-      WEACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS: options.nonInteractivePermissions ?? "fail"
+      WEACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS: options.nonInteractivePermissions ?? "deny"
     },
     stdio: ["pipe", "pipe", "inherit"]
   });
-  const client = new AcpxBridgeClient((line) => {
-    child.stdin.write(line);
-  });
+  const client = new AcpxBridgeClient((line) => child.stdin.write(line));
   const output = createInterface({
     input: child.stdout,
     crlfDelay: Infinity
@@ -5201,10 +6226,14 @@ class AcpxBridgeTransport {
   async ensureSession(session) {
     await this.client.request("ensureSession", this.toParams(session));
   }
-  async prompt(session, text, _reply) {
+  async prompt(session, text, reply) {
     return await this.client.request("prompt", {
       ...this.toParams(session),
       text
+    }, (event) => {
+      if (event.type === "prompt.segment") {
+        reply?.(event.text);
+      }
     });
   }
   async setMode(session, modeId) {
@@ -5220,8 +6249,8 @@ class AcpxBridgeTransport {
     const result = await this.client.request("hasSession", this.toParams(session));
     return result.exists;
   }
-  async listSessions() {
-    return [];
+  async updatePermissionPolicy(policy) {
+    await this.client.request("updatePermissionPolicy", { ...policy });
   }
   async dispose() {
     await this.client.dispose?.();
@@ -5311,12 +6340,12 @@ function parseStreamingChunks(state, line) {
 
 // src/transport/acpx-cli/node-pty-helper.ts
 import { chmod as chmodFs } from "node:fs/promises";
-import { dirname as dirname7, join as join3 } from "node:path";
+import { dirname as dirname8, join as join4 } from "node:path";
 function resolveNodePtyHelperPath(packageJsonPath, platform, arch) {
   if (platform === "win32") {
     return null;
   }
-  return join3(dirname7(packageJsonPath), "prebuilds", `${platform}-${arch}`, "spawn-helper");
+  return join4(dirname8(packageJsonPath), "prebuilds", `${platform}-${arch}`, "spawn-helper");
 }
 async function ensureNodePtyHelperExecutable(helperPath, chmod = chmodFs) {
   if (!helperPath) {
@@ -5404,7 +6433,7 @@ class AcpxCliTransport {
     this.command = options.command ?? "acpx";
     this.sessionInitTimeoutMs = options.sessionInitTimeoutMs ?? 120000;
     this.permissionMode = options.permissionMode ?? "approve-all";
-    this.nonInteractivePermissions = options.nonInteractivePermissions ?? "fail";
+    this.nonInteractivePermissions = options.nonInteractivePermissions ?? "deny";
     this.runCommand = runCommand;
     this.runPtyCommand = runPtyCommand;
   }
@@ -5448,6 +6477,10 @@ class AcpxCliTransport {
       message: output.trim()
     };
   }
+  async updatePermissionPolicy(policy) {
+    this.permissionMode = policy.permissionMode;
+    this.nonInteractivePermissions = policy.nonInteractivePermissions;
+  }
   async hasSession(session) {
     const result = await this.runCommand(this.command, this.buildArgs(session, [
       "sessions",
@@ -5456,9 +6489,6 @@ class AcpxCliTransport {
     ]));
     return result.code === 0;
   }
-  async listSessions() {
-    return [];
-  }
   async run(args, options) {
     const result = await this.runCommandWithTimeout(this.runCommand, args, options);
     if (result.code !== 0) {
@@ -5607,8 +6637,8 @@ __export(exports_main, {
   main: () => main2,
   buildApp: () => buildApp
 });
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname8, join as join4 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname9, join as join5 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 async function buildApp(paths, deps = {}) {
   await ensureConfigExists(paths.configPath);
@@ -5670,7 +6700,7 @@ async function main2() {
   }
 }
 function resolveRuntimePaths() {
-  const home = process.env.HOME ?? homedir3();
+  const home = process.env.HOME ?? homedir5();
   if (!home) {
     throw new Error("Unable to resolve the current user home directory");
   }
@@ -5686,9 +6716,9 @@ function resolveBridgeEntryPath() {
   return fileURLToPath3(new URL("./bridge/bridge-main.ts", import.meta.url));
 }
 function resolveAppLogPath(configPath) {
-  const rootDir = dirname8(configPath);
-  const runtimeDir = join4(rootDir, "runtime");
-  return join4(runtimeDir, "app.log");
+  const rootDir = dirname9(configPath);
+  const runtimeDir = join5(rootDir, "runtime");
+  return join5(runtimeDir, "app.log");
 }
 var init_main = __esm(async () => {
   init_command_router();
@@ -5700,6 +6730,7 @@ var init_main = __esm(async () => {
   init_app_logger();
   init_session_service();
   init_state_store();
+  init_run_console();
   init_acpx_bridge_client();
   init_acpx_cli_transport();
   init_weixin_sdk();
@@ -5707,7 +6738,7 @@ var init_main = __esm(async () => {
 });
 
 // src/cli.ts
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { sep } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
@@ -5788,7 +6819,7 @@ class DaemonController {
       return { state: "stopped", stale: true };
     }
     if (!status) {
-      return { state: "stopped" };
+      return { state: "indeterminate", pid, reason: "missing-status" };
     }
     return {
       state: "running",
@@ -5801,6 +6832,9 @@ class DaemonController {
     if (current.state === "running") {
       return { state: "already-running", pid: current.pid };
     }
+    if (current.state === "indeterminate") {
+      throw new Error(`weacpx daemon process is already running (pid ${current.pid}) but status metadata is missing`);
+    }
     await this.statusStore.clear();
     const pid = await this.deps.spawnDetached();
     await this.writePid(pid);
@@ -6008,27 +7042,30 @@ async function spawnWindowsHiddenProcess(request) {
 async function defaultTerminateProcess(pid) {
   await terminateProcessTree(pid);
 }
-async function terminateProcessTree(pid, platform = process.platform, runCommand = defaultRunProcessCommand) {
+async function terminateProcessTree(pid, platform = process.platform, runCommand = defaultRunProcessCommand, killProcess = (targetPid, signal) => {
+  process.kill(targetPid, signal);
+}, isProcessRunning = defaultIsProcessRunning) {
   if (platform === "win32") {
     try {
       await runCommand("taskkill", ["/PID", String(pid), "/T", "/F"]);
     } catch {}
     return;
   }
+  const targetPid = pid > 0 ? -pid : pid;
   try {
-    process.kill(pid, "SIGTERM");
+    killProcess(targetPid, "SIGTERM");
   } catch {
     return;
   }
   const deadline = Date.now() + 5000;
   while (Date.now() < deadline) {
-    if (!defaultIsProcessRunning(pid)) {
+    if (!isProcessRunning(targetPid)) {
       return;
     }
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
   try {
-    process.kill(pid, "SIGKILL");
+    killProcess(targetPid, "SIGKILL");
   } catch {}
 }
 async function defaultRunProcessCommand(command, args) {
@@ -6103,6 +7140,7 @@ class DaemonRuntime {
 }
 
 // src/cli.ts
+init_consumer_lock();
 var HELP_LINES = [
   "用法：",
   "weacpx login  - 微信登录",
@@ -6139,6 +7177,11 @@ async function runCli(args, deps = {}) {
     }
     case "status": {
       const status = await controller.getStatus();
+      if (status.state === "indeterminate") {
+        print("weacpx 进程仍在运行，但状态元数据缺失");
+        print(`PID: ${status.pid}`);
+        return 1;
+      }
       if (status.state !== "running") {
         print("weacpx 未运行");
         return 0;
@@ -6182,7 +7225,7 @@ async function defaultRun() {
   const [{ buildApp: buildApp2, resolveRuntimePaths: resolveRuntimePaths2 }, { loadWeixinSdk: loadWeixinSdk2 }, { runConsole: runConsole2 }] = await Promise.all([
     init_main().then(() => exports_main),
     Promise.resolve().then(() => (init_weixin_sdk(), exports_weixin_sdk)),
-    Promise.resolve().then(() => exports_run_console)
+    Promise.resolve().then(() => (init_run_console(), exports_run_console))
   ]);
   const runtimePaths = resolveRuntimePaths2();
   const daemonPaths = resolveDaemonPaths({ home: requireHome() });
@@ -6192,7 +7235,13 @@ async function defaultRun() {
       defaultLoggingLevel: resolveCliEntryPath().includes(`${sep}src${sep}`) ? "debug" : "info"
     }),
     loadWeixinSdk: loadWeixinSdk2,
-    daemonRuntime
+    daemonRuntime,
+    consumerLockFactory: (runtime) => createWeixinConsumerLock({
+      lockFilePath: `${daemonPaths.runtimeDir}${sep}weixin-consumer.lock.json`,
+      onDiagnostic: async (event, context) => {
+        await runtime.logger.info(`weixin.consumer_lock.${event}`, "weixin consumer lock diagnostic", context);
+      }
+    })
   });
 }
 function createDefaultController() {
@@ -6205,7 +7254,7 @@ function createDefaultController() {
   });
 }
 function requireHome() {
-  const home = process.env.HOME ?? homedir4();
+  const home = process.env.HOME ?? homedir6();
   if (!home) {
     throw new Error("Unable to resolve the current user home directory");
   }