chatccc 0.2.123 → 0.2.125

package/README.md

@@ -296,28 +296,20 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 
 ## 可用指令
 
-| 指令 | 作用 | 适用 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 服务进程 | 全部 |
+| 指令 | 作用 |
+| --- | --- |
+| `/new` | 使用默认 Agent 创建新会话 |
+| `/new claude` | 创建 Claude Code 会话 |
+| `/new cursor` | 创建 Cursor 会话 |
+| `/new codex` | 创建 Codex 会话 |
+| `/newh` | 重置当前会话，保留工作目录 |
+| `/model` | 查看或切换当前会话的模型 |
+| `/stop` | 停止当前回复 |
+| `/state` | 查看当前会话状态 |
+| `/cd` | 查看或设置当前会话工作目录 |
+| `/sessions` | 查看所有会话状态 |
+| `/git <子命令>` | 在当前会话工作目录执行 `git ...` 并回传输出 |
+| `/restart` | 重启机器人进程 |
 
 > **模型切换**：`/model` 查看可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。当前仅 Claude Code 支持模型切换（需同时填写 `claude.model` 和 `claude.subagentModel`），Cursor / Codex 切换正在开发中。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.123",
+  "version": "0.2.125",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",

package/src/__tests__/orchestrator.test.ts

@@ -169,48 +169,6 @@ 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) {
@@ -219,7 +177,7 @@ describe("handleCommand WeChat processing ack", () => {
         blocks: [{ type: "text" as const, text: `收到: ${userText}` }],
       };
     });
-    _setAdapterForToolForTest("claude", {
+    _setAdapterForToolForTest("cursor", {
       displayName: "Claude",
       sessionDescPrefix: "Claude Session:",
       createSession: vi.fn(async () => ({ sessionId: "sid-feishu-new" })),

package/src/adapters/adapter-interface.ts

@@ -128,13 +128,6 @@ 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,18 +274,15 @@ 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", permMode,
-    ...(skipPermissions ? ["--dangerously-skip-permissions"] : []),
-    "--settings", "{\"maxTurns\":0,\"autoCompact\":{\"enabled\":true}}",
+    "--permission-mode", "bypassPermissions",
+    "--dangerously-skip-permissions",
+    "--settings", "{\"maxTurns\":0}",
   ];
 
   if (!isEmpty(model)) args.push("--model", model);
@@ -435,7 +432,6 @@ 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,18 +261,8 @@ 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);
@@ -380,7 +370,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, options?.permissionMode);
+    const proc = spawnAgent(["--resume", sessionId], cwd, userText, this.modelOverride);
     this.activeProcs.add(proc);
     if (proc.pid !== undefined) options?.onProcessStart?.({ pid: proc.pid });
 

package/src/cards.ts

@@ -131,8 +131,6 @@ 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,24 +122,6 @@ 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,8 +19,6 @@ import {
   CONFIG_FILE,
   GIT_TIMEOUT_MS,
   PROJECT_ROOT,
-  AGENT_MODE_COMMANDS,
-  AGENT_TOOLS,
   anthropicConfigDisplay,
   config,
   fileLog,
@@ -127,85 +125,6 @@ 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,
@@ -510,7 +429,11 @@ export async function handleCommand(
           `**Session ID:** ${sessionId}\n` +
           `**工作目录:** \`${cwd}\`\n\n` +
           `直接在这里发消息即可与 ${toolLabel} 对话。\n\n` +
-          buildWelcomeCommands(tool),
+          `发送 **/cd** 切换新建会话的默认目录。\n` +
+          `发送 **/model** 查看或切换当前会话的模型。\n` +
+          `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。\n` +
+          `发送 **/sessions** 查看所有会话状态。\n` +
+          `发送 \`/git <子命令>\` 在本会话工作目录执行 git，例如 \`/git status\`、\`/git log --oneline -n 5\`。`,
         "green",
       );
       console.log(
@@ -592,7 +515,11 @@ export async function handleCommand(
         `**Session ID:** ${sessionId}\n` +
         `**工作目录:** \`${cwd}\`\n\n` +
         `直接在这里发消息即可与 ${toolLabel} 对话。\n\n` +
-        buildWelcomeCommands(tool),
+        `发送 **/cd** 切换新建会话的默认目录。\n` +
+        `发送 **/model** 查看或切换当前会话的模型。\n` +
+        `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。\n` +
+        `发送 **/sessions** 查看所有会话状态。\n` +
+        `发送 \`/git <子命令>\` 在本会话工作目录执行 git，例如 \`/git status\`、\`/git log --oneline -n 5\`。`,
       "green",
     );
 
@@ -950,8 +877,9 @@ export async function handleCommand(
         `会话已重置为新的 **${toolLabel}** 会话。\n\n` +
           `**Session ID:** ${newSessionId}\n` +
           `**工作目录:** \`${cwd}\`（沿用当前会话目录）\n\n` +
-          `直接在这里发消息即可继续对话。\n\n` +
-          buildWelcomeCommands(descriptionTool),
+          `直接在这里发消息即可继续对话。\n` +
+          `发送 **/cd** 可切换新建会话的默认目录。\n` +
+          `发送 **/model** 查看或切换当前会话的模型。`,
         "green",
       );
 
@@ -1253,134 +1181,6 @@ 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", {
@@ -1619,7 +1419,8 @@ export async function handleCommand(
         `**Session ID:** ${sessionId}\n` +
         `**工作目录:** \`${cwd}\`\n\n` +
         `下面会自动把你的私聊消息作为第一句话发送给 ${toolLabel}。\n\n` +
-        buildWelcomeCommands(tool),
+        `发送 **/model** 查看或切换当前会话的模型。\n` +
+        `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。`,
       "green",
     );
     platform.setChatAvatar(newChatId, tool, "new").catch(() => {});

package/src/session-chat-binding.ts

@@ -151,8 +151,6 @@ export interface DisplayCardState {
   lastSentFinalReply?: string;
   /** 点点点动画计数器（统一 display loop 每个卡片独立计数） */
   dotCount: number;
-  /** stream-state 连续读取失败次数，超过阈值才删除 display entry */
-  readFailCount?: number;
 }
 
 export const displayCards = new Map<string, DisplayCardState>();

package/src/session.ts

@@ -832,9 +832,8 @@ export async function resumeAndPrompt(
   msgTimestamp: number,
   tool: string,
   traceId?: string,
-  permissionMode?: "plan" | "ask",
 ): Promise<void> {
-  return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId, permissionMode);
+  return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId);
 }
 
 // ---------------------------------------------------------------------------
@@ -849,7 +848,6 @@ export async function runAgentSession(
   msgTimestamp: number,
   tool: string,
   traceId?: string,
-  permissionMode?: "plan" | "ask",
 ): Promise<void> {
   const tid = traceId ?? "";
 
@@ -1108,7 +1106,6 @@ export async function runAgentSession(
         clearPromptProcessMonitor(sessionId);
         if (exitInfo.pid !== undefined) unregisterProcess(exitInfo.pid);
       },
-      permissionMode,
     })) {
       for (const block of unifiedMsg.blocks) {
         accumulateBlockContent(block, state, toolCallMap);
@@ -1282,21 +1279,15 @@ export function startUnifiedDisplayLoop(): void {
         const sessionId = display.sessionId;
         const state = await readStreamState(sessionId);
         if (!state) {
-          display.readFailCount = (display.readFailCount ?? 0) + 1;
-          if (display.readFailCount >= 3) {
-            console.log(`[${ts()}] [DISPLAY] readStreamState ${display.readFailCount} consecutive failures for ${sessionId}, removing display entry for chat ${chatId}`);
-            displayCards.delete(chatId);
-          }
+          displayCards.delete(chatId);
           continue;
         }
-        display.readFailCount = 0;
 
         // 交叉验证：chat 当前绑定的 session 是否仍是 display 记录的 session。
         // 若 chat 已被切换到其他 session（如 /newh），旧 display 必须停推。
         const currentSessionForChat = sessionInfoMap.get(chatId)?.sessionId;
         if (currentSessionForChat && currentSessionForChat !== sessionId) {
           if (state.status !== "running") {
-            console.log(`[${ts()}] [DISPLAY] chat ${chatId} now bound to ${currentSessionForChat}, removing stale display for ${sessionId} (terminal: ${state.status})`);
             displayCards.delete(chatId);
           }
           continue;
@@ -1306,7 +1297,6 @@ export function startUnifiedDisplayLoop(): void {
         const lastActive = getLastActiveChat(sessionId);
         if (lastActive !== chatId) {
           if (state.status !== "running") {
-            console.log(`[${ts()}] [DISPLAY] lastActive mismatch for ${sessionId}: display chat=${chatId} lastActive=${lastActive ?? "undefined"}, removing display entry (terminal: ${state.status})`);
             displayCards.delete(chatId);
           }
           continue;