weacpx 0.1.6 → 0.1.7

package/dist/cli.js

@@ -2829,20 +2829,26 @@ var init_slash_commands = __esm(() => {
 // src/weixin/messaging/process-message.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,10 +2863,10 @@ 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) {
@@ -2891,7 +2897,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,7 +2920,7 @@ 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 ?? "";
@@ -2926,7 +2932,7 @@ async function processOneMessage(full, deps) {
         opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken }
       });
     } catch (err) {
-      logger.error(`intermediate reply failed: ${String(err)}`);
+      deps.errLog(`intermediate reply failed: ${String(err)}`);
     }
   };
   const request = {
@@ -2959,7 +2965,7 @@ async function processOneMessage(full, deps) {
       let filePath;
       const mediaUrl = response.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);
       }
@@ -2978,7 +2984,8 @@ async function processOneMessage(full, deps) {
       });
     }
   } 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(`processOneMessage: agent or send failed: ${errorText}`);
     sendWeixinErrorNotice({
       to,
       contextToken,
@@ -3003,14 +3010,13 @@ async function processOneMessage(full, deps) {
     }
   }
 }
-var MEDIA_TEMP_DIR = "/tmp/weixin-agent/media", hasDownloadableMedia = (m) => m?.encrypt_query_param || m?.full_url;
+var hasDownloadableMedia = (media) => media?.encrypt_query_param || media?.full_url;
 var init_process_message = __esm(() => {
   init_api();
   init_types();
   init_upload();
   init_media_download();
   init_mime();
-  init_logger();
   init_inbound();
   init_error_notice();
   init_send_media();
@@ -3327,90 +3333,6 @@ 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";
@@ -3898,11 +3820,640 @@ var init_parse_command = __esm(() => {
   ]);
 });
 
+// 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: "当前没有加载可写入的配置。" };
+  }
+  const updated = await context.configStore.updateTransport({
+    permissionMode: mode
+  });
+  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 updated = await context.configStore.updateTransport({
+    nonInteractivePermissions: policy
+  });
+  context.replaceConfig(updated);
+  return { text: renderPermissionStatus(context.config, "非交互策略已更新：") };
+}
+function renderPermissionStatus(config, title) {
+  const permissionMode = config?.transport.permissionMode ?? "approve-all";
+  const nonInteractivePermissions = config?.transport.nonInteractivePermissions ?? "fail";
+  return [title, `- mode: ${permissionMode}`, `- auto: ${nonInteractivePermissions}`].join(`
+`);
+}
+
+// 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(`
+`)
+  };
+}
+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, cwdInput, createNew) {
+  return await context.lifecycle.handleSessionShortcut(chatKey, agent, cwdInput, 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(`
+`)
+    };
+  }
+  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(`
+`)
+  };
+}
+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 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(`
+`)
+  };
+}
+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 result = await context.interaction.promptTransportSession(session, text, reply);
+    return { text: result.text };
+  } catch (error) {
+    const recovered = await context.recovery.tryRecoverMissingSession(session, error);
+    if (recovered) {
+      const result = await context.interaction.promptTransportSession(recovered, text, reply);
+      return { text: result.text };
+    }
+    return context.recovery.renderTransportError(session, error);
+  }
+}
+var NO_CURRENT_SESSION_TEXT = "当前还没有选中的会话。请先执行 /session new ... 或 /use <alias>。";
+
+// 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;
+    }
+  }
+  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("未收到最终回复");
+}
+
+// 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/commands/handlers/help-handler.ts
+function handleHelp() {
+  return { text: renderHelpText() };
+}
+var init_help_handler = () => {};
+
+// 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/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 init_agent_handler = __esm(() => {
+  init_agent_templates();
+});
+
+// src/commands/handlers/workspace-handler.ts
+import { access } from "node:fs/promises";
+import { homedir as homedir2 } 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("~") ? homedir2() + path11.slice(1) : path11;
+  return normalize(expanded);
+}
+var init_workspace_handler = () => {};
+
+// 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 homedir3 } from "node:os";
+async function handleSessionShortcutCommand(context, ops, chatKey, agent, cwdInput, createNew) {
+  if (!context.config || !context.configStore) {
+    return { text: "当前没有加载可写入的配置。" };
+  }
+  const cwd = normalizePathForWorkspace2(cwdInput);
+  if (!await pathExists2(cwd)) {
+    return { text: `工作区路径不存在：${cwdInput}` };
+  }
+  const workspace = await resolveShortcutWorkspace(context, cwd);
+  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,
+      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, cwd) {
+  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("~") ? homedir3() + 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 renderSessionCreationVerificationError(session);
+  }
+  throw error;
+}
+function renderSessionCreationVerificationError(session) {
+  return {
+    text: [
+      "当前还不能直接在微信里创建新会话。",
+      `请先准备好一个已有会话，然后在微信里执行：/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: [
+          `会话「${session.alias}」重置失败。`,
+          "新的后端会话未创建成功，请稍后重试。"
+        ].join(`
+`)
+      };
+    }
+  } 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
-import { access } from "node:fs/promises";
-import { basename as basename2, normalize } from "node:path";
-import { homedir as homedir2 } from "node:os";
-
 class CommandRouter {
   sessions;
   transport;
@@ -3941,388 +4492,132 @@ class CommandRouter {
 `)
           };
         case "help":
-          return { text: renderHelpText() };
+          return handleHelp();
         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}」已删除` };
-        }
+          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 { 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("权限模式已更新：") };
-        }
+          return handlePermissionStatus(this.createHandlerContext(), "当前权限模式：");
+        case "permission.mode.set":
+          return await handlePermissionModeSet(this.createHandlerContext(), command.mode);
         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("非交互策略已更新：") };
-        }
+          return handlePermissionAutoStatus(this.createHandlerContext(), "当前非交互策略：");
+        case "permission.auto.set":
+          return await handlePermissionAutoSet(this.createHandlerContext(), command.policy);
         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(`
-`)
-          };
-        }
-        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}」已创建并切换` };
-        }
+          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 this.handleSessionShortcut(chatKey, command.agent, command.cwd, false);
+          return await handleSessionShortcut(this.createSessionHandlerContext(), 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 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}」已绑定并切换` };
-        }
+          return await handleSessionShortcut(this.createSessionHandlerContext(), chatKey, command.agent, command.cwd, true);
+        case "session.attach":
+          return await handleSessionAttach(this.createSessionHandlerContext(), chatKey, command.alias, command.agent, command.workspace, command.transportSession);
         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(`
-`)
-          };
-        }
-        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(`
-`)
-          };
-        }
-        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);
-          }
-        }
+          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 "status":
+          return await handleStatus(this.createSessionHandlerContext(), chatKey);
+        case "cancel":
+          return await handleCancel(this.createSessionHandlerContext(), chatKey);
         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);
-          }
-        }
+          return await handleSessionReset(this.createSessionHandlerContext(), chatKey);
+        case "prompt":
+          return await handlePrompt(this.createSessionHandlerContext(), chatKey, command.text, reply);
       }
     });
   }
   async clearSession(chatKey) {
-    await this.resetCurrentSession(chatKey);
+    await handleSessionResetCommand(this.createHandlerContext(), this.createSessionResetOps(), chatKey);
   }
-  async handleSessionShortcut(chatKey, agent, cwdInput, createNew) {
-    if (!this.config || !this.configStore) {
-      return { text: "当前没有加载可写入的配置。" };
-    }
-    const cwd = normalizePathForWorkspace(cwdInput);
-    if (!await pathExists(cwd)) {
-      return { text: `工作区路径不存在：${cwdInput}` };
-    }
-    const workspace = await this.resolveShortcutWorkspace(cwd);
-    await this.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 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 = 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 {
-      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
-    });
+  createHandlerContext() {
     return {
-      text: [
-        `已创建并切换到会话「${alias}」`,
-        workspace.reused ? `- 复用工作区：${workspace.name}` : `- 新增工作区：${workspace.name} -> ${workspace.cwd}`,
-        `- 新增会话：${alias}`
-      ].join(`
-`)
+      sessions: this.sessions,
+      transport: this.transport,
+      config: this.config,
+      configStore: this.configStore,
+      logger: this.logger,
+      replaceConfig: (updated) => this.replaceConfig(updated)
     };
   }
-  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(`
-`);
-  }
-  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;
-    }
+  createSessionHandlerContext() {
     return {
-      text: [
-        `当前会话「${session.alias}」执行中断，未收到最终回复。`,
-        "请直接重试；如果长时间无响应，可先发送 /cancel 后再重试。",
-        `错误信息：${summarizeTransportError(message)}`
-      ].join(`
-`)
+      ...this.createHandlerContext(),
+      lifecycle: this.createSessionLifecycleOps(),
+      interaction: this.createSessionInteractionOps(),
+      recovery: this.createSessionRenderRecoveryOps()
     };
   }
-  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;
-  }
-  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, cwdInput, createNew) => handleSessionShortcutCommand(this.createHandlerContext(), this.createSessionShortcutOps(), chatKey, agent, cwdInput, 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.agents = { ...updated.agents };
+    this.config.workspaces = { ...updated.workspaces };
+  }
   async executeCommand(chatKey, kind, startedAt, operation) {
     try {
       const response = await operation();
@@ -4345,42 +4640,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 +4663,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 +4700,17 @@ 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_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
@@ -5220,9 +5393,6 @@ class AcpxBridgeTransport {
     const result = await this.client.request("hasSession", this.toParams(session));
     return result.exists;
   }
-  async listSessions() {
-    return [];
-  }
   async dispose() {
     await this.client.dispose?.();
   }
@@ -5456,9 +5626,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,7 +5774,7 @@ __export(exports_main, {
   main: () => main2,
   buildApp: () => buildApp
 });
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 import { dirname as dirname8, join as join4 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 async function buildApp(paths, deps = {}) {
@@ -5670,7 +5837,7 @@ async function main2() {
   }
 }
 function resolveRuntimePaths() {
-  const home = process.env.HOME ?? homedir3();
+  const home = process.env.HOME ?? homedir4();
   if (!home) {
     throw new Error("Unable to resolve the current user home directory");
   }
@@ -5707,7 +5874,7 @@ var init_main = __esm(async () => {
 });
 
 // src/cli.ts
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import { sep } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
@@ -6205,7 +6372,7 @@ function createDefaultController() {
   });
 }
 function requireHome() {
-  const home = process.env.HOME ?? homedir4();
+  const home = process.env.HOME ?? homedir5();
   if (!home) {
     throw new Error("Unable to resolve the current user home directory");
   }