@keyou007/agent-bot 0.1.20 → 0.1.21

package/src/codex/CodexRuntime.ts

@@ -1,3 +1,4 @@
+import { statSync } from "node:fs";
 import type { Logger } from "pino";
 import type {
   AgentRuntime,
@@ -9,6 +10,7 @@ import type {
   ModelProviderOption,
   PermissionMode,
   RemoteSessionActivity,
+  RemoteSessionMetrics,
   RemoteSessionPage,
   RemoteSessionSummary,
   RemoteTurnPage,
@@ -30,6 +32,7 @@ import { CodexLocalActivityDetector } from "./CodexLocalActivityDetector.js";
 import { detectProjectlessWorkspace } from "./ProjectlessWorkspace.js";
 import { threadWriterLockPath } from "./ThreadWriterProcess.js";
 import { assertProviderSettingsApplied, PROVIDER_SWITCH_BUSY, providerSwitchFailure } from "./ProviderSwitch.js";
+import { fetchProviderModels, type ProviderModelConfig } from "./ProviderModels.js";
 
 const WINDOWS_SCREENSHOT_DEVELOPER_INSTRUCTIONS = [
   "When capturing any screenshot on Windows, use one fresh process and make it Per-Monitor DPI Aware V2 before loading System.Windows.Forms, System.Drawing, or UI Automation, and before calling any screen, window, or bounds API.",
@@ -66,6 +69,7 @@ export interface AppServerClientProvider {
   getAgentFamily?(): "codex" | "traex" | undefined;
   getProcessInfo?(): AgentProcessInfo;
   getCodexHome?(): string;
+  getEnvironmentVariable?(name: string): string | undefined;
   onDisconnect?(listener: (error: Error) => void): () => void;
   release?(): Promise<void>;
   close(): void;
@@ -80,6 +84,9 @@ interface CodexSession extends RuntimeSession {
   needsResume: boolean;
   canReplaceEmptyThread: boolean;
   settingsRecoveryError?: string;
+  rolloutPath?: string;
+  turnCount?: number;
+  knownTurnIds: Set<string>;
 }
 
 interface PendingApproval {
@@ -291,6 +298,8 @@ export class CodexRuntime implements AgentRuntime {
         limit: input.limit ?? 20,
         sortKey: this.provider.getAgentFamily?.() === "traex" ? "updated_at" : "recency_at",
         sortDirection: "desc",
+        // Omitting this filter only lists the App Server's current Provider.
+        modelProviders: [],
         sourceKinds: USER_RESUMABLE_THREAD_SOURCE_KINDS,
         archived: false,
         searchTerm: input.searchTerm,
@@ -312,6 +321,53 @@ export class CodexRuntime implements AgentRuntime {
     return this.decorateRemoteSession(remoteSessionId, remoteSessionSummary({ ...response.thread, turns }));
   }
 
+  async readRemoteSessionMetrics(remoteSessionId: string): Promise<RemoteSessionMetrics> {
+    const client = await this.client();
+    const metadata = await client.request<ThreadReadResponse>(
+      "thread/read", { threadId: remoteSessionId, includeTurns: false }, SYNC_REQUEST_TIMEOUT_MS,
+    );
+    const { turnCount, turnIds } = await this.countRemoteTurns(client, remoteSessionId);
+    const rolloutPath = stringValue(metadata.thread.path)?.trim() || undefined;
+    const loaded = [...this.sessions.values()].filter((session) => session.remoteSessionId === remoteSessionId);
+    for (const session of loaded) {
+      session.rolloutPath = rolloutPath ?? session.rolloutPath;
+      const knownTurnIds = new Set(turnIds);
+      if (session.activeTurnId && !knownTurnIds.has(session.activeTurnId)) knownTurnIds.add(session.activeTurnId);
+      session.knownTurnIds = knownTurnIds;
+      session.turnCount = knownTurnIds.size;
+    }
+    const effectivePath = rolloutPath ?? loaded[0]?.rolloutPath;
+    return {
+      turnCount: loaded[0]?.turnCount ?? turnCount,
+      storageBytes: rolloutStorageBytes(effectivePath),
+    };
+  }
+
+  private async countRemoteTurns(
+    client: AppServerClient,
+    remoteSessionId: string,
+  ): Promise<{ turnCount: number; turnIds: Set<string> }> {
+    const turnIds = new Set<string>();
+    const seenCursors = new Set<string>();
+    let cursor: string | undefined;
+    do {
+      const page = await this.readTurnPage(client, remoteSessionId, {
+        cursor,
+        limit: 100,
+        itemsView: "summary",
+      }, CONTROL_REQUEST_TIMEOUT_MS);
+      for (const turn of page.data) turnIds.add(turn.id);
+      const nextCursor = page.nextCursor ?? undefined;
+      if (!nextCursor) break;
+      if (nextCursor === cursor || seenCursors.has(nextCursor)) {
+        throw new Error("App Server repeated a Turn history cursor while counting task Turns.");
+      }
+      seenCursors.add(nextCursor);
+      cursor = nextCursor;
+    } while (cursor);
+    return { turnCount: turnIds.size, turnIds };
+  }
+
   async listRemoteTurnSummaries(
     remoteSessionId: string,
     input: { cursor?: string; limit: number },
@@ -698,7 +754,43 @@ export class CodexRuntime implements AgentRuntime {
     this.emit({ type: "approval_resolved", sessionId, turnId: pending.turnId, requestId, decision });
   }
 
-  async listModels(): Promise<ModelOption[]> {
+  async listModels(modelProvider?: string, fallbackModel?: string): Promise<ModelOption[]> {
+    const requestedProvider = modelProvider?.trim();
+    if (!requestedProvider
+      || (requestedProvider === BUILT_IN_CODEX_PROVIDER_ID && this.provider.getAgentFamily?.() !== "traex")) {
+      return this.listCatalogModels();
+    }
+    const config = await this.readConfig();
+    const configuredProviders = isRecord(config.model_providers) ? config.model_providers : {};
+    const providerConfig = configuredProviders[requestedProvider];
+    let catalog: ModelOption[] = [];
+    try {
+      catalog = await this.listCatalogModels();
+    } catch (error) {
+      this.logger.warn({ error, modelProvider: requestedProvider },
+        "Failed to read the App Server model catalog while discovering Provider models.");
+    }
+    const configuredDefaultModel = stringValue(config.model_provider)?.trim() === requestedProvider
+      ? stringValue(config.model)?.trim()
+      : undefined;
+    try {
+      return await fetchProviderModels({
+        providerId: requestedProvider,
+        config: (isRecord(providerConfig) ? providerConfig : {}) as ProviderModelConfig,
+        catalog,
+        configuredDefaultModel,
+        environmentValue: (name) => this.provider.getEnvironmentVariable?.(name) ?? process.env[name],
+      });
+    } catch (error) {
+      const fallback = fallbackProviderModel(catalog, fallbackModel, configuredDefaultModel);
+      if (!fallback) throw error;
+      this.logger.warn({ error, modelProvider: requestedProvider, fallbackModel: fallback.id },
+        "Provider model discovery failed; using the current or configured model as a fallback.");
+      return [fallback];
+    }
+  }
+
+  private async listCatalogModels(): Promise<ModelOption[]> {
     const response = await (await this.client()).request<{
       data: Array<{
         id: string;
@@ -724,12 +816,7 @@ export class CodexRuntime implements AgentRuntime {
   }
 
   async listModelProviders(): Promise<ModelProviderOption[]> {
-    const response = await (await this.client()).request<{ config?: Record<string, unknown> }>(
-      "config/read",
-      {},
-      CONTROL_REQUEST_TIMEOUT_MS,
-    );
-    const config = response.config ?? {};
+    const config = await this.readConfig();
     const defaultProvider = stringValue(config.model_provider)?.trim();
     const configuredProviders = isRecord(config.model_providers) ? config.model_providers : {};
     const providers = new Map<string, ModelProviderOption>();
@@ -757,6 +844,15 @@ export class CodexRuntime implements AgentRuntime {
     );
   }
 
+  private async readConfig(): Promise<Record<string, unknown>> {
+    const response = await (await this.client()).request<{ config?: Record<string, unknown> }>(
+      "config/read",
+      {},
+      CONTROL_REQUEST_TIMEOUT_MS,
+    );
+    return response.config ?? {};
+  }
+
   onEvent(listener: (event: RuntimeEvent) => void): () => void {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
@@ -890,6 +986,18 @@ export class CodexRuntime implements AgentRuntime {
         turnId: mapped.turnId,
         lastTokens: mapped.lastTokens,
         cumulativeTokens: mapped.cumulativeTokens,
+        contextTokens: mapped.contextTokens,
+      });
+    } else if (mapped.kind === "context_compaction") {
+      this.emit({
+        type: "context_compaction",
+        sessionId,
+        turnId: mapped.turnId,
+        phase: mapped.phase,
+        compactionId: mapped.compactionId,
+        timestampMs: mapped.timestampMs,
+        turnCount: session.turnCount,
+        storageBytes: rolloutStorageBytes(session.rolloutPath),
       });
     } else if (mapped.kind === "agent_message_phase") {
       session.messagePhases.set(mapped.itemId, mapped.phase);
@@ -1005,7 +1113,7 @@ export class CodexRuntime implements AgentRuntime {
     if (input.reasoningEffort) return input.reasoningEffort;
     if (response.reasoningEffort) return response.reasoningEffort;
     const model = input.model ?? response.model;
-    const models = await this.listModels();
+    const models = await this.listModels(input.modelProvider ?? response.modelProvider, model);
     return models.find((item) => item.id === model)?.defaultReasoningEffort
       ?? models.find((item) => item.isDefault)?.defaultReasoningEffort;
   }
@@ -1091,6 +1199,10 @@ export class CodexRuntime implements AgentRuntime {
 
   private adoptTurn(session: CodexSession, turnId: string, startedAt: number): void {
     session.canReplaceEmptyThread = false;
+    if (!session.knownTurnIds.has(turnId)) {
+      session.knownTurnIds.add(turnId);
+      if (session.turnCount !== undefined) session.turnCount += 1;
+    }
     session.activeTurnId = turnId;
     session.activeTurnStartedAt = startedAt;
     session.finalText = "";
@@ -1183,6 +1295,9 @@ export class CodexRuntime implements AgentRuntime {
       messagePhases: new Map(),
       needsResume: false,
       canReplaceEmptyThread: !("remoteSessionId" in input),
+      rolloutPath: stringValue(response.thread.path)?.trim() || undefined,
+      turnCount: "remoteSessionId" in input ? undefined : 0,
+      knownTurnIds: new Set(),
     };
   }
 
@@ -1241,7 +1356,7 @@ export class CodexRuntime implements AgentRuntime {
 }
 
 interface ThreadResponse {
-  thread: { id: string; name?: string | null; preview?: string };
+  thread: { id: string; name?: string | null; preview?: string; path?: string | null };
   modelProvider?: string;
   model?: string;
   reasoningEffort?: string | null;
@@ -1273,6 +1388,7 @@ interface CodexThreadSnapshot {
   recencyAt?: number | null;
   status?: { type?: string };
   forkedFromId?: string | null;
+  path?: string | null;
   turns?: CodexTurnSnapshot[];
 }
 
@@ -1341,6 +1457,34 @@ function stringValue(value: unknown): string | undefined {
   return typeof value === "string" ? value : undefined;
 }
 
+function rolloutStorageBytes(filePath: string | undefined): number | undefined {
+  if (!filePath) return undefined;
+  try {
+    const stats = statSync(filePath);
+    return stats.isFile() ? stats.size : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function fallbackProviderModel(
+  catalog: ModelOption[],
+  requestedModel?: string,
+  configuredDefaultModel?: string,
+): ModelOption | undefined {
+  const id = requestedModel?.trim()
+    || configuredDefaultModel?.trim()
+    || catalog.find((model) => model.isDefault)?.id
+    || catalog[0]?.id;
+  if (!id) return undefined;
+  const catalogModel = catalog.find((model) => model.id === id);
+  return {
+    ...(catalogModel ?? { id, supportedReasoningEfforts: [] }),
+    id,
+    isDefault: true,
+  };
+}
+
 function turnStartedAt(turn: CodexTurnSnapshot): number {
   return typeof turn.startedAt === "number" ? turn.startedAt * 1_000 : Date.now();
 }

package/src/codex/ProviderModels.ts

@@ -0,0 +1,185 @@
+import type { ModelOption, ReasoningEffortOption } from "../runtime/types.js";
+
+const PROVIDER_MODEL_LIST_TIMEOUT_MS = 10_000;
+
+export interface ProviderModelConfig {
+  base_url?: unknown;
+  env_key?: unknown;
+  experimental_bearer_token?: unknown;
+  query_params?: unknown;
+  http_headers?: unknown;
+  env_http_headers?: unknown;
+  default_model?: unknown;
+  model?: unknown;
+}
+
+export async function fetchProviderModels(input: {
+  providerId: string;
+  config: ProviderModelConfig;
+  catalog: ModelOption[];
+  configuredDefaultModel?: string;
+  environmentValue: (name: string) => string | undefined;
+}): Promise<ModelOption[]> {
+  const baseUrl = stringValue(input.config.base_url)?.trim();
+  if (!baseUrl) {
+    throw new Error(`Provider ${input.providerId} 没有配置 base_url，无法读取模型列表。`);
+  }
+
+  const url = providerModelsUrl(baseUrl, input.config.query_params, input.providerId);
+  const headers = providerModelHeaders(input.config, input.environmentValue);
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: AbortSignal.timeout(PROVIDER_MODEL_LIST_TIMEOUT_MS),
+    });
+  } catch {
+    throw new Error(`无法连接 Provider ${input.providerId} 的模型列表，请检查 Provider 服务和网络。`);
+  }
+  if (!response.ok) {
+    throw new Error(`Provider ${input.providerId} 的模型列表请求失败（HTTP ${response.status}）。`);
+  }
+
+  let payload: unknown;
+  try {
+    payload = await response.json();
+  } catch {
+    throw new Error(`Provider ${input.providerId} 返回了无效的模型列表。`);
+  }
+  const models = normalizeProviderModels(payload, input.catalog, {
+    configuredDefaultModel: input.configuredDefaultModel,
+    providerDefaultModel: stringValue(input.config.default_model)?.trim()
+      ?? stringValue(input.config.model)?.trim(),
+  });
+  if (models.length === 0) {
+    throw new Error(`Provider ${input.providerId} 没有返回可用模型。`);
+  }
+  return models;
+}
+
+function providerModelsUrl(baseUrl: string, queryParams: unknown, providerId: string): URL {
+  let url: URL;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    throw new Error(`Provider ${providerId} 的 base_url 无效，无法读取模型列表。`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Provider ${providerId} 的 base_url 不支持模型发现。`);
+  }
+  const path = url.pathname.replace(/\/+$/u, "");
+  if (!/\/models$/iu.test(path)) url.pathname = `${path}/models`;
+  if (isRecord(queryParams)) {
+    for (const [key, value] of Object.entries(queryParams)) {
+      if (!key || value === null || value === undefined || typeof value === "object") continue;
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url;
+}
+
+function providerModelHeaders(
+  config: ProviderModelConfig,
+  environmentValue: (name: string) => string | undefined,
+): Headers {
+  const headers = new Headers({ Accept: "application/json" });
+  appendHeaderValues(headers, config.http_headers, (value) => value);
+  appendHeaderValues(headers, config.env_http_headers, environmentValue);
+  if (!headers.has("authorization")) {
+    const envKey = stringValue(config.env_key)?.trim();
+    const token = (envKey ? environmentValue(envKey) : undefined)
+      ?? stringValue(config.experimental_bearer_token)?.trim();
+    if (token) headers.set("Authorization", `Bearer ${token}`);
+  }
+  return headers;
+}
+
+function appendHeaderValues(
+  headers: Headers,
+  values: unknown,
+  resolve: (value: string) => string | undefined,
+): void {
+  if (!isRecord(values)) return;
+  for (const [name, rawValue] of Object.entries(values)) {
+    const value = stringValue(rawValue)?.trim();
+    const resolved = value ? resolve(value)?.trim() : undefined;
+    if (name.trim() && resolved) headers.set(name, resolved);
+  }
+}
+
+function normalizeProviderModels(
+  payload: unknown,
+  catalog: ModelOption[],
+  defaults: { configuredDefaultModel?: string; providerDefaultModel?: string },
+): ModelOption[] {
+  const root = isRecord(payload) ? payload : undefined;
+  const entries = Array.isArray(root?.data)
+    ? root.data
+    : Array.isArray(root?.models)
+      ? root.models
+      : Array.isArray(payload)
+        ? payload
+        : [];
+  const catalogById = new Map(catalog.map((model) => [model.id, model]));
+  const normalized = new Map<string, ModelOption>();
+  let itemDefaultModel: string | undefined;
+
+  for (const entry of entries) {
+    const record = isRecord(entry) ? entry : undefined;
+    const id = (typeof entry === "string"
+      ? entry
+      : stringValue(record?.id) ?? stringValue(record?.model) ?? stringValue(record?.name))?.trim();
+    if (!id || normalized.has(id)) continue;
+    const catalogModel = catalogById.get(id);
+    const efforts = reasoningEfforts(record) ?? catalogModel?.supportedReasoningEfforts ?? [];
+    const defaultEffort = stringValue(record?.defaultReasoningEffort)?.trim()
+      ?? stringValue(record?.default_reasoning_effort)?.trim()
+      ?? catalogModel?.defaultReasoningEffort;
+    const displayName = stringValue(record?.displayName)?.trim()
+      ?? stringValue(record?.display_name)?.trim()
+      ?? (stringValue(record?.name)?.trim() !== id ? stringValue(record?.name)?.trim() : undefined)
+      ?? catalogModel?.displayName;
+    if (!itemDefaultModel && (record?.isDefault === true || record?.is_default === true || record?.default === true)) {
+      itemDefaultModel = id;
+    }
+    normalized.set(id, {
+      id,
+      ...(displayName ? { displayName } : {}),
+      supportedReasoningEfforts: efforts,
+      ...(defaultEffort ? { defaultReasoningEffort: defaultEffort } : {}),
+    });
+  }
+
+  const rootDefaultModel = stringValue(root?.defaultModel)?.trim()
+    ?? stringValue(root?.default_model)?.trim();
+  const defaultModel = [rootDefaultModel, itemDefaultModel, defaults.providerDefaultModel, defaults.configuredDefaultModel]
+    .find((candidate) => candidate && normalized.has(candidate));
+  if (defaultModel) normalized.set(defaultModel, { ...normalized.get(defaultModel)!, isDefault: true });
+  return [...normalized.values()];
+}
+
+function reasoningEfforts(record: Record<string, unknown> | undefined): ReasoningEffortOption[] | undefined {
+  if (!record) return undefined;
+  const raw = record.supportedReasoningEfforts ?? record.supported_reasoning_efforts;
+  if (!Array.isArray(raw)) return undefined;
+  const efforts = raw.flatMap((entry): ReasoningEffortOption[] => {
+    if (typeof entry === "string" && entry.trim()) return [{ value: entry.trim() }];
+    if (!isRecord(entry)) return [];
+    const value = stringValue(entry.value)?.trim()
+      ?? stringValue(entry.reasoningEffort)?.trim()
+      ?? stringValue(entry.reasoning_effort)?.trim();
+    if (!value) return [];
+    const description = stringValue(entry.description)?.trim();
+    return [{ value, ...(description ? { description } : {}) }];
+  });
+  return efforts.length > 0 ? efforts : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}

package/src/commands/CommandRouter.ts

@@ -128,8 +128,13 @@ export class CommandRouter {
         throw new Error("/mute 只接受 on 或 off；不传参数等同于 /mute on。");
       }
       case "turns":
-        if (args.length > 0) throw new Error("/turns 不接受参数，请在历史轮次卡片中选择 turn。");
-        return { type: "turns" };
+        rejectOptions("/turn", args);
+        if (args.length > 1) throw new Error("/turn 只接受一个可选的 Turn ID 或序号。");
+        if (args[0] && /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/.test(args[0])
+          && (!/^\d+$/.test(args[0]) || !Number.isSafeInteger(Number(args[0])) || Number(args[0]) < 1)) {
+          throw new Error("Turn 序号必须是从 1 开始的正整数。");
+        }
+        return args[0] ? { type: "turns", turnReference: args[0] } : { type: "turns" };
       case "model":
         return settingsCommand("/model", args, { type: "model" });
       case "provider":

package/src/commands/commandTypes.ts

@@ -21,7 +21,7 @@ export type Command =
   | { type: "restart"; force?: boolean }
   | { type: "release" }
   | { type: "mute"; enabled: boolean }
-  | { type: "turns" }
+  | { type: "turns"; turnReference?: string }
   | { type: "model" }
   | { type: "provider" }
   | { type: "thinking" }

package/src/console/ConsoleTurnPresenter.ts

@@ -15,11 +15,14 @@ export class ConsoleTurnPresenter implements TurnPresenter {
     _taskTitle?: string,
     _projectCwd?: string,
     agentLabel?: string,
+    _model?: string,
   ): void {
     this.contexts.set(sessionId, contextKey);
     if (agentLabel) this.agentLabels.set(sessionId, agentLabel);
   }
 
+  updateSessionModel(): void {}
+
   updateSessionTitle(): void {}
 
   unregisterSession(sessionId: string): void {

package/src/feishu/CardRenderer.ts

@@ -123,6 +123,14 @@ export interface PermissionSelectorCardView {
 
 export type ExecutionSettingsTab = "agent" | "provider" | "model" | "thinking" | "permission";
 
+const EXECUTION_SETTING_EFFECTS: Record<ExecutionSettingsTab, string> = {
+  agent: "只影响新建任务，不切换当前任务。",
+  provider: "只影响当前任务，需空闲时切换。",
+  model: "只影响当前任务，下一轮生效。",
+  thinking: "只影响当前任务，下一轮生效。",
+  permission: "只影响当前任务，下一轮生效。",
+};
+
 export interface ExecutionSettingsAgentOption {
   name: string;
   title: string;
@@ -158,6 +166,7 @@ export interface TaskListCardAction {
   text: string;
   type?: "default" | "primary" | "danger";
   value: Record<string, string>;
+  url?: string;
 }
 
 export interface HelpCardCommand {
@@ -542,7 +551,7 @@ export class CardRenderer {
 
     if (view.activeTab === "agent") {
       elements.push(...view.agents.map((agent) => settingsOptionRow({
-        label: `${inlineCode(agent.name)} · ${escapeCardHtml(agent.title)}`,
+        label: inlineCode(agent.name),
         current: agent.name === view.currentAgent,
         action: {
           text: "Switch",
@@ -562,9 +571,6 @@ export class CardRenderer {
         elements.push(...view.providers.map((provider) => settingsOptionRow({
           label: [
             inlineCode(provider.id),
-            provider.displayName && provider.displayName !== provider.id
-              ? ` · ${escapeCardHtml(provider.displayName)}`
-              : "",
             provider.isDefault ? " · 默认" : "",
           ].join(""),
           current: provider.id === view.currentProvider,
@@ -631,6 +637,7 @@ export class CardRenderer {
       })));
     }
 
+    elements.push(markdown(`> ${EXECUTION_SETTING_EFFECTS[view.activeTab]}`));
     return sectionCard("运行设置", elements, view.notice ? "green" : "blue");
   }
 
@@ -1138,7 +1145,7 @@ export class CardRenderer {
     };
   }
 
-  renderTurn(state: TurnViewState): Record<string, unknown> {
+  renderTurn(state: TurnViewState, previewUrl?: string): Record<string, unknown> {
     const elements = this.thinkingCardLayout === "timeline"
       ? renderTurnElements(state, "hidden")
       : renderGroupedTurnElements(state, "hidden");
@@ -1149,23 +1156,31 @@ export class CardRenderer {
         type: "danger",
         value: { action: "turn_cancel", sessionId: state.sessionId, turnId: state.turnId },
       });
+      if (previewUrl) footerActions.push(turnPreviewAction(previewUrl));
       elements.push(
         { tag: "hr" },
-        taskActionRow(footerActions, renderTurnDuration(state)),
+        taskActionRow(footerActions, renderTurnDuration(state), true),
       );
     } else if (state.status === "completed") {
       footerActions.push({
         text: "Reset",
         value: { action: "turn_reset", sessionId: state.sessionId, turnId: state.turnId },
       });
+      if (previewUrl) footerActions.push(turnPreviewAction(previewUrl));
       elements.push(
         { tag: "hr" },
-        taskActionRow(footerActions),
+        taskActionRow(footerActions, undefined, true),
       );
     } else if (state.status === "starting") {
+      if (previewUrl) footerActions.push(turnPreviewAction(previewUrl));
+      elements.push(
+        { tag: "hr" },
+        taskActionRow(footerActions, renderTurnDuration(state), true),
+      );
+    } else if (previewUrl) {
       elements.push(
         { tag: "hr" },
-        taskActionRow([], renderTurnDuration(state)),
+        taskActionRow([turnPreviewAction(previewUrl)], renderTurnDuration(state)),
       );
     }
     if (state.status === "completed") {
@@ -1184,11 +1199,15 @@ export class CardRenderer {
     );
   }
 
-  renderTurnDetails(state: TurnViewState): Record<string, unknown> {
+  renderTurnDetails(state: TurnViewState, previewUrl?: string): Record<string, unknown> {
     const title = state.taskTitle
       ? `任务执行详情：${truncateText(state.taskTitle.replace(/\s+/g, " ").trim(), 60)}`
       : "任务执行详情";
-    return turnCard(title, "blue", renderTurnElements(state, "always"), renderTurnSubtitle(state));
+    const elements = [markdown(`Turn: \`${state.turnId}\``)];
+    if (state.prompt) elements.push(markdown(`**Prompt**\n${truncateText(state.prompt, 1_000)}`));
+    elements.push(...renderTurnElements(state, "always"));
+    if (previewUrl) elements.push(taskActionRow([turnPreviewAction(previewUrl)]));
+    return turnCard(title, "blue", elements, renderTurnSubtitle(state));
   }
 
   renderActivityHistory(state: TurnViewState, requestedPage: number): Record<string, unknown> {
@@ -2274,7 +2293,7 @@ function renderToolDetails(tool: ToolState, projectCwd?: string): string {
   return codeBlock([`$ ${commandText}`, resultText].filter((part): part is string => part !== undefined).join("\n"), 2_003);
 }
 
-function formatShellCommandForDisplay(command: string): string {
+export function formatShellCommandForDisplay(command: string): string {
   const normalized = command.replace(/\r\n/g, "\n");
   let result = "";
   let quote: "'" | "\"" | undefined;
@@ -2379,7 +2398,7 @@ function toolPanelTitle(tool: ToolState): string {
   const command = stripAnsi(tool.command ?? tool.title).trim();
   const meaningfulCommand = tool.kind === "web_search"
     ? tool.title
-    : unwrapShellCommand(command) ?? tool.title;
+    : displayToolCommand(command) ?? tool.title;
   const duration = toolDuration(tool);
   const prefix = `${icon} `;
   const suffix = duration ? ` · ${duration}` : "";
@@ -2451,6 +2470,11 @@ function shellCommandStatus(view: ShellCommandCardView): {
   return { title: "命令执行失败", label: `退出码 ${view.exitCode ?? "未知"}`, template: "red" };
 }
 
+export function displayToolCommand(command: string): string | undefined {
+  const clean = stripAnsi(command).trim();
+  return unwrapShellCommand(clean);
+}
+
 function unwrapShellCommand(command: string): string | undefined {
   return unwrapPowerShellCommand(command) ?? unwrapPosixShellCommand(command);
 }
@@ -3007,10 +3031,17 @@ function taskActionElement(action: TaskListCardAction): Record<string, unknown>
     elements: [markdown(
       `<font color='${action.type === "danger" ? "red" : "blue"}'>${escapeCardActionText(action.text)}</font>`,
     )],
-    behaviors: [{
-      type: "callback",
-      value: action.value,
-    }],
+    behaviors: action.url
+      ? [{ type: "open_url", default_url: action.url }]
+      : [{ type: "callback", value: action.value }],
+  };
+}
+
+function turnPreviewAction(previewUrl: string): TaskListCardAction {
+  return {
+    text: "Preview",
+    value: {},
+    url: previewUrl,
   };
 }