@keyou007/agent-bot 0.1.14-alpha.1 → 0.1.14-alpha.3

package/dist/proxy/ProxySessionController.js

@@ -71,6 +71,12 @@ const HELP_COMMAND_SECTIONS = [
                 requiresArgument: true,
             },
             { command: "/sessions", usage: "[关键词]", description: "查找本机任务" },
+            {
+                command: "/archive",
+                usage: "[序号或任务 ID]",
+                description: "归档当前或指定任务",
+            },
+            { command: "/dismiss", description: "归档当前任务并解散当前群" },
             {
                 command: "/switch",
                 usage: "[序号或任务 ID]",
@@ -268,7 +274,7 @@ export class ProxySessionController {
         if (isQueueIndependentCommand(command)) {
             await this.outbound.withReplyTarget(message.contextKey, replyTarget, async () => {
                 try {
-                    if (command.type !== "forkgroup")
+                    if (command.type !== "forkgroup" && command.type !== "dismiss")
                         await this.ensureThreadFork(message);
                     await this.execute(message.contextKey, command, message.messageId, replyTarget, localImagePaths, message.userId, message);
                     if (!isPromptCommand(command))
@@ -413,6 +419,22 @@ 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 === "group_dismiss_keep") {
+                    this.assertDismissGroupRequester(scopedAction);
+                    await this.outbound.updateInteractiveCard(contextKey, requiredCardMessageId(scopedAction.messageId), this.cardRenderer.renderDismissGroupKept());
+                }
+                else if (kind === "group_dismiss_confirm") {
+                    this.assertDismissGroupRequester(scopedAction);
+                    await this.dismissGroupAndArchiveTask(contextKey, String(scopedAction.value.sessionId ?? ""), "command");
+                }
                 else if (kind === "session_stop") {
                     const sessionId = String(scopedAction.value.sessionId ?? "");
                     await this.stopSessionReference(contextKey, sessionId);
@@ -557,6 +579,19 @@ 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 controlDismissTask(localSessionId) {
+        const record = this.store.getSession(localSessionId);
+        if (!record)
+            throw new Error(`Task not found: ${localSessionId}`);
+        return this.dismissGroupAndArchiveTask(this.controlSessionContextKey(record), localSessionId, "cli");
+    }
     async controlGetTaskStatus(localSessionId) {
         const record = this.store.getSession(localSessionId);
         if (!record)
@@ -706,6 +741,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))
@@ -776,6 +1119,19 @@ 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 "dismiss":
+                await this.openDismissGroupCard(contextKey, userId);
+                return;
             case "status":
                 await this.status(contextKey, command.sessionId);
                 return;
@@ -2390,15 +2746,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);
@@ -2413,7 +2773,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;
@@ -2445,13 +2805,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 ?? "");
@@ -3268,6 +3630,16 @@ export class ProxySessionController {
                     contextKey,
                 },
             });
+            actions.push({
+                text: "Archive",
+                value: {
+                    action: "session_archive",
+                    sessionId: entry.reference,
+                    ...(searchTerm ? { searchTerm } : {}),
+                    page: String(page),
+                    contextKey,
+                },
+            });
             const title = truncateText(entry.title.replace(/\s+/gu, " ").trim() || "未命名任务", 56);
             return {
                 project,
@@ -3306,7 +3678,7 @@ export class ProxySessionController {
             `第 ${page + 1} 页 · 每页 ${SESSION_PAGE_SIZE} 个任务${hasNext ? "" : ` · 当前共 ${entries.length} 个任务`}`,
             "",
             "> 项目行：**New** 新建任务，**NewGroup** 新建群。",
-            "> 任务详情：**Switch** 切换，**Stop** 停止，**Fork** / **ForkGroup** 创建分支，**Status** 查看状态。",
+            "> 任务详情：**Switch** 切换，**Stop** 停止，**Fork** / **ForkGroup** 创建分支，**Status** 查看状态，**Archive** 归档。",
         ], [
             ...(hasPrevious ? [{
                     text: "Previous",
@@ -3471,6 +3843,138 @@ 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,
+        };
+    }
+    async openDismissGroupCard(contextKey, userId) {
+        const groupContextKey = this.dismissibleGroupContextKey(contextKey);
+        if (!userId)
+            throw new Error("无法识别当前用户，不能发起解散群操作。");
+        const session = this.requireCurrentSession(groupContextKey);
+        await this.outbound.sendInteractiveCard(groupContextKey, this.cardRenderer.renderDismissGroupConfirmation({
+            contextKey: groupContextKey,
+            sessionId: session.localSessionId,
+            taskTitle: session.title ?? session.remoteSessionId ?? session.localSessionId,
+            requestedBy: userId,
+        }));
+    }
+    assertDismissGroupRequester(action) {
+        const requestedBy = String(action.value.requestedBy ?? "");
+        if (!requestedBy || !action.userId || action.userId !== requestedBy) {
+            throw new Error("只有发起解散操作的用户可以点击这张卡片。");
+        }
+    }
+    async dismissGroupAndArchiveTask(contextKey, localSessionId, source) {
+        const groupContextKey = this.dismissibleGroupContextKey(contextKey);
+        const session = this.store.getSessionForContext(localSessionId, groupContextKey);
+        if (!session)
+            throw new Error("解散群卡片已失效，请重新发送 /dismiss。");
+        const currentSessionId = this.store.getUserContext(groupContextKey)?.currentSessionId;
+        if (session.status !== "closed" && currentSessionId !== localSessionId) {
+            throw new Error("当前任务已经切换，解散群卡片已失效，请重新发送 /dismiss。");
+        }
+        this.assertNoOtherActiveGroupTasks(groupContextKey, localSessionId);
+        const archived = session.status === "closed"
+            ? {
+                localSessionId: session.localSessionId,
+                remoteSessionId: session.remoteSessionId ?? session.acpSessionId ?? "",
+                title: session.title ?? session.remoteSessionId ?? session.localSessionId,
+            }
+            : await this.archiveSessionReference(groupContextKey, localSessionId, {
+                announce: false,
+                source: "dismiss",
+            });
+        const chatId = groupContextKey.slice("chat_id:".length);
+        try {
+            await this.outbound.deleteGroup(groupContextKey, chatId);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`当前任务已归档，但解散群失败：${message}`);
+        }
+        const detachedSessionIds = this.store.removeChatContext(groupContextKey);
+        for (const detachedSessionId of detachedSessionIds) {
+            const linked = this.store.getSession(detachedSessionId);
+            const routedContextKey = this.outbound.getSessionContextKey(detachedSessionId) ?? linked?.contextKey;
+            if (routedContextKey && baseChatContextKey(routedContextKey) === groupContextKey) {
+                this.outbound.unregisterSession(detachedSessionId);
+            }
+        }
+        this.store.audit(groupContextKey, "group_dismissed", {
+            chatId,
+            localSessionId,
+            remoteSessionId: archived.remoteSessionId,
+            source,
+        });
+        return { ...archived, chatId };
+    }
+    assertNoOtherActiveGroupTasks(contextKey, dismissedSessionId) {
+        const active = this.store.listSessionsForChat(contextKey).find((session) => (session.localSessionId !== dismissedSessionId
+            && session.status !== "closed"
+            && (session.status === "running"
+                || Boolean(this.runtimes.forAgent(session.agentName).getSession(session.localSessionId)?.activeTurnId)
+                || this.store.countQueuedPrompts(session.localSessionId) > 0)));
+        if (active) {
+            throw new Error(`群内任务仍在执行或有排队消息，暂时不能解散：${active.title ?? active.localSessionId}`);
+        }
+    }
+    dismissibleGroupContextKey(contextKey) {
+        if (isThreadContextKey(contextKey)) {
+            throw new Error("/dismiss 不能在话题中使用，请回到群聊正文后重试。");
+        }
+        const groupContextKey = baseChatContextKey(contextKey);
+        if (!groupContextKey.startsWith("chat_id:") || this.store.getChatContext(groupContextKey)?.chatType !== "group") {
+            throw new Error("/dismiss 仅适用于普通群聊。");
+        }
+        return groupContextKey;
+    }
     resolveSessionReference(contextKey, reference) {
         if (reference === undefined) {
             const previous = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent).previousSessionId;
@@ -3770,6 +4274,26 @@ export class ProxySessionController {
             ? "已开启当前群的静音模式。之后只有 @ 机器人的消息会被处理；发送 @机器人 /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)
@@ -4276,7 +4800,7 @@ function isBotOwnedActiveTurn(record, remote) {
         && record.lastTurnId === remote.lastTurnId;
 }
 function isQueueIndependentCommand(command) {
-    if (["stop", "status", "restart", "mute", "help", "sessions", "dir", "goal", "nosteer"].includes(command.type))
+    if (["archive", "dismiss", "stop", "status", "restart", "mute", "help", "sessions", "dir", "goal", "nosteer"].includes(command.type))
         return true;
     if (command.type === "agent")
         return command.agent === undefined;