chatccc 0.2.187 → 0.2.188

package/src/index.ts

@@ -142,8 +142,8 @@ function createFeishuAdapter(): PlatformAdapter {
     async disbandChat(chatId) {
       return disbandChat(await auth(), chatId);
     },
-    async setChatAvatar(chatId, tool, status) {
-      return setChatAvatar(await auth(), chatId, tool, status);
+    async setChatAvatar(chatId, tool, status, usageHints) {
+      return setChatAvatar(await auth(), chatId, tool, status, usageHints);
     },
 
     extractSessionInfo(description) {

package/src/orchestrator.ts

@@ -22,9 +22,11 @@ import {
   PROJECT_ROOT,
   anthropicConfigDisplay,
   config,
-  fileLog,
-  getAllModelsForTool,
-  getDefaultCwd,
+  fileLog,
+  getAllEffortsForTool,
+  getAllModelsForTool,
+  getDefaultEffortForTool,
+  getDefaultCwd,
   setDefaultCwd,
   getRecentDirs,
   addRecentDir,
@@ -36,8 +38,9 @@ import {
   type AgentTool,
 } from "./config.ts";
 import {
-  buildHelpCard,
-  buildModelCard,
+  buildHelpCard,
+  buildEffortCard,
+  buildModelCard,
   buildStatusCard,
   buildCdContent,
   buildCdCard,
@@ -52,18 +55,21 @@ import {
   runGitCommand,
 } from "./git-command.ts";
 import {
-  clearSessionModelOverride,
+  clearSessionModelOverride,
+  clearSessionEffortOverride,
   getSessionStatus,
   getAllSessionsStatus,
   initClaudeSession,
   lastMsgTimestamps,
   resumeAndPrompt,
   sessionInfoMap,
-  setSessionModelOverride,
+  setSessionModelOverride,
+  setSessionEffortOverride,
   switchChatBinding,
   recordSessionRegistry,
   getAdapterForTool,
-  getEffectiveModelForTool,
+  getEffectiveModelForTool,
+  getEffectiveEffortForTool,
   stopSession,
   loadSessionRegistryForBinding,
   removeSessionRegistryRecord,
@@ -86,7 +92,7 @@ import { delegateAgentTask } from "./agent-delegate-task.ts";
 import { applySharedPrefix } from "./shared-prefix.ts";
 import { cwdDisplayName, sessionChatName } from "./session-name.ts";
 export { type PlatformAdapter } from "./platform-adapter.ts";
-import type { PlatformAdapter } from "./platform-adapter.ts";
+import type { ChatAvatarUsageHints, PlatformAdapter } from "./platform-adapter.ts";
 import type { CodexUsageSummary } from "./feishu-api.ts";
 
 // ---------------------------------------------------------------------------
@@ -186,6 +192,39 @@ function formatCodexUsageSummary(usage: CodexUsageSummary, chatGptSubscription:
     return lines.join("\n");
   };
 
+  const formatSubscriptionFailureReason = (result: ChatGptSubscriptionResult) => {
+    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;
@@ -221,7 +260,7 @@ function formatCodexUsageSummary(usage: CodexUsageSummary, chatGptSubscription:
     "Codex 用量：",
     "",
     formatChatGptSubscription(),
-    chatGptSubscription?.ok ? "" : "",
+    formatChatGptSubscriptionFailure(),
     formatResetCredits(),
     "",
     formatWindow("5h", usage.fiveHour),
@@ -291,23 +330,46 @@ function usageHelpLine(tool: string): string {
   return "";
 }
 
-async function resolveUsageTool(chatId: string): Promise<"codex" | "cursor"> {
+async function resolveUsageTarget(chatId: string): Promise<{ tool: "codex" | "cursor"; sessionId?: string }> {
   try {
     const registry = await loadSessionRegistryForBinding();
-    return registry[chatId]?.tool === "cursor" ? "cursor" : "codex";
+    const record = registry[chatId];
+    return {
+      tool: record?.tool === "cursor" ? "cursor" : "codex",
+      sessionId: record?.sessionId,
+    };
   } catch {
-    return "codex";
+    return { tool: "codex" };
   }
 }
 
-async function sendUsageSummary(platform: PlatformAdapter, chatId: string, tool: "codex" | "cursor"): Promise<void> {
+function refreshUsageAvatar(
+  platform: PlatformAdapter,
+  chatId: string,
+  tool: "codex" | "cursor",
+  status: "busy" | "idle",
+  usageHints: ChatAvatarUsageHints,
+): void {
+  platform.setChatAvatar(chatId, tool, status, usageHints).catch((err) => {
+    console.warn(`[${ts()}] [AVATAR] usage refresh failed: chatId=${chatId} tool=${tool} ${(err as Error).message}`);
+  });
+}
+
+async function sendUsageSummary(
+  platform: PlatformAdapter,
+  chatId: string,
+  tool: "codex" | "cursor",
+  avatarStatus: "busy" | "idle" = "idle",
+): Promise<void> {
   if (tool === "cursor") {
-    const content = formatCursorUsageSummary(await getCursorUsageSummary());
+    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 });
     return;
   }
 
@@ -323,6 +385,7 @@ async function sendUsageSummary(platform: PlatformAdapter, chatId: string, tool:
   } else {
     await platform.sendCard(chatId, "Codex Usage", content, "blue");
   }
+  refreshUsageAvatar(platform, chatId, tool, avatarStatus, { codexUsage: usage });
 }
 
 async function sendUsageError(platform: PlatformAdapter, chatId: string, tool: "codex" | "cursor", err: unknown): Promise<void> {
@@ -538,10 +601,12 @@ export async function handleCommand(
   }
 
   if (isCommandText && textLower === "/usage") {
-    const usageTool = await resolveUsageTool(chatId);
+    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);
+      await sendUsageSummary(platform, chatId, usageTool, avatarStatus);
       logTrace(tid, "DONE", { outcome: "usage", tool: usageTool });
     } catch (err) {
       await sendUsageError(platform, chatId, usageTool, err);
@@ -1469,7 +1534,96 @@ export async function handleCommand(
     }
 
     // /git <args>：在「当前会话工作目录」执行 git 命令
-    if (isCommandText && (textLower.startsWith("/git ") || textLower === "/git")) {
+    if (isCommandText && textLower === "/effort clear") {
+      logTrace(tid, "BRANCH", { cmd: "/effort clear", sessionId, tool: descriptionTool });
+      const efforts = getAllEffortsForTool(descriptionTool as AgentTool);
+      const toolLabel = toolDisplayName(descriptionTool);
+      if (efforts.length === 0) {
+        const msg = `当前 ${toolLabel} 不支持 effort 切换。`;
+        await (platform.kind === "wechat"
+          ? platform.sendText(chatId, msg)
+          : platform.sendCard(chatId, "Effort 切换", msg, "red")
+        ).catch(() => {});
+        logTrace(tid, "DONE", { outcome: "effort_unsupported", tool: descriptionTool });
+        return;
+      }
+
+      clearSessionEffortOverride(sessionId);
+      const defaultEffort = getDefaultEffortForTool(descriptionTool as AgentTool);
+      const msg = `已清除当前 ${toolLabel} 会话的 effort 覆盖，恢复使用: \`${defaultEffort || "(未指定)"}\``;
+      await (platform.kind === "wechat"
+        ? platform.sendText(chatId, msg)
+        : platform.sendCard(chatId, "Effort 切换", msg, "green")
+      ).catch(() => {});
+      logTrace(tid, "DONE", { outcome: "effort_cleared", sessionId, tool: descriptionTool });
+      return;
+    }
+
+    if (isCommandText && textLower.startsWith("/effort ")) {
+      const effortArg = text.slice(8).trim();
+      if (!effortArg) return;
+      logTrace(tid, "BRANCH", { cmd: "/effort", arg: effortArg, sessionId, tool: descriptionTool });
+
+      const efforts = getAllEffortsForTool(descriptionTool as AgentTool);
+      const toolLabel = toolDisplayName(descriptionTool);
+      if (efforts.length === 0) {
+        const msg = `当前 ${toolLabel} 不支持 effort 切换。`;
+        await (platform.kind === "wechat"
+          ? platform.sendText(chatId, msg)
+          : platform.sendCard(chatId, "Effort 切换", msg, "red")
+        ).catch(() => {});
+        logTrace(tid, "DONE", { outcome: "effort_unsupported", tool: descriptionTool });
+        return;
+      }
+
+      const target = findModelMatch(effortArg, efforts);
+      if (!target) {
+        const msg = `未找到匹配 "${effortArg}" 的 effort。当前 ${toolLabel} 可选 effort:\n${efforts.map(e => `  \`${e}\``).join("\n")}`;
+        await (platform.kind === "wechat"
+          ? platform.sendText(chatId, msg)
+          : platform.sendCard(chatId, "Effort 切换", msg, "red")
+        ).catch(() => {});
+        logTrace(tid, "DONE", { outcome: "effort_not_found", arg: effortArg, tool: descriptionTool });
+        return;
+      }
+
+      setSessionEffortOverride(sessionId, target);
+      const msg = `已切换当前 ${toolLabel} 会话 effort 为: \`${target}\``;
+      await (platform.kind === "wechat"
+        ? platform.sendText(chatId, msg)
+        : platform.sendCard(chatId, "Effort 切换", msg, "green")
+      ).catch(() => {});
+      logTrace(tid, "DONE", { outcome: "effort_switched", arg: effortArg, target, sessionId, tool: descriptionTool });
+      return;
+    }
+
+    if (isCommandText && textLower === "/effort") {
+      logTrace(tid, "BRANCH", { cmd: "/effort", sessionId, tool: descriptionTool });
+      const efforts = getAllEffortsForTool(descriptionTool as AgentTool);
+      const currentEffort = getEffectiveEffortForTool(descriptionTool, sessionId);
+      const toolLabel = toolDisplayName(descriptionTool);
+
+      if (efforts.length === 0) {
+        const msg = `当前 ${toolLabel} 不支持 effort 切换。`;
+        await (platform.kind === "wechat"
+          ? platform.sendText(chatId, msg)
+          : platform.sendCard(chatId, "Effort 切换", msg, "red")
+        ).catch(() => {});
+      } else if (platform.kind === "wechat") {
+        const lines = [currentEffort ? `当前 effort (${toolLabel}): ${currentEffort}` : `当前 effort (${toolLabel}): 未指定`];
+        lines.push("", "可切换 effort:");
+        for (const e of efforts) lines.push(`  ${e}`);
+        lines.push("", "输入 /effort <effort> 切换 effort");
+        await platform.sendText(chatId, lines.join("\n")).catch(() => {});
+      } else {
+        const card = buildEffortCard(currentEffort, efforts, descriptionTool);
+        await platform.sendRawCard(chatId, card);
+      }
+      logTrace(tid, "DONE", { outcome: "effort_query", tool: descriptionTool });
+      return;
+    }
+
+    if (isCommandText && (textLower.startsWith("/git ") || textLower === "/git")) {
       const args = text === "/git" ? "" : text.slice(5).trim();
       logTrace(tid, "BRANCH", { cmd: "/git", args: args || "(none)" });
       if (!args) {
@@ -1627,7 +1781,45 @@ export async function handleCommand(
   }
 
   // 无会话上下文 → /sessions 仍是有效指令，不触发飞书私聊自动建群。
-  if (isCommandText && textLower === "/sessions") {
+  if (isCommandText && textLower === "/effort") {
+    const defaultTool = resolveDefaultAgentTool();
+    const efforts = getAllEffortsForTool(defaultTool);
+    const currentEffort = getDefaultEffortForTool(defaultTool);
+    const toolLabel = toolDisplayName(defaultTool);
+
+    if (efforts.length === 0) {
+      const msg = `当前默认 agent (${toolLabel}) 不支持 effort 切换。`;
+      await (platform.kind === "wechat"
+        ? platform.sendText(chatId, msg)
+        : platform.sendCard(chatId, "Effort 切换", msg, "red")
+      ).catch(() => {});
+    } else if (platform.kind === "wechat") {
+      const lines = [currentEffort ? `当前默认 effort (${toolLabel}): ${currentEffort}` : `当前默认 effort (${toolLabel}): 未指定`];
+      lines.push("", "可切换 effort:");
+      for (const e of efforts) lines.push(`  ${e}`);
+      lines.push("", "在会话中输入 /effort <effort> 切换 effort");
+      await platform.sendText(chatId, lines.join("\n")).catch(() => {});
+    } else {
+      const card = buildEffortCard(currentEffort, efforts, defaultTool);
+      await platform.sendRawCard(chatId, card);
+    }
+    logTrace(tid, "DONE", { outcome: "effort_query", defaultTool });
+    return;
+  }
+
+  if (isCommandText && textLower.startsWith("/effort ")) {
+    const defaultTool = resolveDefaultAgentTool();
+    const toolLabel = toolDisplayName(defaultTool);
+    const msg = `当前没有绑定会话。请先进入 Claude/Codex 会话，再输入 /effort <effort> 切换当前会话的 effort。当前默认 agent: ${toolLabel}`;
+    await (platform.kind === "wechat"
+      ? platform.sendText(chatId, msg)
+      : platform.sendCard(chatId, "Effort 切换", msg, "yellow")
+    ).catch(() => {});
+    logTrace(tid, "DONE", { outcome: "effort_no_session", defaultTool });
+    return;
+  }
+
+  if (isCommandText && textLower === "/sessions") {
     logTrace(tid, "BRANCH", { cmd: "/sessions", scope: "global" });
     const allSessions = await getAllSessionsStatus();
     const now = Date.now();

package/src/platform-adapter.ts

@@ -5,6 +5,14 @@
  * 每个方法内部自行管理认证，消费者不感知 token 等认证细节。
  */
 
+import type { CursorUsageSummary } from "./cursor-usage.ts";
+import type { CodexUsageSummary } from "./feishu-api.ts";
+
+export interface ChatAvatarUsageHints {
+  codexUsage?: CodexUsageSummary | null;
+  cursorUsage?: CursorUsageSummary | null;
+}
+
 export interface PlatformAdapter {
   /** 平台标识，用于区分不同平台的行为（如 wechat、feishu 等） */
   kind?: string;
@@ -40,7 +48,7 @@ export interface PlatformAdapter {
   disbandChat(chatId: string): Promise<void>;
 
   /** 设置群头像 */
-  setChatAvatar(chatId: string, tool: string, status: string): Promise<void>;
+  setChatAvatar(chatId: string, tool: string, status: string, usageHints?: ChatAvatarUsageHints): Promise<void>;
 
   /** 从群描述中提取 session 信息 */
   extractSessionInfo(

package/src/session.ts

@@ -2,10 +2,9 @@ import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 
 import {
-  CLAUDE_API_KEY,
-  CLAUDE_BASE_URL,
-  CLAUDE_EFFORT,
-  CLAUDE_MAX_TURN,
+  CLAUDE_API_KEY,
+  CLAUDE_BASE_URL,
+  CLAUDE_MAX_TURN,
   CLAUDE_MODEL,
   CLAUDE_SUBAGENT_MODEL,
   CHATCCC_PORT,
@@ -15,12 +14,13 @@ import {
   addRecentDir,
   anthropicConfigDisplay,
   config,
-  fileLog,
-  getDefaultCwd,
-  isAnthropicConfigEmpty,
-  toolDisplayName,
-  ts,
-} from "./config.ts";
+  fileLog,
+  getDefaultCwd,
+  getDefaultEffortForTool,
+  isAnthropicConfigEmpty,
+  toolDisplayName,
+  ts,
+} from "./config.ts";
 import { buildProgressCard, getToolEmoji, isCodeBlockOpen, truncateContent } from "./cards.ts";
 import { simplifyToolUse, simplifyToolResult } from "./simplify.ts";
 import { logTrace } from "./trace.ts";
@@ -333,11 +333,14 @@ export function resetState(): void {
   for (const prompt of activePrompts.values()) {
     if (prompt.processMonitor) clearInterval(prompt.processMonitor);
   }
-  activePrompts.clear();
-  displayCards.clear();
-  stopUnifiedDisplayLoop();
-  console.log(`[${ts()}] [RESET] State cleared (dedup + active sessions + bindings)`);
-}
+  activePrompts.clear();
+  displayCards.clear();
+  sessionModelOverrides.clear();
+  sessionEffortOverrides.clear();
+  adapterCache.clear();
+  stopUnifiedDisplayLoop();
+  console.log(`[${ts()}] [RESET] State cleared (dedup + active sessions + bindings)`);
+}
 
 // 注:`rebuildBindingsFromRegistry` 定义在下方与 loadSessionRegistry 同区域,
 // 是 onReady/onReconnected 取代 resetState 的正确入口。
@@ -349,7 +352,8 @@ export function resetState(): void {
 const adapterCache = new Map<string, ToolAdapter>();
 
 // Per-session 模型覆盖（/model 命令设置，不持久化）
-const sessionModelOverrides = new Map<string, string>();
+const sessionModelOverrides = new Map<string, string>();
+const sessionEffortOverrides = new Map<string, string>();
 
 /** 返回 session 的生效模型：优先 per-session 覆盖，其次全局配置（Claude） */
 function getModelForSession(sessionId?: string): string {
@@ -361,15 +365,26 @@ function getModelForSession(sessionId?: string): string {
 }
 
 /** 返回指定 tool 的生效模型：优先 per-session 覆盖，其次 tool 默认配置 */
-export function getEffectiveModelForTool(tool: string, sessionId?: string): string {
-  if (sessionId) {
-    const override = sessionModelOverrides.get(sessionId);
-    if (override) return override;
-  }
+export function getEffectiveModelForTool(tool: string, sessionId?: string): string {
+  if (sessionId) {
+    const override = sessionModelOverrides.get(sessionId);
+    if (override) return override;
+  }
   if (tool === "cursor") return config.cursor.model;
   if (tool === "codex") return config.codex.model;
-  return CLAUDE_MODEL;
-}
+  return CLAUDE_MODEL;
+}
+
+export function getEffectiveEffortForTool(tool: string, sessionId?: string): string {
+  if (sessionId) {
+    const override = sessionEffortOverrides.get(sessionId);
+    if (override) return override;
+  }
+  if (tool === "claude" || tool === "codex") {
+    return getDefaultEffortForTool(tool);
+  }
+  return "";
+}
 
 /** 为指定 session 设置模型覆盖（/model <name>） */
 export function setSessionModelOverride(sessionId: string, model: string): void {
@@ -378,30 +393,41 @@ export function setSessionModelOverride(sessionId: string, model: string): void
 }
 
 /** 清除指定 session 的模型覆盖（/model clear） */
-export function clearSessionModelOverride(sessionId: string): void {
-  sessionModelOverrides.delete(sessionId);
-  adapterCache.clear();
-}
-
-export function getAdapterForTool(tool: string, sessionId?: string): ToolAdapter {
-  const effectiveModel = getEffectiveModelForTool(tool, sessionId);
-  const cacheKey = effectiveModel ? `${tool}:${effectiveModel}` : tool;
-  const cached = adapterCache.get(cacheKey);
-  if (cached) return cached;
-
-  let adapter: ToolAdapter;
-  if (tool === "cursor") {
-    adapter = createCursorAdapter({ model: effectiveModel || undefined });
-  } else if (tool === "codex") {
-    adapter = createCodexAdapter({ model: effectiveModel || undefined });
-  } else {
-    adapter = createClaudeAdapter({
-      model: effectiveModel,
-      subagentModel: CLAUDE_SUBAGENT_MODEL,
-      effort: CLAUDE_EFFORT,
-      apiKey: CLAUDE_API_KEY,
-      baseUrl: CLAUDE_BASE_URL,
-      isEmpty: isAnthropicConfigEmpty,
+export function clearSessionModelOverride(sessionId: string): void {
+  sessionModelOverrides.delete(sessionId);
+  adapterCache.clear();
+}
+
+export function setSessionEffortOverride(sessionId: string, effort: string): void {
+  sessionEffortOverrides.set(sessionId, effort);
+  adapterCache.clear();
+}
+
+export function clearSessionEffortOverride(sessionId: string): void {
+  sessionEffortOverrides.delete(sessionId);
+  adapterCache.clear();
+}
+
+export function getAdapterForTool(tool: string, sessionId?: string): ToolAdapter {
+  const effectiveModel = getEffectiveModelForTool(tool, sessionId);
+  const effectiveEffort = getEffectiveEffortForTool(tool, sessionId);
+  const cacheKey = `${tool}:${effectiveModel || ""}:${effectiveEffort || ""}`;
+  const cached = adapterCache.get(cacheKey);
+  if (cached) return cached;
+
+  let adapter: ToolAdapter;
+  if (tool === "cursor") {
+    adapter = createCursorAdapter({ model: effectiveModel || undefined });
+  } else if (tool === "codex") {
+    adapter = createCodexAdapter({ model: effectiveModel || undefined, effort: effectiveEffort || undefined });
+  } else {
+    adapter = createClaudeAdapter({
+      model: effectiveModel,
+      subagentModel: CLAUDE_SUBAGENT_MODEL,
+      effort: effectiveEffort,
+      apiKey: CLAUDE_API_KEY,
+      baseUrl: CLAUDE_BASE_URL,
+      isEmpty: isAnthropicConfigEmpty,
       maxTurn: CLAUDE_MAX_TURN,
     });
   }
@@ -829,18 +855,18 @@ export async function switchChatBinding(args: SwitchChatBindingArgs): Promise<Sw
 function formatToolConfigForLog(tool: string, sessionModel?: string, sessionId?: string): string {
   if (tool === "cursor") {
     return `model=${sessionModel ?? "(由 cursor-agent 决定，init 事件后学习)"}`;
-  }
-  if (tool === "codex") {
-    const m = config.codex.model;
-    const e = config.codex.effort;
+  }
+  if (tool === "codex") {
+    const m = getEffectiveModelForTool(tool, sessionId);
+    const e = getEffectiveEffortForTool(tool, sessionId);
     const modelStr = m.trim() !== "" ? m : "(由 codex config.toml 决定)";
     const effortStr = e.trim() !== ""
       ? `effort=${e}`
       : "effort=(由 codex config.toml 决定)";
     return `model=${modelStr}, ${effortStr}`;
   }
-  return `model=${anthropicConfigDisplay(getModelForSession(sessionId))}, subagentModel=${anthropicConfigDisplay(CLAUDE_SUBAGENT_MODEL)}, effort=${anthropicConfigDisplay(CLAUDE_EFFORT)}`;
-}
+  return `model=${anthropicConfigDisplay(getModelForSession(sessionId))}, subagentModel=${anthropicConfigDisplay(CLAUDE_SUBAGENT_MODEL)}, effort=${anthropicConfigDisplay(getEffectiveEffortForTool(tool, sessionId))}`;
+}
 
 export async function initClaudeSession(tool: string, overrideCwd?: string, chatId?: string): Promise<{ sessionId: string; cwd: string }> {
   const cwd = overrideCwd ?? (await getDefaultCwd(chatId));
@@ -1754,20 +1780,20 @@ async function resolveModelEffort(
       // adapter 异常时降级为占位符（不阻塞 /state 卡片）
     }
     return { model, effort: null };
-  }
-  if (tool === "codex") {
-    const m = config.codex.model;
-    const e = config.codex.effort;
+  }
+  if (tool === "codex") {
+    const m = getEffectiveModelForTool(tool, sessionId);
+    const e = getEffectiveEffortForTool(tool, sessionId);
     return {
       model: m.trim() !== "" ? m : UNKNOWN_MODEL_PLACEHOLDER,
       effort: e.trim() !== "" ? e : UNKNOWN_MODEL_PLACEHOLDER,
     };
-  }
-  return {
-    model: anthropicConfigDisplay(getModelForSession(sessionId)),
-    effort: anthropicConfigDisplay(CLAUDE_EFFORT),
-  };
-}
+  }
+  return {
+    model: anthropicConfigDisplay(getModelForSession(sessionId)),
+    effort: anthropicConfigDisplay(getEffectiveEffortForTool(tool, sessionId)),
+  };
+}
 
 export async function getSessionStatus(chatId: string): Promise<SessionStatus | null> {
   const info = sessionInfoMap.get(chatId);
@@ -1873,7 +1899,9 @@ export function _setAdapterForToolForTest(tool: string, adapter: ToolAdapter): v
   adapterCache.set(tool, adapter);
   // 同时设置当前配置模型对应的 key（getAdapterForTool 会优先 lookup 含 model 的 key）
   const effective = getEffectiveModelForTool(tool);
-  if (effective) adapterCache.set(`${tool}:${effective}`, adapter);
+  const effort = getEffectiveEffortForTool(tool);
+  adapterCache.set(`${tool}:${effective || ""}:${effort || ""}`, adapter);
+  if (effective) adapterCache.set(`${tool}:${effective}`, adapter);
 }
 
 export function clearAdapterCache(): void {