linkshell-cli 0.3.28 → 0.3.29

package/src/runtime/acp/agent-workspace.ts

@@ -1,5 +1,4 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { basename, join, relative } from "node:path";
 import {
@@ -10,9 +9,6 @@ import {
 import { AcpClient } from "./acp-client.js";
 import { ClaudeSdkClient } from "./claude-sdk-client.js";
 import { ClaudeStreamJsonClient } from "./claude-stream-json-client.js";
-import { CodexRpcBridge } from "./codex-rpc-bridge.js";
-import { listClaudeStoredSessions, loadClaudeStoredTimeline } from "./claude-sessions.js";
-import { loadCodexStoredTimeline } from "./codex-sessions.js";
 import type { AgentProtocol, AgentProvider } from "./provider-resolver.js";
 import { resolveAgentCommand } from "./provider-resolver.js";
 
@@ -21,15 +17,12 @@ type AgentPermissionMode = "read_only" | "workspace_write" | "full_access";
 type AgentCollaborationMode = "default" | "plan";
 type AgentCommandExecutionKind = "prompt" | "native" | "local_ui";
 type AgentCommandSource = "built_in" | "custom" | "project" | "user" | "linkshell";
-type AgentSyncSource = "device" | "device-history" | "device-live" | "app-server" | "cache";
 
 interface AgentContentBlock {
-  type: "text" | "image" | "file";
+  type: "text" | "image";
   text?: string;
   data?: string;
   mimeType?: string;
-  path?: string;
-  name?: string;
 }
 
 interface AgentToolCall {
@@ -165,16 +158,10 @@ interface AgentConversation {
   title?: string;
   model?: string;
   reasoningEffort?: string;
-  serviceTier?: string;
   permissionMode?: AgentPermissionMode;
   collaborationMode?: AgentCollaborationMode;
   status: AgentStatus;
   archived: boolean;
-  timelineRevision?: number;
-  historyComplete?: boolean;
-  runningTurnId?: string;
-  source?: AgentSyncSource;
-  canonical?: boolean;
   lastMessagePreview?: string;
   lastActivityAt: number;
   createdAt: number;
@@ -185,9 +172,6 @@ interface AgentTimelineItem {
   conversationId: string;
   type: "message" | "tool_call" | "plan" | "permission" | "status" | "error";
   kind?: AgentTimelineKind;
-  revision?: number;
-  source?: AgentSyncSource;
-  canonical?: boolean;
   turnId?: string;
   itemId?: string;
   role?: "user" | "assistant" | "system";
@@ -219,51 +203,13 @@ interface PendingStructuredInputWaiter {
   source?: string;
 }
 
-interface AgentRevisionEvent {
-  revision: number;
-  item?: AgentTimelineItem;
-  conversation?: AgentConversation;
-}
-
 const PERMISSION_TIMEOUT_MS = 5 * 60_000;
 const MAX_TIMELINE_ITEMS = 200;
-const MAX_SNAPSHOT_ITEMS = 80;
-const MAX_SNAPSHOT_TEXT_BYTES = 128 * 1024;
-const MAX_DELTA_EVENTS = 500;
-const HISTORY_PAGE_MAX_ITEMS = 500;
 
 function id(prefix: string): string {
   return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
 
-function clampHistoryCursor(value: string | undefined, fallback: number, max: number): number {
-  if (!value) return fallback;
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isFinite(parsed)) return fallback;
-  return Math.max(0, Math.min(max, parsed));
-}
-
-function appServerText(value: unknown): string | undefined {
-  if (typeof value === "string") {
-    const text = value.trim();
-    return text || undefined;
-  }
-  if (Array.isArray(value)) {
-    const text = value
-      .map((part) => appServerText(part))
-      .filter(Boolean)
-      .join("\n")
-      .trim();
-    return text || undefined;
-  }
-  const record = asRecord(value);
-  if (!record) return undefined;
-  if (typeof record.text === "string") return appServerText(record.text);
-  if (typeof record.content === "string") return appServerText(record.content);
-  if (typeof record.message === "string") return appServerText(record.message);
-  return appServerText(record.content ?? record.message ?? record.parts);
-}
-
 function stringify(value: unknown): string {
   if (typeof value === "string") return value;
   try {
@@ -273,71 +219,6 @@ function stringify(value: unknown): string {
   }
 }
 
-function truncateUtf8(value: string | undefined, maxBytes = MAX_SNAPSHOT_TEXT_BYTES): string | undefined {
-  if (!value) return value;
-  if (Buffer.byteLength(value, "utf8") <= maxBytes) return value;
-  let end = Math.min(value.length, maxBytes);
-  while (end > 0 && Buffer.byteLength(value.slice(0, end), "utf8") > maxBytes) {
-    end = Math.floor(end * 0.9);
-  }
-  return `${value.slice(0, end)}\n\n[truncated by LinkShell: original ${Buffer.byteLength(value, "utf8")} bytes]`;
-}
-
-function snapshotContentBlocks(
-  blocks: AgentContentBlock[] | undefined,
-  options: { stripImages?: boolean } = {},
-): AgentContentBlock[] | undefined {
-  if (!blocks) return undefined;
-  return blocks.map((block) =>
-    block.type === "image" && options.stripImages !== false
-      ? { ...block, data: undefined, text: block.text || "图片附件" }
-      : { ...block, text: truncateUtf8(block.text) },
-  );
-}
-
-function snapshotTimelineItem(
-  item: AgentTimelineItem,
-  options: { stripImages?: boolean } = {},
-): AgentTimelineItem {
-  return {
-    ...item,
-    content: snapshotContentBlocks(item.content, options),
-    text: truncateUtf8(item.text),
-    toolCall: item.toolCall
-      ? {
-          ...item.toolCall,
-          input: truncateUtf8(item.toolCall.input),
-          output: truncateUtf8(item.toolCall.output),
-        }
-      : undefined,
-    commandExecution: item.commandExecution
-      ? {
-          ...item.commandExecution,
-          command: truncateUtf8(item.commandExecution.command, 16 * 1024),
-          output: truncateUtf8(item.commandExecution.output),
-        }
-      : undefined,
-    fileChange: item.fileChange
-      ? {
-          ...item.fileChange,
-          diff: truncateUtf8(item.fileChange.diff),
-          summary: truncateUtf8(item.fileChange.summary),
-        }
-      : undefined,
-    permission: item.permission
-      ? {
-          ...item.permission,
-          toolInput: truncateUtf8(item.permission.toolInput),
-          context: truncateUtf8(item.permission.context),
-        }
-      : undefined,
-  };
-}
-
-function snapshotTimelineItems(items: AgentTimelineItem[]): AgentTimelineItem[] {
-  return items.slice(-MAX_SNAPSHOT_ITEMS).map((item) => snapshotTimelineItem(item));
-}
-
 function asRecord(value: unknown): Record<string, unknown> | undefined {
   return typeof value === "object" && value ? value as Record<string, unknown> : undefined;
 }
@@ -643,12 +524,7 @@ function titleFromCwd(cwd: string): string {
 
 function textFromBlocks(blocks: AgentContentBlock[]): string {
   return blocks
-    .map((block) => {
-      if (block.type === "text") return block.text ?? "";
-      if (block.type === "image") return `[${block.mimeType ?? "image"} attachment]`;
-      if (block.type === "file" && block.path) return `@${block.path}`;
-      return "";
-    })
+    .map((block) => block.type === "text" ? block.text ?? "" : `[${block.mimeType ?? "image"} attachment]`)
     .filter(Boolean)
     .join("\n");
 }
@@ -681,11 +557,6 @@ function contentBlocksFromValue(value: unknown): AgentContentBlock[] {
     const text = firstString(raw, ["text", "content", "message"]);
     return text ? [{ type: "text", text }] : [];
   }
-  if (normalizedType === "file" || normalizedType === "inputfile" || normalizedType === "filereference") {
-    const path = firstString(raw, ["path", "file", "filePath", "file_path", "absolutePath", "relativePath"]);
-    const text = firstString(raw, ["text", "name", "label"]);
-    return path ? [{ type: "file", path, name: text, text: text ?? `@${path}` }] : [];
-  }
   const nested = raw.content ?? raw.contentItems ?? raw.parts;
   if (Array.isArray(nested)) return contentBlocksFromValue(nested);
   const text = firstString(raw, ["text", "message", "content"]);
@@ -881,54 +752,20 @@ function providerLabel(provider: AgentProvider): string {
 interface AgentModelOption {
   id: string;
   label: string;
-  reasoningEfforts?: string[];
-  defaultReasoningEffort?: string;
-  speedTiers?: string[];
-  supportsImages?: boolean;
-  description?: string;
 }
 
 interface ProviderRuntimeCapabilities {
   models?: AgentModelOption[];
   defaultModel?: string;
   reasoningEfforts?: string[];
-  speedTiers?: string[];
-  defaultServiceTier?: string;
   commands?: AgentCommandDescriptor[];
   modes?: AgentModeDescriptor[];
   currentMode?: string;
 }
 
 const ALL_REASONING_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh"] as const;
-const CLAUDE_REASONING_EFFORTS = ["low", "medium", "high", "xhigh"] as const;
-const ALL_SERVICE_TIERS = ["standard", "fast"] as const;
-const AGENT_PERMISSION_MODES: AgentPermissionMode[] = ["read_only", "workspace_write", "full_access"];
-const COMMAND_OUTPUT_MAX_BYTES = 96 * 1024;
-const LINKSHELL_NATIVE_COMMANDS: Array<{
-  name: string;
-  description: string;
-  category: string;
-  argsMode?: AgentCommandDescriptor["argsMode"];
-  destructive?: boolean;
-  providers?: AgentProvider[];
-}> = [
-  { name: "status", description: "Show current Agent and workspace status", category: "LinkShell", argsMode: "none" },
-  { name: "plan", description: "Enter Plan mode for the next turn", category: "Agent", argsMode: "none" },
-  { name: "exit-plan", description: "Exit Plan mode", category: "Agent", argsMode: "none" },
-  { name: "review", description: "Ask the Agent to review current local changes", category: "Agent", argsMode: "optional" },
-  { name: "subagents", description: "Ask the Agent to split work across subagents when useful", category: "Agent", argsMode: "optional" },
-  { name: "compact", description: "Compact the active Codex context", category: "Codex", argsMode: "none", providers: ["codex"] },
-  { name: "new", description: "Start a fresh Codex thread", category: "Codex", argsMode: "none", providers: ["codex"], destructive: true },
-  { name: "clear", description: "Start a fresh Agent context for this conversation", category: "Agent", argsMode: "none", destructive: true },
-  { name: "git-status", description: "Show branch and working tree status", category: "Git", argsMode: "none" },
-  { name: "git-diff", description: "Show a compact diffstat for current changes", category: "Git", argsMode: "none" },
-  { name: "git-commit", description: "Commit staged changes with the given message", category: "Git", argsMode: "required" },
-  { name: "git-pull", description: "Pull with fast-forward only", category: "Git", argsMode: "none" },
-  { name: "git-push", description: "Push the current branch", category: "Git", argsMode: "none" },
-  { name: "git-stash", description: "Stash current working tree changes", category: "Git", argsMode: "optional" },
-  { name: "git-stash-pop", description: "Pop the latest stash", category: "Git", argsMode: "none" },
-];
-const CODEX_JSON_RPC_COMMANDS = new Set(["plan", "exit-plan", "review", "compact", "new"]);
+const ALL_PERMISSION_MODES = ["read_only", "workspace_write", "full_access"] as const;
+const CODEX_COMMAND_NAMES = ["plan", "exit-plan", "compact", "clear", "status", "review", "subagents"] as const;
 const CLAUDE_REMOTE_HIDDEN_COMMANDS = new Set([
   "add-dir",
   "agents",
@@ -1201,31 +1038,57 @@ function customClaudeCommands(cwd: string): AgentCommandDescriptor[] {
 
 function defaultProviderCommands(provider: AgentProvider, cwd: string, enabled: boolean): AgentCommandDescriptor[] {
   const disabledReason = enabled ? undefined : `${providerLabel(provider)} 未安装或启动失败`;
-  const linkshellCommands = LINKSHELL_NATIVE_COMMANDS
-    .filter((command) => provider !== "codex" || CODEX_JSON_RPC_COMMANDS.has(command.name))
-    .filter((command) => !command.providers || command.providers.includes(provider))
-    .map((command) => makeCommand({
+  if (provider === "codex") {
+    return CODEX_COMMAND_NAMES.map((name) => makeCommand({
       provider,
-      name: command.name,
-      description: command.description,
+      name,
       source: "linkshell",
-      category: command.category,
-      argsMode: command.argsMode ?? "optional",
-      destructive: command.destructive,
+      category: name === "plan" || name === "exit-plan" ? "Modes" : "Codex",
+      description: {
+        "plan": "Enter Codex plan mode",
+        "exit-plan": "Exit Codex plan mode",
+        compact: "Compact the current thread",
+        clear: "Start a fresh Codex thread",
+        status: "Show LinkShell agent status",
+        review: "Ask Codex to review local changes",
+        subagents: "Insert a delegation prompt",
+      }[name],
+      argsMode: name === "review" || name === "subagents" ? "optional" : "none",
+      destructive: name === "clear",
       disabledReason,
-      executionKind: "native",
+      executionKind: name === "review" || name === "subagents" ? "prompt" : "native",
     }));
-  if (provider === "codex") {
-    return linkshellCommands;
   }
   if (provider === "claude") {
+    const builtIns = CLAUDE_BUILT_IN_COMMANDS
+      .filter((entry) => isClaudeRemoteFriendlyCommand(entry.name))
+      .map((entry) => makeCommand({
+        provider,
+        name: entry.name,
+        description: entry.description,
+        argsMode: entry.argsMode,
+        destructive: entry.destructive,
+        disabledReason,
+        executionKind: "prompt",
+      }));
     const custom = customClaudeCommands(cwd).map((command) => ({
       ...command,
       disabledReason: command.disabledReason ?? disabledReason,
     }));
-    return [...linkshellCommands, ...custom];
+    return [...builtIns, ...custom];
   }
-  return linkshellCommands;
+  return [
+    makeCommand({
+      provider,
+      name: "status",
+      source: "linkshell",
+      category: "LinkShell",
+      description: "Show LinkShell agent status",
+      argsMode: "none",
+      disabledReason,
+      executionKind: "native",
+    }),
+  ];
 }
 
 function mergeCommands(...groups: Array<AgentCommandDescriptor[] | undefined>): AgentCommandDescriptor[] {
@@ -1244,81 +1107,6 @@ function mergeCommands(...groups: Array<AgentCommandDescriptor[] | undefined>):
   return [...map.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
 
-function isGitNativeCommand(name: string): boolean {
-  return name === "git-status" ||
-    name === "git-diff" ||
-    name === "git-commit" ||
-    name === "git-pull" ||
-    name === "git-push" ||
-    name === "git-stash" ||
-    name === "git-stash-pop";
-}
-
-function gitCommandArgs(name: string, args?: string): { display: string; argv: string[] } {
-  const message = args?.trim();
-  switch (name) {
-    case "git-status":
-      return { display: "git status --short --branch", argv: ["status", "--short", "--branch"] };
-    case "git-diff":
-      return { display: "git diff --stat", argv: ["diff", "--stat"] };
-    case "git-commit":
-      if (!message) throw new Error("请先输入提交信息，例如 /git-commit fix mobile agent timeline");
-      return { display: `git commit -m ${JSON.stringify(message)}`, argv: ["commit", "-m", message] };
-    case "git-pull":
-      return { display: "git pull --ff-only", argv: ["pull", "--ff-only"] };
-    case "git-push":
-      return { display: "git push", argv: ["push"] };
-    case "git-stash":
-      return {
-        display: "git stash push -u",
-        argv: ["stash", "push", "-u", "-m", message || "LinkShell mobile stash"],
-      };
-    case "git-stash-pop":
-      return { display: "git stash pop", argv: ["stash", "pop"] };
-    default:
-      throw new Error(`未知 Git 命令：/${name}`);
-  }
-}
-
-function runProcess(
-  command: string,
-  args: string[],
-  options: { cwd: string; maxBytes?: number },
-): Promise<{ output: string; exitCode: number | null; signal: NodeJS.Signals | null }> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd: options.cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true,
-    });
-    const maxBytes = options.maxBytes ?? COMMAND_OUTPUT_MAX_BYTES;
-    let output = "";
-    let bytes = 0;
-    let truncated = false;
-    const append = (chunk: Buffer) => {
-      if (bytes >= maxBytes) {
-        truncated = true;
-        return;
-      }
-      const remaining = maxBytes - bytes;
-      const slice = chunk.byteLength > remaining ? chunk.subarray(0, remaining) : chunk;
-      output += slice.toString("utf8");
-      bytes += slice.byteLength;
-      if (slice.byteLength < chunk.byteLength) truncated = true;
-    };
-    child.stdout.on("data", append);
-    child.stderr.on("data", append);
-    child.once("error", reject);
-    child.once("close", (exitCode, signal) => {
-      resolve({
-        output: `${output.trimEnd()}${truncated ? "\n\n[truncated by LinkShell]" : ""}`,
-        exitCode,
-        signal,
-      });
-    });
-  });
-}
-
 function runtimeCommands(provider: AgentProvider, value: unknown): AgentCommandDescriptor[] {
   const raw = asRecord(value);
   const commandsValue =
@@ -1362,14 +1150,10 @@ function parseModelListCapabilities(value: unknown): ProviderRuntimeCapabilities
   const raw = asRecord(value);
   const modelsValue =
     Array.isArray(value) ? value :
-    Array.isArray(raw?.data) ? raw.data :
     Array.isArray(raw?.models) ? raw.models :
     Array.isArray(raw?.items) ? raw.items :
     Array.isArray(raw?.modelOptions) ? raw.modelOptions :
     [];
-  const effortSet = new Set<string>();
-  const speedTierSet = new Set<string>(["standard"]);
-  let defaultModelFromEntry: string | undefined;
   const models = modelsValue
     .map((entry, index) => {
       const model = asRecord(entry);
@@ -1379,40 +1163,13 @@ function parseModelListCapabilities(value: unknown): ProviderRuntimeCapabilities
           : undefined;
       }
       const modelId = firstString(model, ["id", "model", "name", "value"]) ?? `model-${index + 1}`;
-      const label = firstString(model, ["displayName", "label", "title", "name", "model"]) ?? modelId;
-      if (model.hidden === true) return undefined;
-      const modelEfforts = arrayFromKeys(model, ["supportedReasoningEfforts", "reasoningEfforts"])
-        .map((effort) => {
-          const rawEffort = asRecord(effort);
-          return firstString(rawEffort, ["reasoningEffort", "id", "value"]) ?? (typeof effort === "string" ? effort : undefined);
-        })
-        .filter((effort): effort is string => Boolean(effort) && ALL_REASONING_EFFORTS.includes(effort as typeof ALL_REASONING_EFFORTS[number]));
-      modelEfforts.forEach((effort) => effortSet.add(effort));
-      const defaultReasoningEffort = firstString(model, ["defaultReasoningEffort", "default_reasoning_effort"]);
-      if (defaultReasoningEffort && ALL_REASONING_EFFORTS.includes(defaultReasoningEffort as typeof ALL_REASONING_EFFORTS[number])) {
-        effortSet.add(defaultReasoningEffort);
-      }
-      const modalities = arrayFromKeys(model, ["inputModalities", "modalities"]);
-      const speedTiers = arrayFromKeys(model, ["additionalSpeedTiers", "additional_speed_tiers", "serviceTiers", "service_tiers"])
-        .map((tier) => typeof tier === "string" ? tier : firstString(asRecord(tier), ["id", "tier", "value"]))
-        .filter((tier): tier is string => Boolean(tier) && ALL_SERVICE_TIERS.includes(tier as typeof ALL_SERVICE_TIERS[number]));
-      speedTiers.forEach((tier) => speedTierSet.add(tier));
-      if (model.isDefault === true) defaultModelFromEntry = modelId;
-      return {
-        id: modelId,
-        label,
-        ...(modelEfforts.length > 0 ? { reasoningEfforts: modelEfforts } : {}),
-        ...(defaultReasoningEffort ? { defaultReasoningEffort } : {}),
-        ...(speedTiers.length > 0 ? { speedTiers: ["standard", ...speedTiers.filter((tier) => tier !== "standard")] } : {}),
-        ...(modalities.length > 0 ? { supportsImages: modalities.includes("image") } : {}),
-        ...(firstString(model, ["description"]) ? { description: firstString(model, ["description"]) } : {}),
-      };
+      const label = firstString(model, ["label", "title", "displayName", "name"]) ?? modelId;
+      return { id: modelId, label };
     })
     .filter((entry): entry is AgentModelOption => Boolean(entry));
   const defaultModel =
     firstString(raw, ["defaultModel", "default_model", "currentModel"]) ??
-    firstString(asRecord(raw?.defaults), ["model"]) ??
-    defaultModelFromEntry;
+    firstString(asRecord(raw?.defaults), ["model"]);
   const effortsValue =
     Array.isArray(raw?.reasoningEfforts) ? raw.reasoningEfforts :
     Array.isArray(raw?.reasoning_efforts) ? raw.reasoning_efforts :
@@ -1420,14 +1177,11 @@ function parseModelListCapabilities(value: unknown): ProviderRuntimeCapabilities
     undefined;
   const reasoningEfforts = effortsValue
     ?.filter((entry): entry is string => typeof entry === "string" && ALL_REASONING_EFFORTS.includes(entry as typeof ALL_REASONING_EFFORTS[number]));
-  const resolvedReasoningEfforts = reasoningEfforts?.length ? reasoningEfforts : [...effortSet];
-  const resolvedSpeedTiers = [...speedTierSet];
-  if (models.length === 0 && !defaultModel && resolvedReasoningEfforts.length === 0 && resolvedSpeedTiers.length <= 1) return undefined;
+  if (models.length === 0 && !defaultModel && !reasoningEfforts?.length) return undefined;
   return {
-    ...(models.length > 0 ? { models } : {}),
+    ...(models.length > 0 ? { models: [{ id: "default", label: "默认模型" }, ...models] } : {}),
     ...(defaultModel ? { defaultModel } : {}),
-    ...(resolvedReasoningEfforts.length > 0 ? { reasoningEfforts: resolvedReasoningEfforts } : {}),
-    ...(resolvedSpeedTiers.length > 0 ? { speedTiers: resolvedSpeedTiers } : {}),
+    ...(reasoningEfforts?.length ? { reasoningEfforts } : {}),
   };
 }
 
@@ -1449,9 +1203,6 @@ function parseRemoteSessions(value: unknown): Array<{
   model?: string;
   createdAt?: number;
   lastActivityAt?: number;
-  archived?: boolean;
-  status?: AgentStatus;
-  runningTurnId?: string;
 }> {
   const raw = asRecord(value);
   const sessionsValue =
@@ -1467,9 +1218,6 @@ function parseRemoteSessions(value: unknown): Array<{
     model?: string;
     createdAt?: number;
     lastActivityAt?: number;
-    archived?: boolean;
-    status?: AgentStatus;
-    runningTurnId?: string;
   }> = [];
   for (const entry of sessionsValue) {
     const session = asRecord(entry);
@@ -1488,34 +1236,16 @@ function parseRemoteSessions(value: unknown): Array<{
       model: firstString(source, ["model", "modelId"]),
       createdAt: parseTimestamp(source.createdAt ?? source.created_at),
       lastActivityAt: parseTimestamp(source.lastActivityAt ?? source.updatedAt ?? source.modifiedAt ?? source.lastModified ?? source.updated_at),
-      archived: typeof source.archived === "boolean" ? source.archived : undefined,
-      status: normalizeAgentStatus(firstString(source, ["status", "state", "phase"])),
-      runningTurnId: firstString(source, ["runningTurnId", "running_turn_id", "turnId", "activeTurnId"]),
     });
   }
   return result;
 }
 
-function normalizeAgentStatus(value: string | undefined): AgentStatus | undefined {
-  if (!value) return undefined;
-  const normalized = value.toLowerCase();
-  if (normalized === "running" || normalized === "in_progress" || normalized === "busy") return "running";
-  if (normalized === "waiting_permission" || normalized === "waiting" || normalized === "blocked") return "waiting_permission";
-  if (normalized === "error" || normalized === "failed") return "error";
-  if (normalized === "idle" || normalized === "completed" || normalized === "done") return "idle";
-  return undefined;
-}
-
 export class AgentWorkspaceProxy {
   private clients = new Map<AgentProvider, AcpClient | ClaudeSdkClient | ClaudeStreamJsonClient>();
-  private codexRpcBridge: CodexRpcBridge | undefined;
   private agentProtocols = new Map<AgentProvider, AgentProtocol>();
   private providerCapabilities = new Map<AgentProvider, ProviderRuntimeCapabilities>();
-  private providerCapabilityErrors = new Map<AgentProvider, string>();
-  private capabilitiesRevision = 0;
   private initialized = false;
-  private initializePromise: Promise<void> | undefined;
-  private providerStartPromises = new Map<AgentProvider, Promise<AcpClient | ClaudeSdkClient | ClaudeStreamJsonClient | undefined>>();
   private status: AgentStatus = "unavailable";
   private error: string | undefined;
   private activeConversationId: string | undefined;
@@ -1524,8 +1254,6 @@ export class AgentWorkspaceProxy {
   private conversations = new Map<string, AgentConversation>();
   private conversationByAgentSessionId = new Map<string, string>();
   private timelines = new Map<string, AgentTimelineItem[]>();
-  private conversationRevisions = new Map<string, number>();
-  private revisionEvents = new Map<string, AgentRevisionEvent[]>();
   private toolOutputBuffers = new Map<string, string>();
   private pendingPermissions = new Map<string, AgentPermission>();
   private permissionWaiters = new Map<string, PendingPermissionWaiter>();
@@ -1537,7 +1265,7 @@ export class AgentWorkspaceProxy {
 
   constructor(
     private readonly input: {
-      hostDeviceId: string;
+      sessionId: string;
       cwd: string;
       availableProviders: AgentProvider[];
       command?: string;
@@ -1548,31 +1276,6 @@ export class AgentWorkspaceProxy {
 
   async handleEnvelope(envelope: Envelope): Promise<void> {
     switch (envelope.type) {
-      case "agent.codex.rpc": {
-        const payload = parseTypedPayload("agent.codex.rpc", envelope.payload);
-        try {
-          this.codexRpc().send(payload as never);
-        } catch (error) {
-          const idValue = payload && typeof payload === "object" && "id" in payload
-            ? (payload as { id?: unknown }).id
-            : undefined;
-          if (typeof idValue === "string" || typeof idValue === "number") {
-            this.input.send(createEnvelope({
-              type: "agent.codex.rpc",
-              hostDeviceId: this.input.hostDeviceId,
-              payload: {
-                jsonrpc: "2.0",
-                id: idValue,
-                error: {
-                  code: -32000,
-                  message: error instanceof Error ? error.message : String(error),
-                },
-              },
-            }));
-          }
-        }
-        break;
-      }
       case "agent.v2.capabilities.request":
         await this.initialize();
         this.sendCapabilities();
@@ -1590,8 +1293,8 @@ export class AgentWorkspaceProxy {
         );
         this.input.send(createEnvelope({
           type: "agent.v2.conversation.list.result",
-          hostDeviceId: this.input.hostDeviceId,
-          payload: { conversations: conversations.map((conversation) => this.conversationSnapshot(conversation)) },
+          sessionId: this.input.sessionId,
+          payload: { conversations },
         }));
         break;
       }
@@ -1600,16 +1303,6 @@ export class AgentWorkspaceProxy {
         this.sendSnapshot(payload.conversationId);
         break;
       }
-      case "agent.v2.history.request": {
-        const payload = parseTypedPayload("agent.v2.history.request", envelope.payload);
-        await this.sendHistoryPage(payload);
-        break;
-      }
-      case "agent.v2.delta.request": {
-        const payload = parseTypedPayload("agent.v2.delta.request", envelope.payload);
-        this.sendDelta(payload);
-        break;
-      }
       case "agent.v2.prompt": {
         const payload = parseTypedPayload("agent.v2.prompt", envelope.payload);
         await this.sendPrompt(payload);
@@ -1648,68 +1341,35 @@ export class AgentWorkspaceProxy {
   }
 
   stop(): void {
-    this.codexRpcBridge?.stop();
-    this.codexRpcBridge = undefined;
     for (const client of this.clients.values()) {
       client.stop();
     }
     this.clients.clear();
-    this.providerStartPromises.clear();
-    this.initializePromise = undefined;
   }
 
   private clientForProvider(provider: AgentProvider): AcpClient | ClaudeSdkClient | ClaudeStreamJsonClient | undefined {
     return this.clients.get(provider);
   }
 
-  private codexRpc(): CodexRpcBridge {
-    this.codexRpcBridge ??= new CodexRpcBridge({
-      command: this.input.command,
-      cwd: this.input.cwd,
-      hostDeviceId: this.input.hostDeviceId,
-      send: this.input.send,
-      verbose: this.input.verbose,
-    });
-    return this.codexRpcBridge;
-  }
-
   private protocolForProvider(provider: AgentProvider): AgentProtocol | undefined {
     return this.agentProtocols.get(provider);
   }
 
   private async initialize(): Promise<void> {
     if (this.initialized) return;
-    if (this.initializePromise) return this.initializePromise;
-    this.initializePromise = (async () => {
-      // Eagerly start all detected providers so capabilities report real status.
-      const startPromises = this.input.availableProviders
-        .filter((provider) => provider !== "codex")
-        .map((p) => this.ensureProviderClient(p));
-      await Promise.allSettled(startPromises);
-      this.initialized = true;
-      this.status = "idle";
-      this.error = undefined;
-      this.sendCapabilities();
-    })().finally(() => {
-      this.initializePromise = undefined;
-    });
-    return this.initializePromise;
+    this.initialized = true;
+    // Eagerly start all detected providers so capabilities report real status
+    const startPromises = this.input.availableProviders.map((p) => this.ensureProviderClient(p));
+    await Promise.allSettled(startPromises);
+    this.status = "idle";
+    this.error = undefined;
+    this.sendCapabilities();
   }
 
   private async ensureProviderClient(provider: AgentProvider): Promise<AcpClient | ClaudeSdkClient | ClaudeStreamJsonClient | undefined> {
     const existing = this.clients.get(provider);
     if (existing) return existing;
-    const starting = this.providerStartPromises.get(provider);
-    if (starting) return starting;
 
-    const startPromise = this.startProviderClient(provider).finally(() => {
-      this.providerStartPromises.delete(provider);
-    });
-    this.providerStartPromises.set(provider, startPromise);
-    return startPromise;
-  }
-
-  private async startProviderClient(provider: AgentProvider): Promise<AcpClient | ClaudeSdkClient | ClaudeStreamJsonClient | undefined> {
     const resolved = resolveAgentCommand({
       provider,
       command: this.input.command,
@@ -1809,12 +1469,8 @@ export class AgentWorkspaceProxy {
     try {
       const result = await listModels.call(client);
       const runtimeCapabilities = parseModelListCapabilities(result);
-      if (runtimeCapabilities) {
-        this.providerCapabilities.set(provider, runtimeCapabilities);
-        this.providerCapabilityErrors.delete(provider);
-      }
+      if (runtimeCapabilities) this.providerCapabilities.set(provider, runtimeCapabilities);
     } catch (error) {
-      this.providerCapabilityErrors.set(provider, error instanceof Error ? error.message : String(error));
       if (this.input.verbose) {
         process.stderr.write(`[agent:v2] model/list failed for ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
       }
@@ -1823,11 +1479,36 @@ export class AgentWorkspaceProxy {
 
   private async syncProviderSessions(): Promise<void> {
     await this.initialize();
-    this.upsertProviderSessions("claude", listClaudeStoredSessions(this.input.cwd));
     for (const [provider, client] of this.clients) {
       try {
         const result = await client.listSessions();
-        this.upsertProviderSessions(provider, result);
+        for (const remote of parseRemoteSessions(result)) {
+          const agentSessionId = remote.id;
+          const existingId = this.conversationByAgentSessionId.get(agentSessionId);
+          const now = Date.now();
+          const conversationId = existingId ?? `agent:${agentSessionId}`;
+          const existing = this.conversations.get(conversationId);
+          const cwd = remote.cwd ?? existing?.cwd ?? this.input.cwd;
+          const conversation: AgentConversation = {
+            id: conversationId,
+            agentSessionId,
+            provider,
+            cwd,
+            title: remote.title ?? existing?.title ?? titleFromCwd(cwd),
+            model: remote.model ?? existing?.model,
+            reasoningEffort: existing?.reasoningEffort,
+            permissionMode: existing?.permissionMode,
+            collaborationMode: existing?.collaborationMode,
+            status: existing?.status ?? "idle",
+            archived: existing?.archived ?? false,
+            lastMessagePreview: existing?.lastMessagePreview,
+            lastActivityAt: remote.lastActivityAt ?? existing?.lastActivityAt ?? now,
+            createdAt: remote.createdAt ?? existing?.createdAt ?? now,
+          };
+          this.conversations.set(conversation.id, conversation);
+          this.conversationByAgentSessionId.set(agentSessionId, conversation.id);
+          this.timelines.set(conversation.id, this.timelines.get(conversation.id) ?? []);
+        }
       } catch (error) {
         if (this.input.verbose) {
           process.stderr.write(`[agent:v2] session list failed for ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -1836,55 +1517,16 @@ export class AgentWorkspaceProxy {
     }
   }
 
-  private upsertProviderSessions(provider: AgentProvider, result: unknown): void {
-    for (const remote of parseRemoteSessions(result)) {
-      const agentSessionId = remote.id;
-      const existingId = this.conversationByAgentSessionId.get(agentSessionId);
-      const now = Date.now();
-      const conversationId = existingId ?? `agent:${agentSessionId}`;
-      const existing = this.conversations.get(conversationId);
-      const cwd = remote.cwd ?? existing?.cwd ?? this.input.cwd;
-      const conversation: AgentConversation = {
-        id: conversationId,
-        agentSessionId,
-        provider,
-        cwd,
-        title: remote.title ?? existing?.title ?? titleFromCwd(cwd),
-        model: remote.model ?? existing?.model,
-        reasoningEffort: existing?.reasoningEffort,
-        serviceTier: existing?.serviceTier,
-        permissionMode: existing?.permissionMode,
-        collaborationMode: existing?.collaborationMode,
-        status: remote.status ?? existing?.status ?? "idle",
-        archived: remote.archived ?? existing?.archived ?? false,
-        timelineRevision: existing?.timelineRevision ?? this.getRevision(conversationId),
-        historyComplete: existing?.historyComplete ?? false,
-        runningTurnId: remote.runningTurnId ?? this.currentTurnIds.get(conversationId),
-        source: "device",
-        canonical: true,
-        lastMessagePreview: existing?.lastMessagePreview,
-        lastActivityAt: remote.lastActivityAt ?? existing?.lastActivityAt ?? now,
-        createdAt: remote.createdAt ?? existing?.createdAt ?? now,
-      };
-      this.conversations.set(conversation.id, conversation);
-      this.conversationByAgentSessionId.set(agentSessionId, conversation.id);
-      if (remote.runningTurnId) this.rememberTurnConversationId(conversation.id, remote.runningTurnId);
-      this.timelines.set(conversation.id, this.timelines.get(conversation.id) ?? []);
-    }
-  }
-
   private sendCapabilities(): void {
     const providers = this.input.availableProviders.map((provider) => {
       const client = this.clients.get(provider);
-      const protocol = provider === "codex" ? "codex-app-server" : this.agentProtocols.get(provider);
+      const protocol = this.agentProtocols.get(provider);
       const runtimeCapabilities = this.providerCapabilities.get(provider);
-      const enabled = provider === "codex" ? true : Boolean(client);
-      const hasRuntimeModels = Boolean(runtimeCapabilities?.models?.length);
+      const enabled = Boolean(client);
       const supportsImages = enabled && protocolSupportsImages(protocol);
-      const isClaudeSdk = protocol === "claude-agent-sdk";
       const isClaudeFallback = protocol === "claude-stream-json";
-      const supportsPermission = enabled && (isClaudeSdk || !isClaudeFallback);
-      const supportsReasoningEffort = enabled;
+      const supportsPermission = enabled && !isClaudeFallback;
+      const supportsReasoningEffort = enabled && !isClaudeFallback;
       const commands = mergeCommands(
         defaultProviderCommands(provider, this.input.cwd, enabled),
         runtimeCapabilities?.commands,
@@ -1895,23 +1537,21 @@ export class AgentWorkspaceProxy {
         label: providerLabel(provider),
         enabled,
         reason: enabled ? undefined : `${providerLabel(provider)} 未安装或启动失败`,
-        providerProtocol: protocol,
         supportsImages,
         supportsPermission,
         supportsPlan: enabled,
         supportsCancel: enabled,
         models: runtimeCapabilities?.models ?? [{ id: "default", label: "默认模型" }],
-        defaultModel: runtimeCapabilities?.defaultModel,
-        modelsSource: hasRuntimeModels ? "runtime" : enabled ? "fallback" : "unavailable",
-        modelListError: this.providerCapabilityErrors.get(provider),
+        defaultModel: runtimeCapabilities?.defaultModel ?? "default",
         reasoningEfforts: supportsReasoningEffort
-          ? runtimeCapabilities?.reasoningEfforts ?? (provider === "claude" ? [...CLAUDE_REASONING_EFFORTS] : [...ALL_REASONING_EFFORTS])
+          ? runtimeCapabilities?.reasoningEfforts ?? [...ALL_REASONING_EFFORTS]
           : [],
-        speedTiers: provider === "codex" ? runtimeCapabilities?.speedTiers ?? ["standard"] : [],
-        defaultServiceTier: provider === "codex" ? runtimeCapabilities?.defaultServiceTier : undefined,
-        permissionModes: supportsPermission ? AGENT_PERMISSION_MODES : [],
+        permissionModes: supportsPermission ? [...ALL_PERMISSION_MODES] : [],
         commands,
-        modes: runtimeCapabilities?.modes ?? [],
+        modes: runtimeCapabilities?.modes ?? (provider === "codex" ? [
+          { id: "default", title: "Default", description: "Run normal implementation turns" },
+          { id: "plan", title: "Plan", description: "Discuss and produce an implementation plan first" },
+        ] : []),
         currentMode,
         features: {
           images: supportsImages,
@@ -1919,8 +1559,6 @@ export class AgentWorkspaceProxy {
           plan: enabled,
           cancel: enabled,
           reasoningEffort: supportsReasoningEffort,
-          serviceTier: provider === "codex" && Boolean(runtimeCapabilities?.speedTiers?.includes("fast")),
-          claudeSdk: isClaudeSdk,
           streamJsonFallback: isClaudeFallback,
         },
       };
@@ -1929,14 +1567,13 @@ export class AgentWorkspaceProxy {
     const anyPermission = providers.some((p) => p.supportsPermission);
     this.input.send(createEnvelope({
       type: "agent.v2.capabilities",
-      hostDeviceId: this.input.hostDeviceId,
+      sessionId: this.input.sessionId,
       payload: {
         enabled: anyEnabled,
         provider: this.input.availableProviders[0] ?? "codex",
         providers,
         protocolVersion: 1,
         workspaceProtocolVersion: 2,
-        capabilitiesRevision: ++this.capabilitiesRevision,
         error: anyEnabled ? undefined : "没有可用的 Agent provider。请安装 Claude Code 或 Codex CLI。",
         supportsSessionList: anyEnabled,
         supportsSessionLoad: anyEnabled,
@@ -1956,12 +1593,29 @@ export class AgentWorkspaceProxy {
     provider?: AgentProvider;
     model?: string;
     reasoningEffort?: string;
-    serviceTier?: string;
     permissionMode?: AgentPermissionMode;
     collaborationMode?: AgentCollaborationMode;
     title?: string;
   }): Promise<AgentConversation | undefined> {
     const provider = payload.provider ?? this.input.availableProviders[0];
+    if (!provider) {
+      return this.openFailure(payload, "没有可用的 Agent provider。");
+    }
+    if (!this.input.availableProviders.includes(provider)) {
+      return this.openFailure(
+        payload,
+        `${providerLabel(provider)} 未安装或不可用。`,
+      );
+    }
+
+    const client = await this.ensureProviderClient(provider);
+    if (!client) {
+      return this.openFailure(
+        payload,
+        `${providerLabel(provider)} 启动失败。请确认 CLI 已安装并可用。`,
+      );
+    }
+
     const cwd = payload.cwd ?? this.input.cwd;
     let agentSessionId = payload.agentSessionId;
     let existingConversation =
@@ -1972,43 +1626,18 @@ export class AgentWorkspaceProxy {
       if (payload.conversationId && existingConversation.id !== payload.conversationId) {
         existingConversation = this.adoptConversationId(existingConversation.id, payload.conversationId);
       }
-      this.hydrateStoredTimeline(existingConversation);
       this.activeConversationId = existingConversation.id;
-      const snapshot = this.latestSnapshot(existingConversation.id);
       this.input.send(createEnvelope({
         type: "agent.v2.conversation.opened",
-        hostDeviceId: this.input.hostDeviceId,
+        sessionId: this.input.sessionId,
         payload: {
-          conversation: this.conversationSnapshot(existingConversation),
-          snapshot: snapshot.items,
-          revision: this.getRevision(existingConversation.id),
-          cursor: snapshot.cursor,
-          hasMore: snapshot.hasMore,
-          source: "device-history",
-          canonical: true,
+          conversation: existingConversation,
+          snapshot: this.timelines.get(existingConversation.id) ?? [],
         },
       }));
       return existingConversation;
     }
 
-    if (!provider) {
-      return this.openFailure(payload, "没有可用的 Agent provider。");
-    }
-    if (!this.input.availableProviders.includes(provider)) {
-      return this.openFailure(
-        payload,
-        `${providerLabel(provider)} 未安装或不可用。`,
-      );
-    }
-
-    const client = await this.ensureProviderClient(provider);
-    if (!client) {
-      return this.openFailure(
-        payload,
-        `${providerLabel(provider)} 启动失败。请确认 CLI 已安装并可用。`,
-      );
-    }
-
     try {
       const result = agentSessionId
         ? await client.loadSession({ sessionId: agentSessionId, cwd })
@@ -2025,16 +1654,10 @@ export class AgentWorkspaceProxy {
         title: payload.title ?? existingConversation?.title ?? titleFromCwd(cwd),
         model: payload.model ?? existingConversation?.model,
         reasoningEffort: payload.reasoningEffort ?? existingConversation?.reasoningEffort,
-        serviceTier: payload.serviceTier ?? existingConversation?.serviceTier,
         permissionMode: payload.permissionMode ?? existingConversation?.permissionMode,
         collaborationMode: payload.collaborationMode ?? existingConversation?.collaborationMode,
         status: "idle",
         archived: existingConversation?.archived ?? false,
-        timelineRevision: existingConversation?.timelineRevision ?? this.getRevision(conversationId),
-        historyComplete: existingConversation?.historyComplete ?? false,
-        runningTurnId: this.currentTurnIds.get(conversationId),
-        source: "device",
-        canonical: true,
         lastMessagePreview: existingConversation?.status === "error" ? undefined : existingConversation?.lastMessagePreview,
         lastActivityAt: now,
         createdAt: existingConversation?.createdAt ?? now,
@@ -2043,20 +1666,10 @@ export class AgentWorkspaceProxy {
       this.conversationByAgentSessionId.set(agentSessionId, conversation.id);
       this.activeConversationId = conversation.id;
       this.timelines.set(conversation.id, this.timelines.get(conversation.id) ?? []);
-      this.hydrateStoredTimeline(conversation);
-      const snapshot = this.latestSnapshot(conversation.id);
       this.input.send(createEnvelope({
         type: "agent.v2.conversation.opened",
-        hostDeviceId: this.input.hostDeviceId,
-        payload: {
-          conversation: this.conversationSnapshot(conversation),
-          snapshot: snapshot.items,
-          revision: this.getRevision(conversation.id),
-          cursor: snapshot.cursor,
-          hasMore: snapshot.hasMore,
-          source: "device-history",
-          canonical: true,
-        },
+        sessionId: this.input.sessionId,
+        payload: { conversation, snapshot: this.timelines.get(conversation.id) ?? [] },
       }));
       return conversation;
     } catch (error) {
@@ -2092,10 +1705,6 @@ export class AgentWorkspaceProxy {
       collaborationMode: payload.collaborationMode,
       status: "error",
       archived: false,
-      timelineRevision: this.getRevision(fallbackId),
-      historyComplete: false,
-      source: "device",
-      canonical: true,
       lastMessagePreview: message,
       lastActivityAt: now,
       createdAt: now,
@@ -2111,15 +1720,8 @@ export class AgentWorkspaceProxy {
     });
     this.input.send(createEnvelope({
       type: "agent.v2.conversation.opened",
-      hostDeviceId: this.input.hostDeviceId,
-      payload: {
-        conversation: this.conversationSnapshot(conversation),
-        snapshot: snapshotTimelineItems(this.timelines.get(conversation.id) ?? []),
-        revision: this.getRevision(conversation.id),
-        hasMore: false,
-        source: "device",
-        canonical: true,
-      },
+      sessionId: this.input.sessionId,
+      payload: { conversation, snapshot: this.timelines.get(conversation.id) ?? [] },
     }));
     return conversation;
   }
@@ -2128,11 +1730,10 @@ export class AgentWorkspaceProxy {
     conversationId: string;
     clientMessageId: string;
     contentBlocks: AgentContentBlock[];
-    model?: string | null;
-    reasoningEffort?: string | null;
-    serviceTier?: string | null;
-    permissionMode?: AgentPermissionMode | null;
-    collaborationMode?: AgentCollaborationMode | null;
+    model?: string;
+    reasoningEffort?: string;
+    permissionMode?: AgentPermissionMode;
+    collaborationMode?: AgentCollaborationMode;
   }): Promise<void> {
     const conversation =
       this.conversations.get(payload.conversationId) ??
@@ -2175,21 +1776,10 @@ export class AgentWorkspaceProxy {
       return;
     }
 
-    if (Object.prototype.hasOwnProperty.call(payload, "model")) {
-      conversation.model = payload.model ?? undefined;
-    }
-    if (Object.prototype.hasOwnProperty.call(payload, "reasoningEffort")) {
-      conversation.reasoningEffort = payload.reasoningEffort ?? undefined;
-    }
-    if (Object.prototype.hasOwnProperty.call(payload, "serviceTier")) {
-      conversation.serviceTier = payload.serviceTier ?? undefined;
-    }
-    if (Object.prototype.hasOwnProperty.call(payload, "permissionMode")) {
-      conversation.permissionMode = payload.permissionMode ?? undefined;
-    }
-    if (Object.prototype.hasOwnProperty.call(payload, "collaborationMode")) {
-      conversation.collaborationMode = payload.collaborationMode ?? "default";
-    }
+    conversation.model = payload.model ?? conversation.model;
+    conversation.reasoningEffort = payload.reasoningEffort ?? conversation.reasoningEffort;
+    conversation.permissionMode = payload.permissionMode ?? conversation.permissionMode;
+    conversation.collaborationMode = payload.collaborationMode ?? conversation.collaborationMode;
     conversation.status = "running";
     conversation.lastActivityAt = Date.now();
     this.activeConversationId = conversation.id;
@@ -2211,11 +1801,10 @@ export class AgentWorkspaceProxy {
         sessionId: conversation.agentSessionId,
         content: payload.contentBlocks,
         clientMessageId: payload.clientMessageId,
-        model: conversation.model,
-        reasoningEffort: conversation.reasoningEffort,
-        serviceTier: conversation.serviceTier,
-        permissionMode: conversation.permissionMode,
-        collaborationMode: conversation.collaborationMode,
+        model: payload.model,
+        reasoningEffort: payload.reasoningEffort,
+        permissionMode: payload.permissionMode,
+        collaborationMode: payload.collaborationMode ?? conversation.collaborationMode,
         cwd: conversation.cwd,
       });
       const nextAgentSessionId = this.extractSessionId(result);
@@ -2308,7 +1897,6 @@ export class AgentWorkspaceProxy {
         contentBlocks: [{ type: "text", text: rawText }],
         model: conversation.model,
         reasoningEffort: conversation.reasoningEffort,
-        serviceTier: conversation.serviceTier,
         permissionMode: conversation.permissionMode,
         collaborationMode: conversation.collaborationMode,
       });
@@ -2352,8 +1940,14 @@ export class AgentWorkspaceProxy {
         return;
       }
 
-      if (isGitNativeCommand(command.name)) {
-        await this.executeGitNativeCommand(conversation, command.name, args);
+      if (conversation.provider !== "codex") {
+        this.addItem(conversation.id, {
+          id: id("error"),
+          conversationId: conversation.id,
+          type: "error",
+          error: `${command.title} 暂无 ${providerLabel(conversation.provider)} 原生实现。`,
+          createdAt: now,
+        });
         return;
       }
 
@@ -2370,23 +1964,6 @@ export class AgentWorkspaceProxy {
         return;
       }
 
-      if (command.name === "review" || command.name === "subagents") {
-        const prompt = command.name === "review"
-          ? args || "Review the current local changes."
-          : args || "Run subagents for distinct tasks in parallel when useful, then synthesize the results.";
-        await this.sendPrompt({
-          conversationId: conversation.id,
-          clientMessageId: id(command.name),
-          contentBlocks: [{ type: "text", text: prompt }],
-          model: conversation.model,
-          reasoningEffort: conversation.reasoningEffort,
-          serviceTier: conversation.serviceTier,
-          permissionMode: conversation.permissionMode,
-          collaborationMode: conversation.collaborationMode,
-        });
-        return;
-      }
-
       if (command.name === "compact") {
         if (!(client instanceof AcpClient)) throw new Error("当前 Codex runtime 不支持原生 compact。");
         conversation.status = "running";
@@ -2407,7 +1984,7 @@ export class AgentWorkspaceProxy {
         return;
       }
 
-      if (command.name === "clear" || command.name === "new") {
+      if (command.name === "clear") {
         if (!client) throw new Error("Agent provider 不在线。");
         const result = await client.newSession({ cwd: conversation.cwd });
         const nextAgentSessionId = this.extractSessionId(result) ?? id("agent-session");
@@ -2424,6 +2001,22 @@ export class AgentWorkspaceProxy {
         return;
       }
 
+      if (command.name === "review" || command.name === "subagents") {
+        const prompt = command.name === "review"
+          ? args || "Review the current local changes."
+          : args || "Run subagents for distinct tasks in parallel when useful, then synthesize the results.";
+        await this.sendPrompt({
+          conversationId: conversation.id,
+          clientMessageId: id(command.name),
+          contentBlocks: [{ type: "text", text: prompt }],
+          model: conversation.model,
+          reasoningEffort: conversation.reasoningEffort,
+          permissionMode: conversation.permissionMode,
+          collaborationMode: conversation.collaborationMode,
+        });
+        return;
+      }
+
       throw new Error(`命令暂未实现：/${command.name}`);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -2438,46 +2031,6 @@ export class AgentWorkspaceProxy {
     }
   }
 
-  private async executeGitNativeCommand(
-    conversation: AgentConversation,
-    commandName: string,
-    args?: string,
-  ): Promise<void> {
-    const git = gitCommandArgs(commandName, args);
-    const toolId = id(commandName);
-    const now = Date.now();
-    conversation.status = "running";
-    conversation.lastMessagePreview = git.display;
-    conversation.lastActivityAt = now;
-    this.emitConversation(conversation);
-    this.upsertTool(conversation.id, {
-      id: toolId,
-      name: "命令",
-      input: `${git.display}\n\ncwd: ${conversation.cwd}`,
-      createdAt: now,
-      status: "running",
-    });
-    const result = await runProcess("git", git.argv, {
-      cwd: conversation.cwd,
-      maxBytes: COMMAND_OUTPUT_MAX_BYTES,
-    });
-    const ok = result.exitCode === 0;
-    this.upsertTool(conversation.id, {
-      id: toolId,
-      name: "命令",
-      input: `${git.display}\n\ncwd: ${conversation.cwd}`,
-      output: result.output || (ok ? "完成" : `退出码 ${result.exitCode ?? "unknown"}`),
-      createdAt: now,
-      status: ok ? "completed" : "failed",
-    });
-    conversation.status = ok ? "idle" : "error";
-    conversation.lastMessagePreview = ok
-      ? `${git.display} 完成`
-      : `${git.display} 失败`;
-    conversation.lastActivityAt = Date.now();
-    this.emitConversation(conversation);
-  }
-
   private handleRequest(method: string, params: unknown): Promise<unknown> | unknown {
     if (method === "item/tool/requestUserInput" || method === "tool/requestUserInput") {
       return this.handleStructuredInput(params, true);
@@ -2517,7 +2070,6 @@ export class AgentWorkspaceProxy {
     if (
       method.startsWith("account/") ||
       method.startsWith("mcpServer/startupStatus/") ||
-      method.startsWith("remoteControl/") ||
       method === "thread/status/changed" ||
       method === "thread/tokenUsage/updated" ||
       method === "serverRequest/resolved" ||
@@ -2545,9 +2097,6 @@ export class AgentWorkspaceProxy {
         this.conversationByAgentSessionId.set(agentSessionId, conversationId);
         const conversation = this.conversations.get(conversationId);
         if (conversation) {
-          if (conversation.agentSessionId && conversation.agentSessionId !== agentSessionId) {
-            this.conversationByAgentSessionId.delete(conversation.agentSessionId);
-          }
           conversation.agentSessionId = agentSessionId;
           conversation.lastActivityAt = Date.now();
           this.emitConversation(conversation);
@@ -3129,7 +2678,7 @@ export class AgentWorkspaceProxy {
     this.upsertItem(conversationId, item);
     this.input.send(createEnvelope({
       type: "agent.v2.permission.request",
-      hostDeviceId: this.input.hostDeviceId,
+      sessionId: this.input.sessionId,
       payload: { conversationId, ...permission, item },
     }));
 
@@ -3140,14 +2689,6 @@ export class AgentWorkspaceProxy {
         this.permissionWaiters.delete(requestId);
         this.permissionSources.delete(requestId);
         resolve(formatPermissionResponse(source, "cancelled", "cancelled"));
-        this.markPermission(conversationId, requestId, {
-          permissionOutcome: "cancelled",
-          optionId: "cancelled",
-          permissionLive: false,
-          permissionPending: false,
-          permissionExpired: true,
-          permissionError: "等待授权超时",
-        });
         this.updateConversationStatus(conversationId, "idle");
       }, PERMISSION_TIMEOUT_MS);
       this.permissionWaiters.set(requestId, { resolve, timer });
@@ -3187,8 +2728,6 @@ export class AgentWorkspaceProxy {
     this.markPermission(payload.conversationId, payload.requestId, {
       permissionOutcome: payload.outcome,
       optionId: selectedOptionId,
-      permissionLive: false,
-      permissionExpired: false,
       permissionError: undefined,
       permissionPending: false,
     });
@@ -3249,228 +2788,6 @@ export class AgentWorkspaceProxy {
     });
   }
 
-  private getRevision(conversationId: string): number {
-    return this.conversationRevisions.get(conversationId) ??
-      this.conversations.get(conversationId)?.timelineRevision ??
-      0;
-  }
-
-  private setRevisionFloor(conversationId: string, revision: number): number {
-    const nextRevision = Math.max(this.getRevision(conversationId), revision);
-    this.conversationRevisions.set(conversationId, nextRevision);
-    const conversation = this.conversations.get(conversationId);
-    if (conversation) {
-      conversation.timelineRevision = nextRevision;
-      conversation.runningTurnId = this.currentTurnIds.get(conversationId);
-    }
-    return nextRevision;
-  }
-
-  private conversationSnapshot(conversation: AgentConversation): AgentConversation {
-    return {
-      ...conversation,
-      timelineRevision: this.getRevision(conversation.id),
-      historyComplete: conversation.historyComplete ?? false,
-      runningTurnId: this.currentTurnIds.get(conversation.id),
-      source: conversation.source ?? "device",
-      canonical: conversation.canonical ?? true,
-    };
-  }
-
-  private annotateTimelineItem(
-    item: AgentTimelineItem,
-    revision: number | undefined,
-    source: AgentSyncSource,
-  ): AgentTimelineItem {
-    return {
-      ...item,
-      revision: revision ?? item.revision,
-      source: item.source ?? source,
-      canonical: item.canonical ?? true,
-    };
-  }
-
-  private recordRevisionEvent(
-    conversationId: string,
-    change: { item?: AgentTimelineItem; conversation?: AgentConversation },
-  ): AgentRevisionEvent {
-    const revision = this.getRevision(conversationId) + 1;
-    this.conversationRevisions.set(conversationId, revision);
-    const conversation = this.conversations.get(conversationId);
-    if (conversation) {
-      conversation.timelineRevision = revision;
-      conversation.runningTurnId = this.currentTurnIds.get(conversationId);
-    }
-    const event: AgentRevisionEvent = {
-      revision,
-      item: change.item ? this.annotateTimelineItem(change.item, revision, "device-live") : undefined,
-      conversation: change.conversation ? this.conversationSnapshot(change.conversation) : undefined,
-    };
-    const events = this.revisionEvents.get(conversationId) ?? [];
-    events.push(event);
-    if (events.length > MAX_DELTA_EVENTS) {
-      events.splice(0, events.length - MAX_DELTA_EVENTS);
-    }
-    this.revisionEvents.set(conversationId, events);
-    return event;
-  }
-
-  private storedTimeline(conversation: AgentConversation, maxItems = HISTORY_PAGE_MAX_ITEMS): AgentTimelineItem[] {
-    if (!conversation.agentSessionId) return [];
-    const result = conversation.provider === "codex"
-      ? loadCodexStoredTimeline(conversation.agentSessionId, conversation.id, conversation.cwd || this.input.cwd, { maxItems })
-      : conversation.provider === "claude"
-      ? loadClaudeStoredTimeline(conversation.agentSessionId, conversation.id, { maxItems })
-      : { items: [] };
-    return result.items
-      .sort((a, b) => a.createdAt - b.createdAt)
-      .map((item, index) => this.annotateTimelineItem(item as AgentTimelineItem, index + 1, "device-history"));
-  }
-
-  private canonicalTimeline(conversation: AgentConversation, maxItems = HISTORY_PAGE_MAX_ITEMS): AgentTimelineItem[] {
-    const merged = new Map<string, AgentTimelineItem>();
-    for (const item of this.storedTimeline(conversation, maxItems)) {
-      merged.set(item.id, item);
-    }
-    for (const item of this.timelines.get(conversation.id) ?? []) {
-      merged.set(item.id, this.annotateTimelineItem(item, item.revision, item.source ?? "device-live"));
-    }
-    const items = [...merged.values()]
-      .sort((a, b) => a.createdAt - b.createdAt)
-      .slice(-maxItems);
-    this.setRevisionFloor(conversation.id, Math.max(this.getRevision(conversation.id), items.length));
-    return items;
-  }
-
-  private async appServerTimeline(conversation: AgentConversation, maxItems = HISTORY_PAGE_MAX_ITEMS): Promise<AgentTimelineItem[]> {
-    if (conversation.provider !== "codex" || !conversation.agentSessionId) return [];
-    if (this.protocolForProvider(conversation.provider) !== "codex-app-server") return [];
-    const client = this.clientForProvider(conversation.provider);
-    const listTurns = (client as { listTurns?: (input: { sessionId: string; limit?: number }) => Promise<unknown> } | undefined)?.listTurns;
-    if (typeof listTurns !== "function") return [];
-    try {
-      const result = await listTurns.call(client, { sessionId: conversation.agentSessionId, limit: maxItems });
-      return this.timelineFromAppServerTurns(conversation.id, conversation.agentSessionId, result);
-    } catch (error) {
-      if (this.input.verbose) {
-        process.stderr.write(`[agent:v2] thread/turns/list failed: ${error instanceof Error ? error.message : String(error)}\n`);
-      }
-      return [];
-    }
-  }
-
-  private timelineFromAppServerTurns(
-    conversationId: string,
-    agentSessionId: string,
-    value: unknown,
-  ): AgentTimelineItem[] {
-    const raw = asRecord(value);
-    const turns =
-      Array.isArray(value) ? value :
-      Array.isArray(raw?.turns) ? raw.turns :
-      Array.isArray(raw?.items) ? raw.items :
-      Array.isArray(raw?.entries) ? raw.entries :
-      [];
-    const items: AgentTimelineItem[] = [];
-    turns.forEach((entry, index) => {
-      const turn = asRecord(entry);
-      if (!turn) return;
-      const turnId = firstString(turn, ["id", "turnId", "turn_id"]) ?? `turn-${index + 1}`;
-      const createdAt = parseTimestamp(turn.createdAt ?? turn.created_at ?? turn.startedAt ?? turn.started_at) ?? Date.now() + index;
-      const updatedAt = parseTimestamp(turn.updatedAt ?? turn.updated_at ?? turn.completedAt ?? turn.completed_at);
-      const userText = appServerText(turn.input ?? turn.prompt ?? turn.user ?? turn.userMessage ?? turn.request);
-      if (userText) {
-        items.push({
-          id: `app-server:${agentSessionId}:${turnId}:user`,
-          conversationId,
-          type: "message",
-          kind: "chat",
-          turnId,
-          role: "user",
-          content: [{ type: "text", text: userText }],
-          text: userText,
-          createdAt,
-          updatedAt,
-          metadata: { source: "app-server", provider: "codex" },
-        });
-      }
-      const assistantText = appServerText(turn.output ?? turn.response ?? turn.assistant ?? turn.assistantMessage ?? turn.result);
-      if (assistantText) {
-        items.push({
-          id: `app-server:${agentSessionId}:${turnId}:assistant`,
-          conversationId,
-          type: "message",
-          kind: "chat",
-          turnId,
-          role: "assistant",
-          content: [{ type: "text", text: assistantText }],
-          text: assistantText,
-          createdAt: updatedAt ?? createdAt + 1,
-          updatedAt,
-          metadata: { source: "app-server", provider: "codex" },
-        });
-      }
-      const nestedItems = Array.isArray(turn.items) ? turn.items : Array.isArray(turn.messages) ? turn.messages : [];
-      for (const nested of nestedItems) {
-        const nestedRecord = asRecord(nested);
-        if (!nestedRecord) continue;
-        const text = appServerText(nestedRecord.content ?? nestedRecord.text ?? nestedRecord.message);
-        const role = nestedRecord.role === "user" || nestedRecord.role === "assistant" || nestedRecord.role === "system"
-          ? nestedRecord.role
-          : undefined;
-        if (!text || !role) continue;
-        const itemId = firstString(nestedRecord, ["id", "itemId", "messageId"]) ?? `${role}-${items.length + 1}`;
-        items.push({
-          id: `app-server:${agentSessionId}:${turnId}:${itemId}`,
-          conversationId,
-          type: "message",
-          kind: "chat",
-          turnId,
-          itemId,
-          role,
-          content: [{ type: "text", text }],
-          text,
-          createdAt: parseTimestamp(nestedRecord.createdAt ?? nestedRecord.created_at) ?? createdAt + items.length,
-          updatedAt: parseTimestamp(nestedRecord.updatedAt ?? nestedRecord.updated_at),
-          metadata: { source: "app-server", provider: "codex" },
-        });
-      }
-    });
-    return items
-      .sort((a, b) => a.createdAt - b.createdAt)
-      .map((item, index) => this.annotateTimelineItem(item, index + 1, "app-server"));
-  }
-
-  private mergeCanonicalTimelineItems(items: AgentTimelineItem[], maxItems: number): AgentTimelineItem[] {
-    const byKey = new Map<string, AgentTimelineItem>();
-    for (const item of items.sort((a, b) => a.createdAt - b.createdAt)) {
-      const key = item.type === "message" && item.role && item.text
-        ? `${item.role}:${item.text.replace(/\s+/g, " ").trim().slice(0, 500)}`
-        : item.id;
-      const existing = byKey.get(key);
-      if (!existing || item.source === "app-server" || (item.updatedAt ?? item.createdAt) >= (existing.updatedAt ?? existing.createdAt)) {
-        byKey.set(key, item);
-      }
-    }
-    return [...byKey.values()]
-      .sort((a, b) => a.createdAt - b.createdAt)
-      .slice(-maxItems);
-  }
-
-  private latestSnapshot(conversationId: string): {
-    items: AgentTimelineItem[];
-    cursor?: string;
-    hasMore: boolean;
-  } {
-    const timeline = this.timelines.get(conversationId) ?? [];
-    const start = Math.max(0, timeline.length - MAX_SNAPSHOT_ITEMS);
-    return {
-      items: timeline.slice(start).map((item) => snapshotTimelineItem(item)),
-      cursor: start > 0 ? String(start) : undefined,
-      hasMore: start > 0,
-    };
-  }
-
   private addItem(conversationId: string, item: AgentTimelineItem): void {
     this.rememberItemConversationId(conversationId, item);
     const timeline = this.timelines.get(conversationId) ?? [];
@@ -3508,8 +2825,6 @@ export class AgentWorkspaceProxy {
       ...existing,
       ...toolCall,
       id: targetToolId,
-      input: toolCall.input ?? existing?.input,
-      output: toolCall.output ?? existing?.output,
       createdAt: existing?.createdAt ?? toolCall.createdAt ?? Date.now(),
     };
     this.toolConversationIds.set(toolCall.id, conversationId);
@@ -3588,7 +2903,6 @@ export class AgentWorkspaceProxy {
       conversation.title = conversation.title ?? target.title;
       conversation.model = conversation.model ?? target.model;
       conversation.reasoningEffort = conversation.reasoningEffort ?? target.reasoningEffort;
-      conversation.serviceTier = conversation.serviceTier ?? target.serviceTier;
       conversation.permissionMode = conversation.permissionMode ?? target.permissionMode;
       conversation.lastMessagePreview = conversation.lastMessagePreview ?? target.lastMessagePreview;
       conversation.createdAt = Math.min(conversation.createdAt, target.createdAt);
@@ -3605,17 +2919,6 @@ export class AgentWorkspaceProxy {
         .sort((a, b) => a.createdAt - b.createdAt)
         .slice(-MAX_TIMELINE_ITEMS),
     );
-    const oldRevision = this.conversationRevisions.get(oldId) ?? 0;
-    if (oldRevision > 0) {
-      this.conversationRevisions.delete(oldId);
-      this.setRevisionFloor(newId, oldRevision);
-    }
-    const oldEvents = this.revisionEvents.get(oldId);
-    if (oldEvents) {
-      this.revisionEvents.delete(oldId);
-      const existingEvents = this.revisionEvents.get(newId) ?? [];
-      this.revisionEvents.set(newId, [...existingEvents, ...oldEvents].slice(-MAX_DELTA_EVENTS));
-    }
 
     for (const [agentSessionId, conversationId] of this.conversationByAgentSessionId) {
       if (conversationId === oldId) {
@@ -3651,48 +2954,18 @@ export class AgentWorkspaceProxy {
 
   private emitItem(conversationId: string, item: AgentTimelineItem): void {
     const conversation = this.conversations.get(conversationId);
-    const itemSnapshot = snapshotTimelineItem(item, { stripImages: false });
-    const event = this.recordRevisionEvent(conversationId, { conversation, item: itemSnapshot });
     this.input.send(createEnvelope({
       type: "agent.v2.event",
-      hostDeviceId: this.input.hostDeviceId,
-      payload: {
-        conversationId,
-        conversation: event.conversation,
-        item: event.item,
-        revision: event.revision,
-        source: "device-live",
-        canonical: true,
-      },
+      sessionId: this.input.sessionId,
+      payload: { conversationId, conversation, item },
     }));
   }
 
   private emitConversation(conversation: AgentConversation): void {
-    const event = this.recordRevisionEvent(conversation.id, { conversation });
     this.input.send(createEnvelope({
       type: "agent.v2.event",
-      hostDeviceId: this.input.hostDeviceId,
-      payload: {
-        conversationId: conversation.id,
-        conversation: event.conversation,
-        revision: event.revision,
-        source: "device-live",
-        canonical: true,
-      },
-    }));
-    this.input.send(createEnvelope({
-      type: "agent.v2.running_state",
-      hostDeviceId: this.input.hostDeviceId,
-      payload: {
-        conversationId: conversation.id,
-        status: conversation.status,
-        runningTurnId: this.currentTurnIds.get(conversation.id),
-        revision: event.revision,
-        error: conversation.status === "error" ? conversation.lastMessagePreview : undefined,
-        updatedAt: conversation.lastActivityAt,
-        source: "device-live",
-        canonical: true,
-      },
+      sessionId: this.input.sessionId,
+      payload: { conversationId: conversation.id, conversation },
     }));
   }
 
@@ -3734,186 +3007,21 @@ export class AgentWorkspaceProxy {
   }
 
   private sendSnapshot(conversationId?: string): void {
-    if (conversationId) {
-      const conversation = this.conversations.get(conversationId);
-      if (conversation) this.hydrateStoredTimeline(conversation);
-    } else if (this.activeConversationId) {
-      const conversation = this.conversations.get(this.activeConversationId);
-      if (conversation) this.hydrateStoredTimeline(conversation);
-    }
-    const conversations = [...this.conversations.values()].map((conversation) => this.conversationSnapshot(conversation));
-    const snapshot = conversationId ? this.latestSnapshot(conversationId) : { items: [], cursor: undefined, hasMore: false };
+    const conversations = [...this.conversations.values()];
+    const items = conversationId
+      ? this.timelines.get(conversationId) ?? []
+      : [...this.timelines.values()].flat();
     this.input.send(createEnvelope({
       type: "agent.v2.snapshot",
-      hostDeviceId: this.input.hostDeviceId,
+      sessionId: this.input.sessionId,
       payload: {
         conversations,
         activeConversationId: this.activeConversationId,
-        items: snapshot.items,
-        revision: conversationId ? this.getRevision(conversationId) : undefined,
-        cursor: snapshot.cursor,
-        hasMore: snapshot.hasMore,
-        source: "device-history",
-        canonical: true,
+        items,
       },
     }));
   }
 
-  private async sendHistoryPage(payload: {
-    conversationId: string;
-    cursor?: string;
-    limit?: number;
-    direction?: "older" | "newer";
-  }): Promise<void> {
-    const conversation = this.conversations.get(payload.conversationId);
-    if (!conversation) return;
-    const limit = Math.min(Math.max(payload.limit ?? MAX_SNAPSHOT_ITEMS, 1), 200);
-    const items = this.mergeCanonicalTimelineItems([
-      ...this.canonicalTimeline(conversation, HISTORY_PAGE_MAX_ITEMS),
-      ...await this.appServerTimeline(conversation, HISTORY_PAGE_MAX_ITEMS),
-    ], HISTORY_PAGE_MAX_ITEMS);
-    this.timelines.set(
-      conversation.id,
-      items.slice(-MAX_TIMELINE_ITEMS).map((item) => this.annotateTimelineItem(item, item.revision, item.source ?? "device-history")),
-    );
-    for (const item of this.timelines.get(conversation.id) ?? []) {
-      this.rememberItemConversationId(conversation.id, item);
-    }
-
-    const direction = payload.direction ?? "older";
-    let page: AgentTimelineItem[];
-    let cursor: string | undefined;
-    let hasMore = false;
-    if (direction === "newer") {
-      const start = clampHistoryCursor(payload.cursor, 0, items.length);
-      const end = Math.min(items.length, start + limit);
-      page = items.slice(start, end);
-      hasMore = end < items.length;
-      cursor = hasMore ? String(end) : undefined;
-    } else {
-      const end = clampHistoryCursor(payload.cursor, items.length, items.length);
-      const start = Math.max(0, end - limit);
-      page = items.slice(start, end);
-      hasMore = start > 0;
-      cursor = hasMore ? String(start) : undefined;
-    }
-    conversation.historyComplete = !hasMore;
-    const revision = this.setRevisionFloor(conversation.id, Math.max(this.getRevision(conversation.id), items.length));
-    this.input.send(createEnvelope({
-      type: "agent.v2.history.page",
-      hostDeviceId: this.input.hostDeviceId,
-      payload: {
-        conversationId: conversation.id,
-        conversation: this.conversationSnapshot(conversation),
-        items: page.map((item) => snapshotTimelineItem(item)),
-        revision,
-        cursor,
-        hasMore,
-        source: "device-history",
-        canonical: true,
-      },
-    }));
-  }
-
-  private sendDelta(payload: {
-    conversationId: string;
-    sinceRevision?: number;
-    limit?: number;
-  }): void {
-    const conversation = this.conversations.get(payload.conversationId);
-    if (!conversation) return;
-    this.hydrateStoredTimeline(conversation);
-    const sinceRevision = payload.sinceRevision ?? 0;
-    const limit = Math.min(Math.max(payload.limit ?? 100, 1), 500);
-    const events = this.revisionEvents.get(conversation.id) ?? [];
-    const oldestAvailable = events[0]?.revision ?? this.getRevision(conversation.id);
-    const newestRevision = this.getRevision(conversation.id);
-    const reset = sinceRevision > 0 &&
-      (
-        sinceRevision > newestRevision ||
-        (
-          sinceRevision < newestRevision &&
-          (events.length === 0 || sinceRevision < oldestAvailable - 1)
-        )
-      );
-
-    if (reset) {
-      const snapshot = this.latestSnapshot(conversation.id);
-      this.input.send(createEnvelope({
-        type: "agent.v2.delta",
-        hostDeviceId: this.input.hostDeviceId,
-        payload: {
-          conversationId: conversation.id,
-          conversation: this.conversationSnapshot(conversation),
-          items: snapshot.items,
-          sinceRevision,
-          revision: newestRevision,
-          reset: true,
-          cursor: snapshot.cursor,
-          hasMore: snapshot.hasMore,
-          source: "device-history",
-          canonical: true,
-        },
-      }));
-      return;
-    }
-
-    const changed = events
-      .filter((event) => event.revision > sinceRevision)
-      .slice(-limit);
-    const itemsById = new Map<string, AgentTimelineItem>();
-    for (const event of changed) {
-      if (event.item) itemsById.set(event.item.id, event.item);
-    }
-    this.input.send(createEnvelope({
-      type: "agent.v2.delta",
-      hostDeviceId: this.input.hostDeviceId,
-      payload: {
-        conversationId: conversation.id,
-        conversation: this.conversationSnapshot(conversation),
-        items: [...itemsById.values()].map((item) => snapshotTimelineItem(item)),
-        sinceRevision,
-        revision: newestRevision,
-        reset: false,
-        hasMore: changed.length === limit && events.some((event) => event.revision > sinceRevision && event.revision < changed[0]!.revision),
-        source: "device-live",
-        canonical: true,
-      },
-    }));
-  }
-
-  private hydrateStoredTimeline(conversation: AgentConversation): void {
-    if (!conversation.agentSessionId) return;
-    const existing = this.timelines.get(conversation.id) ?? [];
-    if (existing.length > 0) {
-      this.setRevisionFloor(conversation.id, Math.max(
-        existing.length,
-        ...existing.map((item) => item.revision ?? 0),
-      ));
-      return;
-    }
-    const stored = this.storedTimeline(conversation, MAX_TIMELINE_ITEMS);
-    conversation.historyComplete = stored.length <= MAX_SNAPSHOT_ITEMS;
-    if (stored.length === 0) {
-      this.setRevisionFloor(conversation.id, this.getRevision(conversation.id));
-      return;
-    }
-    const items = stored
-      .sort((a, b) => a.createdAt - b.createdAt)
-      .slice(-MAX_TIMELINE_ITEMS);
-    this.timelines.set(conversation.id, items);
-    for (const item of items) this.rememberItemConversationId(conversation.id, item);
-    this.setRevisionFloor(conversation.id, Math.max(items.length, ...items.map((item) => item.revision ?? 0)));
-    const lastMessage = [...items].reverse().find((item) => item.text?.trim());
-    if (lastMessage?.text && !conversation.lastMessagePreview) {
-      conversation.lastMessagePreview = previewText(lastMessage.text);
-    }
-    const lastActivityAt = items.at(-1)?.createdAt;
-    if (lastActivityAt) {
-      conversation.lastActivityAt = Math.max(conversation.lastActivityAt, lastActivityAt);
-    }
-  }
-
   private conversationIdFromParams(params: unknown): string | undefined {
     const raw = asRecord(params);
     if (!raw) return undefined;
@@ -3971,8 +3079,6 @@ export class AgentWorkspaceProxy {
   private rememberTurnConversationId(conversationId: string, turnId: string): void {
     this.currentTurnIds.set(conversationId, turnId);
     this.turnConversationIds.set(turnId, conversationId);
-    const conversation = this.conversations.get(conversationId);
-    if (conversation) conversation.runningTurnId = turnId;
   }
 
   private forgetCurrentTurn(conversationId: string, turnId?: string): void {
@@ -3980,8 +3086,6 @@ export class AgentWorkspaceProxy {
     this.currentTurnIds.delete(conversationId);
     if (turnId) this.turnConversationIds.delete(turnId);
     if (currentTurnId && currentTurnId !== turnId) this.turnConversationIds.delete(currentTurnId);
-    const conversation = this.conversations.get(conversationId);
-    if (conversation) conversation.runningTurnId = undefined;
   }
 
   private rememberItemConversationId(conversationId: string, item: AgentTimelineItem): void {
@@ -4023,54 +3127,32 @@ export class AgentWorkspaceProxy {
 
   private cancelPendingPermissions(conversationId?: string): void {
     for (const [requestId, waiter] of this.permissionWaiters) {
-      const ownerConversationId = this.conversationIdForPermissionRequest(requestId);
-      if (conversationId && ownerConversationId && ownerConversationId !== conversationId) continue;
       clearTimeout(waiter.timer);
       waiter.resolve(formatPermissionResponse(
         this.permissionSources.get(requestId),
         "cancelled",
         "cancelled",
       ));
-      if (ownerConversationId) {
-        this.markPermission(ownerConversationId, requestId, {
-          permissionOutcome: "cancelled",
-          optionId: "cancelled",
-          permissionLive: false,
-          permissionPending: false,
-          permissionExpired: false,
-          permissionError: "已停止",
-        });
-      }
-      this.permissionWaiters.delete(requestId);
       this.pendingPermissions.delete(requestId);
       this.permissionSources.delete(requestId);
     }
+    this.permissionWaiters.clear();
     for (const [requestId, waiter] of this.structuredInputWaiters) {
-      const pending = this.pendingStructuredInputs.get(requestId);
-      if (conversationId && pending?.conversationId && pending.conversationId !== conversationId) continue;
       clearTimeout(waiter.timer);
       waiter.resolve(formatStructuredInputResponse({}));
+      const pending = this.pendingStructuredInputs.get(requestId);
       if (pending) {
         this.markStructuredInput(pending.conversationId, requestId, {
           inputPending: false,
           inputError: "已停止",
         });
       }
-      this.structuredInputWaiters.delete(requestId);
       this.pendingStructuredInputs.delete(requestId);
     }
+    this.structuredInputWaiters.clear();
     if (conversationId) this.updateConversationStatus(conversationId, "idle");
   }
 
-  private conversationIdForPermissionRequest(requestId: string): string | undefined {
-    for (const [conversationId, timeline] of this.timelines) {
-      if (timeline.some((item) => item.type === "permission" && item.permission?.requestId === requestId)) {
-        return conversationId;
-      }
-    }
-    return undefined;
-  }
-
   private extractSessionId(value: unknown): string | undefined {
     const raw = asRecord(value);
     if (!raw) return undefined;