chatccc 0.2.120 → 0.2.122

package/src/__tests__/orchestrator.test.ts

@@ -154,67 +154,67 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendCard).not.toHaveBeenCalled();
   });
 
-  it("sends the WeChat processing ack after the busy check for normal prompts", async () => {
-    const platform = mockPlatform();
-    await recordSessionRegistry({
-      chatId: "wx-chat",
-      sessionId: "sid-wechat",
+  it("sends the WeChat processing ack after the busy check for normal prompts", async () => {
+    const platform = mockPlatform();
+    await recordSessionRegistry({
+      chatId: "wx-chat",
+      sessionId: "sid-wechat",
       tool: "claude",
       chatName: "ready-session",
       running: false,
     });
 
     await handleCommand(platform, "继续说明", "wx-chat", "wx-user", Date.now(), "p2p");
-
-    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) {
-      yield {
+
+    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) {
+      yield {
         type: "assistant" as const,
         blocks: [{ type: "text" as const, text: `收到: ${userText}` }],
       };

package/src/adapters/resource-monitor.ts

@@ -1,141 +1,141 @@
-// =============================================================================
-// resource-monitor.ts — CLI 进程资源监控（CPU + 内存）
-// =============================================================================
-// 对所有 chatccc 启动的 CLI 进程持续监控 CPU 和内存占用。
-// 若连续 3 分钟两项指标均无变化，判定为僵死，发出 "stuck" 事件。
-// =============================================================================
-
-import { exec } from "node:child_process";
-import { EventEmitter } from "node:events";
-
-const CHECK_INTERVAL_MS = 30_000; // 30 秒检查一次
-const STUCK_THRESHOLD = 6; // 连续 6 次无变化 = 3 分钟
-
-interface ProcessSnapshot {
-  cpu: number;
-  memory: number;
-  unchangedCount: number;
-}
-
-interface TrackedProcess {
-  pid: number;
-  sessionId: string;
-  snapshot: ProcessSnapshot;
-}
-
-export const resourceMonitor = new EventEmitter();
-
-const tracked = new Map<number, TrackedProcess>();
-
-let timer: ReturnType<typeof setInterval> | null = null;
-
-function startIfNeeded(): void {
-  if (timer) return;
-  timer = setInterval(checkAll, CHECK_INTERVAL_MS);
-  timer.unref?.();
-}
-
-function stopIfIdle(): void {
-  if (tracked.size > 0) return;
-  if (timer) { clearInterval(timer); timer = null; }
-}
-
-export function registerProcess(pid: number, sessionId: string): void {
-  tracked.set(pid, { pid, sessionId, snapshot: { cpu: -1, memory: -1, unchangedCount: 0 } });
-  startIfNeeded();
-}
-
-export function unregisterProcess(pid: number): void {
-  tracked.delete(pid);
-  stopIfIdle();
-}
-
-// ---------------------------------------------------------------------------
-// 批量查询进程指标（Windows PowerShell）
-// ---------------------------------------------------------------------------
-
-function execPowerShell(script: string, timeoutMs: number): Promise<string> {
-  return new Promise((resolve, reject) => {
-    exec(
-      `powershell -NoProfile -Command "${script}"`,
-      { timeout: timeoutMs, windowsHide: true },
-      (err, stdout) => {
-        if (err) reject(err);
-        else resolve(stdout);
-      },
-    );
-  });
-}
-
-async function getProcessMetrics(pids: number[]): Promise<Map<number, { cpu: number; memory: number }>> {
-  const result = new Map<number, { cpu: number; memory: number }>();
-  if (pids.length === 0) return result;
-
-  const psScript = `Get-Process -Id ${pids.join(",")} -ErrorAction SilentlyContinue | ForEach-Object { "$($_.Id)|$($_.CPU)|$($_.WorkingSet64)" }`;
-
-  try {
-    const stdout = await execPowerShell(psScript, 10_000);
-    for (const line of stdout.trim().split(/\r?\n/)) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      const [idStr, cpuStr, memStr] = trimmed.split("|");
-      const id = parseInt(idStr, 10);
-      const cpu = parseFloat(cpuStr);
-      const memory = parseInt(memStr, 10);
-      if (!isNaN(id) && !isNaN(cpu) && !isNaN(memory)) {
-        result.set(id, { cpu, memory });
-      }
-    }
-  } catch {
-    // PowerShell 查询失败时跳过本轮，下次重试
-  }
-
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// 定时检查
-// ---------------------------------------------------------------------------
-
-async function checkAll(): Promise<void> {
-  if (tracked.size === 0) return;
-
-  const pids = [...tracked.keys()];
-  const metrics = await getProcessMetrics(pids);
-
-  for (const [pid, tp] of tracked) {
-    const m = metrics.get(pid);
-    if (!m) {
-      // 进程已不存在，停止追踪
-      tracked.delete(pid);
-      continue;
-    }
-
-    const prev = tp.snapshot;
-    const cpuChanged = m.cpu !== prev.cpu;
-    // 内存允许 ±1% 波动，避免正常抖动触发误判
-    const memTolerance = prev.memory > 0 ? Math.max(prev.memory * 0.01, 1024 * 1024) : 1024 * 1024;
-    const memChanged = Math.abs(m.memory - prev.memory) > memTolerance;
-
-    if (!cpuChanged && !memChanged) {
-      tp.snapshot.unchangedCount++;
-      if (tp.snapshot.unchangedCount >= STUCK_THRESHOLD) {
-        const idleMinutes = Math.round(
-          (tp.snapshot.unchangedCount * CHECK_INTERVAL_MS) / 60_000,
-        );
-        resourceMonitor.emit("stuck", {
-          pid: tp.pid,
-          sessionId: tp.sessionId,
-          idleMinutes,
-        });
-        tracked.delete(pid);
-      }
-    } else {
-      tp.snapshot.unchangedCount = 0;
-    }
-    tp.snapshot.cpu = m.cpu;
-    tp.snapshot.memory = m.memory;
-  }
-
-  stopIfIdle();
+// =============================================================================
+// resource-monitor.ts — CLI 进程资源监控（CPU + 内存）
+// =============================================================================
+// 对所有 chatccc 启动的 CLI 进程持续监控 CPU 和内存占用。
+// 若连续 3 分钟两项指标均无变化，判定为僵死，发出 "stuck" 事件。
+// =============================================================================
+
+import { exec } from "node:child_process";
+import { EventEmitter } from "node:events";
+
+const CHECK_INTERVAL_MS = 30_000; // 30 秒检查一次
+const STUCK_THRESHOLD = 6; // 连续 6 次无变化 = 3 分钟
+
+interface ProcessSnapshot {
+  cpu: number;
+  memory: number;
+  unchangedCount: number;
+}
+
+interface TrackedProcess {
+  pid: number;
+  sessionId: string;
+  snapshot: ProcessSnapshot;
+}
+
+export const resourceMonitor = new EventEmitter();
+
+const tracked = new Map<number, TrackedProcess>();
+
+let timer: ReturnType<typeof setInterval> | null = null;
+
+function startIfNeeded(): void {
+  if (timer) return;
+  timer = setInterval(checkAll, CHECK_INTERVAL_MS);
+  timer.unref?.();
+}
+
+function stopIfIdle(): void {
+  if (tracked.size > 0) return;
+  if (timer) { clearInterval(timer); timer = null; }
+}
+
+export function registerProcess(pid: number, sessionId: string): void {
+  tracked.set(pid, { pid, sessionId, snapshot: { cpu: -1, memory: -1, unchangedCount: 0 } });
+  startIfNeeded();
+}
+
+export function unregisterProcess(pid: number): void {
+  tracked.delete(pid);
+  stopIfIdle();
+}
+
+// ---------------------------------------------------------------------------
+// 批量查询进程指标（Windows PowerShell）
+// ---------------------------------------------------------------------------
+
+function execPowerShell(script: string, timeoutMs: number): Promise<string> {
+  return new Promise((resolve, reject) => {
+    exec(
+      `powershell -NoProfile -Command "${script}"`,
+      { timeout: timeoutMs, windowsHide: true },
+      (err, stdout) => {
+        if (err) reject(err);
+        else resolve(stdout);
+      },
+    );
+  });
+}
+
+async function getProcessMetrics(pids: number[]): Promise<Map<number, { cpu: number; memory: number }>> {
+  const result = new Map<number, { cpu: number; memory: number }>();
+  if (pids.length === 0) return result;
+
+  const psScript = `Get-Process -Id ${pids.join(",")} -ErrorAction SilentlyContinue | ForEach-Object { "$($_.Id)|$($_.CPU)|$($_.WorkingSet64)" }`;
+
+  try {
+    const stdout = await execPowerShell(psScript, 10_000);
+    for (const line of stdout.trim().split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const [idStr, cpuStr, memStr] = trimmed.split("|");
+      const id = parseInt(idStr, 10);
+      const cpu = parseFloat(cpuStr);
+      const memory = parseInt(memStr, 10);
+      if (!isNaN(id) && !isNaN(cpu) && !isNaN(memory)) {
+        result.set(id, { cpu, memory });
+      }
+    }
+  } catch {
+    // PowerShell 查询失败时跳过本轮，下次重试
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// 定时检查
+// ---------------------------------------------------------------------------
+
+async function checkAll(): Promise<void> {
+  if (tracked.size === 0) return;
+
+  const pids = [...tracked.keys()];
+  const metrics = await getProcessMetrics(pids);
+
+  for (const [pid, tp] of tracked) {
+    const m = metrics.get(pid);
+    if (!m) {
+      // 进程已不存在，停止追踪
+      tracked.delete(pid);
+      continue;
+    }
+
+    const prev = tp.snapshot;
+    const cpuChanged = m.cpu !== prev.cpu;
+    // 内存允许 ±1% 波动，避免正常抖动触发误判
+    const memTolerance = prev.memory > 0 ? Math.max(prev.memory * 0.01, 1024 * 1024) : 1024 * 1024;
+    const memChanged = Math.abs(m.memory - prev.memory) > memTolerance;
+
+    if (!cpuChanged && !memChanged) {
+      tp.snapshot.unchangedCount++;
+      if (tp.snapshot.unchangedCount >= STUCK_THRESHOLD) {
+        const idleMinutes = Math.round(
+          (tp.snapshot.unchangedCount * CHECK_INTERVAL_MS) / 60_000,
+        );
+        resourceMonitor.emit("stuck", {
+          pid: tp.pid,
+          sessionId: tp.sessionId,
+          idleMinutes,
+        });
+        tracked.delete(pid);
+      }
+    } else {
+      tp.snapshot.unchangedCount = 0;
+    }
+    tp.snapshot.cpu = m.cpu;
+    tp.snapshot.memory = m.memory;
+  }
+
+  stopIfIdle();
 }

package/src/orchestrator.ts

@@ -1254,132 +1254,132 @@ export async function handleCommand(
     }
 
     // /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" });
-    }
+    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" });
-    }
+    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) {