chatccc 0.2.204 → 0.2.205

package/package.json

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

package/src/__tests__/agent-activity.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  createAgentActivityTracker,
+  formatAgentActivityTitle,
+  updateAgentActivity,
+} from "../agent-activity.ts";
+
+describe("agent activity", () => {
+  it("starts with an explicit startup status", () => {
+    const tracker = createAgentActivityTracker(1_000);
+
+    expect(formatAgentActivityTitle(tracker.activity, 4_000)).toBe("正在启动 Agent · 3秒");
+  });
+
+  it("keeps the thinking timer stable across repeated thinking blocks", () => {
+    const tracker = createAgentActivityTracker(1_000);
+
+    expect(updateAgentActivity(tracker, { type: "thinking", thinking: "first" }, 2_000)).toBe(true);
+    expect(updateAgentActivity(tracker, { type: "thinking", thinking: "second" }, 5_000)).toBe(false);
+    expect(formatAgentActivityTitle(tracker.activity, 8_000)).toBe("思考中 · 6秒");
+  });
+
+  it("shows the active tool name and elapsed time", () => {
+    const tracker = createAgentActivityTracker(1_000);
+
+    updateAgentActivity(tracker, {
+      type: "tool_use",
+      id: "tool-1",
+      name: "Bash",
+      input: { command: "npm test" },
+    }, 3_000);
+
+    expect(formatAgentActivityTitle(tracker.activity, 38_000)).toBe("正在执行 Bash · 35秒");
+  });
+
+  it("tracks parallel tools and keeps the remaining tool after one result", () => {
+    const tracker = createAgentActivityTracker(1_000);
+
+    updateAgentActivity(tracker, { type: "tool_use", id: "read", name: "Read", input: {} }, 2_000);
+    updateAgentActivity(tracker, { type: "tool_use", id: "grep", name: "Grep", input: {} }, 3_000);
+    expect(formatAgentActivityTitle(tracker.activity, 4_000)).toBe("正在执行 Read 等 2 项 · 2秒");
+
+    updateAgentActivity(tracker, {
+      type: "tool_result",
+      tool_use_id: "read",
+      content: "done",
+    }, 5_000);
+    expect(formatAgentActivityTitle(tracker.activity, 7_000)).toBe("正在执行 Grep · 4秒");
+
+    updateAgentActivity(tracker, {
+      type: "tool_result",
+      tool_use_id: "grep",
+      content: "done",
+    }, 8_000);
+    expect(formatAgentActivityTitle(tracker.activity, 10_000)).toBe("正在处理工具结果 · 2秒");
+  });
+
+  it("switches to response and context-compaction statuses", () => {
+    const tracker = createAgentActivityTracker(1_000);
+
+    updateAgentActivity(tracker, { type: "text", text: "answer" }, 2_000);
+    expect(formatAgentActivityTitle(tracker.activity, 3_000)).toBe("正在生成回复 · 1秒");
+
+    updateAgentActivity(tracker, {
+      type: "compact_boundary",
+      trigger: "auto",
+      pre_tokens: 100_000,
+    }, 4_000);
+    expect(formatAgentActivityTitle(tracker.activity, 5_000)).toBe("正在整理上下文 · 1秒");
+  });
+
+  it("formats longer elapsed time without decorative animation", () => {
+    expect(formatAgentActivityTitle({ kind: "thinking", startedAt: 1_000 }, 74_000)).toBe("思考中 · 1分13秒");
+  });
+});

package/src/__tests__/codex-adapter.test.ts

@@ -76,12 +76,12 @@ describe("normalizeCodexMessage", () => {
         status: "in_progress",
       },
     });
-    expect(result).not.toBeNull();
-    expect(result!.type).toBe("assistant");
-    expect(result!.blocks).toEqual([
-      { type: "tool_use", name: "Bash", input: { command: "powershell.exe -Command ls" } },
-    ]);
-  });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("assistant");
+    expect(result!.blocks).toEqual([
+      { type: "tool_use", id: "item_0", name: "Bash", input: { command: "powershell.exe -Command ls" } },
+    ]);
+  });
 
   it("normalizes command_execution completion as tool_result (success)", () => {
     const result = normalizeCodexMessage({
@@ -302,4 +302,4 @@ describe("createCodexAdapter", () => {
     });
     expect(await adapter.getSessionInfo("sid-C")).toBeUndefined();
   });
-});
+});

package/src/__tests__/cursor-adapter.test.ts

@@ -660,11 +660,11 @@ describe("Cursor stream fixture - 端到端不重复", () => {
       session_id: "sid",
       timestamp_ms: 1000,
     } as Parameters<typeof normalizeCursorMessage>[0]);
-    expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([
-      { type: "tool_use", name: "Bash", input: { command: "ls" } },
-    ]);
-  });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toEqual([
+      { type: "tool_use", id: "toolu_abc", name: "Bash", input: { command: "ls" } },
+    ]);
+  });
 
   it("normalizes tool_call completed → tool_result block (success)", () => {
     const result = normalizeCursorMessage({

package/src/__tests__/session.test.ts

@@ -4,10 +4,16 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
 // mock stream-state 以支持在测试中控制累积长度
-const mockStreamStates = new Map<string, {
-  accumulatedContent: string;
-  finalReply: string;
-  status?: "running" | "done" | "stopped" | "error";
+const mockStreamStates = new Map<string, {
+  accumulatedContent: string;
+  finalReply: string;
+  activity?: {
+    kind: "starting" | "thinking" | "tool" | "processing" | "responding" | "compacting";
+    startedAt: number;
+    toolName?: string;
+    toolCount?: number;
+  };
+  status?: "running" | "done" | "stopped" | "error";
   turnCount?: number;
   finalReplySentTurn?: number;
   finalReplySentAt?: number;
@@ -18,8 +24,9 @@ vi.mock("../stream-state.ts", () => ({
     if (!state) return null;
     return {
       sessionId: sid,
-      accumulatedContent: state.accumulatedContent,
-      finalReply: state.finalReply,
+      accumulatedContent: state.accumulatedContent,
+      finalReply: state.finalReply,
+      activity: state.activity,
       finalReplySentTurn: state.finalReplySentTurn,
       finalReplySentAt: state.finalReplySentAt,
       status: state.status ?? "running",
@@ -34,24 +41,31 @@ vi.mock("../stream-state.ts", () => ({
   writeStreamState: async (state: {
     sessionId: string;
     accumulatedContent: string;
-    finalReply: string;
+    finalReply: string;
+    activity?: {
+      kind: "starting" | "thinking" | "tool" | "processing" | "responding" | "compacting";
+      startedAt: number;
+      toolName?: string;
+      toolCount?: number;
+    };
     status?: "running" | "done" | "stopped" | "error";
     turnCount?: number;
     finalReplySentTurn?: number;
     finalReplySentAt?: number;
   }) => {
     mockStreamStates.set(state.sessionId, {
-      accumulatedContent: state.accumulatedContent,
-      finalReply: state.finalReply,
+      accumulatedContent: state.accumulatedContent,
+      finalReply: state.finalReply,
+      activity: state.activity,
       status: state.status,
       turnCount: state.turnCount,
       finalReplySentTurn: state.finalReplySentTurn,
       finalReplySentAt: state.finalReplySentAt,
     });
   },
-  createEmptyStreamState: (sid: string, cwd: string, tool: string, turnCount: number) => ({
-    sessionId: sid, status: "running" as const, accumulatedContent: "", finalReply: "", chunkCount: 0, turnCount, contextTokens: 0, updatedAt: Date.now(), cwd, tool,
-  }),
+  createEmptyStreamState: (sid: string, cwd: string, tool: string, turnCount: number) => ({
+    sessionId: sid, status: "running" as const, accumulatedContent: "", finalReply: "", activity: { kind: "starting" as const, startedAt: Date.now() }, chunkCount: 0, turnCount, contextTokens: 0, updatedAt: Date.now(), cwd, tool,
+  }),
   isFinalReplySentForTurn: (state: { turnCount: number; finalReplySentTurn?: number }) => state.finalReplySentTurn === state.turnCount,
   markFinalReplySent: async (sid: string, turnCount: number, sentAt = Date.now()) => {
     const state = mockStreamStates.get(sid);
@@ -569,7 +583,7 @@ describe("runAgentSession process monitor", () => {
   });
 });
 
-describe("unified display loop WeChat delta", () => {
+describe("unified display loop WeChat delta", () => {
   beforeEach(() => {
     vi.useFakeTimers();
     resetState();
@@ -636,10 +650,76 @@ describe("unified display loop WeChat delta", () => {
       "chat-wechat",
       "tool output",
     );
-  });
-});
-
-describe("unified display loop terminal card update", () => {
+  });
+});
+
+describe("unified display loop activity status", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-07-16T08:00:00.000Z"));
+    resetState();
+    resetBindingState();
+    mockStreamStates.clear();
+  });
+
+  afterEach(() => {
+    stopUnifiedDisplayLoop();
+    resetBindingState();
+    vi.useRealTimers();
+  });
+
+  it("renders explicit activity and elapsed time alongside the liveness dots", async () => {
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+
+    bindChatToSession("sid-activity", "chat-activity");
+    recordLastActiveChat("sid-activity", "chat-activity");
+    sessionInfoMap.set("chat-activity", {
+      sessionId: "sid-activity",
+      turnCount: 1,
+      lastContextTokens: 0,
+      startTime: Date.now() - 12_000,
+      tool: "codex",
+    });
+    displayCards.set("chat-activity", {
+      cardId: "card-activity",
+      sequence: 1,
+      cardBusy: false,
+      cardCreatedAt: Date.now(),
+      lastSentContent: "",
+      streamErrorNotified: false,
+      sessionId: "sid-activity",
+      turnCount: 1,
+      dotCount: 0,
+    });
+    mockStreamStates.set("sid-activity", {
+      accumulatedContent: "正在检查日志",
+      finalReply: "",
+      activity: {
+        kind: "tool",
+        startedAt: Date.now() - 12_000,
+        toolName: "Shell",
+        toolCount: 1,
+      },
+      status: "running",
+      turnCount: 1,
+    });
+
+    startUnifiedDisplayLoop();
+    await vi.advanceTimersByTimeAsync(3_000);
+
+    const payload = vi.mocked(platform.cardUpdate).mock.calls[0]?.[1];
+    expect(payload).toBeTypeOf("string");
+    const card = JSON.parse(payload as string) as {
+      header: { title: { content: string } };
+      body: { elements: Array<{ tag: string; content?: string }> };
+    };
+    expect(card.header.title.content).toBe("正在执行 Shell · 15秒");
+    expect(card.body.elements[0]?.content).toBe("正在检查日志\n。");
+  });
+});
+
+describe("unified display loop terminal card update", () => {
   beforeEach(() => {
     vi.useFakeTimers();
     resetState();

package/src/adapters/codex-adapter.ts

@@ -153,6 +153,7 @@ export function normalizeCodexMessage(
       blocks: [
         {
           type: "tool_use",
+          id: msg.item.id,
           name: "Bash",
           input: { command: msg.item.command },
         },

package/src/adapters/cursor-adapter.ts

@@ -297,6 +297,7 @@ export function normalizeCursorMessage(
         blocks: [
           {
             type: "tool_use",
+            id: msg.call_id,
             name: mapToolCallKey(toolKey),
             input: toolData.args ?? {},
           },

package/src/agent-activity.ts

@@ -0,0 +1,170 @@
+import type { UnifiedBlock } from "./adapters/adapter-interface.ts";
+
+export type AgentActivityKind =
+  | "starting"
+  | "thinking"
+  | "tool"
+  | "processing"
+  | "responding"
+  | "searching"
+  | "compacting";
+
+/** The user-visible activity of a running Agent turn. */
+export interface AgentActivity {
+  kind: AgentActivityKind;
+  /** Time when the current activity began, used for truthful elapsed time. */
+  startedAt: number;
+  toolName?: string;
+  toolCount?: number;
+}
+
+interface ActiveTool {
+  id: string;
+  name: string;
+  startedAt: number;
+}
+
+export interface AgentActivityTracker {
+  activity: AgentActivity;
+  activeTools: Map<string, ActiveTool>;
+  nextAnonymousToolId: number;
+}
+
+export function createAgentActivityTracker(now = Date.now()): AgentActivityTracker {
+  return {
+    activity: { kind: "starting", startedAt: now },
+    activeTools: new Map(),
+    nextAnonymousToolId: 1,
+  };
+}
+
+function sameVisibleActivity(left: AgentActivity, right: AgentActivity): boolean {
+  return left.kind === right.kind
+    && left.toolName === right.toolName
+    && left.toolCount === right.toolCount;
+}
+
+function setActivity(tracker: AgentActivityTracker, next: AgentActivity): boolean {
+  if (sameVisibleActivity(tracker.activity, next)) return false;
+  tracker.activity = next;
+  return true;
+}
+
+function refreshToolActivity(tracker: AgentActivityTracker): boolean {
+  const tools = [...tracker.activeTools.values()];
+  const first = tools[0];
+  if (!first) return false;
+  return setActivity(tracker, {
+    kind: "tool",
+    startedAt: first.startedAt,
+    toolName: first.name,
+    toolCount: tools.length,
+  });
+}
+
+function removeCompletedTool(tracker: AgentActivityTracker, toolUseId: string): void {
+  if (toolUseId && tracker.activeTools.delete(toolUseId)) return;
+
+  // Older adapters did not always include a tool ID. Prefer an anonymous entry;
+  // if there is only one active call, it is still safe to match that result.
+  const anonymousId = [...tracker.activeTools.keys()].find((id) => id.startsWith("anonymous:"));
+  if (anonymousId) {
+    tracker.activeTools.delete(anonymousId);
+  } else if (tracker.activeTools.size === 1) {
+    const onlyId = tracker.activeTools.keys().next().value as string | undefined;
+    if (onlyId) tracker.activeTools.delete(onlyId);
+  }
+}
+
+/**
+ * Applies one normalized Agent event and returns whether the persisted activity
+ * changed. Tool activity takes precedence while a tool call is still active.
+ */
+export function updateAgentActivity(
+  tracker: AgentActivityTracker,
+  block: UnifiedBlock,
+  now = Date.now(),
+): boolean {
+  if (block.type === "tool_use") {
+    const id = block.id || `anonymous:${tracker.nextAnonymousToolId++}`;
+    const existing = tracker.activeTools.get(id);
+    tracker.activeTools.set(id, {
+      id,
+      name: block.name || "未知工具",
+      startedAt: existing?.startedAt ?? now,
+    });
+    return refreshToolActivity(tracker);
+  }
+
+  if (block.type === "tool_result") {
+    removeCompletedTool(tracker, block.tool_use_id);
+    if (tracker.activeTools.size > 0) return refreshToolActivity(tracker);
+    return setActivity(tracker, { kind: "processing", startedAt: now });
+  }
+
+  if (tracker.activeTools.size > 0) return false;
+
+  switch (block.type) {
+    case "thinking":
+    case "redacted_thinking":
+      return setActivity(tracker, { kind: "thinking", startedAt: now });
+    case "text":
+    case "text_final":
+      return setActivity(tracker, { kind: "responding", startedAt: now });
+    case "search_result":
+      return setActivity(tracker, { kind: "searching", startedAt: now });
+    case "compact_boundary":
+      return setActivity(tracker, { kind: "compacting", startedAt: now });
+  }
+}
+
+function formatElapsed(startedAt: number, now: number): string {
+  const totalSeconds = Math.max(0, Math.floor((now - startedAt) / 1000));
+  if (totalSeconds < 60) return `${totalSeconds}秒`;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (totalMinutes < 60) return `${totalMinutes}分${seconds}秒`;
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return `${hours}小时${minutes}分`;
+}
+
+function displayToolName(name: string | undefined): string {
+  const normalized = (name || "未知工具").replace(/\s+/g, " ").trim();
+  return normalized.length > 24 ? `${normalized.slice(0, 23)}…` : normalized;
+}
+
+export function formatAgentActivityTitle(
+  activity: AgentActivity | undefined,
+  now = Date.now(),
+): string {
+  if (!activity) return "正在处理";
+
+  let label: string;
+  switch (activity.kind) {
+    case "starting":
+      label = "正在启动 Agent";
+      break;
+    case "thinking":
+      label = "思考中";
+      break;
+    case "tool": {
+      const count = Math.max(1, activity.toolCount ?? 1);
+      label = `正在执行 ${displayToolName(activity.toolName)}${count > 1 ? ` 等 ${count} 项` : ""}`;
+      break;
+    }
+    case "processing":
+      label = "正在处理工具结果";
+      break;
+    case "responding":
+      label = "正在生成回复";
+      break;
+    case "searching":
+      label = "正在处理搜索结果";
+      break;
+    case "compacting":
+      label = "正在整理上下文";
+      break;
+  }
+  return `${label} · ${formatElapsed(activity.startedAt, now)}`;
+}

package/src/session-chat-binding.ts

@@ -139,8 +139,10 @@ export interface DisplayCardState {
   cardId: string;
   sequence: number;
   cardBusy: boolean;
-  cardCreatedAt: number;
-  lastSentContent: string;
+  cardCreatedAt: number;
+  lastSentContent: string;
+  /** Last rendered activity header; elapsed time can change without body output. */
+  lastSentHeaderTitle?: string;
   streamErrorNotified: boolean;
   /** 所属 session */
   sessionId: string;
@@ -153,8 +155,8 @@ export interface DisplayCardState {
   lastSentAccLen?: number;
   /** WeChat delta: 上次发送时的 finalReply */
   lastSentFinalReply?: string;
-  /** 点点点动画计数器（统一 display loop 每个卡片独立计数） */
-  dotCount: number;
+  /** Liveness animation counter; the explicit activity header conveys Agent state. */
+  dotCount: number;
 }
 
 export const displayCards = new Map<string, DisplayCardState>();

package/src/session.ts

@@ -21,7 +21,12 @@ import {
   toolDisplayName,
   ts,
 } from "./config.ts";
-import { buildProgressCard, getToolEmoji, isCodeBlockOpen, truncateContent } from "./cards.ts";
+import { buildProgressCard, getToolEmoji, isCodeBlockOpen, truncateContent } from "./cards.ts";
+import {
+  createAgentActivityTracker,
+  formatAgentActivityTitle,
+  updateAgentActivity,
+} from "./agent-activity.ts";
 import { simplifyToolUse, simplifyToolResult } from "./simplify.ts";
 import { logTrace } from "./trace.ts";
 import type { UnifiedBlock } from "./adapters/adapter-interface.ts";
@@ -82,18 +87,19 @@ async function sendFinalReplyTextOnce(
   return sent;
 }
 
-async function createVisibleProgressCard(
+async function createVisibleProgressCard(
   platform: PlatformAdapter,
   chatId: string,
   sessionId: string,
-  turnCount: number,
-  notifyFailureText?: string,
-): Promise<string | null> {
+  turnCount: number,
+  notifyFailureText?: string,
+  headerTitle = "正在启动 Agent · 0秒",
+): Promise<string | null> {
   for (let attempt = 1; attempt <= 2; attempt++) {
     let cardId: string | null = null;
     try {
-      cardId = await platform.cardCreate(
-        buildProgressCard("", { showStop: true, headerTitle: "生成中..." }),
+      cardId = await platform.cardCreate(
+        buildProgressCard("等待 Agent 输出...", { showStop: true, headerTitle }),
       );
       if (!cardId) throw new Error("empty card id");
       await platform.cardSend(chatId, cardId);
@@ -1115,29 +1121,33 @@ export async function runAgentSession(
   }
 
   // 初始化 stream-state.json
-  const initialState = createEmptyStreamState(sessionId, cwd, tool, nextTurnCount);
-  await writeStreamState(initialState);
+  const initialState = createEmptyStreamState(sessionId, cwd, tool, nextTurnCount);
+  const activityTracker = createAgentActivityTracker(initialState.activity?.startedAt ?? Date.now());
+  await writeStreamState(initialState);
 
   // 为新 turn 创建第一张展示卡片，同时注册到 turn-cards 持久化。
   // 统一 display loop 始终运行，卡片创建后下一个 tick 即自动开始更新。
   const displayChatIdForNew = pickDisplayChat(sessionId);
-  if (displayChatIdForNew) {
-    const ppNew = platformForChat(displayChatIdForNew);
-    if (ppNew && ppNew.kind !== "wechat") {
-      const cardId = await createVisibleProgressCard(
+  if (displayChatIdForNew) {
+    const ppNew = platformForChat(displayChatIdForNew);
+    if (ppNew && ppNew.kind !== "wechat") {
+      const initialHeaderTitle = formatAgentActivityTitle(activityTracker.activity);
+      const cardId = await createVisibleProgressCard(
         ppNew,
         displayChatIdForNew,
         sessionId,
-        nextTurnCount,
-        "生成中卡片发送失败，结果将以文本形式发送。",
+        nextTurnCount,
+        "生成中卡片发送失败，结果将以文本形式发送。",
+        initialHeaderTitle,
       );
       if (cardId) {
         displayCards.set(displayChatIdForNew, {
           cardId,
           sequence: 1,
           cardBusy: false,
-          cardCreatedAt: Date.now(),
-          lastSentContent: "",
+          cardCreatedAt: Date.now(),
+          lastSentContent: "",
+          lastSentHeaderTitle: initialHeaderTitle,
           streamErrorNotified: false,
           sessionId,
           turnCount: nextTurnCount,
@@ -1179,7 +1189,7 @@ export async function runAgentSession(
   let streamErrored = false;
 
   try {
-    for await (const unifiedMsg of adapter.prompt(sessionId, userTextWithCapabilities, cwd, controller.signal, {
+    for await (const unifiedMsg of adapter.prompt(sessionId, userTextWithCapabilities, cwd, controller.signal, {
       onProcessStart: (processInfo) => {
         startPromptProcessMonitor(sessionId, processInfo);
         if (processInfo.pid !== undefined) registerProcess(processInfo.pid, sessionId);
@@ -1193,8 +1203,10 @@ export async function runAgentSession(
         if (prompt) prompt.closeSession = closeSession;
       },
     })) {
-      for (const block of unifiedMsg.blocks) {
-        accumulateBlockContent(block, state, toolCallMap);
+      let activityChanged = false;
+      for (const block of unifiedMsg.blocks) {
+        if (updateAgentActivity(activityTracker, block)) activityChanged = true;
+        accumulateBlockContent(block, state, toolCallMap);
 
         if (block.type === "compact_boundary" && block.post_tokens) {
           for (const cid of getChatsForSession(sessionId)) {
@@ -1213,13 +1225,14 @@ export async function runAgentSession(
 
       // 定时写入文件
       const now2 = Date.now();
-      if (now2 - lastFileWrite >= FILE_WRITE_INTERVAL_MS) {
-        lastFileWrite = now2;
-        await writeStreamState({
+      if (activityChanged || now2 - lastFileWrite >= FILE_WRITE_INTERVAL_MS) {
+        lastFileWrite = now2;
+        await writeStreamState({
           sessionId,
           status: "running",
-          accumulatedContent: state.accumulatedContent,
-          finalReply: pickFinalReply(state),
+          accumulatedContent: state.accumulatedContent,
+          finalReply: pickFinalReply(state),
+          activity: activityTracker.activity,
           chunkCount: state.chunkCount,
           turnCount: nextTurnCount,
           contextTokens: existingInfo?.lastContextTokens ?? 0,
@@ -1267,8 +1280,9 @@ export async function runAgentSession(
     await writeStreamState({
       sessionId,
       status: finalStatus,
-      accumulatedContent: state.accumulatedContent,
-      finalReply: finalReplyToWrite,
+      accumulatedContent: state.accumulatedContent,
+      finalReply: finalReplyToWrite,
+      activity: activityTracker.activity,
       chunkCount: state.chunkCount,
       turnCount: nextTurnCount,
       contextTokens: existingInfo?.lastContextTokens ?? 0,
@@ -1553,14 +1567,16 @@ export function startUnifiedDisplayLoop(): void {
               }
             } else {
               // 非 WeChat: 卡片流程
-              if (display.turnCount !== state.turnCount) {
+              if (display.turnCount !== state.turnCount) {
                 console.log(`[${ts()}] [DISPLAY] turn mismatch for ${chatId}: display.turnCount=${display.turnCount} state.turnCount=${state.turnCount}, resetting`);
                 finalizeTurnCards(sessionId, display.turnCount, "done").catch(() => {});
                 displayCards.delete(chatId);
-                continue;
-              }
-
-              // 卡片轮转
+                continue;
+              }
+
+              const activityHeaderTitle = formatAgentActivityTitle(state.activity, Date.now());
+
+              // 卡片轮转
               if (Date.now() - display.cardCreatedAt > CARD_ROTATE_MS) {
                 display.cardBusy = true;
                 try {
@@ -1568,8 +1584,9 @@ export function startUnifiedDisplayLoop(): void {
                     p,
                     chatId,
                     sessionId,
-                    display.turnCount,
-                    display.streamErrorNotified ? undefined : "生成中卡片发送失败，结果将继续更新在上一张卡片中。",
+                    display.turnCount,
+                    display.streamErrorNotified ? undefined : "生成中卡片发送失败，结果将继续更新在上一张卡片中。",
+                    activityHeaderTitle,
                   );
                   if (!newCardId) {
                     display.streamErrorNotified = true;
@@ -1577,7 +1594,7 @@ export function startUnifiedDisplayLoop(): void {
                   }
                   const oldSeqBase = display.sequence;
                   const oldContent = state.accumulatedContent + state.finalReply;
-                  const oldCard = buildProgressCard(truncateContent(oldContent) || " ", { showStop: false, headerTitle: "生成中（上轮）" });
+                  const oldCard = buildProgressCard(truncateContent(oldContent) || " ", { showStop: false, headerTitle: "上一阶段记录" });
                   await p.cardUpdate(display.cardId, oldCard, oldSeqBase + 1).then(() => {
                     display.sequence = oldSeqBase + 1;
                   }).catch(err => {
@@ -1588,9 +1605,10 @@ export function startUnifiedDisplayLoop(): void {
                   display.sequence = 1;
                   display.cardCreatedAt = Date.now();
                   display.rotationAccLen = state.accumulatedContent.length;
-                  display.rotationFinalReply = state.finalReply;
-                  display.lastSentContent = "";
-                  display.streamErrorNotified = false;
+                  display.rotationFinalReply = state.finalReply;
+                  display.lastSentContent = "";
+                  display.lastSentHeaderTitle = activityHeaderTitle;
+                  display.streamErrorNotified = false;
                 } catch (err) {
                   console.error(`[${ts()}] [CARDIKT] rotation FAIL for ${chatId}: ${(err as Error).message}`);
                 } finally {
@@ -1608,17 +1626,24 @@ export function startUnifiedDisplayLoop(): void {
                   replyDelta = state.finalReply.slice(rotReply.length);
                 } else {
                   replyDelta = state.finalReply;
-                }
-                const delta = (accDelta + replyDelta).trim();
-
-                display.dotCount = (display.dotCount % 9) + 1;
-                let deltaBase = (delta || "");
-                if (isCodeBlockOpen(deltaBase)) deltaBase += "\n```";
-                const displayContent = deltaBase + "\n" + "。" .repeat(display.dotCount);
-                if (displayContent === display.lastSentContent) continue;
-
-                display.lastSentContent = displayContent;
-                const deltaCard = buildProgressCard(truncateContent(displayContent) || "处理中...", { showStop: true, headerTitle: "生成中..." });
+                }
+                const delta = (accDelta + replyDelta).trim();
+
+                display.dotCount = (display.dotCount % 9) + 1;
+                let deltaBase = delta;
+                if (isCodeBlockOpen(deltaBase)) deltaBase += "\n```";
+                const displayContent = deltaBase + "\n" + "。".repeat(display.dotCount);
+                if (
+                  displayContent === display.lastSentContent
+                  && activityHeaderTitle === display.lastSentHeaderTitle
+                ) continue;
+
+                display.lastSentContent = displayContent;
+                display.lastSentHeaderTitle = activityHeaderTitle;
+                const deltaCard = buildProgressCard(truncateContent(displayContent) || "等待 Agent 输出...", {
+                  showStop: true,
+                  headerTitle: activityHeaderTitle,
+                });
                 display.cardBusy = true;
                 const mySeq = display.sequence + 1;
                 try {
@@ -1637,20 +1662,24 @@ export function startUnifiedDisplayLoop(): void {
                   display.cardBusy = false;
                 }
                 continue;
-              }
-
-              display.dotCount = (display.dotCount % 9) + 1;
-              let contentBase = state.accumulatedContent + state.finalReply;
-              if (isCodeBlockOpen(contentBase)) contentBase += "\n```";
-              const fullContent = contentBase + "\n" + "。".repeat(display.dotCount);
-              if (fullContent === display.lastSentContent) continue;
-
-              display.lastSentContent = fullContent;
-              const cardContent = truncateContent(fullContent);
+              }
+
+              display.dotCount = (display.dotCount % 9) + 1;
+              let contentBase = state.accumulatedContent + state.finalReply;
+              if (isCodeBlockOpen(contentBase)) contentBase += "\n```";
+              const fullContent = contentBase + "\n" + "。".repeat(display.dotCount);
+              if (
+                fullContent === display.lastSentContent
+                && activityHeaderTitle === display.lastSentHeaderTitle
+              ) continue;
+
+              display.lastSentContent = fullContent;
+              display.lastSentHeaderTitle = activityHeaderTitle;
+              const cardContent = truncateContent(fullContent) || "等待 Agent 输出...";
               display.cardBusy = true;
               const mySeq = display.sequence + 1;
               try {
-                const card = buildProgressCard(cardContent, { showStop: true, headerTitle: "生成中..." });
+                const card = buildProgressCard(cardContent, { showStop: true, headerTitle: activityHeaderTitle });
                 await p.cardUpdate(display.cardId, card, mySeq);
                 display.sequence = mySeq;
               } catch (err) {

package/src/stream-state.ts

@@ -1,7 +1,9 @@
 import { readFile, writeFile, mkdir, rename, unlink } from "node:fs/promises";
 import { dirname, join } from "node:path";
 
-import { USER_DATA_DIR, ts } from "./config.ts";
+import { USER_DATA_DIR, ts } from "./config.ts";
+import { createAgentActivityTracker } from "./agent-activity.ts";
+import type { AgentActivity } from "./agent-activity.ts";
 
 // ---------------------------------------------------------------------------
 // stream-state.json — 每个 session 的流式输出持久化文件
@@ -16,7 +18,9 @@ export interface StreamState {
   /** 本轮会话中 LLM 输出的全部文本内容（所有 text block 的累加）。
    *  命名含 "final" 但实为"全部累积文本"，并非仅"最终一段回复"。
    *  参见 session.ts 的 AccumulatorState 注释。 */
-  finalReply: string;
+  finalReply: string;
+  /** Current user-visible work phase for running progress cards. */
+  activity?: AgentActivity;
   /** The turn whose terminal text reply has already been delivered to IM. */
   finalReplySentTurn?: number;
   finalReplySentAt?: number;
@@ -122,16 +126,18 @@ export async function markFinalReplySent(sessionId: string, turnCount: number, s
   await writeStreamState(state);
 }
 
-export function createEmptyStreamState(sessionId: string, cwd: string, tool: string, turnCount: number): StreamState {
-  return {
+export function createEmptyStreamState(sessionId: string, cwd: string, tool: string, turnCount: number): StreamState {
+  const now = Date.now();
+  return {
     sessionId,
     status: "running",
-    accumulatedContent: "",
-    finalReply: "",
+    accumulatedContent: "",
+    finalReply: "",
+    activity: createAgentActivityTracker(now).activity,
     chunkCount: 0,
     turnCount,
     contextTokens: 0,
-    updatedAt: Date.now(),
+    updatedAt: now,
     cwd,
     tool,
   };