chatccc 0.2.121 → 0.2.123

package/README.md

@@ -296,20 +296,28 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 
 ## 可用指令
 
-| 指令 | 作用 |
-| --- | --- |
-| `/new` | 使用默认 Agent 创建新会话 |
-| `/new claude` | 创建 Claude Code 会话 |
-| `/new cursor` | 创建 Cursor 会话 |
-| `/new codex` | 创建 Codex 会话 |
-| `/newh` | 重置当前会话，保留工作目录 |
-| `/model` | 查看或切换当前会话的模型 |
-| `/stop` | 停止当前回复 |
-| `/state` | 查看当前会话状态 |
-| `/cd` | 查看或设置当前会话工作目录 |
-| `/sessions` | 查看所有会话状态 |
-| `/git <子命令>` | 在当前会话工作目录执行 `git ...` 并回传输出 |
-| `/restart` | 重启机器人进程 |
+| 指令 | 作用 | 适用 Agent |
+| --- | --- | --- |
+| `/new` | 使用默认 Agent 创建新会话 | 全部 |
+| `/new claude` | 创建 Claude Code 会话 | 全部 |
+| `/new cursor` | 创建 Cursor 会话 | 全部 |
+| `/new codex` | 创建 Codex 会话 | 全部 |
+| `/newh` | 重置当前会话，保留工作目录 | 全部 |
+| `/stop` | 停止当前回复 | 全部 |
+| `/cancel` | 取消缓存队列中的消息 | 全部 |
+| `/state` | 查看当前会话状态 | 全部 |
+| `/sessions` | 查看所有会话状态 | 全部 |
+| `/session <编号>` | 将当前群聊切换到指定编号的会话 | 全部 |
+| `/model` | 查看当前会话的可用模型 | 全部 |
+| `/model <名称>` | 模糊匹配切换当前会话模型 | 全部 |
+| `/model clear` | 清除模型覆盖，恢复默认 | 全部 |
+| `/cd` | 查看当前工作目录（含最近目录快捷按钮） | 全部 |
+| `/cd <路径>` | 设置新建会话的默认工作目录 | 全部 |
+| `/plan <消息>` | Claude Code 使用 CLI 只读/规划模式；其他 Agent 会收到包含 `/plan` 前缀的原始消息，可能通过消息内容自行支持 | Claude Code（CLI 模式）/ 全部（消息透传） |
+| `/ask <消息>` | Cursor 使用 CLI 只读/问答模式；其他 Agent 会收到包含 `/ask` 前缀的原始消息，可能通过消息内容自行支持 | Cursor（CLI 模式）/ 全部（消息透传） |
+| `/git <子命令>` | 在当前会话工作目录执行 git 命令并回传输出 | 全部 |
+| `/deleteg` | 解散当前群聊，保留 Agent 会话 | 全部（仅群聊） |
+| `/restart` | 重启 ChatCCC 服务进程 | 全部 |
 
 > **模型切换**：`/model` 查看可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。当前仅 Claude Code 支持模型切换（需同时填写 `claude.model` 和 `claude.subagentModel`），Cursor / Codex 切换正在开发中。
 

package/package.json

@@ -1,63 +1,63 @@
-{
-  "name": "chatccc",
-  "version": "0.2.121",
-  "description": "Feishu bot bridge for Claude Code",
-  "license": "Apache-2.0",
-  "type": "module",
-  "main": "./src/index.ts",
-  "bin": {
-    "chatccc": "bin/chatccc.mjs"
-  },
-  "files": [
-    "src/",
-    "bin/",
-    "scripts/postinstall-sharp-check.mjs",
-    "demo/ilink_echo_probe.ts",
-    "im-skills/",
-    "images/img_readme_*.jpg",
-    "images/img_readme_*.png",
-    "images/avatars/status_*.png",
-    "images/avatars/badges/",
-    "package.json",
-    "README.md",
-    "config.sample.json"
-  ],
-  "scripts": {
-    "dev": "tsx src/index.ts",
-    "chatccc": "tsx src/index.ts",
-    "start": "tsx src/index.ts",
-    "demo:bot-test": "tsx demo/bot_test.ts",
-    "demo:bot-test:local": "tsx demo/bot_test.ts --local",
-    "demo:create-group": "tsx src/index.ts",
-    "demo:create-group:local": "tsx src/index.ts --local",
-    "demo:permission-check": "tsx demo/permission_check.ts",
-    "demo:claude-hi": "tsx demo/claude_say_hi.ts",
-    "demo:codex-hi": "tsx demo/codex_say_hi.ts",
-    "demo:ilink-echo": "tsx demo/ilink_echo_probe.ts",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "postinstall": "node scripts/postinstall-sharp-check.mjs"
-  },
-  "dependencies": {
-    "@ai-sdk/openai-compatible": "^2.0.47",
-    "@anthropic-ai/claude-agent-sdk": "0.2.133",
-    "@larksuiteoapi/node-sdk": "^1.59.0",
-    "@openilink/openilink-sdk-node": "^0.6.0",
-    "ai": "^6.0.184",
-    "nodemailer": "^8.0.7",
-    "qrcode-terminal": "^0.12.0",
-    "sharp": "^0.34.5",
-    "tsx": "^4.0.0",
-    "ws": "^8.18.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@types/qrcode-terminal": "^0.12.2",
-    "@types/ws": "^8.18.1",
-    "typescript": "^5.0.0",
-    "vitest": "^3.2.4"
-  },
-  "engines": {
-    "node": ">=20"
-  }
-}
+{
+  "name": "chatccc",
+  "version": "0.2.123",
+  "description": "Feishu bot bridge for Claude Code",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./src/index.ts",
+  "bin": {
+    "chatccc": "bin/chatccc.mjs"
+  },
+  "files": [
+    "src/",
+    "bin/",
+    "scripts/postinstall-sharp-check.mjs",
+    "demo/ilink_echo_probe.ts",
+    "im-skills/",
+    "images/img_readme_*.jpg",
+    "images/img_readme_*.png",
+    "images/avatars/status_*.png",
+    "images/avatars/badges/",
+    "package.json",
+    "README.md",
+    "config.sample.json"
+  ],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "chatccc": "tsx src/index.ts",
+    "start": "tsx src/index.ts",
+    "demo:bot-test": "tsx demo/bot_test.ts",
+    "demo:bot-test:local": "tsx demo/bot_test.ts --local",
+    "demo:create-group": "tsx src/index.ts",
+    "demo:create-group:local": "tsx src/index.ts --local",
+    "demo:permission-check": "tsx demo/permission_check.ts",
+    "demo:claude-hi": "tsx demo/claude_say_hi.ts",
+    "demo:codex-hi": "tsx demo/codex_say_hi.ts",
+    "demo:ilink-echo": "tsx demo/ilink_echo_probe.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "postinstall": "node scripts/postinstall-sharp-check.mjs"
+  },
+  "dependencies": {
+    "@ai-sdk/openai-compatible": "^2.0.47",
+    "@anthropic-ai/claude-agent-sdk": "0.2.133",
+    "@larksuiteoapi/node-sdk": "^1.59.0",
+    "@openilink/openilink-sdk-node": "^0.6.0",
+    "ai": "^6.0.184",
+    "nodemailer": "^8.0.7",
+    "qrcode-terminal": "^0.12.0",
+    "sharp": "^0.34.5",
+    "tsx": "^4.0.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/qrcode-terminal": "^0.12.2",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.0.0",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/src/__tests__/orchestrator.test.ts

@@ -169,6 +169,48 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
   });
 
+  it.each([
+    { tool: "claude" as const, sessionId: "sid-claude", text: "/ask 只回答不要改文件" },
+    { tool: "cursor" as const, sessionId: "sid-cursor", text: "/plan 先给我计划" },
+  ])("passes unsupported mode commands through as raw prompts for $tool", async ({ tool, sessionId, text }) => {
+    const platform = mockPlatform();
+    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
+      yield {
+        type: "assistant" as const,
+        blocks: [{ type: "text" as const, text: `收到: ${userText}` }],
+      };
+    });
+    _setAdapterForToolForTest(tool, {
+      displayName: tool,
+      sessionDescPrefix: `${tool} Session:`,
+      createSession: vi.fn(async () => ({ sessionId })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
+      closeSession: async () => {},
+    });
+    await recordSessionRegistry({
+      chatId: "wx-chat",
+      sessionId,
+      tool,
+      chatName: "ready-session",
+      running: false,
+    });
+
+    await handleCommand(platform, text, "wx-chat", "wx-user", Date.now(), "p2p");
+
+    expect(platform.sendText).not.toHaveBeenCalledWith("wx-chat", expect.stringContaining("仅在以下 Agent 会话中可用"));
+    expect(prompt).toHaveBeenCalledWith(
+      sessionId,
+      expect.stringContaining(text),
+      "F:\\repo",
+      expect.any(AbortSignal),
+      expect.objectContaining({ permissionMode: undefined }),
+    );
+  });
+
   it("cleans stale Feishu p2p binding, creates a group, and sends the private message as first prompt", async () => {
     const platform = mockPlatform("feishu");
     const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
@@ -177,7 +219,7 @@ describe("handleCommand WeChat processing ack", () => {
         blocks: [{ type: "text" as const, text: `收到: ${userText}` }],
       };
     });
-    _setAdapterForToolForTest("cursor", {
+    _setAdapterForToolForTest("claude", {
       displayName: "Claude",
       sessionDescPrefix: "Claude Session:",
       createSession: vi.fn(async () => ({ sessionId: "sid-feishu-new" })),

package/src/adapters/adapter-interface.ts

@@ -128,6 +128,13 @@ export interface ToolPromptOptions {
   onProcessStart?: (info: ToolProcessInfo) => void;
   /** Called when the adapter leaves the prompt process scope normally or by abort. */
   onProcessExit?: (info: ToolProcessInfo) => void;
+  /**
+   * 权限模式覆盖：
+   * - "plan": Claude Code --permission-mode plan（只读/规划）
+   * - "ask":  Cursor Agent --mode ask（只读/问答）
+   * 不传或为 undefined 时使用适配器默认行为（正常编辑模式）。
+   */
+  permissionMode?: "plan" | "ask";
 }
 
 // ---------------------------------------------------------------------------

package/src/adapters/claude-adapter.ts

@@ -274,15 +274,18 @@ function buildCliArgs(
   isEmpty: (value: string) => boolean,
   mcpConfigJson: string | null,
   extraArgs: string[],
+  permissionMode?: "plan" | "ask",
 ): string[] {
+  const permMode = permissionMode === "plan" ? "plan" : permissionMode === "ask" ? "default" : "bypassPermissions";
+  const skipPermissions = permissionMode !== "plan" && permissionMode !== "ask";
   const args = [
     "-p",
     "--output-format", "stream-json",
     "--verbose",
     "--setting-sources", "user,project,local",
-    "--permission-mode", "bypassPermissions",
-    "--dangerously-skip-permissions",
-    "--settings", "{\"maxTurns\":0}",
+    "--permission-mode", permMode,
+    ...(skipPermissions ? ["--dangerously-skip-permissions"] : []),
+    "--settings", "{\"maxTurns\":0,\"autoCompact\":{\"enabled\":true}}",
   ];
 
   if (!isEmpty(model)) args.push("--model", model);
@@ -432,6 +435,7 @@ class ClaudeAdapter implements ToolAdapter {
     const args = buildCliArgs(
       this.model, this.effort, this.isEmpty, mcpConfigJson,
       ["--resume", sessionId, "--input-format", "stream-json", "--replay-user-messages"],
+      options?.permissionMode,
     );
 
     const proc = spawnCli(args, cwd, env, true);

package/src/adapters/cursor-adapter.ts

@@ -261,8 +261,18 @@ function spawnAgent(
   cwd?: string,
   stdinText?: string,
   modelOverride?: string,
+  permissionMode?: "plan" | "ask",
 ): ChildProcess {
   let allArgs = [...CURSOR_AGENT_ARGS, ...extraArgs];
+  if (permissionMode === "ask") {
+    // 替换已有的 --mode 或追加
+    const modeIdx = allArgs.findIndex((a, i) => a === "--mode" && i + 1 < allArgs.length);
+    if (modeIdx >= 0) {
+      allArgs[modeIdx + 1] = "ask";
+    } else {
+      allArgs.push("--mode", "ask");
+    }
+  }
   if (modelOverride) {
     // 替换全局 --model 为 per-session override
     const modelIdx = allArgs.findIndex((a, i) => a === "--model" && i + 1 < allArgs.length);
@@ -370,7 +380,7 @@ class CursorAdapter implements ToolAdapter {
     options?: ToolPromptOptions,
   ): AsyncIterable<UnifiedStreamMessage> {
     console.log(`[Cursor debug] prompt start: sessionId=${sessionId}, cwd=${cwd}, userTextLen=${userText.length}`);
-    const proc = spawnAgent(["--resume", sessionId], cwd, userText, this.modelOverride);
+    const proc = spawnAgent(["--resume", sessionId], cwd, userText, this.modelOverride, options?.permissionMode);
     this.activeProcs.add(proc);
     if (proc.pid !== undefined) options?.onProcessStart?.({ pid: proc.pid });
 

package/src/cards.ts

@@ -131,6 +131,8 @@ export function buildHelpCard(
     "发送 **/new cursor** 创建新 Cursor 会话",
     "发送 **/new codex** 创建新 Codex 会话",
     "发送 **/newh** 重置当前会话（沿用当前工作目录，不切换）",
+    "发送 **/plan <消息>** 在 Claude 会话中以只读规划模式提问",
+    "发送 **/ask <消息>** 在 Cursor 会话中以只读问答模式提问",
   ].join("\n");
   return JSON.stringify({
     config: { wide_screen_mode: true },

package/src/config.ts

@@ -122,6 +122,24 @@ export interface AppConfig {
 export type AgentTool = "claude" | "cursor" | "codex";
 export const AGENT_TOOLS: AgentTool[] = ["claude", "cursor", "codex"];
 
+/**
+ * Agent 专属模式指令（内部配置，非用户可配）。
+ * 映射每个 Agent 支持的特殊指令及其对应的 CLI 权限模式。
+ *
+ * - claude: /plan → --permission-mode plan（只读/规划）
+ * - cursor: /ask  → --mode ask（只读/问答）
+ * - codex:  暂无原生只读模式，不注册任何模式指令
+ */
+export const AGENT_MODE_COMMANDS: Record<AgentTool, { command: string; mode: "plan" | "ask"; description: string }[]> = {
+  claude: [
+    { command: "/plan", mode: "plan", description: "以只读规划模式提问（Claude 专属）" },
+  ],
+  cursor: [
+    { command: "/ask", mode: "ask", description: "以只读问答模式提问（Cursor 专属）" },
+  ],
+  codex: [],
+};
+
 /** 获取指定 agent 配置中所有模型相关的值（最多 100 个，去重） */
 export function getAllModelsForTool(tool: AgentTool, cfg: AppConfig = config): string[] {
   const seen = new Set<string>();

package/src/orchestrator.ts

@@ -19,6 +19,8 @@ import {
   CONFIG_FILE,
   GIT_TIMEOUT_MS,
   PROJECT_ROOT,
+  AGENT_MODE_COMMANDS,
+  AGENT_TOOLS,
   anthropicConfigDisplay,
   config,
   fileLog,
@@ -125,6 +127,85 @@ function isNonWechatP2p(platform: PlatformAdapter, chatType: string): boolean {
   return chatType === "p2p" && platform.kind !== "wechat";
 }
 
+/** 根据 Agent 类型构建欢迎卡片中的指令说明 */
+function buildWelcomeCommands(tool: string): string {
+  const lines = [
+    "发送 **/cd** 切换新建会话的默认目录。",
+    "发送 **/model** 查看或切换当前会话的模型。",
+    "发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。",
+    "发送 **/sessions** 查看所有会话状态。",
+  ];
+  const modeCmds = AGENT_MODE_COMMANDS[tool as AgentTool] ?? [];
+  for (const mc of modeCmds) {
+    lines.push(`发送 **${mc.command} <消息>** ${mc.description}。`);
+  }
+  return lines.join("\n");
+}
+
+/** 根据指令名从 AGENT_MODE_COMMANDS 查找对应的 mode 和支持的 agent 列表 */
+function resolveModeCommand(cmd: string): { mode: "plan" | "ask"; supportedTools: string[] } | null {
+  const supportedTools: string[] = [];
+  let mode: "plan" | "ask" | null = null;
+  for (const tool of AGENT_TOOLS) {
+    for (const mc of AGENT_MODE_COMMANDS[tool]) {
+      if (mc.command === cmd) {
+        supportedTools.push(tool);
+        mode = mc.mode;
+        break;
+      }
+    }
+  }
+  return mode ? { mode, supportedTools } : null;
+}
+
+/** 如果当前群名是未命名会话（"新会话" 或 "新会话-xxx"），用消息内容前缀重命名 */
+async function renameUntitledSession(
+  platform: PlatformAdapter,
+  chatId: string,
+  chatType: string,
+  sessionId: string,
+  tool: string,
+  namePrefix: string,
+  description: string | undefined,
+  chatInfo: { name: string } | undefined,
+): Promise<void> {
+  const MAX_PREFIX = 10;
+  const prefix = namePrefix.slice(0, MAX_PREFIX);
+
+  if (chatType !== "p2p" && chatInfo && isUntitledSessionChatName(chatInfo.name)) {
+    const adapter = getAdapterForTool(tool, sessionId);
+    const info = await adapter.getSessionInfo(sessionId).catch(() => undefined);
+    const sessionCwd = info?.cwd ?? (await getDefaultCwd(chatId));
+    const newName = sessionChatName(prefix, sessionCwd);
+    try {
+      await platform.updateChatInfo(chatId, newName, description!);
+      console.log(`[${ts()}] [RENAME] First message → group renamed to "${newName}"`);
+      await recordSessionRegistry({ chatId, sessionId, tool, chatName: newName }).catch(() => {});
+      await saveSessionTool(sessionId, tool, newName).catch(() => {});
+    } catch (err) {
+      console.error(`[${ts()}] [RENAME] Failed: ${(err as Error).message}`);
+    }
+  }
+
+  if (chatType === "p2p" && platform.kind === "wechat") {
+    try {
+      const reg = await loadSessionRegistryForBinding();
+      const rec = reg[chatId];
+      if (rec && rec.sessionId === sessionId && isUntitledSessionChatName(rec.chatName ?? "")) {
+        const adapter = getAdapterForTool(tool, sessionId);
+        const info = await adapter.getSessionInfo(sessionId).catch(() => undefined);
+        const sessionCwd = info?.cwd ?? (await getDefaultCwd(chatId));
+        const newName2 = sessionChatName(prefix, sessionCwd);
+        await recordSessionRegistry({ chatId, sessionId, tool, chatName: newName2 }).catch(() => {});
+        await saveSessionTool(sessionId, tool, newName2).catch(() => {});
+        console.log(`[${ts()}] [RENAME] WeChat P2P → "${newName2}"`);
+      }
+    } catch (err) {
+      console.error(`[${ts()}] [RENAME] WeChat P2P failed: ${(err as Error).message}`);
+    }
+  }
+}
+
 async function cleanupNonWechatP2pBinding(
   platform: PlatformAdapter,
   chatId: string,
@@ -429,11 +510,7 @@ export async function handleCommand(
           `**Session ID:** ${sessionId}\n` +
           `**工作目录:** \`${cwd}\`\n\n` +
           `直接在这里发消息即可与 ${toolLabel} 对话。\n\n` +
-          `发送 **/cd** 切换新建会话的默认目录。\n` +
-          `发送 **/model** 查看或切换当前会话的模型。\n` +
-          `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。\n` +
-          `发送 **/sessions** 查看所有会话状态。\n` +
-          `发送 \`/git <子命令>\` 在本会话工作目录执行 git，例如 \`/git status\`、\`/git log --oneline -n 5\`。`,
+          buildWelcomeCommands(tool),
         "green",
       );
       console.log(
@@ -515,11 +592,7 @@ export async function handleCommand(
         `**Session ID:** ${sessionId}\n` +
         `**工作目录:** \`${cwd}\`\n\n` +
         `直接在这里发消息即可与 ${toolLabel} 对话。\n\n` +
-        `发送 **/cd** 切换新建会话的默认目录。\n` +
-        `发送 **/model** 查看或切换当前会话的模型。\n` +
-        `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。\n` +
-        `发送 **/sessions** 查看所有会话状态。\n` +
-        `发送 \`/git <子命令>\` 在本会话工作目录执行 git，例如 \`/git status\`、\`/git log --oneline -n 5\`。`,
+        buildWelcomeCommands(tool),
       "green",
     );
 
@@ -877,9 +950,8 @@ export async function handleCommand(
         `会话已重置为新的 **${toolLabel}** 会话。\n\n` +
           `**Session ID:** ${newSessionId}\n` +
           `**工作目录:** \`${cwd}\`（沿用当前会话目录）\n\n` +
-          `直接在这里发消息即可继续对话。\n` +
-          `发送 **/cd** 可切换新建会话的默认目录。\n` +
-          `发送 **/model** 查看或切换当前会话的模型。`,
+          `直接在这里发消息即可继续对话。\n\n` +
+          buildWelcomeCommands(descriptionTool),
         "green",
       );
 
@@ -1181,6 +1253,134 @@ export async function handleCommand(
       return;
     }
 
+    // /plan <message> — 只读/规划模式
+    if (textLower.startsWith("/plan ")) {
+      const planText = text.slice(6).trim();
+      const resolved = resolveModeCommand("/plan");
+      if (!planText) {
+        await platform.sendText(chatId, "用法：`/plan <消息>` — 在只读/规划模式下提问。").catch(() => {});
+        logTrace(tid, "DONE", { outcome: "plan_no_message" });
+        return;
+      }
+      if (resolved?.supportedTools.includes(descriptionTool) === true) {
+        logTrace(tid, "BRANCH", { cmd: "/plan", sessionId, tool: descriptionTool });
+
+        await renameUntitledSession(
+          platform, chatId, chatType, sessionId, descriptionTool,
+          planText, description, chatInfo,
+        );
+
+        if (isSessionRunning(sessionId)) {
+          const queued = enqueueMessage(sessionId, {
+            text, chatId, openId, msgTimestamp, chatType, traceId: tid,
+          });
+          if (queued) {
+            logTrace(tid, "QUEUED", { sessionId, mode: "plan" });
+            if (platform.kind === "wechat") {
+              await platform.sendText(chatId, "当前会话正在生成中，你的消息已进入缓存队列，生成完成后会立即处理。发送 /cancel 可取消缓存。").catch(() => {});
+            } else {
+              await platform.sendRawCard(chatId, buildQueuedCard(planText)).catch(() => {});
+            }
+          } else {
+            logTrace(tid, "QUEUE_FULL", { sessionId });
+            if (platform.kind === "wechat") {
+              await platform.sendText(chatId, "当前缓存队列中已有消息等待处理，请等待或发送 /stop（停止生成）或 /cancel（取消缓存）。").catch(() => {});
+            } else {
+              await platform.sendRawCard(chatId, buildQueueFullCard()).catch(() => {});
+            }
+          }
+          return;
+        }
+
+        if (shouldSendWechatProcessingAck(platform, planText.toLowerCase(), chatType)) {
+          await platform.sendText(chatId, "生成中...").catch(() => {});
+        }
+
+        try {
+          logTrace(tid, "RESUME", { sessionId, tool: descriptionTool, mode: "plan" });
+          await resumeAndPrompt(
+            sessionId, planText, platform, chatId, msgTimestamp,
+            descriptionTool, tid, "plan",
+          );
+          logTrace(tid, "DONE", { outcome: "plan_done", sessionId });
+        } catch (err) {
+          logTrace(tid, "DONE", { outcome: "plan_fail", error: (err as Error).message });
+          await platform.sendCard(
+            chatId, "Error",
+            `Failed to run plan mode:\n${(err as Error).message}`,
+            "red",
+          );
+        }
+        return;
+      }
+
+      logTrace(tid, "BRANCH", { cmd: "/plan", sessionId, tool: descriptionTool, fallback: "raw_message" });
+    }
+
+    // /ask <message> — 只读/问答模式
+    if (textLower.startsWith("/ask ")) {
+      const askText = text.slice(5).trim();
+      const resolved = resolveModeCommand("/ask");
+      if (!askText) {
+        await platform.sendText(chatId, "用法：`/ask <消息>` — 在只读/问答模式下提问。").catch(() => {});
+        logTrace(tid, "DONE", { outcome: "ask_no_message" });
+        return;
+      }
+      if (resolved?.supportedTools.includes(descriptionTool) === true) {
+        logTrace(tid, "BRANCH", { cmd: "/ask", sessionId, tool: descriptionTool });
+
+        await renameUntitledSession(
+          platform, chatId, chatType, sessionId, descriptionTool,
+          askText, description, chatInfo,
+        );
+
+        if (isSessionRunning(sessionId)) {
+          const queued = enqueueMessage(sessionId, {
+            text, chatId, openId, msgTimestamp, chatType, traceId: tid,
+          });
+          if (queued) {
+            logTrace(tid, "QUEUED", { sessionId, mode: "ask" });
+            if (platform.kind === "wechat") {
+              await platform.sendText(chatId, "当前会话正在生成中，你的消息已进入缓存队列，生成完成后会立即处理。发送 /cancel 可取消缓存。").catch(() => {});
+            } else {
+              await platform.sendRawCard(chatId, buildQueuedCard(askText)).catch(() => {});
+            }
+          } else {
+            logTrace(tid, "QUEUE_FULL", { sessionId });
+            if (platform.kind === "wechat") {
+              await platform.sendText(chatId, "当前缓存队列中已有消息等待处理，请等待或发送 /stop（停止生成）或 /cancel（取消缓存）。").catch(() => {});
+            } else {
+              await platform.sendRawCard(chatId, buildQueueFullCard()).catch(() => {});
+            }
+          }
+          return;
+        }
+
+        if (shouldSendWechatProcessingAck(platform, askText.toLowerCase(), chatType)) {
+          await platform.sendText(chatId, "生成中...").catch(() => {});
+        }
+
+        try {
+          logTrace(tid, "RESUME", { sessionId, tool: descriptionTool, mode: "ask" });
+          await resumeAndPrompt(
+            sessionId, askText, platform, chatId, msgTimestamp,
+            descriptionTool, tid, "ask",
+          );
+          logTrace(tid, "DONE", { outcome: "ask_done", sessionId });
+        } catch (err) {
+          logTrace(tid, "DONE", { outcome: "ask_fail", error: (err as Error).message });
+          await platform.sendCard(
+            chatId, "Error",
+            `Failed to run ask mode:\n${(err as Error).message}`,
+            "red",
+          );
+        }
+        return;
+      }
+
+      logTrace(tid, "BRANCH", { cmd: "/ask", sessionId, tool: descriptionTool, fallback: "raw_message" });
+    }
+
     const lastTs = lastMsgTimestamps.get(chatId);
     if (lastTs !== undefined && msgTimestamp <= lastTs) {
       logTrace(tid, "DONE", {
@@ -1419,8 +1619,7 @@ export async function handleCommand(
         `**Session ID:** ${sessionId}\n` +
         `**工作目录:** \`${cwd}\`\n\n` +
         `下面会自动把你的私聊消息作为第一句话发送给 ${toolLabel}。\n\n` +
-        `发送 **/model** 查看或切换当前会话的模型。\n` +
-        `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。`,
+        buildWelcomeCommands(tool),
       "green",
     );
     platform.setChatAvatar(newChatId, tool, "new").catch(() => {});

package/src/session.ts

@@ -832,8 +832,9 @@ export async function resumeAndPrompt(
   msgTimestamp: number,
   tool: string,
   traceId?: string,
+  permissionMode?: "plan" | "ask",
 ): Promise<void> {
-  return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId);
+  return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId, permissionMode);
 }
 
 // ---------------------------------------------------------------------------
@@ -848,6 +849,7 @@ export async function runAgentSession(
   msgTimestamp: number,
   tool: string,
   traceId?: string,
+  permissionMode?: "plan" | "ask",
 ): Promise<void> {
   const tid = traceId ?? "";
 
@@ -1106,6 +1108,7 @@ export async function runAgentSession(
         clearPromptProcessMonitor(sessionId);
         if (exitInfo.pid !== undefined) unregisterProcess(exitInfo.pid);
       },
+      permissionMode,
     })) {
       for (const block of unifiedMsg.blocks) {
         accumulateBlockContent(block, state, toolCallMap);