chatccc 0.2.251 → 0.2.253

package/dist/src/orchestrator.js

@@ -0,0 +1,2078 @@
+/**
+ * orchestrator.ts — 平台无关的消息命令处理
+ *
+ * Phase 1: 从 index.ts 抽出 handleCommand 及辅助函数。
+ * 所有 IM 平台操作通过 PlatformAdapter 接口注入，不直接依赖 feishu-platform.ts。
+ */
+import { execSync, spawn } from "node:child_process";
+import { readdir, stat } from "node:fs/promises";
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+import { makeTraceId, logTrace } from "./trace.js";
+import { appendStartupTrace } from "./shared.js";
+import { CLAUDE_MODEL, GIT_TIMEOUT_MS, PROJECT_ROOT, anthropicConfigDisplay, config, fileLog, getAllEffortsForTool, getAllModelsForTool, getDefaultEffortForTool, getDefaultCwd, LOG_DIR, setDefaultCwd, getRecentDirs, addRecentDir, resolveDefaultAgentTool, sessionPrefixForTool, toolDisplayName, ts, } from "./config.js";
+import { buildHelpCard, buildEffortCard, buildFastModeCard, buildModelCard, buildStatusCard, buildCdContent, buildCdCard, buildSessionsCard, buildQueuedCard, buildQueueFullCard, buildCodexUsageCard, } from "./cards.js";
+import { formatGitResult, gitResultHeaderTemplate, runGitCommand, } from "./git-command.js";
+import { clearSessionModelOverride, clearSessionEffortOverride, getSessionStatus, getAllSessionsStatus, initClaudeSession, lastMsgTimestamps, resumeAndPrompt, sessionInfoMap, setSessionModelOverride, setSessionEffortOverride, switchChatBinding, recordSessionRegistry, getAdapterForTool, getEffectiveModelForTool, getEffectiveEffortForTool, getEffectiveFastModeForTool, setSessionFastModeOverride, stopSession, loadSessionRegistryForBinding, removeSessionRegistryRecord, saveSessionTool, recordChatPlatform, } from "./session.js";
+import { bindChatToSession, unbindChatFromSession, isSessionRunning, displayCards, enqueueMessage, cancelQueuedMessage, } from "./session-chat-binding.js";
+import { getCodexUsageSummary, getTenantAccessToken, sendPostMessage } from "./feishu-platform.js";
+import { getCursorUsageSummary } from "./cursor-usage.js";
+import { getChatGptSubscriptionStatus } from "./chatgpt-subscription.js";
+import { applySharedPrefix } from "./shared-prefix.js";
+import { sessionChatName } from "./session-name.js";
+import { reloadRuntimeConfig } from "./runtime-reload.js";
+import { acquireUpdateCommandGuard } from "./update-command-guard.js";
+import { createInternalRestartEnv } from "./startup-lifecycle.js";
+import { resolveChatCccRuntimeSpawnSpec } from "./runtime-entry.js";
+// ---------------------------------------------------------------------------
+// 辅助函数
+// ---------------------------------------------------------------------------
+/** 模型模糊匹配：精确匹配优先，否则找子串匹配（模型名越短越优先） */
+function findModelMatch(input, models) {
+    if (models.length === 0)
+        return null;
+    const inputLower = input.toLowerCase();
+    // 1) 精确匹配（忽略大小写）
+    for (const m of models) {
+        if (m.toLowerCase() === inputLower)
+            return m;
+    }
+    // 2) 子串匹配：模型全名包含输入，按模型名长度升序（越短越优先）
+    const candidates = models
+        .filter(m => m.toLowerCase().includes(inputLower))
+        .sort((a, b) => a.length - b.length);
+    return candidates[0] ?? null;
+}
+function formatCodexUsageSummary(usage, chatGptSubscription = null) {
+    const progressBar = (usedPercent) => {
+        const width = 20;
+        const usedBlocks = Math.max(0, Math.min(width, Math.round((usedPercent / 100) * width)));
+        return `[${"█".repeat(usedBlocks)}${"░".repeat(width - usedBlocks)}]`;
+    };
+    const formatDuration = (seconds) => {
+        if (seconds === null)
+            return "";
+        if (seconds <= 0)
+            return "（已到重置时间）";
+        const totalMinutes = Math.max(1, Math.floor(seconds / 60));
+        const days = Math.floor(totalMinutes / 1440);
+        const hours = Math.floor((totalMinutes % 1440) / 60);
+        const minutes = totalMinutes % 60;
+        const parts = [];
+        if (days > 0)
+            parts.push(`${days}天`);
+        if (hours > 0)
+            parts.push(`${hours}小时`);
+        if (minutes > 0 || parts.length === 0)
+            parts.push(`${minutes}分钟`);
+        return `（约 ${parts.join("")}后）`;
+    };
+    const formatResetTime = (balance) => {
+        if (balance.resetAtEpochSeconds === null)
+            return "暂无数据";
+        const date = new Date(balance.resetAtEpochSeconds * 1000);
+        const pad = (value) => String(value).padStart(2, "0");
+        const absolute = [
+            date.getFullYear(),
+            "-",
+            pad(date.getMonth() + 1),
+            "-",
+            pad(date.getDate()),
+            " ",
+            pad(date.getHours()),
+            ":",
+            pad(date.getMinutes()),
+        ].join("");
+        return `${absolute}${formatDuration(balance.resetAfterSeconds)}`;
+    };
+    const formatWindow = (label, balance) => {
+        if (!balance)
+            return `**${label}:** 暂无数据`;
+        return [
+            `**${label}:** 已用 ${balance.usedPercent}%，剩余 ${balance.remainingPercent}%，重置: ${formatResetTime(balance)}`,
+            progressBar(balance.usedPercent),
+        ].join("\n");
+    };
+    const formatResetCredits = () => {
+        if (usage.rateLimitResetCreditsAvailable === null)
+            return "**主动重置:** 暂无数据";
+        const lines = [`**主动重置:** 剩余 ${usage.rateLimitResetCreditsAvailable} 次`];
+        const credits = usage.rateLimitResetCredits ?? [];
+        if (credits.length > 0) {
+            const pad = (value) => String(value).padStart(2, "0");
+            const formatExpiresAt = (value) => {
+                const date = new Date(value);
+                if (!Number.isFinite(date.getTime()))
+                    return value;
+                return [
+                    date.getFullYear(),
+                    "-",
+                    pad(date.getMonth() + 1),
+                    "-",
+                    pad(date.getDate()),
+                    " ",
+                    pad(date.getHours()),
+                    ":",
+                    pad(date.getMinutes()),
+                    ":",
+                    pad(date.getSeconds()),
+                ].join("");
+            };
+            lines.push("**过期时间:**");
+            for (const credit of credits) {
+                lines.push(`- ${formatExpiresAt(credit.expiresAt)}`);
+            }
+        }
+        return lines.join("\n");
+    };
+    const formatSubscriptionFailureReason = (result) => {
+        const port = result.chromeCdp.port;
+        switch (result.code) {
+            case "chrome_cdp_unreachable":
+                return `Chrome CDP 端口 ${port} 不可访问。请确认常驻 Chrome 已启动，或重启 ChatCCC。`;
+            case "chrome_cdp_occupied":
+                return `${port} 端口可访问，但不是健康的 Chrome CDP。请释放该端口或修改 chromeDevtools.port。`;
+            case "chatgpt_page_missing":
+                return `没有可用的 ChatGPT 页面。请在 ${port} 端口对应的 Chrome 浏览器中打开 https://chatgpt.com/ 并登录。`;
+            case "chatgpt_session_missing":
+                return `请在 ${port} 端口对应的 Chrome 浏览器中登录 ChatGPT。`;
+            case "chatgpt_subscription_failed":
+                return "ChatGPT 订阅接口探测失败。可能是页面未加载完成、ChatGPT 接口变更或网络异常。";
+            case "chrome_cdp_disabled":
+                return "";
+            case "ok":
+                return "";
+        }
+    };
+    const formatChatGptSubscriptionFailure = () => {
+        if (!chatGptSubscription || chatGptSubscription.ok || !chatGptSubscription.chromeCdp.enabled)
+            return "";
+        const lines = [
+            "**ChatGPT 订阅查询失败:**",
+            `- 原因: ${formatSubscriptionFailureReason(chatGptSubscription) || "暂无数据"}`,
+        ];
+        const detail = chatGptSubscription.reason?.replace(/\s+/g, " ").trim();
+        if (detail) {
+            lines.push(`- 详情: ${detail.length > 240 ? `${detail.slice(0, 240)}...` : detail}`);
+        }
+        return lines.join("\n");
+    };
+    const formatChatGptSubscription = () => {
+        if (!chatGptSubscription?.ok || !chatGptSubscription.subscription)
+            return "";
+        const subscription = chatGptSubscription.subscription;
+        const pad = (value) => String(value).padStart(2, "0");
+        const formatExpiresAt = (value) => {
+            if (!value)
+                return "暂无数据";
+            const date = new Date(value);
+            if (!Number.isFinite(date.getTime()))
+                return value;
+            return [
+                date.getFullYear(),
+                "-",
+                pad(date.getMonth() + 1),
+                "-",
+                pad(date.getDate()),
+                " ",
+                pad(date.getHours()),
+                ":",
+                pad(date.getMinutes()),
+            ].join("");
+        };
+        const remaining = typeof subscription.remainingDays === "number"
+            ? `（剩余 ${subscription.remainingDays} 天）`
+            : "";
+        return [
+            "**ChatGPT 订阅:**",
+            `- 套餐: ${subscription.plan ?? "暂无数据"}`,
+            `- 到期: ${formatExpiresAt(subscription.expiresAt)}${remaining}`,
+            `- 自动续费: ${subscription.willRenew === null ? "暂无数据" : subscription.willRenew ? "是" : "否"}`,
+        ].join("\n");
+    };
+    return [
+        "Codex 用量：",
+        "",
+        formatChatGptSubscription(),
+        formatChatGptSubscriptionFailure(),
+        formatResetCredits(),
+        "",
+        usage.fiveHour ? formatWindow("5h", usage.fiveHour) : "",
+        usage.weekly ? formatWindow("7天", usage.weekly) : "",
+    ].filter((line, index, arr) => line !== "" || (index > 0 && arr[index - 1] !== "")).join("\n");
+}
+function formatCursorUsageSummary(usage) {
+    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const dateFormatter = new Intl.DateTimeFormat("zh-CN", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+        timeZoneName: "shortOffset",
+    });
+    const formatDate = (value) => {
+        const timestamp = Number(value);
+        if (!Number.isFinite(timestamp))
+            return "暂无数据";
+        return dateFormatter.format(new Date(timestamp));
+    };
+    const formatMoney = (value) => {
+        if (typeof value !== "number" || !Number.isFinite(value))
+            return "暂无数据";
+        return `$${(value / 100).toFixed(2)}`;
+    };
+    const formatPercent = (value) => {
+        if (typeof value !== "number" || !Number.isFinite(value))
+            return "暂无数据";
+        return `${value}%`;
+    };
+    const plan = usage.planUsage;
+    const spendLimit = usage.spendLimitUsage;
+    return [
+        "Cursor 用量：",
+        "",
+        `**计费周期:** ${formatDate(usage.billingCycleStart)} - ${formatDate(usage.billingCycleEnd)}`,
+        "",
+        "**Included usage:**",
+        `- Total: ${formatMoney(plan?.totalSpend)} / ${formatMoney(plan?.limit)} (${formatPercent(plan?.totalPercentUsed)})`,
+        `- Included: ${formatMoney(plan?.includedSpend)}`,
+        `- Bonus: ${formatMoney(plan?.bonusSpend)}`,
+        `- Auto: ${formatPercent(plan?.autoPercentUsed)}`,
+        `- API: ${formatPercent(plan?.apiPercentUsed)}`,
+        "",
+        "**On-Demand / Spend limit:**",
+        `- Individual used: ${formatMoney(spendLimit?.individualUsed)}`,
+        `- Pool used: ${formatMoney(spendLimit?.pooledUsed)} / ${formatMoney(spendLimit?.pooledLimit)}`,
+        `- Pool remaining: ${formatMoney(spendLimit?.pooledRemaining)}`,
+        `- Limit type: ${spendLimit?.limitType ?? "暂无数据"}`,
+        `- Display threshold: ${formatMoney(usage.displayThreshold)}`,
+        "",
+        `**Enabled:** ${usage.enabled === undefined ? "暂无数据" : String(usage.enabled)}`,
+        usage.displayMessage ? `**Message:** ${usage.displayMessage}` : "",
+        usage.autoModelSelectedDisplayMessage ? `**Auto model:** ${usage.autoModelSelectedDisplayMessage}` : "",
+        usage.namedModelSelectedDisplayMessage ? `**Named model:** ${usage.namedModelSelectedDisplayMessage}` : "",
+        usage.autoBucketModels?.length ? `**Auto bucket models:** ${usage.autoBucketModels.join(", ")}` : "",
+    ].filter(Boolean).join("\n");
+}
+function usageHelpLine(tool) {
+    if (tool === "codex")
+        return "\n发送 **/usage** 查看 Codex 实际存在的 5h/7天用量窗口，以及查询/使用主动重置卡。";
+    if (tool === "cursor")
+        return "\n发送 **/usage** 查看 Cursor 用量。";
+    return "";
+}
+function fastHelpAfterModel(tool) {
+    return tool === "codex"
+        ? "\n发送 **/fast** 查看或切换当前会话的 Fast 模式。"
+        : "";
+}
+function setChatAvatarForSession(platform, chatId, tool, status, sessionId, usageHints) {
+    const fastMode = getEffectiveFastModeForTool(tool, sessionId);
+    if (!usageHints && !fastMode)
+        return platform.setChatAvatar(chatId, tool, status);
+    return platform.setChatAvatar(chatId, tool, status, {
+        ...usageHints,
+        ...(fastMode ? { fastMode: true } : {}),
+    });
+}
+async function sendFastModeStatus(platform, chatId, enabled) {
+    if (platform.kind === "wechat") {
+        const mode = enabled ? "ON (Fast)" : "OFF (Standard)";
+        await platform.sendText(chatId, `Codex Fast 模式: ${mode}\n输入 /fast on 或 /fast off 切换。切换将在下一条消息生效，当前生成不中断。`);
+        return;
+    }
+    await platform.sendRawCard(chatId, buildFastModeCard(enabled));
+}
+async function resolveUsageTarget(chatId) {
+    try {
+        const registry = await loadSessionRegistryForBinding();
+        const record = registry[chatId];
+        const tool = record?.tool;
+        if (tool === "cursor")
+            return { tool: "cursor", sessionId: record?.sessionId };
+        if (tool === "ccc")
+            return { tool: "ccc", sessionId: record?.sessionId };
+        return { tool: "codex", sessionId: record?.sessionId };
+    }
+    catch {
+        return { tool: "codex" };
+    }
+}
+function isOfficialDeepSeek(baseURL) {
+    try {
+        return new URL(baseURL).host === "api.deepseek.com";
+    }
+    catch {
+        return false;
+    }
+}
+async function fetchDeepSeekBalance(apiKey, baseURL) {
+    const apiOrigin = new URL(baseURL).origin;
+    const resp = await fetch(`${apiOrigin}/user/balance`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!resp.ok) {
+        throw new Error(`DeepSeek 余额查询失败: HTTP ${resp.status}`);
+    }
+    return (await resp.json());
+}
+function formatDeepSeekBalance(balance) {
+    if (!balance.is_available)
+        return "**DeepSeek 余额:** 暂无数据";
+    const infos = balance.balance_infos ?? [];
+    if (infos.length === 0)
+        return "**DeepSeek 余额:** 暂无数据";
+    const lines = infos.map((info) => {
+        const parts = [`**${info.currency}:**`];
+        parts.push(`- 总余额: ${info.total_balance}`);
+        if (info.topped_up_balance)
+            parts.push(`- 充值余额: ${info.topped_up_balance}`);
+        if (info.granted_balance)
+            parts.push(`- 赠送余额: ${info.granted_balance}`);
+        return parts.join("\n");
+    });
+    return `**DeepSeek 余额:**\n${lines.join("\n")}`;
+}
+function refreshUsageAvatar(platform, chatId, tool, status, usageHints, sessionId) {
+    setChatAvatarForSession(platform, chatId, tool, status, sessionId, usageHints).catch((err) => {
+        console.warn(`[${ts()}] [AVATAR] usage refresh failed: chatId=${chatId} tool=${tool} ${err.message}`);
+    });
+}
+async function sendUsageSummary(platform, chatId, tool, avatarStatus = "idle", sessionId) {
+    if (tool === "ccc") {
+        const baseURL = config.ccc.DEEPSEEK_BASE_URL;
+        if (!isOfficialDeepSeek(baseURL)) {
+            const msg = "CCC 用量查询仅支持官方 DeepSeek API (api.deepseek.com)，当前使用的非官方接口不支持余额查询。";
+            if (platform.kind === "wechat") {
+                await platform.sendText(chatId, msg).catch(() => { });
+            }
+            else {
+                await platform.sendCard(chatId, "CCC Usage", msg, "blue");
+            }
+            return;
+        }
+        const balance = await fetchDeepSeekBalance(config.ccc.DEEPSEEK_API_KEY, baseURL);
+        const content = formatDeepSeekBalance(balance);
+        if (platform.kind === "wechat") {
+            await platform.sendText(chatId, content).catch(() => { });
+        }
+        else {
+            await platform.sendCard(chatId, "CCC Usage", content, "blue");
+        }
+        return;
+    }
+    if (tool === "cursor") {
+        const usage = await getCursorUsageSummary();
+        const content = formatCursorUsageSummary(usage);
+        if (platform.kind === "wechat") {
+            await platform.sendText(chatId, content).catch(() => { });
+        }
+        else {
+            await platform.sendCard(chatId, "Cursor Usage", content, "blue");
+        }
+        refreshUsageAvatar(platform, chatId, tool, avatarStatus, { cursorUsage: usage }, sessionId);
+        return;
+    }
+    const [usage, chatGptSubscription] = await Promise.all([
+        getCodexUsageSummary(),
+        getChatGptSubscriptionStatus().catch(() => null),
+    ]);
+    const content = formatCodexUsageSummary(usage, chatGptSubscription);
+    if (platform.kind === "wechat") {
+        await platform.sendText(chatId, content).catch(() => { });
+    }
+    else if (platform.kind === "feishu") {
+        await platform.sendRawCard(chatId, buildCodexUsageCard(content, usage.rateLimitResetCreditsAvailable));
+    }
+    else {
+        await platform.sendCard(chatId, "Codex Usage", content, "blue");
+    }
+    refreshUsageAvatar(platform, chatId, tool, avatarStatus, { codexUsage: usage }, sessionId);
+}
+async function sendUsageError(platform, chatId, tool, err) {
+    const toolLabel = tool === "cursor" ? "Cursor" : tool === "ccc" ? "CCC" : "Codex";
+    const message = `${toolLabel} 用量获取失败：${err.message}`;
+    if (platform.kind === "wechat") {
+        await platform.sendText(chatId, message).catch(() => { });
+    }
+    else {
+        await platform.sendCard(chatId, `${toolLabel} Usage`, message, "red");
+    }
+}
+function isUntitledSessionChatName(name) {
+    return name === "新会话" || name.startsWith("新会话-");
+}
+function shouldSendWechatProcessingAck(platform, isCommandText, chatType) {
+    return platform.kind === "wechat" && chatType === "p2p" && !isCommandText;
+}
+/** 飞书私聊是专属会话容器；显式 /new 才创建独立群聊。 */
+function isFeishuP2p(platform, chatType) {
+    return chatType === "p2p" && platform.kind === "feishu";
+}
+async function sendStateCard(platform, chatId, sessionId, toolLabel, traceId) {
+    const status = sessionId ? await getSessionStatus(chatId) : null;
+    const isActive = sessionId ? isSessionRunning(sessionId) : false;
+    const stateLabel = sessionId
+        ? (isActive ? "🟢 运行中" : "⚪ 空闲")
+        : "⚪ 未建立会话";
+    const statusText = [
+        `**群名:** ${status?.chatName || "—"}`,
+        `**Session ID:** ${sessionId ? `\`${status?.sessionId ?? sessionId}\`` : "—"}`,
+        `**工具:** ${toolLabel}`,
+        `**状态:** ${stateLabel}`,
+        `**已对话轮数:** ${status?.turnCount ?? 0}`,
+        `**模型:** ${sessionId ? (status?.model ?? anthropicConfigDisplay(CLAUDE_MODEL)) : "—"}`,
+    ];
+    if (status?.effort != null) {
+        statusText.push(`**Effort:** ${status.effort}`);
+    }
+    if (isActive && status) {
+        const elapsed = Math.floor((Date.now() - status.startTime) / 1000);
+        const mins = Math.floor(elapsed / 60);
+        const secs = elapsed % 60;
+        statusText.push(`**本轮已运行:** ${mins}分${secs}秒`);
+        statusText.push(`**已产出总字符:** ${status.accumulatedLength.toLocaleString()}`);
+    }
+    if (status?.lastContextTokens) {
+        statusText.push(`**上下文 Token 数:** ~${status.lastContextTokens.toLocaleString()}`);
+    }
+    const card = buildStatusCard(statusText.join("\n"), isActive ? "blue" : "green");
+    const ok = await platform.sendRawCard(chatId, card);
+    console.log(`[${ts()}] [STATUS] card sent, ok=${ok}`);
+    logTrace(traceId, "DONE", {
+        outcome: sessionId ? "status" : "status_no_session",
+        ok,
+    });
+}
+// 同一个飞书私聊可能短时间收到多条消息。切换期间共享同一个 Promise，避免
+// 为同一次默认 Agent 变化创建多个空会话。
+const feishuP2pAgentSwitches = new Map();
+async function resolveFeishuP2pAgent(platform, chatId, text, record, traceId) {
+    const desiredTool = resolveDefaultAgentTool();
+    if (record.tool === desiredTool) {
+        return { kind: "ready", sessionId: record.sessionId, tool: record.tool };
+    }
+    if (isSessionRunning(record.sessionId)) {
+        return {
+            kind: "waiting",
+            sessionId: record.sessionId,
+            tool: record.tool,
+            desiredTool,
+        };
+    }
+    const existingSwitch = feishuP2pAgentSwitches.get(chatId);
+    if (existingSwitch)
+        return existingSwitch;
+    const switchOperation = (async () => {
+        try {
+            // 异步创建开始前重新读取一次，防止另一个请求刚完成了绑定切换。
+            const latestRecord = (await loadSessionRegistryForBinding())[chatId];
+            if (!latestRecord?.sessionId || !latestRecord.tool || latestRecord.chatType !== "p2p") {
+                return {
+                    kind: "error",
+                    previousTool: record.tool,
+                    desiredTool,
+                    error: new Error("飞书私聊绑定在切换前已发生变化"),
+                };
+            }
+            if (latestRecord.tool === desiredTool) {
+                return { kind: "ready", sessionId: latestRecord.sessionId, tool: latestRecord.tool };
+            }
+            if (isSessionRunning(latestRecord.sessionId)) {
+                return {
+                    kind: "waiting",
+                    sessionId: latestRecord.sessionId,
+                    tool: latestRecord.tool,
+                    desiredTool,
+                };
+            }
+            const cwd = homedir();
+            const init = await initClaudeSession(desiredTool, cwd);
+            const chatName = sessionChatName(text.slice(0, 10) || "私聊会话", cwd);
+            const switchResult = await switchChatBinding({
+                chatId,
+                chatType: "p2p",
+                oldSessionId: latestRecord.sessionId,
+                newSessionId: init.sessionId,
+                tool: desiredTool,
+                chatName,
+                newDescription: `${sessionPrefixForTool(desiredTool)} ${init.sessionId}`,
+                updateChatInfoFn: (id, name, desc) => platform.updateChatInfo(id, name, desc),
+            });
+            if (!switchResult.ok) {
+                return {
+                    kind: "error",
+                    previousTool: latestRecord.tool,
+                    desiredTool,
+                    error: switchResult.error ?? new Error("更新飞书私聊绑定失败"),
+                };
+            }
+            const previousLabel = toolDisplayName(latestRecord.tool);
+            const desiredLabel = toolDisplayName(desiredTool);
+            logTrace(traceId, "BRANCH", {
+                reason: "switch_feishu_p2p_default_agent",
+                chatId,
+                oldSessionId: latestRecord.sessionId,
+                newSessionId: init.sessionId,
+                oldTool: latestRecord.tool,
+                newTool: desiredTool,
+            });
+            await platform.sendCard(chatId, "默认 Agent 已切换", `检测到默认 Agent 已变化：**${previousLabel} → ${desiredLabel}**。\n\n已创建新的空白 ${desiredLabel} 私聊会话，并从本条消息开始使用。`, "green").catch(() => { });
+            setChatAvatarForSession(platform, chatId, desiredTool, "new", init.sessionId).catch(() => { });
+            return { kind: "ready", sessionId: init.sessionId, tool: desiredTool };
+        }
+        catch (err) {
+            return {
+                kind: "error",
+                previousTool: record.tool,
+                desiredTool,
+                error: err,
+            };
+        }
+    })();
+    feishuP2pAgentSwitches.set(chatId, switchOperation);
+    try {
+        return await switchOperation;
+    }
+    finally {
+        if (feishuP2pAgentSwitches.get(chatId) === switchOperation) {
+            feishuP2pAgentSwitches.delete(chatId);
+        }
+    }
+}
+/** 检测当前进程是否从 npm 全局安装启动 */
+function isRunningFromGlobalNpm() {
+    try {
+        const globalRoot = execSync("npm root -g", { encoding: "utf8", timeout: 5000, windowsHide: true }).trim();
+        return resolve(PROJECT_ROOT).startsWith(resolve(globalRoot));
+    }
+    catch {
+        return false;
+    }
+}
+const UPDATE_LOG = join(homedir(), ".chatccc", "logs", "update-watcher.log");
+function updLog(msg) {
+    const ts = new Date().toISOString();
+    try {
+        appendFileSync(UPDATE_LOG, `${ts} [UPDATE-SYNC] ${msg}\n`, "utf-8");
+    }
+    catch { }
+}
+/** 同步更新 npm 全局包并 spawn 新进程重启。不依赖 systemd 或任何服务管理器。 */
+function syncUpdateAndRestart() {
+    updLog(`sync update start, pid=${process.pid}`);
+    appendStartupTrace("update: sync update start", { pid: process.pid });
+    const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+    // 1. npm update
+    updLog(`running: ${npmCmd} update -g chatccc`);
+    appendStartupTrace("update: npm update begin", { npmCmd });
+    const t0 = Date.now();
+    try {
+        const out = execSync(`${npmCmd} update -g chatccc 2>&1`, { encoding: "utf8", timeout: 120000, windowsHide: true });
+        const elapsed = Date.now() - t0;
+        updLog(`npm update OK (${elapsed}ms): ${out.slice(0, 500)}`);
+        appendStartupTrace("update: npm update OK", { elapsedMs: elapsed, outputLen: out.length });
+    }
+    catch (e) {
+        const elapsed = Date.now() - t0;
+        const err = e;
+        updLog(`npm update failed (${elapsed}ms): message=${err.message}, stderr=${(err.stderr || "").slice(0, 500)}, stdout=${(err.stdout || "").slice(0, 200)}`);
+        appendStartupTrace("update: npm update failed", { elapsedMs: elapsed, message: err.message, stderrLen: (err.stderr || "").length });
+        // fallback
+        updLog(`fallback: ${npmCmd} install -g chatccc@latest`);
+        appendStartupTrace("update: npm install fallback begin", { npmCmd });
+        const t1 = Date.now();
+        try {
+            const out2 = execSync(`${npmCmd} install -g chatccc@latest 2>&1`, { encoding: "utf8", timeout: 120000, windowsHide: true });
+            const elapsed2 = Date.now() - t1;
+            updLog(`npm install fallback OK (${elapsed2}ms): ${out2.slice(0, 500)}`);
+            appendStartupTrace("update: npm install fallback OK", { elapsedMs: elapsed2, outputLen: out2.length });
+        }
+        catch (e2) {
+            const elapsed2 = Date.now() - t1;
+            const err2 = e2;
+            updLog(`npm install fallback also failed (${elapsed2}ms): message=${err2.message}, stderr=${(err2.stderr || "").slice(0, 500)}`);
+            appendStartupTrace("update: npm install fallback failed", { elapsedMs: elapsed2, message: err2.message });
+        }
+    }
+    // 2. resolve bin path
+    const npmPrefix = process.env.NPM_PREFIX || "";
+    const binName = process.platform === "win32" ? "chatccc.cmd" : "chatccc";
+    const binPath = npmPrefix ? join(npmPrefix, binName) : "chatccc";
+    updLog(`bin path: npmPrefix=${npmPrefix || "(empty)"}, binPath=${binPath}`);
+    appendStartupTrace("update: spawn begin", { npmPrefix: npmPrefix || "(empty)", binPath });
+    // 3. spawn new chatccc：优先 node + 全局包入口绝对路径（不依赖 PATH/shell），
+    //    避免继承环境 PATH 异常时秒退；失败时回退到 binPath（走 shell）。
+    try {
+        let spawnSpec = null;
+        if (npmPrefix) {
+            const entry = join(npmPrefix, "node_modules", "chatccc", "bin", "chatccc.mjs");
+            if (existsSync(entry)) {
+                spawnSpec = { command: process.execPath, args: [entry] };
+            }
+        }
+        const child = spawnSpec
+            ? spawn(spawnSpec.command, spawnSpec.args, {
+                detached: true,
+                stdio: "ignore",
+                shell: false,
+                env: createInternalRestartEnv(),
+            })
+            : spawn(binPath, [], {
+                detached: true,
+                stdio: "ignore",
+                shell: true,
+                env: createInternalRestartEnv(),
+            });
+        child.unref();
+        const spawnedAs = spawnSpec ? `${spawnSpec.command} ${spawnSpec.args.join(" ")}` : binPath;
+        updLog(`spawn new chatccc OK, childPid=${child.pid}, bin=${spawnedAs}`);
+        appendStartupTrace("update: spawn OK", {
+            childPid: child.pid,
+            binPath: spawnSpec ? spawnSpec.args[0] : binPath,
+        });
+        return child;
+    }
+    catch (e) {
+        const errMsg = e.message;
+        updLog(`spawn new chatccc failed: ${errMsg}`);
+        appendStartupTrace("update: spawn failed", { error: errMsg });
+        return undefined;
+    }
+}
+// ---------------------------------------------------------------------------
+// /restart — 自重启子进程（不经过 npx/npm，避免 PATH 注入秒退；防空窗兜底）
+// ---------------------------------------------------------------------------
+/** 父进程等待子进程稳定启动的时间窗口（毫秒）。 */
+export const RESTART_CHILD_READY_MS = 3000;
+/**
+ * 构建自重启的 spawn 参数：发布包直接运行编译后的 JavaScript；只有尚未
+ * build 的开发工作区才使用本地 tsx CLI。两种情况都不经过 npx/npm。
+ */
+export function buildRestartSpawnSpec(projectRoot = PROJECT_ROOT) {
+    return resolveChatCccRuntimeSpawnSpec(projectRoot);
+}
+/**
+ * spawn 自重启子进程。
+ *
+ * stdout/stderr 按启动方式分流：
+ * - **终端（TTY）场景**（用户从 cmd/PowerShell/node.exe 窗口启动）：stdio 用
+ *   ["ignore", "inherit", "inherit"] 直接继承终端句柄，restart 后窗口日志不中断。
+ *   终端句柄的生命周期不随父进程退出而关闭，因此不存在 EPIPE 风险。
+ * - **非终端场景**（守护进程/黑匣子等管道或文件启动）：stderr 重定向到磁盘日志
+ *   文件（restart-*.log），子进程继承文件句柄，父进程退出不影响写入。
+ *   不能用 pipe 收集：pipe 读端随父进程退出关闭后，子进程
+ *   再写 stderr（如飞书 SDK 内部 console.warn）会 EPIPE → uncaughtException
+ *   → 整个服务崩溃。若日志文件打开失败，退回 pipe 收集（旧行为），并记录 trace。
+ */
+export function spawnRestartChild(deps = {}) {
+    const projectRoot = deps.projectRoot ?? PROJECT_ROOT;
+    const spawnImpl = deps.spawnImpl ?? spawn;
+    const trace = deps.trace ?? appendStartupTrace;
+    const restartLogDir = deps.restartLogDir ?? LOG_DIR;
+    const isTty = deps.isTty ?? (() => process.stdout.isTTY === true || process.stderr.isTTY === true);
+    const { command, args } = buildRestartSpawnSpec(projectRoot);
+    let stderrFd;
+    const stdio = ["ignore", "ignore", "pipe"];
+    const tty = isTty();
+    if (tty) {
+        // 终端场景：全部 inherit（含 stdin）。注意 stdin 不能是 "ignore"：
+        // Windows 上 detached + stdio[0]=ignore 的组合（DETACHED_PROCESS）会让
+        // 子进程丢失控制台关联，或在部分 Node/libuv 组合下触发 CREATE_NEW_CONSOLE
+        // 弹出新窗口——日志全跑到新窗口，用户当前窗口反而看不到。
+        // 全 inherit 让子进程直接复用当前终端句柄，父进程退出后窗口日志不中断，
+        // 且终端句柄不随父进程退出关闭，天然无 EPIPE 风险。
+        stdio[0] = "inherit";
+        stdio[1] = "inherit";
+        stdio[2] = "inherit";
+    }
+    else {
+        try {
+            mkdirSync(restartLogDir, { recursive: true });
+            const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+            const restartLogPath = join(restartLogDir, `restart-${timestamp}.log`);
+            stderrFd = openSync(restartLogPath, "a");
+            stdio[2] = stderrFd;
+        }
+        catch (err) {
+            trace("restart: stderr log open failed, falling back to pipe", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    // 运行时自检：记录本次 restart 子进程的启动方式，便于确认日志走向。
+    trace("restart: spawn child", {
+        isTty: tty,
+        stdio: JSON.stringify(stdio),
+    });
+    const child = spawnImpl(command, args, {
+        cwd: projectRoot,
+        detached: true,
+        stdio,
+        shell: false,
+        env: createInternalRestartEnv(),
+    });
+    // 子进程已继承 stderr 文件句柄；父进程关闭自己的副本，避免"子进程早退、
+    // 父进程留下继续服务"时 fd 泄漏。
+    if (stderrFd !== undefined) {
+        try {
+            closeSync(stderrFd);
+        }
+        catch { /* ignore */ }
+    }
+    child.on("error", (err) => {
+        trace("restart: spawn error", { error: err.message });
+    });
+    child.on("exit", (code, signal) => {
+        trace("restart: child exit", {
+            childPid: child.pid,
+            code,
+            signal,
+        });
+    });
+    return child;
+}
+/**
+ * 决定父进程是否应退出（防空窗兜底）：
+ * - 窗口内子进程已退出（死亡或信号终止）→ 返回 false，父进程留下继续服务；
+ * - 子进程存活满整个窗口 → 返回 true，父进程退出并把端口让给新进程。
+ */
+export async function decideRestartParentExit(child, timeoutMs, pollMs = 500, trace = appendStartupTrace) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null || child.signalCode !== null) {
+            trace("restart: child died during window, keeping parent", {
+                childPid: child.pid,
+                exitCode: child.exitCode,
+                signalCode: child.signalCode,
+            });
+            return false;
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+    trace("restart: child alive after window, parent exiting", { childPid: child.pid });
+    return true;
+}
+// ---------------------------------------------------------------------------
+// handleCommand — 平台无关的命令分发
+// ---------------------------------------------------------------------------
+export async function handleCommand(platform, text, chatId, openId, msgTimestamp, chatType = "group", traceId, commandId) {
+    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);
+    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}`,
+                "后续新会话会使用最新配置；飞书私聊会在下一条普通消息时跟随默认 Agent，正在生成的会话不会被中断。",
+            ].join("\n")).catch(() => { });
+            logTrace(tid, "DONE", { outcome: "reload", defaultAgent: result.defaultAgent });
+        }
+        catch (err) {
+            await platform.sendText(chatId, `配置重载失败：${err.message}`).catch(() => { });
+            logTrace(tid, "DONE", { outcome: "reload_fail", error: err.message });
+        }
+        return;
+    }
+    if (isCommandText && textLower === "/restart") {
+        logTrace(tid, "BRANCH", { cmd: "/restart" });
+        await platform.sendText(chatId, "重启中...请几秒后发消息唤醒我").catch(() => { });
+        logTrace(tid, "DONE", { outcome: "restart" });
+        appendStartupTrace("restart: spawn begin", { fromPid: process.pid });
+        const child = spawnRestartChild();
+        child.unref();
+        // 子进程存活满窗口才退出父进程；若子进程在窗口内死亡，父进程留下继续
+        // 服务（防空窗），并已把子进程 stderr 写入 startup-trace 供排查。
+        void decideRestartParentExit(child, RESTART_CHILD_READY_MS).then((shouldExit) => {
+            if (!shouldExit)
+                return;
+            appendStartupTrace("restart: parent exit", { childPid: child.pid });
+            process.exit(0);
+        });
+        return;
+    }
+    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;
+        }
+        // `/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 });
+        const child = syncUpdateAndRestart();
+        if (child) {
+            // 子进程存活满窗口才退出父进程；若子进程在窗口内死亡，父进程留下继续
+            // 服务（防空窗）。
+            void decideRestartParentExit(child, RESTART_CHILD_READY_MS).then((shouldExit) => {
+                if (!shouldExit)
+                    return;
+                appendStartupTrace("update: parent exit", { childPid: child.pid });
+                process.exit(0);
+            });
+        }
+        else {
+            // spawn 失败：没有子进程可等，给残留日志写入时间后退出
+            setTimeout(() => process.exit(0), 2000);
+        }
+        return;
+    }
+    if (isCommandText && textLower === "/usage") {
+        const usageTarget = await resolveUsageTarget(chatId);
+        const usageTool = usageTarget.tool;
+        const avatarStatus = usageTarget.sessionId && isSessionRunning(usageTarget.sessionId) ? "busy" : "idle";
+        logTrace(tid, "BRANCH", { cmd: "/usage", tool: usageTool });
+        try {
+            await sendUsageSummary(platform, chatId, usageTool, avatarStatus, usageTarget.sessionId);
+            logTrace(tid, "DONE", { outcome: "usage", tool: usageTool });
+        }
+        catch (err) {
+            await sendUsageError(platform, chatId, usageTool, err);
+            logTrace(tid, "DONE", { outcome: "usage_fail", tool: usageTool, error: err.message });
+        }
+        return;
+    }
+    if (isCommandText && (textLower === "/cd" || textLower.startsWith("/cd "))) {
+        logTrace(tid, "BRANCH", {
+            cmd: "/cd",
+            arg: text.slice(3).trim() || "(none)",
+        });
+        const currentDir = await getDefaultCwd(chatId);
+        // 获取当前会话的实际工作路径（若在会话群内）
+        let sessionCwd;
+        try {
+            const chatInfo = await platform.getChatInfo(chatId);
+            const sessionInfoResult = platform.extractSessionInfo(chatInfo.description);
+            if (sessionInfoResult) {
+                const adapter = getAdapterForTool(sessionInfoResult.tool, sessionInfoResult.sessionId);
+                const info = await adapter.getSessionInfo(sessionInfoResult.sessionId);
+                sessionCwd = info?.cwd;
+            }
+        }
+        catch {
+            /* 非会话群或获取失败，不显示 */
+        }
+        const arg = text.slice(3).trim();
+        // Resolve target directory
+        let targetDir;
+        if (!arg) {
+            targetDir = currentDir;
+        }
+        else if (arg === "..") {
+            targetDir = dirname(currentDir);
+        }
+        else {
+            targetDir = resolve(currentDir, arg);
+        }
+        // Verify the target exists and is a directory
+        try {
+            const s = await stat(targetDir);
+            if (!s.isDirectory()) {
+                logTrace(tid, "DONE", { outcome: "cd_not_dir", targetDir });
+                await platform.sendCard(chatId, "新会话工作路径", `路径存在但不是目录:\n\`${targetDir}\``, "red");
+                return;
+            }
+        }
+        catch {
+            logTrace(tid, "DONE", { outcome: "cd_not_found", targetDir });
+            await platform.sendCard(chatId, "新会话工作路径", `路径不存在:\n\`${targetDir}\``, "red");
+            return;
+        }
+        // Change working dir if user provided a path
+        const isUpdate = !!arg && targetDir !== currentDir;
+        if (isUpdate) {
+            await setDefaultCwd(targetDir, chatId);
+            await addRecentDir(targetDir);
+        }
+        // Read directory entries
+        let entries;
+        try {
+            entries = await readdir(targetDir);
+        }
+        catch (err) {
+            logTrace(tid, "DONE", {
+                outcome: "cd_readdir_fail",
+                error: err.message,
+            });
+            await platform.sendCard(chatId, "新会话工作路径", `无法读取目录:\n\`${targetDir}\`\n\n${err.message}`, "red");
+            return;
+        }
+        // Sort: directories first, then files, alphabetically within each group
+        const withStats = [];
+        for (const name of entries) {
+            try {
+                const s = await stat(resolve(targetDir, name));
+                withStats.push({ name, isDir: s.isDirectory() });
+            }
+            catch {
+                withStats.push({ name, isDir: false });
+            }
+        }
+        withStats.sort((a, b) => {
+            if (a.isDir !== b.isDir)
+                return a.isDir ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+        if (!arg) {
+            // /cd 无参数：展示卡片（含最近使用路径按钮）
+            const recentDirs = await getRecentDirs();
+            const card = buildCdCard(targetDir, withStats, recentDirs, sessionCwd);
+            const ok = await platform.sendRawCard(chatId, card);
+            console.log(`[${ts()}] [CD] card sent, ok=${ok}, recentDirs=${recentDirs.length}`);
+            logTrace(tid, "DONE", { outcome: "cd_card", ok });
+        }
+        else {
+            // /cd <path>：切换目录，发送文本卡片
+            const content = buildCdContent(targetDir, withStats, isUpdate, sessionCwd);
+            await platform.sendCard(chatId, "新会话工作路径", content, "blue");
+            logTrace(tid, "DONE", { outcome: "cd_path", targetDir, isUpdate });
+            // 微信模式下，若用户没有活跃会话，自动创建新会话
+            if (platform.kind === "wechat" && !sessionInfoMap.has(chatId)) {
+                logTrace(tid, "BRANCH", { cmd: "/new", trigger: "auto_after_cd" });
+                await handleCommand(platform, "/new", chatId, openId, msgTimestamp, chatType, traceId);
+            }
+        }
+        return;
+    }
+    if (isCommandText && (textLower === "/new" || textLower.startsWith("/new "))) {
+        const toolArg = text.slice(5).trim().toLowerCase();
+        const tool = toolArg || resolveDefaultAgentTool();
+        logTrace(tid, "BRANCH", { cmd: "/new", tool });
+        const validTools = ["claude", "cursor", "codex", "ccc"];
+        if (!validTools.includes(tool)) {
+            logTrace(tid, "DONE", { outcome: "new_invalid_tool", tool });
+            await platform.sendCard(chatId, "Error", `未知的工具类型: "${toolArg}"。支持: claude (Claude Code), cursor (Cursor), codex (Codex), ccc (CCC Agent)。`, "red");
+            return;
+        }
+        const toolLabel = toolDisplayName(tool);
+        if (!openId) {
+            logTrace(tid, "DONE", { outcome: "new_no_openid" });
+            console.log(`[${ts()}] [WARN] Cannot get sender open_id`);
+            await platform.sendCard(chatId, "Error", "Cannot identify sender.", "red");
+            return;
+        }
+        let sessionId;
+        let sessionCwd;
+        try {
+            const init = await initClaudeSession(tool, undefined, chatId);
+            sessionId = init.sessionId;
+            sessionCwd = init.cwd;
+            console.log(`[${ts()}] [STEP 1/4] ${toolLabel} session created: ${sessionId} → OK`);
+        }
+        catch (err) {
+            console.error(`[${ts()}] [STEP 1/4] FAIL: ${err.message}`);
+            logTrace(tid, "DONE", {
+                outcome: "new_session_fail",
+                error: err.message,
+            });
+            await platform.sendCard(chatId, "Error", `Failed to initialize ${toolLabel} session:\n${err.message}`, "red");
+            return;
+        }
+        const cwd = sessionCwd;
+        const initialName = sessionChatName("新会话", cwd);
+        // /new 的平台语义保持不同：微信在当前私聊新建 session；飞书显式
+        // /new 始终创建独立群聊。飞书私聊自己的常驻 session 不在这里切换。
+        if (chatType === "p2p" && platform.kind === "wechat") {
+            // 先解绑旧 session（如果存在），避免旧 session 的 display loop
+            // 继续往同一个 chat 推送内容（/newh 走 switchChatBinding 已有此逻辑，
+            // 但 /new p2p 之前遗漏了解绑）。
+            const oldRegistry = await loadSessionRegistryForBinding();
+            const oldRecord = oldRegistry[chatId];
+            if (oldRecord?.sessionId && oldRecord.sessionId !== sessionId) {
+                unbindChatFromSession(oldRecord.sessionId, chatId);
+                displayCards.delete(chatId);
+                cancelQueuedMessage(oldRecord.sessionId);
+            }
+            bindChatToSession(sessionId, chatId);
+            sessionInfoMap.set(chatId, {
+                sessionId,
+                turnCount: 0,
+                lastContextTokens: 0,
+                startTime: Date.now(),
+                tool,
+            });
+            await setDefaultCwd(cwd, chatId);
+            await recordSessionRegistry({
+                chatId,
+                sessionId,
+                tool,
+                chatType,
+                chatName: initialName,
+                turnCount: 0,
+                startTime: Date.now(),
+                running: false,
+            });
+            await saveSessionTool(sessionId, tool, initialName);
+            await platform.sendCard(chatId, `${toolLabel} Session Ready`, `这是你的 **${toolLabel}** 私聊会话。\n\n` +
+                `**Session ID:** ${sessionId}\n` +
+                `**工作目录:** \`${cwd}\`\n\n` +
+                `直接在这里发消息即可与 ${toolLabel} 对话。\n\n` +
+                `发送 **/cd** 切换新建会话的默认目录。\n` +
+                `发送 **/model** 查看或切换当前会话的模型。${fastHelpAfterModel(tool)}\n` +
+                `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。\n` +
+                `发送 **/sessions** 查看所有会话状态。\n` +
+                `发送 \`/git <子命令>\` 在本会话工作目录执行 git，例如 \`/git status\`、\`/git log --oneline -n 5\`。` +
+                usageHelpLine(tool), "green");
+            console.log(`[${ts()}] [NEW] P2P session created: ${sessionId} (${toolLabel})`);
+            logTrace(tid, "DONE", {
+                outcome: "session_ready_p2p",
+                chatId,
+                sessionId,
+                tool,
+            });
+            return;
+        }
+        let newChatId;
+        try {
+            newChatId = await platform.createGroup(initialName, [openId]);
+            console.log(`[${ts()}] [STEP 2/4] Created Feishu group: ${newChatId}  → OK`);
+        }
+        catch (err) {
+            console.error(`[${ts()}] [STEP 2/4] FAIL: ${err.message}`);
+            logTrace(tid, "DONE", {
+                outcome: "new_group_fail",
+                error: err.message,
+            });
+            await platform.sendCard(chatId, "Error", `Failed to create group:\n${err.message}`, "red");
+            return;
+        }
+        try {
+            const descPrefix = sessionPrefixForTool(tool);
+            await platform.updateChatInfo(newChatId, initialName, `${descPrefix} ${sessionId}`);
+            console.log(`[${ts()}] [STEP 3/4] Renamed group → name="${initialName}" (${toolLabel}) → OK`);
+        }
+        catch (err) {
+            console.error(`[${ts()}] [STEP 3/4] FAIL: ${err.message}`);
+            logTrace(tid, "DONE", {
+                outcome: "new_rename_fail",
+                error: err.message,
+            });
+            await platform.sendCard(chatId, "Error", `Group created but rename failed:\n${err.message}`, "yellow");
+            return;
+        }
+        // 让新群的默认工作目录继承当前会话的 cwd
+        await setDefaultCwd(cwd, newChatId);
+        bindChatToSession(sessionId, newChatId);
+        await recordSessionRegistry({
+            chatId: newChatId,
+            sessionId,
+            tool,
+            chatType: "group",
+            chatName: initialName,
+            turnCount: 0,
+            startTime: Date.now(),
+            running: false,
+        });
+        await saveSessionTool(sessionId, tool, initialName);
+        await platform.sendCard(newChatId, `${toolLabel} Session Ready`, `群聊已创建，这是你的 **${toolLabel}** 会话群。\n\n` +
+            `**Session ID:** ${sessionId}\n` +
+            `**工作目录:** \`${cwd}\`\n\n` +
+            `直接在这里发消息即可与 ${toolLabel} 对话。\n\n` +
+            `发送 **/cd** 切换新建会话的默认目录。\n` +
+            `发送 **/model** 查看或切换当前会话的模型。${fastHelpAfterModel(tool)}\n` +
+            `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。\n` +
+            `发送 **/sessions** 查看所有会话状态。\n` +
+            `发送 \`/git <子命令>\` 在本会话工作目录执行 git，例如 \`/git status\`、\`/git log --oneline -n 5\`。` +
+            usageHelpLine(tool), "green");
+        console.log(`[${ts()}] [STEP 4/4] Replied to new group → OK`);
+        logTrace(tid, "DONE", {
+            outcome: "session_ready",
+            newChatId,
+            sessionId,
+            tool,
+        });
+        setChatAvatarForSession(platform, newChatId, tool, "new", sessionId).catch(() => { });
+        console.log(`${"=".repeat(60)}`);
+        return;
+    }
+    // 检测会话上下文：群聊从 description 获取，飞书/微信私聊都从
+    // session-registry 获取。私聊 chatId 是稳定容器，进程重启后仍恢复绑定。
+    let sessionId = null;
+    let descriptionTool = null;
+    let toolLabel = null;
+    let pendingFeishuP2pDefaultTool = null;
+    let chatInfo;
+    let description;
+    if (chatType !== "p2p") {
+        try {
+            chatInfo = await platform.getChatInfo(chatId);
+            description = chatInfo.description;
+            const sessionInfo = platform.extractSessionInfo(description);
+            if (sessionInfo) {
+                sessionId = sessionInfo.sessionId;
+                descriptionTool = sessionInfo.tool;
+                toolLabel = toolDisplayName(descriptionTool);
+                // 群描述是群聊会话路由的权威来源。历史群可能早于 registry 创建，
+                // 或在冷启动时没有被重建进内存映射；若只解析 sessionId 而不补绑定，
+                // prompt 虽能启动，却找不到生成卡片目标，收尾也无法清除 running。
+                const registry = await loadSessionRegistryForBinding();
+                const record = registry[chatId];
+                if (record?.sessionId && record.sessionId !== sessionId) {
+                    unbindChatFromSession(record.sessionId, chatId);
+                }
+                bindChatToSession(sessionId, chatId);
+                const memoryInfo = sessionInfoMap.get(chatId);
+                if (!memoryInfo || memoryInfo.sessionId !== sessionId) {
+                    sessionInfoMap.set(chatId, {
+                        sessionId,
+                        tool: descriptionTool,
+                        turnCount: record?.sessionId === sessionId ? record.turnCount : 0,
+                        lastContextTokens: record?.sessionId === sessionId ? record.lastContextTokens : 0,
+                        startTime: record?.sessionId === sessionId
+                            ? record.startTime
+                            : Date.now(),
+                    });
+                }
+                // 同步自愈持久化记录，使下一次重启可以直接重建绑定。running 取实际
+                // 内存状态，顺便修复旧故障遗留的 stale running=true。
+                await recordSessionRegistry({
+                    chatId,
+                    sessionId,
+                    tool: descriptionTool,
+                    chatType,
+                    chatName: chatInfo.name,
+                    running: isSessionRunning(sessionId),
+                });
+            }
+        }
+        catch (err) {
+            logTrace(tid, "BRANCH", {
+                reason: "get_chat_info_failed",
+                error: err.message,
+            });
+            console.log(`[${ts()}] [INFO] Cannot get chat info for ${chatId}: ${err.message}`);
+        }
+    }
+    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) {
+                let resolvedRecord = record;
+                if (platform.kind === "feishu" && !isCommandText && record.chatType === "p2p") {
+                    const resolution = await resolveFeishuP2pAgent(platform, chatId, text, record, tid);
+                    if (resolution.kind === "error") {
+                        const previousLabel = toolDisplayName(resolution.previousTool);
+                        const desiredLabel = toolDisplayName(resolution.desiredTool);
+                        console.error(`[${ts()}] [P2P-SWITCH] ${previousLabel} -> ${desiredLabel} FAIL: ${resolution.error.message}`);
+                        logTrace(tid, "DONE", {
+                            outcome: "switch_feishu_p2p_default_agent_fail",
+                            oldTool: resolution.previousTool,
+                            newTool: resolution.desiredTool,
+                            error: resolution.error.message,
+                        });
+                        await platform.sendCard(chatId, "Agent 切换失败", `无法从 ${previousLabel} 切换到 ${desiredLabel}：\n${resolution.error.message}`, "red").catch(() => { });
+                        return;
+                    }
+                    resolvedRecord = resolution;
+                    if (resolution.kind === "waiting") {
+                        pendingFeishuP2pDefaultTool = resolution.desiredTool;
+                    }
+                }
+                sessionId = resolvedRecord.sessionId;
+                descriptionTool = resolvedRecord.tool;
+                toolLabel = toolDisplayName(descriptionTool);
+                // 确保内存状态在冷启动后恢复；bindChatToSession 是幂等的。
+                if (!sessionInfoMap.has(chatId)) {
+                    sessionInfoMap.set(chatId, {
+                        sessionId,
+                        turnCount: record.turnCount ?? 0,
+                        lastContextTokens: record.lastContextTokens ?? 0,
+                        startTime: record.startTime ?? Date.now(),
+                        tool: descriptionTool,
+                    });
+                }
+                bindChatToSession(sessionId, chatId);
+            }
+        }
+        catch (err) {
+            console.log(`[${ts()}] [INFO] Cannot load registry for p2p ${chatId}: ${err.message}`);
+        }
+    }
+    if (sessionId && descriptionTool && toolLabel) {
+        // 有会话上下文 — 路由到命令处理或 prompt
+        logTrace(tid, "BRANCH", { sessionId, tool: descriptionTool });
+        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}`);
+        if (chatType !== "p2p" &&
+            isUntitledSessionChatName(chatInfo.name) &&
+            !isCommandText) {
+            const MAX_PREFIX = 10;
+            const prefix = text.slice(0, MAX_PREFIX);
+            const adapter = getAdapterForTool(descriptionTool, 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: descriptionTool,
+                    chatName: newName,
+                }).catch(() => { });
+                await saveSessionTool(sessionId, descriptionTool, newName).catch(() => { });
+            }
+            catch (err) {
+                console.error(`[${ts()}] [RENAME] Failed: ${err.message}`);
+            }
+        }
+        // P2P：首条非指令消息只更新 registry 中的展示名，不修改私聊信息。
+        if (chatType === "p2p" &&
+            (platform.kind === "wechat" || platform.kind === "feishu") &&
+            !isCommandText) {
+            try {
+                const reg = await loadSessionRegistryForBinding();
+                const rec = reg[chatId];
+                if (rec &&
+                    rec.sessionId === sessionId &&
+                    isUntitledSessionChatName(rec.chatName ?? "")) {
+                    const MAX_PREFIX = 10;
+                    const prefix = text.slice(0, MAX_PREFIX);
+                    const adapter = getAdapterForTool(descriptionTool, 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: descriptionTool,
+                        chatName: newName2,
+                    }).catch(() => { });
+                    await saveSessionTool(sessionId, descriptionTool, newName2).catch(() => { });
+                    console.log(`[${ts()}] [RENAME] ${platform.kind} P2P → "${newName2}"`);
+                }
+            }
+            catch (err) {
+                console.error(`[${ts()}] [RENAME] ${platform.kind} P2P failed: ${err.message}`);
+            }
+        }
+        if (isCommandText && textLower === "/stop") {
+            logTrace(tid, "BRANCH", { cmd: "/stop" });
+            if (stopSession(sessionId)) {
+                console.log(`[${ts()}] [STOP] User sent /stop, session=${sessionId}`);
+                logTrace(tid, "DONE", { outcome: "stop_requested" });
+            }
+            else {
+                await platform
+                    .sendText(chatId, "当前没有正在进行的会话。")
+                    .catch(() => { });
+                logTrace(tid, "DONE", { outcome: "stop_no_session" });
+            }
+            return;
+        }
+        if (isCommandText && textLower === "/cancel") {
+            logTrace(tid, "BRANCH", { cmd: "/cancel" });
+            if (cancelQueuedMessage(sessionId)) {
+                console.log(`[${ts()}] [CANCEL] Queue cancelled for session=${sessionId}`);
+                await platform.sendText(chatId, "已取消缓存队列中的消息。").catch(() => { });
+                logTrace(tid, "DONE", { outcome: "cancelled" });
+            }
+            else {
+                await platform.sendText(chatId, "当前缓存队列中没有消息。").catch(() => { });
+                logTrace(tid, "DONE", { outcome: "cancel_no_queue" });
+            }
+            return;
+        }
+        if (isCommandText && textLower === "/test") {
+            logTrace(tid, "BRANCH", { cmd: "/test" });
+            const tableHeaders = ["名称", "版本", "状态"];
+            const tableRows = [
+                ["ChatCCC", "0.2.96", "运行中"],
+                ["Claude SDK", "0.50.0", "已连接"],
+                ["Feishu API", "v1", "正常"],
+            ];
+            const mdTable = [
+                `| ${tableHeaders.join(" | ")} |`,
+                `| ${tableHeaders.map(() => "---").join(" | ")} |`,
+                ...tableRows.map((row) => `| ${row.join(" | ")} |`),
+            ].join("\n");
+            if (platform.kind === "feishu") {
+                try {
+                    const token = await getTenantAccessToken();
+                    const postContent = [
+                        // 先尝试富文本表格
+                        [{ tag: "table", cells: [tableHeaders, ...tableRows] }],
+                        // 再用代码块包起来
+                        [{ tag: "text", text: `\n表格（代码块格式）：\n\`\`\`\n${mdTable}\n\`\`\`` }],
+                    ];
+                    await sendPostMessage(token, chatId, "测试表格", postContent);
+                }
+                catch (err) {
+                    console.error(`[${ts()}] [TEST] post message failed: ${err.message}`);
+                    // Fallback to markdown card
+                    await platform.sendText(chatId, `表格（代码块格式）：\n\`\`\`\n${mdTable}\n\`\`\``).catch(() => { });
+                }
+            }
+            else {
+                // WeChat / other platforms: just send code block
+                await platform.sendText(chatId, `表格（代码块格式）：\n\`\`\`\n${mdTable}\n\`\`\``).catch(() => { });
+            }
+            logTrace(tid, "DONE", { outcome: "test" });
+            return;
+        }
+        if (isCommandText && textLower === "/state") {
+            logTrace(tid, "BRANCH", { cmd: "/state" });
+            await sendStateCard(platform, chatId, sessionId, toolLabel, tid);
+            return;
+        }
+        if (isCommandText && textLower === "/sessions") {
+            logTrace(tid, "BRANCH", { cmd: "/sessions" });
+            const allSessions = await getAllSessionsStatus();
+            const now = Date.now();
+            const cardData = allSessions.map((s) => ({
+                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)
+                    : null,
+                model: s.model,
+                tool: s.tool,
+            }));
+            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}`);
+            logTrace(tid, "DONE", { outcome: "sessions", ok, count: cardData.length });
+            return;
+        }
+        if (isCommandText && textLower === "/newh") {
+            logTrace(tid, "BRANCH", { cmd: "/newh" });
+            let cwd;
+            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 状态完全保留)。
+            let newSessionId;
+            try {
+                const init = await initClaudeSession(descriptionTool, cwd);
+                newSessionId = init.sessionId;
+            }
+            catch (err) {
+                logTrace(tid, "DONE", {
+                    outcome: "newh_session_fail",
+                    error: err.message,
+                });
+                await platform.sendCard(chatId, "Error", `Failed to create new session:\n${err.message}`, "red");
+                return;
+            }
+            // 第二步:事务式切换 chat 绑定
+            const descPrefix = sessionPrefixForTool(descriptionTool);
+            const newName = sessionChatName("新会话", cwd);
+            const switchResult = await switchChatBinding({
+                chatId,
+                chatType,
+                oldSessionId: sessionId,
+                newSessionId,
+                tool: descriptionTool,
+                chatName: newName,
+                newDescription: `${descPrefix} ${newSessionId}`,
+                updateChatInfoFn: (cid, name, desc) => platform.updateChatInfo(cid, name, desc),
+            });
+            if (!switchResult.ok) {
+                logTrace(tid, "DONE", {
+                    outcome: "newh_update_chat_fail",
+                    error: switchResult.error?.message,
+                });
+                await platform.sendCard(chatId, "Error", `更新群描述失败,会话未切换(新 session 已创建但未启用):\n${switchResult.error?.message}`, "red");
+                return;
+            }
+            if (chatType !== "p2p") {
+                console.log(`[${ts()}] [NEWH] Group updated: name="${newName}" desc="${descPrefix} ${newSessionId}"`);
+            }
+            setChatAvatarForSession(platform, chatId, descriptionTool, "new", newSessionId).catch(() => { });
+            await platform.sendCard(chatId, `${toolLabel} Session Reset`, `会话已重置为新的 **${toolLabel}** 会话。\n\n` +
+                `**Session ID:** ${newSessionId}\n` +
+                `**工作目录:** \`${cwd}\`${isFeishuP2p(platform, chatType) ? "（飞书私聊固定使用系统用户目录）" : "（沿用当前会话目录）"}\n\n` +
+                `直接在这里发消息即可继续对话。\n` +
+                `发送 **/cd** 可切换新建会话的默认目录。\n` +
+                `发送 **/model** 查看或切换当前会话的模型。${fastHelpAfterModel(descriptionTool)}`, "green");
+            console.log(`[${ts()}] [NEWH] Session ${sessionId} → ${newSessionId} (same cwd=${cwd})`);
+            logTrace(tid, "DONE", { outcome: "newh", newSessionId, cwd });
+            return;
+        }
+        if (isCommandText && textLower === "/deleteg") {
+            logTrace(tid, "BRANCH", { cmd: "/deleteg" });
+            if (chatType === "p2p") {
+                await platform
+                    .sendText(chatId, "私聊无法使用 /deleteg，该指令仅用于群聊。")
+                    .catch(() => { });
+                logTrace(tid, "DONE", { outcome: "deleteg_p2p" });
+                return;
+            }
+            console.log(`[${ts()}] [DELETEG] Disbanding group chat ${chatId}, session=${sessionId}`);
+            // 先解绑 session（不删除 Agent 会话）
+            unbindChatFromSession(sessionId, chatId);
+            displayCards.delete(chatId);
+            sessionInfoMap.delete(chatId);
+            await removeSessionRegistryRecord(chatId);
+            await platform
+                .sendText(chatId, "群聊已解散，Agent 会话保留。")
+                .catch(() => { });
+            // 解散群聊
+            try {
+                await platform.disbandChat(chatId);
+                console.log(`[${ts()}] [DELETEG] Group disbanded: ${chatId}`);
+            }
+            catch (err) {
+                console.error(`[${ts()}] [DELETEG] Disband API failed: ${err.message}`);
+            }
+            logTrace(tid, "DONE", { outcome: "deleteg", chatId, sessionId });
+            return;
+        }
+        // /session <number>：切换到 /sessions 列表中的指定会话
+        const sessionMatch = isCommandText ? textLower.match(/^\/session\s+(\d+)$/) : null;
+        if (sessionMatch) {
+            // 飞书私聊有自己唯一的常驻 session；历史群聊 session 只能回到对应群聊
+            // 继续，禁止通过 /session 把它们重新绑定进私聊。
+            if (isFeishuP2p(platform, chatType)) {
+                await platform.sendCard(chatId, "/session", "飞书私聊不能通过 /session 切换到历史群聊会话；它会在下一条普通消息时跟随默认 Agent。请回到对应群聊继续，或发送 /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((s) => s.tool !== "cursor" && s.tool !== "codex");
+            const cursorOrdered = allSessions.filter((s) => s.tool === "cursor");
+            const codexOrdered = allSessions.filter((s) => s.tool === "codex");
+            const ordered = [
+                ...claudeOrdered,
+                ...cursorOrdered,
+                ...codexOrdered,
+            ];
+            if (ordered.length === 0) {
+                await platform.sendCard(chatId, "/session", "暂无历史会话。", "yellow");
+                logTrace(tid, "DONE", { outcome: "session_no_sessions" });
+                return;
+            }
+            if (index < 0 || index >= ordered.length) {
+                await platform.sendCard(chatId, "/session", `序号超出范围，当前共 ${ordered.length} 个会话。`, "yellow");
+                logTrace(tid, "DONE", {
+                    outcome: "session_out_of_range",
+                    index: index + 1,
+                    total: ordered.length,
+                });
+                return;
+            }
+            const target = ordered[index];
+            // 切换到当前已在使用的会话：no-op，避免解绑再重绑的抖动
+            if (target.sessionId === sessionId) {
+                await platform.sendCard(chatId, "/session", "已经是当前会话。", "green");
+                logTrace(tid, "DONE", { outcome: "session_already_current", sessionId });
+                return;
+            }
+            const targetAdapter = getAdapterForTool(target.tool, target.sessionId);
+            let cwd2;
+            try {
+                const targetInfo = await targetAdapter.getSessionInfo(target.sessionId);
+                cwd2 = targetInfo?.cwd ?? (await getDefaultCwd(chatId));
+            }
+            catch {
+                cwd2 = await getDefaultCwd(chatId);
+            }
+            const descPrefix2 = sessionPrefixForTool(target.tool);
+            const newName2 = target.chatName || sessionChatName("新会话", cwd2);
+            const switchResult = await switchChatBinding({
+                chatId,
+                chatType,
+                oldSessionId: sessionId,
+                newSessionId: target.sessionId,
+                tool: target.tool,
+                chatName: newName2,
+                newDescription: `${descPrefix2} ${target.sessionId}`,
+                initialTurnCount: target.turnCount,
+                initialContextTokens: 0,
+                updateChatInfoFn: (cid, name, desc) => platform.updateChatInfo(cid, name, desc),
+            });
+            if (!switchResult.ok) {
+                logTrace(tid, "DONE", {
+                    outcome: "session_update_chat_fail",
+                    error: switchResult.error?.message,
+                });
+                await platform.sendCard(chatId, "Error", `更新群描述失败,会话未切换:\n${switchResult.error?.message}`, "red");
+                return;
+            }
+            if (chatType !== "p2p") {
+                console.log(`[${ts()}] [SESSION] Switched to session ${target.sessionId} (#${index + 1}), name="${newName2}"`);
+            }
+            setChatAvatarForSession(platform, chatId, target.tool, "new", target.sessionId).catch(() => { });
+            const targetToolLabel = toolDisplayName(target.tool);
+            const busyNote = isSessionRunning(target.sessionId)
+                ? "\n\n⚠️ 该会话当前正在生成中，请等待完成后再发送消息。"
+                : "";
+            await platform.sendCard(chatId, `${targetToolLabel} Session Switched`, `已切换到 **${targetToolLabel}** 会话。\n\n` +
+                `**序号:** ${index + 1}\n` +
+                `**Session ID:** ${target.sessionId}\n` +
+                `**工作目录:** \`${cwd2}\`\n\n` +
+                `直接在这里发消息即可继续对话。\n` +
+                `发送 **/model** 查看或切换当前会话的模型。${fastHelpAfterModel(descriptionTool)}${busyNote}`, "green");
+            logTrace(tid, "DONE", {
+                outcome: "session_switch",
+                sessionId: target.sessionId,
+                index: index + 1,
+                cwd: cwd2,
+            });
+            return;
+        }
+        if (isCommandText && (textLower === "/fast" || textLower.startsWith("/fast "))) {
+            const fastArg = text.slice(5).trim().toLowerCase();
+            logTrace(tid, "BRANCH", { cmd: "/fast", arg: fastArg, sessionId, tool: descriptionTool });
+            if (descriptionTool !== "codex") {
+                const msg = `当前 ${toolLabel} 会话不支持 Fast 模式；/fast 仅适用于 Codex。`;
+                await (platform.kind === "wechat"
+                    ? platform.sendText(chatId, msg)
+                    : platform.sendCard(chatId, "Codex Fast 模式", msg, "yellow")).catch(() => { });
+                logTrace(tid, "DONE", { outcome: "fast_unsupported", tool: descriptionTool });
+                return;
+            }
+            if (fastArg && fastArg !== "on" && fastArg !== "off") {
+                const msg = "用法: /fast、/fast on 或 /fast off";
+                await (platform.kind === "wechat"
+                    ? platform.sendText(chatId, msg)
+                    : platform.sendCard(chatId, "Codex Fast 模式", msg, "yellow")).catch(() => { });
+                logTrace(tid, "DONE", { outcome: "fast_invalid", arg: fastArg });
+                return;
+            }
+            if (fastArg) {
+                setSessionFastModeOverride(sessionId, fastArg === "on");
+            }
+            const enabled = getEffectiveFastModeForTool("codex", sessionId);
+            await sendFastModeStatus(platform, chatId, enabled).catch(() => { });
+            if (fastArg) {
+                const avatarStatus = isSessionRunning(sessionId) ? "busy" : "idle";
+                await platform.setChatAvatar(chatId, "codex", avatarStatus, { fastMode: enabled }).catch((err) => {
+                    console.warn(`[${ts()}] [AVATAR] Fast mode refresh failed: chatId=${chatId} ${err.message}`);
+                });
+            }
+            logTrace(tid, "DONE", {
+                outcome: fastArg ? "fast_switched" : "fast_query",
+                enabled,
+                sessionId,
+            });
+            return;
+        }
+        // /model clear — 清除当前 session 的模型覆盖
+        if (isCommandText && textLower === "/model clear") {
+            logTrace(tid, "BRANCH", { cmd: "/model clear", sessionId });
+            clearSessionModelOverride(sessionId);
+            const defaultModel = getEffectiveModelForTool(descriptionTool);
+            const toolLabel = toolDisplayName(descriptionTool);
+            const msg = `已清除当前 ${toolLabel} 会话的模型覆盖，恢复使用: \`${defaultModel || "(未指定)"}\``;
+            await (platform.kind === "wechat"
+                ? platform.sendText(chatId, msg)
+                : platform.sendCard(chatId, "模型切换", msg, "green")).catch(() => { });
+            logTrace(tid, "DONE", { outcome: "model_cleared", sessionId, tool: descriptionTool });
+            return;
+        }
+        // /model <name> — 切换当前 session 的模型（支持所有 agent，模糊匹配）
+        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 });
+            const models = getAllModelsForTool(descriptionTool);
+            const toolLabel = toolDisplayName(descriptionTool);
+            // 查找目标模型：精确匹配优先，否则子串匹配（模型名越短越优先）
+            const target = findModelMatch(modelArg, models);
+            if (!target) {
+                const msg = models.length > 0
+                    ? `未找到匹配 "${modelArg}" 的模型。当前 ${toolLabel} 可选模型:\n${models.map(m => `  \`${m}\``).join("\n")}`
+                    : `当前 ${toolLabel} 没有可切换的模型。请在 config.json 中配置模型字段。`;
+                await (platform.kind === "wechat"
+                    ? platform.sendText(chatId, msg)
+                    : platform.sendCard(chatId, "模型切换", msg, "red")).catch(() => { });
+                logTrace(tid, "DONE", { outcome: "model_not_found", arg: modelArg, tool: descriptionTool });
+                return;
+            }
+            setSessionModelOverride(sessionId, target);
+            const msg = `已切换当前 ${toolLabel} 会话模型为: \`${target}\``;
+            await (platform.kind === "wechat"
+                ? platform.sendText(chatId, msg)
+                : platform.sendCard(chatId, "模型切换", msg, "green")).catch(() => { });
+            logTrace(tid, "DONE", { outcome: "model_switched", arg: modelArg, target, sessionId, tool: descriptionTool });
+            return;
+        }
+        // /model — 查看当前会话的可用模型（根据会话 Agent 类型）
+        if (isCommandText && textLower === "/model") {
+            logTrace(tid, "BRANCH", { cmd: "/model", sessionId, tool: descriptionTool });
+            const models = getAllModelsForTool(descriptionTool);
+            const currentModel = getEffectiveModelForTool(descriptionTool, sessionId);
+            if (platform.kind === "wechat") {
+                const lines = [currentModel ? `当前模型 (${toolLabel}): ${currentModel}` : `当前模型 (${toolLabel}): 未指定`];
+                if (models.length > 0) {
+                    lines.push("", "可切换模型:");
+                    for (const m of models)
+                        lines.push(`  ${m}`);
+                    lines.push("", "输入 /model <模型名> 切换模型");
+                }
+                else {
+                    lines.push("", "没有可切换的模型。请在 config.json 中配置模型字段。");
+                }
+                if (descriptionTool === "codex") {
+                    lines.push("输入 /fast 查看或切换当前会话的 Fast 模式");
+                }
+                await platform.sendText(chatId, lines.join("\n")).catch(() => { });
+            }
+            else {
+                const card = buildModelCard(currentModel, models, descriptionTool);
+                await platform.sendRawCard(chatId, card);
+            }
+            logTrace(tid, "DONE", { outcome: "model_query", tool: descriptionTool });
+            return;
+        }
+        // /git <args>：在「当前会话工作目录」执行 git 命令
+        if (isCommandText && textLower === "/effort clear") {
+            logTrace(tid, "BRANCH", { cmd: "/effort clear", sessionId, tool: descriptionTool });
+            const efforts = getAllEffortsForTool(descriptionTool);
+            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);
+            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);
+            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);
+            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) {
+                logTrace(tid, "DONE", { outcome: "git_no_args" });
+                await platform.sendCard(chatId, "/git", "用法：`/git <子命令> [参数]`，例如 `/git status`、`/git log --oneline -n 5`。", "yellow");
+                return;
+            }
+            const adapter = getAdapterForTool(descriptionTool, sessionId);
+            let cwd;
+            try {
+                const info = await adapter.getSessionInfo(sessionId);
+                cwd = info?.cwd;
+            }
+            catch (err) {
+                console.error(`[${ts()}] [GIT] getSessionInfo FAIL: ${err.message}`);
+            }
+            if (!cwd) {
+                logTrace(tid, "DONE", { outcome: "git_no_cwd", tool: descriptionTool });
+                const isCursor = descriptionTool === "cursor";
+                const hint = isCursor
+                    ? "无法获取当前 Cursor 会话的工作目录（缺少 sessionId→cwd 持久化映射）。请先在本群发送一条普通消息（让 adapter 从 cursor-agent 流中自动补回 cwd），然后再试 /git；若仍失败，可用 /new 重建会话。"
+                    : `无法获取当前会话的工作目录（${toolLabel} adapter 未返回 cwd）。请先与 AI 对话一次再试，或检查会话是否仍存在。`;
+                await platform.sendCard(chatId, "/git", hint, "red");
+                return;
+            }
+            console.log(`[${ts()}] [GIT] chat=${chatId} cwd=${cwd} cmd="git ${args}" timeoutMs=${GIT_TIMEOUT_MS}`);
+            const result = await runGitCommand(args, cwd, {
+                timeoutMs: GIT_TIMEOUT_MS,
+            });
+            console.log(`[${ts()}] [GIT] exitCode=${result.exitCode}, durationMs=${result.durationMs}, truncated=${result.truncated}, timedOut=${result.timedOut}`);
+            const content = formatGitResult(args, cwd, result);
+            const template = gitResultHeaderTemplate(result);
+            await platform.sendCard(chatId, "/git 输出", content, template);
+            logTrace(tid, "DONE", {
+                outcome: "git_result",
+                exitCode: result.exitCode,
+                durationMs: result.durationMs,
+            });
+            return;
+        }
+        const lastTs = lastMsgTimestamps.get(chatId);
+        if (lastTs !== undefined && msgTimestamp <= lastTs) {
+            logTrace(tid, "DONE", {
+                outcome: "skip_old_message_no_session",
+                msgTimestamp,
+                lastTimestamp: lastTs,
+            });
+            console.log(`[${ts()}] [SKIP] Older message (${msgTimestamp} <= ${lastTs}), no active session, ignoring`);
+            return;
+        }
+        // 并发检查：同一 session 只能有一个活跃 prompt，多余消息进入队列
+        if (isSessionRunning(sessionId)) {
+            const queued = enqueueMessage(sessionId, {
+                text: promptText, chatId, openId, msgTimestamp, chatType, traceId: tid,
+            });
+            if (queued) {
+                logTrace(tid, "QUEUED", { sessionId });
+                console.log(`[${ts()}] [QUEUED] Session ${sessionId} is busy, message from chat ${chatId} enqueued`);
+                if (platform.kind === "wechat") {
+                    await platform.sendText(chatId, "当前会话正在生成中，你的消息已进入缓存队列，生成完成后会立即处理。发送 /cancel 可取消缓存。").catch(() => { });
+                }
+                else {
+                    if (isFeishuP2p(platform, chatType) && pendingFeishuP2pDefaultTool) {
+                        const currentLabel = toolDisplayName(descriptionTool);
+                        const desiredLabel = toolDisplayName(pendingFeishuP2pDefaultTool);
+                        await platform.sendCard(chatId, "Agent 切换等待中", `当前 ${currentLabel} 正在生成；完成后会切换到 ${desiredLabel}，并用新的空会话处理这条消息。\n\n发送 **/cancel** 可取消缓存。`, "blue").catch(() => { });
+                    }
+                    else {
+                        await platform.sendRawCard(chatId, buildQueuedCard(text)).catch(() => { });
+                    }
+                }
+            }
+            else {
+                logTrace(tid, "QUEUE_FULL", { sessionId });
+                console.log(`[${ts()}] [QUEUE_FULL] Session ${sessionId} queue full, rejecting message from chat ${chatId}`);
+                if (platform.kind === "wechat") {
+                    await platform.sendText(chatId, "当前缓存队列中已有消息等待处理，请等待或发送 /stop（停止生成）或 /cancel（取消缓存）。").catch(() => { });
+                }
+                else {
+                    await platform.sendRawCard(chatId, buildQueueFullCard()).catch(() => { });
+                }
+            }
+            return;
+        }
+        if (shouldSendWechatProcessingAck(platform, isCommandText, chatType)) {
+            await platform.sendText(chatId, "生成中...").catch(() => { });
+        }
+        try {
+            logTrace(tid, "RESUME", { sessionId, tool: descriptionTool });
+            const resumeOutcome = await resumeAndPrompt(sessionId, promptText, platform, chatId, msgTimestamp, descriptionTool, tid);
+            if (resumeOutcome === "error") {
+                logTrace(tid, "DONE", { outcome: "resume_error", sessionId });
+                console.error(`[${ts()}] [RESUME] Session ${sessionId} ended with an Agent error`);
+            }
+            else {
+                logTrace(tid, "DONE", { outcome: "resume_done", sessionId, sessionOutcome: resumeOutcome });
+                console.log(`[${ts()}] [RESUME] Session ${sessionId} done (${resumeOutcome})`);
+            }
+        }
+        catch (err) {
+            logTrace(tid, "DONE", {
+                outcome: "resume_fail",
+                error: err.message,
+            });
+            console.error(`[${ts()}] [RESUME] FAIL: ${err.message}`);
+            fileLog.flush();
+            await platform.sendCard(chatId, "Error", `Failed to resume ${toolLabel} session:\n${err.message}`, "red");
+        }
+        return;
+    }
+    if (isCommandText && (textLower === "/fast" || textLower.startsWith("/fast "))) {
+        const defaultTool = resolveDefaultAgentTool();
+        const fastArg = text.slice(5).trim().toLowerCase();
+        if (defaultTool !== "codex") {
+            const msg = `当前默认 Agent (${toolDisplayName(defaultTool)}) 不支持 Fast 模式；/fast 仅适用于 Codex。`;
+            await (platform.kind === "wechat"
+                ? platform.sendText(chatId, msg)
+                : platform.sendCard(chatId, "Codex Fast 模式", msg, "yellow")).catch(() => { });
+            logTrace(tid, "DONE", { outcome: "fast_unsupported", defaultTool });
+            return;
+        }
+        if (fastArg) {
+            const msg = "当前没有绑定 Codex 会话，无法设置会话覆盖。请先创建或进入 Codex 会话；全局默认值可在 Web UI 中设置。";
+            await (platform.kind === "wechat"
+                ? platform.sendText(chatId, msg)
+                : platform.sendCard(chatId, "Codex Fast 模式", msg, "yellow")).catch(() => { });
+            logTrace(tid, "DONE", { outcome: "fast_no_session", arg: fastArg });
+            return;
+        }
+        const enabled = getEffectiveFastModeForTool("codex");
+        await sendFastModeStatus(platform, chatId, enabled).catch(() => { });
+        logTrace(tid, "DONE", { outcome: "fast_query", enabled, defaultTool });
+        return;
+    }
+    // 无会话上下文 → 检查是否是 /model 查询
+    if (isCommandText && textLower === "/model") {
+        const defaultTool = resolveDefaultAgentTool();
+        const models = getAllModelsForTool(defaultTool);
+        let currentModel = "";
+        if (defaultTool === "cursor")
+            currentModel = config.cursor.model;
+        else if (defaultTool === "codex")
+            currentModel = config.codex.model;
+        else if (defaultTool === "ccc")
+            currentModel = config.ccc.model;
+        else
+            currentModel = CLAUDE_MODEL;
+        if (platform.kind === "wechat") {
+            const lines = [currentModel ? `当前模型 (${defaultTool}): ${currentModel}` : `当前模型 (${defaultTool}): 未指定`];
+            if (models.length > 0) {
+                lines.push("", "可切换模型:");
+                for (const m of models)
+                    lines.push(`  ${m}`);
+                lines.push("", "在会话中输入 /model <模型名> 切换模型");
+            }
+            else {
+                lines.push("", "没有可切换的模型。请在 config.json 中配置模型字段。");
+            }
+            if (defaultTool === "codex") {
+                lines.push("输入 /fast 查看当前 Codex Fast 模式");
+            }
+            await platform.sendText(chatId, lines.join("\n")).catch(() => { });
+        }
+        else {
+            const card = buildModelCard(currentModel, models, defaultTool);
+            await platform.sendRawCard(chatId, card);
+        }
+        logTrace(tid, "DONE", { outcome: "model_query", defaultTool });
+        return;
+    }
+    // A private /state query is useful even before the first Agent session exists.
+    // Keep it read-only and render the same status-card shape as established chats.
+    if (isCommandText && textLower === "/state" && isFeishuP2p(platform, chatType)) {
+        logTrace(tid, "BRANCH", { cmd: "/state", scope: "unbound_p2p" });
+        await sendStateCard(platform, chatId, null, toolDisplayName(resolveDefaultAgentTool()), tid);
+        return;
+    }
+    // 无会话上下文 → /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,
+            chatType: s.chatType,
+            active: s.active,
+            turnCount: s.turnCount,
+            elapsedSeconds: s.active
+                ? Math.floor((now - s.startTime) / 1000)
+                : null,
+            model: s.model,
+            tool: s.tool,
+        }));
+        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}`);
+        logTrace(tid, "DONE", { outcome: "sessions", ok, count: cardData.length });
+        return;
+    }
+    // 飞书私聊普通消息：首次使用时在当前私聊创建并持久化一个专属 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.message}`);
+            logTrace(tid, "DONE", {
+                outcome: "auto_new_feishu_p2p_fail",
+                error: err.message,
+            });
+            await platform.sendCard(chatId, "Error", `Failed to create ${toolLabel} private session:\n${err.message}`, "red");
+        }
+        return;
+    }
+    // 无会话上下文 → help card
+    logTrace(tid, "SEND", { method: "help_card", chatId });
+    const card = buildHelpCard(text, { defaultToolLabel: toolDisplayName(resolveDefaultAgentTool()) });
+    const ok = await platform.sendRawCard(chatId, card);
+    if (!ok) {
+        console.error(`[${ts()}] [SEND] help_card FAIL: chatId=${chatId}`);
+        logTrace(tid, "DONE", { outcome: "help_card_fail" });
+    }
+    else {
+        console.log(`[${ts()}] [SEND] help_card OK: chatId=${chatId}`);
+        logTrace(tid, "DONE", { outcome: "help_card_sent" });
+    }
+}