@keyou007/agent-bot 0.1.24-alpha.1 → 0.1.24-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.24-alpha.1",
+  "version": "0.1.24-alpha.3",
   "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.
@@ -125,7 +126,7 @@ agentbot task permissions [auto|confirm]
 
 Omit the value to inspect the current setting and available choices. `agent` changes the default Agent for future tasks in that conversation. The other settings affect the specified task from its next request and become the saved defaults for that Agent.
 
-A successful Provider switch confirms settings, not inference connectivity. Model-list fallback warnings appear on settings cards; inspect the Provider service when availability is unconfirmed. App Server errors and native retry notices appear on the current progress card without terminating the turn. Do not stop or restart a retrying task unless the user requests it.
+A successful Provider switch confirms settings, not inference connectivity. Model-list fallback warnings appear on settings cards; inspect the Provider service when availability is unconfirmed. App Server errors and native retry notices show the message and supplied `additionalDetails` as literal text on the current progress card and Preview without terminating the turn. Use Preview for long reasons; `Reconnecting` alone does not identify the cause when the Agent supplies no details, and old snapshots are not backfilled. Do not stop or restart a retrying task unless the user requests it.
 
 Providers such as a Responses bridge may omit assistant message phases. Unphased text stays in the progress timeline; successful completion promotes only the last message not followed by a tool start. Do not diagnose progress text in the answer area as a CSS issue without checking message phases. Old snapshots are not automatically backfilled.
 
@@ -144,6 +145,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 +161,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 +178,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/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;
 }
@@ -571,6 +572,7 @@ export function runNpmCommand(args: string[], cwd: string): CommandResult {
     {
       cwd,
       env: process.env,
+      windowsHide: true,
       encoding: "utf8",
       maxBuffer: 32 * 1024 * 1024,
       shell: process.platform === "win32",
@@ -610,6 +612,7 @@ function runNode(args: string[], cwd: string): CommandResult {
     spawnSync(process.execPath, args, {
       cwd,
       env: process.env,
+      windowsHide: true,
       encoding: "utf8",
       maxBuffer: 32 * 1024 * 1024,
     }),

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[] }
@@ -73,7 +76,7 @@ export function mapCodexNotification(method: string, params: unknown): MappedCod
   if (!threadId || !turnId) return undefined;
 
   if (method === "error" && isRecord(params.error)) {
-    const message = stringValue(params.error.message)?.trim();
+    const message = formatCodexError(params.error);
     if (!message || typeof params.willRetry !== "boolean") return undefined;
     return { kind: "runtime_error", threadId, turnId, message, willRetry: params.willRetry };
   }
@@ -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);
@@ -200,7 +219,7 @@ export function mapCodexNotification(method: string, params: unknown): MappedCod
   if (method === "turn/completed" && isRecord(params.turn)) {
     const status = params.turn.status;
     const mappedStatus = status === "interrupted" ? "cancelled" : status === "failed" ? "failed" : "completed";
-    const error = isRecord(params.turn.error) ? stringValue(params.turn.error.message) : undefined;
+    const error = formatCodexError(params.turn.error);
     return {
       kind: "terminal",
       threadId,
@@ -213,6 +232,24 @@ 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();
+  const details = stringValue(error.additionalDetails)?.trim();
+  if (!message) return details || undefined;
+  if (!details || message.includes(details)) return message;
+  return details.includes(message) ? details : `${message}\n\n${details}`;
+}
+
 function mapTool(
   item: Record<string, unknown>,
   phase: "started" | "updated",

package/src/codex/CodexRuntime.ts

@@ -16,6 +16,7 @@ import type {
   RemoteSessionPage,
   RemoteSessionSummary,
   RemoteTurnPage,
+  RemoteTurnDetails,
   ResumeRuntimeSessionInput,
   RuntimeGoal,
   RuntimeGoalUpdate,
@@ -29,7 +30,7 @@ import type {
 import { appendGeneratedImageMarkdown } from "../utils/generatedImageMarkdown.js";
 import { normalizeTaskTitle } from "../utils/taskTitle.js";
 import { AppServerRequestError } from "./AppServerConnection.js";
-import { mapCodexNotification } from "./CodexEventMapper.js";
+import { formatCodexError, mapCodexNotification } from "./CodexEventMapper.js";
 import { CodexLocalActivityDetector } from "./CodexLocalActivityDetector.js";
 import { detectProjectlessWorkspace } from "./ProjectlessWorkspace.js";
 import { threadWriterLockPath } from "./ThreadWriterProcess.js";
@@ -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,
       });
@@ -1460,7 +1510,7 @@ export class CodexRuntime implements AgentRuntime {
         type: "turn_failed",
         sessionId: session.localSessionId,
         turnId: turn.id,
-        message: turn.error?.message ?? "App Server turn failed.",
+        message: formatCodexError(turn.error) ?? "App Server turn failed.",
       });
       return;
     }
@@ -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;
@@ -1639,7 +1691,7 @@ interface CodexTurnSnapshot {
     status?: string;
     savedPath?: string;
   }>;
-  error?: { message?: string } | null;
+  error?: { message?: string; additionalDetails?: string | null } | null;
   startedAt?: number | null;
   durationMs?: number | null;
 }
@@ -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");
 }
@@ -1798,7 +1885,7 @@ function remoteSessionSummary(thread: CodexThreadSnapshot): RemoteSessionSummary
     finalResponse: lastTurn && lastTurn.status !== "inProgress"
       ? appendGeneratedImageMarkdown(extractFinalResponse(lastTurn), extractGeneratedImagePaths(lastTurn)) || undefined
       : undefined,
-    lastError: lastTurn?.error?.message,
+    lastError: formatCodexError(lastTurn?.error),
     lastTurnToolCount: toolCounts?.total,
     lastTurnCompletedToolCount: toolCounts?.completed,
     lastTurnFailedToolCount: toolCounts?.failed,

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];
@@ -121,6 +122,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" };

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) {
@@ -1847,6 +1859,10 @@ function renderActivity(
   if (activity.kind === "assistant" || (activity.kind === "reasoning" && activity.id.startsWith("commentary:"))) {
     const text = activity.text.trim();
     if (!text) return [];
+    if (activity.id.startsWith("commentary:runtime-error:")) {
+      const chunks = fullAssistantText ? splitText(text, ACTIVITY_TEXT_CHUNK) : [text];
+      return chunks.map((chunk) => markdown(codeBlock(chunk, fullAssistantText ? ACTIVITY_TEXT_CHUNK : MAX_LIVE_ASSISTANT_TEXT)));
+    }
     return fullAssistantText
       ? splitText(text, ACTIVITY_TEXT_CHUNK).map(markdown)
       : [markdown(truncateText(text, MAX_LIVE_ASSISTANT_TEXT))];
@@ -1909,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[] {
@@ -2140,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!)