@keyou007/agent-bot 0.1.24-alpha.2 → 0.1.24-alpha.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.24-alpha.2",
+  "version": "0.1.24-alpha.4",
   "type": "module",
   "description": "Use Codex, TraeX, and compatible coding agents from Lark/Feishu.",
   "license": "GPL-3.0-only",
@@ -75,6 +75,7 @@
     "dotenv": "17.4.2",
     "highlight.js": "11.12.0",
     "markdown-it": "15.0.1",
+    "mermaid": "11.17.2",
     "pino": "10.3.1",
     "yaml": "2.9.0",
     "zod": "4.4.3"
@@ -83,6 +84,7 @@
     "@types/better-sqlite3": "7.6.13",
     "@types/node": "22.18.11",
     "eslint": "10.6.0",
+    "linkedom": "0.18.13",
     "prettier": "3.9.5",
     "tsx": "4.23.0",
     "typescript": "7.0.2",

package/skills/agent-bot/SKILL.md

@@ -73,6 +73,7 @@ agentbot task title "<title>"
 
 - `prompt` posts the Prompt to the task's Feishu conversation before submitting it.
 - `queue` creates a later turn instead of steering the active turn. `nosteer` is an alias.
+- The Feishu `/status` card includes `Preview` for the active or latest Turn when a saved preview and the file viewer are available; opening it does not switch or control the task.
 - `stop` requests an Agent interrupt; it does not kill the Agent process.
 - `release` sends a Lark confirmation card for releasing the Agent's shared App Server. It never releases automatically; the user must click **Release** or **Release Now** on the card.
 - `dismiss --yes` irreversibly dissolves the task's current Feishu group and archives its current task. Use it only after the user explicitly confirms.
@@ -109,12 +110,16 @@ These commands export only user Prompts and final answers through the latest com
 
 Feishu `/sessions [keyword]` lists and searches tasks across projects and all Providers, not just the App Server's current Provider. Switching Provider does not hide existing tasks; listing still uses paged metadata and the latest Turn summary only.
 
+Feishu group renames update only the group's currently bound task title, not topic or historical tasks. Users may remove generated prefixes or use another format: recognized configured names or matching Agent prefixes yield the task title, otherwise the normalized complete group name is used. A renamed prefix does not change the task's Agent. New-group naming rules are unchanged.
+
 Fork creation stores source-task and branch-Turn references without synchronizing the full local Turn list. The Feishu Turn card reuses local records and loads only the summary pages needed for the requested page, not the entire history. `task turns` loads the first page if necessary and returns available local records. This does not change the Agent's inherited context. Retry listing Turns after a temporary history-read failure; unsupported summary pagination never falls back to downloading full history.
 
 If a TraeX task stops producing output, check its progress card for a pending plan-mode confirmation. `Approve Plan` / `Enter Plan Mode`, `Reject`, and `Cancel Request` require the user's explicit choice, even with automatic permissions. Preview displays the plan but cannot approve it. Cancelling a request does not itself stop the task; waiting turns still block safe restart. Never approve, stop, or force-restart merely to clear that wait. Notifications dropped by an older running version are not automatically replayed after upgrading.
 
 ## Change Settings
 
+Feishu slash commands accept unique prefixes: `/mo`, `/mod`, and `/mode` open the `/model` settings card and do not accept arguments. This is model selection, not an Agent mode switch. CLI `task model [model]` keeps its documented argument behavior.
+
 ```powershell
 agentbot task agent [name]
 agentbot task provider [provider]
@@ -144,6 +149,10 @@ agentbot task reset <turn-id>
 
 In Feishu, `/turn` (also `/turns`) opens history. `/turn <Turn ID>` or `/turn <index>` shows saved runtime details for the current task without resetting, resuming, or interrupting it. Indices match the history card: one-based, newest first, including a running Turn at the top. Missing records use only necessary summary pages; Fork queries stay within the branch anchor. Summary-only external Turns do not contain unrecorded tool output. This does not change the CLI's `task turns [task]` task-reference argument.
 
+The Feishu `/sessions` card also has `SwitchGroup`: create a new group bound to the selected existing task, without forking or creating a new Agent task. Source bindings remain unchanged, and active Agent Bot Turns keep their original delivery route; messages from the new group queue instead of steering them. External active tasks are not taken over.
+
+The Feishu `/sessions` card provides `Turns` for each task, including unbound external tasks. Browsing and pagination never switch, resume, or bind a task; Reset is available only for the current task.
+
 Use `turns` to obtain a real Turn ID before `reset`. Reset changes conversation context only; it does not revert local files. Agent Bot announces an interactive Reset when it starts and queues every new message after its Reaction until the replacement thread is ready.
 
 ## Files And Local Commands
@@ -156,7 +165,7 @@ agentbot task shell "<command>"
 
 Paths are resolved from the selected task's working directory; `~` means the operating-system user's home directory. `file` sends the file to the task's Feishu conversation. `shell` runs in the task directory.
 
-For group mention-only mode:
+For group mention-only mode (ordinary @ Prompts also receive bounded recent text/images from the current group or topic; scan newest to oldest and stop at the first message already submitted to the current task/branch, without reading older pages; requires Feishu history/group-message access; `/mute off` disables enrichment):
 
 ```powershell
 agentbot task mute on|off
@@ -173,6 +182,8 @@ agentbot server restart --task <task> --reason "<reason>"
 agentbot server stop
 ```
 
+In Feishu, `/update` checks npm’s latest stable and Alpha releases and displays exact-version update buttons and release notes. It does not install on its own. Only the configured owner can select an update; choices expire after 30 minutes and never permit downgrade. It is available even when automatic checks are disabled. Let the user choose a version; do not click an update button merely to test this command. Source and npm-link installations can inspect releases but cannot use self-update.
+
 `update` is only for npm-installed Agent Bot packages. It verifies the new package, sends a safe-restart card, waits for active tasks, and restarts immediately when the service is already idle. It automatically restores the prior version if activation fails. It refuses source checkouts and `npm link` installations.
 
 The Feishu service also checks stable npm `latest` once daily at a persisted random time between 10:00 and 17:00 (server local time). A new version sends the owner a private release-notes card with 60 seconds to cancel. If not cancelled, preparation runs in the background and activation waits for tasks, final deliveries, and the quiet inbound window before restarting. Each version is notified once per Profile; cancellation survives restarts. An interrupted countdown resumes with a fresh minute on the same card. No private recipient, unconfirmed notification delivery, or missing release notes means no automatic installation. Source/npm-link protections still apply. Set `updates.enabled: false` in the Profile config and safely restart to disable checks. Do not bypass the countdown or idle gate.

package/src/acp/AcpJsonRpcConnection.ts

@@ -1,3 +1,4 @@
+import { ProtocolLineWarning } from "../utils/ProtocolLineWarning.js";
 import { EventEmitter } from "node:events";
 import readline from "node:readline";
 import type { ChildProcessWithoutNullStreams } from "node:child_process";
@@ -26,6 +27,7 @@ export interface AcpJsonRpcConnectionEvents {
 }
 
 export class AcpJsonRpcConnection extends EventEmitter {
+  private readonly invalidLineWarning = new ProtocolLineWarning();
   private nextId = 1;
   private readonly pending = new Map<string | number, PendingRequest>();
   private readonly handlers = new Map<string, ClientMethodHandler>();
@@ -129,7 +131,7 @@ export class AcpJsonRpcConnection extends EventEmitter {
     try {
       message = JSON.parse(line) as JsonRpcMessage;
     } catch (error) {
-      this.logger.warn({ line, error }, "Ignoring non-JSON ACP stdout line.");
+      this.invalidLineWarning.warn(this.logger, line, "Ignoring non-JSON ACP stdout line.");
       return;
     }
 

package/src/acp/AcpSessionManager.ts

@@ -18,7 +18,6 @@ export interface RuntimeSession {
   acpSessionId: string;
   managed: ManagedAcpProcess;
   running: boolean;
-  modes?: JsonValue;
   configOptions?: JsonValue;
   availableCommands?: JsonValue;
   onUpdate: (session: RuntimeSession, update: Record<string, JsonValue>) => void;
@@ -81,7 +80,6 @@ export class AcpSessionManager {
       acpSessionId: newSessionResult.sessionId,
       managed,
       running: false,
-      modes: newSessionResult.modes,
       configOptions: newSessionResult.configOptions,
       onUpdate: input.onUpdate,
       onPermissionRequest: input.onPermissionRequest,
@@ -147,14 +145,6 @@ export class AcpSessionManager {
     this.processManager.stopAll();
   }
 
-  async setMode(localSessionId: string, modeId: string): Promise<void> {
-    const session = this.requireSession(localSessionId);
-    await session.managed.connection.request("session/set_mode", {
-      sessionId: session.acpSessionId,
-      modeId,
-    });
-  }
-
   async setConfigOption(localSessionId: string, configId: string, value: string): Promise<JsonValue> {
     const session = this.requireSession(localSessionId);
     const result = await session.managed.connection.request<JsonValue>("session/set_config_option", {
@@ -242,13 +232,6 @@ export class AcpSessionManager {
       session.configOptions = update.configOptions;
     }
 
-    if (updateType === "current_mode_update" && session.modes && isObject(session.modes)) {
-      session.modes = {
-        ...session.modes,
-        currentModeId: update.modeId,
-      };
-    }
-
     if (updateType === "available_commands_update" && "availableCommands" in update) {
       session.availableCommands = update.availableCommands;
     }

package/src/acp/acpTypes.ts

@@ -63,7 +63,6 @@ export interface AcpInitializeResult {
 
 export interface AcpSessionNewResult {
   sessionId: string;
-  modes?: JsonValue;
   configOptions?: JsonValue;
 }
 

package/src/cli/SelfUpdateRunner.ts

@@ -24,6 +24,7 @@ export interface SelfUpdatePlan {
   restartService: boolean;
   reason?: string;
   notificationSessionId?: string;
+  notificationTarget?: { contextKey: string; replyMessageId?: string };
   resultPath: string;
   logPath: string;
 }

package/src/cli/SelfUpdater.ts

@@ -316,6 +316,7 @@ export function finalizeSelfUpdatePlan(
     workingDirectory?: string;
     reason?: string;
     notificationSessionId?: string;
+    notificationTarget?: SelfUpdatePlan["notificationTarget"];
   },
 ): void {
   const plan = readSelfUpdatePlan(planPath);
@@ -324,6 +325,7 @@ export function finalizeSelfUpdatePlan(
   plan.restartService = values.restartService;
   if (values.workingDirectory) plan.workingDirectory = values.workingDirectory;
   if (values.reason) plan.reason = values.reason;
+  if (values.notificationTarget) plan.notificationTarget = values.notificationTarget;
   if (values.notificationSessionId)
     plan.notificationSessionId = values.notificationSessionId;
   fs.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}\n`);

package/src/codex/AppServerConnection.ts

@@ -1,3 +1,4 @@
+import { ProtocolLineWarning } from "../utils/ProtocolLineWarning.js";
 import type { ChildProcessWithoutNullStreams } from "node:child_process";
 import readline from "node:readline";
 import type { Logger } from "pino";
@@ -42,6 +43,7 @@ export class AppServerRequestError extends Error {
 }
 
 export class AppServerConnection {
+  private readonly invalidLineWarning = new ProtocolLineWarning();
   private nextId = 1;
   private closed = false;
   private readonly pending = new Map<AppServerRequestId, PendingRequest>();
@@ -108,7 +110,7 @@ export class AppServerConnection {
       try {
         message = JSON.parse(line) as AppServerMessage;
       } catch (error) {
-        this.logger.warn({ line, error }, "Ignoring non-JSON App Server stdout line.");
+        this.invalidLineWarning.warn(this.logger, line, "Ignoring non-JSON App Server stdout line.");
         return;
       }
       this.handleMessage(message);

package/src/codex/CodexEventMapper.ts

@@ -51,7 +51,10 @@ export type MappedCodexNotification =
       activityId: string;
       text: string;
       append: boolean;
+      reasoning?: { itemId: string; summaryIndex: number };
     }
+  | { kind: "reasoning_delta"; threadId: string; turnId: string; itemId: string; contentIndex: number; text: string }
+  | { kind: "reasoning_completed"; threadId: string; turnId: string; itemId: string; summary: string[]; content: string[] }
   | ({ kind: "mode_change_requested"; threadId: string; turnId: string } & z.infer<typeof modeChangeRequest>)
   | ({ kind: "mode_change_resolved"; threadId: string; turnId: string } & z.infer<typeof modeChangeResolution>)
   | { kind: "plan"; threadId: string; turnId: string; steps: PlanStep[] }
@@ -146,16 +149,24 @@ export function mapCodexNotification(method: string, params: unknown): MappedCod
     const text = stringValue(params.delta);
     const itemId = stringValue(params.itemId);
     const summaryIndex = numberValue(params.summaryIndex);
-    if (text === undefined || !itemId || summaryIndex === undefined) return undefined;
+    if (text === undefined || !itemId || !isReasoningIndex(summaryIndex)) return undefined;
     return {
       kind: "progress",
       threadId,
       turnId,
       activityId: `reasoning:${itemId}:${summaryIndex}`,
+      reasoning: { itemId, summaryIndex },
       text,
       append: true,
     };
   }
+  if (method === "item/reasoning/textDelta") {
+    const text = stringValue(params.delta);
+    const itemId = stringValue(params.itemId);
+    const contentIndex = numberValue(params.contentIndex);
+    if (text === undefined || !itemId || !isReasoningIndex(contentIndex)) return undefined;
+    return { kind: "reasoning_delta", threadId, turnId, itemId, contentIndex, text };
+  }
   if (method === "turn/plan/updated" && Array.isArray(params.plan)) {
     const steps = params.plan.flatMap((value): PlanStep[] => {
       if (!isRecord(value) || typeof value.step !== "string") return [];
@@ -164,6 +175,14 @@ export function mapCodexNotification(method: string, params: unknown): MappedCod
     return { kind: "plan", threadId, turnId, steps };
   }
   if ((method === "item/started" || method === "item/completed") && isRecord(params.item)) {
+    if (params.item.type === "reasoning") {
+      if (method !== "item/completed") return undefined;
+      const itemId = stringValue(params.item.id);
+      const summary = reasoningSections(params.item.summary);
+      const content = reasoningSections(params.item.content);
+      if (!itemId || !summary || !content) return undefined;
+      return { kind: "reasoning_completed", threadId, turnId, itemId, summary, content };
+    }
     if (params.item.type === "plan") {
       const itemId = stringValue(params.item.id);
       const text = stringValue(params.item.text);
@@ -213,6 +232,15 @@ export function mapCodexNotification(method: string, params: unknown): MappedCod
   return undefined;
 }
 
+function isReasoningIndex(value: number | undefined): value is number {
+  return value !== undefined && Number.isSafeInteger(value) && value >= 0 && value < 10_000;
+}
+
+function reasoningSections(value: unknown): string[] | undefined {
+  if (value === undefined) return [];
+  return Array.isArray(value) && value.every((section) => typeof section === "string") ? value : undefined;
+}
+
 export function formatCodexError(error: unknown): string | undefined {
   if (!isRecord(error)) return undefined;
   const message = stringValue(error.message)?.trim();

package/src/codex/CodexRuntime.ts

@@ -16,6 +16,7 @@ import type {
   RemoteSessionPage,
   RemoteSessionSummary,
   RemoteTurnPage,
+  RemoteTurnDetails,
   ResumeRuntimeSessionInput,
   RuntimeGoal,
   RuntimeGoalUpdate,
@@ -398,6 +399,48 @@ export class CodexRuntime implements AgentRuntime {
     };
   }
 
+  async readRemoteTurn(remoteSessionId: string, turnId: string): Promise<RemoteTurnDetails> {
+    const client = await this.client();
+    const seenCursors = new Set<string>();
+    let cursor: string | undefined;
+    do {
+      const page = await this.readTurnPage(client, remoteSessionId, {
+        cursor, limit: 50, itemsView: "summary",
+      }, CONTROL_REQUEST_TIMEOUT_MS);
+      const index = page.data.findIndex((turn) => turn.id === turnId);
+      if (index >= 0) {
+        // Cursors are opaque; ask for the prefix to obtain the target's boundary.
+        if (index > 0) {
+          const prefix = await this.readTurnPage(client, remoteSessionId, {
+            cursor, limit: index, itemsView: "summary",
+          }, CONTROL_REQUEST_TIMEOUT_MS);
+          if (!prefix.nextCursor || prefix.data.at(-1)?.id !== page.data[index - 1]?.id) {
+            throw new Error("轮次历史发生变化，请重新打开重试。");
+          }
+          cursor = prefix.nextCursor;
+        }
+        const full = await this.readTurnPage(client, remoteSessionId, {
+          cursor, limit: 1, itemsView: "full",
+        }, CONTROL_REQUEST_TIMEOUT_MS);
+        const turn = full.data[0];
+        if (!turn || turn.id !== turnId) throw new Error("轮次历史发生变化，请重新打开重试。");
+        if (turn.itemsView === "summary" || !Array.isArray(turn.items)) {
+          throw new Error("Agent 未返回完整的轮次执行记录。");
+        }
+        if (turn.status === "inProgress") throw new Error("该历史轮次仍在执行，请稍后重试。");
+        return remoteTurnDetails(remoteSessionId, turn);
+      }
+      const nextCursor = page.nextCursor ?? undefined;
+      if (!nextCursor) break;
+      if (nextCursor === cursor || seenCursors.has(nextCursor)) {
+        throw new Error("App Server repeated a Turn history cursor.");
+      }
+      seenCursors.add(nextCursor);
+      cursor = nextCursor;
+    } while (cursor);
+    throw new Error(`Agent 历史中未找到 Turn：${turnId}`);
+  }
+
   async *readConversation(remoteSessionId: string, throughTurnId?: string): AsyncIterable<ConversationTurn> {
     const client = await this.client();
     const seenCursors = new Set<string>();
@@ -1211,12 +1254,19 @@ export class CodexRuntime implements AgentRuntime {
         append: false,
         severity: "warning",
       });
+    } else if (mapped.kind === "reasoning_delta") {
+      this.emit({ type: "reasoning_delta", sessionId, turnId: mapped.turnId,
+        itemId: mapped.itemId, contentIndex: mapped.contentIndex, text: mapped.text });
+    } else if (mapped.kind === "reasoning_completed") {
+      this.emit({ type: "reasoning_completed", sessionId, turnId: mapped.turnId,
+        itemId: mapped.itemId, summary: mapped.summary, content: mapped.content });
     } else if (mapped.kind === "progress") {
       this.emit({
         type: "progress",
         sessionId,
         turnId: mapped.turnId,
         activityId: mapped.activityId,
+        ...(mapped.reasoning ? { reasoning: mapped.reasoning } : {}),
         text: mapped.text,
         append: mapped.append,
       });
@@ -1626,6 +1676,8 @@ interface CodexThreadSnapshot {
 
 interface CodexTurnSnapshot {
   id: string;
+  itemsView?: "summary" | "full";
+  completedAt?: number | null;
   status: "completed" | "interrupted" | "failed" | "inProgress";
   items?: Array<{
     id?: string;
@@ -1722,6 +1774,41 @@ function turnStartedAt(turn: CodexTurnSnapshot): number {
   return typeof turn.startedAt === "number" ? turn.startedAt * 1_000 : Date.now();
 }
 
+function remoteTurnDetails(remoteSessionId: string, turn: CodexTurnSnapshot): RemoteTurnDetails {
+  const items: RemoteTurnDetails["items"] = [];
+  const finalMessages = new Set(finalResponseMessages(turn));
+  for (const [index, item] of (turn.items ?? []).entries()) {
+    const id = item.id ?? `history:${index}`;
+    if (item.type === "userMessage") {
+      const content: unknown[] = item.content ?? [];
+      const text = content.flatMap((block) => isRecord(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("\n");
+      const localImagePaths = content.flatMap((block) => isRecord(block) && block.type === "localImage" && typeof block.path === "string" ? [block.path] : []);
+      items.push({ kind: "message", id, role: "user", text, ...(localImagePaths.length ? { localImagePaths } : {}) });
+      continue;
+    }
+    if (item.type === "agentMessage") {
+      if (!finalMessages.has(item) && item.text) items.push({ kind: "message", id, role: "assistant", text: item.text });
+      continue;
+    }
+    const mapped = mapCodexNotification("item/completed", { threadId: remoteSessionId, turnId: turn.id, item });
+    if (mapped?.kind === "tool") items.push({ kind: "tool", tool: mapped.tool });
+    else if (mapped?.kind === "reasoning_completed") {
+      items.push({ kind: "reasoning", id: mapped.itemId, summary: mapped.summary, content: mapped.content });
+    } else if (mapped?.kind === "progress") items.push({ kind: "message", id, role: "assistant", text: mapped.text });
+    else if (mapped?.kind === "plan") items.push({ kind: "plan", steps: mapped.steps });
+  }
+  return {
+    turnId: turn.id,
+    status: turn.status === "failed" ? "failed" : turn.status === "interrupted" ? "cancelled" : "completed",
+    startedAt: typeof turn.startedAt === "number" ? turn.startedAt * 1_000 : undefined,
+    completedAt: typeof turn.completedAt === "number" ? turn.completedAt * 1_000 : undefined,
+    durationMs: turn.durationMs ?? undefined,
+    finalResponse: appendGeneratedImageMarkdown(extractFinalResponse(turn), extractGeneratedImagePaths(turn)),
+    error: formatCodexError(turn.error),
+    items,
+  };
+}
+
 function extractFinalResponse(turn: CodexTurnSnapshot): string {
   return finalResponseMessages(turn).map((item) => item.text!.trim()).join("\n\n");
 }

package/src/commands/CommandRouter.ts

@@ -29,6 +29,7 @@ export const COMMAND_NAMES = [
   "thinking",
   "title",
   "turns",
+  "update",
 ] as const;
 
 type CommandName = (typeof COMMAND_NAMES)[number];
@@ -41,8 +42,6 @@ const COMMAND_INITIALISMS: Partial<Record<CommandName, string>> = {
   nosteer: "ns",
 };
 
-const DISABLED_COMMAND_NAMES = new Set(["mode", "modes"]);
-
 export class CommandRouter {
   parse(text: string): Command {
     const trimmed = text.trim();
@@ -121,6 +120,9 @@ export class CommandRouter {
         if (args.length === 0) return { type: "restart" };
         if (args.length === 1 && args[0] === "--force") return { type: "restart", force: true };
         throw new Error("/restart 只接受一个可选的 --force 参数。");
+      case "update":
+        if (args.length > 0) throw new Error("/update 不接受参数，请在卡片中选择版本。");
+        return { type: "update" };
       case "release":
         if (args.length > 0) throw new Error("/release 不接受参数。");
         return { type: "release" };
@@ -158,7 +160,6 @@ export class CommandRouter {
 function resolveCommandName(rawCommand: string): CommandName {
   const input = rawCommand.slice(1).toLowerCase();
   if (!input) throw unknownCommand(rawCommand);
-  if (DISABLED_COMMAND_NAMES.has(input)) throw unknownCommand(rawCommand);
 
   const exact = COMMAND_NAMES.find((command) => command === input);
   if (exact) return exact;

package/src/commands/commandTypes.ts

@@ -21,6 +21,7 @@ export type Command =
   | { type: "goal"; action: "pause" | "resume" | "clear" }
   | { type: "restart"; force?: boolean }
   | { type: "release" }
+  | { type: "update" }
   | { type: "mute"; enabled: boolean }
   | { type: "turns"; turnReference?: string }
   | { type: "model" }

package/src/feishu/CardRenderer.ts

@@ -246,6 +246,8 @@ export interface ResetHistoryCardEntry extends TaskListCardEntry {
 }
 
 export interface ResetHistoryCardView {
+  taskTitle?: string;
+  readOnly?: boolean;
   entries: ResetHistoryCardEntry[];
   footerLines: string[];
   pageActions: TaskListCardAction[];
@@ -1267,6 +1269,11 @@ export class CardRenderer {
       : "任务执行详情";
     const elements = [markdown(`Turn: \`${state.turnId}\``)];
     if (state.prompt) elements.push(markdown(`**Prompt**\n${truncateText(state.prompt, 1_000)}`));
+    if (state.historyDetailError) {
+      elements.push(markdown(`**历史执行详情读取失败**\n${truncateText(state.historyDetailError, 1_000)}\n请重新打开详情或 Preview 重试；本轮执行状态未改变。`));
+    } else if (state.historyDetail === "summary") {
+      elements.push(markdown("当前仅保存轮次摘要，尚未加载历史执行详情。"));
+    }
     elements.push(...renderTurnElements(state, "always"));
     if (previewUrl) elements.push(taskActionRow([turnPreviewAction(previewUrl)]));
     return turnCard(title, "blue", elements, renderTurnSubtitle(state));
@@ -1604,13 +1611,16 @@ export class CardRenderer {
   renderResetHistoryCard(view: ResetHistoryCardView): Record<string, unknown> {
     const elements: Record<string, unknown>[] = [
       {
-        ...markdown("<font color='grey'>Reset 会将当前任务的对话上下文恢复到所选轮次完成时；不会回退本地文件。</font>"),
+        ...markdown(view.readOnly
+          ? "<font color='grey'>仅查看此任务的轮次；如需 Reset，请先切换到此任务。</font>"
+          : "<font color='grey'>Reset 会将当前任务的对话上下文恢复到所选轮次完成时；不会回退本地文件。</font>"),
         text_size: "notation",
       },
       { tag: "hr" },
     ];
+    if (view.taskTitle) elements.unshift(markdown(`**任务**：${escapeCardActionText(view.taskTitle)}`));
     if (view.entries.length === 0) {
-      elements.push(markdown("当前任务还没有成功完成的 turn。"));
+      elements.push(markdown(view.readOnly ? "此任务还没有可显示的 turn。" : "当前任务还没有成功完成的 turn。"));
     } else {
       const sequenceWidth = `${Math.max(16, ...view.entries.map((entry) => String(entry.sequence).length * 10))}px`;
       view.entries.forEach((entry) => {
@@ -1674,13 +1684,13 @@ function renderTurnElements(
   const pages = activityPages(allActivities);
   const visibleActivities = pages.at(-1) ?? [];
   if (state.plan.length > 0) elements.push(planPanel(state.plan));
-  if (pages.length > 1) {
+  if (pages.length > 1 || (state.previewJournal && state.activitiesTruncated)) {
     elements.push(taskActionRow([{
-      text: `查看历史思考（共 ${pages.length} 页）`,
+      text: state.activitiesTruncated ? "查看历史思考" : `查看历史思考（共 ${pages.length} 页）`,
       value: {
         action: "activity_history",
         turnId: state.turnId,
-        page: String(pages.length - 2),
+        page: String(state.activitiesTruncated ? Number.MAX_SAFE_INTEGER : pages.length - 2),
       },
     }]));
   }
@@ -1743,18 +1753,20 @@ function renderGroupedTurnElements(
     fullActivityText: true,
   });
   if (state.plan.length > 0) elements.push(planPanel(state.plan));
-  if (historyPages.length > 0) {
+  if (historyPages.length > 0 || (state.previewJournal && state.activitiesTruncated)) {
     elements.push(taskActionRow([{
-      text: `查看历史思考（共 ${historyPages.length + 1} 页）`,
+      text: state.activitiesTruncated ? "查看历史思考" : `查看历史思考（共 ${historyPages.length + 1} 页）`,
       value: {
         action: "activity_history",
         turnId: state.turnId,
-        page: String(historyPages.length - 1),
+        page: String(state.activitiesTruncated ? Number.MAX_SAFE_INTEGER : historyPages.length - 1),
       },
     }]));
   }
-  if (state.activitiesTruncated && visible.groups[0]?.kind !== "gap") elements.push(markdown("…"));
-  elements.push(...renderGroupedActivityGroups(visible.groups, state.projectCwd));
+  const visibleGroups: GroupedTurnActivity[] = state.activitiesTruncated
+    ? [{ kind: "gap", id: "gap:truncated" }, ...visible.groups]
+    : visible.groups;
+  elements.push(...renderGroupedActivityGroups(visibleGroups, state.projectCwd));
   if (state.fileSummary.length > 0) elements.push(fileSummaryPanel(state));
 
   if (state.approval) {
@@ -1913,17 +1925,24 @@ function renderGroupedActivityGroups(
     fullActivityText?: boolean;
   } = {},
 ): Record<string, unknown>[] {
-  return groups.flatMap((group) => {
-    if (group.kind === "gap") return [markdown("…")];
-    if (group.kind === "activity") {
-      return renderActivity(group.activity, projectCwd, options.fullActivityText === true);
-    }
-    if (group.tools.length === 0) {
-      const reasonings = group.latestReasoning ? [group.latestReasoning] : [];
-      return renderReasoningGroup(reasonings);
+  const elements: Record<string, unknown>[] = [];
+  let previousWasGap = false;
+  for (const group of groups) {
+    if (group.kind === "gap") {
+      if (!previousWasGap) elements.push(markdown("…"));
+      previousWasGap = true;
+      continue;
     }
-    return [executionActivityPanel(group, projectCwd)];
-  });
+    const rendered = group.kind === "activity"
+      ? renderActivity(group.activity, projectCwd, options.fullActivityText === true)
+      : group.tools.length === 0
+        ? renderReasoningGroup(group.latestReasoning ? [group.latestReasoning] : [])
+        : [executionActivityPanel(group, projectCwd)];
+    if (rendered.length === 0) continue;
+    elements.push(...rendered);
+    previousWasGap = false;
+  }
+  return elements;
 }
 
 function groupTurnActivities(activities: TurnActivity[]): GroupedTurnActivity[] {
@@ -2144,7 +2163,10 @@ function groupedLiveActivityPage(
 }
 
 function isCommentaryGroup(group: GroupedTurnActivity): boolean {
-  return group.kind === "activity" && isCommentaryActivity(group.activity);
+  return group.kind === "activity"
+    && group.activity.kind !== "tool"
+    && isCommentaryActivity(group.activity)
+    && group.activity.text.trim().length > 0;
 }
 
 function groupsWithGaps(

package/src/feishu/FeishuConnector.ts

@@ -262,6 +262,8 @@ function toIncomingMessage(
   const messageId = message.message_id ?? `${Date.now()}`;
   return {
     messageId,
+    ...(Number.isFinite(Number(message.create_time)) && Number(message.create_time) > 0
+      ? { createdAt: Number(message.create_time) } : {}),
     contextKey: chatId
       ? threadContext
         ? threadContextKey(chatId, threadId!)

package/src/feishu/FeishuMessageClient.ts

@@ -15,7 +15,10 @@ import {
   type MergedForwardMessageItem,
   type ReferencedMessageContent,
 } from "./MergedForwardMessage.js";
+import { RECENT_CONTEXT_LIMIT, RECENT_CONTEXT_MAX_PAGES, RECENT_CONTEXT_PAGE_SIZE, recentMessagePageSchema, scanRecentContextMessages, selectRecentContextMessages } from "./RecentMessageContext.js";
 import type {
+  RecentMessageRequest,
+  RecentContextMessage,
   CreatedGroup,
   CreateGroupInput,
   FeishuOutbound,
@@ -251,6 +254,47 @@ export class FeishuMessageClient implements FeishuOutbound {
     return renderMergedForwardPrompt(messageId, items);
   }
 
+  async readRecentMessages(request: RecentMessageRequest): Promise<RecentContextMessage[]> {
+    const operation = "read recent group context";
+    try {
+      const token = await this.getTenantAccessToken();
+      const items: NonNullable<NonNullable<ReturnType<typeof recentMessagePageSchema.parse>["data"]>["items"]> = [];
+      let pageToken: string | undefined;
+      let selected: RecentContextMessage[] = [];
+      let reachedKnownMessage = false;
+      for (let page = 0; page < RECENT_CONTEXT_MAX_PAGES; page++) {
+        const url = new URL("https://open.feishu.cn/open-apis/im/v1/messages");
+        url.searchParams.set("container_id_type", request.threadId ? "thread" : "chat");
+        url.searchParams.set("container_id", request.threadId ?? request.chatId);
+        url.searchParams.set("sort_type", "ByCreateTimeDesc");
+        url.searchParams.set("page_size", String(RECENT_CONTEXT_PAGE_SIZE));
+        if (pageToken) url.searchParams.set("page_token", pageToken);
+        if (!request.threadId && request.beforeTimestamp) {
+          url.searchParams.set("end_time", String(Math.ceil(request.beforeTimestamp / 1000)));
+        }
+        const response = await fetch(url, {
+          headers: { Authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(10_000),
+        });
+        const payload = recentMessagePageSchema.parse(await response.json());
+        if (!response.ok || payload.code !== 0) {
+          throw new FeishuApiError(payload.msg || "无法读取近期群消息；请检查飞书历史消息及群消息读取权限。", payload.code, { code: payload.code, msg: payload.msg ?? "" }, operation, response.status);
+        }
+        items.push(...(payload.data?.items ?? []));
+        if (request.beforeTimestamp || items.some((item) => item.message_id === request.beforeMessageId)) {
+          const scanned = scanRecentContextMessages(items, request);
+          selected = scanned.messages;
+          reachedKnownMessage = scanned.reachedKnownMessage;
+        }
+        const nextToken = payload.data?.page_token;
+        if (reachedKnownMessage || selected.length >= RECENT_CONTEXT_LIMIT || !payload.data?.has_more || !nextToken || nextToken === pageToken) break;
+        pageToken = nextToken;
+      }
+      return selectRecentContextMessages(items, request);
+    } catch (error) {
+      throw normalizeTransportError(error, operation);
+    }
+  }
+
   async readReferencedMessage(messageId: string): Promise<ReferencedMessageContent> {
     const items = await this.readMessageItems(messageId, "read referenced message");
     return renderReferencedMessage(messageId, items);