chatccc 0.2.179 → 0.2.180

package/README.md

@@ -144,7 +144,12 @@ npm install -g chatccc
 chatccc
 ```
 
-要求 Node.js >= 20。安装完成后，在任意目录执行 `chatccc` 即可启动。配置、日志和状态文件会保存在包目录下的 `config.json`、`logs/`、`state/`。
+要求 Node.js >= 20。安装完成后，在任意目录执行 `chatccc` 即可启动。配置、日志和状态文件会保存在用户目录的 `.chatccc` 下：
+
+- Windows：`C:\Users\<用户名>\.chatccc\`
+- macOS / Linux：`~/.chatccc/`
+
+旧版本留在仓库或包目录下的 `config.json`、`logs/`、`state/` 会在首次启动时自动迁移到用户目录。
 
 首次启动时，如果还没有有效配置，ChatCCC 会自动打开本地 Web 配置向导（默认 `http://127.0.0.1:18080`）。
 
@@ -197,7 +202,7 @@ chatccc
 # 在微信里找到机器人，发送 /new 开始对话
 ```
 
-微信登录信息会保存到 `state/ilink-auth.json`。token 过期后重新扫码即可。
+微信登录信息会保存到 `~/.chatccc/state/ilink-auth.json`。token 过期后重新扫码即可。
 
 ### 3. AI 工具配置
 
@@ -234,7 +239,7 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 
 ### 4. `config.json`
 
-`config.json` 不存在时，ChatCCC 会从 `config.sample.json` 复制一份。常用结构如下：
+`~/.chatccc/config.json` 不存在时，ChatCCC 会从 `config.sample.json` 复制一份。常用结构如下：
 
 ```json
 {
@@ -242,28 +247,32 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
     "appId": "cli_xxxxxxxxxxxx",
     "appSecret": "xxxxxxxxxxxxxxxxxxxxxxxxxx"
   },
-  "platforms": {
-    "feishu": { "enabled": true },
-    "ilink": { "enabled": true }
-  },
-  "port": 18080,
-  "gitTimeoutSeconds": 180,
-  "claude": {
-    "enabled": false,
-    "defaultAgent": true,
-    "model": "claude-sonnet-4-6",
-    "subagentModel": "",
-    "effort": "",
-    "apiKey": "",
-    "baseUrl": ""
-  },
-  "cursor": {
-    "enabled": false,
-    "defaultAgent": false,
-    "path": "",
-    "model": ""
-  },
-  "codex": {
+  "platforms": {
+    "feishu": { "enabled": true, "platformType": "feishu" },
+    "ilink": { "enabled": true, "reuseTokenOnStart": true }
+  },
+  "port": 18080,
+  "gitTimeoutSeconds": 180,
+  "allowInterrupt": false,
+  "claude": {
+    "enabled": false,
+    "defaultAgent": true,
+    "model": "claude-sonnet-4-6",
+    "subagentModel": "",
+    "effort": "",
+    "apiKey": "",
+    "baseUrl": "",
+    "maxTurn": 0
+  },
+  "cursor": {
+    "enabled": false,
+    "defaultAgent": false,
+    "path": "",
+    "model": "",
+    "avatarBatteryMode": "apiPercent",
+    "onDemandMonthlyBudget": 1000
+  },
+  "codex": {
     "enabled": false,
     "defaultAgent": false,
     "path": "",
@@ -276,16 +285,21 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | 字段 | 说明 |
 | --- | --- |
 | `feishu.appId` / `feishu.appSecret` | 飞书应用凭证 |
-| `platforms.feishu.enabled` | 是否启用飞书 |
-| `platforms.ilink.enabled` | 是否启用微信 iLink |
-| `port` | 本地 Web 配置面板和中继服务端口 |
-| `gitTimeoutSeconds` | `/git` 命令超时时间，默认 180 秒 |
-| `*.enabled` | 是否启用对应 AI Agent |
-| `*.defaultAgent` | `/new` 未指定 Agent 时使用哪个工具 |
-| `cursor.path` / `codex.path` | CLI 可执行文件路径；留空时自动探测或使用 PATH |
-| `claude.model` / `claude.subagentModel` / `claude.effort` | 选填；设置后传给 Claude Agent SDK，留空以 `~/.claude/settings.json` 为准 |
-| `claude.apiKey` / `claude.baseUrl` | 选填；设置后传给 Claude Agent SDK，留空以 `~/.claude/settings.json` 为准 |
-| `claude.maxTurn` | 选填；Claude 最大对话轮数，默认 0（无限制），可在 Web UI 编辑 |
+| `platforms.feishu.enabled` | 是否启用飞书 |
+| `platforms.feishu.platformType` | 飞书平台类型，默认 `feishu` |
+| `platforms.ilink.enabled` | 是否启用微信 iLink |
+| `platforms.ilink.reuseTokenOnStart` | 启动时是否复用已有微信登录 token |
+| `port` | 本地 Web 配置面板和中继服务端口 |
+| `gitTimeoutSeconds` | `/git` 命令超时时间，默认 180 秒 |
+| `allowInterrupt` | 是否允许新消息中断正在运行的任务；默认 false |
+| `*.enabled` | 是否启用对应 AI Agent |
+| `*.defaultAgent` | `/new` 未指定 Agent 时使用哪个工具 |
+| `cursor.path` / `codex.path` | CLI 可执行文件路径；留空时自动探测或使用 PATH |
+| `cursor.avatarBatteryMode` | Cursor 头像电量显示来源：`apiPercent` 或 `onDemandUse` |
+| `cursor.onDemandMonthlyBudget` | `avatarBatteryMode=onDemandUse` 时用于计算电量的月预算 |
+| `claude.model` / `claude.subagentModel` / `claude.effort` | 选填；设置后传给 Claude Agent SDK，留空以 `~/.claude/settings.json` 为准 |
+| `claude.apiKey` / `claude.baseUrl` | 选填；设置后传给 Claude Agent SDK，留空以 `~/.claude/settings.json` 为准 |
+| `claude.maxTurn` | 选填；Claude 最大对话轮数，默认 0（无限制），可在 Web UI 编辑 |
 
 > **权限控制**：普通消息以 `bypassPermissions` 模式运行，跳过 Agent 操作确认。使用 `/plan` 或 `/ask` 前缀时，ChatCCC 自动切换为只读模式：Claude SDK 仅放行 Read + stop-stuck-loop 网络请求，Codex 使用 `--sandbox read-only`，Cursor 使用 `--mode plan/ask`。请只在可信环境中使用。
 
@@ -301,22 +315,26 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | --- | --- |
 | `/new` | 使用默认 Agent 创建新会话 |
 | `/new claude` | 创建 Claude Code 会话 |
-| `/new cursor` | 创建 Cursor 会话 |
-| `/new codex` | 创建 Codex 会话 |
-| `/newh` | 重置当前会话，保留工作目录 |
-| `/model` | 查看或切换当前会话的模型 |
-| `/stop` | 停止当前回复 |
-| `/state` | 查看当前会话状态 |
-| `/cd` | 查看或设置当前会话工作目录 |
-| `/sessions` | 查看所有会话状态 |
-| `/usage` | 查看 Codex 5h 用量和周用量 |
-| `/git <子命令>` | 在当前会话工作目录执行 `git ...` 并回传输出 |
-| `/plan <内容>` | 只读计划模式：仅允许读文件和 stop-stuck-loop 请求，不执行任何写操作 |
-| `/ask <内容>` | 只读问答模式：与 /plan 相同，仅允许读文件和 stop-stuck-loop 请求 |
-| `/restart` | 重启机器人进程 |
-| `/update` | 更新 npm 全局包并重启（仅限 `npm install -g chatccc` 安装的全局进程） |
-
-> **模型切换**：`/model` 查看可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。当前仅 Claude Code 支持模型切换（需同时填写 `claude.model` 和 `claude.subagentModel`），Cursor / Codex 切换正在开发中。
+| `/new cursor` | 创建 Cursor 会话 |
+| `/new codex` | 创建 Codex 会话 |
+| `/newh` | 重置当前会话，保留工作目录 |
+| `/model` | 查看或切换当前会话的模型 |
+| `/stop` | 停止当前回复 |
+| `/cancel` | 取消当前会话里排队等待处理的消息 |
+| `/state` | 查看当前会话状态 |
+| `/cd` | 查看或设置当前会话工作目录 |
+| `/sessions` | 查看所有会话状态 |
+| `/session <数字>` | 将当前群聊切换到 `/sessions` 列表中的指定会话 |
+| `/usage` | 查看当前会话对应 Agent 的用量；Codex 显示 5h/周用量，Cursor 显示当前周期用量 |
+| `/git <子命令>` | 在当前会话工作目录执行 `git ...` 并回传输出 |
+| `/abd<内容>` | 去掉 `/abd` 前缀后把内容发给 Agent，并在消息末尾追加第一性原理需求澄清提示 |
+| `/plan <内容>` | 只读计划模式：仅允许读文件和 stop-stuck-loop 请求，不执行任何写操作 |
+| `/ask <内容>` | 只读问答模式：与 /plan 相同，仅允许读文件和 stop-stuck-loop 请求 |
+| `/restart` | 重启机器人进程 |
+| `/update` | 更新 npm 全局包并重启（仅限 `npm install -g chatccc` 安装的全局进程） |
+| `/deleteg` | 解散当前飞书会话群；Agent 会话记录保留 |
+
+> **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`，Cursor 使用 `cursor.model`，Codex 使用 `codex.model`。
 
 ---
 

package/package.json

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

package/src/__tests__/card-plain-text.test.ts

@@ -16,10 +16,11 @@ describe("cardJsonToPlainText", () => {
     expect(text).toContain("/new");
     expect(text).toContain("/new cursor");
     expect(text).toContain("/new codex");
-    expect(text).toContain("/restart");
-    expect(text).toContain("/update");
-    expect(text).toContain("/cd");
-  });
+    expect(text).toContain("/restart");
+    expect(text).toContain("/update");
+    expect(text).toContain("/cd");
+    expect(text).toContain("/abd");
+  });
 
   it("converts status cards from v1 card format", () => {
     const text = cardJsonToPlainText(buildStatusCard("status body", "green"));

package/src/__tests__/cards.test.ts

@@ -1,15 +1,16 @@
 import { describe, it, expect } from "vitest";
-import {
-  buildProgressCard,
-  buildHelpCard,
+import {
+  buildProgressCard,
+  buildHelpCard,
   buildCdContent,
   buildCdCard,
   buildSessionsCard,
   buildStatusCard,
   buildButtons,
   truncateContent,
-  getToolEmoji,
-} from "../cards.ts";
+  getToolEmoji,
+} from "../cards.ts";
+import { ABD_HELP_LINE } from "../shared-prefix.ts";
 
 // ---------------------------------------------------------------------------
 // truncateContent
@@ -151,14 +152,22 @@ describe("buildHelpCard", () => {
     expect(parsed.elements[0].text.content).toContain("你好");
   });
 
-  it("includes action buttons", () => {
-    const card = buildHelpCard("test");
-    const parsed = JSON.parse(card);
-    const action = parsed.elements[2];
-    expect(action.tag).toBe("action");
-    expect(action.actions).toHaveLength(7);
-  });
-});
+  it("includes action buttons", () => {
+    const card = buildHelpCard("test");
+    const parsed = JSON.parse(card);
+    const action = parsed.elements[2];
+    expect(action.tag).toBe("action");
+    expect(action.actions).toHaveLength(7);
+  });
+
+  it("adds ABD prefix help as the final help line", () => {
+    const card = buildHelpCard("test");
+    const parsed = JSON.parse(card);
+    const lines = parsed.elements[1].text.content.split("\n");
+
+    expect(lines.at(-1)).toBe(ABD_HELP_LINE);
+  });
+});
 
 // ---------------------------------------------------------------------------
 // buildCdContent

package/src/__tests__/orchestrator.test.ts

@@ -65,8 +65,8 @@ vi.mock("../cursor-usage.ts", () => ({
 }));
 
 import { handleCommand } from "../orchestrator.ts";
-import {
-  _clearAdapterCacheForTest,
+import {
+  _clearAdapterCacheForTest,
   _resetSessionRegistryFileForTest,
   _resetSessionToolsFileForTest,
   _setAdapterForToolForTest,
@@ -74,9 +74,10 @@ import {
   _setSessionToolsFileForTest,
   loadSessionRegistryForBinding,
   recordSessionRegistry,
-  resetState,
-} from "../session.ts";
-import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
+  resetState,
+} from "../session.ts";
+import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
+import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
 
 function mockPlatform(kind: "wechat" | "feishu" = "wechat"): PlatformAdapter {
   return {
@@ -197,8 +198,8 @@ 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();
+  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",
@@ -208,9 +209,44 @@ describe("handleCommand WeChat processing ack", () => {
     });
 
     await handleCommand(platform, "继续说明", "wx-chat", "wx-user", Date.now(), "p2p");
-
-    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
-  });
+
+    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
+  });
+
+  it("treats /abd as a shared prompt prefix in an existing session", async () => {
+    const platform = mockPlatform();
+    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
+      yield {
+        type: "assistant" as const,
+        blocks: [{ type: "text" as const, text: "done" }],
+      };
+    });
+    _setAdapterForToolForTest("claude", {
+      displayName: "Claude",
+      sessionDescPrefix: "Claude Session:",
+      createSession: vi.fn(async () => ({ sessionId: "sid-wechat" })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
+      closeSession: async () => {},
+    });
+    await recordSessionRegistry({
+      chatId: "wx-chat",
+      sessionId: "sid-wechat",
+      tool: "claude",
+      chatName: "ready-session",
+      running: false,
+    });
+
+    await handleCommand(platform, "/abd帮我分析", "wx-chat", "wx-user", Date.now(), "p2p");
+
+    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
+    const userText = prompt.mock.calls[0][1];
+    expect(userText).toContain(`[User message]\n帮我分析\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
+    expect(userText).not.toContain("/abd");
+  });
 
   it("does not send the stopped success text until the running prompt really exits", async () => {
     const platform = mockPlatform();
@@ -232,7 +268,7 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendText).not.toHaveBeenCalledWith("wx-chat", "会话已停止。");
   });
 
-  it("cleans stale Feishu p2p binding, creates a group, and sends the private message as first prompt", async () => {
+  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 {
@@ -277,8 +313,40 @@ describe("handleCommand WeChat processing ack", () => {
 
     const registry = await loadSessionRegistryForBinding();
     expect(registry["feishu-p2p"]).toBeUndefined();
-    expect(registry["feishu-group"]?.sessionId).toBe("sid-feishu-new");
-  });
+    expect(registry["feishu-group"]?.sessionId).toBe("sid-feishu-new");
+  });
+
+  it("auto-creates a Feishu group for /abd private messages and sends the transformed 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: "done" }],
+      };
+    });
+    _setAdapterForToolForTest("claude", {
+      displayName: "Claude",
+      sessionDescPrefix: "Claude Session:",
+      createSession: vi.fn(async () => ({ sessionId: "sid-feishu-abd" })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
+      closeSession: async () => {},
+    });
+
+    await handleCommand(platform, "/abd帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).toHaveBeenCalledWith(expect.stringContaining("帮我看一下日志"), ["ou-user"]);
+    expect(platform.createGroup).not.toHaveBeenCalledWith(expect.stringContaining("---"), expect.anything());
+    const updateCall = vi.mocked(platform.updateChatInfo).mock.calls[0];
+    expect(updateCall[1]).not.toContain("---");
+    expect(updateCall[1]).not.toContain(ABD_APPEND_PROMPT);
+    const userText = prompt.mock.calls[0][1];
+    expect(userText).toContain(`[User message]\n帮我看一下日志\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
+    expect(userText).not.toContain("/abd");
+  });
 
   it("cleans stale Feishu p2p binding but keeps valid commands from auto-creating a group", async () => {
     const platform = mockPlatform("feishu");

package/src/__tests__/shared-prefix.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  ABD_APPEND_PROMPT,
+  applySharedPrefix,
+} from "../shared-prefix.ts";
+
+describe("applySharedPrefix", () => {
+  it("leaves normal messages unchanged", () => {
+    expect(applySharedPrefix("帮我分析")).toEqual({
+      matched: false,
+      text: "帮我分析",
+      body: "帮我分析",
+    });
+  });
+
+  it("removes /abd without requiring a space", () => {
+    const result = applySharedPrefix("/abd帮我分析");
+
+    expect(result.matched).toBe(true);
+    expect(result.body).toBe("帮我分析");
+    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
+  });
+
+  it("removes whitespace after /abd", () => {
+    const result = applySharedPrefix("/abd   帮我分析");
+
+    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
+  });
+
+  it("keeps the appendix when the user body is empty", () => {
+    const result = applySharedPrefix("/abd   ");
+
+    expect(result.text).toBe(`---\n${ABD_APPEND_PROMPT}`);
+  });
+});

package/src/cards.ts

@@ -1,8 +1,10 @@
-// ---------------------------------------------------------------------------
-// Button helpers
-// ---------------------------------------------------------------------------
-
-export interface ButtonDef {
+// ---------------------------------------------------------------------------
+// Button helpers
+// ---------------------------------------------------------------------------
+
+import { ABD_HELP_LINE } from "./shared-prefix.ts";
+
+export interface ButtonDef {
   text: string;
   value: string;
   type?: "primary" | "default" | "danger";
@@ -135,10 +137,11 @@ export function buildHelpCard(
     "发送 **/newh** 重置当前会话（沿用当前工作目录，不切换）",
     "发送 **/plan** 以规划模式提问（只读，不执行写操作）",
     "发送 **/ask** 以问答模式提问（只读，不执行写操作）",
-    "发送 **/usage** 查看 Codex 5h 和周用量",
-    "发送 **/restart** 重启 ChatCCC 进程",
-    "发送 **/update** 更新并重启（仅 npm 全局安装可用）",
-  ].join("\n");
+    "发送 **/usage** 查看 Codex 5h 和周用量",
+    "发送 **/restart** 重启 ChatCCC 进程",
+    "发送 **/update** 更新并重启（仅 npm 全局安装可用）",
+    ABD_HELP_LINE,
+  ].join("\n");
   return JSON.stringify({
     config: { wide_screen_mode: true },
     header: { template: "blue", title: { content: "ChatCCC", tag: "plain_text" } },

package/src/orchestrator.ts

@@ -78,9 +78,10 @@ import {
   enqueueMessage,
   cancelQueuedMessage,
 } from "./session-chat-binding.ts";
-import { getCodexUsageSummary, getTenantAccessToken, sendPostMessage } from "./feishu-platform.ts";
-import { getCursorUsageSummary, type CursorUsageSummary } from "./cursor-usage.ts";
-export { type PlatformAdapter } from "./platform-adapter.ts";
+import { getCodexUsageSummary, getTenantAccessToken, sendPostMessage } from "./feishu-platform.ts";
+import { getCursorUsageSummary, type CursorUsageSummary } from "./cursor-usage.ts";
+import { applySharedPrefix } from "./shared-prefix.ts";
+export { type PlatformAdapter } from "./platform-adapter.ts";
 import type { PlatformAdapter } from "./platform-adapter.ts";
 import type { CodexUsageSummary } from "./feishu-api.ts";
 
@@ -271,14 +272,13 @@ function isUntitledSessionChatName(name: string): boolean {
   return name === "新会话" || name.startsWith("新会话-");
 }
 
-function shouldSendWechatProcessingAck(
-  platform: PlatformAdapter,
-  textLower: string,
-  chatType: string,
-  text: string,
-): boolean {
-  return platform.kind === "wechat" && chatType === "p2p" && !textLower.startsWith("/");
-}
+function shouldSendWechatProcessingAck(
+  platform: PlatformAdapter,
+  isCommandText: boolean,
+  chatType: string,
+): boolean {
+  return platform.kind === "wechat" && chatType === "p2p" && !isCommandText;
+}
 
 function isNonWechatP2p(platform: PlatformAdapter, chatType: string): boolean {
   return chatType === "p2p" && platform.kind !== "wechat";
@@ -408,13 +408,17 @@ export async function handleCommand(
   msgTimestamp: number,
   chatType = "group",
   traceId?: string,
-): Promise<void> {
-  const tid = traceId ?? makeTraceId();
-  const textLower = text.toLowerCase();
-  recordChatPlatform(chatId, platform);
+): Promise<void> {
+  const tid = traceId ?? makeTraceId();
+  const sharedPrefix = applySharedPrefix(text);
+  const promptText = sharedPrefix.text;
+  text = sharedPrefix.body;
+  const textLower = text.toLowerCase();
+  const isCommandText = !sharedPrefix.matched && textLower.startsWith("/");
+  recordChatPlatform(chatId, platform);
   await cleanupNonWechatP2pBinding(platform, chatId, chatType, tid);
 
-  if (textLower === "/restart") {
+  if (isCommandText && textLower === "/restart") {
     logTrace(tid, "BRANCH", { cmd: "/restart" });
     await platform.sendText(chatId, "重启中...请几秒后发消息唤醒我").catch(() => {});
     logTrace(tid, "DONE", { outcome: "restart" });
@@ -449,7 +453,7 @@ export async function handleCommand(
     return;
   }
 
-  if (textLower === "/update") {
+  if (isCommandText && textLower === "/update") {
     logTrace(tid, "BRANCH", { cmd: "/update" });
     const isGlobal = isRunningFromGlobalNpm();
     appendStartupTrace("update: command received", { isGlobal, chatId });
@@ -466,7 +470,7 @@ export async function handleCommand(
     return;
   }
 
-  if (textLower === "/usage") {
+  if (isCommandText && textLower === "/usage") {
     const usageTool = await resolveUsageTool(chatId);
     logTrace(tid, "BRANCH", { cmd: "/usage", tool: usageTool });
     try {
@@ -479,7 +483,7 @@ export async function handleCommand(
     return;
   }
 
-  if (textLower === "/cd" || textLower.startsWith("/cd ")) {
+  if (isCommandText && (textLower === "/cd" || textLower.startsWith("/cd "))) {
     logTrace(tid, "BRANCH", {
       cmd: "/cd",
       arg: text.slice(3).trim() || "(none)",
@@ -602,7 +606,7 @@ export async function handleCommand(
     return;
   }
 
-  if (textLower === "/new" || textLower.startsWith("/new ")) {
+  if (isCommandText && (textLower === "/new" || textLower.startsWith("/new "))) {
     const toolArg = text.slice(5).trim().toLowerCase();
     const tool = toolArg || resolveDefaultAgentTool();
     logTrace(tid, "BRANCH", { cmd: "/new", tool });
@@ -863,7 +867,7 @@ export async function handleCommand(
   if (sessionId && descriptionTool && toolLabel) {
     // 有会话上下文 — 路由到命令处理或 prompt
     logTrace(tid, "BRANCH", { sessionId, tool: descriptionTool });
-    const routeKind = textLower.startsWith("/") ? "command" : "prompt";
+    const routeKind = isCommandText ? "command" : "prompt";
     const chatKind = chatType === "p2p" ? "p2p chat" : "session group";
     console.log(
       `[${ts()}] [ROUTE] ${toolLabel} ${chatKind} ${routeKind} detected, session=${sessionId} tool=${descriptionTool}`,
@@ -872,7 +876,7 @@ export async function handleCommand(
     if (
       chatType !== "p2p" &&
       isUntitledSessionChatName(chatInfo!.name) &&
-      !textLower.startsWith("/")
+      !isCommandText
     ) {
       const MAX_PREFIX = 10;
       const prefix = text.slice(0, MAX_PREFIX);
@@ -907,7 +911,7 @@ export async function handleCommand(
     if (
       chatType === "p2p" &&
       platform.kind === "wechat" &&
-      !textLower.startsWith("/")
+      !isCommandText
     ) {
       try {
         const reg = await loadSessionRegistryForBinding();
@@ -946,7 +950,7 @@ export async function handleCommand(
       }
     }
 
-    if (textLower === "/stop") {
+    if (isCommandText && textLower === "/stop") {
       logTrace(tid, "BRANCH", { cmd: "/stop" });
       if (stopSession(sessionId)) {
         console.log(`[${ts()}] [STOP] User sent /stop, session=${sessionId}`);
@@ -960,7 +964,7 @@ export async function handleCommand(
       return;
     }
 
-    if (textLower === "/cancel") {
+    if (isCommandText && textLower === "/cancel") {
       logTrace(tid, "BRANCH", { cmd: "/cancel" });
       if (cancelQueuedMessage(sessionId)) {
         console.log(`[${ts()}] [CANCEL] Queue cancelled for session=${sessionId}`);
@@ -973,7 +977,7 @@ export async function handleCommand(
       return;
     }
 
-    if (textLower === "/test") {
+    if (isCommandText && textLower === "/test") {
       logTrace(tid, "BRANCH", { cmd: "/test" });
       const tableHeaders = ["名称", "版本", "状态"];
       const tableRows = [
@@ -1010,7 +1014,7 @@ export async function handleCommand(
       return;
     }
 
-    if (textLower === "/state") {
+    if (isCommandText && textLower === "/state") {
       logTrace(tid, "BRANCH", { cmd: "/state" });
       const status = await getSessionStatus(chatId);
       const isActive = isSessionRunning(sessionId);
@@ -1049,7 +1053,7 @@ export async function handleCommand(
       return;
     }
 
-    if (textLower === "/sessions") {
+    if (isCommandText && textLower === "/sessions") {
       logTrace(tid, "BRANCH", { cmd: "/sessions" });
       const allSessions = await getAllSessionsStatus();
       const now = Date.now();
@@ -1074,7 +1078,7 @@ export async function handleCommand(
       return;
     }
 
-    if (textLower === "/newh") {
+    if (isCommandText && textLower === "/newh") {
       logTrace(tid, "BRANCH", { cmd: "/newh" });
       const adapter = getAdapterForTool(descriptionTool, sessionId);
       let cwd: string;
@@ -1161,7 +1165,7 @@ export async function handleCommand(
       return;
     }
 
-    if (textLower === "/deleteg") {
+    if (isCommandText && textLower === "/deleteg") {
       logTrace(tid, "BRANCH", { cmd: "/deleteg" });
       if (chatType === "p2p") {
         await platform
@@ -1199,7 +1203,7 @@ export async function handleCommand(
     }
 
     // /session <number>：切换到 /sessions 列表中的指定会话
-    const sessionMatch = textLower.match(/^\/session\s+(\d+)$/);
+    const sessionMatch = isCommandText ? textLower.match(/^\/session\s+(\d+)$/) : null;
     if (sessionMatch) {
       const index = parseInt(sessionMatch[1], 10) - 1;
       logTrace(tid, "BRANCH", { cmd: "/session", index: index + 1 });
@@ -1325,7 +1329,7 @@ export async function handleCommand(
     }
 
     // /model clear — 清除当前 session 的模型覆盖
-    if (textLower === "/model clear") {
+    if (isCommandText && textLower === "/model clear") {
       logTrace(tid, "BRANCH", { cmd: "/model clear", sessionId });
       clearSessionModelOverride(sessionId);
       const defaultModel = getEffectiveModelForTool(descriptionTool);
@@ -1340,7 +1344,7 @@ export async function handleCommand(
     }
 
     // /model <name> — 切换当前 session 的模型（支持所有 agent，模糊匹配）
-    if (textLower.startsWith("/model ")) {
+    if (isCommandText && textLower.startsWith("/model ")) {
       const modelArg = text.slice(7).trim();
       if (!modelArg) return; // 纯 "/model " 不处理，交给上面的 /model 分支
       logTrace(tid, "BRANCH", { cmd: "/model", arg: modelArg, sessionId, tool: descriptionTool });
@@ -1374,7 +1378,7 @@ export async function handleCommand(
     }
 
     // /model — 查看当前会话的可用模型（根据会话 Agent 类型）
-    if (textLower === "/model") {
+    if (isCommandText && textLower === "/model") {
       logTrace(tid, "BRANCH", { cmd: "/model", sessionId, tool: descriptionTool });
       const models = getAllModelsForTool(descriptionTool as AgentTool);
       const currentModel = getEffectiveModelForTool(descriptionTool, sessionId);
@@ -1398,7 +1402,7 @@ export async function handleCommand(
     }
 
     // /git <args>：在「当前会话工作目录」执行 git 命令
-    if (textLower.startsWith("/git ") || textLower === "/git") {
+    if (isCommandText && (textLower.startsWith("/git ") || textLower === "/git")) {
       const args = text === "/git" ? "" : text.slice(5).trim();
       logTrace(tid, "BRANCH", { cmd: "/git", args: args || "(none)" });
       if (!args) {
@@ -1467,9 +1471,9 @@ export async function handleCommand(
 
     // 并发检查：同一 session 只能有一个活跃 prompt，多余消息进入队列
     if (isSessionRunning(sessionId)) {
-      const queued = enqueueMessage(sessionId, {
-        text, chatId, openId, msgTimestamp, chatType, traceId: tid,
-      });
+      const queued = enqueueMessage(sessionId, {
+        text: promptText, chatId, openId, msgTimestamp, chatType, traceId: tid,
+      });
       if (queued) {
         logTrace(tid, "QUEUED", { sessionId });
         console.log(
@@ -1494,16 +1498,16 @@ export async function handleCommand(
       return;
     }
 
-    if (shouldSendWechatProcessingAck(platform, textLower, chatType, text)) {
+    if (shouldSendWechatProcessingAck(platform, isCommandText, chatType)) {
       await platform.sendText(chatId, "生成中...").catch(() => {});
     }
 
     try {
       logTrace(tid, "RESUME", { sessionId, tool: descriptionTool });
       await resumeAndPrompt(
-        sessionId,
-        text,
-        platform,
+        sessionId,
+        promptText,
+        platform,
         chatId,
         msgTimestamp,
         descriptionTool,
@@ -1529,7 +1533,7 @@ export async function handleCommand(
   }
 
   // 无会话上下文 → 检查是否是 /model 查询
-  if (textLower === "/model") {
+  if (isCommandText && textLower === "/model") {
     const defaultTool = resolveDefaultAgentTool();
     const models = getAllModelsForTool(defaultTool);
     let currentModel = "";
@@ -1556,7 +1560,7 @@ export async function handleCommand(
   }
 
   // 无会话上下文 → /sessions 仍是有效指令，不触发飞书私聊自动建群。
-  if (textLower === "/sessions") {
+  if (isCommandText && textLower === "/sessions") {
     logTrace(tid, "BRANCH", { cmd: "/sessions", scope: "global" });
     const allSessions = await getAllSessionsStatus();
     const now = Date.now();
@@ -1582,7 +1586,7 @@ export async function handleCommand(
   }
 
   // 飞书私聊普通消息：不再绑定私聊本身，而是自动创建会话群并把私聊内容作为首轮 prompt。
-  if (isNonWechatP2p(platform, chatType) && !textLower.startsWith("/")) {
+  if (isNonWechatP2p(platform, chatType) && !isCommandText) {
     const tool = resolveDefaultAgentTool();
     const toolLabel = toolDisplayName(tool);
     logTrace(tid, "BRANCH", { cmd: "auto_new_from_p2p", tool });
@@ -1700,9 +1704,9 @@ export async function handleCommand(
     try {
       logTrace(tid, "RESUME", { sessionId, tool, trigger: "auto_new_from_p2p" });
       await resumeAndPrompt(
-        sessionId,
-        text,
-        platform,
+        sessionId,
+        promptText,
+        platform,
         newChatId,
         msgTimestamp,
         tool,

package/src/shared-prefix.ts

@@ -0,0 +1,29 @@
+export const ABD_PREFIX = "/abd";
+
+export const ABD_APPEND_PROMPT =
+  "请从第一性原理出发挖掘我的真实需求。你觉得我的需求合理吗？开始实现之前有什么问题要问我的？";
+
+export const ABD_HELP_LINE =
+  `发送 **${ABD_PREFIX}** 前缀消息，将以第一性原理追问真实需求、合理性和实现前问题`;
+
+export interface SharedPrefixResult {
+  matched: boolean;
+  text: string;
+  body: string;
+  prefix?: typeof ABD_PREFIX;
+}
+
+export function applySharedPrefix(text: string): SharedPrefixResult {
+  if (!text.toLowerCase().startsWith(ABD_PREFIX)) {
+    return { matched: false, text, body: text };
+  }
+
+  const body = text.slice(ABD_PREFIX.length).replace(/^\s+/, "");
+  const appendix = ["---", ABD_APPEND_PROMPT].join("\n");
+  return {
+    matched: true,
+    prefix: ABD_PREFIX,
+    body,
+    text: body ? [body, appendix].join("\n\n") : appendix,
+  };
+}