linkshell-cli 0.5.33 → 0.5.35

package/dist/cli/src/runtime/acp/agent-workspace.js

@@ -7,6 +7,7 @@ import { ClaudeSdkClient } from "./claude-sdk-client.js";
 import { ClaudeStreamJsonClient } from "./claude-stream-json-client.js";
 import { aggregateUsage } from "../usage-report.js";
 import { resolveAgentCommand } from "./provider-resolver.js";
+import { agentProviderLabel, discoverAgentProcessesAsync, isLiveConversationId, isProtocolAgentProvider, liveConversationId, } from "./agent-process-discovery.js";
 // Normalize the many status spellings Claude/Codex emit into our enum. Unknown
 // values fall back to "pending" (known-but-not-yet-up) rather than dropping the
 // server. Kept liberal because the real event vocabulary isn't fully pinned.
@@ -24,6 +25,19 @@ function normalizeMcpStatus(raw) {
         return "disabled";
     return "pending";
 }
+function mcpStatusFromRecord(rec) {
+    if (normalizeMcpStatus(rec.authStatus ?? rec.auth) === "needs_auth")
+        return "needs_auth";
+    return normalizeMcpStatus(rec.status ?? rec.state ?? rec.authStatus);
+}
+function mcpListFromProviderResult(value) {
+    const raw = asRecord(value);
+    const list = Array.isArray(value) ? value :
+        Array.isArray(raw?.data) ? raw.data :
+            Array.isArray(raw?.servers) ? raw.servers :
+                value;
+    return parseMcpServerList(list);
+}
 // Parse an MCP server list from either an array of {name,status,...} objects or
 // a {name: status} record — Claude's init `mcp_servers` shape isn't fixed.
 function parseMcpServerList(value) {
@@ -37,7 +51,7 @@ function parseMcpServerList(value) {
                     continue;
                 out.push({
                     name,
-                    status: normalizeMcpStatus(rec.status ?? rec.state),
+                    status: mcpStatusFromRecord(rec),
                     error: firstString(rec, ["error", "message", "reason"]),
                     toolCount: firstNumber(rec, ["toolCount", "tools", "toolsCount"]) ?? (Array.isArray(rec.tools) ? rec.tools.length : undefined),
                 });
@@ -56,7 +70,7 @@ function parseMcpServerList(value) {
             const inner = asRecord(raw);
             out.push({
                 name,
-                status: normalizeMcpStatus(inner ? (inner.status ?? inner.state) : raw),
+                status: inner ? mcpStatusFromRecord(inner) : normalizeMcpStatus(raw),
                 error: inner ? firstString(inner, ["error", "message", "reason"]) : undefined,
                 toolCount: inner ? (firstNumber(inner, ["toolCount", "tools", "toolsCount"]) ?? (Array.isArray(inner.tools) ? inner.tools.length : undefined)) : undefined,
             });
@@ -232,6 +246,47 @@ function normalizePlanStatus(value) {
         return "in_progress";
     return "pending";
 }
+function applyThreadSettingsToConversation(conversation, value) {
+    const raw = asRecord(value);
+    const settings = asRecord(raw?.threadSettings) ?? asRecord(raw?.settings) ?? raw;
+    if (!settings)
+        return;
+    const model = firstString(settings, ["model", "modelId", "currentModel"]);
+    if (model)
+        conversation.model = model;
+    const effort = firstString(settings, ["effort", "reasoningEffort", "reasoning_effort"])
+        ?? firstString(asRecord(asRecord(settings.collaborationMode ?? settings.collaboration_mode)?.settings), ["reasoning_effort", "reasoningEffort"]);
+    if (effort)
+        conversation.reasoningEffort = effort;
+    const collab = asRecord(settings.collaborationMode ?? settings.collaboration_mode);
+    const mode = typeof settings.collaborationMode === "string"
+        ? settings.collaborationMode
+        : typeof settings.collaboration_mode === "string"
+            ? settings.collaboration_mode
+            : firstString(collab, ["mode"]);
+    if (mode === "plan")
+        conversation.collaborationMode = "plan";
+    else if (mode === "default")
+        conversation.collaborationMode = "default";
+    const permission = firstString(settings, ["permissionMode", "permission_mode"]);
+    if (permission === "read_only" || permission === "workspace_write" || permission === "full_access") {
+        conversation.permissionMode = permission;
+        return;
+    }
+    const sandboxValue = settings.sandboxPolicy ?? settings.sandbox_policy;
+    const sandbox = asRecord(sandboxValue);
+    const sandboxType = typeof sandboxValue === "string" ? sandboxValue : firstString(sandbox, ["type"]);
+    if (!sandboxType)
+        return;
+    const norm = sandboxType.replace(/-/g, "").toLowerCase();
+    conversation.permissionMode = norm.includes("readonly")
+        ? "read_only"
+        : norm.includes("workspace")
+            ? "workspace_write"
+            : norm.includes("danger") || norm.includes("full")
+                ? "full_access"
+                : conversation.permissionMode;
+}
 function agentStatusFromThreadStatus(value) {
     const raw = asRecord(value);
     const status = typeof value === "string"
@@ -697,11 +752,7 @@ function previewText(text) {
     return text.replace(/\s+/g, " ").trim().slice(0, 160);
 }
 function providerLabel(provider) {
-    if (provider === "codex")
-        return "Codex";
-    if (provider === "claude")
-        return "Claude";
-    return "Custom";
+    return agentProviderLabel(provider);
 }
 const ALL_REASONING_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh"];
 const ALL_PERMISSION_MODES = ["read_only", "workspace_write", "full_access"];
@@ -1058,6 +1109,28 @@ function mergeCommands(...groups) {
     }
     return [...map.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
+function parseSkillCommands(provider, value) {
+    const raw = asRecord(value);
+    const groups = Array.isArray(value) ? value :
+        Array.isArray(raw?.data) ? raw.data :
+            Array.isArray(raw?.skills) ? [raw] :
+                [];
+    const skills = [];
+    for (const group of groups) {
+        if (typeof group === "string" && group) {
+            skills.push(group);
+            continue;
+        }
+        const rec = asRecord(group);
+        if (!rec)
+            continue;
+        if (Array.isArray(rec.skills))
+            skills.push(...rec.skills);
+        else if (firstString(rec, ["name", "command", "id"]))
+            skills.push(group);
+    }
+    return runtimeCommands(provider, skills);
+}
 function runtimeCommands(provider, value) {
     const raw = asRecord(value);
     const commandsValue = Array.isArray(value) ? value :
@@ -1390,11 +1463,11 @@ function parseRemoteSessions(value) {
         const id = firstString(source, ["id", "threadId", "sessionId", "agentSessionId"]);
         if (!id)
             continue;
-        // Only accept a transcript-derived status the provider actually reported
-        // (Claude's listSessions sets "running"/"idle" from the on-disk transcript).
-        // Anything else is left undefined so the sync site keeps its own status.
-        const reportedStatus = firstString(source, ["status"]);
-        const status = reportedStatus === "running" || reportedStatus === "idle" ? reportedStatus : undefined;
+        // Claude reports "running"/"idle" strings; Codex thread/list uses a tagged
+        // object ({ type: "active"|"idle"|"notLoaded"|"systemError" }). Both map
+        // through the same helper. Unknown / notLoaded stay undefined so the sync
+        // site keeps its own status.
+        const status = agentStatusFromThreadStatus(source.status);
         result.push({
             id,
             cwd: firstString(source, ["cwd", "workingDirectory", "workspacePath"]),
@@ -1664,6 +1737,9 @@ function previewFromTimelineItem(item) {
 export class AgentWorkspaceProxy {
     input;
     clients = new Map();
+    // In-flight client starts, so concurrent ensureProviderClient calls (eager
+    // initialize() racing conversation.open) share one subprocess spawn.
+    clientStartPromises = new Map();
     agentProtocols = new Map();
     providerCapabilities = new Map();
     providerErrors = new Map();
@@ -1676,10 +1752,9 @@ export class AgentWorkspaceProxy {
     conversations = new Map();
     conversationByAgentSessionId = new Map();
     timelines = new Map();
-    // Conversations the user "deleted" (forgot). We never touch the agent's
-    // on-disk transcript, so syncProviderSessions would otherwise re-list and
-    // resurrect them. Tombstone by agentSessionId (the stable provider key) so a
-    // forgotten conversation stays gone for the life of this workspace process.
+    // Conversations the user forgot from the LinkShell list. Tombstone by
+    // agentSessionId so syncProviderSessions cannot resurrect them. This is
+    // NOT Codex thread/delete (that hard-deletes the on-disk rollout).
     deletedAgentSessionIds = new Set();
     // Opaque codex turns cursor per conversation, pointing at OLDER history to
     // page through (captured at hydration, advanced on each history.request).
@@ -1692,6 +1767,12 @@ export class AgentWorkspaceProxy {
     structuredInputWaiters = new Map();
     itemConversationIds = new Map();
     toolConversationIds = new Map();
+    processPollTimer;
+    processPollInFlight = false;
+    processMissCounts = new Map();
+    lastDiscoveredProviders = new Set();
+    static PROCESS_POLL_MS = 3_000;
+    static PROCESS_MISS_LIMIT = 2;
     constructor(input) {
         this.input = input;
     }
@@ -1712,36 +1793,89 @@ export class AgentWorkspaceProxy {
                 const conversation = this.conversations.get(payload.conversationId);
                 if (!conversation)
                     break;
+                const raw = asRecord(envelope.payload) ?? {};
+                const model = payload.model ?? (typeof raw.model === "string" ? raw.model : undefined);
+                const reasoningEffort = payload.reasoningEffort
+                    ?? (typeof raw.reasoningEffort === "string" ? raw.reasoningEffort : undefined);
+                const permissionMode = payload.permissionMode
+                    ?? (raw.permissionMode === "read_only" || raw.permissionMode === "workspace_write" || raw.permissionMode === "full_access"
+                        ? raw.permissionMode
+                        : undefined);
+                const collaborationMode = payload.collaborationMode
+                    ?? (raw.collaborationMode === "default" || raw.collaborationMode === "plan"
+                        ? raw.collaborationMode
+                        : undefined);
                 if (payload.title !== undefined) {
                     const trimmed = payload.title.trim();
                     conversation.title = trimmed === "" ? undefined : trimmed;
                 }
                 if (payload.archived !== undefined)
                     conversation.archived = payload.archived;
+                if (model !== undefined) {
+                    const trimmed = model.trim();
+                    if (trimmed)
+                        conversation.model = trimmed;
+                }
+                if (reasoningEffort !== undefined)
+                    conversation.reasoningEffort = reasoningEffort;
+                if (permissionMode !== undefined)
+                    conversation.permissionMode = permissionMode;
+                if (collaborationMode !== undefined)
+                    conversation.collaborationMode = collaborationMode;
                 conversation.lastActivityAt = Date.now();
                 // Echo the updated record so every client refreshes (the web store
                 // force-replaces by id on any event carrying `conversation`).
                 this.emitConversation(conversation);
+                if (conversation.provider === "codex" && conversation.agentSessionId) {
+                    const client = this.clientForProvider(conversation.provider);
+                    const settingsChanged = model !== undefined ||
+                        reasoningEffort !== undefined ||
+                        permissionMode !== undefined ||
+                        collaborationMode !== undefined;
+                    try {
+                        const acp = client;
+                        if (payload.title !== undefined && typeof acp?.setThreadName === "function") {
+                            await acp.setThreadName({
+                                sessionId: conversation.agentSessionId,
+                                name: conversation.title ?? "",
+                            });
+                        }
+                        if (payload.archived === true && typeof acp?.archiveThread === "function") {
+                            await acp.archiveThread({ sessionId: conversation.agentSessionId });
+                        }
+                        else if (payload.archived === false && typeof acp?.unarchiveThread === "function") {
+                            await acp.unarchiveThread({ sessionId: conversation.agentSessionId });
+                        }
+                        if (settingsChanged && typeof acp?.updateThreadSettings === "function") {
+                            await acp.updateThreadSettings({
+                                sessionId: conversation.agentSessionId,
+                                model,
+                                reasoningEffort,
+                                permissionMode,
+                                collaborationMode,
+                                cwd: conversation.cwd,
+                            });
+                        }
+                    }
+                    catch (error) {
+                        if (this.input.verbose) {
+                            process.stderr.write(`[agent:v2] conversation update provider call failed: ${error instanceof Error ? error.message : String(error)}\n`);
+                        }
+                    }
+                }
                 break;
             }
             case "agent.v2.conversation.delete": {
                 const payload = parseTypedPayload("agent.v2.conversation.delete", envelope.payload);
-                const conversation = this.conversations.get(payload.conversationId);
-                // Forget the conversation from the workspace's tracked set. We do NOT
-                // delete the provider's on-disk transcript — only stop tracking it and
-                // tombstone its session id so syncProviderSessions won't re-add it.
-                if (conversation?.agentSessionId) {
-                    this.deletedAgentSessionIds.add(conversation.agentSessionId);
-                    this.conversationByAgentSessionId.delete(conversation.agentSessionId);
-                }
-                this.conversations.delete(payload.conversationId);
-                this.timelines.delete(payload.conversationId);
-                this.historyCursors.delete(payload.conversationId);
-                this.input.send(createEnvelope({
-                    type: "agent.v2.conversation.deleted",
-                    sessionId: this.input.sessionId,
-                    payload: { conversationId: payload.conversationId },
-                }));
+                // Forget from LinkShell only. Never call Codex thread/delete here —
+                // that hard-deletes the on-disk rollout. Archive is the destructive-ish
+                // user action; this menu item is "hide from the tree".
+                this.forgetConversationLocally(payload.conversationId);
+                break;
+            }
+            case "agent.v2.mcp.login": {
+                const payload = parseTypedPayload("agent.v2.mcp.login", envelope.payload);
+                await this.startMcpLogin(payload);
                 break;
             }
             case "agent.v2.conversation.list": {
@@ -1814,6 +1948,10 @@ export class AgentWorkspaceProxy {
         }
     }
     stop() {
+        if (this.processPollTimer) {
+            clearInterval(this.processPollTimer);
+            this.processPollTimer = undefined;
+        }
         for (const watcher of this.fsWatchers) {
             try {
                 watcher.close();
@@ -1844,7 +1982,9 @@ export class AgentWorkspaceProxy {
     fsSyncTimer;
     fsSyncRunning = false;
     lastPushedConversationSignature;
+    lastHydrateAt = new Map();
     static FS_SYNC_THROTTLE_MS = 1500;
+    static EXTERNAL_HYDRATE_THROTTLE_MS = 2000;
     startSessionWatchers() {
         const roots = [
             join(homedir(), ".claude", "projects"),
@@ -1898,17 +2038,40 @@ export class AgentWorkspaceProxy {
             // and client re-renders. A cheap signature over the render-relevant fields
             // gates the push.
             const signature = this.conversationListSignature(conversations);
-            if (signature === this.lastPushedConversationSignature)
-                return;
-            this.lastPushedConversationSignature = signature;
-            // Push the conversation list (statuses) — lighter than a full snapshot and
-            // exactly what refreshes the tree. The web handles an unsolicited
-            // conversation.list.result the same as a requested one.
-            this.input.send(createEnvelope({
-                type: "agent.v2.conversation.list.result",
-                sessionId: this.input.sessionId,
-                payload: { conversations },
-            }));
+            if (signature !== this.lastPushedConversationSignature) {
+                this.lastPushedConversationSignature = signature;
+                // Push the conversation list (statuses) — lighter than a full snapshot and
+                // exactly what refreshes the tree. The web handles an unsolicited
+                // conversation.list.result the same as a requested one.
+                this.input.send(createEnvelope({
+                    type: "agent.v2.conversation.list.result",
+                    sessionId: this.input.sessionId,
+                    payload: { conversations },
+                }));
+            }
+            // External sessions (status running / waiting_permission but LinkShell is
+            // not driving the turn) have no live event stream on this app-server.
+            // Re-hydrate on a short throttle so the Web timeline still moves.
+            const now = Date.now();
+            for (const conversation of conversations) {
+                if (conversation.status !== "running" && conversation.status !== "waiting_permission")
+                    continue;
+                if (this.currentTurnIds.has(conversation.id))
+                    continue;
+                const last = this.lastHydrateAt.get(conversation.id) ?? 0;
+                if (now - last < AgentWorkspaceProxy.EXTERNAL_HYDRATE_THROTTLE_MS)
+                    continue;
+                this.lastHydrateAt.set(conversation.id, now);
+                try {
+                    await this.hydrateConversationFromProvider(conversation, undefined, { rememberActiveTurn: false });
+                    this.sendSnapshot(conversation.id);
+                }
+                catch (error) {
+                    if (this.input.verbose) {
+                        process.stderr.write(`[agent:v2] external hydrate failed for ${conversation.id}: ${error instanceof Error ? error.message : String(error)}\n`);
+                    }
+                }
+            }
         }
         catch (error) {
             if (this.input.verbose) {
@@ -1926,7 +2089,7 @@ export class AgentWorkspaceProxy {
      *  membership are what matter. */
     conversationListSignature(conversations) {
         return conversations
-            .map((c) => `${c.id}
${c.status}
${c.title ?? ""}
${c.model ?? ""}
${c.provider ?? ""}`)
+            .map((c) => `${c.id}
${c.status}
${c.title ?? ""}
${c.model ?? ""}
${c.provider ?? ""}
${c.lastMessagePreview ?? ""}`)
             .sort()
             .join("");
     }
@@ -1978,11 +2141,183 @@ export class AgentWorkspaceProxy {
         // Start watching the on-disk session stores so externally-started sessions
         // and status changes surface live, not just at connect time.
         this.startSessionWatchers();
+        this.startProcessDiscovery();
+    }
+    startProcessDiscovery() {
+        void this.pollDiscoveredProcesses();
+        if (this.processPollTimer)
+            return;
+        this.processPollTimer = setInterval(() => {
+            void this.pollDiscoveredProcesses();
+        }, AgentWorkspaceProxy.PROCESS_POLL_MS);
+        this.processPollTimer.unref?.();
+    }
+    async pollDiscoveredProcesses() {
+        if (this.processPollInFlight)
+            return;
+        this.processPollInFlight = true;
+        try {
+            const snapshots = this.input.discoverProcesses
+                ? this.input.discoverProcesses()
+                : await discoverAgentProcessesAsync();
+            this.applyDiscoveredProcesses(snapshots);
+        }
+        catch {
+            // A failed ps scan must not tear down the workspace or hitch the PTY.
+        }
+        finally {
+            this.processPollInFlight = false;
+        }
+    }
+    /** Open Island rule: a visible agent session is a live process. Two missed
+     *  polls (~6s) drop the running signal so a killed CLI does not linger. */
+    reconcileDiscoveredProcesses() {
+        let snapshots = [];
+        try {
+            snapshots = this.input.discoverProcesses?.() ?? [];
+        }
+        catch {
+            snapshots = [];
+        }
+        this.applyDiscoveredProcesses(snapshots);
+    }
+    applyDiscoveredProcesses(snapshots) {
+        const seenKeys = new Set();
+        const discoveredProviders = new Set();
+        let listChanged = false;
+        for (const snapshot of snapshots) {
+            discoveredProviders.add(snapshot.provider);
+            const key = snapshot.sessionId
+                ? `${snapshot.provider}:${snapshot.sessionId}`
+                : `${snapshot.provider}:${snapshot.pid}`;
+            seenKeys.add(key);
+            this.processMissCounts.set(key, 0);
+            const existingId = snapshot.sessionId
+                ? this.conversationByAgentSessionId.get(snapshot.sessionId)
+                : undefined;
+            const liveId = liveConversationId(snapshot);
+            const conversationId = existingId ?? liveId;
+            const existing = this.conversations.get(conversationId);
+            const cwd = snapshot.cwd ?? existing?.cwd ?? this.input.cwd;
+            const driving = this.currentTurnIds.has(conversationId);
+            const status = driving
+                ? existing?.status ?? "running"
+                : existing?.status === "waiting_permission"
+                    ? "waiting_permission"
+                    : "running";
+            if (existing) {
+                const changed = existing.status !== status || existing.cwd !== cwd || !existing.title;
+                existing.status = status;
+                existing.cwd = cwd;
+                if (!existing.title)
+                    existing.title = agentProviderLabel(snapshot.provider);
+                if (snapshot.sessionId && !existing.agentSessionId) {
+                    existing.agentSessionId = snapshot.sessionId;
+                    this.conversationByAgentSessionId.set(snapshot.sessionId, existing.id);
+                }
+                if (changed) {
+                    listChanged = true;
+                    this.emitConversation(existing);
+                }
+                continue;
+            }
+            const now = Date.now();
+            const conversation = {
+                id: conversationId,
+                agentSessionId: snapshot.sessionId,
+                provider: snapshot.provider,
+                cwd,
+                title: agentProviderLabel(snapshot.provider),
+                status,
+                archived: false,
+                lastMessagePreview: "本机终端中的 Agent 进程",
+                lastActivityAt: now,
+                createdAt: now,
+            };
+            this.conversations.set(conversation.id, conversation);
+            if (snapshot.sessionId)
+                this.conversationByAgentSessionId.set(snapshot.sessionId, conversation.id);
+            this.emitConversation(conversation);
+            listChanged = true;
+        }
+        for (const [key, misses] of this.processMissCounts) {
+            if (seenKeys.has(key))
+                continue;
+            const next = misses + 1;
+            this.processMissCounts.set(key, next);
+            if (next < AgentWorkspaceProxy.PROCESS_MISS_LIMIT)
+                continue;
+            this.processMissCounts.delete(key);
+            const [provider, idPart] = key.split(":");
+            if (!provider || !idPart)
+                continue;
+            const conversation = [...this.conversations.values()].find((item) => {
+                if (item.provider !== provider)
+                    return false;
+                if (item.agentSessionId === idPart)
+                    return true;
+                return item.id === `agent-live-${provider}-${idPart}`;
+            });
+            if (!conversation)
+                continue;
+            if (this.currentTurnIds.has(conversation.id))
+                continue;
+            if (conversation.status === "waiting_permission")
+                continue;
+            if (conversation.status === "running") {
+                conversation.status = "idle";
+                conversation.lastActivityAt = Date.now();
+                this.emitConversation(conversation);
+                listChanged = true;
+            }
+            if (isLiveConversationId(conversation.id) && !conversation.agentSessionId) {
+                this.conversations.delete(conversation.id);
+                this.timelines.delete(conversation.id);
+                this.input.send(createEnvelope({
+                    type: "agent.v2.conversation.deleted",
+                    sessionId: this.input.sessionId,
+                    payload: { conversationId: conversation.id },
+                }));
+                listChanged = true;
+            }
+        }
+        const catalogChanged = discoveredProviders.size !== this.lastDiscoveredProviders.size ||
+            [...discoveredProviders].some((provider) => !this.lastDiscoveredProviders.has(provider));
+        this.lastDiscoveredProviders = discoveredProviders;
+        if (catalogChanged)
+            this.sendCapabilities();
+        if (listChanged) {
+            const conversations = [...this.conversations.values()].filter((item) => !item.archived);
+            this.lastPushedConversationSignature = this.conversationListSignature(conversations);
+            this.input.send(createEnvelope({
+                type: "agent.v2.conversation.list.result",
+                sessionId: this.input.sessionId,
+                payload: { conversations },
+            }));
+        }
     }
     async ensureProviderClient(provider) {
         const existing = this.clients.get(provider);
         if (existing)
             return existing;
+        // Dedupe concurrent starts: eager initialize() and conversation.open can
+        // race here before this.clients is populated (it's only set AFTER the
+        // client finishes initializing), which would spawn the provider subprocess
+        // twice. Memoize the in-flight promise so both callers share one spawn;
+        // drop it once settled so a failed start can be retried.
+        const inflight = this.clientStartPromises.get(provider);
+        if (inflight)
+            return inflight;
+        const start = this.startProviderClient(provider);
+        this.clientStartPromises.set(provider, start);
+        try {
+            return await start;
+        }
+        finally {
+            this.clientStartPromises.delete(provider);
+        }
+    }
+    async startProviderClient(provider) {
         const resolved = resolveAgentCommand({
             provider,
             command: this.input.command,
@@ -2033,7 +2368,7 @@ export class AgentWorkspaceProxy {
             const client = await tryCreateClient(resolved);
             this.clients.set(provider, client);
             this.providerErrors.delete(provider);
-            await this.refreshProviderCapabilities(provider, client, resolved.protocol);
+            this.refreshProviderCapabilitiesInBackground(provider, client, resolved.protocol);
             this.status = "idle";
             this.error = undefined;
             this.sendCapabilities();
@@ -2054,7 +2389,7 @@ export class AgentWorkspaceProxy {
                     const client = await tryCreateClient(fallback);
                     this.clients.set(provider, client);
                     this.providerErrors.delete(provider);
-                    await this.refreshProviderCapabilities(provider, client, fallback.protocol);
+                    this.refreshProviderCapabilitiesInBackground(provider, client, fallback.protocol);
                     this.status = "idle";
                     this.error = undefined;
                     this.sendCapabilities();
@@ -2074,6 +2409,22 @@ export class AgentWorkspaceProxy {
             return undefined;
         }
     }
+    /** Kick off runtime capability discovery WITHOUT blocking the caller.
+     *  refreshProviderCapabilities spawns a warm provider subprocess (measured
+     *  858ms warm, multi-second cold for Claude), and nothing on the open/prompt
+     *  path needs it — sendCapabilities and prompt-time model resolution both
+     *  degrade gracefully to static fallbacks until providerCapabilities is
+     *  populated. When discovery lands we push a fresh agent.v2.capabilities so
+     *  clients pick up the real model/command list. */
+    refreshProviderCapabilitiesInBackground(provider, client, protocol) {
+        void this.refreshProviderCapabilities(provider, client, protocol)
+            .then(() => this.sendCapabilities())
+            .catch((error) => {
+            if (this.input.verbose) {
+                process.stderr.write(`[agent:v2] capability refresh failed for ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        });
+    }
     async refreshProviderCapabilities(provider, client, protocol) {
         if (client instanceof AcpClient && protocol !== "codex-app-server")
             return;
@@ -2090,9 +2441,11 @@ export class AgentWorkspaceProxy {
                 }
             }
         }
+        const listedMcp = await this.listProviderMcpServers(client);
         if (provider === "codex") {
             // Codex `model/list` is unreliable across versions — make sure mobile always
             // sees a usable model picker by merging in a static fallback list.
+            const skillCommands = await this.loadProviderSkillCommands(provider, client);
             const merged = {
                 models: runtimeCapabilities?.models?.length
                     ? runtimeCapabilities.models
@@ -2101,13 +2454,15 @@ export class AgentWorkspaceProxy {
                 reasoningEfforts: runtimeCapabilities?.reasoningEfforts?.length
                     ? runtimeCapabilities.reasoningEfforts
                     : [...ALL_REASONING_EFFORTS],
-                commands: runtimeCapabilities?.commands,
+                commands: mergeCommands(runtimeCapabilities?.commands, skillCommands),
                 modes: runtimeCapabilities?.modes,
                 currentMode: runtimeCapabilities?.currentMode,
                 // Preserve any MCP status already accumulated from startupStatus events.
                 mcpServers: runtimeCapabilities?.mcpServers ?? this.providerCapabilities.get(provider)?.mcpServers,
             };
             this.providerCapabilities.set(provider, merged);
+            if (listedMcp.length > 0)
+                this.mergeMcpServers(provider, listedMcp);
             return;
         }
         if (runtimeCapabilities) {
@@ -2120,8 +2475,46 @@ export class AgentWorkspaceProxy {
                     map.set(name, desc);
                 runtimeCapabilities = { ...runtimeCapabilities, mcpServers: map };
             }
+            const skillCommands = await this.loadProviderSkillCommands(provider, client);
+            if (skillCommands.length > 0) {
+                runtimeCapabilities = {
+                    ...runtimeCapabilities,
+                    commands: mergeCommands(runtimeCapabilities.commands, skillCommands),
+                };
+            }
             this.providerCapabilities.set(provider, runtimeCapabilities);
         }
+        if (listedMcp.length > 0)
+            this.mergeMcpServers(provider, listedMcp);
+    }
+    async listProviderMcpServers(client) {
+        const listMcpServers = client.listMcpServers;
+        if (typeof listMcpServers !== "function")
+            return [];
+        try {
+            return mcpListFromProviderResult(await listMcpServers.call(client));
+        }
+        catch (error) {
+            if (this.input.verbose) {
+                process.stderr.write(`[agent:v2] mcpServerStatus/list failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+            return [];
+        }
+    }
+    async loadProviderSkillCommands(provider, client) {
+        const listSkills = client.listSkills;
+        if (typeof listSkills !== "function")
+            return [];
+        try {
+            const result = await listSkills.call(client, { cwd: this.input.cwd });
+            return parseSkillCommands(provider, result);
+        }
+        catch (error) {
+            if (this.input.verbose) {
+                process.stderr.write(`[agent:v2] skills/list failed for ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+            return [];
+        }
     }
     async syncProviderSessions() {
         await this.initialize();
@@ -2180,9 +2573,11 @@ export class AgentWorkspaceProxy {
                         ? existing?.status ?? "running"
                         : remoteRunning
                             ? "running"
-                            : existing?.status === "error" || existing?.status === "waiting_permission"
-                                ? existing.status
-                                : "idle";
+                            : remote.status === "error"
+                                ? "error"
+                                : existing?.status === "error" || existing?.status === "waiting_permission"
+                                    ? existing.status
+                                    : "idle";
                     const conversation = {
                         id: conversationId,
                         agentSessionId,
@@ -2212,7 +2607,7 @@ export class AgentWorkspaceProxy {
             }
         }
     }
-    async hydrateConversationFromProvider(conversation, seedResult) {
+    async hydrateConversationFromProvider(conversation, seedResult, options) {
         let client = this.clientForProvider(conversation.provider);
         if (!client || !conversation.agentSessionId)
             return;
@@ -2282,8 +2677,9 @@ export class AgentWorkspaceProxy {
         }
         const thread = threadFromProviderResult(source);
         const activeTurnId = activeTurnIdFromThread(thread);
-        if (activeTurnId)
+        if (activeTurnId && options?.rememberActiveTurn !== false) {
             this.rememberTurnConversationId(conversation.id, activeTurnId);
+        }
         const model = firstString(thread, ["model", "modelId", "currentModel"]);
         if (model && !conversation.model)
             conversation.model = model;
@@ -2356,7 +2752,11 @@ export class AgentWorkspaceProxy {
         }
     }
     sendCapabilities() {
-        const providers = this.input.availableProviders.map((provider) => {
+        const catalog = [...new Set([
+                ...this.input.availableProviders,
+                ...this.lastDiscoveredProviders,
+            ])];
+        const providers = catalog.map((provider) => {
             const client = this.clients.get(provider);
             const protocol = this.agentProtocols.get(provider);
             const runtimeCapabilities = this.providerCapabilities.get(provider);
@@ -2365,13 +2765,18 @@ export class AgentWorkspaceProxy {
             const isClaudeFallback = protocol === "claude-stream-json";
             const supportsPermission = enabled && !isClaudeFallback;
             const supportsReasoningEffort = enabled && !isClaudeFallback;
+            const protocolBacked = isProtocolAgentProvider(provider);
             const commands = mergeCommands(defaultProviderCommands(provider, this.input.cwd, enabled), runtimeCapabilities?.commands);
             const currentMode = [...this.conversations.values()].find((conversation) => conversation.provider === provider)?.collaborationMode;
             return {
                 id: provider,
                 label: providerLabel(provider),
                 enabled,
-                reason: enabled ? undefined : this.providerErrors.get(provider) ?? `${providerLabel(provider)} 未安装或启动失败`,
+                reason: enabled
+                    ? undefined
+                    : protocolBacked
+                        ? this.providerErrors.get(provider) ?? `${providerLabel(provider)} 未安装或启动失败`
+                        : `${providerLabel(provider)} 已在本机检测；远程对话请在终端继续`,
                 supportsImages,
                 supportsPermission,
                 supportsPlan: enabled,
@@ -2408,11 +2813,11 @@ export class AgentWorkspaceProxy {
             sessionId: this.input.sessionId,
             payload: {
                 enabled: anyEnabled,
-                provider: this.input.availableProviders[0] ?? "codex",
+                provider: this.input.availableProviders[0] ?? catalog[0] ?? "codex",
                 providers,
                 protocolVersion: 1,
                 workspaceProtocolVersion: 2,
-                error: anyEnabled ? undefined : "没有可用的 Agent provider。请安装 Claude Code 或 Codex CLI。",
+                error: anyEnabled ? undefined : "没有可远程驱动的 Agent。请安装 Claude Code 或 Codex CLI；其它 Agent 只要在本机终端运行就会出现在列表里。",
                 supportsSessionList: anyEnabled,
                 supportsSessionLoad: anyEnabled,
                 supportsImages: providers.some((p) => p.supportsImages),
@@ -2428,13 +2833,34 @@ export class AgentWorkspaceProxy {
         if (!provider) {
             return this.openFailure(payload, "没有可用的 Agent provider。");
         }
-        if (!this.input.availableProviders.includes(provider)) {
-            return this.openFailure(payload, `${providerLabel(provider)} 未安装或不可用。`);
-        }
         let cwd = payload.cwd ?? this.input.cwd;
         let agentSessionId = payload.agentSessionId;
         let existingConversation = (payload.conversationId ? this.conversations.get(payload.conversationId) : undefined) ??
             (agentSessionId ? this.conversations.get(this.conversationByAgentSessionId.get(agentSessionId) ?? "") : undefined);
+        if (existingConversation &&
+            !this.clientForProvider(existingConversation.provider) &&
+            !isProtocolAgentProvider(existingConversation.provider)) {
+            this.activeConversationId = existingConversation.id;
+            this.input.send(createEnvelope({
+                type: "agent.v2.conversation.opened",
+                sessionId: this.input.sessionId,
+                payload: {
+                    conversation: existingConversation,
+                    snapshot: this.timelines.get(existingConversation.id) ?? [],
+                    requestedConversationId: payload.conversationId,
+                },
+            }));
+            return existingConversation;
+        }
+        if (!isProtocolAgentProvider(provider) && !resolveAgentCommand({
+            provider,
+            command: this.input.command,
+        })) {
+            return this.openFailure(payload, `${providerLabel(provider)} 还不能从远程新建对话。在本机终端启动后，会话会出现在列表里。`);
+        }
+        if (!this.input.availableProviders.includes(provider) && !existingConversation) {
+            return this.openFailure(payload, `${providerLabel(provider)} 未安装或不可用。`);
+        }
         if (!payload.cwd && existingConversation?.cwd)
             cwd = existingConversation.cwd;
         let client = await this.ensureProviderClient(provider);
@@ -2461,14 +2887,15 @@ export class AgentWorkspaceProxy {
             return this.openFailure(payload, message, cwd);
         }
         // Fork: seed a NEW conversation from an existing one's transcript, truncated
-        // at forkFromTurnId. Claude only — the SDK client exposes forkSession(); the
-        // stream-json fallback and Codex don't, so we notify and fall through to a
-        // plain new conversation rather than pretend. On success we set agentSessionId
-        // to the freshly-written transcript id and let the normal load path hydrate it.
+        // at forkFromTurnId. Claude uses the SDK forkSession(); Codex uses
+        // thread/fork. Other providers notify and fall through to a plain new
+        // conversation. On success we set agentSessionId to the new thread id and
+        // let the normal load path hydrate it.
         if (payload.forkFromConversationId) {
             const source = this.conversations.get(payload.forkFromConversationId);
             const sourceSessionId = source?.agentSessionId;
             const forkable = client.forkSession;
+            const forkThread = client.forkThread;
             if (provider === "claude" && typeof forkable === "function" && sourceSessionId) {
                 if (source?.cwd && !payload.cwd)
                     cwd = source.cwd;
@@ -2490,6 +2917,39 @@ export class AgentWorkspaceProxy {
                     this.emitNotice({ kind: "warning", title: "分叉失败", detail: "无法复制该会话的历史记录，已新建空会话。" });
                 }
             }
+            else if (provider === "codex" && typeof forkThread === "function" && sourceSessionId) {
+                if (source?.cwd && !payload.cwd)
+                    cwd = source.cwd;
+                try {
+                    const forked = await forkThread.call(client, {
+                        sessionId: sourceSessionId,
+                        lastTurnId: payload.forkFromTurnId,
+                    });
+                    const forkedId = this.extractSessionId(forked);
+                    if (forkedId) {
+                        agentSessionId = forkedId;
+                        payload = {
+                            ...payload,
+                            model: payload.model ?? source?.model,
+                            reasoningEffort: payload.reasoningEffort ?? source?.reasoningEffort,
+                            permissionMode: payload.permissionMode ?? source?.permissionMode,
+                            collaborationMode: payload.collaborationMode ?? source?.collaborationMode,
+                            title: payload.title ?? (source?.title ? `${source.title} (分叉)` : undefined),
+                        };
+                        existingConversation = undefined;
+                    }
+                    else {
+                        this.emitNotice({ kind: "warning", title: "分叉失败", detail: "无法复制该会话的历史记录，已新建空会话。" });
+                    }
+                }
+                catch (error) {
+                    this.emitNotice({
+                        kind: "warning",
+                        title: "分叉失败",
+                        detail: error instanceof Error ? error.message : "无法复制该会话的历史记录，已新建空会话。",
+                    });
+                }
+            }
             else {
                 this.emitNotice({
                     kind: "native_unsupported",
@@ -2690,12 +3150,16 @@ export class AgentWorkspaceProxy {
         if (!conversation)
             return;
         if (!conversation.agentSessionId) {
-            this.rejectAgentAction(conversation, "Agent session 尚未就绪，消息没有发送。请重新打开对话后再试。");
+            this.rejectAgentAction(conversation, isLiveConversationId(conversation.id) || !isProtocolAgentProvider(conversation.provider)
+                ? `${providerLabel(conversation.provider)} 正在本机终端中运行。远程对话协议尚未接入，请打开终端面板继续。`
+                : "Agent session 尚未就绪，消息没有发送。请重新打开对话后再试。");
             return;
         }
         const client = this.clientForProvider(conversation.provider) ?? await this.ensureProviderClient(conversation.provider);
         if (!client) {
-            this.rejectAgentAction(conversation, this.providerErrors.get(conversation.provider) ?? `${providerLabel(conversation.provider)} 未连接，消息没有发送。`, "error");
+            this.rejectAgentAction(conversation, isLiveConversationId(conversation.id) || !isProtocolAgentProvider(conversation.provider)
+                ? `${providerLabel(conversation.provider)} 正在本机终端中运行。远程对话协议尚未接入，请打开终端面板继续。`
+                : this.providerErrors.get(conversation.provider) ?? `${providerLabel(conversation.provider)} 未连接，消息没有发送。`, "error");
             return;
         }
         const protocol = this.protocolForProvider(conversation.provider);
@@ -2999,14 +3463,37 @@ export class AgentWorkspaceProxy {
                 this.emitStatus(conversation.id, "idle", "上下文已重置，已创建新的 Codex thread。");
                 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.";
+            if (command.name === "review") {
+                const startReview = client?.startReview;
+                if (typeof startReview === "function" && conversation.agentSessionId) {
+                    conversation.status = "running";
+                    conversation.lastActivityAt = now;
+                    this.emitConversation(conversation);
+                    const result = await startReview.call(client, {
+                        sessionId: conversation.agentSessionId,
+                        prompt: args || undefined,
+                    });
+                    const turnId = this.extractTurnId(result);
+                    if (turnId)
+                        this.rememberTurnConversationId(conversation.id, turnId);
+                    return;
+                }
+                await this.sendPrompt({
+                    conversationId: conversation.id,
+                    clientMessageId: id(command.name),
+                    contentBlocks: [{ type: "text", text: args || "Review the current local changes." }],
+                    model: conversation.model,
+                    reasoningEffort: conversation.reasoningEffort,
+                    permissionMode: conversation.permissionMode,
+                    collaborationMode: conversation.collaborationMode,
+                });
+                return;
+            }
+            if (command.name === "subagents") {
                 await this.sendPrompt({
                     conversationId: conversation.id,
                     clientMessageId: id(command.name),
-                    contentBlocks: [{ type: "text", text: prompt }],
+                    contentBlocks: [{ type: "text", text: args || "Run subagents for distinct tasks in parallel when useful, then synthesize the results." }],
                     model: conversation.model,
                     reasoningEffort: conversation.reasoningEffort,
                     permissionMode: conversation.permissionMode,
@@ -3046,8 +3533,73 @@ export class AgentWorkspaceProxy {
         }
         return {};
     }
-    // Merge MCP server descriptors into a provider's runtime capabilities,
-    // last-writer-wins by server name. Creates the map lazily.
+    async startMcpLogin(payload) {
+        const provider = payload.provider
+            ?? this.input.availableProviders.find((item) => this.clients.has(item))
+            ?? this.input.availableProviders[0];
+        const sendResult = (input) => {
+            this.input.send(createEnvelope({
+                type: "agent.v2.mcp.login.result",
+                sessionId: this.input.sessionId,
+                payload: {
+                    ...(provider ? { provider } : {}),
+                    serverName: payload.serverName,
+                    authorizationUrl: input.authorizationUrl,
+                    error: input.error,
+                },
+            }));
+        };
+        if (!provider) {
+            sendResult({ error: "没有可用的 Agent 提供方。" });
+            return;
+        }
+        const client = this.clientForProvider(provider);
+        const startMcpOAuth = client?.startMcpOAuth;
+        if (typeof startMcpOAuth !== "function") {
+            sendResult({ error: "请在主机上的 Claude / Codex 完成该 MCP 的授权。" });
+            return;
+        }
+        try {
+            const result = await startMcpOAuth.call(client, { serverName: payload.serverName });
+            const raw = asRecord(result);
+            const authorizationUrl = firstString(raw, [
+                "authorizationUrl",
+                "authorization_url",
+                "url",
+                "loginUrl",
+            ]);
+            if (!authorizationUrl) {
+                sendResult({ error: "主机没有返回授权地址。" });
+                return;
+            }
+            this.mergeMcpServers(provider, [{
+                    name: payload.serverName,
+                    status: "needs_auth",
+                }]);
+            this.sendCapabilities();
+            sendResult({ authorizationUrl });
+        }
+        catch (error) {
+            sendResult({ error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    handleMcpOAuthCompleted(params) {
+        const raw = asRecord(params) ?? {};
+        const name = firstString(raw, ["name", "server", "serverName"]);
+        if (!name)
+            return;
+        const success = raw.success !== false && !raw.error;
+        const provider = this.input.availableProviders.find((item) => this.clients.has(item))
+            ?? this.input.availableProviders[0];
+        if (!provider)
+            return;
+        this.mergeMcpServers(provider, [{
+                name,
+                status: success ? "connected" : "needs_auth",
+                error: success ? undefined : firstString(raw, ["error", "message"]),
+            }]);
+        this.sendCapabilities();
+    }
     mergeMcpServers(provider, servers) {
         if (servers.length === 0)
             return;
@@ -3075,7 +3627,7 @@ export class AgentWorkspaceProxy {
             return;
         this.mergeMcpServers(provider, [{
                 name,
-                status: normalizeMcpStatus(raw.status ?? raw.state),
+                status: mcpStatusFromRecord(raw),
                 error: firstString(raw, ["error", "message", "reason"]),
                 toolCount: firstNumber(raw, ["toolCount", "tools", "toolsCount"]) ?? (Array.isArray(raw.tools) ? raw.tools.length : undefined),
             }]);
@@ -3125,9 +3677,11 @@ export class AgentWorkspaceProxy {
             this.handleMcpStartupStatus(method, params);
             return;
         }
-        if (method.startsWith("account/") ||
-            method === "serverRequest/resolved" ||
-            method === "mcpServer/oauthLogin/completed") {
+        if (method === "mcpServer/oauthLogin/completed") {
+            this.handleMcpOAuthCompleted(params);
+            return;
+        }
+        if (method.startsWith("account/") || method === "serverRequest/resolved") {
             return;
         }
         const conversationId = this.conversationIdFromParams(params) ?? this.fallbackConversationId();
@@ -3160,6 +3714,46 @@ export class AgentWorkspaceProxy {
             }
             return;
         }
+        if (method === "thread/name/updated") {
+            if (conversationId) {
+                const raw = asRecord(params);
+                const title = firstString(raw, ["name", "title"]) ?? firstString(asRecord(raw?.thread), ["name", "title"]);
+                const conversation = this.conversations.get(conversationId);
+                if (conversation && title !== undefined) {
+                    conversation.title = title;
+                    conversation.lastActivityAt = Date.now();
+                    this.emitConversation(conversation);
+                }
+            }
+            return;
+        }
+        if (method === "thread/settings/updated") {
+            if (conversationId) {
+                const conversation = this.conversations.get(conversationId);
+                if (conversation) {
+                    applyThreadSettingsToConversation(conversation, params);
+                    conversation.lastActivityAt = Date.now();
+                    this.emitConversation(conversation);
+                }
+            }
+            return;
+        }
+        if (method === "thread/archived" || method === "thread/unarchived") {
+            if (conversationId) {
+                const conversation = this.conversations.get(conversationId);
+                if (conversation) {
+                    conversation.archived = method === "thread/archived";
+                    conversation.lastActivityAt = Date.now();
+                    this.emitConversation(conversation);
+                }
+            }
+            return;
+        }
+        if (method === "thread/deleted") {
+            if (conversationId)
+                this.forgetConversationLocally(conversationId);
+            return;
+        }
         if (method === "item/tool/requestUserInput" || method === "tool/requestUserInput") {
             this.handleStructuredInput(params);
             return;
@@ -3220,6 +3814,13 @@ export class AgentWorkspaceProxy {
             case "item/agentMessage/delta":
                 this.handleAgentMessageDelta(params);
                 return;
+            case "item/reasoning/summaryTextDelta":
+            case "item/reasoning/textDelta":
+                this.handleReasoningDelta(params);
+                return;
+            case "item/reasoning/summaryPartAdded":
+                this.handleReasoningDelta(params, { partBoundary: true });
+                return;
             case "turn/plan/updated":
                 this.handlePlanUpdated(params);
                 return;
@@ -3284,9 +3885,65 @@ export class AgentWorkspaceProxy {
             updatedAt: Date.now(),
             isStreaming: true,
         };
-        this.upsertItem(conversationId, item);
+        this.applyStreamingTextDelta(conversationId, item, existing, delta);
         this.updateConversationPreview(conversationId, text, "running");
     }
+    handleReasoningDelta(params, options) {
+        const raw = asRecord(params);
+        if (!raw)
+            return;
+        const conversationId = this.conversationIdFromParams(raw) ?? this.fallbackConversationId();
+        if (!conversationId)
+            return;
+        const itemId = firstString(raw, ["itemId", "id", "messageId"]) ?? id("thinking");
+        const existing = this.findItem(conversationId, itemId);
+        const delta = firstString(raw, ["delta", "text", "content", "summary"])
+            ?? (options?.partBoundary ? "\n" : undefined);
+        if (!delta)
+            return;
+        const text = `${existing?.text ?? ""}${delta}`;
+        const item = {
+            id: itemId,
+            conversationId,
+            type: "status",
+            kind: "thinking",
+            role: "system",
+            turnId: this.extractTurnId(raw) ?? this.currentTurnIds.get(conversationId),
+            itemId,
+            content: [{ type: "text", text }],
+            text,
+            createdAt: existing?.createdAt ?? Date.now(),
+            updatedAt: Date.now(),
+            isStreaming: true,
+        };
+        this.applyStreamingTextDelta(conversationId, item, existing, delta);
+    }
+    applyStreamingTextDelta(conversationId, item, existing, delta) {
+        if (!existing) {
+            this.upsertItem(conversationId, item);
+            return;
+        }
+        this.rememberItemConversationId(conversationId, item);
+        const timeline = this.timelines.get(conversationId) ?? [];
+        const index = timeline.findIndex((entry) => entry.id === item.id);
+        if (index >= 0)
+            timeline[index] = item;
+        else
+            timeline.push(item);
+        this.timelines.set(conversationId, timeline);
+        this.input.send(createEnvelope({
+            type: "agent.v2.event",
+            sessionId: this.input.sessionId,
+            payload: {
+                conversationId,
+                patch: {
+                    itemId: item.id,
+                    textDelta: delta,
+                    updatedAt: item.updatedAt,
+                },
+            },
+        }));
+    }
     handlePlanUpdated(params) {
         const raw = asRecord(params);
         const conversationId = this.conversationIdFromParams(raw) ?? this.fallbackConversationId();
@@ -3752,19 +4409,14 @@ export class AgentWorkspaceProxy {
         const requestId = firstString(raw, ["requestId", "id", "permissionId"]) ?? id("perm");
         const rawToolCall = asRecord(raw.toolCall) ?? raw;
         // Codex app-server command/file approvals carry `command`/`reason`/`cwd`
-        // (not toolCall/context). Surface them so the card actually shows what's
-        // being approved; fall back to the Claude/MCP shape otherwise.
-        const codexCommand = firstString(raw, ["command"]);
-        const codexCwd = firstString(raw, ["cwd"]);
+        // (not toolCall/context). Keep those fields as JSON so the web card can
+        // render `$ command` / a path instead of a raw dump.
         const permission = {
             requestId,
-            toolName: firstString(rawToolCall, ["toolName", "tool", "name", "title", "kind"]) ??
-                (codexCommand ? "shell" : undefined),
-            toolInput: codexCommand
-                ? (codexCwd ? `$ ${codexCommand}\n# cwd: ${codexCwd}` : `$ ${codexCommand}`)
-                : stringify(rawToolCall.input ?? rawToolCall.toolInput ?? rawToolCall),
+            toolName: permissionToolName(raw, rawToolCall),
+            toolInput: permissionToolInput(raw, rawToolCall),
             context: firstString(raw, ["context", "description", "message", "title", "reason"]),
-            options: parsePermissionOptions(raw.options),
+            options: permissionOptionsFromRequest(raw, source),
         };
         this.pendingPermissions.set(requestId, permission);
         if (source)
@@ -4038,6 +4690,22 @@ export class AgentWorkspaceProxy {
             payload: { conversationId, conversation: conversation ? { ...conversation } : undefined, item },
         }));
     }
+    forgetConversationLocally(conversationId) {
+        const conversation = this.conversations.get(conversationId);
+        if (conversation?.agentSessionId) {
+            this.deletedAgentSessionIds.add(conversation.agentSessionId);
+            this.conversationByAgentSessionId.delete(conversation.agentSessionId);
+        }
+        this.conversations.delete(conversationId);
+        this.timelines.delete(conversationId);
+        this.historyCursors.delete(conversationId);
+        this.lastHydrateAt.delete(conversationId);
+        this.input.send(createEnvelope({
+            type: "agent.v2.conversation.deleted",
+            sessionId: this.input.sessionId,
+            payload: { conversationId },
+        }));
+    }
     emitConversation(conversation) {
         this.input.send(createEnvelope({
             type: "agent.v2.event",
@@ -4381,6 +5049,77 @@ export class AgentWorkspaceProxy {
         }, 0);
     }
 }
+function permissionToolName(raw, rawToolCall) {
+    const named = firstString(rawToolCall, ["toolName", "tool", "name", "title", "kind"]);
+    if (named)
+        return named;
+    if (firstString(raw, ["command"]))
+        return "shell";
+    if (permissionFilePath(raw))
+        return "Edit";
+    return undefined;
+}
+function permissionFilePath(raw) {
+    const direct = firstString(raw, ["path", "filePath", "file_path"]);
+    if (direct)
+        return direct;
+    const changes = Array.isArray(raw.changes) ? raw.changes : undefined;
+    const first = changes ? asRecord(changes[0]) : undefined;
+    return firstString(first, ["path", "filePath", "file_path"]);
+}
+function permissionToolInput(raw, rawToolCall) {
+    const command = firstString(raw, ["command"]);
+    const cwd = firstString(raw, ["cwd"]);
+    const path = permissionFilePath(raw);
+    if (command || path) {
+        return JSON.stringify({
+            ...(command ? { command } : {}),
+            ...(cwd ? { cwd } : {}),
+            ...(path ? { path } : {}),
+        });
+    }
+    return stringify(rawToolCall.input ?? rawToolCall.toolInput ?? rawToolCall);
+}
+function officialDecisionKey(value) {
+    if (typeof value === "string" && value.trim())
+        return value.trim();
+    const raw = asRecord(value);
+    return firstString(raw, ["decision", "id", "kind", "type", "optionId"]);
+}
+function officialDecisionOption(key) {
+    const normalized = key.replace(/[\s_-]/g, "").toLowerCase();
+    if (normalized === "accept" || normalized === "allow" || normalized === "allowonce") {
+        return { id: key === "accept" ? "accept" : key, label: "允许一次", kind: "allow" };
+    }
+    if (normalized === "acceptforsession" ||
+        normalized === "allowsession" ||
+        normalized === "allowforsession" ||
+        normalized === "session") {
+        return { id: "acceptForSession", label: "本会话允许", kind: "allow" };
+    }
+    if (normalized === "decline" || normalized === "deny" || normalized === "reject") {
+        return { id: normalized === "decline" ? "decline" : key, label: "拒绝", kind: "deny" };
+    }
+    if (normalized === "cancel") {
+        return { id: "cancel", label: "取消", kind: "deny" };
+    }
+    return undefined;
+}
+function parseOfficialDecisions(value) {
+    const options = [];
+    const seen = new Set();
+    for (const entry of value) {
+        const key = officialDecisionKey(entry);
+        if (!key)
+            continue;
+        const mapped = officialDecisionOption(key);
+        if (!mapped || seen.has(mapped.id))
+            continue;
+        seen.add(mapped.id);
+        options.push(mapped);
+    }
+    return options;
+}
 function parsePermissionOptions(value) {
     if (!Array.isArray(value)) {
         return [
@@ -4388,17 +5127,24 @@ function parsePermissionOptions(value) {
             { id: "deny", label: "拒绝", kind: "deny" },
         ];
     }
+    const official = parseOfficialDecisions(value);
+    if (official.length > 0 && value.every((entry) => officialDecisionOption(officialDecisionKey(entry) ?? ""))) {
+        return official;
+    }
     const options = value
         .map((entry, index) => {
         const raw = asRecord(entry) ?? {};
-        const idValue = raw.optionId ?? raw.id ?? raw.kind ?? `option-${index + 1}`;
-        const labelValue = raw.name ?? raw.label ?? raw.kind ?? String(idValue);
+        const idValue = raw.optionId ?? raw.id ?? raw.kind ?? raw.decision ?? `option-${index + 1}`;
+        const labelValue = raw.name ?? raw.label ?? raw.kind ?? raw.decision ?? String(idValue);
         const id = String(idValue);
         const label = String(labelValue);
+        const official = officialDecisionOption(id);
+        if (official)
+            return { ...official, id, label: official.label === "允许一次" && label !== id ? label : official.label };
         const normalized = `${id} ${label}`.toLowerCase();
-        const kind = normalized.includes("reject") || normalized.includes("deny")
+        const kind = /reject|deny|decline|cancel/.test(normalized)
             ? "deny"
-            : normalized.includes("allow")
+            : /allow|accept/.test(normalized)
                 ? "allow"
                 : "other";
         return { id, label, kind };
@@ -4411,6 +5157,35 @@ function parsePermissionOptions(value) {
             { id: "deny", label: "拒绝", kind: "deny" },
         ];
 }
+function permissionOptionsFromRequest(raw, source) {
+    const decisions = raw.availableDecisions;
+    if (Array.isArray(decisions) && decisions.length > 0) {
+        const official = parseOfficialDecisions(decisions);
+        if (official.length > 0)
+            return official;
+    }
+    if (Array.isArray(raw.options)) {
+        return parsePermissionOptions(raw.options);
+    }
+    if (source === "item/commandExecution/requestApproval" || source === "item/fileChange/requestApproval") {
+        return [
+            { id: "accept", label: "允许一次", kind: "allow" },
+            { id: "acceptForSession", label: "本会话允许", kind: "allow" },
+            { id: "decline", label: "拒绝", kind: "deny" },
+        ];
+    }
+    if (source === "item/permissions/requestApproval") {
+        return [
+            { id: "turn", label: "本次允许", kind: "allow" },
+            { id: "session", label: "本会话允许", kind: "allow" },
+            { id: "deny", label: "拒绝", kind: "deny" },
+        ];
+    }
+    return [
+        { id: "allow", label: "允许", kind: "allow" },
+        { id: "deny", label: "拒绝", kind: "deny" },
+    ];
+}
 function selectPermissionOption(permission, outcome) {
     if (outcome === "cancelled")
         return "cancelled";
@@ -4481,7 +5256,13 @@ function formatStructuredInputResponseForSource(source, answers, input) {
 }
 function formatPermissionResponse(source, outcome, optionId) {
     if (source === "item/commandExecution/requestApproval" || source === "item/fileChange/requestApproval") {
-        return { decision: outcome === "allow" ? "accept" : outcome === "deny" ? "decline" : "cancel" };
+        if (outcome === "cancelled" || optionId === "cancel")
+            return { decision: "cancel" };
+        if (outcome === "deny")
+            return { decision: "decline" };
+        if (optionId === "acceptForSession")
+            return { decision: "acceptForSession" };
+        return { decision: "accept" };
     }
     if (source === "item/permissions/requestApproval") {
         if (outcome === "allow") {