@keyou007/agent-bot 0.1.14-alpha.0 → 0.1.14-alpha.2

package/dist/proxy/ProxySessionController.js

@@ -1,3 +1,4 @@
+import { promises as fs } from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { createProjectlessWorkspace, detectProjectlessWorkspace } from "../codex/ProjectlessWorkspace.js";
@@ -6,6 +7,7 @@ import { CommandRouter } from "../commands/CommandRouter.js";
 import { baseChatContextKey, isThreadContextKey } from "../feishu/contextKey.js";
 import { CardRenderer, } from "../feishu/CardRenderer.js";
 import { generateGroupAvatarPng, resolveGroupAvatarProjectName } from "../feishu/GroupAvatarGenerator.js";
+import { allowsFeishuUser } from "../feishu/ownerAccess.js";
 import { buildTurnGraphRows } from "../presentation/turnGraph.js";
 import { createId } from "../utils/id.js";
 import { asInlineCode, codeBlock, truncateMiddle, truncateText } from "../utils/markdown.js";
@@ -16,8 +18,22 @@ const MESSAGE_COMPLETED_REACTION = "DONE";
 const MESSAGE_FAILED_REACTION = "ERROR";
 const MESSAGE_CANCELLED_REACTION = "CrossMark";
 const SESSION_PAGE_SIZE = 5;
+const DIRECTORY_PAGE_SIZE = 15;
 const RESET_HISTORY_PAGE_SIZE = 10;
+const MAX_LLM_TURN_RETRIES = 3;
+const RECOVERY_ACTIVITY_WINDOW_MS = 5 * 60 * 1_000;
+const RECOVERY_HEARTBEAT_INTERVAL_MS = 60 * 1_000;
 const REMOTE_SESSION_REFERENCE_PREFIX = "agent-runtime:";
+const WINDOWS_DRIVES_DIRECTORY = "agentbot://windows-drives";
+const IMAGE_FILE_EXTENSIONS = new Set([
+    ".avif", ".bmp", ".gif", ".heic", ".heif", ".ico", ".jpeg", ".jpg", ".png", ".svg", ".tif", ".tiff", ".webp",
+]);
+const BINARY_FILE_EXTENSIONS = new Set([
+    ".7z", ".a", ".apk", ".avi", ".bin", ".bz2", ".class", ".dat", ".db", ".deb", ".dll", ".dmg", ".doc", ".docx",
+    ".dylib", ".eot", ".exe", ".flac", ".gz", ".ico", ".ipa", ".iso", ".jar", ".lib", ".mdb", ".mkv", ".mov", ".mp3",
+    ".mp4", ".msi", ".o", ".obj", ".ogg", ".otf", ".pdf", ".ppt", ".pptx", ".rar", ".rpm", ".so", ".sqlite", ".tar",
+    ".ttf", ".wav", ".webm", ".woff", ".woff2", ".xls", ".xlsx", ".xz", ".zip", ".zst",
+]);
 const HELP_COMMAND_SECTIONS = [
     {
         title: "任务管理",
@@ -32,6 +48,11 @@ const HELP_COMMAND_SECTIONS = [
                 usage: "[title] [--dir <cwd> | --nodir]",
                 description: "创建飞书群和新任务",
             },
+            {
+                command: "/dir",
+                usage: "[目录]",
+                description: "浏览、发送文件，并从选定目录创建任务或群",
+            },
             {
                 command: "/forkgroup",
                 usage: "[title]",
@@ -50,6 +71,11 @@ const HELP_COMMAND_SECTIONS = [
                 requiresArgument: true,
             },
             { command: "/sessions", usage: "[关键词]", description: "查找本机任务" },
+            {
+                command: "/archive",
+                usage: "[序号或任务 ID]",
+                description: "归档当前或指定任务",
+            },
             {
                 command: "/switch",
                 usage: "[序号或任务 ID]",
@@ -114,6 +140,11 @@ const HELP_COMMAND_SECTIONS = [
                 usage: "[--force]",
                 description: "默认安全重启；--force 立即重启",
             },
+            {
+                command: "/mute",
+                usage: "[on|off]",
+                description: "开启或关闭当前群的仅 @ 响应模式",
+            },
             { command: "/help", description: "显示本帮助" },
         ],
     },
@@ -129,6 +160,7 @@ export class ProxySessionController {
     logger;
     lifecycle;
     shellCommandExecutor;
+    windowsDriveLister;
     router = new CommandRouter();
     cardRenderer = new CardRenderer();
     messageQueues = new Map();
@@ -139,8 +171,14 @@ export class ProxySessionController {
     sessionResets = new Map();
     lastSessionListings = new Map();
     threadInitializations = new Map();
+    llmRetryingSessions = new Set();
+    retriedFailureTurnIds = new Set();
+    recoveryRetryTimers = new Map();
     unsubscribe = [];
-    constructor(config, store, runtimes, outbound, logger, lifecycle, shellCommandExecutor = executeShellCommand) {
+    recoveryActivityHeartbeat;
+    startupRecovery;
+    queuedPromptsRestored = false;
+    constructor(config, store, runtimes, outbound, logger, lifecycle, shellCommandExecutor = executeShellCommand, windowsDriveLister = listWindowsDriveRoots) {
         this.config = config;
         this.store = store;
         this.runtimes = runtimes;
@@ -148,12 +186,7 @@ export class ProxySessionController {
         this.logger = logger;
         this.lifecycle = lifecycle;
         this.shellCommandExecutor = shellCommandExecutor;
-        const interruptedAcpSessions = this.store.reconcileInterruptedAcpSessions(Object.entries(this.config.agents)
-            .filter(([, agent]) => agent.kind === "acp")
-            .map(([name]) => name));
-        if (interruptedAcpSessions.length > 0) {
-            this.logger.warn({ sessionIds: interruptedAcpSessions.map((session) => session.localSessionId) }, "Marked interrupted ACP sessions as failed after process restart.");
-        }
+        this.windowsDriveLister = windowsDriveLister;
         for (const [, runtime] of this.runtimes.entries()) {
             this.unsubscribe.push(runtime.onEvent((event) => {
                 void this.handleRuntimeEvent(event).catch((error) => {
@@ -162,14 +195,25 @@ export class ProxySessionController {
             }));
         }
         this.restorePersistedSessionRoutes();
-        this.restorePersistedQueuedPrompts();
         void this.restorePersistedMessageReactions().catch((error) => {
             this.logger.warn({ error }, "Failed to restore persisted message reaction statuses.");
         });
+        this.recoveryActivityHeartbeat = setInterval(() => this.persistActiveTurnHeartbeats(), RECOVERY_HEARTBEAT_INTERVAL_MS);
+        this.recoveryActivityHeartbeat.unref?.();
     }
     async onMessage(message) {
-        // The durable deduplication claim is the only operation allowed before acknowledgement.
-        // It prevents event retries from adding duplicate reactions.
+        if (!message.contextKey.startsWith("console:") && !allowsFeishuUser(this.config, message.userId)) {
+            this.logger.debug({ messageId: message.messageId }, "Ignored a Feishu message from a non-owner before acknowledgement.");
+            return;
+        }
+        if (message.chatType === "group"
+            && this.store.chatRequiresMention(baseChatContextKey(message.contextKey))
+            && message.mentionedBot !== true) {
+            this.logger.debug({ messageId: message.messageId, contextKey: message.contextKey }, "Ignored an unmentioned message from a muted Lark group.");
+            return;
+        }
+        // For accepted messages, claim durable deduplication before acknowledgement so event
+        // retries cannot add duplicate reactions.
         if (!this.store.claimInboundEvent(message.messageId, "message"))
             return;
         try {
@@ -262,6 +306,10 @@ export class ProxySessionController {
             this.messageQueues.delete(message.contextKey);
     }
     async onCardAction(action) {
+        if (!allowsFeishuUser(this.config, action.userId)) {
+            this.logger.debug({ actionId: action.actionId }, "Ignored a Feishu card action from a non-owner.");
+            return;
+        }
         if (!this.store.claimInboundEvent(action.actionId, "card_action"))
             return;
         const contextKey = this.cardActionContextKey(action);
@@ -321,6 +369,24 @@ export class ProxySessionController {
                         await this.outbound.sendText(contextKey, "该安全重启计划已失效，请查看最新状态卡片。");
                     }
                 }
+                else if (kind === "directory_open" || kind === "directory_page") {
+                    await this.openDirectoryBrowser(contextKey, directoryActionPath(scopedAction.value.directory), {
+                        updateMessageId: requiredCardMessageId(scopedAction.messageId),
+                        page: kind === "directory_page" ? directoryPageValue(scopedAction.value.page) : 0,
+                    });
+                }
+                else if (kind === "directory_send_file") {
+                    const filePath = directoryFileActionPath(scopedAction.value.filePath);
+                    await this.assertSendableFile(filePath);
+                    await this.outbound.sendFile(contextKey, filePath);
+                }
+                else if (kind === "directory_new" || kind === "directory_new_group") {
+                    const directory = directoryActionPath(scopedAction.value.directory);
+                    await this.assertBrowsableDirectory(directory);
+                    await this.execute(contextKey, kind === "directory_new"
+                        ? { type: "new", cwd: directory }
+                        : { type: "newgroup", cwd: directory }, undefined, replyTarget, undefined, scopedAction.userId);
+                }
                 else if (kind === "session_page") {
                     await this.refreshSessionsCardFromAction(scopedAction);
                 }
@@ -352,6 +418,14 @@ export class ProxySessionController {
                     await this.createFeishuGroupFromReference(contextKey, sessionId, scopedAction.userId);
                     await this.refreshSessionsCardFromAction(scopedAction);
                 }
+                else if (kind === "session_archive") {
+                    const sessionId = String(scopedAction.value.sessionId ?? "");
+                    await this.archiveSessionReference(contextKey, sessionId, {
+                        announce: true,
+                        source: "sessions_card",
+                    });
+                    await this.refreshSessionsCardFromAction(scopedAction);
+                }
                 else if (kind === "session_stop") {
                     const sessionId = String(scopedAction.value.sessionId ?? "");
                     await this.stopSessionReference(contextKey, sessionId);
@@ -484,6 +558,10 @@ export class ProxySessionController {
         this.queuedPromptCards.clear();
         this.queuedPromptCardWrites.clear();
         this.sessionResets.clear();
+        for (const timer of this.recoveryRetryTimers.values())
+            clearTimeout(timer);
+        this.recoveryRetryTimers.clear();
+        clearInterval(this.recoveryActivityHeartbeat);
     }
     async controlStopTask(localSessionId) {
         const record = this.store.getSession(localSessionId);
@@ -492,6 +570,13 @@ export class ProxySessionController {
         await this.cancelSession(record);
         return `Task stop requested: ${record.title ?? record.remoteSessionId ?? record.localSessionId}`;
     }
+    async controlArchiveTask(localSessionId) {
+        const record = this.requireControlSession(localSessionId);
+        return this.archiveSessionReference(this.controlSessionContextKey(record), localSessionId, {
+            announce: false,
+            source: "cli",
+        });
+    }
     async controlGetTaskStatus(localSessionId) {
         const record = this.store.getSession(localSessionId);
         if (!record)
@@ -641,6 +726,314 @@ export class ProxySessionController {
             task: forked.task,
         };
     }
+    async controlCreateTask(localSessionId, requestedTitle, requestedProjectCwd, forceProjectless = false, requestedAgentName) {
+        const source = this.requireControlSession(localSessionId);
+        const contextKey = this.controlSessionContextKey(source);
+        const context = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent);
+        const agentName = requestedAgentName?.trim() || context.defaultAgent;
+        const agent = this.ensureAgent(agentName);
+        if (forceProjectless && agent.kind !== "app-server") {
+            throw new Error("task new --nodir is only available for App Server agents.");
+        }
+        const replyTarget = this.controlSessionReplyTarget(source);
+        const cwd = forceProjectless
+            ? undefined
+            : requestedProjectCwd === undefined
+                ? detectProjectlessWorkspace(source.cwd)
+                    ? agent.kind === "app-server" ? undefined : createProjectlessWorkspace().cwd
+                    : source.cwd
+                : resolveUserPath(requestedProjectCwd, source.cwd);
+        const settings = source.agentName === agentName
+            ? {
+                modelProvider: source.modelProvider,
+                model: source.model,
+                reasoningEffort: source.reasoningEffort,
+                permissionMode: source.permissionMode,
+            }
+            : {};
+        return this.outbound.withReplyTarget(contextKey, replyTarget, () => this.createSession(contextKey, agentName, cwd, true, false, undefined, undefined, requestedTitle, settings));
+    }
+    async controlForkTask(localSessionId) {
+        const source = this.requireControlSession(localSessionId);
+        const contextKey = this.controlSessionContextKey(source);
+        const replyTarget = this.controlSessionReplyTarget(source);
+        const plan = await this.prepareForkSession(contextKey, source.localSessionId);
+        const forked = await this.outbound.withReplyTarget(contextKey, replyTarget, async () => {
+            const result = await this.forkSessionIntoContext(contextKey, plan);
+            await this.outbound.sendText(contextKey, `已从指定任务${plan.forkedFromHistoricalTurn ? "最近已完成轮次" : ""}创建分支并切换到新任务：${result.session.title
+                ? `${result.session.title}（${result.session.remoteSessionId}）`
+                : result.session.remoteSessionId}`);
+            return result;
+        });
+        return {
+            sourceLocalSessionId: source.localSessionId,
+            sourceTurnId: plan.lastTurnId,
+            task: this.store.getSession(forked.record.localSessionId) ?? forked.record,
+        };
+    }
+    async controlSwitchTask(localSessionId, targetLocalSessionId, previous = false) {
+        const anchor = this.requireControlSession(localSessionId);
+        const contextKey = this.controlSessionContextKey(anchor);
+        const replyTarget = this.controlSessionReplyTarget(anchor);
+        const target = previous ? undefined : targetLocalSessionId ?? anchor.localSessionId;
+        await this.outbound.withReplyTarget(contextKey, replyTarget, () => this.switchSession(contextKey, target));
+        return this.requireCurrentSession(contextKey);
+    }
+    async controlQueueTaskPrompt(localSessionId, text) {
+        const promptText = text.trim();
+        if (!promptText)
+            throw new Error("The queued Prompt cannot be empty.");
+        const record = this.requireControlSession(localSessionId);
+        const contextKey = this.controlSessionContextKey(record);
+        const replyTarget = this.controlSessionReplyTarget(record);
+        const queued = this.persistQueuedPrompt(record.localSessionId, contextKey, promptText, { replyTarget });
+        this.store.audit(contextKey, "queued_prompt_added", {
+            promptId: queued.promptId,
+            localSessionId: record.localSessionId,
+            source: "cli",
+        });
+        const queuedCount = this.store.countQueuedPrompts(record.localSessionId);
+        await this.scheduleNextQueuedPrompt(record.localSessionId);
+        return { promptId: queued.promptId, queued: queuedCount };
+    }
+    controlTaskAgent(localSessionId, agentName) {
+        const record = this.requireControlSession(localSessionId);
+        const contextKey = this.controlSessionContextKey(record);
+        const context = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent);
+        if (agentName) {
+            this.ensureAgent(agentName);
+            this.store.setDefaultAgent(contextKey, agentName);
+        }
+        return {
+            current: agentName ?? context.defaultAgent,
+            agents: Object.entries(this.config.agents).map(([name, agent]) => ({ name, title: agent.title })),
+        };
+    }
+    async controlTaskSettings(localSessionId, setting, value) {
+        const record = this.requireControlSession(localSessionId);
+        const loaded = await this.loadSession(record);
+        if (setting && !value?.trim())
+            throw new Error(`task ${setting} requires a value.`);
+        const nextValue = value?.trim();
+        if (setting === "provider" && nextValue) {
+            await this.assertModelProvider(loaded, nextValue);
+            const models = await loaded.runtime.listModels();
+            const model = models.find((candidate) => candidate.id === loaded.session.model)
+                ?? models.find((candidate) => candidate.isDefault);
+            if (!model)
+                throw new Error("The current runtime has no model available for a Provider change.");
+            const effort = model.supportedReasoningEfforts.some((candidate) => candidate.value === loaded.session.reasoningEffort)
+                ? loaded.session.reasoningEffort
+                : model.defaultReasoningEffort ?? model.supportedReasoningEfforts[0]?.value;
+            if (!effort)
+                throw new Error(`Model ${model.id} has no reasoning effort available for a Provider change.`);
+            if (!loaded.runtime.setExecutionSettings)
+                throw new Error("The current runtime does not support Provider settings.");
+            const updated = await loaded.runtime.setExecutionSettings(record.localSessionId, {
+                modelProvider: nextValue,
+                model: model.id,
+                reasoningEffort: effort,
+                permissionMode: loaded.session.permissionMode,
+            });
+            this.store.updateRuntimeSession(record.localSessionId, {
+                modelProvider: updated.modelProvider ?? nextValue,
+                model: updated.model ?? model.id,
+                reasoningEffort: updated.reasoningEffort ?? effort,
+                permissionMode: updated.permissionMode,
+            });
+        }
+        else if (setting === "model" && nextValue) {
+            const models = await loaded.runtime.listModels();
+            const selected = models.find((candidate) => candidate.id === nextValue);
+            if (!selected)
+                throw new Error(`Unknown model: ${nextValue}`);
+            const currentEffort = loaded.session.reasoningEffort;
+            const nextEffort = currentEffort && selected.supportedReasoningEfforts.some((candidate) => candidate.value === currentEffort)
+                ? currentEffort
+                : selected.defaultReasoningEffort;
+            await loaded.runtime.setModel(record.localSessionId, nextValue);
+            if (nextEffort && nextEffort !== currentEffort) {
+                await loaded.runtime.setReasoningEffort(record.localSessionId, nextEffort);
+            }
+            this.store.updateRuntimeSession(record.localSessionId, { model: nextValue, reasoningEffort: nextEffort });
+        }
+        else if (setting === "thinking" && nextValue) {
+            const models = await loaded.runtime.listModels();
+            const currentModel = models.find((candidate) => candidate.id === loaded.session.model)
+                ?? models.find((candidate) => candidate.isDefault);
+            if (!currentModel)
+                throw new Error("The current runtime has no model with configurable reasoning effort.");
+            if (!currentModel.supportedReasoningEfforts.some((candidate) => candidate.value === nextValue)) {
+                const supported = currentModel.supportedReasoningEfforts.map((candidate) => candidate.value).join(", ") || "none";
+                throw new Error(`Unsupported reasoning effort: ${nextValue}. Supported values: ${supported}.`);
+            }
+            await loaded.runtime.setReasoningEffort(record.localSessionId, nextValue);
+            this.store.updateRuntimeSession(record.localSessionId, { reasoningEffort: nextValue });
+        }
+        else if (setting === "permissions" && nextValue) {
+            if (nextValue !== "auto" && nextValue !== "confirm") {
+                throw new Error("task permissions accepts auto or confirm.");
+            }
+            await loaded.runtime.setPermissionMode(record.localSessionId, nextValue);
+            this.store.updateRuntimeSession(record.localSessionId, { permissionMode: nextValue });
+        }
+        const session = this.store.getSession(record.localSessionId) ?? record;
+        const models = await loaded.runtime.listModels();
+        const currentModel = models.find((candidate) => candidate.id === session.model)
+            ?? models.find((candidate) => candidate.isDefault);
+        const providers = loaded.runtime.listModelProviders
+            ? await loaded.runtime.listModelProviders()
+            : [];
+        return {
+            session,
+            providers,
+            models,
+            reasoningOptions: currentModel?.supportedReasoningEfforts ?? [],
+            permissionModes: ["auto", "confirm"],
+        };
+    }
+    async controlTaskGoal(localSessionId, action, objective) {
+        const record = this.requireControlSession(localSessionId);
+        const loaded = await this.loadSession(record);
+        if (loaded.runtime.kind !== "codex" || !loaded.runtime.getGoal || !loaded.runtime.setGoal || !loaded.runtime.clearGoal) {
+            throw new Error("The current Agent does not support Goal mode.");
+        }
+        if (action === "show")
+            return { goal: await loaded.runtime.getGoal(record.localSessionId) };
+        if (action === "clear")
+            return { cleared: await loaded.runtime.clearGoal(record.localSessionId) };
+        const current = await loaded.runtime.getGoal(record.localSessionId);
+        if (action === "pause" || action === "resume") {
+            if (!current)
+                throw new Error("The task has no Goal.");
+            return { goal: await loaded.runtime.setGoal(record.localSessionId, { status: action === "pause" ? "paused" : "active" }) };
+        }
+        const nextObjective = objective?.trim();
+        if (!nextObjective)
+            throw new Error(`task goal ${action} requires an objective.`);
+        validateGoalObjective(nextObjective);
+        if (action === "set" && current && current.status !== "complete") {
+            throw new Error("The task already has an unfinished Goal. Use task goal <task> edit <objective>, or clear it first.");
+        }
+        if (action === "edit" && !current)
+            throw new Error("The task has no Goal to edit.");
+        return {
+            goal: await loaded.runtime.setGoal(record.localSessionId, {
+                objective: nextObjective,
+                status: action === "edit" ? current.status : "active",
+                ...(action === "edit" ? { tokenBudget: current.tokenBudget } : {}),
+            }),
+        };
+    }
+    controlListTaskTurns(localSessionId) {
+        const session = this.requireControlSession(localSessionId);
+        if (!session.remoteSessionId || !this.isCodexSession(session)) {
+            throw new Error("The task is not an App Server task that can be reset.");
+        }
+        const contextKey = this.controlSessionContextKey(session);
+        const rows = this.store.listCompletedTurnGraph(session.localSessionId, contextKey);
+        const graph = buildTurnGraphRows(rows.map((turn) => ({ turnId: turn.turnId, parentTurnId: turn.parentTurnId })));
+        return {
+            session,
+            turns: rows.flatMap((turn, index) => {
+                const snapshot = turnViewSnapshot(turn.snapshot);
+                if (!snapshot)
+                    return [];
+                return [{
+                        sequence: graph[index].sequence,
+                        turnId: turn.turnId,
+                        parentTurnId: turn.parentTurnId,
+                        prompt: snapshot.prompt ?? snapshot.taskTitle,
+                        startedAt: snapshot.startedAt,
+                        completedAt: snapshot.completedAt,
+                        current: session.lastTurnId === turn.turnId && session.lastTurnStatus === "completed",
+                    }];
+            }),
+        };
+    }
+    async controlResetTaskToTurn(localSessionId, turnId) {
+        const record = this.requireControlSession(localSessionId);
+        const contextKey = this.controlSessionContextKey(record);
+        const previous = this.sessionResets.get(record.localSessionId) ?? Promise.resolve();
+        const reset = previous.catch(() => undefined).then(() => this.performSessionReset(contextKey, record, turnId, false));
+        this.sessionResets.set(record.localSessionId, reset);
+        try {
+            await reset;
+        }
+        finally {
+            if (this.sessionResets.get(record.localSessionId) === reset)
+                this.sessionResets.delete(record.localSessionId);
+        }
+        return this.store.getSession(record.localSessionId) ?? record;
+    }
+    controlTaskMute(localSessionId, enabled) {
+        const record = this.requireControlSession(localSessionId);
+        const contextKey = baseChatContextKey(this.controlSessionContextKey(record));
+        const chat = this.store.getChatContext(contextKey);
+        if (chat?.chatType !== "group")
+            throw new Error("task mute is only available for group chats.");
+        const next = enabled ?? Boolean(chat.requiresMention);
+        if (enabled !== undefined)
+            this.store.setChatRequiresMention(contextKey, enabled);
+        return { contextKey, enabled: next };
+    }
+    async controlRunTaskShell(localSessionId, command) {
+        const record = this.requireControlSession(localSessionId);
+        const normalized = command.trim();
+        if (!normalized)
+            throw new Error("task shell requires a command.");
+        return { ...await this.shellCommandExecutor(normalized, record.cwd), cwd: record.cwd, command: normalized };
+    }
+    async controlListTaskDirectory(localSessionId, requestedDirectory, requestedPage = 0) {
+        const record = this.requireControlSession(localSessionId);
+        if (requestedDirectory === WINDOWS_DRIVES_DIRECTORY) {
+            const drives = await this.windowsDriveLister();
+            const totalPages = Math.max(1, Math.ceil(drives.length / DIRECTORY_PAGE_SIZE));
+            const page = Math.min(Math.max(0, Math.trunc(requestedPage)), totalPages - 1);
+            return {
+                directory: WINDOWS_DRIVES_DIRECTORY,
+                page,
+                totalPages,
+                totalEntries: drives.length,
+                entries: drives.slice(page * DIRECTORY_PAGE_SIZE, (page + 1) * DIRECTORY_PAGE_SIZE).map((drive) => ({
+                    name: windowsDriveDisplayName(drive),
+                    path: drive.root,
+                    kind: "drive",
+                })),
+            };
+        }
+        const directory = requestedDirectory === undefined
+            ? path.resolve(record.cwd)
+            : resolveUserPath(requestedDirectory, record.cwd);
+        await this.assertBrowsableDirectory(directory);
+        const entries = (await fs.readdir(directory, { withFileTypes: true }))
+            .map((entry) => ({
+            name: entry.name,
+            path: path.join(directory, entry.name),
+            kind: directoryBrowserEntryKind(entry),
+        }))
+            .sort((left, right) => Number(right.kind === "directory") - Number(left.kind === "directory")
+            || left.name.localeCompare(right.name, undefined, { numeric: true, sensitivity: "base" }));
+        const totalPages = Math.max(1, Math.ceil(entries.length / DIRECTORY_PAGE_SIZE));
+        const page = Math.min(Math.max(0, Math.trunc(requestedPage)), totalPages - 1);
+        const parentDirectory = isWindowsDriveRoot(directory) ? WINDOWS_DRIVES_DIRECTORY : path.dirname(directory);
+        return {
+            directory,
+            ...(parentDirectory !== directory ? { parentDirectory } : {}),
+            page,
+            totalPages,
+            totalEntries: entries.length,
+            entries: entries.slice(page * DIRECTORY_PAGE_SIZE, (page + 1) * DIRECTORY_PAGE_SIZE),
+        };
+    }
+    async controlSendTaskFile(localSessionId, requestedFilePath) {
+        const record = this.requireControlSession(localSessionId);
+        const filePath = resolveUserPath(requestedFilePath, record.cwd);
+        await this.assertSendableFile(filePath);
+        const contextKey = this.controlSessionContextKey(record);
+        const replyTarget = this.controlSessionReplyTarget(record);
+        return this.outbound.withReplyTarget(contextKey, replyTarget, () => this.outbound.sendFile(contextKey, filePath));
+    }
     cardActionContextKey(action) {
         const explicit = typeof action.value.contextKey === "string" ? action.value.contextKey : undefined;
         if (explicit && baseChatContextKey(explicit) === baseChatContextKey(action.contextKey))
@@ -665,6 +1058,9 @@ export class ProxySessionController {
             case "shell":
                 await this.runShellCommand(contextKey, command.command);
                 return;
+            case "dir":
+                await this.openDirectoryBrowser(contextKey, command.directory);
+                return;
             case "new":
                 if (command.projectless && this.ensureAgent(context.defaultAgent).kind !== "app-server") {
                     throw new Error("/new --nodir 仅支持 App Server Agent。");
@@ -708,6 +1104,16 @@ export class ProxySessionController {
                 else
                     await this.openAgentSettings(contextKey);
                 return;
+            case "archive": {
+                const sessionId = command.sessionId ?? context.currentSessionId;
+                if (!sessionId)
+                    throw new Error("当前会话没有可归档的任务。请使用 /sessions 查找任务。");
+                await this.archiveSessionReference(contextKey, sessionId, {
+                    announce: true,
+                    source: "command",
+                });
+                return;
+            }
             case "status":
                 await this.status(contextKey, command.sessionId);
                 return;
@@ -719,6 +1125,9 @@ export class ProxySessionController {
                     throw new Error("当前运行方式不支持自动重启。");
                 await this.lifecycle.restart(contextKey, command.force === true, replyTarget);
                 return;
+            case "mute":
+                await this.setGroupMute(contextKey, command.enabled);
+                return;
             case "turns":
                 await this.openResetHistory(contextKey);
                 return;
@@ -752,6 +1161,8 @@ export class ProxySessionController {
             const turnContextKey = session.lastTurnId
                 ? this.store.getTurnContextKey(session.lastTurnId) ?? context.contextKey
                 : context.contextKey;
+            if (!this.outbound.canRoute(turnContextKey))
+                continue;
             this.outbound.registerSession(session.localSessionId, turnContextKey, session.title, session.cwd, this.agentLabel(session.agentName));
             if (!session.lastTurnId)
                 continue;
@@ -759,14 +1170,314 @@ export class ProxySessionController {
                 this.logger.warn({ error, sessionId: session.localSessionId }, "Failed to restore persisted turn delivery.");
             });
         }
+        for (const turn of this.store.listUndeliveredCompletedTurns()) {
+            const contextKey = turn.contextKey ?? this.store.getSession(turn.localSessionId)?.contextKey;
+            if (!contextKey || !this.outbound.canRoute(contextKey))
+                continue;
+            void this.outbound.resumeDelivery(turn.localSessionId, contextKey, turn.turnId).catch((error) => {
+                this.logger.warn({ error, sessionId: turn.localSessionId, turnId: turn.turnId }, "Failed to resume an undelivered completed turn.");
+            });
+        }
     }
     restorePersistedQueuedPrompts() {
+        if (this.queuedPromptsRestored)
+            return;
+        this.queuedPromptsRestored = true;
         for (const sessionId of this.store.listQueuedPromptSessionIds()) {
+            const firstPrompt = this.store.listQueuedPrompts(sessionId)[0];
+            if (firstPrompt && !this.outbound.canRoute(firstPrompt.contextKey))
+                continue;
             void this.scheduleNextQueuedPrompt(sessionId).catch((error) => {
                 this.logger.warn({ error, sessionId }, "Failed to resume a persisted prompt queue.");
             });
         }
     }
+    async recoverInterruptedTasks() {
+        if (this.startupRecovery)
+            return this.startupRecovery;
+        const recovery = this.runStartupRecovery();
+        this.startupRecovery = recovery;
+        return recovery;
+    }
+    async runStartupRecovery() {
+        this.backfillTurnAttemptsForUpgrade();
+        const attempts = this.store.listIncompleteTurnAttempts();
+        const recoveryCutoff = Date.now() - RECOVERY_ACTIVITY_WINDOW_MS;
+        const recentAttempts = attempts.filter((attempt) => isRecoveryAttemptRecent(attempt, recoveryCutoff));
+        if (recentAttempts.length > 0) {
+            this.logger.warn({ attemptIds: recentAttempts.map((attempt) => attempt.attemptId) }, "Recovering unfinished Agent Bot tasks after startup.");
+        }
+        for (const attempt of attempts) {
+            if (!isRecoveryAttemptRecent(attempt, recoveryCutoff)) {
+                await this.expireStaleTurnAttempt(attempt);
+                continue;
+            }
+            if (!this.outbound.canRoute(attempt.contextKey))
+                continue;
+            try {
+                await this.recoverTurnAttempt(attempt);
+            }
+            catch (error) {
+                this.logger.error({ error, attemptId: attempt.attemptId, sessionId: attempt.localSessionId }, "Failed to recover an unfinished task; it will be retried while the server is running.");
+                this.scheduleRecoveryRetry(attempt.attemptId);
+            }
+        }
+        this.restorePersistedQueuedPrompts();
+    }
+    backfillTurnAttemptsForUpgrade() {
+        for (const session of this.store.listAllSessions()) {
+            if (session.status !== "starting" && session.status !== "running" && session.status !== "ready")
+                continue;
+            if (this.store.findIncompleteTurnAttemptForSession(session.localSessionId))
+                continue;
+            const lastTurn = session.lastTurnId
+                ? {
+                    turnId: session.lastTurnId,
+                    localSessionId: session.localSessionId,
+                    contextKey: this.store.getTurnContextKey(session.lastTurnId),
+                    snapshot: this.store.getTurnSnapshot(session.lastTurnId),
+                    updatedAt: session.updatedAt,
+                }
+                : undefined;
+            const lastTurnSnapshot = turnViewSnapshot(lastTurn?.snapshot);
+            const latestPersisted = this.store.findLatestTurnSnapshotForSession(session.localSessionId);
+            const latestPersistedSnapshot = turnViewSnapshot(latestPersisted?.snapshot);
+            const latest = lastTurnSnapshot && !isTerminalTurnViewStatus(lastTurnSnapshot.status)
+                ? lastTurn
+                : latestPersistedSnapshot && !isTerminalTurnViewStatus(latestPersistedSnapshot.status)
+                    ? latestPersisted
+                    : session.status === "ready"
+                        ? undefined
+                        : lastTurn;
+            if (!latest && session.status === "ready")
+                continue;
+            const snapshot = turnViewSnapshot(latest?.snapshot);
+            if (snapshot && isTerminalTurnViewStatus(snapshot.status)) {
+                this.store.updateSession(session.localSessionId, {
+                    status: snapshot.status === "failed" ? "failed" : "ready",
+                });
+                continue;
+            }
+            const persistedTurnId = latest?.turnId;
+            const pendingTurnId = persistedTurnId?.startsWith("pending_") ? persistedTurnId : undefined;
+            const turnId = pendingTurnId ? undefined : persistedTurnId ?? session.lastTurnId;
+            const replyTarget = snapshot?.replyTarget?.replyInThread ? snapshot.replyTarget : undefined;
+            this.store.createTurnAttempt({
+                attemptId: createId("attempt"),
+                localSessionId: session.localSessionId,
+                contextKey: latest?.contextKey ?? session.contextKey,
+                promptText: snapshot?.prompt?.trim() || "继续完成重启前尚未完成的任务。",
+                messageId: turnId ? this.store.findMessageIdForTurn(turnId) : undefined,
+                replyMessageId: replyTarget?.messageId,
+                pendingTurnId,
+                turnId,
+                status: turnId ? "running" : "accepted",
+                createdAt: latest?.updatedAt ?? session.updatedAt,
+                updatedAt: latest?.updatedAt ?? session.updatedAt,
+            });
+        }
+    }
+    async expireStaleTurnAttempt(attempt) {
+        const session = this.store.getSession(attempt.localSessionId);
+        const oldCardTurnId = attempt.pendingTurnId ?? attempt.turnId;
+        if (session && oldCardTurnId && this.outbound.canRoute(attempt.contextKey)) {
+            await this.outbound.interruptTurnForRecovery(session.localSessionId, attempt.contextKey, oldCardTurnId, "执行中断已超过 5 分钟，未自动恢复。").catch((error) => {
+                this.logger.warn({ error, attemptId: attempt.attemptId, turnId: oldCardTurnId }, "Failed to close an expired interrupted thinking card.");
+            });
+        }
+        this.store.updateTurnAttempt(attempt.attemptId, { status: "interrupted" });
+        if (!session || session.status === "closed")
+            return;
+        if (attempt.turnId && session.lastTurnId === attempt.turnId) {
+            this.store.updateRuntimeSession(session.localSessionId, { lastTurnStatus: "cancelled" });
+        }
+        if (session.status === "starting" || session.status === "running") {
+            this.store.updateSession(session.localSessionId, { status: "ready" });
+        }
+        if (attempt.turnId && this.outbound.canRoute(attempt.contextKey)) {
+            await this.finalizeTurnMessageReactions(attempt.turnId, "cancelled").catch((error) => {
+                this.logger.warn({ error, attemptId: attempt.attemptId, turnId: attempt.turnId }, "Failed to finalize the message reaction for an expired interrupted turn.");
+            });
+        }
+    }
+    persistActiveTurnHeartbeats() {
+        for (const attempt of this.store.listIncompleteTurnAttempts()) {
+            if (!attempt.turnId)
+                continue;
+            const session = this.store.getSession(attempt.localSessionId);
+            if (!session)
+                continue;
+            const activeTurnId = this.runtimes.forAgent(session.agentName).getSession(session.localSessionId)?.activeTurnId;
+            if (activeTurnId === attempt.turnId)
+                this.store.touchTurnAttempt(attempt.turnId);
+        }
+    }
+    async recoverTurnAttempt(attempt, announce = true) {
+        const session = this.store.getSession(attempt.localSessionId);
+        if (!session || session.status === "closed") {
+            this.store.updateTurnAttempt(attempt.attemptId, { status: "interrupted" });
+            return;
+        }
+        const contextKey = attempt.contextKey || session.contextKey;
+        const replyTarget = attempt.replyMessageId
+            ? { messageId: attempt.replyMessageId, replyInThread: true }
+            : undefined;
+        this.outbound.registerSession(session.localSessionId, contextKey, session.title, session.cwd, this.agentLabel(session.agentName));
+        if (announce) {
+            await this.outbound.withReplyTarget(contextKey, replyTarget, () => this.outbound.sendText(contextKey, "检测到任务在 Agent Bot 重启前尚未完成，正在自动恢复。")).catch((error) => {
+                this.logger.warn({ error, attemptId: attempt.attemptId, contextKey }, "Failed to send the task recovery notification.");
+                return undefined;
+            });
+        }
+        const runtime = this.runtimes.forAgent(session.agentName);
+        const sourceTurnId = attempt.turnId;
+        if (runtime.kind === "acp") {
+            await this.continueInterruptedAttempt(attempt, session, sourceTurnId, replyTarget);
+            return;
+        }
+        let remote;
+        if (session.remoteSessionId && runtime.readRemoteSession) {
+            try {
+                remote = await runtime.readRemoteSession(session.remoteSessionId);
+            }
+            catch (error) {
+                this.logger.warn({ error, attemptId: attempt.attemptId, remoteSessionId: session.remoteSessionId }, "Failed to read the remote task during startup recovery; treating the old local execution as interrupted.");
+            }
+        }
+        const remoteTurnBelongsToAttempt = remoteTurnMatchesAttempt(remote, attempt);
+        if (remote && remoteTurnBelongsToAttempt && remote.lastTurnStatus === "completed") {
+            await this.reconcileRecoveredRemoteTurn(attempt, session, remote.lastTurnId);
+            return;
+        }
+        if (remote && remoteTurnBelongsToAttempt && remote.lastTurnStatus === "failed") {
+            await this.reconcileRecoveredRemoteTurn(attempt, session, remote.lastTurnId);
+            return;
+        }
+        if (remote && remoteTurnBelongsToAttempt && isRemoteSessionActive(remote) && remote.lastTurnId) {
+            await this.reattachActiveRecoveredTurn(attempt, session, remote.lastTurnId, replyTarget);
+            return;
+        }
+        if (remote && isRemoteSessionActive(remote) && !remoteTurnBelongsToAttempt) {
+            this.store.updateTurnAttempt(attempt.attemptId, { status: "recovering" });
+            if (announce) {
+                await this.outbound.withReplyTarget(contextKey, replyTarget, () => this.outbound.sendText(contextKey, "任务中检测到另一轮仍在执行；本次恢复将在它结束后重试。"));
+            }
+            this.scheduleRecoveryRetry(attempt.attemptId);
+            return;
+        }
+        await this.continueInterruptedAttempt(attempt, session, sourceTurnId, replyTarget);
+    }
+    async reconcileRecoveredRemoteTurn(attempt, session, remoteTurnId) {
+        if (remoteTurnId && !attempt.turnId) {
+            this.store.updateTurnAttempt(attempt.attemptId, { turnId: remoteTurnId, status: "running" });
+            this.store.updateRuntimeSession(session.localSessionId, {
+                lastTurnId: remoteTurnId,
+                lastTurnStatus: "running",
+            });
+        }
+        const current = this.store.getSession(session.localSessionId) ?? session;
+        const loaded = await this.loadSession({
+            ...current,
+            contextKey: attempt.contextKey,
+            status: "running",
+            lastTurnStatus: "running",
+        });
+        const synchronized = await loaded.runtime.synchronizeSession(session.localSessionId);
+        if (synchronized.activeTurnId)
+            this.scheduleRecoveryRetry(attempt.attemptId, synchronized.activeTurnId);
+    }
+    scheduleRecoveryRetry(attemptId, activeTurnId) {
+        if (this.recoveryRetryTimers.has(attemptId))
+            return;
+        const timer = setTimeout(() => {
+            this.recoveryRetryTimers.delete(attemptId);
+            const attempt = this.store.getTurnAttempt(attemptId);
+            if (!attempt || !isIncompleteTurnAttemptStatus(attempt.status))
+                return;
+            const retry = async () => {
+                let recoveryAttempt = attempt;
+                if (activeTurnId) {
+                    const session = this.store.getSession(attempt.localSessionId);
+                    if (session) {
+                        const runtime = this.runtimes.forAgent(session.agentName);
+                        const synchronized = await runtime.synchronizeSession(session.localSessionId);
+                        if (synchronized.activeTurnId === activeTurnId) {
+                            this.scheduleRecoveryRetry(attemptId, activeTurnId);
+                            return;
+                        }
+                        const current = this.store.getTurnAttempt(attemptId);
+                        if (!current || !isIncompleteTurnAttemptStatus(current.status))
+                            return;
+                        recoveryAttempt = current;
+                    }
+                }
+                await this.recoverTurnAttempt(recoveryAttempt, false);
+            };
+            void retry().catch((error) => {
+                this.logger.warn({ error, attemptId, sessionId: attempt.localSessionId }, "Failed to retry an unfinished task recovery.");
+                this.scheduleRecoveryRetry(attemptId, activeTurnId);
+            });
+        }, 5_000);
+        timer.unref?.();
+        this.recoveryRetryTimers.set(attemptId, timer);
+    }
+    async reattachActiveRecoveredTurn(attempt, session, turnId, replyTarget) {
+        const oldCardTurnId = attempt.pendingTurnId ?? attempt.turnId;
+        if (oldCardTurnId) {
+            await this.outbound.interruptTurnForRecovery(session.localSessionId, attempt.contextKey, oldCardTurnId, "Agent Bot 已重启，执行仍在继续；进度已转移到新的思考卡片。");
+        }
+        const pendingTurnId = await this.outbound.startPendingTurn(session.localSessionId, attempt.contextKey, session.title, replyTarget, recoveryCardPrompt(attempt.promptText));
+        this.store.updateTurnAttempt(attempt.attemptId, {
+            pendingTurnId: pendingTurnId ?? null,
+            turnId,
+            status: "running",
+        });
+        await this.outbound.onEvent({
+            type: "turn_started",
+            sessionId: session.localSessionId,
+            turnId,
+            startedAt: Date.now(),
+        });
+        this.store.updateTurnAttempt(attempt.attemptId, { pendingTurnId: null });
+        const current = this.store.getSession(session.localSessionId) ?? session;
+        const loaded = await this.loadSession({
+            ...current,
+            contextKey: attempt.contextKey,
+            status: "running",
+            lastTurnId: turnId,
+            lastTurnStatus: "running",
+        });
+        const synchronized = await loaded.runtime.synchronizeSession(session.localSessionId);
+        if (synchronized.activeTurnId)
+            this.scheduleRecoveryRetry(attempt.attemptId, synchronized.activeTurnId);
+    }
+    async continueInterruptedAttempt(attempt, session, sourceTurnId, replyTarget) {
+        const oldCardTurnId = attempt.pendingTurnId ?? sourceTurnId;
+        if (oldCardTurnId) {
+            await this.outbound.interruptTurnForRecovery(session.localSessionId, attempt.contextKey, oldCardTurnId, "Agent Bot 重启中断了这次执行，正在新的思考卡片中继续。").catch((error) => {
+                this.logger.warn({ error, attemptId: attempt.attemptId, turnId: oldCardTurnId }, "Failed to close the interrupted thinking card before recovery.");
+            });
+        }
+        this.store.prepareTurnAttemptRecovery(attempt.attemptId, oldCardTurnId);
+        this.store.updateSession(session.localSessionId, { status: "ready" });
+        if (sourceTurnId) {
+            this.store.updateRuntimeSession(session.localSessionId, {
+                lastTurnId: sourceTurnId,
+                lastTurnStatus: "cancelled",
+            });
+        }
+        const current = this.store.getSession(session.localSessionId) ?? session;
+        const loaded = await this.loadSession({ ...current, contextKey: attempt.contextKey });
+        const recoveryText = recoveryRuntimePrompt(attempt.promptText);
+        const turnId = await this.startTurn(loaded, recoveryText, replyTarget, attempt.localImagePaths, {
+            attemptId: attempt.attemptId,
+            messageId: attempt.messageId,
+            displayPrompt: recoveryCardPrompt(attempt.promptText),
+            preserveAttemptOnFailure: true,
+        });
+        if (attempt.messageId)
+            await this.bindMessageReactionToTurn(attempt.messageId, session.localSessionId, turnId);
+    }
     async restorePersistedMessageReactions() {
         const pending = this.store.listPendingMessageReactions();
         const terminalTurns = new Map();
@@ -795,6 +1506,19 @@ export class ProxySessionController {
         await this.promptSession(record, contextKey, text, messageId, replyTarget, localImagePaths);
     }
     async promptSession(record, contextKey, text, messageId, replyTarget, localImagePaths) {
+        if (this.llmRetryingSessions.has(record.localSessionId)) {
+            const queued = this.persistQueuedPrompt(record.localSessionId, contextKey, text, {
+                localImagePaths,
+                messageId,
+                replyTarget,
+            });
+            this.store.audit(contextKey, "queued_prompt_added_during_llm_retry", {
+                promptId: queued.promptId,
+                localSessionId: record.localSessionId,
+            });
+            await this.presentPromptQueueCard(record.localSessionId, contextKey);
+            return;
+        }
         const configuredRuntime = this.runtimes.forAgent(record.agentName);
         if (!configuredRuntime.getSession(record.localSessionId)) {
             this.outbound.registerSession(record.localSessionId, contextKey, record.title, record.cwd, this.agentLabel(record.agentName));
@@ -852,7 +1576,7 @@ export class ProxySessionController {
                     this.logger.warn({ error: syncError, sessionId: record.localSessionId }, "Failed to synchronize after steering failure.");
                 }
                 if (!current?.activeTurnId) {
-                    const turnId = await this.startTurn(loaded, text, replyTarget, localImagePaths);
+                    const turnId = await this.startTurn(loaded, text, replyTarget, localImagePaths, { messageId });
                     if (messageId)
                         await this.bindMessageReactionToTurn(messageId, record.localSessionId, turnId);
                     return;
@@ -877,11 +1601,12 @@ export class ProxySessionController {
                 return;
             }
         }
-        const turnId = await this.startTurn(loaded, text, replyTarget, localImagePaths);
+        const turnId = await this.startTurn(loaded, text, replyTarget, localImagePaths, { messageId });
         if (messageId)
             await this.bindMessageReactionToTurn(messageId, record.localSessionId, turnId);
     }
     async presentSteerMessage(localSessionId, turnId, text, messageId) {
+        this.store.touchTurnAttempt(turnId);
         try {
             await this.outbound.appendSteerMessage(localSessionId, turnId, text, messageId);
         }
@@ -992,6 +1717,10 @@ export class ProxySessionController {
         const current = this.store.getUserContext(message.contextKey)?.currentSessionId;
         if (current && this.store.getSession(current))
             return;
+        const hasPersistedSourceTurn = threadForkAnchorMessageIds(message)
+            .some((messageId) => this.store.findTurnAnchorByMessageId(messageId) !== undefined);
+        if (!hasPersistedSourceTurn)
+            return;
         const existing = this.threadInitializations.get(message.contextKey);
         if (existing)
             return existing;
@@ -1074,9 +1803,7 @@ export class ProxySessionController {
         if (!message.threadContext || !message.threadId || !message.chatId) {
             throw new Error("当前消息不属于可识别的飞书话题。");
         }
-        const anchorMessageIds = [message.rootMessageId, message.parentMessageId]
-            .filter((messageId) => Boolean(messageId && messageId !== message.messageId));
-        const anchor = [...new Set(anchorMessageIds)]
+        const anchor = threadForkAnchorMessageIds(message)
             .map((messageId) => this.store.findTurnAnchorByMessageId(messageId))
             .find((candidate) => candidate !== undefined);
         if (!anchor) {
@@ -1381,22 +2108,51 @@ export class ProxySessionController {
             executionSettings,
         };
     }
-    async startTurn(loaded, text, replyTarget, localImagePaths) {
+    async startTurn(loaded, text, replyTarget, localImagePaths, options = {}) {
         const currentRecord = this.store.getSession(loaded.record.localSessionId);
         const title = currentRecord?.title ?? normalizeTaskTitle(text);
         if (!currentRecord?.title && title)
             this.store.updateRuntimeSession(loaded.record.localSessionId, { title });
         if (title)
             this.outbound.updateSessionTitle(loaded.record.localSessionId, title);
-        await this.outbound.startPendingTurn(loaded.record.localSessionId, loaded.record.contextKey, title, replyTarget, text);
+        const attemptId = options.attemptId ?? createId("attempt");
+        if (options.attemptId) {
+            this.store.updateTurnAttempt(attemptId, {
+                messageId: options.messageId ?? undefined,
+                replyMessageId: replyTarget?.messageId ?? undefined,
+                status: "recovering",
+            });
+        }
+        else {
+            this.store.createTurnAttempt({
+                attemptId,
+                localSessionId: loaded.record.localSessionId,
+                contextKey: loaded.record.contextKey,
+                promptText: text,
+                localImagePaths,
+                messageId: options.messageId,
+                replyMessageId: replyTarget?.messageId,
+            });
+        }
         let turnId;
         try {
+            const pendingTurnId = await this.outbound.startPendingTurn(loaded.record.localSessionId, loaded.record.contextKey, title, replyTarget, options.displayPrompt ?? text);
+            this.store.updateTurnAttempt(attemptId, { pendingTurnId: pendingTurnId ?? null });
             turnId = await loaded.runtime.startTurn(loaded.record.localSessionId, runtimePrompt(text, localImagePaths));
         }
         catch (error) {
+            this.store.updateTurnAttempt(attemptId, {
+                status: options.preserveAttemptOnFailure ? "recovering" : "failed",
+            });
             await this.outbound.failPendingTurn(loaded.record.localSessionId, error instanceof Error ? error.message : String(error));
             throw error;
         }
+        const attempt = this.store.getTurnAttempt(attemptId);
+        this.store.updateTurnAttempt(attemptId, {
+            pendingTurnId: null,
+            turnId,
+            ...(attempt && isIncompleteTurnAttemptStatus(attempt.status) ? { status: "running" } : {}),
+        });
         const latest = this.store.getSession(loaded.record.localSessionId);
         const alreadyTerminal = latest?.lastTurnId === turnId
             && ["completed", "cancelled", "failed"].includes(latest.lastTurnStatus ?? "");
@@ -1665,14 +2421,34 @@ export class ProxySessionController {
     }
     async handleRuntimeEvent(event) {
         if ("turnId" in event) {
+            this.store.touchTurnAttempt(event.turnId);
             const source = this.store.getSession(event.sessionId);
             if (source?.remoteSessionId && this.isCodexSession(source)) {
                 this.store.saveTurnRuntimeOrigin(event.turnId, source.localSessionId, source.agentName, source.remoteSessionId);
             }
             if (event.type === "turn_started") {
+                const attempt = this.store.bindTurnAttempt(event.sessionId, event.turnId);
+                if (attempt?.recoveredFromTurnId && attempt.recoveredFromTurnId !== event.turnId) {
+                    this.store.rebindPendingTurnMessages(event.sessionId, attempt.recoveredFromTurnId, event.turnId);
+                }
                 this.store.saveTurnParent(event.turnId, event.sessionId, this.completedParentTurnId(source));
             }
         }
+        const failedAttempt = event.type === "turn_failed"
+            ? this.store.findIncompleteTurnAttemptByTurnId(event.turnId)
+            : undefined;
+        if (event.type === "turn_failed") {
+            if (this.retriedFailureTurnIds.has(event.turnId))
+                return;
+            if (failedAttempt && isRetryableLlmTurnFailure(event.message) && failedAttempt.retryCount < MAX_LLM_TURN_RETRIES) {
+                const retryAttempt = this.store.prepareTurnAttemptRetry(failedAttempt.attemptId, event.turnId);
+                if (retryAttempt) {
+                    this.retriedFailureTurnIds.add(event.turnId);
+                    await this.retryFailedLlmTurn(event, retryAttempt);
+                    return;
+                }
+            }
+        }
         if (event.type === "session_metadata_updated") {
             this.store.updateRuntimeSession(event.sessionId, { title: event.title });
             this.outbound.updateSessionTitle(event.sessionId, event.title);
@@ -1683,14 +2459,23 @@ export class ProxySessionController {
             this.store.updateRuntimeSession(event.sessionId, { lastTurnId: event.turnId, lastTurnStatus: "running" });
         }
         else if (event.type === "turn_completed" || event.type === "turn_cancelled" || event.type === "turn_failed") {
+            this.store.markTurnAttemptTerminal(event.turnId, event.type === "turn_completed" ? "completed" : event.type === "turn_cancelled" ? "cancelled" : "failed");
             this.store.updateRuntimeSession(event.sessionId, {
                 lastTurnId: event.turnId,
                 lastTurnStatus: event.type === "turn_completed" ? "completed" : event.type === "turn_cancelled" ? "cancelled" : "failed",
             });
         }
+        const presentationEvent = event.type === "turn_failed"
+            && isRetryableLlmTurnFailure(event.message)
+            && (failedAttempt?.retryCount ?? 0) >= MAX_LLM_TURN_RETRIES
+            ? {
+                ...event,
+                message: `${event.message}\n\n已自动重试 ${MAX_LLM_TURN_RETRIES} 次，仍未成功。`,
+            }
+            : event;
         let presentationError;
         try {
-            await this.outbound.onEvent(event);
+            await this.outbound.onEvent(presentationEvent);
         }
         catch (error) {
             presentationError = error;
@@ -1719,6 +2504,61 @@ export class ProxySessionController {
         if (presentationError)
             throw presentationError;
     }
+    async retryFailedLlmTurn(event, attempt) {
+        const retryNumber = attempt.retryCount;
+        const session = this.store.getSession(event.sessionId);
+        if (!session || session.status === "closed") {
+            this.store.updateTurnAttempt(attempt.attemptId, { status: "failed" });
+            return;
+        }
+        this.llmRetryingSessions.add(session.localSessionId);
+        this.store.updateRuntimeSession(session.localSessionId, {
+            lastTurnId: event.turnId,
+            lastTurnStatus: "failed",
+        });
+        this.store.audit(attempt.contextKey, "llm_turn_retry_started", {
+            attemptId: attempt.attemptId,
+            failedTurnId: event.turnId,
+            retryNumber,
+            maxRetries: MAX_LLM_TURN_RETRIES,
+            error: event.message,
+        });
+        try {
+            await this.outbound.onEvent({
+                ...event,
+                message: `${event.message}\n\n检测到临时模型服务错误，正在自动重试（${retryNumber}/${MAX_LLM_TURN_RETRIES}）。`,
+            });
+        }
+        catch (error) {
+            this.logger.warn({ error, sessionId: session.localSessionId, turnId: event.turnId }, "Failed to finalize the failed thinking card before an LLM retry.");
+        }
+        const replyTarget = attempt.replyMessageId
+            ? { messageId: attempt.replyMessageId, replyInThread: true }
+            : undefined;
+        try {
+            const current = this.store.getSession(session.localSessionId) ?? session;
+            const loaded = await this.loadSession(current);
+            const retryTurnId = await this.startTurn(loaded, llmRetryRuntimePrompt(attempt.promptText, retryNumber), replyTarget, attempt.localImagePaths, {
+                attemptId: attempt.attemptId,
+                messageId: attempt.messageId,
+                displayPrompt: llmRetryCardPrompt(attempt.promptText, retryNumber),
+                preserveAttemptOnFailure: true,
+            });
+            this.store.rebindPendingTurnMessages(session.localSessionId, event.turnId, retryTurnId);
+        }
+        catch (error) {
+            this.store.updateTurnAttempt(attempt.attemptId, { status: "failed" });
+            this.store.updateSession(session.localSessionId, { status: "failed" });
+            await this.finalizeTurnMessageReactions(event.turnId, "failed").catch((reactionError) => {
+                this.logger.warn({ error: reactionError, sessionId: session.localSessionId, turnId: event.turnId }, "Failed to finalize reactions after an LLM retry could not start.");
+            });
+            this.logger.error({ error, sessionId: session.localSessionId, retryNumber }, "Failed to start an automatic LLM turn retry.");
+            await this.scheduleNextQueuedPrompt(session.localSessionId);
+        }
+        finally {
+            this.llmRetryingSessions.delete(session.localSessionId);
+        }
+    }
     scheduleNextQueuedPrompt(sessionId) {
         const previous = this.queuedPromptStarts.get(sessionId) ?? Promise.resolve();
         const next = previous.catch(() => undefined).then(() => this.startNextQueuedPromptIfIdle(sessionId));
@@ -1749,7 +2589,7 @@ export class ProxySessionController {
             const record = this.store.getSessionForContext(sessionId, prompt.contextKey) ?? baseRecord;
             loaded = { ...loaded, record };
             await this.refreshPromptQueueCards(sessionId);
-            const turnId = await this.startTurn(loaded, prompt.text, prompt.replyMessageId ? { messageId: prompt.replyMessageId, replyInThread: true } : undefined, prompt.localImagePaths);
+            const turnId = await this.startTurn(loaded, prompt.text, prompt.replyMessageId ? { messageId: prompt.replyMessageId, replyInThread: true } : undefined, prompt.localImagePaths, { messageId: prompt.messageId });
             if (prompt.messageId)
                 await this.bindMessageReactionToTurn(prompt.messageId, sessionId, turnId);
         }
@@ -1770,7 +2610,9 @@ export class ProxySessionController {
         if (source.lastTurnStatus === "completed")
             return source.lastTurnId;
         const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(source.lastTurnId));
-        return snapshot?.status === "completed" ? source.lastTurnId : undefined;
+        return snapshot?.status === "completed"
+            ? source.lastTurnId
+            : this.store.findLatestCompletedTurnId(source.localSessionId, source.contextKey);
     }
     async finalizeStandaloneMessageReaction(messageId, status) {
         const reaction = this.store.claimMessageReaction(messageId);
@@ -1886,15 +2728,19 @@ export class ProxySessionController {
         if (current.localSessionId !== sessionId) {
             throw new Error("这张思考卡片不属于当前任务。请先切换回对应任务，再点击 Reset。");
         }
+        await this.performSessionReset(contextKey, current, turnId, true);
+    }
+    async performSessionReset(contextKey, current, turnId, announce) {
         if (!current.remoteSessionId || !this.isCodexSession(current)) {
             throw new Error("当前任务不是可 Reset 的 App Server 任务。");
         }
         const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(turnId));
-        if (!snapshot || snapshot.sessionId !== sessionId || snapshot.status !== "completed") {
+        if (!snapshot || snapshot.sessionId !== current.localSessionId || snapshot.status !== "completed") {
             throw new Error("只能将当前任务 Reset 到已成功完成的轮次。");
         }
         if (current.lastTurnId === turnId && current.lastTurnStatus === "completed") {
-            await this.outbound.sendText(contextKey, "当前任务已经处于本轮完成后的对话状态，无需 Reset。");
+            if (announce)
+                await this.outbound.sendText(contextKey, "当前任务已经处于本轮完成后的对话状态，无需 Reset。");
             return;
         }
         const runtime = this.runtimes.forAgent(current.agentName);
@@ -1909,7 +2755,7 @@ export class ProxySessionController {
             throw new Error("当前任务仍在执行。请等待任务完成或先停止任务，再点击 Reset。");
         }
         const origin = this.store.getTurnRuntimeOrigin(turnId);
-        if (origin && (origin.localSessionId !== sessionId || origin.agentName !== current.agentName)) {
+        if (origin && (origin.localSessionId !== current.localSessionId || origin.agentName !== current.agentName)) {
             throw new Error("这张思考卡片与当前任务不匹配，已拒绝 Reset。");
         }
         const sourceRemoteSessionId = origin?.remoteSessionId ?? current.remoteSessionId;
@@ -1941,13 +2787,15 @@ export class ProxySessionController {
         });
         const targetSummary = truncateText((snapshot.prompt ?? snapshot.taskTitle ?? "未记录对话内容").replace(/\s+/g, " ").trim(), 100) || "未记录对话内容";
         const targetTime = snapshot.completedAt ?? snapshot.startedAt;
-        await this.outbound.sendText(contextKey, [
-            "已将当前任务重置到：",
-            targetSummary,
-            `完成时间：${targetTime === undefined ? "未知" : formatResetTurnTime(targetTime)}`,
-            `Turn ID：${turnId}`,
-            "后续对话将从该轮完成后的状态继续；本地文件没有回退。",
-        ].join("\n"));
+        if (announce) {
+            await this.outbound.sendText(contextKey, [
+                "已将当前任务重置到：",
+                targetSummary,
+                `完成时间：${targetTime === undefined ? "未知" : formatResetTurnTime(targetTime)}`,
+                `Turn ID：${turnId}`,
+                "后续对话将从该轮完成后的状态继续；本地文件没有回退。",
+            ].join("\n"));
+        }
     }
     async resolveApproval(action) {
         const sessionId = String(action.value.sessionId ?? "");
@@ -2497,6 +3345,165 @@ export class ProxySessionController {
             await this.outbound.sendInteractiveCard(contextKey, card);
         }
     }
+    async openDirectoryBrowser(contextKey, requestedDirectory, options = {}) {
+        if (requestedDirectory === WINDOWS_DRIVES_DIRECTORY) {
+            await this.openWindowsDriveBrowser(contextKey, options);
+            return;
+        }
+        const baseDirectory = this.currentSession(contextKey)?.cwd
+            ?? this.store.getUserContext(contextKey)?.boundProjectCwd
+            ?? this.config.defaults.cwd;
+        const directory = requestedDirectory === undefined
+            ? path.resolve(baseDirectory)
+            : resolveUserPath(requestedDirectory, baseDirectory);
+        await this.assertBrowsableDirectory(directory);
+        let directoryEntries;
+        try {
+            directoryEntries = await fs.readdir(directory, { withFileTypes: true });
+        }
+        catch (error) {
+            throw new Error(`无法读取目录 ${directory}：${runtimeErrorMessage(error)}`);
+        }
+        const entries = directoryEntries
+            .map((entry) => ({
+            name: entry.name,
+            path: path.join(directory, entry.name),
+            kind: directoryBrowserEntryKind(entry),
+        }))
+            .sort((left, right) => Number(right.kind === "directory") - Number(left.kind === "directory")
+            || left.name.localeCompare(right.name, undefined, { numeric: true, sensitivity: "base" }));
+        const parentDirectory = isWindowsDriveRoot(directory)
+            ? WINDOWS_DRIVES_DIRECTORY
+            : path.dirname(directory);
+        const parentEntries = parentDirectory === directory ? [] : [{
+                name: "..",
+                kind: "directory",
+                openAction: {
+                    text: "..",
+                    value: {
+                        action: "directory_open",
+                        directory: parentDirectory,
+                        contextKey,
+                    },
+                },
+            }];
+        const pageSize = DIRECTORY_PAGE_SIZE;
+        const requestedPage = Math.max(0, Math.trunc(options.page ?? 0));
+        const totalPages = Math.max(1, Math.ceil(entries.length / pageSize));
+        const page = Math.min(requestedPage, totalPages - 1);
+        const offset = page * pageSize;
+        const visibleEntries = [
+            ...parentEntries,
+            ...entries
+                .slice(offset, offset + pageSize)
+                .map((entry) => entry.kind === "directory"
+                ? {
+                    name: entry.name,
+                    kind: entry.kind,
+                    openAction: {
+                        text: entry.name,
+                        value: {
+                            action: "directory_open",
+                            directory: entry.path,
+                            contextKey,
+                        },
+                    },
+                    actions: directoryCreationActions(entry.path, contextKey),
+                }
+                : {
+                    name: entry.name,
+                    kind: entry.kind,
+                    openAction: {
+                        text: entry.name,
+                        value: {
+                            action: "directory_send_file",
+                            filePath: entry.path,
+                            contextKey,
+                        },
+                    },
+                }),
+        ];
+        const navigationActions = directoryPaginationActions(directory, page, totalPages, contextKey);
+        const directoryCount = entries.filter((entry) => entry.kind === "directory").length;
+        const card = this.cardRenderer.renderDirectoryBrowserCard({
+            directory: abbreviateHomeDirectory(directory),
+            entries: visibleEntries,
+            currentActions: directoryCreationActions(directory, contextKey),
+            navigationActions,
+            footerLines: [
+                `第 ${page + 1}/${totalPages} 页 · ${directoryCount} 个目录 · ${entries.length - directoryCount} 个文件`,
+                "",
+                "> 点击目录名称进入，点击文件名称发送到当前会话；**New** 在该目录创建任务，**NewGroup** 在该目录创建新群和任务。",
+            ],
+        });
+        if (options.updateMessageId) {
+            await this.outbound.updateInteractiveCard(contextKey, options.updateMessageId, card);
+        }
+        else {
+            await this.outbound.sendInteractiveCard(contextKey, card);
+        }
+    }
+    async openWindowsDriveBrowser(contextKey, options) {
+        const drives = await this.windowsDriveLister();
+        const requestedPage = Math.max(0, Math.trunc(options.page ?? 0));
+        const totalPages = Math.max(1, Math.ceil(drives.length / DIRECTORY_PAGE_SIZE));
+        const page = Math.min(requestedPage, totalPages - 1);
+        const offset = page * DIRECTORY_PAGE_SIZE;
+        const entries = drives
+            .slice(offset, offset + DIRECTORY_PAGE_SIZE)
+            .map((drive) => ({
+            name: windowsDriveDisplayName(drive),
+            kind: "drive",
+            openAction: {
+                text: windowsDriveDisplayName(drive),
+                value: {
+                    action: "directory_open",
+                    directory: drive.root,
+                    contextKey,
+                },
+            },
+            actions: directoryCreationActions(drive.root, contextKey),
+        }));
+        const card = this.cardRenderer.renderDirectoryBrowserCard({
+            directory: "此电脑",
+            entries,
+            currentActions: [],
+            navigationActions: directoryPaginationActions(WINDOWS_DRIVES_DIRECTORY, page, totalPages, contextKey),
+            footerLines: [
+                `第 ${page + 1}/${totalPages} 页 · ${drives.length} 个磁盘`,
+                "",
+                "> 点击磁盘名称进入；**New** 在磁盘根目录创建任务，**NewGroup** 在磁盘根目录创建新群和任务。",
+            ],
+        });
+        if (options.updateMessageId) {
+            await this.outbound.updateInteractiveCard(contextKey, options.updateMessageId, card);
+        }
+        else {
+            await this.outbound.sendInteractiveCard(contextKey, card);
+        }
+    }
+    async assertBrowsableDirectory(directory) {
+        let stats;
+        try {
+            stats = await fs.stat(directory);
+        }
+        catch (error) {
+            throw new Error(`目录不存在或无法访问：${directory}（${runtimeErrorMessage(error)}）`);
+        }
+        if (!stats.isDirectory())
+            throw new Error(`这不是目录：${directory}`);
+    }
+    async assertSendableFile(filePath) {
+        let stats;
+        try {
+            stats = await fs.stat(filePath);
+        }
+        catch (error) {
+            throw new Error(`文件不存在或无法访问：${filePath}（${runtimeErrorMessage(error)}）`);
+        }
+        if (!stats.isFile())
+            throw new Error(`这不是普通文件：${filePath}`);
+    }
     async listSessions(contextKey, searchTerm, options = {}) {
         const context = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent);
         const normalizedSearch = searchTerm?.trim().toLowerCase();
@@ -2522,23 +3529,28 @@ export class ProxySessionController {
         const remoteHint = remoteErrors.length > 0
             ? `部分 Agent 的任务读取失败：${remoteErrors.join("；")}`
             : undefined;
-        const entries = mergeTaskList(localSessions, remoteSessions, context.currentSessionId)
+        const entries = orderTaskListByProject(mergeTaskList(localSessions, remoteSessions, context.currentSessionId)
             .filter((entry) => !normalizedSearch
             || [entry.id, entry.title, entry.cwd, entry.agentName]
-                .some((value) => value.toLowerCase().includes(normalizedSearch)))
-            .sort((left, right) => Number(right.current) - Number(left.current)
-            || Number(right.active) - Number(left.active)
-            || right.updatedAt - left.updatedAt);
+                .some((value) => value.toLowerCase().includes(normalizedSearch))));
         const activeCount = entries.filter((entry) => entry.active).length;
         const lastKnownPage = Math.max(0, Math.ceil(entries.length / SESSION_PAGE_SIZE) - 1);
         const page = remoteHasMore ? requestedPage : Math.min(requestedPage, lastKnownPage);
         const offset = page * SESSION_PAGE_SIZE;
         const visibleEntries = entries.slice(offset, offset + SESSION_PAGE_SIZE);
+        const projectActionSources = new Map();
+        for (const entry of entries) {
+            const project = taskProjectInfo(entry);
+            if (!projectActionSources.has(project.key))
+                projectActionSources.set(project.key, entry);
+        }
         const hasPrevious = page > 0;
         const hasNext = remoteHasMore || entries.length > offset + SESSION_PAGE_SIZE;
         this.lastSessionListings.set(contextKey, entries.map((entry) => entry.reference));
         const cardEntries = visibleEntries.map((entry, index) => {
-            const marker = entry.current ? "✅" : entry.active ? "🟢 **活跃**" : "•";
+            const project = taskProjectInfo(entry);
+            const projectActionSource = projectActionSources.get(project.key) ?? entry;
+            const marker = entry.current ? "✅" : entry.active ? "🟢" : "•";
             const showStop = entry.status === "外部执行中"
                 && entry.reference !== options.forceSwitchTaskId
                 && entry.id !== options.forceSwitchTaskId;
@@ -2553,10 +3565,29 @@ export class ProxySessionController {
                         contextKey,
                     },
                 }];
+            const projectActions = [{
+                    text: "New",
+                    value: {
+                        action: "session_new",
+                        sessionId: projectActionSource.reference,
+                        ...(searchTerm ? { searchTerm } : {}),
+                        page: String(page),
+                        contextKey,
+                    },
+                }, {
+                    text: "NewGroup",
+                    value: {
+                        action: "session_new_group",
+                        sessionId: projectActionSource.reference,
+                        ...(searchTerm ? { searchTerm } : {}),
+                        page: String(page),
+                        contextKey,
+                    },
+                }];
             actions.push({
-                text: "New",
+                text: "Fork",
                 value: {
-                    action: "session_new",
+                    action: "session_fork",
                     sessionId: entry.reference,
                     ...(searchTerm ? { searchTerm } : {}),
                     page: String(page),
@@ -2564,9 +3595,9 @@ export class ProxySessionController {
                 },
             });
             actions.push({
-                text: "NewGroup",
+                text: "ForkGroup",
                 value: {
-                    action: "session_new_group",
+                    action: "session_fork_group",
                     sessionId: entry.reference,
                     ...(searchTerm ? { searchTerm } : {}),
                     page: String(page),
@@ -2574,47 +3605,62 @@ export class ProxySessionController {
                 },
             });
             actions.push({
-                text: "Fork",
+                text: "Status",
                 value: {
-                    action: "session_fork",
+                    action: "session_status",
                     sessionId: entry.reference,
-                    ...(searchTerm ? { searchTerm } : {}),
-                    page: String(page),
                     contextKey,
                 },
             });
             actions.push({
-                text: "ForkGroup",
+                text: "Archive",
                 value: {
-                    action: "session_fork_group",
+                    action: "session_archive",
                     sessionId: entry.reference,
                     ...(searchTerm ? { searchTerm } : {}),
                     page: String(page),
                     contextKey,
                 },
             });
-            actions.push({
-                text: "Status",
-                value: {
-                    action: "session_status",
-                    sessionId: entry.reference,
-                    contextKey,
-                },
-            });
+            const title = truncateText(entry.title.replace(/\s+/gu, " ").trim() || "未命名任务", 56);
             return {
-                lines: [
-                    `**${offset + index + 1}.**　${marker}　**${cardText(entry.title)}**　${cardText(entry.id)}`,
-                    `${entry.status} · ${entry.updatedLabel} · ${cardText(entry.agentName)} · ${cardText(entry.cwd || "目录未知")}`,
-                ],
-                actions,
+                project,
+                projectActions,
+                cardEntry: {
+                    reference: entry.reference,
+                    summary: `${offset + index + 1}. ${marker} ${title} · ${entry.agentName}`,
+                    detailLines: [
+                        `**状态 / 更新时间**：${cardText(entry.status)} / ${cardText(entry.updatedLabel)}`,
+                        `**Agent / 任务 ID**：${cardCode(entry.agentName)} / ${cardCode(entry.id)}`,
+                        `**目录**：${cardCode(entry.cwd || "目录未知")}`,
+                    ],
+                    actions,
+                    current: entry.current,
+                },
             };
         });
-        const card = this.cardRenderer.renderTaskListCard(searchTerm ? `App Server 任务：${searchTerm}` : "App Server 任务", activeCount > 0 ? `任务（${activeCount} 个活跃）` : "任务", cardEntries, [
+        const cardGroups = [];
+        let currentProjectKey;
+        for (const item of cardEntries) {
+            const currentGroup = cardGroups.at(-1);
+            if (currentGroup && currentProjectKey === item.project.key) {
+                currentGroup.entries.push(item.cardEntry);
+            }
+            else {
+                currentProjectKey = item.project.key;
+                cardGroups.push({
+                    title: item.project.title,
+                    entries: [item.cardEntry],
+                    actions: item.projectActions,
+                });
+            }
+        }
+        const card = this.cardRenderer.renderSessionTaskListCard(searchTerm ? `任务列表：${searchTerm}` : "任务列表", activeCount > 0 ? `任务（${activeCount} 个活跃）` : "任务", cardGroups, [
             ...(remoteHint ? [remoteHint] : []),
             `第 ${page + 1} 页 · 每页 ${SESSION_PAGE_SIZE} 个任务${hasNext ? "" : ` · 当前共 ${entries.length} 个任务`}`,
             "",
-            "> **Switch** 切换任务；**Stop** 停止运行；**Status** 查看状态。",
-            "> **New** / **Fork** 新建 / 分支任务；**NewGroup** / **ForkGroup** 新建 / 分支群。",
+            "> 项目行：**New** 新建任务，**NewGroup** 新建群。",
+            "> 任务详情：**Switch** 切换，**Stop** 停止，**Fork** / **ForkGroup** 创建分支，**Status** 查看状态，**Archive** 归档。",
         ], [
             ...(hasPrevious ? [{
                     text: "Previous",
@@ -2779,6 +3825,56 @@ export class ProxySessionController {
         });
         await this.outbound.sendText(contextKey, `已向 Agent 发送 Interrupt 请求：${turnId}`);
     }
+    async archiveSessionReference(contextKey, reference, options) {
+        const taskId = this.resolveSessionReference(contextKey, reference);
+        const direct = this.store.getSession(taskId);
+        if (direct?.status === "closed")
+            throw new Error(`任务已经归档：${direct.title ?? taskId}`);
+        const local = direct ?? this.findStoredSessionByReference(taskId);
+        if (local && (!local.remoteSessionId || !this.isCodexSession(local))) {
+            throw new Error("当前 Agent 不支持归档任务。");
+        }
+        if (local && (local.status === "running"
+            || Boolean(this.runtimes.forAgent(local.agentName).getSession(local.localSessionId)?.activeTurnId))) {
+            throw new Error("任务正在执行，无法归档。请先停止任务或等待本轮完成。");
+        }
+        if (local && this.store.countQueuedPrompts(local.localSessionId) > 0) {
+            throw new Error("任务仍有排队消息，无法归档。请先处理或取消排队消息。");
+        }
+        const remoteReference = local
+            ? remoteSessionReference(local.agentName, local.remoteSessionId)
+            : taskId;
+        const { agentName, runtime, remote } = await this.resolveRemoteCodexSession(remoteReference);
+        if (isRemoteSessionActive(remote)) {
+            throw new Error("任务正在执行，无法归档。请先停止任务或等待本轮完成。");
+        }
+        if (!runtime.archiveRemoteSession) {
+            throw new Error(`Agent ${agentName} 不支持归档任务。`);
+        }
+        const wasCurrent = Boolean(local && this.store.getUserContext(contextKey)?.currentSessionId === local.localSessionId);
+        await runtime.archiveRemoteSession(remote.id);
+        const title = local?.title ?? remote.title ?? remote.preview ?? remote.id;
+        if (local) {
+            this.store.archiveSession(local.localSessionId);
+            this.outbound.unregisterSession(local.localSessionId);
+        }
+        this.store.audit(contextKey, "session_archived", {
+            ...(local ? { localSessionId: local.localSessionId } : {}),
+            remoteSessionId: remote.id,
+            agentName,
+            source: options.source,
+        });
+        if (options.announce) {
+            await this.outbound.sendText(contextKey, wasCurrent
+                ? `已归档任务：${title}\n当前会话已没有绑定任务，直接发送消息即可创建新任务。`
+                : `已归档任务：${title}`);
+        }
+        return {
+            localSessionId: local?.localSessionId ?? "",
+            remoteSessionId: remote.id,
+            title,
+        };
+    }
     resolveSessionReference(contextKey, reference) {
         if (reference === undefined) {
             const previous = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent).previousSessionId;
@@ -3067,6 +4163,37 @@ export class ProxySessionController {
             "**[参数]** 可选　**&#60;参数&#62;** 必填",
         ], sections));
     }
+    async setGroupMute(contextKey, enabled) {
+        const chatContextKey = baseChatContextKey(contextKey);
+        const chat = this.store.getChatContext(chatContextKey);
+        if (chat?.chatType !== "group") {
+            throw new Error("/mute 仅适用于群聊。");
+        }
+        this.store.setChatRequiresMention(chatContextKey, enabled);
+        await this.outbound.sendText(contextKey, enabled
+            ? "已开启当前群的静音模式。之后只有 @ 机器人的消息会被处理；发送 @机器人 /mute off 可恢复自动响应。"
+            : "已关闭当前群的静音模式。机器人将恢复自动响应群消息。");
+    }
+    requireControlSession(localSessionId) {
+        const record = this.store.getSession(localSessionId);
+        if (!record || record.status === "closed")
+            throw new Error(`Task not found: ${localSessionId}`);
+        return record;
+    }
+    controlSessionContextKey(record) {
+        return this.outbound.getSessionContextKey(record.localSessionId)
+            ?? (record.lastTurnId ? this.store.getTurnContextKey(record.lastTurnId) : undefined)
+            ?? record.contextKey;
+    }
+    controlSessionReplyTarget(record) {
+        const routed = this.outbound.getSessionReplyTarget(record.localSessionId);
+        if (routed)
+            return routed;
+        const snapshot = record.lastTurnId
+            ? turnViewSnapshot(this.store.getTurnSnapshot(record.lastTurnId))
+            : undefined;
+        return snapshot?.replyTarget;
+    }
     ensureAgent(agentName) {
         const agent = this.config.agents[agentName];
         if (!agent)
@@ -3127,6 +4254,10 @@ export class ProxySessionController {
         await this.outbound.sendText(contextKey, error instanceof Error ? error.message : String(error));
     }
 }
+function threadForkAnchorMessageIds(message) {
+    return [...new Set([message.rootMessageId, message.parentMessageId]
+            .filter((messageId) => Boolean(messageId && messageId !== message.messageId)))];
+}
 function sessionStatusLabel(status, activeTurnId) {
     if (activeTurnId || status === "running")
         return "执行中";
@@ -3157,6 +4288,50 @@ function statusRefreshAction(sessionId, contextKey) {
         },
     };
 }
+function orderTaskListByProject(entries) {
+    const groups = new Map();
+    for (const entry of entries) {
+        const project = taskProjectInfo(entry);
+        const group = groups.get(project.key);
+        if (group)
+            group.entries.push(entry);
+        else
+            groups.set(project.key, { project, entries: [entry] });
+    }
+    const orderedGroups = [...groups.values()]
+        .map((group) => ({
+        ...group,
+        current: group.entries.some((entry) => entry.current),
+        active: group.entries.some((entry) => entry.active),
+        updatedAt: Math.max(...group.entries.map((entry) => entry.updatedAt)),
+    }))
+        .sort((left, right) => Number(right.current) - Number(left.current)
+        || Number(right.active) - Number(left.active)
+        || right.updatedAt - left.updatedAt
+        || left.project.title.localeCompare(right.project.title, undefined, { sensitivity: "base" }));
+    return orderedGroups.flatMap((group) => group.entries.sort(compareTaskListEntries));
+}
+function compareTaskListEntries(left, right) {
+    return Number(right.current) - Number(left.current)
+        || Number(right.active) - Number(left.active)
+        || right.updatedAt - left.updatedAt
+        || left.title.localeCompare(right.title, undefined, { sensitivity: "base" });
+}
+function taskProjectInfo(entry) {
+    if (!entry.cwd)
+        return { key: "unknown", title: "📁 目录未知" };
+    if (detectProjectlessWorkspace(entry.cwd)) {
+        return { key: "projectless", title: "🗒️ 未指定项目" };
+    }
+    const windowsPath = isWindowsAbsolutePath(entry.cwd);
+    const normalized = windowsPath
+        ? path.win32.normalize(entry.cwd).toLowerCase()
+        : path.resolve(entry.cwd);
+    return {
+        key: `cwd:${normalized}`,
+        title: `📁 ${abbreviateHomeDirectory(entry.cwd)}`,
+    };
+}
 function mergeTaskList(localSessions, remoteSessions, currentLocalSessionId) {
     const localByRemoteId = new Map(localSessions
         .filter((session) => session.runtimeKind === "codex" && session.remoteSessionId)
@@ -3246,6 +4421,12 @@ function turnViewSnapshot(value) {
         ? candidate
         : undefined;
 }
+function isTerminalTurnViewStatus(status) {
+    return status === "completed" || status === "cancelled" || status === "failed";
+}
+function isIncompleteTurnAttemptStatus(status) {
+    return status === "accepted" || status === "running" || status === "recovering";
+}
 function executionDetailLines(record, snapshot, remote, activeTurnId, queued) {
     const remoteActive = isRemoteSessionActive(remote);
     const turnId = remoteActive
@@ -3519,7 +4700,7 @@ function isBotOwnedActiveTurn(record, remote) {
         && record.lastTurnId === remote.lastTurnId;
 }
 function isQueueIndependentCommand(command) {
-    if (["stop", "status", "restart", "help", "sessions", "goal", "nosteer"].includes(command.type))
+    if (["archive", "stop", "status", "restart", "mute", "help", "sessions", "dir", "goal", "nosteer"].includes(command.type))
         return true;
     if (command.type === "agent")
         return command.agent === undefined;
@@ -3531,12 +4712,200 @@ function parseSessionPage(value) {
     const parsed = typeof value === "string" || typeof value === "number" ? Number(value) : Number.NaN;
     return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : 0;
 }
+function directoryPageValue(value) {
+    const page = Number(value);
+    if (!Number.isSafeInteger(page) || page < 0)
+        throw new Error("文件浏览卡片页码无效，请重新发送 /dir。");
+    return page;
+}
+function isWindowsDriveRoot(directory) {
+    return /^[a-z]:\\$/iu.test(path.win32.normalize(directory));
+}
+function directoryBrowserEntryKind(entry) {
+    if (entry.isDirectory())
+        return "directory";
+    const extension = path.extname(entry.name).toLowerCase();
+    if (IMAGE_FILE_EXTENSIONS.has(extension))
+        return "image";
+    if (BINARY_FILE_EXTENSIONS.has(extension))
+        return "binary";
+    return "file";
+}
+function directoryActionPath(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error("文件浏览卡片中的目录无效，请重新发送 /dir。");
+    }
+    return value === WINDOWS_DRIVES_DIRECTORY ? value : path.resolve(value);
+}
+function directoryFileActionPath(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error("文件浏览卡片中的文件无效，请重新发送 /dir。");
+    }
+    return path.resolve(value);
+}
+function directoryCreationActions(directory, contextKey) {
+    return [
+        {
+            text: "New",
+            value: {
+                action: "directory_new",
+                directory,
+                contextKey,
+            },
+        },
+        {
+            text: "NewGroup",
+            value: {
+                action: "directory_new_group",
+                directory,
+                contextKey,
+            },
+        },
+    ];
+}
+function directoryPaginationActions(directory, page, totalPages, contextKey) {
+    return [
+        ...(page > 0 ? [{
+                text: "Previous",
+                value: {
+                    action: "directory_page",
+                    directory,
+                    page: String(page - 1),
+                    contextKey,
+                },
+            }] : []),
+        ...(page < totalPages - 1 ? [{
+                text: "Next",
+                value: {
+                    action: "directory_page",
+                    directory,
+                    page: String(page + 1),
+                    contextKey,
+                },
+            }] : []),
+    ];
+}
+function windowsDriveDisplayName(drive) {
+    const driveLetter = drive.root.slice(0, 2).toUpperCase();
+    const label = drive.label?.trim() || windowsDriveTypeLabel(drive.driveType);
+    return `${label} (${driveLetter})`;
+}
+function windowsDriveTypeLabel(driveType) {
+    switch (driveType?.toLowerCase()) {
+        case "fixed": return "本地磁盘";
+        case "network": return "网络驱动器";
+        case "removable": return "可移动磁盘";
+        case "cdrom": return "光驱";
+        case "ram": return "RAM 磁盘";
+        default: return "磁盘";
+    }
+}
+async function listWindowsDriveRoots() {
+    if (process.platform !== "win32")
+        throw new Error("磁盘列表仅在 Windows 上可用。");
+    const result = await executeShellCommand("$drives = @([System.IO.DriveInfo]::GetDrives() | ForEach-Object { $label = ''; if ($_.IsReady) { try { $label = $_.VolumeLabel } catch {} }; [PSCustomObject]@{ root = $_.Name; label = $label; driveType = $_.DriveType.ToString() } }); ConvertTo-Json -Compress -InputObject $drives", os.homedir(), { timeoutMs: 10_000, maxOutputBytes: 16 * 1024, platform: "win32" });
+    if (result.timedOut || result.exitCode !== 0) {
+        const detail = result.stderr.trim() || `退出码 ${result.exitCode ?? "未知"}`;
+        throw new Error(`无法读取 Windows 磁盘列表：${detail}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout.trim().replace(/^\uFEFF/u, ""));
+    }
+    catch (error) {
+        throw new Error(`无法解析 Windows 磁盘列表：${runtimeErrorMessage(error)}`);
+    }
+    const values = Array.isArray(parsed) ? parsed : [parsed];
+    const drives = values.flatMap((value) => {
+        if (typeof value !== "object" || value === null)
+            return [];
+        const record = value;
+        if (typeof record.root !== "string")
+            return [];
+        const root = path.win32.normalize(record.root.trim());
+        if (!isWindowsDriveRoot(root))
+            return [];
+        return [{
+                root,
+                ...(typeof record.label === "string" && record.label.trim() ? { label: record.label.trim() } : {}),
+                ...(typeof record.driveType === "string" ? { driveType: record.driveType } : {}),
+            }];
+    }).sort((left, right) => left.root.localeCompare(right.root, undefined, { sensitivity: "base" }));
+    if (drives.length === 0)
+        throw new Error("没有检测到可用的 Windows 磁盘。");
+    return drives;
+}
 function isPromptCommand(command) {
     return command.type === "prompt" || command.type === "nosteer";
 }
 function runtimePrompt(text, localImagePaths) {
     return localImagePaths?.length ? { text, localImagePaths } : text;
 }
+function recoveryCardPrompt(prompt) {
+    return `恢复重启前的任务：${prompt}`;
+}
+function recoveryRuntimePrompt(prompt) {
+    return [
+        "Agent Bot restarted while the previous turn was still running.",
+        "Continue the unfinished task in the current task and workspace.",
+        "Inspect the existing conversation, files, and completed tool effects first. Do not repeat completed or irreversible actions.",
+        "Finish the original request:",
+        "",
+        prompt,
+    ].join("\n");
+}
+function llmRetryCardPrompt(prompt, retryNumber) {
+    return `自动重试 ${retryNumber}/${MAX_LLM_TURN_RETRIES}：${prompt}`;
+}
+function llmRetryRuntimePrompt(prompt, retryNumber) {
+    return [
+        `Agent Bot is automatically retrying this request after a transient LLM service failure (${retryNumber}/${MAX_LLM_TURN_RETRIES}).`,
+        "Continue in the current task and workspace. Inspect the conversation, files, and completed tool effects before acting.",
+        "Do not repeat completed or irreversible actions. Finish the original request:",
+        "",
+        prompt,
+    ].join("\n");
+}
+function isRetryableLlmTurnFailure(message) {
+    const normalized = message.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    const permanentFailure = [
+        /auth(?:entication|orization)?\b|unauthorized|forbidden|invalid api key|incorrect api key/u,
+        /insufficient[_ -]?quota|quota (?:exceeded|exhausted)|usage limit|billing|credit balance/u,
+        /context (?:length|window)|maximum context|too many tokens|token limit/u,
+        /invalid request|bad request|invalid argument|malformed|unsupported|not supported/u,
+        /model (?:not found|does not exist)|unknown model/u,
+        /permission|approval|sandbox|policy violation|content policy/u,
+    ].some((pattern) => pattern.test(normalized));
+    if (permanentFailure)
+        return false;
+    return [
+        /(?:^|\D)429(?:\D|$)|rate[_ -]?limit|too many requests/u,
+        /overload|high demand|at capacity|capacity limit|temporar(?:y|ily) unavailable/u,
+        /service unavailable|internal server error|bad gateway|gateway timeout/u,
+        /(?:^|\D)(?:500|502|503|504)(?:\D|$)|upstream (?:error|failure|timeout)/u,
+        /deadline exceeded|request timed out|request timeout|response timeout/u,
+        /connection (?:reset|closed|aborted)|network error|socket hang up/u,
+        /stream (?:closed|disconnected|interrupted|error)/u,
+        /\b(?:llm|model|provider|inference)\b.*\b(?:error|failed|failure|unavailable|timeout|timed out)\b/u,
+    ].some((pattern) => pattern.test(normalized));
+}
+function remoteTurnMatchesAttempt(remote, attempt) {
+    if (!remote?.lastTurnId)
+        return false;
+    if (attempt.turnId)
+        return remote.lastTurnId === attempt.turnId;
+    const remoteUpdatedAt = remote.updatedAt === undefined ? undefined : normalizeRemoteTimestamp(remote.updatedAt);
+    const acceptedAt = Date.parse(attempt.createdAt);
+    return remoteUpdatedAt !== undefined
+        && Number.isFinite(acceptedAt)
+        && remoteUpdatedAt >= acceptedAt - 1_000;
+}
+function isRecoveryAttemptRecent(attempt, cutoff) {
+    const updatedAt = Date.parse(attempt.updatedAt);
+    return Number.isFinite(updatedAt) && updatedAt >= cutoff;
+}
 function formatGroupDateSuffix(date) {
     const month = String(date.getMonth() + 1).padStart(2, "0");
     const day = String(date.getDate()).padStart(2, "0");
@@ -3567,12 +4936,21 @@ function formatGroupProjectDirectory(projectCwd) {
     return `[${fitTrailingPathLevels(levels, GROUP_PROJECT_DIRECTORY_MAX_LENGTH, path.sep)}]`;
 }
 function abbreviateHomeDirectory(value) {
-    const relative = path.relative(os.homedir(), value);
+    const homeDirectory = os.homedir();
+    const valueIsWindows = isWindowsAbsolutePath(value);
+    const homeIsWindows = isWindowsAbsolutePath(homeDirectory);
+    if (valueIsWindows !== homeIsWindows && (valueIsWindows || path.posix.isAbsolute(value)))
+        return value;
+    const pathApi = valueIsWindows ? path.win32 : path;
+    const relative = pathApi.relative(homeDirectory, value);
     if (relative === "")
         return "~";
-    if (path.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path.sep}`))
+    if (pathApi.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${pathApi.sep}`))
         return value;
-    return `~${path.sep}${relative}`;
+    return `~${pathApi.sep}${relative}`;
+}
+function isWindowsAbsolutePath(value) {
+    return /^[a-z]:[\\/]|^\\\\/iu.test(value);
 }
 function fitTrailingPathLevels(levels, maxLength, separator) {
     if (levels.length === 0)