chatccc 0.2.201 → 0.2.203

package/src/orchestrator.ts

@@ -22,24 +22,24 @@ import {
   PROJECT_ROOT,
   anthropicConfigDisplay,
   config,
-  fileLog,
-  getAllEffortsForTool,
-  getAllModelsForTool,
-  getDefaultEffortForTool,
-  getDefaultCwd,
+  fileLog,
+  getAllEffortsForTool,
+  getAllModelsForTool,
+  getDefaultEffortForTool,
+  getDefaultCwd,
   setDefaultCwd,
   getRecentDirs,
   addRecentDir,
   resolveDefaultAgentTool,
-  sessionPrefixForTool,
-  toolDisplayName,
-  ts,
-  type AgentTool,
-} from "./config.ts";
+  sessionPrefixForTool,
+  toolDisplayName,
+  ts,
+  type AgentTool,
+} from "./config.ts";
 import {
-  buildHelpCard,
-  buildEffortCard,
-  buildModelCard,
+  buildHelpCard,
+  buildEffortCard,
+  buildModelCard,
   buildStatusCard,
   buildCdContent,
   buildCdCard,
@@ -54,21 +54,21 @@ import {
   runGitCommand,
 } from "./git-command.ts";
 import {
-  clearSessionModelOverride,
-  clearSessionEffortOverride,
+  clearSessionModelOverride,
+  clearSessionEffortOverride,
   getSessionStatus,
   getAllSessionsStatus,
   initClaudeSession,
   lastMsgTimestamps,
   resumeAndPrompt,
   sessionInfoMap,
-  setSessionModelOverride,
-  setSessionEffortOverride,
+  setSessionModelOverride,
+  setSessionEffortOverride,
   switchChatBinding,
   recordSessionRegistry,
   getAdapterForTool,
-  getEffectiveModelForTool,
-  getEffectiveEffortForTool,
+  getEffectiveModelForTool,
+  getEffectiveEffortForTool,
   stopSession,
   loadSessionRegistryForBinding,
   removeSessionRegistryRecord,
@@ -87,11 +87,11 @@ import {
 import { getCodexUsageSummary, getTenantAccessToken, sendPostMessage } from "./feishu-platform.ts";
 import { getCursorUsageSummary, type CursorUsageSummary } from "./cursor-usage.ts";
 import { getChatGptSubscriptionStatus, type ChatGptSubscriptionResult } from "./chatgpt-subscription.ts";
-import { delegateAgentTask } from "./agent-delegate-task.ts";
-import { applySharedPrefix } from "./shared-prefix.ts";
-import { cwdDisplayName, sessionChatName } from "./session-name.ts";
-import { reloadRuntimeConfig } from "./runtime-reload.ts";
-export { type PlatformAdapter } from "./platform-adapter.ts";
+import { applySharedPrefix } from "./shared-prefix.ts";
+import { cwdDisplayName, sessionChatName } from "./session-name.ts";
+import { reloadRuntimeConfig } from "./runtime-reload.ts";
+import { acquireUpdateCommandGuard } from "./update-command-guard.ts";
+export { type PlatformAdapter } from "./platform-adapter.ts";
 import type { ChatAvatarUsageHints, PlatformAdapter } from "./platform-adapter.ts";
 import type { CodexUsageSummary } from "./feishu-api.ts";
 
@@ -135,7 +135,7 @@ function formatCodexUsageSummary(usage: CodexUsageSummary, chatGptSubscription:
     return `（约 ${parts.join("")}后）`;
   };
 
-  const formatResetTime = (balance: NonNullable<CodexUsageSummary["fiveHour"]>) => {
+  const formatResetTime = (balance: NonNullable<CodexUsageSummary["fiveHour"]>) => {
     if (balance.resetAtEpochSeconds === null) return "暂无数据";
     const date = new Date(balance.resetAtEpochSeconds * 1000);
     const pad = (value: number) => String(value).padStart(2, "0");
@@ -263,8 +263,8 @@ function formatCodexUsageSummary(usage: CodexUsageSummary, chatGptSubscription:
     formatChatGptSubscriptionFailure(),
     formatResetCredits(),
     "",
-    usage.fiveHour ? formatWindow("5h", usage.fiveHour) : "",
-    usage.weekly ? formatWindow("7天", usage.weekly) : "",
+    usage.fiveHour ? formatWindow("5h", usage.fiveHour) : "",
+    usage.weekly ? formatWindow("7天", usage.weekly) : "",
   ].filter((line, index, arr) => line !== "" || (index > 0 && arr[index - 1] !== "")).join("\n");
 }
 
@@ -325,7 +325,7 @@ function formatCursorUsageSummary(usage: CursorUsageSummary): string {
 }
 
 function usageHelpLine(tool: string): string {
-  if (tool === "codex") return "\n发送 **/usage** 查看 Codex 实际存在的 5h/7天用量窗口，以及查询/使用主动重置卡。";
+  if (tool === "codex") return "\n发送 **/usage** 查看 Codex 实际存在的 5h/7天用量窗口，以及查询/使用主动重置卡。";
   if (tool === "cursor") return "\n发送 **/usage** 查看 Cursor 用量。";
   return "";
 }
@@ -410,42 +410,10 @@ function shouldSendWechatProcessingAck(
   return platform.kind === "wechat" && chatType === "p2p" && !isCommandText;
 }
 
-function isNonWechatP2p(platform: PlatformAdapter, chatType: string): boolean {
-  return chatType === "p2p" && platform.kind !== "wechat";
-}
-
-async function cleanupNonWechatP2pBinding(
-  platform: PlatformAdapter,
-  chatId: string,
-  chatType: string,
-  tid: string,
-): Promise<void> {
-  if (!isNonWechatP2p(platform, chatType)) return;
-
-  try {
-    const registry = await loadSessionRegistryForBinding();
-    const record = registry[chatId];
-    if (!record?.sessionId) return;
-
-    unbindChatFromSession(record.sessionId, chatId);
-    displayCards.delete(chatId);
-    cancelQueuedMessage(record.sessionId);
-    sessionInfoMap.delete(chatId);
-    await removeSessionRegistryRecord(chatId);
-    logTrace(tid, "BRANCH", {
-      reason: "cleanup_non_wechat_p2p_binding",
-      chatId,
-      oldSessionId: record.sessionId,
-    });
-    console.log(
-      `[${ts()}] [P2P] Removed non-WeChat p2p binding: chat=${chatId} session=${record.sessionId}`,
-    );
-  } catch (err) {
-    console.log(
-      `[${ts()}] [INFO] Cannot cleanup p2p registry for ${chatId}: ${(err as Error).message}`,
-    );
-  }
-}
+/** 飞书私聊是固定会话容器；显式 /new 才创建独立群聊。 */
+function isFeishuP2p(platform: PlatformAdapter, chatType: string): boolean {
+  return chatType === "p2p" && platform.kind === "feishu";
+}
 
 /** 检测当前进程是否从 npm 全局安装启动 */
 function isRunningFromGlobalNpm(): boolean {
@@ -530,46 +498,46 @@ function syncUpdateAndRestart(): void {
 // handleCommand — 平台无关的命令分发
 // ---------------------------------------------------------------------------
 
-export async function handleCommand(
-  platform: PlatformAdapter,
-  text: string,
-  chatId: string,
-  openId: string,
-  msgTimestamp: number,
-  chatType = "group",
-  traceId?: string,
-): Promise<void> {
+export async function handleCommand(
+  platform: PlatformAdapter,
+  text: string,
+  chatId: string,
+  openId: string,
+  msgTimestamp: number,
+  chatType = "group",
+  traceId?: string,
+  commandId?: string,
+): 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 (isCommandText && textLower === "/reload") {
-    logTrace(tid, "BRANCH", { cmd: "/reload" });
-    try {
-      const result = await reloadRuntimeConfig("chat-command");
-      await platform.sendText(
-        chatId,
-        [
-          "配置已重新加载。",
-          `默认 Agent: ${toolDisplayName(result.defaultAgent)}`,
-          `配置文件: ${result.configPath}`,
-          "后续新会话会使用最新配置；正在生成的会话不会被中断。",
-        ].join("\n"),
-      ).catch(() => {});
-      logTrace(tid, "DONE", { outcome: "reload", defaultAgent: result.defaultAgent });
-    } catch (err) {
-      await platform.sendText(chatId, `配置重载失败：${(err as Error).message}`).catch(() => {});
-      logTrace(tid, "DONE", { outcome: "reload_fail", error: (err as Error).message });
-    }
-    return;
-  }
-
-  if (isCommandText && textLower === "/restart") {
+  const isCommandText = !sharedPrefix.matched && textLower.startsWith("/");
+  recordChatPlatform(chatId, platform);
+
+  if (isCommandText && textLower === "/reload") {
+    logTrace(tid, "BRANCH", { cmd: "/reload" });
+    try {
+      const result = await reloadRuntimeConfig("chat-command");
+      await platform.sendText(
+        chatId,
+        [
+          "配置已重新加载。",
+          `默认 Agent: ${toolDisplayName(result.defaultAgent)}`,
+          `配置文件: ${result.configPath}`,
+          "后续新会话会使用最新配置；正在生成的会话不会被中断。",
+        ].join("\n"),
+      ).catch(() => {});
+      logTrace(tid, "DONE", { outcome: "reload", defaultAgent: result.defaultAgent });
+    } catch (err) {
+      await platform.sendText(chatId, `配置重载失败：${(err as Error).message}`).catch(() => {});
+      logTrace(tid, "DONE", { outcome: "reload_fail", error: (err as Error).message });
+    }
+    return;
+  }
+
+  if (isCommandText && textLower === "/restart") {
     logTrace(tid, "BRANCH", { cmd: "/restart" });
     await platform.sendText(chatId, "重启中...请几秒后发消息唤醒我").catch(() => {});
     logTrace(tid, "DONE", { outcome: "restart" });
@@ -604,16 +572,40 @@ export async function handleCommand(
     return;
   }
 
-  if (isCommandText && textLower === "/update") {
-    logTrace(tid, "BRANCH", { cmd: "/update" });
-    const isGlobal = isRunningFromGlobalNpm();
-    appendStartupTrace("update: command received", { isGlobal, chatId });
+  if (isCommandText && textLower === "/update") {
+    logTrace(tid, "BRANCH", { cmd: "/update" });
+    const isGlobal = isRunningFromGlobalNpm();
+    appendStartupTrace("update: command received", { isGlobal, chatId });
     if (!isGlobal) {
       await platform.sendText(chatId, "当前进程非 npm 全局安装，无法使用 /update 更新。请通过 npm install -g chatccc 安装后使用。").catch(() => {});
-      logTrace(tid, "DONE", { outcome: "update_not_global" });
-      return;
-    }
-    await platform.sendText(chatId, "正在更新并重启，请稍候...").catch(() => {});
+      logTrace(tid, "DONE", { outcome: "update_not_global" });
+      return;
+    }
+
+    // `/update` 会主动重启进程，内存 processedMessages 随之丢失。必须在发送
+    // “正在更新”以及执行 npm 命令之前同步落盘，才能挡住新进程收到的飞书重投。
+    // 该护栏只位于此分支，不改变普通消息和 `/restart` 的现有去重行为。
+    const updateGuard = acquireUpdateCommandGuard({ commandId });
+    appendStartupTrace("update: command guard checked", {
+      allowed: updateGuard.allowed,
+      reason: updateGuard.reason,
+      hasCommandId: Boolean(commandId),
+    });
+    if (!updateGuard.allowed) {
+      if (updateGuard.reason === "duplicate_id") {
+        // 同一条飞书消息的重投静默丢弃，避免用户再次看到重复提示。
+        logTrace(tid, "DONE", { outcome: "update_duplicate_id" });
+        return;
+      }
+      await platform.sendText(
+        chatId,
+        "无法写入更新保护状态。为避免连续更新和重启，本次 /update 未执行。",
+      ).catch(() => {});
+      logTrace(tid, "DONE", { outcome: "update_guard_write_failed" });
+      return;
+    }
+
+    await platform.sendText(chatId, "正在更新并重启，请稍候...").catch(() => {});
     logTrace(tid, "DONE", { outcome: "update" });
     appendStartupTrace("update: sync update begin", { fromPid: process.pid });
     syncUpdateAndRestart();
@@ -763,7 +755,7 @@ export async function handleCommand(
     const toolArg = text.slice(5).trim().toLowerCase();
     const tool = toolArg || resolveDefaultAgentTool();
     logTrace(tid, "BRANCH", { cmd: "/new", tool });
-    const validTools = ["claude", "cursor", "codex", "ccc"];
+    const validTools = ["claude", "cursor", "codex", "ccc"];
     if (!validTools.includes(tool)) {
       logTrace(tid, "DONE", { outcome: "new_invalid_tool", tool });
       await platform.sendCard(
@@ -815,9 +807,9 @@ export async function handleCommand(
     const cwd = sessionCwd;
     const initialName = sessionChatName("新会话", cwd);
 
-    // 微信私聊：不创建群，直接绑定 session 到当前私聊
-    // 飞书私聊：也要建群
-    if (chatType === "p2p" && platform.kind === "wechat") {
+    // /new 的平台语义保持不同：微信在当前私聊新建 session；飞书显式
+    // /new 始终创建独立群聊。飞书私聊自己的常驻 session 不在这里切换。
+    if (chatType === "p2p" && platform.kind === "wechat") {
       // 先解绑旧 session（如果存在），避免旧 session 的 display loop
       // 继续往同一个 chat 推送内容（/newh 走 switchChatBinding 已有此逻辑，
       // 但 /new p2p 之前遗漏了解绑）。
@@ -837,11 +829,12 @@ export async function handleCommand(
         tool,
       });
       await setDefaultCwd(cwd, chatId);
-      await recordSessionRegistry({
-        chatId,
-        sessionId,
-        tool,
-        chatName: initialName,
+      await recordSessionRegistry({
+        chatId,
+        sessionId,
+        tool,
+        chatType,
+        chatName: initialName,
         turnCount: 0,
         startTime: Date.now(),
         running: false,
@@ -923,11 +916,12 @@ export async function handleCommand(
     // 让新群的默认工作目录继承当前会话的 cwd
     await setDefaultCwd(cwd, newChatId);
     bindChatToSession(sessionId, newChatId);
-    await recordSessionRegistry({
-      chatId: newChatId,
-      sessionId,
-      tool,
-      chatName: initialName,
+    await recordSessionRegistry({
+      chatId: newChatId,
+      sessionId,
+      tool,
+      chatType: "group",
+      chatName: initialName,
       turnCount: 0,
       startTime: Date.now(),
       running: false,
@@ -962,7 +956,8 @@ export async function handleCommand(
     return;
   }
 
-  // 检测会话上下文：群聊从 description 获取，私聊从 session-registry 获取
+  // 检测会话上下文：群聊从 description 获取，飞书/微信私聊都从
+  // session-registry 获取。私聊 chatId 是稳定容器，进程重启后仍恢复绑定。
   let sessionId: string | null = null;
   let descriptionTool: string | null = null;
   let toolLabel: string | null = null;
@@ -988,17 +983,30 @@ export async function handleCommand(
         `[${ts()}] [INFO] Cannot get chat info for ${chatId}: ${(err as Error).message}`,
       );
     }
-  } else if (platform.kind === "wechat") {
-    // 微信私聊：从 session-registry.json 获取绑定的 session。
-    // 飞书私聊不再作为持久会话入口，避免历史 registry 残留误路由到旧 session。
-    try {
-      const registry = await loadSessionRegistryForBinding();
-      const record = registry[chatId];
-      if (record && record.sessionId && record.tool) {
-        sessionId = record.sessionId;
+  } else if (platform.kind === "wechat" || platform.kind === "feishu") {
+    // 私聊没有可写的群描述，因此会话绑定只持久化在 session-registry.json。
+    try {
+      const registry = await loadSessionRegistryForBinding();
+      const record = registry[chatId];
+      // 旧版飞书曾把私聊视为建群入口，并会清理私聊 registry。没有 p2p
+      // 标记的残留记录不能证明它是在固定用户目录创建的，因此只迁移一次：
+      // 先解除旧绑定；若本条是普通消息，随后在用户目录创建新的私聊 session。
+      if (platform.kind === "feishu" && record?.sessionId && record.chatType !== "p2p") {
+        unbindChatFromSession(record.sessionId, chatId);
+        displayCards.delete(chatId);
+        cancelQueuedMessage(record.sessionId);
+        sessionInfoMap.delete(chatId);
+        await removeSessionRegistryRecord(chatId);
+        logTrace(tid, "BRANCH", {
+          reason: "migrate_legacy_feishu_p2p_binding",
+          chatId,
+          oldSessionId: record.sessionId,
+        });
+      } else if (record && record.sessionId && record.tool) {
+        sessionId = record.sessionId;
         descriptionTool = record.tool;
         toolLabel = toolDisplayName(descriptionTool);
-        // 确保 sessionInfoMap 中有该私聊的信息
+        // 确保内存状态在冷启动后恢复；bindChatToSession 是幂等的。
         if (!sessionInfoMap.has(chatId)) {
           sessionInfoMap.set(chatId, {
             sessionId,
@@ -1008,8 +1016,8 @@ export async function handleCommand(
             tool: descriptionTool,
           });
         }
-        bindChatToSession(sessionId, chatId);
-      }
+        bindChatToSession(sessionId, chatId);
+      }
     } catch (err) {
       console.log(
         `[${ts()}] [INFO] Cannot load registry for p2p ${chatId}: ${(err as Error).message}`,
@@ -1060,11 +1068,11 @@ export async function handleCommand(
       }
     }
 
-    // 微信 P2P：首条非指令消息 → 更新 registry 中的会话名
-    if (
-      chatType === "p2p" &&
-      platform.kind === "wechat" &&
-      !isCommandText
+    // P2P：首条非指令消息只更新 registry 中的展示名，不修改私聊信息。
+    if (
+      chatType === "p2p" &&
+      (platform.kind === "wechat" || platform.kind === "feishu") &&
+      !isCommandText
     ) {
       try {
         const reg = await loadSessionRegistryForBinding();
@@ -1093,12 +1101,12 @@ export async function handleCommand(
             () => {},
           );
           console.log(
-            `[${ts()}] [RENAME] WeChat P2P → "${newName2}"`,
+            `[${ts()}] [RENAME] ${platform.kind} P2P → "${newName2}"`,
           );
         }
       } catch (err) {
         console.error(
-          `[${ts()}] [RENAME] WeChat P2P failed: ${(err as Error).message}`,
+          `[${ts()}] [RENAME] ${platform.kind} P2P failed: ${(err as Error).message}`,
         );
       }
     }
@@ -1211,10 +1219,11 @@ export async function handleCommand(
       const allSessions = await getAllSessionsStatus();
       const now = Date.now();
       const cardData = allSessions.map((s) => ({
-        sessionId: s.sessionId,
-        chatName: s.chatName,
-        chatId: s.chatId,
-        active: s.active,
+        sessionId: s.sessionId,
+        chatName: s.chatName,
+        chatId: s.chatId,
+        chatType: s.chatType,
+        active: s.active,
         turnCount: s.turnCount,
         elapsedSeconds: s.active
           ? Math.floor((now - s.startTime) / 1000)
@@ -1222,7 +1231,10 @@ export async function handleCommand(
         model: s.model,
         tool: s.tool,
       }));
-      const card = buildSessionsCard(cardData, { defaultToolLabel: toolDisplayName(resolveDefaultAgentTool()) });
+      const card = buildSessionsCard(cardData, {
+        defaultToolLabel: toolDisplayName(resolveDefaultAgentTool()),
+        fixedPrivateSession: isFeishuP2p(platform, chatType),
+      });
       const ok = await platform.sendRawCard(chatId, card);
       console.log(
         `[${ts()}] [SESSIONS] card sent, ok=${ok}, count=${cardData.length}`,
@@ -1231,16 +1243,22 @@ export async function handleCommand(
       return;
     }
 
-    if (isCommandText && textLower === "/newh") {
-      logTrace(tid, "BRANCH", { cmd: "/newh" });
-      const adapter = getAdapterForTool(descriptionTool, sessionId);
-      let cwd: string;
-      try {
-        const info = await adapter.getSessionInfo(sessionId);
-        cwd = info?.cwd ?? (await getDefaultCwd(chatId));
-      } catch {
-        cwd = await getDefaultCwd(chatId);
-      }
+    if (isCommandText && textLower === "/newh") {
+      logTrace(tid, "BRANCH", { cmd: "/newh" });
+      let cwd: string;
+      if (isFeishuP2p(platform, chatType)) {
+        // 飞书私聊不支持切换工作目录。即使 /cd 已为后续 /new 群聊
+        // 保存了其他默认目录，/newh 仍必须在运行 ChatCCC 的用户目录重建。
+        cwd = homedir();
+      } else {
+        const adapter = getAdapterForTool(descriptionTool, sessionId);
+        try {
+          const info = await adapter.getSessionInfo(sessionId);
+          cwd = info?.cwd ?? (await getDefaultCwd(chatId));
+        } catch {
+          cwd = await getDefaultCwd(chatId);
+        }
+      }
 
       // 第一步:创建新 session(此时尚未碰任何内存绑定,失败可直接返回,
       // 旧 session 状态完全保留)。
@@ -1299,13 +1317,13 @@ export async function handleCommand(
         .setChatAvatar(chatId, descriptionTool, "new")
         .catch(() => {});
 
-      await platform.sendCard(
-        chatId,
-        `${toolLabel} Session Reset`,
-        `会话已重置为新的 **${toolLabel}** 会话。\n\n` +
-          `**Session ID:** ${newSessionId}\n` +
-          `**工作目录:** \`${cwd}\`（沿用当前会话目录）\n\n` +
-          `直接在这里发消息即可继续对话。\n` +
+      await platform.sendCard(
+        chatId,
+        `${toolLabel} Session Reset`,
+        `会话已重置为新的 **${toolLabel}** 会话。\n\n` +
+          `**Session ID:** ${newSessionId}\n` +
+          `**工作目录:** \`${cwd}\`${isFeishuP2p(platform, chatType) ? "（飞书私聊固定使用系统用户目录）" : "（沿用当前会话目录）"}\n\n` +
+          `直接在这里发消息即可继续对话。\n` +
           `发送 **/cd** 可切换新建会话的默认目录。\n` +
           `发送 **/model** 查看或切换当前会话的模型。`,
         "green",
@@ -1356,9 +1374,22 @@ export async function handleCommand(
     }
 
     // /session <number>：切换到 /sessions 列表中的指定会话
-    const sessionMatch = isCommandText ? textLower.match(/^\/session\s+(\d+)$/) : null;
-    if (sessionMatch) {
-      const index = parseInt(sessionMatch[1], 10) - 1;
+    const sessionMatch = isCommandText ? textLower.match(/^\/session\s+(\d+)$/) : null;
+    if (sessionMatch) {
+      // 飞书私聊有自己唯一的常驻 session；历史群聊 session 只能回到对应群聊
+      // 继续，禁止通过 /session 把它们重新绑定进私聊。
+      if (isFeishuP2p(platform, chatType)) {
+        await platform.sendCard(
+          chatId,
+          "/session",
+          "飞书私聊使用固定的专属会话，不能切换到历史群聊会话。请回到对应群聊继续，或发送 /new 新建群聊。",
+          "yellow",
+        );
+        logTrace(tid, "DONE", { outcome: "session_switch_disabled_feishu_p2p" });
+        return;
+      }
+
+      const index = parseInt(sessionMatch[1], 10) - 1;
       logTrace(tid, "BRANCH", { cmd: "/session", index: index + 1 });
       const allSessions = await getAllSessionsStatus();
       const claudeOrdered = allSessions.filter(
@@ -1555,96 +1586,96 @@ export async function handleCommand(
     }
 
     // /git <args>：在「当前会话工作目录」执行 git 命令
-    if (isCommandText && textLower === "/effort clear") {
-      logTrace(tid, "BRANCH", { cmd: "/effort clear", sessionId, tool: descriptionTool });
-      const efforts = getAllEffortsForTool(descriptionTool as AgentTool);
-      const toolLabel = toolDisplayName(descriptionTool);
-      if (efforts.length === 0) {
-        const msg = `当前 ${toolLabel} 不支持 effort 切换。`;
-        await (platform.kind === "wechat"
-          ? platform.sendText(chatId, msg)
-          : platform.sendCard(chatId, "Effort 切换", msg, "red")
-        ).catch(() => {});
-        logTrace(tid, "DONE", { outcome: "effort_unsupported", tool: descriptionTool });
-        return;
-      }
-
-      clearSessionEffortOverride(sessionId);
-      const defaultEffort = getDefaultEffortForTool(descriptionTool as AgentTool);
-      const msg = `已清除当前 ${toolLabel} 会话的 effort 覆盖，恢复使用: \`${defaultEffort || "(未指定)"}\``;
-      await (platform.kind === "wechat"
-        ? platform.sendText(chatId, msg)
-        : platform.sendCard(chatId, "Effort 切换", msg, "green")
-      ).catch(() => {});
-      logTrace(tid, "DONE", { outcome: "effort_cleared", sessionId, tool: descriptionTool });
-      return;
-    }
-
-    if (isCommandText && textLower.startsWith("/effort ")) {
-      const effortArg = text.slice(8).trim();
-      if (!effortArg) return;
-      logTrace(tid, "BRANCH", { cmd: "/effort", arg: effortArg, sessionId, tool: descriptionTool });
-
-      const efforts = getAllEffortsForTool(descriptionTool as AgentTool);
-      const toolLabel = toolDisplayName(descriptionTool);
-      if (efforts.length === 0) {
-        const msg = `当前 ${toolLabel} 不支持 effort 切换。`;
-        await (platform.kind === "wechat"
-          ? platform.sendText(chatId, msg)
-          : platform.sendCard(chatId, "Effort 切换", msg, "red")
-        ).catch(() => {});
-        logTrace(tid, "DONE", { outcome: "effort_unsupported", tool: descriptionTool });
-        return;
-      }
-
-      const target = findModelMatch(effortArg, efforts);
-      if (!target) {
-        const msg = `未找到匹配 "${effortArg}" 的 effort。当前 ${toolLabel} 可选 effort:\n${efforts.map(e => `  \`${e}\``).join("\n")}`;
-        await (platform.kind === "wechat"
-          ? platform.sendText(chatId, msg)
-          : platform.sendCard(chatId, "Effort 切换", msg, "red")
-        ).catch(() => {});
-        logTrace(tid, "DONE", { outcome: "effort_not_found", arg: effortArg, tool: descriptionTool });
-        return;
-      }
-
-      setSessionEffortOverride(sessionId, target);
-      const msg = `已切换当前 ${toolLabel} 会话 effort 为: \`${target}\``;
-      await (platform.kind === "wechat"
-        ? platform.sendText(chatId, msg)
-        : platform.sendCard(chatId, "Effort 切换", msg, "green")
-      ).catch(() => {});
-      logTrace(tid, "DONE", { outcome: "effort_switched", arg: effortArg, target, sessionId, tool: descriptionTool });
-      return;
-    }
-
-    if (isCommandText && textLower === "/effort") {
-      logTrace(tid, "BRANCH", { cmd: "/effort", sessionId, tool: descriptionTool });
-      const efforts = getAllEffortsForTool(descriptionTool as AgentTool);
-      const currentEffort = getEffectiveEffortForTool(descriptionTool, sessionId);
-      const toolLabel = toolDisplayName(descriptionTool);
-
-      if (efforts.length === 0) {
-        const msg = `当前 ${toolLabel} 不支持 effort 切换。`;
-        await (platform.kind === "wechat"
-          ? platform.sendText(chatId, msg)
-          : platform.sendCard(chatId, "Effort 切换", msg, "red")
-        ).catch(() => {});
-      } else if (platform.kind === "wechat") {
-        const lines = [currentEffort ? `当前 effort (${toolLabel}): ${currentEffort}` : `当前 effort (${toolLabel}): 未指定`];
-        lines.push("", "可切换 effort:");
-        for (const e of efforts) lines.push(`  ${e}`);
-        lines.push("", "输入 /effort <effort> 切换 effort");
-        await platform.sendText(chatId, lines.join("\n")).catch(() => {});
-      } else {
-        const card = buildEffortCard(currentEffort, efforts, descriptionTool);
-        await platform.sendRawCard(chatId, card);
-      }
-      logTrace(tid, "DONE", { outcome: "effort_query", tool: descriptionTool });
-      return;
-    }
-
-    if (isCommandText && (textLower.startsWith("/git ") || textLower === "/git")) {
+    if (isCommandText && textLower === "/effort clear") {
+      logTrace(tid, "BRANCH", { cmd: "/effort clear", sessionId, tool: descriptionTool });
+      const efforts = getAllEffortsForTool(descriptionTool as AgentTool);
+      const toolLabel = toolDisplayName(descriptionTool);
+      if (efforts.length === 0) {
+        const msg = `当前 ${toolLabel} 不支持 effort 切换。`;
+        await (platform.kind === "wechat"
+          ? platform.sendText(chatId, msg)
+          : platform.sendCard(chatId, "Effort 切换", msg, "red")
+        ).catch(() => {});
+        logTrace(tid, "DONE", { outcome: "effort_unsupported", tool: descriptionTool });
+        return;
+      }
+
+      clearSessionEffortOverride(sessionId);
+      const defaultEffort = getDefaultEffortForTool(descriptionTool as AgentTool);
+      const msg = `已清除当前 ${toolLabel} 会话的 effort 覆盖，恢复使用: \`${defaultEffort || "(未指定)"}\``;
+      await (platform.kind === "wechat"
+        ? platform.sendText(chatId, msg)
+        : platform.sendCard(chatId, "Effort 切换", msg, "green")
+      ).catch(() => {});
+      logTrace(tid, "DONE", { outcome: "effort_cleared", sessionId, tool: descriptionTool });
+      return;
+    }
+
+    if (isCommandText && textLower.startsWith("/effort ")) {
+      const effortArg = text.slice(8).trim();
+      if (!effortArg) return;
+      logTrace(tid, "BRANCH", { cmd: "/effort", arg: effortArg, sessionId, tool: descriptionTool });
+
+      const efforts = getAllEffortsForTool(descriptionTool as AgentTool);
+      const toolLabel = toolDisplayName(descriptionTool);
+      if (efforts.length === 0) {
+        const msg = `当前 ${toolLabel} 不支持 effort 切换。`;
+        await (platform.kind === "wechat"
+          ? platform.sendText(chatId, msg)
+          : platform.sendCard(chatId, "Effort 切换", msg, "red")
+        ).catch(() => {});
+        logTrace(tid, "DONE", { outcome: "effort_unsupported", tool: descriptionTool });
+        return;
+      }
+
+      const target = findModelMatch(effortArg, efforts);
+      if (!target) {
+        const msg = `未找到匹配 "${effortArg}" 的 effort。当前 ${toolLabel} 可选 effort:\n${efforts.map(e => `  \`${e}\``).join("\n")}`;
+        await (platform.kind === "wechat"
+          ? platform.sendText(chatId, msg)
+          : platform.sendCard(chatId, "Effort 切换", msg, "red")
+        ).catch(() => {});
+        logTrace(tid, "DONE", { outcome: "effort_not_found", arg: effortArg, tool: descriptionTool });
+        return;
+      }
+
+      setSessionEffortOverride(sessionId, target);
+      const msg = `已切换当前 ${toolLabel} 会话 effort 为: \`${target}\``;
+      await (platform.kind === "wechat"
+        ? platform.sendText(chatId, msg)
+        : platform.sendCard(chatId, "Effort 切换", msg, "green")
+      ).catch(() => {});
+      logTrace(tid, "DONE", { outcome: "effort_switched", arg: effortArg, target, sessionId, tool: descriptionTool });
+      return;
+    }
+
+    if (isCommandText && textLower === "/effort") {
+      logTrace(tid, "BRANCH", { cmd: "/effort", sessionId, tool: descriptionTool });
+      const efforts = getAllEffortsForTool(descriptionTool as AgentTool);
+      const currentEffort = getEffectiveEffortForTool(descriptionTool, sessionId);
+      const toolLabel = toolDisplayName(descriptionTool);
+
+      if (efforts.length === 0) {
+        const msg = `当前 ${toolLabel} 不支持 effort 切换。`;
+        await (platform.kind === "wechat"
+          ? platform.sendText(chatId, msg)
+          : platform.sendCard(chatId, "Effort 切换", msg, "red")
+        ).catch(() => {});
+      } else if (platform.kind === "wechat") {
+        const lines = [currentEffort ? `当前 effort (${toolLabel}): ${currentEffort}` : `当前 effort (${toolLabel}): 未指定`];
+        lines.push("", "可切换 effort:");
+        for (const e of efforts) lines.push(`  ${e}`);
+        lines.push("", "输入 /effort <effort> 切换 effort");
+        await platform.sendText(chatId, lines.join("\n")).catch(() => {});
+      } else {
+        const card = buildEffortCard(currentEffort, efforts, descriptionTool);
+        await platform.sendRawCard(chatId, card);
+      }
+      logTrace(tid, "DONE", { outcome: "effort_query", tool: descriptionTool });
+      return;
+    }
+
+    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) {
@@ -1802,53 +1833,54 @@ export async function handleCommand(
   }
 
   // 无会话上下文 → /sessions 仍是有效指令，不触发飞书私聊自动建群。
-  if (isCommandText && textLower === "/effort") {
-    const defaultTool = resolveDefaultAgentTool();
-    const efforts = getAllEffortsForTool(defaultTool);
-    const currentEffort = getDefaultEffortForTool(defaultTool);
-    const toolLabel = toolDisplayName(defaultTool);
-
-    if (efforts.length === 0) {
-      const msg = `当前默认 agent (${toolLabel}) 不支持 effort 切换。`;
-      await (platform.kind === "wechat"
-        ? platform.sendText(chatId, msg)
-        : platform.sendCard(chatId, "Effort 切换", msg, "red")
-      ).catch(() => {});
-    } else if (platform.kind === "wechat") {
-      const lines = [currentEffort ? `当前默认 effort (${toolLabel}): ${currentEffort}` : `当前默认 effort (${toolLabel}): 未指定`];
-      lines.push("", "可切换 effort:");
-      for (const e of efforts) lines.push(`  ${e}`);
-      lines.push("", "在会话中输入 /effort <effort> 切换 effort");
-      await platform.sendText(chatId, lines.join("\n")).catch(() => {});
-    } else {
-      const card = buildEffortCard(currentEffort, efforts, defaultTool);
-      await platform.sendRawCard(chatId, card);
-    }
-    logTrace(tid, "DONE", { outcome: "effort_query", defaultTool });
-    return;
-  }
-
-  if (isCommandText && textLower.startsWith("/effort ")) {
-    const defaultTool = resolveDefaultAgentTool();
-    const toolLabel = toolDisplayName(defaultTool);
-    const msg = `当前没有绑定会话。请先进入 Claude/Codex 会话，再输入 /effort <effort> 切换当前会话的 effort。当前默认 agent: ${toolLabel}`;
-    await (platform.kind === "wechat"
-      ? platform.sendText(chatId, msg)
-      : platform.sendCard(chatId, "Effort 切换", msg, "yellow")
-    ).catch(() => {});
-    logTrace(tid, "DONE", { outcome: "effort_no_session", defaultTool });
-    return;
-  }
-
-  if (isCommandText && textLower === "/sessions") {
+  if (isCommandText && textLower === "/effort") {
+    const defaultTool = resolveDefaultAgentTool();
+    const efforts = getAllEffortsForTool(defaultTool);
+    const currentEffort = getDefaultEffortForTool(defaultTool);
+    const toolLabel = toolDisplayName(defaultTool);
+
+    if (efforts.length === 0) {
+      const msg = `当前默认 agent (${toolLabel}) 不支持 effort 切换。`;
+      await (platform.kind === "wechat"
+        ? platform.sendText(chatId, msg)
+        : platform.sendCard(chatId, "Effort 切换", msg, "red")
+      ).catch(() => {});
+    } else if (platform.kind === "wechat") {
+      const lines = [currentEffort ? `当前默认 effort (${toolLabel}): ${currentEffort}` : `当前默认 effort (${toolLabel}): 未指定`];
+      lines.push("", "可切换 effort:");
+      for (const e of efforts) lines.push(`  ${e}`);
+      lines.push("", "在会话中输入 /effort <effort> 切换 effort");
+      await platform.sendText(chatId, lines.join("\n")).catch(() => {});
+    } else {
+      const card = buildEffortCard(currentEffort, efforts, defaultTool);
+      await platform.sendRawCard(chatId, card);
+    }
+    logTrace(tid, "DONE", { outcome: "effort_query", defaultTool });
+    return;
+  }
+
+  if (isCommandText && textLower.startsWith("/effort ")) {
+    const defaultTool = resolveDefaultAgentTool();
+    const toolLabel = toolDisplayName(defaultTool);
+    const msg = `当前没有绑定会话。请先进入 Claude/Codex 会话，再输入 /effort <effort> 切换当前会话的 effort。当前默认 agent: ${toolLabel}`;
+    await (platform.kind === "wechat"
+      ? platform.sendText(chatId, msg)
+      : platform.sendCard(chatId, "Effort 切换", msg, "yellow")
+    ).catch(() => {});
+    logTrace(tid, "DONE", { outcome: "effort_no_session", defaultTool });
+    return;
+  }
+
+  if (isCommandText && textLower === "/sessions") {
     logTrace(tid, "BRANCH", { cmd: "/sessions", scope: "global" });
     const allSessions = await getAllSessionsStatus();
     const now = Date.now();
     const cardData = allSessions.map((s) => ({
-      sessionId: s.sessionId,
-      chatName: s.chatName,
-      chatId: s.chatId,
-      active: s.active,
+      sessionId: s.sessionId,
+      chatName: s.chatName,
+      chatId: s.chatId,
+      chatType: s.chatType,
+      active: s.active,
       turnCount: s.turnCount,
       elapsedSeconds: s.active
         ? Math.floor((now - s.startTime) / 1000)
@@ -1856,7 +1888,10 @@ export async function handleCommand(
       model: s.model,
       tool: s.tool,
     }));
-    const card = buildSessionsCard(cardData, { defaultToolLabel: toolDisplayName(resolveDefaultAgentTool()) });
+    const card = buildSessionsCard(cardData, {
+      defaultToolLabel: toolDisplayName(resolveDefaultAgentTool()),
+      fixedPrivateSession: isFeishuP2p(platform, chatType),
+    });
     const ok = await platform.sendRawCard(chatId, card);
     console.log(
       `[${ts()}] [SESSIONS] card sent, ok=${ok}, count=${cardData.length}`,
@@ -1865,53 +1900,63 @@ export async function handleCommand(
     return;
   }
 
-  // 飞书私聊普通消息：不再绑定私聊本身，而是自动创建会话群并把私聊内容作为首轮 prompt。
-  if (isNonWechatP2p(platform, chatType) && !isCommandText) {
-    const tool = resolveDefaultAgentTool();
-    const toolLabel = toolDisplayName(tool);
-    logTrace(tid, "BRANCH", { cmd: "auto_new_from_p2p", tool });
-
-    if (!openId) {
-      logTrace(tid, "DONE", { outcome: "auto_new_p2p_no_openid" });
-      await platform.sendCard(
-        chatId,
-        "Error",
-        "Cannot identify sender.",
-        "red",
-      );
-      return;
-    }
-
-    try {
-      const cwd = await getDefaultCwd(chatId);
-      const result = await delegateAgentTask({
-        platform,
-        tool,
-        cwd,
-        promptText,
-        openIds: [openId],
-        chatNamePrefix: text.slice(0, 10) || "新会话",
-        msgTimestamp,
-        traceId: tid,
-      });
-      logTrace(tid, "DONE", {
-        outcome: "auto_new_p2p_prompt_done",
-        newChatId: result.chatId,
-        sessionId: result.sessionId,
-        tool,
-      });
-    } catch (err) {
-      console.error(`[${ts()}] [AUTO-P2P] FAIL: ${(err as Error).message}`);
-      logTrace(tid, "DONE", {
-        outcome: "auto_new_p2p_delegate_fail",
-        error: (err as Error).message,
-      });
-      await platform.sendCard(
-        chatId,
-        "Error",
-        `Failed to create ${toolLabel} delegated task:\n${(err as Error).message}`,
-        "red",
-      );
+  // 飞书私聊普通消息：首次使用时在当前私聊创建并持久化一个专属 session，
+  // 随后的消息会在上面的 registry 路由中继续该 session。只有显式 /new 才建群。
+  if (isFeishuP2p(platform, chatType) && !isCommandText) {
+    const tool = resolveDefaultAgentTool();
+    const toolLabel = toolDisplayName(tool);
+    // 私聊 cwd 故意不读取 /cd 的 chatId 默认值：/cd 只为之后显式
+    // /new 创建的群聊服务，飞书私聊始终从 ChatCCC 运行账号的用户目录启动。
+    const cwd = homedir();
+    logTrace(tid, "BRANCH", { cmd: "auto_new_feishu_p2p", tool, cwd });
+
+    try {
+      const init = await initClaudeSession(tool, cwd);
+      const sessionId = init.sessionId;
+      const chatName = sessionChatName(text.slice(0, 10) || "私聊会话", cwd);
+      const switchResult = await switchChatBinding({
+        chatId,
+        chatType,
+        oldSessionId: null,
+        newSessionId: sessionId,
+        tool,
+        chatName,
+        newDescription: `${sessionPrefixForTool(tool)} ${sessionId}`,
+        updateChatInfoFn: (cid, name, desc) =>
+          platform.updateChatInfo(cid, name, desc),
+      });
+      if (!switchResult.ok) {
+        throw switchResult.error ?? new Error("Failed to bind Feishu private session");
+      }
+
+      await resumeAndPrompt(
+        sessionId,
+        promptText,
+        platform,
+        chatId,
+        msgTimestamp,
+        tool,
+        tid,
+      );
+      logTrace(tid, "DONE", {
+        outcome: "auto_new_feishu_p2p_prompt_done",
+        chatId,
+        sessionId,
+        tool,
+        cwd,
+      });
+    } catch (err) {
+      console.error(`[${ts()}] [AUTO-P2P] FAIL: ${(err as Error).message}`);
+      logTrace(tid, "DONE", {
+        outcome: "auto_new_feishu_p2p_fail",
+        error: (err as Error).message,
+      });
+      await platform.sendCard(
+        chatId,
+        "Error",
+        `Failed to create ${toolLabel} private session:\n${(err as Error).message}`,
+        "red",
+      );
     }
     return;
   }