feat: ACP 协议版本 remote control (#293)

* fix: 添加 usage 字段缺失时的防御性防护

第三方 API（如智谱 GLM）在某些流式响应中不返回 usage 字段，
导致 usage.input_tokens 访问 undefined 崩溃并连锁影响后续所有请求。

- claude.ts: content_block_stop 创建消息时 fallback 到 EMPTY_USAGE
- LocalAgentTask.tsx: usage 为 undefined 时提前返回
- tokens.ts: getTokenCountFromUsage 加 null guard 和 ?? 0
- cost-tracker.ts: input_tokens/output_tokens 加 ?? 0

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat: ACP Plan 展示 — 支持 session/update plan 类型的可视化

补全 PlanUpdate 类型定义（PlanEntry/Priority/Status），新建 PlanView 组件
渲染进度条、状态图标和优先级标签，在 ChatInterface 中处理 plan 更新逻辑。

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat: 穷鬼模式下跳过 verification agent 以节省 token

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* test: 补充 RCS 后端 + 前端测试覆盖 (+116 tests)

后端新增 3 个测试文件 (70 tests):
- automationState: normalize/snapshot/equals 纯函数
- client-payload: toClientPayload 协议转换
- transport-normalize: normalizePayload + extractContent

前端新增 2 个测试文件 (46 tests):
- utils: formatTime/statusClass/truncate/extractEventText 等
- api-client: getUuid/setUuid/api GET/POST 错误处理

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat: RCS ACP 页面添加权限模式选择器 + 权限响应修复

- 新增权限模式选择器 UI（6种模式：默认/自动接受编辑/跳过权限/规划/不询问/自动判断）
- 权限模式通过 ACP _meta 从 web → acp-link → agent 全链路传递
- 修复 PermissionPanel 点击"允许"发送 cancelled 而非 selected 的 bug
- 权限模式和模型选择持久化到 localStorage
- acp-link 直接连接路径同步支持 permissionMode 透传

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat: RCS Web UI 重构 + QR 修复 + ACP 扫描自动跳转

- RCS Web UI 组件全面重构: Dialog 迁移 Radix UI, lazy loading,
  主题系统改进, 组件样式优化
- IdentityPanel QR 码显示修复: requestAnimationFrame 延迟绘制
  解决 Radix Dialog Portal 挂载时序问题
- ACP QR 扫描自动跳转: IdentityPanel 扫描 ACP 格式 { url, token }
  后存储 sessionStorage 并跳转 /code/?acp=1
- 新增 ACPDirectView 组件: ACP 直连视图, 用 ACPClient 连接并
  渲染 ACPMain 聊天界面

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat: ACP 权限管道改进 — 模式同步 + bypass 检测 + 统一权限流水线

- agent.ts: applySessionMode 同步 appState.toolPermissionContext.mode
- agent.ts: bypassPermissions 可用性检测 (非 root 或 sandbox 环境)
- permissions.ts: createAcpCanUseTool 接入 hasPermissionsToUseTool
  统一权限流水线, 替代原来分散的处理逻辑
- permissions.ts: 支持 onModeChange 回调, 模式变更时实时同步

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: acp-link 支持 permissionMode 默认值传递给 agent

客户端 (Zed/VS Code 等) 的 new_session 不一定携带 permissionMode,
导致 agent 收到 _meta: undefined, permission 回退到 default。

修复: handleNewSession 使用 fallback 链:
  客户端传值 > config.permissionMode > ACP_PERMISSION_MODE 环境变量

使用: ACP_PERMISSION_MODE=auto acp-link claude

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* docs: 更新文档及说明

* fix: 修复类型错误

* chore: 提交脚本

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

packages/remote-control-server/src/__tests__/automationState.test.ts

@@ -0,0 +1,182 @@
+import { describe, test, expect } from "bun:test";
+import {
+  getAutomationStateSnapshot,
+  getAutomationStateEventPayload,
+  automationStatesEqual,
+} from "../services/automationState";
+import type { AutomationStateResponse } from "../types/api";
+
+// =============================================================================
+// normalizeAutomationState (via getAutomationStateSnapshot)
+// =============================================================================
+
+describe("normalizeAutomationState", () => {
+  test("returns undefined when metadata has no automation_state key", () => {
+    expect(getAutomationStateSnapshot({})).toBeUndefined();
+    expect(getAutomationStateSnapshot({ other: true })).toBeUndefined();
+    expect(getAutomationStateSnapshot(null)).toBeUndefined();
+    expect(getAutomationStateSnapshot(undefined)).toBeUndefined();
+  });
+
+  test("returns disabled state for null automation_state", () => {
+    const result = getAutomationStateSnapshot({ automation_state: null });
+    expect(result).toEqual({
+      enabled: false,
+      phase: null,
+      next_tick_at: null,
+      sleep_until: null,
+    });
+  });
+
+  test("returns disabled state for non-object automation_state", () => {
+    for (const val of ["string", 123, true, []]) {
+      const result = getAutomationStateSnapshot({ automation_state: val });
+      expect(result?.enabled).toBe(false);
+    }
+  });
+
+  test("normalizes enabled: true correctly", () => {
+    const result = getAutomationStateSnapshot({ automation_state: { enabled: true } });
+    expect(result?.enabled).toBe(true);
+  });
+
+  test("normalizes enabled to false for non-true values", () => {
+    const result = getAutomationStateSnapshot({ automation_state: { enabled: "yes" } });
+    expect(result?.enabled).toBe(false);
+  });
+
+  test("accepts phase: standby", () => {
+    const result = getAutomationStateSnapshot({ automation_state: { enabled: true, phase: "standby" } });
+    expect(result?.phase).toBe("standby");
+  });
+
+  test("accepts phase: sleeping", () => {
+    const result = getAutomationStateSnapshot({ automation_state: { enabled: true, phase: "sleeping" } });
+    expect(result?.phase).toBe("sleeping");
+  });
+
+  test("rejects invalid phase values", () => {
+    for (const phase of ["running", "idle", "active", "", null]) {
+      const result = getAutomationStateSnapshot({ automation_state: { enabled: true, phase } });
+      expect(result?.phase).toBeNull();
+    }
+  });
+
+  test("normalizes next_tick_at as number", () => {
+    const result = getAutomationStateSnapshot({ automation_state: { enabled: true, next_tick_at: 12345 } });
+    expect(result?.next_tick_at).toBe(12345);
+  });
+
+  test("normalizes next_tick_at as null for non-number", () => {
+    const result = getAutomationStateSnapshot({ automation_state: { enabled: true, next_tick_at: "soon" } });
+    expect(result?.next_tick_at).toBeNull();
+  });
+
+  test("normalizes sleep_until as number", () => {
+    const result = getAutomationStateSnapshot({ automation_state: { enabled: true, sleep_until: 99999 } });
+    expect(result?.sleep_until).toBe(99999);
+  });
+
+  test("normalizes sleep_until as null for non-number", () => {
+    const result = getAutomationStateSnapshot({ automation_state: { enabled: true, sleep_until: false } });
+    expect(result?.sleep_until).toBeNull();
+  });
+
+  test("fully normalizes a complete valid state", () => {
+    const result = getAutomationStateSnapshot({
+      automation_state: { enabled: true, phase: "sleeping", next_tick_at: 100, sleep_until: 200 },
+    });
+    expect(result).toEqual({
+      enabled: true,
+      phase: "sleeping",
+      next_tick_at: 100,
+      sleep_until: 200,
+    });
+  });
+});
+
+// =============================================================================
+// getAutomationStateEventPayload
+// =============================================================================
+
+describe("getAutomationStateEventPayload", () => {
+  test("returns disabled default when no automation_state in metadata", () => {
+    const result = getAutomationStateEventPayload({});
+    expect(result).toEqual({
+      enabled: false,
+      phase: null,
+      next_tick_at: null,
+      sleep_until: null,
+    });
+  });
+
+  test("returns disabled default for null metadata", () => {
+    const result = getAutomationStateEventPayload(null);
+    expect(result).toEqual({
+      enabled: false,
+      phase: null,
+      next_tick_at: null,
+      sleep_until: null,
+    });
+  });
+
+  test("returns normalized state when automation_state present", () => {
+    const result = getAutomationStateEventPayload({
+      automation_state: { enabled: true, phase: "standby", next_tick_at: 50, sleep_until: 60 },
+    });
+    expect(result).toEqual({
+      enabled: true,
+      phase: "standby",
+      next_tick_at: 50,
+      sleep_until: 60,
+    });
+  });
+
+  test("returns a new object each call (not frozen reference)", () => {
+    const a = getAutomationStateEventPayload({});
+    const b = getAutomationStateEventPayload({});
+    expect(a).toEqual(b);
+    expect(a).not.toBe(b);
+  });
+});
+
+// =============================================================================
+// automationStatesEqual
+// =============================================================================
+
+describe("automationStatesEqual", () => {
+  const base: AutomationStateResponse = {
+    enabled: true,
+    phase: "standby",
+    next_tick_at: 100,
+    sleep_until: 200,
+  };
+
+  test("returns true for identical states", () => {
+    expect(automationStatesEqual(base, { ...base })).toBe(true);
+  });
+
+  test("returns false when enabled differs", () => {
+    expect(automationStatesEqual(base, { ...base, enabled: false })).toBe(false);
+  });
+
+  test("returns false when phase differs", () => {
+    expect(automationStatesEqual(base, { ...base, phase: "sleeping" })).toBe(false);
+    expect(automationStatesEqual(base, { ...base, phase: null })).toBe(false);
+  });
+
+  test("returns false when next_tick_at differs", () => {
+    expect(automationStatesEqual(base, { ...base, next_tick_at: 999 })).toBe(false);
+    expect(automationStatesEqual(base, { ...base, next_tick_at: null })).toBe(false);
+  });
+
+  test("returns false when sleep_until differs", () => {
+    expect(automationStatesEqual(base, { ...base, sleep_until: 999 })).toBe(false);
+    expect(automationStatesEqual(base, { ...base, sleep_until: null })).toBe(false);
+  });
+
+  test("returns true when both are disabled defaults", () => {
+    const disabled: AutomationStateResponse = { enabled: false, phase: null, next_tick_at: null, sleep_until: null };
+    expect(automationStatesEqual(disabled, { ...disabled })).toBe(true);
+  });
+});

packages/remote-control-server/src/__tests__/client-payload.test.ts

@@ -0,0 +1,256 @@
+import { describe, test, expect } from "bun:test";
+import { toClientPayload } from "../transport/client-payload";
+import type { SessionEvent } from "../transport/event-bus";
+
+function makeEvent(overrides: Partial<SessionEvent> & Pick<SessionEvent, "type" | "sessionId">): SessionEvent {
+  return {
+    id: "evt-1",
+    payload: null,
+    direction: "inbound",
+    seqNum: 1,
+    createdAt: Date.now(),
+    ...overrides,
+  };
+}
+
+// =============================================================================
+// user / user_message
+// =============================================================================
+
+describe("toClientPayload — user message", () => {
+  test("maps user type with content", () => {
+    const event = makeEvent({
+      type: "user",
+      sessionId: "sess-1",
+      payload: { content: "hello" },
+    });
+    const result = toClientPayload(event);
+    expect(result.type).toBe("user");
+    expect(result.session_id).toBe("sess-1");
+    expect((result as any).message.role).toBe("user");
+    expect((result as any).message.content).toBe("hello");
+  });
+
+  test("maps user_message type same as user", () => {
+    const event = makeEvent({
+      type: "user_message",
+      sessionId: "sess-2",
+      payload: { content: "world" },
+    });
+    const result = toClientPayload(event);
+    expect(result.type).toBe("user");
+    expect(result.session_id).toBe("sess-2");
+  });
+
+  test("falls back to message field when content is missing", () => {
+    const event = makeEvent({
+      type: "user",
+      sessionId: "sess-3",
+      payload: { message: "fallback msg" },
+    });
+    const result = toClientPayload(event);
+    expect((result as any).message.content).toBe("fallback msg");
+  });
+
+  test("falls back to empty string when both content and message missing", () => {
+    const event = makeEvent({
+      type: "user",
+      sessionId: "sess-4",
+      payload: {},
+    });
+    const result = toClientPayload(event);
+    expect((result as any).message.content).toBe("");
+  });
+
+  test("includes isSynthetic when true", () => {
+    const event = makeEvent({
+      type: "user",
+      sessionId: "sess-5",
+      payload: { content: "auto", isSynthetic: true },
+    });
+    const result = toClientPayload(event);
+    expect((result as any).isSynthetic).toBe(true);
+  });
+
+  test("does not include isSynthetic when false", () => {
+    const event = makeEvent({
+      type: "user",
+      sessionId: "sess-6",
+      payload: { content: "manual", isSynthetic: false },
+    });
+    const result = toClientPayload(event);
+    expect((result as any).isSynthetic).toBeUndefined();
+  });
+
+  test("uses payload.uuid when present", () => {
+    const event = makeEvent({
+      type: "user",
+      sessionId: "sess-7",
+      payload: { content: "hi", uuid: "custom-uuid" },
+    });
+    const result = toClientPayload(event);
+    expect(result.uuid).toBe("custom-uuid");
+  });
+
+  test("falls back to event.id when payload.uuid is missing", () => {
+    const event = makeEvent({
+      type: "user",
+      sessionId: "sess-8",
+      payload: { content: "hi" },
+    });
+    const result = toClientPayload(event);
+    expect(result.uuid).toBe("evt-1");
+  });
+});
+
+// =============================================================================
+// permission_response / control_response
+// =============================================================================
+
+describe("toClientPayload — permission response", () => {
+  test("approved=true maps to allow behavior", () => {
+    const event = makeEvent({
+      type: "permission_response",
+      sessionId: "sess-1",
+      payload: { approved: true, request_id: "req-1" },
+    });
+    const result = toClientPayload(event);
+    expect(result.type).toBe("control_response");
+    const resp = (result as any).response;
+    expect(resp.subtype).toBe("success");
+    expect(resp.request_id).toBe("req-1");
+    expect(resp.response.behavior).toBe("allow");
+  });
+
+  test("approved=false maps to deny behavior with error", () => {
+    const event = makeEvent({
+      type: "permission_response",
+      sessionId: "sess-2",
+      payload: { approved: false, request_id: "req-2" },
+    });
+    const result = toClientPayload(event);
+    expect(result.type).toBe("control_response");
+    const resp = (result as any).response;
+    expect(resp.subtype).toBe("error");
+    expect(resp.error).toBe("Permission denied by user");
+    expect(resp.response.behavior).toBe("deny");
+  });
+
+  test("approved=false includes feedback message when provided", () => {
+    const event = makeEvent({
+      type: "permission_response",
+      sessionId: "sess-3",
+      payload: { approved: false, request_id: "req-3", message: "please revise" },
+    });
+    const result = toClientPayload(event);
+    expect((result as any).response.message).toBe("please revise");
+  });
+
+  test("passes through existingResponse directly", () => {
+    const existingResponse = { subtype: "success", custom: true };
+    const event = makeEvent({
+      type: "control_response",
+      sessionId: "sess-4",
+      payload: { approved: true, response: existingResponse },
+    });
+    const result = toClientPayload(event);
+    expect(result.type).toBe("control_response");
+    expect((result as any).response).toBe(existingResponse);
+  });
+
+  test("includes updatedInput when approved with updated_input", () => {
+    const updatedInput = { file_path: "/new/path" };
+    const event = makeEvent({
+      type: "permission_response",
+      sessionId: "sess-5",
+      payload: { approved: true, request_id: "req-5", updated_input: updatedInput },
+    });
+    const result = toClientPayload(event);
+    expect((result as any).response.response.updatedInput).toEqual(updatedInput);
+  });
+
+  test("includes updatedPermissions when approved with updated_permissions", () => {
+    const perms = [{ type: "allow", tool: "bash" }];
+    const event = makeEvent({
+      type: "permission_response",
+      sessionId: "sess-6",
+      payload: { approved: true, request_id: "req-6", updated_permissions: perms },
+    });
+    const result = toClientPayload(event);
+    expect((result as any).response.response.updatedPermissions).toEqual(perms);
+  });
+});
+
+// =============================================================================
+// interrupt
+// =============================================================================
+
+describe("toClientPayload — interrupt", () => {
+  test("maps interrupt to control_request with subtype interrupt", () => {
+    const event = makeEvent({
+      type: "interrupt",
+      sessionId: "sess-1",
+    });
+    const result = toClientPayload(event);
+    expect(result.type).toBe("control_request");
+    expect((result as any).request_id).toBe("evt-1");
+    expect((result as any).request.subtype).toBe("interrupt");
+  });
+});
+
+// =============================================================================
+// control_request
+// =============================================================================
+
+describe("toClientPayload — control_request", () => {
+  test("passes through request_id and request from payload", () => {
+    const event = makeEvent({
+      type: "control_request",
+      sessionId: "sess-1",
+      payload: { request_id: "req-99", request: { subtype: "permission", tool: "bash" } },
+    });
+    const result = toClientPayload(event);
+    expect(result.type).toBe("control_request");
+    expect((result as any).request_id).toBe("req-99");
+    expect((result as any).request.subtype).toBe("permission");
+  });
+
+  test("falls back request to payload when no request field", () => {
+    const event = makeEvent({
+      type: "control_request",
+      sessionId: "sess-2",
+      payload: { request_id: "req-10", custom: "data" },
+    });
+    const result = toClientPayload(event);
+    expect((result as any).request).toEqual({ request_id: "req-10", custom: "data" });
+  });
+
+  test("falls back request_id to event.id when missing", () => {
+    const event = makeEvent({
+      type: "control_request",
+      sessionId: "sess-3",
+      payload: { request: { subtype: "test" } },
+    });
+    const result = toClientPayload(event);
+    expect((result as any).request_id).toBe("evt-1");
+  });
+});
+
+// =============================================================================
+// default fallback
+// =============================================================================
+
+describe("toClientPayload — default types", () => {
+  test("passes through unknown type with type/uuid/session_id/message", () => {
+    const event = makeEvent({
+      type: "assistant",
+      sessionId: "sess-1",
+      payload: { uuid: "u-1", content: "response text" },
+    });
+    const result = toClientPayload(event);
+    expect(result.type).toBe("assistant");
+    expect(result.uuid).toBe("u-1");
+    expect(result.session_id).toBe("sess-1");
+    expect(result.message).toEqual({ uuid: "u-1", content: "response text" });
+  });
+});

packages/remote-control-server/src/__tests__/transport-normalize.test.ts

@@ -0,0 +1,188 @@
+import { describe, test, expect } from "bun:test";
+
+const { normalizePayload } = await import("../services/transport");
+
+// extractContent is not exported; we test it via normalizePayload's content field
+
+// =============================================================================
+// extractContent (via normalizePayload content field)
+// =============================================================================
+
+describe("extractContent", () => {
+  test("returns empty string for null payload", () => {
+    const result = normalizePayload("assistant", null);
+    expect(result.content).toBe("");
+  });
+
+  test("returns empty string for undefined payload", () => {
+    const result = normalizePayload("assistant", undefined);
+    expect(result.content).toBe("");
+  });
+
+  test("returns the string for string payload", () => {
+    const result = normalizePayload("assistant", "hello world");
+    expect(result.content).toBe("hello world");
+  });
+
+  test("extracts content field from object payload", () => {
+    const result = normalizePayload("assistant", { content: "direct content" });
+    expect(result.content).toBe("direct content");
+  });
+
+  test("extracts message.content string from object payload", () => {
+    const result = normalizePayload("assistant", { message: { content: "msg content" } });
+    expect(result.content).toBe("msg content");
+  });
+
+  test("extracts text blocks from message.content array", () => {
+    const payload = {
+      message: {
+        content: [
+          { type: "text", text: "Hello " },
+          { type: "text", text: "World" },
+        ],
+      },
+    };
+    const result = normalizePayload("assistant", payload);
+    expect(result.content).toBe("Hello World");
+  });
+
+  test("ignores non-text blocks in message.content array", () => {
+    const payload = {
+      message: {
+        content: [
+          { type: "image", url: "http://example.com/img.png" },
+          { type: "text", text: "only this" },
+        ],
+      },
+    };
+    const result = normalizePayload("assistant", payload);
+    expect(result.content).toBe("only this");
+  });
+
+  test("returns empty string when no extractable content", () => {
+    const result = normalizePayload("assistant", { foo: "bar" });
+    expect(result.content).toBe("");
+  });
+
+  test("prefers direct content over message.content", () => {
+    const result = normalizePayload("assistant", { content: "direct", message: { content: "nested" } });
+    expect(result.content).toBe("direct");
+  });
+});
+
+// =============================================================================
+// normalizePayload — field preservation
+// =============================================================================
+
+describe("normalizePayload — field preservation", () => {
+  test("preserves raw payload", () => {
+    const payload = { content: "test", extra: true };
+    const result = normalizePayload("assistant", payload);
+    expect(result.raw).toBe(payload);
+  });
+
+  test("preserves uuid field", () => {
+    const result = normalizePayload("assistant", { uuid: "u-123" });
+    expect(result.uuid).toBe("u-123");
+  });
+
+  test("does not preserve uuid when empty string", () => {
+    const result = normalizePayload("assistant", { uuid: "" });
+    expect(result.uuid).toBeUndefined();
+  });
+
+  test("preserves isSynthetic boolean", () => {
+    const result = normalizePayload("assistant", { isSynthetic: true });
+    expect(result.isSynthetic).toBe(true);
+  });
+
+  test("preserves status string", () => {
+    const result = normalizePayload("assistant", { status: "running" });
+    expect(result.status).toBe("running");
+  });
+
+  test("preserves subtype string", () => {
+    const result = normalizePayload("assistant", { subtype: "progress" });
+    expect(result.subtype).toBe("progress");
+  });
+
+  test("preserves tool_name from tool_name field", () => {
+    const result = normalizePayload("tool", { tool_name: "bash" });
+    expect(result.tool_name).toBe("bash");
+  });
+
+  test("preserves tool_name from name field", () => {
+    const result = normalizePayload("tool", { name: "read" });
+    expect(result.tool_name).toBe("read");
+  });
+
+  test("preserves tool_input from tool_input field", () => {
+    const input = { command: "ls" };
+    const result = normalizePayload("tool", { tool_input: input });
+    expect(result.tool_input).toEqual(input);
+  });
+
+  test("preserves tool_input from input field", () => {
+    const input = { path: "/tmp" };
+    const result = normalizePayload("tool", { input });
+    expect(result.tool_input).toEqual(input);
+  });
+
+  test("preserves request_id", () => {
+    const result = normalizePayload("permission", { request_id: "req-1" });
+    expect(result.request_id).toBe("req-1");
+  });
+
+  test("preserves request object", () => {
+    const req = { subtype: "permission" };
+    const result = normalizePayload("permission", { request: req });
+    expect(result.request).toEqual(req);
+  });
+
+  test("preserves approved field", () => {
+    const result = normalizePayload("permission", { approved: true });
+    expect(result.approved).toBe(true);
+  });
+
+  test("preserves updated_input", () => {
+    const input = { command: "rm -rf" };
+    const result = normalizePayload("permission", { updated_input: input });
+    expect(result.updated_input).toEqual(input);
+  });
+
+  test("preserves message field for backward compat", () => {
+    const msg = { role: "user", content: "hi" };
+    const result = normalizePayload("assistant", { message: msg });
+    expect(result.message).toEqual(msg);
+  });
+});
+
+// =============================================================================
+// normalizePayload — task_state special handling
+// =============================================================================
+
+describe("normalizePayload — task_state type", () => {
+  test("preserves task_list_id (snake_case)", () => {
+    const result = normalizePayload("task_state", { task_list_id: "tl-1" });
+    expect(result.task_list_id).toBe("tl-1");
+  });
+
+  test("preserves taskListId (camelCase)", () => {
+    const result = normalizePayload("task_state", { taskListId: "tl-2" });
+    expect(result.taskListId).toBe("tl-2");
+  });
+
+  test("preserves tasks array", () => {
+    const tasks = [{ id: "t1", title: "Task 1" }];
+    const result = normalizePayload("task_state", { tasks });
+    expect(result.tasks).toEqual(tasks);
+  });
+
+  test("does not preserve task fields for non-task_state type", () => {
+    const result = normalizePayload("assistant", { task_list_id: "tl-1", taskListId: "tl-2", tasks: [] });
+    expect(result.task_list_id).toBeUndefined();
+    expect(result.taskListId).toBeUndefined();
+    expect(result.tasks).toBeUndefined();
+  });
+});