@zhin.js/adapter-sandbox 1.1.0 → 1.1.3

package/src/protocol.ts

@@ -1,8 +1,7 @@
 /** Sandbox WebSocket wire protocol helpers (no legacy Adapter/Endpoint). */
 
 import { readFileSync } from 'node:fs';
-import { isMediaRef } from '@zhin.js/core';
-import type { ConversationKind, ConversationRef } from '@zhin.js/im-contract';
+import { isMediaRef, type ConversationKind, type ConversationRef } from '@zhin.js/im-contract';
 import { formatCompact, getLogger } from '@zhin.js/logger';
 import {
   normalizeSandboxAgentRunConfig,
@@ -43,33 +42,17 @@ export type ResolvedSandboxBot = {
   readonly randomNamePerConnection: boolean;
 };
 
-export interface SandboxAdapterConfig {
-  /** Runtime expands `endpoints[i]` onto the top level — prefer these. */
-  readonly context?: string;
+/** One endpoint config after AdapterIndex expands `plugins.<instanceKey>.endpoints`. */
+export interface SandboxEndpointConfig {
   readonly id?: string;
   readonly owner?: string;
-  /** Legacy shape: endpoint entries nested under `endpoints[]`. */
-  readonly endpoints?: ReadonlyArray<{
-    readonly context?: string;
-    readonly id?: string;
-    readonly owner?: string;
-  }>;
 }
 
 export function resolveSandboxEndpoint(
-  appConfig: SandboxAdapterConfig,
+  config: SandboxEndpointConfig,
 ): ResolvedSandboxBot {
-  const entry = appConfig.endpoints?.find((item) => item.context === 'sandbox');
-  const fixedName = typeof appConfig.id === 'string' && appConfig.id
-    ? appConfig.id
-    : typeof entry?.id === 'string' && entry.id
-      ? entry.id
-      : undefined;
-  const id = fixedName || process.env.SANDBOX_BOT_NAME || 'sandbox-bot';
-  const owner = (typeof appConfig.owner === 'string' && appConfig.owner)
-    || (typeof entry?.owner === 'string' && entry.owner)
-    || process.env.SANDBOX_BOT_OWNER
-    || 'sandbox-user';
+  const id = optionalEndpointField(config.id) ?? 'sandbox-bot';
+  const owner = optionalEndpointField(config.owner) ?? 'sandbox-user';
   return {
     context: 'sandbox',
     id,
@@ -81,6 +64,10 @@ export function resolveSandboxEndpoint(
   };
 }
 
+function optionalEndpointField(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
 export function bindSandboxWsSocket(
   ws: SandboxWsSocket,
   handlers: {

package/src/run-config.ts

@@ -1,5 +1,5 @@
 export type SandboxSafetyMode = 'read-only' | 'workspace-write' | 'danger-full-access';
-export type SandboxApprovalMode = 'ask' | 'deny' | 'allow';
+export type SandboxApprovalMode = 'ask' | 'auto' | 'bypass';
 
 export interface SandboxAgentRunConfig {
   readonly workingDirectory: string;
@@ -16,7 +16,7 @@ export const DEFAULT_SANDBOX_AGENT_RUN_CONFIG: SandboxAgentRunConfig = Object.fr
 });
 
 const SAFETY_MODES = new Set<SandboxSafetyMode>(['read-only', 'workspace-write', 'danger-full-access']);
-const APPROVAL_MODES = new Set<SandboxApprovalMode>(['ask', 'deny', 'allow']);
+const APPROVAL_MODES = new Set<SandboxApprovalMode>(['ask', 'auto', 'bypass']);
 
 export function normalizeSandboxAgentRunConfig(value: unknown): SandboxAgentRunConfig | undefined {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;

package/agent/skills/sandbox.md

@@ -1,33 +0,0 @@
----
-name: sandbox
-platforms:
-  - sandbox
-description: >-
-  沙箱测试适配器：基于 WebSocket 的本地测试环境，提供浏览器内聊天 UI，
-  无需第三方平台即可调试插件和命令。开发调试专用，无额外 AI 工具。
-keywords:
-  - sandbox
-  - adapter:sandbox
-  - test
-  - 测试
-  - 沙箱
-  - development
-  - 开发
-  - debug
-  - 调试
-tags:
-  - sandbox
-  - testing
-  - development
-tools: []
----
-
-# 沙箱测试适配器
-
-本地开发调试专用。通过浏览器 Web UI 模拟聊天，无需第三方平台凭据。无 AI 工具可调用。
-
-## 使用场景
-
-- 开发新插件时在本地模拟消息收发
-- 调试命令路由和中间件逻辑
-- 依赖 HTTP 服务和 Console 插件提供 Web 界面

package/pages/agentTrace.test.js

@@ -1,235 +0,0 @@
-// Generated by build-plugin-runtime-entries.mjs. Do not edit.
-import { buildSandboxSessionKey, buildAgentRunReport, deriveAgentRunSteps, deriveTaskRuns, deriveWorkbenchArtifacts, loadCachedAgentTrace, mergeTraceSnapshot, presentTraceEvent, summarizeTrace, saveCachedAgentTrace, } from './agentTrace.js';
-const snapshot = {
-    sessionKey: 'sandbox:bot:private:user',
-    latestSequence: 3,
-    activeTurnIds: ['turn-1'],
-    events: [
-        { sequence: 1, recordedAt: 1, sessionKey: 'sandbox:bot:private:user', turnId: 'turn-1', type: 'turn_start', data: {} },
-        { sequence: 2, recordedAt: 2, sessionKey: 'sandbox:bot:private:user', turnId: 'turn-1', type: 'tool_call', data: { toolName: 'lookup' } },
-        { sequence: 3, recordedAt: 3, sessionKey: 'sandbox:bot:private:user', turnId: 'turn-1', type: 'usage', data: { usage: { totalTokens: 218 } } },
-    ],
-};
-class MemoryTraceStorage {
-    values = new Map();
-    getItem(key) { return this.values.get(key) ?? null; }
-    setItem(key, value) { this.values.set(key, value); }
-}
-describe('sandbox agent trace helpers', () => {
-    it('builds the canonical IM session key', () => {
-        expect(buildSandboxSessionKey('sandbox-bot', 'group', 'planning-room')).toBe('sandbox:sandbox-bot:group:planning-room');
-    });
-    it('merges incremental trace snapshots without duplicates', () => {
-        const merged = mergeTraceSnapshot(snapshot, {
-            ...snapshot,
-            latestSequence: 4,
-            activeTurnIds: [],
-            events: [snapshot.events[2], { ...snapshot.events[0], sequence: 4, recordedAt: 4, type: 'turn_end' }],
-        });
-        expect(merged.events.map((event) => event.sequence)).toEqual([1, 2, 3, 4]);
-        expect(merged.activeTurnIds).toEqual([]);
-    });
-    it('persists bounded task history across browser and Host restarts', () => {
-        const storage = new MemoryTraceStorage();
-        expect(saveCachedAgentTrace(snapshot, storage)).toBe(true);
-        const restored = loadCachedAgentTrace(snapshot.sessionKey, storage);
-        expect(restored).toEqual(snapshot);
-        const afterHostRestart = mergeTraceSnapshot(restored, {
-            sessionKey: snapshot.sessionKey,
-            latestSequence: 1,
-            activeTurnIds: ['turn-new'],
-            events: [{
-                    sequence: 1,
-                    recordedAt: 100,
-                    sessionKey: snapshot.sessionKey,
-                    turnId: 'turn-new',
-                    type: 'turn_start',
-                    data: {},
-                }],
-        });
-        expect(afterHostRestart.events.map((event) => event.turnId)).toEqual([
-            'turn-1', 'turn-1', 'turn-1', 'turn-new',
-        ]);
-        expect(afterHostRestart.latestSequence).toBe(1);
-    });
-    it('summarizes operational metrics and presents tool events', () => {
-        expect(summarizeTrace(snapshot)).toEqual({ eventCount: 3, toolCount: 1, tokenCount: 218, problemCount: 0, activeTurns: 1 });
-        expect(presentTraceEvent(snapshot.events[1])).toMatchObject({ title: '调用 lookup', tone: 'tool' });
-    });
-    it('derives stable task lifecycle states from trace terminals', () => {
-        const runs = deriveTaskRuns({
-            sessionKey: snapshot.sessionKey,
-            latestSequence: 9,
-            activeTurnIds: ['turn-running'],
-            events: [
-                { sequence: 1, recordedAt: 10, sessionKey: snapshot.sessionKey, turnId: 'turn-done', type: 'turn_start', data: { sourceMessageId: 'msg-done' } },
-                { sequence: 2, recordedAt: 20, sessionKey: snapshot.sessionKey, turnId: 'turn-done', type: 'tool_call', data: { toolName: 'write_file' } },
-                { sequence: 3, recordedAt: 30, sessionKey: snapshot.sessionKey, turnId: 'turn-done', type: 'usage', data: { usage: { totalTokens: 144 } } },
-                { sequence: 4, recordedAt: 40, sessionKey: snapshot.sessionKey, turnId: 'turn-done', type: 'turn_end', data: {} },
-                { sequence: 5, recordedAt: 50, sessionKey: snapshot.sessionKey, turnId: 'turn-failed', type: 'turn_start', data: {} },
-                { sequence: 6, recordedAt: 60, sessionKey: snapshot.sessionKey, turnId: 'turn-failed', type: 'error', data: { error: { message: 'boom' } } },
-                { sequence: 7, recordedAt: 70, sessionKey: snapshot.sessionKey, turnId: 'turn-running', type: 'turn_start', data: {} },
-                { sequence: 8, recordedAt: 80, sessionKey: snapshot.sessionKey, turnId: 'turn-running', type: 'iteration_start', data: {} },
-                { sequence: 9, recordedAt: 45, sessionKey: snapshot.sessionKey, turnId: 'turn-incomplete', type: 'turn_start', data: {} },
-            ],
-        });
-        expect(runs.map((run) => ({ id: run.turnId, status: run.status }))).toEqual([
-            { id: 'turn-running', status: 'running' },
-            { id: 'turn-failed', status: 'failed' },
-            { id: 'turn-incomplete', status: 'failed' },
-            { id: 'turn-done', status: 'completed' },
-        ]);
-        expect(runs[3]).toMatchObject({ sourceMessageId: 'msg-done', toolCount: 1, tokenCount: 144, durationMs: 30 });
-    });
-    it('projects file edits and test commands into workbench artifacts', () => {
-        const artifacts = deriveWorkbenchArtifacts({
-            sessionKey: snapshot.sessionKey,
-            latestSequence: 4,
-            activeTurnIds: [],
-            events: [
-                { sequence: 1, recordedAt: 1, sessionKey: snapshot.sessionKey, turnId: 'turn-1', type: 'tool_call', data: {
-                        toolName: 'edit_file', toolUseId: 'edit-1', args: {
-                            file_path: '/workspace/src/app.ts', old_string: 'const draft = true', new_string: 'const draft = false',
-                        },
-                    } },
-                { sequence: 2, recordedAt: 2, sessionKey: snapshot.sessionKey, turnId: 'turn-1', type: 'tool_result', data: {
-                        toolName: 'edit_file', toolUseId: 'edit-1', output: 'Edited /workspace/src/app.ts', durationMs: 8,
-                    } },
-                { sequence: 3, recordedAt: 3, sessionKey: snapshot.sessionKey, turnId: 'turn-1', type: 'tool_call', data: {
-                        toolName: 'bash', toolUseId: 'test-1', args: { command: 'pnpm test' },
-                    } },
-                { sequence: 4, recordedAt: 4, sessionKey: snapshot.sessionKey, turnId: 'turn-1', type: 'tool_result', data: {
-                        toolName: 'bash', toolUseId: 'test-1', output: '12 tests passed', durationMs: 42,
-                    } },
-            ],
-        });
-        expect(artifacts).toHaveLength(2);
-        const file = artifacts.find((artifact) => artifact.kind === 'file-change');
-        const test = artifacts.find((artifact) => artifact.kind === 'test');
-        expect(file).toMatchObject({ status: 'completed', path: '/workspace/src/app.ts' });
-        expect(file?.diff).toContain('+++ b/workspace/src/app.ts');
-        expect(file?.diff).toContain('- const draft = true');
-        expect(file?.diff).toContain('+ const draft = false');
-        expect(test).toMatchObject({ status: 'completed', title: 'pnpm test', detail: '12 tests passed' });
-    });
-    it('does not cross-wire reused tool ids across turns or runtime generations', () => {
-        const events = [
-            { runtimeId: 'runtime-old', sequence: 1, recordedAt: 1, sessionKey: snapshot.sessionKey, turnId: 'turn-reused', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'call_1', args: { command: 'pnpm test' } } },
-            { runtimeId: 'runtime-old', sequence: 2, recordedAt: 2, sessionKey: snapshot.sessionKey, turnId: 'turn-reused', type: 'tool_result', data: { toolName: 'bash', toolUseId: 'call_1', output: 'old result' } },
-            { runtimeId: 'runtime-new', sequence: 1, recordedAt: 3, sessionKey: snapshot.sessionKey, turnId: 'turn-reused', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'call_1', args: { command: 'pnpm build' } } },
-            { runtimeId: 'runtime-new', sequence: 2, recordedAt: 4, sessionKey: snapshot.sessionKey, turnId: 'turn-reused', type: 'tool_result', data: { toolName: 'bash', toolUseId: 'call_1', output: 'new result' } },
-        ];
-        const artifacts = deriveWorkbenchArtifacts({
-            runtimeId: 'runtime-new',
-            sessionKey: snapshot.sessionKey,
-            latestSequence: 2,
-            activeTurnIds: [],
-            events,
-        });
-        expect(artifacts.map((artifact) => artifact.detail)).toEqual(['new result', 'old result']);
-        expect(new Set(artifacts.map((artifact) => artifact.id)).size).toBe(2);
-        expect(deriveTaskRuns({
-            runtimeId: 'runtime-new', sessionKey: snapshot.sessionKey, latestSequence: 2, activeTurnIds: [], events,
-        }).map((run) => run.id)).toEqual(['runtime-new:turn-reused', 'runtime-old:turn-reused']);
-    });
-    it('projects a turn into readable, correlated workbench steps', () => {
-        const runSnapshot = {
-            sessionKey: snapshot.sessionKey,
-            latestSequence: 8,
-            activeTurnIds: [],
-            events: [
-                { sequence: 1, recordedAt: 10, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'turn_start', data: {} },
-                { sequence: 2, recordedAt: 12, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'capability_resolution', data: { tools: ['bash'], skills: [] } },
-                { sequence: 3, recordedAt: 14, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'iteration_start', data: { iteration: 1, maxIterations: 8 } },
-                { sequence: 4, recordedAt: 16, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'call-1', args: { command: 'pnpm test' } } },
-                { sequence: 5, recordedAt: 30, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'tool_result', data: { toolName: 'bash', toolUseId: 'call-1', output: '18 tests passed', durationMs: 14 } },
-                { sequence: 6, recordedAt: 32, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'call-2', args: { command: 'pnpm lint' } } },
-                { sequence: 7, recordedAt: 40, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'tool_failed', data: { toolName: 'bash', toolUseId: 'call-2', error: 'lint failed', durationMs: 8 } },
-                { sequence: 8, recordedAt: 42, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'error', data: { error: 'lint failed' } },
-            ],
-        };
-        expect(deriveAgentRunSteps(runSnapshot, { turnId: 'turn-report' })).toEqual([
-            expect.objectContaining({ title: '接收任务', status: 'completed' }),
-            expect.objectContaining({ title: '准备运行能力', detail: '1 tools · 0 skills', status: 'completed' }),
-            expect.objectContaining({ title: '推理迭代 1', status: 'completed' }),
-            expect.objectContaining({ title: '运行 bash', detail: 'pnpm test', status: 'completed', durationMs: 14 }),
-            expect.objectContaining({ title: '运行 bash', detail: 'pnpm lint', status: 'failed', durationMs: 8 }),
-            expect.objectContaining({ title: '任务失败', detail: 'lint failed', status: 'failed' }),
-        ]);
-    });
-    it('does not leave interrupted work looking active after a terminal event', () => {
-        const interrupted = {
-            sessionKey: snapshot.sessionKey,
-            latestSequence: 3,
-            activeTurnIds: [],
-            events: [
-                { sequence: 1, recordedAt: 1, sessionKey: snapshot.sessionKey, turnId: 'turn-stop', type: 'turn_start', data: {} },
-                { sequence: 2, recordedAt: 2, sessionKey: snapshot.sessionKey, turnId: 'turn-stop', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'slow', args: { command: 'pnpm test' } } },
-                { sequence: 3, recordedAt: 3, sessionKey: snapshot.sessionKey, turnId: 'turn-stop', type: 'turn_cancelled', data: { reason: 'user stopped' } },
-            ],
-        };
-        expect(deriveAgentRunSteps(interrupted, { turnId: 'turn-stop' })).toEqual([
-            expect.objectContaining({ title: '接收任务', status: 'completed' }),
-            expect.objectContaining({ title: '运行 bash', status: 'cancelled' }),
-            expect.objectContaining({ title: '任务已停止', status: 'cancelled' }),
-        ]);
-    });
-    it('preserves a completed tool result while a live turn waits for the model', () => {
-        const live = {
-            sessionKey: snapshot.sessionKey,
-            latestSequence: 3,
-            activeTurnIds: ['turn-live'],
-            events: [
-                { sequence: 1, recordedAt: 1, sessionKey: snapshot.sessionKey, turnId: 'turn-live', type: 'turn_start', data: {} },
-                { sequence: 2, recordedAt: 2, sessionKey: snapshot.sessionKey, turnId: 'turn-live', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'done', args: { command: 'pnpm test' } } },
-                { sequence: 3, recordedAt: 3, sessionKey: snapshot.sessionKey, turnId: 'turn-live', type: 'tool_result', data: { toolName: 'bash', toolUseId: 'done', durationMs: 1 } },
-            ],
-        };
-        const steps = deriveAgentRunSteps(live, { turnId: 'turn-live' });
-        expect(steps.at(-2)).toMatchObject({ title: '运行 bash', status: 'completed' });
-        expect(steps.at(-1)).toMatchObject({ title: '等待 Agent 返回', status: 'running' });
-    });
-    it('builds a portable Markdown report for the selected run', () => {
-        const reportSnapshot = {
-            sessionKey: snapshot.sessionKey,
-            latestSequence: 4,
-            activeTurnIds: [],
-            events: [
-                { sequence: 1, recordedAt: 1_000, sessionKey: snapshot.sessionKey, turnId: 'turn-export', type: 'turn_start', data: {} },
-                { sequence: 2, recordedAt: 1_100, sessionKey: snapshot.sessionKey, turnId: 'turn-export', type: 'tool_call', data: { toolName: 'edit_file', toolUseId: 'edit-1', args: { file_path: '/workspace/app.ts', old_string: 'false', new_string: 'true' } } },
-                { sequence: 3, recordedAt: 1_120, sessionKey: snapshot.sessionKey, turnId: 'turn-export', type: 'tool_result', data: { toolName: 'edit_file', toolUseId: 'edit-1', output: 'done', durationMs: 20 } },
-                { sequence: 4, recordedAt: 1_140, sessionKey: snapshot.sessionKey, turnId: 'turn-export', type: 'turn_end', data: {} },
-            ],
-        };
-        const report = buildAgentRunReport(reportSnapshot, {
-            run: { turnId: 'turn-export' },
-            sessionName: '代码审查',
-            taskPrompt: '请修复 `app.ts`',
-            workingDirectory: '/workspace',
-            safetyMode: 'workspace-write',
-            approvalMode: 'ask',
-            networkAccess: false,
-        });
-        expect(report).toContain('# Agent 运行报告');
-        expect(report).toContain('**状态：** 已完成');
-        expect(report).toContain('请修复 `app.ts`');
-        expect(report).toContain('运行 `edit_file`');
-        expect(report).toContain('`/workspace/app.ts`');
-        expect(report).toContain('```diff');
-        expect(report).toContain('+ true');
-    });
-    it('uses longer Markdown fences for untrusted report content', () => {
-        const report = buildAgentRunReport({
-            sessionKey: snapshot.sessionKey,
-            latestSequence: 3,
-            activeTurnIds: [],
-            events: [
-                { sequence: 1, recordedAt: 1, sessionKey: snapshot.sessionKey, turnId: 'turn-fence', type: 'turn_start', data: {} },
-                { sequence: 2, recordedAt: 2, sessionKey: snapshot.sessionKey, turnId: 'turn-fence', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'fence', args: { command: 'echo report' } } },
-                { sequence: 3, recordedAt: 3, sessionKey: snapshot.sessionKey, turnId: 'turn-fence', type: 'tool_result', data: { toolName: 'bash', toolUseId: 'fence', output: '```\n<img src=x onerror=alert(1)>\n```' } },
-            ],
-        }, { run: { turnId: 'turn-fence' }, taskPrompt: '```\n# injected\n```' });
-        expect(report).toContain('````text\n```\n# injected\n```\n````');
-        expect(report).toContain('````text\n```\n<img src=x onerror=alert(1)>\n```\n````');
-    });
-});

package/pages/agentTrace.test.ts

@@ -1,265 +0,0 @@
-import {
-  buildSandboxSessionKey,
-  buildAgentRunReport,
-  deriveAgentRunSteps,
-  deriveTaskRuns,
-  deriveWorkbenchArtifacts,
-  loadCachedAgentTrace,
-  mergeTraceSnapshot,
-  presentTraceEvent,
-  summarizeTrace,
-  saveCachedAgentTrace,
-  type AgentTraceStorage,
-  type AgentTraceSnapshot,
-} from './agentTrace.js';
-
-const snapshot: AgentTraceSnapshot = {
-  sessionKey: 'sandbox:bot:private:user',
-  latestSequence: 3,
-  activeTurnIds: ['turn-1'],
-  events: [
-    { sequence: 1, recordedAt: 1, sessionKey: 'sandbox:bot:private:user', turnId: 'turn-1', type: 'turn_start', data: {} },
-    { sequence: 2, recordedAt: 2, sessionKey: 'sandbox:bot:private:user', turnId: 'turn-1', type: 'tool_call', data: { toolName: 'lookup' } },
-    { sequence: 3, recordedAt: 3, sessionKey: 'sandbox:bot:private:user', turnId: 'turn-1', type: 'usage', data: { usage: { totalTokens: 218 } } },
-  ],
-};
-
-class MemoryTraceStorage implements AgentTraceStorage {
-  readonly values = new Map<string, string>();
-  getItem(key: string): string | null { return this.values.get(key) ?? null; }
-  setItem(key: string, value: string): void { this.values.set(key, value); }
-}
-
-describe('sandbox agent trace helpers', () => {
-  it('builds the canonical IM session key', () => {
-    expect(buildSandboxSessionKey('sandbox-bot', 'group', 'planning-room')).toBe('sandbox:sandbox-bot:group:planning-room');
-  });
-
-  it('merges incremental trace snapshots without duplicates', () => {
-    const merged = mergeTraceSnapshot(snapshot, {
-      ...snapshot,
-      latestSequence: 4,
-      activeTurnIds: [],
-      events: [snapshot.events[2], { ...snapshot.events[0], sequence: 4, recordedAt: 4, type: 'turn_end' }],
-    });
-    expect(merged.events.map((event) => event.sequence)).toEqual([1, 2, 3, 4]);
-    expect(merged.activeTurnIds).toEqual([]);
-  });
-
-  it('persists bounded task history across browser and Host restarts', () => {
-    const storage = new MemoryTraceStorage();
-    expect(saveCachedAgentTrace(snapshot, storage)).toBe(true);
-    const restored = loadCachedAgentTrace(snapshot.sessionKey, storage);
-    expect(restored).toEqual(snapshot);
-
-    const afterHostRestart = mergeTraceSnapshot(restored, {
-      sessionKey: snapshot.sessionKey,
-      latestSequence: 1,
-      activeTurnIds: ['turn-new'],
-      events: [{
-        sequence: 1,
-        recordedAt: 100,
-        sessionKey: snapshot.sessionKey,
-        turnId: 'turn-new',
-        type: 'turn_start',
-        data: {},
-      }],
-    });
-    expect(afterHostRestart.events.map((event) => event.turnId)).toEqual([
-      'turn-1', 'turn-1', 'turn-1', 'turn-new',
-    ]);
-    expect(afterHostRestart.latestSequence).toBe(1);
-  });
-
-  it('summarizes operational metrics and presents tool events', () => {
-    expect(summarizeTrace(snapshot)).toEqual({ eventCount: 3, toolCount: 1, tokenCount: 218, problemCount: 0, activeTurns: 1 });
-    expect(presentTraceEvent(snapshot.events[1])).toMatchObject({ title: '调用 lookup', tone: 'tool' });
-  });
-
-  it('derives stable task lifecycle states from trace terminals', () => {
-    const runs = deriveTaskRuns({
-      sessionKey: snapshot.sessionKey,
-      latestSequence: 9,
-      activeTurnIds: ['turn-running'],
-      events: [
-        { sequence: 1, recordedAt: 10, sessionKey: snapshot.sessionKey, turnId: 'turn-done', type: 'turn_start', data: { sourceMessageId: 'msg-done' } },
-        { sequence: 2, recordedAt: 20, sessionKey: snapshot.sessionKey, turnId: 'turn-done', type: 'tool_call', data: { toolName: 'write_file' } },
-        { sequence: 3, recordedAt: 30, sessionKey: snapshot.sessionKey, turnId: 'turn-done', type: 'usage', data: { usage: { totalTokens: 144 } } },
-        { sequence: 4, recordedAt: 40, sessionKey: snapshot.sessionKey, turnId: 'turn-done', type: 'turn_end', data: {} },
-        { sequence: 5, recordedAt: 50, sessionKey: snapshot.sessionKey, turnId: 'turn-failed', type: 'turn_start', data: {} },
-        { sequence: 6, recordedAt: 60, sessionKey: snapshot.sessionKey, turnId: 'turn-failed', type: 'error', data: { error: { message: 'boom' } } },
-        { sequence: 7, recordedAt: 70, sessionKey: snapshot.sessionKey, turnId: 'turn-running', type: 'turn_start', data: {} },
-        { sequence: 8, recordedAt: 80, sessionKey: snapshot.sessionKey, turnId: 'turn-running', type: 'iteration_start', data: {} },
-        { sequence: 9, recordedAt: 45, sessionKey: snapshot.sessionKey, turnId: 'turn-incomplete', type: 'turn_start', data: {} },
-      ],
-    });
-    expect(runs.map((run) => ({ id: run.turnId, status: run.status }))).toEqual([
-      { id: 'turn-running', status: 'running' },
-      { id: 'turn-failed', status: 'failed' },
-      { id: 'turn-incomplete', status: 'failed' },
-      { id: 'turn-done', status: 'completed' },
-    ]);
-    expect(runs[3]).toMatchObject({ sourceMessageId: 'msg-done', toolCount: 1, tokenCount: 144, durationMs: 30 });
-  });
-
-  it('projects file edits and test commands into workbench artifacts', () => {
-    const artifacts = deriveWorkbenchArtifacts({
-      sessionKey: snapshot.sessionKey,
-      latestSequence: 4,
-      activeTurnIds: [],
-      events: [
-        { sequence: 1, recordedAt: 1, sessionKey: snapshot.sessionKey, turnId: 'turn-1', type: 'tool_call', data: {
-          toolName: 'edit_file', toolUseId: 'edit-1', args: {
-            file_path: '/workspace/src/app.ts', old_string: 'const draft = true', new_string: 'const draft = false',
-          },
-        } },
-        { sequence: 2, recordedAt: 2, sessionKey: snapshot.sessionKey, turnId: 'turn-1', type: 'tool_result', data: {
-          toolName: 'edit_file', toolUseId: 'edit-1', output: 'Edited /workspace/src/app.ts', durationMs: 8,
-        } },
-        { sequence: 3, recordedAt: 3, sessionKey: snapshot.sessionKey, turnId: 'turn-1', type: 'tool_call', data: {
-          toolName: 'bash', toolUseId: 'test-1', args: { command: 'pnpm test' },
-        } },
-        { sequence: 4, recordedAt: 4, sessionKey: snapshot.sessionKey, turnId: 'turn-1', type: 'tool_result', data: {
-          toolName: 'bash', toolUseId: 'test-1', output: '12 tests passed', durationMs: 42,
-        } },
-      ],
-    });
-    expect(artifacts).toHaveLength(2);
-    const file = artifacts.find((artifact) => artifact.kind === 'file-change');
-    const test = artifacts.find((artifact) => artifact.kind === 'test');
-    expect(file).toMatchObject({ status: 'completed', path: '/workspace/src/app.ts' });
-    expect(file?.diff).toContain('+++ b/workspace/src/app.ts');
-    expect(file?.diff).toContain('- const draft = true');
-    expect(file?.diff).toContain('+ const draft = false');
-    expect(test).toMatchObject({ status: 'completed', title: 'pnpm test', detail: '12 tests passed' });
-  });
-
-  it('does not cross-wire reused tool ids across turns or runtime generations', () => {
-    const events = [
-      { runtimeId: 'runtime-old', sequence: 1, recordedAt: 1, sessionKey: snapshot.sessionKey, turnId: 'turn-reused', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'call_1', args: { command: 'pnpm test' } } },
-      { runtimeId: 'runtime-old', sequence: 2, recordedAt: 2, sessionKey: snapshot.sessionKey, turnId: 'turn-reused', type: 'tool_result', data: { toolName: 'bash', toolUseId: 'call_1', output: 'old result' } },
-      { runtimeId: 'runtime-new', sequence: 1, recordedAt: 3, sessionKey: snapshot.sessionKey, turnId: 'turn-reused', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'call_1', args: { command: 'pnpm build' } } },
-      { runtimeId: 'runtime-new', sequence: 2, recordedAt: 4, sessionKey: snapshot.sessionKey, turnId: 'turn-reused', type: 'tool_result', data: { toolName: 'bash', toolUseId: 'call_1', output: 'new result' } },
-    ] satisfies AgentTraceSnapshot['events'];
-    const artifacts = deriveWorkbenchArtifacts({
-      runtimeId: 'runtime-new',
-      sessionKey: snapshot.sessionKey,
-      latestSequence: 2,
-      activeTurnIds: [],
-      events,
-    });
-    expect(artifacts.map((artifact) => artifact.detail)).toEqual(['new result', 'old result']);
-    expect(new Set(artifacts.map((artifact) => artifact.id)).size).toBe(2);
-    expect(deriveTaskRuns({
-      runtimeId: 'runtime-new', sessionKey: snapshot.sessionKey, latestSequence: 2, activeTurnIds: [], events,
-    }).map((run) => run.id)).toEqual(['runtime-new:turn-reused', 'runtime-old:turn-reused']);
-  });
-
-  it('projects a turn into readable, correlated workbench steps', () => {
-    const runSnapshot: AgentTraceSnapshot = {
-      sessionKey: snapshot.sessionKey,
-      latestSequence: 8,
-      activeTurnIds: [],
-      events: [
-        { sequence: 1, recordedAt: 10, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'turn_start', data: {} },
-        { sequence: 2, recordedAt: 12, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'capability_resolution', data: { tools: ['bash'], skills: [] } },
-        { sequence: 3, recordedAt: 14, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'iteration_start', data: { iteration: 1, maxIterations: 8 } },
-        { sequence: 4, recordedAt: 16, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'call-1', args: { command: 'pnpm test' } } },
-        { sequence: 5, recordedAt: 30, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'tool_result', data: { toolName: 'bash', toolUseId: 'call-1', output: '18 tests passed', durationMs: 14 } },
-        { sequence: 6, recordedAt: 32, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'call-2', args: { command: 'pnpm lint' } } },
-        { sequence: 7, recordedAt: 40, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'tool_failed', data: { toolName: 'bash', toolUseId: 'call-2', error: 'lint failed', durationMs: 8 } },
-        { sequence: 8, recordedAt: 42, sessionKey: snapshot.sessionKey, turnId: 'turn-report', type: 'error', data: { error: 'lint failed' } },
-      ],
-    };
-
-    expect(deriveAgentRunSteps(runSnapshot, { turnId: 'turn-report' })).toEqual([
-      expect.objectContaining({ title: '接收任务', status: 'completed' }),
-      expect.objectContaining({ title: '准备运行能力', detail: '1 tools · 0 skills', status: 'completed' }),
-      expect.objectContaining({ title: '推理迭代 1', status: 'completed' }),
-      expect.objectContaining({ title: '运行 bash', detail: 'pnpm test', status: 'completed', durationMs: 14 }),
-      expect.objectContaining({ title: '运行 bash', detail: 'pnpm lint', status: 'failed', durationMs: 8 }),
-      expect.objectContaining({ title: '任务失败', detail: 'lint failed', status: 'failed' }),
-    ]);
-  });
-
-  it('does not leave interrupted work looking active after a terminal event', () => {
-    const interrupted: AgentTraceSnapshot = {
-      sessionKey: snapshot.sessionKey,
-      latestSequence: 3,
-      activeTurnIds: [],
-      events: [
-        { sequence: 1, recordedAt: 1, sessionKey: snapshot.sessionKey, turnId: 'turn-stop', type: 'turn_start', data: {} },
-        { sequence: 2, recordedAt: 2, sessionKey: snapshot.sessionKey, turnId: 'turn-stop', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'slow', args: { command: 'pnpm test' } } },
-        { sequence: 3, recordedAt: 3, sessionKey: snapshot.sessionKey, turnId: 'turn-stop', type: 'turn_cancelled', data: { reason: 'user stopped' } },
-      ],
-    };
-    expect(deriveAgentRunSteps(interrupted, { turnId: 'turn-stop' })).toEqual([
-      expect.objectContaining({ title: '接收任务', status: 'completed' }),
-      expect.objectContaining({ title: '运行 bash', status: 'cancelled' }),
-      expect.objectContaining({ title: '任务已停止', status: 'cancelled' }),
-    ]);
-  });
-
-  it('preserves a completed tool result while a live turn waits for the model', () => {
-    const live: AgentTraceSnapshot = {
-      sessionKey: snapshot.sessionKey,
-      latestSequence: 3,
-      activeTurnIds: ['turn-live'],
-      events: [
-        { sequence: 1, recordedAt: 1, sessionKey: snapshot.sessionKey, turnId: 'turn-live', type: 'turn_start', data: {} },
-        { sequence: 2, recordedAt: 2, sessionKey: snapshot.sessionKey, turnId: 'turn-live', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'done', args: { command: 'pnpm test' } } },
-        { sequence: 3, recordedAt: 3, sessionKey: snapshot.sessionKey, turnId: 'turn-live', type: 'tool_result', data: { toolName: 'bash', toolUseId: 'done', durationMs: 1 } },
-      ],
-    };
-    const steps = deriveAgentRunSteps(live, { turnId: 'turn-live' });
-    expect(steps.at(-2)).toMatchObject({ title: '运行 bash', status: 'completed' });
-    expect(steps.at(-1)).toMatchObject({ title: '等待 Agent 返回', status: 'running' });
-  });
-
-  it('builds a portable Markdown report for the selected run', () => {
-    const reportSnapshot: AgentTraceSnapshot = {
-      sessionKey: snapshot.sessionKey,
-      latestSequence: 4,
-      activeTurnIds: [],
-      events: [
-        { sequence: 1, recordedAt: 1_000, sessionKey: snapshot.sessionKey, turnId: 'turn-export', type: 'turn_start', data: {} },
-        { sequence: 2, recordedAt: 1_100, sessionKey: snapshot.sessionKey, turnId: 'turn-export', type: 'tool_call', data: { toolName: 'edit_file', toolUseId: 'edit-1', args: { file_path: '/workspace/app.ts', old_string: 'false', new_string: 'true' } } },
-        { sequence: 3, recordedAt: 1_120, sessionKey: snapshot.sessionKey, turnId: 'turn-export', type: 'tool_result', data: { toolName: 'edit_file', toolUseId: 'edit-1', output: 'done', durationMs: 20 } },
-        { sequence: 4, recordedAt: 1_140, sessionKey: snapshot.sessionKey, turnId: 'turn-export', type: 'turn_end', data: {} },
-      ],
-    };
-
-    const report = buildAgentRunReport(reportSnapshot, {
-      run: { turnId: 'turn-export' },
-      sessionName: '代码审查',
-      taskPrompt: '请修复 `app.ts`',
-      workingDirectory: '/workspace',
-      safetyMode: 'workspace-write',
-      approvalMode: 'ask',
-      networkAccess: false,
-    });
-
-    expect(report).toContain('# Agent 运行报告');
-    expect(report).toContain('**状态：** 已完成');
-    expect(report).toContain('请修复 `app.ts`');
-    expect(report).toContain('运行 `edit_file`');
-    expect(report).toContain('`/workspace/app.ts`');
-    expect(report).toContain('```diff');
-    expect(report).toContain('+ true');
-  });
-
-  it('uses longer Markdown fences for untrusted report content', () => {
-    const report = buildAgentRunReport({
-      sessionKey: snapshot.sessionKey,
-      latestSequence: 3,
-      activeTurnIds: [],
-      events: [
-        { sequence: 1, recordedAt: 1, sessionKey: snapshot.sessionKey, turnId: 'turn-fence', type: 'turn_start', data: {} },
-        { sequence: 2, recordedAt: 2, sessionKey: snapshot.sessionKey, turnId: 'turn-fence', type: 'tool_call', data: { toolName: 'bash', toolUseId: 'fence', args: { command: 'echo report' } } },
-        { sequence: 3, recordedAt: 3, sessionKey: snapshot.sessionKey, turnId: 'turn-fence', type: 'tool_result', data: { toolName: 'bash', toolUseId: 'fence', output: '```\n<img src=x onerror=alert(1)>\n```' } },
-      ],
-    }, { run: { turnId: 'turn-fence' }, taskPrompt: '```\n# injected\n```' });
-    expect(report).toContain('````text\n```\n# injected\n```\n````');
-    expect(report).toContain('````text\n```\n<img src=x onerror=alert(1)>\n```\n````');
-  });
-});