linkshell-cli 0.5.1 → 0.5.4

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

@@ -11,6 +11,12 @@ const MAX_TIMELINE_ITEMS = 200;
 function id(prefix) {
     return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
+function normalizeAgentSessionIdSegment(value) {
+    return value.replace(/[^a-zA-Z0-9_-]+/g, "-");
+}
+export function makeAgentV2RemoteConversationId(provider, agentSessionId) {
+    return `agent-remote-${provider}-${normalizeAgentSessionIdSegment(agentSessionId)}`;
+}
 function stringify(value) {
     if (typeof value === "string")
         return value;
@@ -66,6 +72,12 @@ function extractItem(value) {
         return undefined;
     return asRecord(raw.item) ?? raw;
 }
+function extractTurn(value) {
+    const raw = asRecord(value);
+    if (!raw)
+        return undefined;
+    return asRecord(raw.turn) ?? raw;
+}
 function stringifyDefined(value) {
     if (value === undefined || value === null || value === "")
         return undefined;
@@ -107,6 +119,29 @@ function normalizePlanStatus(value) {
         return "in_progress";
     return "pending";
 }
+function agentStatusFromThreadStatus(value) {
+    const raw = asRecord(value);
+    const status = typeof value === "string"
+        ? value
+        : firstString(raw, ["status", "state", "phase", "type"]) ??
+            firstString(asRecord(raw?.status), ["status", "state", "phase", "type"]);
+    const normalized = normalizedIdentifier(status);
+    if (!normalized)
+        return undefined;
+    if (["active", "running", "inprogress", "busy", "working", "streaming"].includes(normalized)) {
+        return "running";
+    }
+    if (["idle", "ready", "completed", "complete", "done", "finished"].includes(normalized)) {
+        return "idle";
+    }
+    if (["waitingpermission", "waitingforpermission", "requirespermission", "needspermission"].includes(normalized)) {
+        return "waiting_permission";
+    }
+    if (["error", "failed", "systemerror", "fatal"].includes(normalized)) {
+        return "error";
+    }
+    return undefined;
+}
 function nameFromToolMethod(method) {
     if (method.includes("commandExecution"))
         return "命令";
@@ -473,7 +508,9 @@ function parseStructuredInputQuestion(value, index) {
         question,
         isOther: raw.isOther === true,
         isSecret: raw.isSecret === true || raw.secret === true,
-        selectionLimit: firstNumber(raw, ["selectionLimit", "maxSelections"]),
+        selectionLimit: raw.multiSelect === true
+            ? options.length || undefined
+            : firstNumber(raw, ["selectionLimit", "maxSelections"]),
         options: options.length > 0 ? options : undefined,
     };
 }
@@ -1004,10 +1041,11 @@ function parseTimestamp(value) {
 function parseRemoteSessions(value) {
     const raw = asRecord(value);
     const sessionsValue = Array.isArray(value) ? value :
-        Array.isArray(raw?.threads) ? raw.threads :
-            Array.isArray(raw?.sessions) ? raw.sessions :
-                Array.isArray(raw?.items) ? raw.items :
-                    [];
+        Array.isArray(raw?.data) ? raw.data :
+            Array.isArray(raw?.threads) ? raw.threads :
+                Array.isArray(raw?.sessions) ? raw.sessions :
+                    Array.isArray(raw?.items) ? raw.items :
+                        [];
     const result = [];
     for (const entry of sessionsValue) {
         const session = asRecord(entry);
@@ -1024,7 +1062,7 @@ function parseRemoteSessions(value) {
         result.push({
             id,
             cwd: firstString(source, ["cwd", "workingDirectory", "workspacePath"]),
-            title: firstString(source, ["title", "name", "summary"]),
+            title: firstString(source, ["title", "name", "summary", "preview"]),
             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),
@@ -1032,11 +1070,265 @@ function parseRemoteSessions(value) {
     }
     return result;
 }
+function threadFromProviderResult(value) {
+    const raw = asRecord(value);
+    return asRecord(raw?.thread) ?? raw;
+}
+function threadFromTurnsListResult(sessionId, value) {
+    const raw = asRecord(value);
+    const order = firstString(raw, ["sortDirection", "order", "sortOrder", "sort"]);
+    const turns = Array.isArray(raw?.turns) ? raw.turns :
+        Array.isArray(raw?.data) ? raw.data :
+            Array.isArray(raw?.items) ? raw.items :
+                Array.isArray(value) ? value :
+                    undefined;
+    if (!turns)
+        return undefined;
+    const extracted = turns
+        .map(extractTurn)
+        .filter((turn) => Boolean(turn));
+    const chronological = order && /asc/i.test(order)
+        ? extracted
+        : [...extracted].reverse();
+    return { id: sessionId, turns: chronological };
+}
+function turnItemsFromThread(thread) {
+    if (!thread)
+        return [];
+    const turnsValue = Array.isArray(thread.turns)
+        ? thread.turns
+        : Array.isArray(thread.items)
+            ? [{ id: firstString(thread, ["turnId", "id"]), items: thread.items }]
+            : [];
+    const result = [];
+    for (const turnEntry of turnsValue) {
+        const turn = extractTurn(turnEntry);
+        if (!turn)
+            continue;
+        const turnId = firstString(turn, ["id", "turnId"]);
+        const createdAt = parseTimestamp(turn.createdAt ??
+            turn.created_at ??
+            turn.startedAt ??
+            turn.started_at ??
+            turn.completedAt ??
+            turn.completed_at ??
+            turn.updatedAt ??
+            turn.updated_at);
+        const itemsRecord = asRecord(turn.items);
+        const items = Array.isArray(turn.items)
+            ? turn.items
+            : Array.isArray(itemsRecord?.data)
+                ? itemsRecord.data
+                : Array.isArray(itemsRecord?.items)
+                    ? itemsRecord.items
+                    : Array.isArray(turn.item)
+                        ? turn.item
+                        : Array.isArray(turn.events)
+                            ? turn.events
+                            : [];
+        for (const itemEntry of items) {
+            const item = extractItem(itemEntry);
+            if (!item)
+                continue;
+            result.push({
+                ...item,
+                ...(turnId && !firstString(item, ["turnId"]) ? { turnId } : {}),
+                __turnCreatedAt: createdAt,
+            });
+        }
+    }
+    return result;
+}
+function activeTurnIdFromThread(thread) {
+    if (!thread)
+        return undefined;
+    const turnsValue = Array.isArray(thread.turns)
+        ? thread.turns
+        : Array.isArray(thread.items)
+            ? [{ id: firstString(thread, ["turnId", "id"]), items: thread.items, status: thread.status }]
+            : [];
+    let activeTurnId;
+    for (const turnEntry of turnsValue) {
+        const turn = extractTurn(turnEntry);
+        if (!turn)
+            continue;
+        const turnId = firstString(turn, ["id", "turnId"]);
+        if (!turnId)
+            continue;
+        const status = firstString(turn, ["status", "state", "phase"]) ??
+            firstString(asRecord(turn.status), ["status", "state", "phase", "type"]);
+        const normalized = normalizedIdentifier(status);
+        if ([
+            "active",
+            "running",
+            "inprogress",
+            "busy",
+            "working",
+            "streaming",
+            "waitingpermission",
+            "waitingforpermission",
+            "requirespermission",
+            "needspermission",
+        ].includes(normalized)) {
+            activeTurnId = turnId;
+        }
+    }
+    return activeTurnId;
+}
+function timelineItemFromProviderItem(item, conversationId, index) {
+    const itemType = firstString(item, ["type"]);
+    const normalized = normalizedIdentifier(itemType);
+    const itemId = firstString(item, ["id", "itemId", "messageId", "toolCallId"]) ?? `history-${index + 1}`;
+    const createdAt = parseTimestamp(item.createdAt ?? item.created_at ?? item.timestamp ?? item.__turnCreatedAt) ??
+        Date.now() + index;
+    const base = {
+        id: itemId,
+        conversationId,
+        turnId: firstString(item, ["turnId"]),
+        itemId,
+        createdAt,
+        updatedAt: parseTimestamp(item.updatedAt ?? item.updated_at) ?? createdAt,
+        isStreaming: false,
+    };
+    if (normalized === "usermessage" ||
+        normalized === "userinput" ||
+        (normalized === "message" && item.role === "user")) {
+        const content = contentBlocksFromItem(item);
+        const text = textFromBlocks(content);
+        if (!content.length && !text)
+            return undefined;
+        return {
+            ...base,
+            type: "message",
+            kind: "chat",
+            role: "user",
+            content,
+            text,
+        };
+    }
+    if (normalized === "agentmessage" ||
+        normalized === "assistantmessage" ||
+        (normalized === "message" && item.role !== "user")) {
+        const content = contentBlocksFromItem(item);
+        const text = textFromBlocks(content);
+        if (!content.length && !text)
+            return undefined;
+        return {
+            ...base,
+            type: "message",
+            kind: "chat",
+            role: item.role === "system" ? "system" : "assistant",
+            content,
+            text,
+        };
+    }
+    if (normalized === "reasoning" || normalized === "thinking") {
+        const text = firstString(item, ["text", "content", "summary", "message"]) ??
+            stringifyDefined(item.contentItems ?? item.summary);
+        if (!text)
+            return undefined;
+        return {
+            ...base,
+            type: "status",
+            kind: "thinking",
+            role: "system",
+            text,
+        };
+    }
+    if (normalized === "enteredreviewmode" || normalized === "exitedreviewmode") {
+        const text = firstString(item, ["review", "text", "content", "summary", "message"]);
+        return {
+            ...base,
+            type: "status",
+            kind: "review",
+            role: "system",
+            text: text ?? (normalized === "enteredreviewmode" ? "正在审查" : "审查已完成"),
+        };
+    }
+    if (normalized === "contextcompaction") {
+        return {
+            ...base,
+            type: "status",
+            kind: "context_compaction",
+            role: "system",
+            text: firstString(item, ["text", "summary", "message"]) ?? "上下文已压缩",
+        };
+    }
+    if (isSubagentItemType(itemType)) {
+        const subagent = decodeSubagentAction(item, normalizeToolStatus(item.status, true));
+        if (!subagent)
+            return undefined;
+        return {
+            ...base,
+            type: "status",
+            kind: "subagent_action",
+            role: "system",
+            text: summarizeSubagentAction(subagent),
+            subagent,
+        };
+    }
+    if (isToolItemType(itemType) || toolNameFromItem(item)) {
+        const toolId = firstString(item, ["id", "itemId", "toolCallId"]) ?? itemId;
+        const toolCall = {
+            id: toolId,
+            name: toolNameFromItem(item) ?? "工具",
+            input: toolInputFromItem(item),
+            output: normalized === "filechange" || normalized === "diff"
+                ? extractDiffText(item) ?? firstString(item, ["output", "summary"])
+                : firstString(item, ["aggregatedOutput", "output", "stdout", "stderr"]) ??
+                    stringifyDefined(item.result ?? item.error ?? item.contentItems),
+            createdAt,
+            status: normalizeToolStatus(item.status, true),
+        };
+        const kind = toolCall.name.includes("文件") || normalized === "filechange" || normalized === "diff"
+            ? "file_change"
+            : toolCall.name.includes("命令") || normalized === "commandexecution"
+                ? "command_execution"
+                : "tool_activity";
+        return {
+            ...base,
+            id: `tool:${toolId}`,
+            type: "tool_call",
+            kind,
+            itemId: toolId,
+            toolCall,
+            commandExecution: kind === "command_execution" ? commandExecutionFromTool(toolCall) : undefined,
+            fileChange: kind === "file_change" ? fileChangeFromTool(toolCall) : undefined,
+        };
+    }
+    return undefined;
+}
+function timelineItemsFromProviderThread(value, conversationId) {
+    const items = turnItemsFromThread(threadFromProviderResult(value))
+        .map((item, index) => timelineItemFromProviderItem(item, conversationId, index))
+        .filter((item) => Boolean(item));
+    const byId = new Map();
+    for (const item of items) {
+        byId.set(item.id, item);
+    }
+    return [...byId.values()].sort((a, b) => a.createdAt - b.createdAt).slice(-MAX_TIMELINE_ITEMS);
+}
+function previewFromTimelineItem(item) {
+    if (item.error)
+        return item.error;
+    if (item.text)
+        return item.text;
+    if (item.content?.length)
+        return textFromBlocks(item.content);
+    if (item.toolCall)
+        return `${item.toolCall.name} · ${item.toolCall.status}`;
+    if (item.permission)
+        return `需要授权 ${item.permission.toolName ?? ""}`.trim();
+    if (item.subagent)
+        return summarizeSubagentAction(item.subagent);
+    return undefined;
+}
 export class AgentWorkspaceProxy {
     input;
     clients = new Map();
     agentProtocols = new Map();
     providerCapabilities = new Map();
+    providerErrors = new Map();
     initialized = false;
     status = "unavailable";
     error;
@@ -1046,6 +1338,9 @@ export class AgentWorkspaceProxy {
     conversations = new Map();
     conversationByAgentSessionId = new Map();
     timelines = new Map();
+    // Opaque codex turns cursor per conversation, pointing at OLDER history to
+    // page through (captured at hydration, advanced on each history.request).
+    historyCursors = new Map();
     toolOutputBuffers = new Map();
     pendingPermissions = new Map();
     permissionWaiters = new Map();
@@ -1085,6 +1380,11 @@ export class AgentWorkspaceProxy {
                 this.sendSnapshot(payload.conversationId);
                 break;
             }
+            case "agent.v2.history.request": {
+                const payload = parseTypedPayload("agent.v2.history.request", envelope.payload);
+                await this.loadOlderHistory(payload);
+                break;
+            }
             case "agent.v2.prompt": {
                 const payload = parseTypedPayload("agent.v2.prompt", envelope.payload);
                 await this.sendPrompt(payload);
@@ -1098,11 +1398,18 @@ export class AgentWorkspaceProxy {
             case "agent.v2.cancel": {
                 const payload = parseTypedPayload("agent.v2.cancel", envelope.payload);
                 const conversation = this.conversations.get(payload.conversationId);
+                if (!conversation)
+                    break;
+                const turnId = this.currentTurnIds.get(payload.conversationId);
+                if (this.protocolForProvider(conversation.provider) === "codex-app-server" && !turnId) {
+                    this.rejectAgentAction(conversation, "无法停止 Codex：当前运行 turn 尚未同步，请重新打开对话后再试。", conversation.status);
+                    break;
+                }
                 this.cancelPendingPermissions(payload.conversationId);
-                const cancelClient = conversation ? this.clientForProvider(conversation.provider) : undefined;
+                const cancelClient = this.clientForProvider(conversation.provider);
                 cancelClient?.cancel({
-                    sessionId: conversation?.agentSessionId,
-                    turnId: this.currentTurnIds.get(payload.conversationId),
+                    sessionId: conversation.agentSessionId,
+                    turnId,
                 });
                 this.forgetCurrentTurn(payload.conversationId);
                 this.updateConversationStatus(payload.conversationId, "idle");
@@ -1130,9 +1437,38 @@ export class AgentWorkspaceProxy {
     clientForProvider(provider) {
         return this.clients.get(provider);
     }
+    shouldRecycleProviderClient(provider, error) {
+        if (provider !== "codex")
+            return false;
+        const message = error instanceof Error ? error.message : String(error);
+        return /ACP agent is not running|ACP request timed out|Transport channel closed|TokenRefreshFailed|Failed to parse server response|channel closed|EPIPE|ECONNRESET/i.test(message);
+    }
+    async recycleProviderClient(provider, error) {
+        if (!this.shouldRecycleProviderClient(provider, error))
+            return undefined;
+        const message = error instanceof Error ? error.message : String(error);
+        const existing = this.clients.get(provider);
+        if (existing) {
+            try {
+                existing.stop();
+            }
+            catch { }
+        }
+        this.clients.delete(provider);
+        this.agentProtocols.delete(provider);
+        this.providerErrors.set(provider, message);
+        return this.ensureProviderClient(provider);
+    }
     protocolForProvider(provider) {
         return this.agentProtocols.get(provider);
     }
+    defaultModelForProvider(provider) {
+        const capabilities = this.providerCapabilities.get(provider);
+        const defaultModel = capabilities?.defaultModel?.trim();
+        if (defaultModel)
+            return defaultModel;
+        return capabilities?.models?.find((model) => model.id && model.id !== "default")?.id;
+    }
     async initialize() {
         if (this.initialized)
             return;
@@ -1197,6 +1533,7 @@ export class AgentWorkspaceProxy {
         try {
             const client = await tryCreateClient(resolved);
             this.clients.set(provider, client);
+            this.providerErrors.delete(provider);
             await this.refreshProviderCapabilities(provider, client, resolved.protocol);
             this.status = "idle";
             this.error = undefined;
@@ -1217,6 +1554,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.status = "idle";
                     this.error = undefined;
@@ -1232,6 +1570,8 @@ export class AgentWorkspaceProxy {
             if (this.input.verbose) {
                 process.stderr.write(`[agent:v2] failed to start ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
             }
+            this.providerErrors.set(provider, error instanceof Error ? error.message : String(error));
+            this.sendCapabilities();
             return undefined;
         }
     }
@@ -1276,12 +1616,23 @@ export class AgentWorkspaceProxy {
         await this.initialize();
         for (const [provider, client] of this.clients) {
             try {
-                const result = await client.listSessions();
+                let activeClient = client;
+                let result;
+                try {
+                    result = await activeClient.listSessions();
+                }
+                catch (error) {
+                    const recovered = await this.recycleProviderClient(provider, error);
+                    if (!recovered)
+                        throw error;
+                    activeClient = recovered;
+                    result = await activeClient.listSessions();
+                }
                 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 conversationId = existingId ?? makeAgentV2RemoteConversationId(provider, agentSessionId);
                     const existing = this.conversations.get(conversationId);
                     const cwd = remote.cwd ?? existing?.cwd ?? this.input.cwd;
                     const conversation = {
@@ -1312,6 +1663,103 @@ export class AgentWorkspaceProxy {
             }
         }
     }
+    async hydrateConversationFromProvider(conversation, seedResult) {
+        let client = this.clientForProvider(conversation.provider);
+        if (!client || !conversation.agentSessionId)
+            return;
+        let source = seedResult;
+        const hasSeedTurns = turnItemsFromThread(threadFromProviderResult(seedResult)).length > 0;
+        if (!hasSeedTurns) {
+            const readSession = client.readSession;
+            if (typeof readSession === "function") {
+                try {
+                    source = await readSession.call(client, {
+                        sessionId: conversation.agentSessionId,
+                        includeTurns: true,
+                    });
+                }
+                catch (error) {
+                    const recovered = await this.recycleProviderClient(conversation.provider, error);
+                    if (recovered)
+                        client = recovered;
+                    if (this.input.verbose) {
+                        process.stderr.write(`[agent:v2] thread/read hydration failed for ${conversation.provider}: ${error instanceof Error ? error.message : String(error)}\n`);
+                    }
+                }
+            }
+            if (turnItemsFromThread(threadFromProviderResult(source)).length === 0) {
+                const listTurns = client.listTurns;
+                if (typeof listTurns === "function") {
+                    try {
+                        let turnsResult;
+                        try {
+                            turnsResult = await listTurns.call(client, {
+                                sessionId: conversation.agentSessionId,
+                                limit: MAX_TIMELINE_ITEMS,
+                                sortDirection: "desc",
+                                itemsView: "full",
+                            });
+                        }
+                        catch (error) {
+                            const recovered = await this.recycleProviderClient(conversation.provider, error);
+                            if (!recovered)
+                                throw error;
+                            client = recovered;
+                            const recoveredListTurns = client.listTurns;
+                            if (typeof recoveredListTurns !== "function")
+                                throw error;
+                            turnsResult = await recoveredListTurns.call(client, {
+                                sessionId: conversation.agentSessionId,
+                                limit: MAX_TIMELINE_ITEMS,
+                                sortDirection: "desc",
+                                itemsView: "full",
+                            });
+                        }
+                        const turnsThread = threadFromTurnsListResult(conversation.agentSessionId, turnsResult);
+                        if (turnsThread)
+                            source = { thread: turnsThread };
+                        // Capture the opaque cursor pointing at OLDER turns so the client
+                        // can page further back via agent.v2.history.request.
+                        const olderCursor = firstString(asRecord(turnsResult), ["nextCursor", "next_cursor", "cursor"]);
+                        this.historyCursors.set(conversation.id, olderCursor);
+                    }
+                    catch (error) {
+                        if (this.input.verbose) {
+                            process.stderr.write(`[agent:v2] thread/turns/list hydration failed for ${conversation.provider}: ${error instanceof Error ? error.message : String(error)}\n`);
+                        }
+                    }
+                }
+            }
+        }
+        const thread = threadFromProviderResult(source);
+        const activeTurnId = activeTurnIdFromThread(thread);
+        if (activeTurnId)
+            this.rememberTurnConversationId(conversation.id, activeTurnId);
+        const model = firstString(thread, ["model", "modelId", "currentModel"]);
+        if (model && !conversation.model)
+            conversation.model = model;
+        const hydratedItems = timelineItemsFromProviderThread(source, conversation.id);
+        if (hydratedItems.length === 0)
+            return;
+        const existing = this.timelines.get(conversation.id) ?? [];
+        const merged = new Map();
+        for (const item of [...existing, ...hydratedItems]) {
+            merged.set(item.id, item);
+        }
+        const nextItems = [...merged.values()]
+            .sort((a, b) => a.createdAt - b.createdAt)
+            .slice(-MAX_TIMELINE_ITEMS);
+        this.timelines.set(conversation.id, nextItems);
+        for (const item of nextItems) {
+            this.rememberItemConversationId(conversation.id, item);
+        }
+        const lastPreview = [...nextItems].reverse()
+            .map((item) => previewText(previewFromTimelineItem(item) ?? ""))
+            .find(Boolean);
+        if (lastPreview && !conversation.lastMessagePreview) {
+            conversation.lastMessagePreview = lastPreview;
+        }
+    }
     sendCapabilities() {
         const providers = this.input.availableProviders.map((provider) => {
             const client = this.clients.get(provider);
@@ -1328,7 +1776,7 @@ export class AgentWorkspaceProxy {
                 id: provider,
                 label: providerLabel(provider),
                 enabled,
-                reason: enabled ? undefined : `${providerLabel(provider)} 未安装或启动失败`,
+                reason: enabled ? undefined : this.providerErrors.get(provider) ?? `${providerLabel(provider)} 未安装或启动失败`,
                 supportsImages,
                 supportsPermission,
                 supportsPlan: enabled,
@@ -1385,18 +1833,70 @@ export class AgentWorkspaceProxy {
         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 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 (!payload.cwd && existingConversation?.cwd)
+            cwd = existingConversation.cwd;
+        let client = await this.ensureProviderClient(provider);
+        if (!client) {
+            const message = this.providerErrors.get(provider) ?? `${providerLabel(provider)} 启动失败。请确认 CLI 已安装并可用。`;
+            if (existingConversation) {
+                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,
+                        providerError: message,
+                    },
+                }));
+                this.sendCapabilities();
+                return existingConversation;
+            }
+            if (payload.conversationId) {
+                return this.openOfflineHistory(payload, message, cwd);
+            }
+            return this.openFailure(payload, message, cwd);
+        }
         if (existingConversation && existingConversation.status !== "error" && existingConversation.agentSessionId) {
-            if (payload.conversationId && existingConversation.id !== payload.conversationId) {
+            const requestedCanonicalId = makeAgentV2RemoteConversationId(provider, existingConversation.agentSessionId);
+            if (payload.conversationId &&
+                payload.conversationId === requestedCanonicalId &&
+                existingConversation.id !== payload.conversationId) {
                 existingConversation = this.adoptConversationId(existingConversation.id, payload.conversationId);
             }
+            if ((this.timelines.get(existingConversation.id) ?? []).length === 0 && existingConversation.status !== "running") {
+                try {
+                    const existingAgentSessionId = existingConversation.agentSessionId;
+                    let result;
+                    try {
+                        result = await client.loadSession({ sessionId: existingAgentSessionId, cwd });
+                    }
+                    catch (error) {
+                        const recovered = await this.recycleProviderClient(provider, error);
+                        if (!recovered)
+                            throw error;
+                        client = recovered;
+                        result = await client.loadSession({ sessionId: existingAgentSessionId, cwd });
+                    }
+                    const nextAgentSessionId = this.extractSessionId(result);
+                    if (nextAgentSessionId && nextAgentSessionId !== existingAgentSessionId) {
+                        this.conversationByAgentSessionId.delete(existingAgentSessionId);
+                        existingConversation.agentSessionId = nextAgentSessionId;
+                        this.conversationByAgentSessionId.set(nextAgentSessionId, existingConversation.id);
+                    }
+                    await this.hydrateConversationFromProvider(existingConversation, result);
+                }
+                catch (error) {
+                    if (this.input.verbose) {
+                        process.stderr.write(`[agent:v2] resume failed for ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
+                    }
+                }
+            }
             this.activeConversationId = existingConversation.id;
             this.input.send(createEnvelope({
                 type: "agent.v2.conversation.opened",
@@ -1404,17 +1904,30 @@ export class AgentWorkspaceProxy {
                 payload: {
                     conversation: existingConversation,
                     snapshot: this.timelines.get(existingConversation.id) ?? [],
+                    requestedConversationId: payload.conversationId,
                 },
             }));
             return existingConversation;
         }
         try {
-            const result = agentSessionId
-                ? await client.loadSession({ sessionId: agentSessionId, cwd })
-                : await client.newSession({ cwd });
+            let result;
+            try {
+                result = agentSessionId
+                    ? await client.loadSession({ sessionId: agentSessionId, cwd })
+                    : await client.newSession({ cwd });
+            }
+            catch (error) {
+                const recovered = await this.recycleProviderClient(provider, error);
+                if (!recovered)
+                    throw error;
+                client = recovered;
+                result = agentSessionId
+                    ? await client.loadSession({ sessionId: agentSessionId, cwd })
+                    : await client.newSession({ cwd });
+            }
             agentSessionId = this.extractSessionId(result) ?? agentSessionId ?? id("agent-session");
             const now = Date.now();
-            const conversationId = payload.conversationId ?? `agent:${agentSessionId}`;
+            const conversationId = makeAgentV2RemoteConversationId(provider, agentSessionId);
             const conversation = {
                 ...existingConversation,
                 id: conversationId,
@@ -1436,10 +1949,15 @@ export class AgentWorkspaceProxy {
             this.conversationByAgentSessionId.set(agentSessionId, conversation.id);
             this.activeConversationId = conversation.id;
             this.timelines.set(conversation.id, this.timelines.get(conversation.id) ?? []);
+            await this.hydrateConversationFromProvider(conversation, result);
             this.input.send(createEnvelope({
                 type: "agent.v2.conversation.opened",
                 sessionId: this.input.sessionId,
-                payload: { conversation, snapshot: this.timelines.get(conversation.id) ?? [] },
+                payload: {
+                    conversation,
+                    snapshot: this.timelines.get(conversation.id) ?? [],
+                    requestedConversationId: payload.conversationId,
+                },
             }));
             return conversation;
         }
@@ -1478,8 +1996,47 @@ export class AgentWorkspaceProxy {
         this.input.send(createEnvelope({
             type: "agent.v2.conversation.opened",
             sessionId: this.input.sessionId,
-            payload: { conversation, snapshot: this.timelines.get(conversation.id) ?? [] },
+            payload: {
+                conversation,
+                snapshot: this.timelines.get(conversation.id) ?? [],
+                requestedConversationId: payload.conversationId,
+            },
+        }));
+        return conversation;
+    }
+    openOfflineHistory(payload, message, cwd = payload.cwd ?? this.input.cwd) {
+        const now = Date.now();
+        const conversation = {
+            id: payload.conversationId,
+            agentSessionId: payload.agentSessionId,
+            provider: payload.provider ?? this.input.availableProviders[0] ?? "codex",
+            cwd,
+            title: payload.title ?? titleFromCwd(cwd),
+            model: payload.model,
+            reasoningEffort: payload.reasoningEffort,
+            permissionMode: payload.permissionMode,
+            collaborationMode: payload.collaborationMode,
+            status: "idle",
+            archived: false,
+            lastActivityAt: now,
+            createdAt: now,
+        };
+        this.conversations.set(conversation.id, conversation);
+        if (conversation.agentSessionId) {
+            this.conversationByAgentSessionId.set(conversation.agentSessionId, conversation.id);
+        }
+        this.activeConversationId = conversation.id;
+        this.input.send(createEnvelope({
+            type: "agent.v2.conversation.opened",
+            sessionId: this.input.sessionId,
+            payload: {
+                conversation,
+                snapshot: this.timelines.get(conversation.id) ?? [],
+                requestedConversationId: payload.conversationId,
+                providerError: message,
+            },
         }));
+        this.sendCapabilities();
         return conversation;
     }
     async sendPrompt(payload) {
@@ -1488,60 +2045,62 @@ export class AgentWorkspaceProxy {
         if (!conversation)
             return;
         if (!conversation.agentSessionId) {
-            this.addItem(payload.conversationId, {
-                id: id("error"),
-                conversationId: payload.conversationId,
-                type: "error",
-                error: "Agent session 尚未就绪，消息没有发送。请重新打开对话后再试。",
-                createdAt: Date.now(),
-            });
+            this.rejectAgentAction(conversation, "Agent session 尚未就绪，消息没有发送。请重新打开对话后再试。");
             return;
         }
-        const client = this.clientForProvider(conversation.provider);
+        const client = this.clientForProvider(conversation.provider) ?? await this.ensureProviderClient(conversation.provider);
         if (!client) {
-            this.addItem(conversation.id, {
-                id: id("error"),
-                conversationId: conversation.id,
-                type: "error",
-                error: `${providerLabel(conversation.provider)} 未连接，消息没有发送。`,
-                createdAt: Date.now(),
-            });
+            this.rejectAgentAction(conversation, this.providerErrors.get(conversation.provider) ?? `${providerLabel(conversation.provider)} 未连接，消息没有发送。`, "error");
             return;
         }
         const protocol = this.protocolForProvider(conversation.provider);
         if (payload.contentBlocks.some((block) => block.type === "image") && !protocolSupportsImages(protocol)) {
-            conversation.status = "idle";
-            conversation.lastActivityAt = Date.now();
-            this.emitConversation(conversation);
+            this.rejectAgentAction(conversation, "当前 Agent provider 暂不支持图片输入，请升级 CLI 或切换到 Codex。");
+            return;
+        }
+        const priorSettings = {
+            model: conversation.model,
+            reasoningEffort: conversation.reasoningEffort,
+            permissionMode: conversation.permissionMode,
+        };
+        const effectiveModel = payload.model ??
+            conversation.model ??
+            (protocol === "codex-app-server" ? this.defaultModelForProvider(conversation.provider) : undefined);
+        const wasRunning = conversation.status === "running";
+        const activeTurnId = payload.targetTurnId ?? this.currentTurnIds.get(conversation.id);
+        const shouldSteer = Boolean(payload.delivery !== "new_turn" &&
+            wasRunning &&
+            protocol === "codex-app-server" &&
+            activeTurnId);
+        if (wasRunning && payload.delivery !== "new_turn" && protocol !== "codex-app-server") {
             this.addItem(conversation.id, {
                 id: id("error"),
                 conversationId: conversation.id,
                 type: "error",
-                error: "当前 Agent provider 暂不支持图片输入，请升级 CLI 或切换到 Codex。",
+                error: `${providerLabel(conversation.provider)} 当前不支持运行中追加输入。请等待本轮结束，或先停止后再发送。`,
                 createdAt: Date.now(),
             });
             return;
         }
-        const priorSettings = {
-            model: conversation.model,
-            reasoningEffort: conversation.reasoningEffort,
-            permissionMode: conversation.permissionMode,
-        };
-        conversation.model = payload.model ?? conversation.model;
+        if (payload.delivery === "steer" && protocol === "codex-app-server" && !activeTurnId) {
+            this.rejectAgentAction(conversation, "当前没有可追加输入的 Codex turn。请等待本轮开始后重试，或作为新消息发送。");
+            return;
+        }
+        conversation.model = effectiveModel ?? 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;
-        if (payload.model && payload.model !== priorSettings.model) {
+        if (effectiveModel && effectiveModel !== priorSettings.model) {
             const runtimeCapabilities = this.providerCapabilities.get(conversation.provider);
-            const label = runtimeCapabilities?.models?.find((m) => m.id === payload.model)?.label ?? payload.model;
+            const label = runtimeCapabilities?.models?.find((m) => m.id === effectiveModel)?.label ?? effectiveModel;
             this.emitNotice({
                 conversationId: conversation.id,
                 kind: "model_changed",
                 title: `已切换模型 · ${label}`,
-                detail: `${providerLabel(conversation.provider)} 下次回复将使用 ${payload.model}`,
+                detail: `${providerLabel(conversation.provider)} 下次回复将使用 ${effectiveModel}`,
             });
         }
         if (payload.reasoningEffort && payload.reasoningEffort !== priorSettings.reasoningEffort) {
@@ -1566,20 +2125,61 @@ export class AgentWorkspaceProxy {
             role: "user",
             content: payload.contentBlocks,
             text: userText,
+            metadata: shouldSteer ? { delivery: "steer", targetTurnId: activeTurnId } : undefined,
             createdAt: Date.now(),
         });
         this.emitConversation(conversation);
+        const promptAsNewTurn = () => client.prompt({
+            sessionId: conversation.agentSessionId,
+            content: payload.contentBlocks,
+            clientMessageId: payload.clientMessageId,
+            model: effectiveModel,
+            reasoningEffort: payload.reasoningEffort,
+            permissionMode: payload.permissionMode,
+            collaborationMode: payload.collaborationMode ?? conversation.collaborationMode,
+            cwd: conversation.cwd,
+        });
         try {
-            const result = await client.prompt({
-                sessionId: conversation.agentSessionId,
-                content: payload.contentBlocks,
-                clientMessageId: payload.clientMessageId,
-                model: payload.model,
-                reasoningEffort: payload.reasoningEffort,
-                permissionMode: payload.permissionMode,
-                collaborationMode: payload.collaborationMode ?? conversation.collaborationMode,
-                cwd: conversation.cwd,
-            });
+            const steer = client.steer;
+            let result;
+            if (shouldSteer && typeof steer === "function") {
+                try {
+                    result = await steer.call(client, {
+                        sessionId: conversation.agentSessionId,
+                        turnId: activeTurnId,
+                        content: payload.contentBlocks,
+                    });
+                }
+                catch (steerError) {
+                    this.forgetCurrentTurn(conversation.id, activeTurnId);
+                    const userItem = this.findItem(conversation.id, payload.clientMessageId);
+                    if (userItem) {
+                        this.upsertItem(conversation.id, {
+                            ...userItem,
+                            metadata: {
+                                ...(userItem.metadata ?? {}),
+                                delivery: "new_turn",
+                                fallbackFrom: "steer",
+                                failedTargetTurnId: activeTurnId,
+                            },
+                            updatedAt: Date.now(),
+                        });
+                    }
+                    this.addItem(conversation.id, {
+                        id: id("status"),
+                        conversationId: conversation.id,
+                        type: "status",
+                        role: "system",
+                        text: "Codex 未接收运行中追加输入，已改为发送新消息。",
+                        status: "running",
+                        createdAt: Date.now(),
+                    });
+                    result = await promptAsNewTurn();
+                }
+            }
+            else {
+                result = await promptAsNewTurn();
+            }
             const nextAgentSessionId = this.extractSessionId(result);
             if (nextAgentSessionId && nextAgentSessionId !== conversation.agentSessionId) {
                 if (conversation.agentSessionId)
@@ -1784,6 +2384,9 @@ export class AgentWorkspaceProxy {
         }
     }
     handleRequest(method, params) {
+        if (method === "claude/askUserQuestion") {
+            return this.handleStructuredInput({ ...(asRecord(params) ?? {}), source: method }, true);
+        }
         if (method === "item/tool/requestUserInput" || method === "tool/requestUserInput") {
             return this.handleStructuredInput(params, true);
         }
@@ -1829,13 +2432,30 @@ export class AgentWorkspaceProxy {
         }
         if (method.startsWith("account/") ||
             method.startsWith("mcpServer/startupStatus/") ||
-            method === "thread/status/changed" ||
             method === "thread/tokenUsage/updated" ||
             method === "serverRequest/resolved" ||
             method === "mcpServer/oauthLogin/completed") {
             return;
         }
         const conversationId = this.conversationIdFromParams(params) ?? this.fallbackConversationId();
+        if (method === "thread/status/changed") {
+            const status = agentStatusFromThreadStatus(params);
+            if (conversationId && status) {
+                const raw = asRecord(params);
+                const turnId = this.extractTurnId(raw);
+                if (turnId && (status === "running" || status === "waiting_permission")) {
+                    this.rememberTurnConversationId(conversationId, turnId);
+                }
+                if (status === "idle" || status === "error") {
+                    this.forgetCurrentTurn(conversationId, turnId);
+                }
+                const message = status === "error"
+                    ? firstString(raw, ["message", "error", "reason"])
+                    : undefined;
+                this.updateConversationStatus(conversationId, status, message);
+            }
+            return;
+        }
         if (method === "item/tool/requestUserInput" || method === "tool/requestUserInput") {
             this.handleStructuredInput(params);
             return;
@@ -2345,9 +2965,7 @@ export class AgentWorkspaceProxy {
         const raw = asRecord(params) ?? {};
         const conversationId = this.conversationIdFromParams(raw) ?? this.fallbackConversationId();
         const source = firstString(raw, ["method", "source", "requestMethod"]);
-        const formatResponse = source === "mcpServer/elicitation/request"
-            ? formatMcpElicitationResponse
-            : formatStructuredInputResponse;
+        const formatResponse = (answers, input) => formatStructuredInputResponseForSource(source, answers, input);
         if (!conversationId)
             return waitForResponse ? Promise.resolve(formatResponse({})) : undefined;
         const structuredInput = decodeStructuredInput(raw);
@@ -2374,13 +2992,13 @@ export class AgentWorkspaceProxy {
             const timer = setTimeout(() => {
                 this.pendingStructuredInputs.delete(structuredInput.requestId);
                 this.structuredInputWaiters.delete(structuredInput.requestId);
-                resolve(formatResponse({}));
+                resolve(formatResponse({}, structuredInput));
                 this.markStructuredInput(conversationId, structuredInput.requestId, {
                     inputPending: false,
                     inputError: "等待用户输入超时",
                 });
             }, PERMISSION_TIMEOUT_MS);
-            this.structuredInputWaiters.set(structuredInput.requestId, { resolve, timer, source });
+            this.structuredInputWaiters.set(structuredInput.requestId, { resolve, timer, source, input: structuredInput });
         });
     }
     toolCallFromItem(item, fallbackStatus) {
@@ -2414,11 +3032,19 @@ export class AgentWorkspaceProxy {
             return waitForResponse ? Promise.resolve({ outcome: { outcome: "cancelled" } }) : undefined;
         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"]);
         const permission = {
             requestId,
-            toolName: firstString(rawToolCall, ["toolName", "tool", "name", "title", "kind"]),
-            toolInput: stringify(rawToolCall.input ?? rawToolCall.toolInput ?? rawToolCall),
-            context: firstString(raw, ["context", "description", "message", "title"]),
+            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),
+            context: firstString(raw, ["context", "description", "message", "title", "reason"]),
             options: parsePermissionOptions(raw.options),
         };
         this.pendingPermissions.set(requestId, permission);
@@ -2430,6 +3056,12 @@ export class AgentWorkspaceProxy {
             conversationId,
             type: "permission",
             permission,
+            metadata: {
+                protocol: "v2",
+                permissionLive: true,
+                permissionExpired: false,
+                permissionPending: false,
+            },
             createdAt: Date.now(),
             updatedAt: Date.now(),
         };
@@ -2454,9 +3086,13 @@ export class AgentWorkspaceProxy {
     }
     respondPermission(payload) {
         const permission = this.pendingPermissions.get(payload.requestId);
+        const waiter = this.permissionWaiters.get(payload.requestId);
+        const existingItem = this.findItem(payload.conversationId, `permission:${payload.requestId}`);
+        const alreadyResolved = Boolean(existingItem?.metadata?.permissionOutcome);
+        if (!permission && !waiter && alreadyResolved)
+            return;
         this.pendingPermissions.delete(payload.requestId);
         const selectedOptionId = payload.optionId ?? selectPermissionOption(permission, payload.outcome);
-        const waiter = this.permissionWaiters.get(payload.requestId);
         if (waiter) {
             clearTimeout(waiter.timer);
             this.permissionWaiters.delete(payload.requestId);
@@ -2479,19 +3115,22 @@ export class AgentWorkspaceProxy {
             permissionError: undefined,
             permissionPending: false,
         });
-        this.updateConversationStatus(payload.conversationId, "running");
+        if (permission || waiter || existingItem) {
+            this.updateConversationStatus(payload.conversationId, "running");
+        }
     }
     respondStructuredInput(payload) {
         const pending = this.pendingStructuredInputs.get(payload.requestId);
-        this.pendingStructuredInputs.delete(payload.requestId);
         const waiter = this.structuredInputWaiters.get(payload.requestId);
+        const existingItem = this.findItem(payload.conversationId, `input:${payload.requestId}`);
+        const alreadySubmitted = existingItem?.metadata?.inputSubmitted === true;
+        if (!pending && !waiter && alreadySubmitted)
+            return;
+        this.pendingStructuredInputs.delete(payload.requestId);
         if (waiter) {
             clearTimeout(waiter.timer);
             this.structuredInputWaiters.delete(payload.requestId);
-            const formatResponse = waiter.source === "mcpServer/elicitation/request"
-                ? formatMcpElicitationResponse
-                : formatStructuredInputResponse;
-            waiter.resolve(formatResponse(payload.answers));
+            waiter.resolve(formatStructuredInputResponseForSource(waiter.source, payload.answers, waiter.input));
         }
         this.markStructuredInput(payload.conversationId, payload.requestId, {
             inputPending: false,
@@ -2500,7 +3139,9 @@ export class AgentWorkspaceProxy {
             inputError: undefined,
             answers: payload.answers,
         });
-        this.updateConversationStatus(pending?.conversationId ?? payload.conversationId, "running");
+        if (pending || waiter || existingItem) {
+            this.updateConversationStatus(pending?.conversationId ?? payload.conversationId, "running");
+        }
     }
     markPermission(conversationId, requestId, metadata) {
         const item = this.findItem(conversationId, `permission:${requestId}`);
@@ -2675,14 +3316,14 @@ export class AgentWorkspaceProxy {
         this.input.send(createEnvelope({
             type: "agent.v2.event",
             sessionId: this.input.sessionId,
-            payload: { conversationId, conversation, item },
+            payload: { conversationId, conversation: conversation ? { ...conversation } : undefined, item },
         }));
     }
     emitConversation(conversation) {
         this.input.send(createEnvelope({
             type: "agent.v2.event",
             sessionId: this.input.sessionId,
-            payload: { conversationId: conversation.id, conversation },
+            payload: { conversationId: conversation.id, conversation: { ...conversation } },
         }));
     }
     emitStatus(conversationId, status, text) {
@@ -2702,6 +3343,16 @@ export class AgentWorkspaceProxy {
             payload: input,
         }));
     }
+    rejectAgentAction(conversation, message, status = "idle") {
+        this.updateConversationStatus(conversation.id, status, message);
+        this.addItem(conversation.id, {
+            id: id("error"),
+            conversationId: conversation.id,
+            type: "error",
+            error: message,
+            createdAt: Date.now(),
+        });
+    }
     updateConversationPreview(conversationId, text, status) {
         const conversation = this.conversations.get(conversationId);
         if (!conversation)
@@ -2737,6 +3388,58 @@ export class AgentWorkspaceProxy {
             },
         }));
     }
+    /** Page OLDER transcript history for a conversation (client scrolling up).
+     *  Only Codex's app-server exposes paginated reads; other providers report
+     *  no more history. Pure pass-through — does not touch the bounded live
+     *  timeline. The client prepends the returned (ascending) items. */
+    async loadOlderHistory(payload) {
+        const sendResult = (items, nextCursor) => {
+            this.input.send(createEnvelope({
+                type: "agent.v2.history.result",
+                sessionId: this.input.sessionId,
+                payload: {
+                    conversationId: payload.conversationId,
+                    items,
+                    nextCursor,
+                    hasMore: Boolean(nextCursor),
+                },
+            }));
+        };
+        const conversation = this.conversations.get(payload.conversationId);
+        if (!conversation?.agentSessionId)
+            return sendResult([], undefined);
+        const client = this.clientForProvider(conversation.provider);
+        const listTurns = client?.listTurns;
+        if (typeof listTurns !== "function")
+            return sendResult([], undefined);
+        // Client-supplied cursor wins; else the one captured at hydration. Absent
+        // cursor means we're already at the start of history.
+        const cursor = payload.cursor ?? this.historyCursors.get(payload.conversationId);
+        if (!cursor)
+            return sendResult([], undefined);
+        try {
+            const turnsResult = await listTurns.call(client, {
+                sessionId: conversation.agentSessionId,
+                limit: payload.limit,
+                cursor,
+                sortDirection: "desc",
+                itemsView: "full",
+            });
+            const turnsThread = threadFromTurnsListResult(conversation.agentSessionId, turnsResult);
+            const items = turnsThread
+                ? timelineItemsFromProviderThread({ thread: turnsThread }, payload.conversationId)
+                : [];
+            const nextCursor = firstString(asRecord(turnsResult), ["nextCursor", "next_cursor", "cursor"]);
+            this.historyCursors.set(payload.conversationId, nextCursor);
+            sendResult(items, nextCursor);
+        }
+        catch (error) {
+            if (this.input.verbose) {
+                process.stderr.write(`[agent:v2] history page failed for ${conversation.provider}: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+            sendResult([], undefined);
+        }
+    }
     conversationIdFromParams(params) {
         const raw = asRecord(params);
         if (!raw)
@@ -2823,13 +3526,23 @@ export class AgentWorkspaceProxy {
     handleProviderExit(provider, message) {
         this.clients.delete(provider);
         this.agentProtocols.delete(provider);
-        this.cancelPendingPermissions();
+        this.providerErrors.set(provider, message);
+        for (const conversation of this.conversations.values()) {
+            if (conversation.provider === provider && conversation.status === "waiting_permission") {
+                this.cancelPendingPermissions(conversation.id, false);
+            }
+        }
         for (const conversation of this.conversations.values()) {
             if (conversation.provider !== provider)
                 continue;
+            if (conversation.status !== "running" && conversation.status !== "waiting_permission") {
+                this.emitConversation(conversation);
+                continue;
+            }
             conversation.status = "error";
             conversation.lastMessagePreview = message;
             conversation.lastActivityAt = Date.now();
+            this.forgetCurrentTurn(conversation.id);
             this.emitConversation(conversation);
             this.addItem(conversation.id, {
                 id: id("error"),
@@ -2841,18 +3554,23 @@ export class AgentWorkspaceProxy {
         }
         this.sendCapabilities();
     }
-    cancelPendingPermissions(conversationId) {
+    cancelPendingPermissions(conversationId, updateStatus = true) {
         for (const [requestId, waiter] of this.permissionWaiters) {
+            if (conversationId && this.itemConversationIds.get(requestId) !== conversationId)
+                continue;
             clearTimeout(waiter.timer);
             waiter.resolve(formatPermissionResponse(this.permissionSources.get(requestId), "cancelled", "cancelled"));
             this.pendingPermissions.delete(requestId);
             this.permissionSources.delete(requestId);
         }
-        this.permissionWaiters.clear();
+        if (!conversationId)
+            this.permissionWaiters.clear();
         for (const [requestId, waiter] of this.structuredInputWaiters) {
-            clearTimeout(waiter.timer);
-            waiter.resolve(formatStructuredInputResponse({}));
             const pending = this.pendingStructuredInputs.get(requestId);
+            if (conversationId && pending?.conversationId !== conversationId)
+                continue;
+            clearTimeout(waiter.timer);
+            waiter.resolve(formatStructuredInputResponseForSource(waiter.source, {}, waiter.input));
             if (pending) {
                 this.markStructuredInput(pending.conversationId, requestId, {
                     inputPending: false,
@@ -2860,9 +3578,11 @@ export class AgentWorkspaceProxy {
                 });
             }
             this.pendingStructuredInputs.delete(requestId);
+            this.structuredInputWaiters.delete(requestId);
         }
-        this.structuredInputWaiters.clear();
-        if (conversationId)
+        if (!conversationId)
+            this.structuredInputWaiters.clear();
+        if (conversationId && updateStatus)
             this.updateConversationStatus(conversationId, "idle");
     }
     extractSessionId(value) {
@@ -2940,6 +3660,34 @@ function formatStructuredInputResponse(answers) {
         ])),
     };
 }
+function formatClaudeAskUserQuestionResponse(answers, input) {
+    const questions = input?.questions ?? [];
+    const byQuestionText = {};
+    for (const question of questions) {
+        const values = answers[question.id] ?? answers[question.question] ?? [];
+        const cleaned = values.map((value) => value.trim()).filter(Boolean);
+        if (cleaned.length === 0)
+            continue;
+        byQuestionText[question.question] = question.selectionLimit && question.selectionLimit > 1
+            ? cleaned
+            : cleaned[0] ?? "";
+    }
+    return {
+        behavior: "allow",
+        updatedInput: {
+            questions: questions.map((question) => ({
+                question: question.question,
+                header: question.header,
+                options: question.options?.map((option) => ({
+                    label: option.label,
+                    description: option.description,
+                })) ?? [],
+                multiSelect: Boolean(question.selectionLimit && question.selectionLimit > 1),
+            })),
+            answers: byQuestionText,
+        },
+    };
+}
 function formatMcpElicitationResponse(answers) {
     const content = Object.fromEntries(Object.entries(answers).map(([questionId, values]) => [
         questionId,
@@ -2951,6 +3699,15 @@ function formatMcpElicitationResponse(answers) {
         _meta: { source: "linkshell" },
     };
 }
+function formatStructuredInputResponseForSource(source, answers, input) {
+    if (source === "mcpServer/elicitation/request") {
+        return formatMcpElicitationResponse(answers);
+    }
+    if (source === "claude/askUserQuestion") {
+        return formatClaudeAskUserQuestionResponse(answers, input);
+    }
+    return formatStructuredInputResponse(answers);
+}
 function formatPermissionResponse(source, outcome, optionId) {
     if (source === "item/commandExecution/requestApproval" || source === "item/fileChange/requestApproval") {
         return { decision: outcome === "allow" ? "accept" : outcome === "deny" ? "decline" : "cancel" };