@keyou007/agent-bot 0.1.24-alpha.2 → 0.1.24-alpha.4

package/dist/proxy/ProxySessionController.js

@@ -15,9 +15,11 @@ import { CardUpdateScheduler } from "../feishu/CardUpdateScheduler.js";
 import { generateGroupAvatarPng, resolveGroupAvatarProjectName } from "../feishu/GroupAvatarGenerator.js";
 import { formatGroupNameDate, formatNewGroupName, parseTaskNameFromGroupName, } from "../feishu/GroupNameFormatter.js";
 import { normalizeFeishuPostText } from "../feishu/InboundText.js";
+import { RECENT_CONTEXT_LIMIT, RECENT_CONTEXT_IMAGE_LIMIT, RECENT_CONTEXT_TEXT_LIMIT, recentContextPrompt } from "../feishu/RecentMessageContext.js";
 import { allowsFeishuUser } from "../feishu/ownerAccess.js";
 import { classifyFileContent } from "../local-files/LocalFileViewerServer.js";
 import { errorLogValue } from "../logging/errorLogValue.js";
+import { createTurnViewState, hydrateTurnViewState } from "../presentation/TurnStateReducer.js";
 import { buildTurnGraphRows } from "../presentation/turnGraph.js";
 import { isActiveShellCommandJob, ShellCommandJobManager, } from "../shell/ShellCommandJobManager.js";
 import { createId } from "../utils/id.js";
@@ -62,6 +64,7 @@ const FORK_GROUP_STARTED_MESSAGE = "正在创建分支群聊，请稍后。";
 const LIST_SESSIONS_STARTED_MESSAGE = "正在读取任务列表，请稍后。";
 const LIST_TURNS_STARTED_MESSAGE = "正在读取历史轮次，请稍后。";
 const SWITCH_TASK_STARTED_MESSAGE = "正在切换任务，请稍后。";
+const SWITCH_GROUP_STARTED_MESSAGE = "正在创建群聊并绑定所选任务，请稍后。";
 const STATUS_STARTED_MESSAGE = "正在读取任务状态，请稍后。";
 const GOAL_STARTED_MESSAGE = "正在处理 Goal，请稍后。";
 const ARCHIVE_TASK_STARTED_MESSAGE = "正在归档任务，请稍后。";
@@ -190,6 +193,7 @@ const HELP_COMMAND_SECTIONS = [
                 usage: "[--force]",
                 description: "默认安全重启；--force 立即重启",
             },
+            { command: "/update", description: "查看正式版和 Alpha 版更新，选择版本安全更新" },
             {
                 command: "/release",
                 description: "释放 Agent Bot 占用的 App Server 任务",
@@ -220,6 +224,7 @@ export class ProxySessionController {
     router = new CommandRouter();
     cardRenderer = new CardRenderer();
     messageQueues = new Map();
+    switchGroupOperations = new Set();
     sessionLoads = new Map();
     queuedPromptStarts = new Map();
     queuedPromptCards = new Map();
@@ -228,6 +233,7 @@ export class ProxySessionController {
     resetHistoryOperations = new Map();
     remoteTurnHistoryRefreshes = new Map();
     turnHistoryHydrations = new Map();
+    turnDetailHydrations = new Map();
     forkHistoryCursors = new Map();
     lastSessionListings = new Map();
     threadInitializations = new Map();
@@ -536,15 +542,24 @@ export class ProxySessionController {
                     let executableImagePaths = localImagePaths;
                     let executableMessage = message;
                     let injectedRootMessageId;
+                    let recentContextIds = [];
                     if (command.type === "prompt") {
                         await this.ensureThreadFork(message);
                         const prepared = await this.prepareTopicRootPrompt(message, command.text, localImagePaths);
-                        executableCommand = { ...command, text: prepared.text };
-                        executableImagePaths = prepared.localImagePaths;
+                        const recent = await this.prepareMutedGroupContext(message, prepared.text, prepared.localImagePaths);
+                        executableCommand = { ...command, text: recent.text };
+                        executableImagePaths = recent.localImagePaths;
+                        recentContextIds = recent.messageIds;
                         executableMessage = { ...message, displayText: prepared.displayPrompt };
                         injectedRootMessageId = prepared.injectedRootMessageId;
                     }
                     await this.execute(message.contextKey, executableCommand, message.messageId, replyTarget, executableImagePaths, message.userId, executableMessage);
+                    if (command.type === "prompt" && message.chatType === "group" && message.mentionedBot
+                        && this.store.chatRequiresMention(baseChatContextKey(message.contextKey))) {
+                        const current = this.currentSession(message.contextKey);
+                        if (current)
+                            this.store.rememberRecentContextMessages(current.localSessionId, current.remoteSessionId ?? "", message.contextKey, message.messageId, [...recentContextIds, message.messageId, ...[referencedMessageId, injectedRootMessageId].filter((id) => Boolean(id))]);
+                    }
                     if (injectedRootMessageId) {
                         const current = this.currentSession(message.contextKey);
                         if (current) {
@@ -609,11 +624,18 @@ export class ProxySessionController {
                         throw new Error("自动更新功能未启用。");
                     await this.lifecycle.cancelAutomaticUpdate(scopedAction);
                 }
+                else if (kind === "agentbot_update_select") {
+                    if (!this.lifecycle?.selectUpdate)
+                        throw new Error("当前运行方式不支持在线更新。");
+                    await this.lifecycle.selectUpdate(scopedAction, replyTarget);
+                }
                 else if (kind === "help_command") {
                     await this.executeHelpCommandAction(scopedAction, contextKey, replyTarget);
                 }
                 else if (kind === "turn_details") {
-                    await this.outbound.showDetails(contextKey, String(scopedAction.value.turnId ?? ""));
+                    const turnId = String(scopedAction.value.turnId ?? "");
+                    await this.loadTurnDetails(turnId);
+                    await this.outbound.showDetails(contextKey, turnId);
                 }
                 else if (kind === "activity_history") {
                     const requestedPage = String(scopedAction.value.page ?? "0");
@@ -745,6 +767,10 @@ export class ProxySessionController {
                     await this.forkSessionReference(contextKey, sessionId);
                     await this.refreshSessionsCardFromAction(scopedAction, { page: 0 });
                 }
+                else if (kind === "session_switch_group") {
+                    await this.switchSessionReferenceToFeishuGroup(contextKey, String(scopedAction.value.sessionId ?? ""), scopedAction.userId);
+                    await this.refreshSessionsCardFromAction(scopedAction);
+                }
                 else if (kind === "session_fork_group") {
                     const sessionId = String(scopedAction.value.sessionId ?? "");
                     await this.forkSessionReferenceToFeishuGroup(contextKey, sessionId, scopedAction.userId);
@@ -789,6 +815,21 @@ export class ProxySessionController {
                         await this.refreshSessionsCardFromAction(scopedAction, { forceSwitchTaskId: sessionId });
                     }
                 }
+                else if (kind === "session_turns" || kind === "session_turns_page") {
+                    const sessionReference = String(scopedAction.value.sessionId ?? "").trim();
+                    if (!sessionReference)
+                        throw new Error("任务轮次卡片无效，请重新发送 /sessions。");
+                    if (kind === "session_turns")
+                        await this.outbound.sendText(contextKey, LIST_TURNS_STARTED_MESSAGE);
+                    await this.openResetHistory(contextKey, {
+                        sessionReference,
+                        ...(kind === "session_turns_page" ? {
+                            updateMessageId: requiredCardMessageId(scopedAction.messageId),
+                            page: resetHistoryPageValue(scopedAction.value.page),
+                            cursor: typeof scopedAction.value.cursor === "string" ? scopedAction.value.cursor : undefined,
+                        } : {}),
+                    });
+                }
                 else if (kind === "session_status") {
                     await this.outbound.sendText(contextKey, STATUS_STARTED_MESSAGE);
                     await this.status(contextKey, String(scopedAction.value.sessionId ?? ""));
@@ -1054,7 +1095,7 @@ export class ProxySessionController {
             ?? { ...record, contextKey: responseContextKey };
         const previous = this.messageQueues.get(responseContextKey) ?? Promise.resolve();
         const next = previous.catch(() => undefined).then(async () => {
-            this.outbound.registerSession(scopedRecord.localSessionId, responseContextKey, scopedRecord.title, scopedRecord.cwd, this.agentLabel(scopedRecord.agentName), scopedRecord.model);
+            this.outbound.registerSession(scopedRecord.localSessionId, responseContextKey, scopedRecord.title, scopedRecord.cwd, this.agentLabel(scopedRecord.agentName), scopedRecord.model, scopedRecord.modelProvider);
             const promptMessageId = await this.outbound.withReplyTarget(responseContextKey, existingReplyTarget, () => this.outbound.sendText(responseContextKey, promptText));
             const turnReplyTarget = isThreadContextKey(responseContextKey)
                 ? promptMessageId
@@ -1256,7 +1297,7 @@ export class ProxySessionController {
                 await loaded.runtime.setReasoningEffort(record.localSessionId, nextEffort);
             }
             this.store.updateRuntimeSession(record.localSessionId, { model: nextValue, reasoningEffort: nextEffort });
-            this.outbound.updateSessionModel(record.localSessionId, nextValue);
+            this.outbound.updateSessionModel(record.localSessionId, nextValue, loaded.session.modelProvider);
         }
         else if (setting === "thinking" && nextValue) {
             const models = await loaded.runtime.listModels(loaded.session.modelProvider, loaded.session.model);
@@ -1580,6 +1621,11 @@ export class ProxySessionController {
                     throw new Error("当前运行方式不支持自动重启。");
                 await this.lifecycle.restart(contextKey, command.force === true, replyTarget);
                 return;
+            case "update":
+                if (!this.lifecycle?.showUpdates)
+                    throw new Error("当前运行方式不支持检查更新。");
+                await this.lifecycle.showUpdates(contextKey, userId);
+                return;
             case "release":
                 await this.requestAppServerRelease(contextKey);
                 return;
@@ -1628,7 +1674,7 @@ export class ProxySessionController {
                 : context.contextKey;
             if (!this.outbound.canRoute(turnContextKey))
                 continue;
-            this.outbound.registerSession(session.localSessionId, turnContextKey, session.title, session.cwd, this.agentLabel(session.agentName), session.model);
+            this.outbound.registerSession(session.localSessionId, turnContextKey, session.title, session.cwd, this.agentLabel(session.agentName), session.model, session.modelProvider);
             if (!session.lastTurnId)
                 continue;
             void this.outbound.resumeDelivery(session.localSessionId, turnContextKey, session.lastTurnId).catch((error) => {
@@ -1702,7 +1748,7 @@ export class ProxySessionController {
                 continue;
             }
             if (session) {
-                this.outbound.registerSession(session.localSessionId, attempt.contextKey, session.title, session.cwd, this.agentLabel(session.agentName), session.model);
+                this.outbound.registerSession(session.localSessionId, attempt.contextKey, session.title, session.cwd, this.agentLabel(session.agentName), session.model, session.modelProvider);
             }
             try {
                 await this.handleRuntimeEvent({
@@ -1814,7 +1860,7 @@ export class ProxySessionController {
         const replyTarget = attempt.replyMessageId
             ? { messageId: attempt.replyMessageId, replyInThread: true }
             : undefined;
-        this.outbound.registerSession(session.localSessionId, contextKey, session.title, session.cwd, this.agentLabel(session.agentName), session.model);
+        this.outbound.registerSession(session.localSessionId, contextKey, session.title, session.cwd, this.agentLabel(session.agentName), session.model, session.modelProvider);
         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.");
@@ -2016,8 +2062,8 @@ export class ProxySessionController {
         }
         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), record.model);
-            await this.outbound.startPendingTurn(record.localSessionId, contextKey, record.title, replyTarget, displayPrompt ?? text);
+            this.outbound.registerSession(record.localSessionId, contextKey, record.title, record.cwd, this.agentLabel(record.agentName), record.model, record.modelProvider);
+            await this.outbound.startPendingTurn(record.localSessionId, contextKey, record.title, replyTarget, displayPrompt ?? text, localImagePaths);
         }
         let loaded;
         try {
@@ -2060,7 +2106,7 @@ export class ProxySessionController {
             }
             try {
                 await loaded.runtime.steerTurn(record.localSessionId, activeTurnId, runtimePrompt(text, localImagePaths));
-                await this.presentSteerMessage(record.localSessionId, activeTurnId, displayPrompt ?? text, messageId);
+                await this.presentSteerMessage(record.localSessionId, activeTurnId, displayPrompt ?? text, messageId, localImagePaths);
                 if (messageId)
                     await this.bindMessageReactionToTurn(messageId, record.localSessionId, activeTurnId);
                 return;
@@ -2083,7 +2129,7 @@ export class ProxySessionController {
                 if (current.activeTurnId !== activeTurnId) {
                     try {
                         await loaded.runtime.steerTurn(record.localSessionId, current.activeTurnId, runtimePrompt(text, localImagePaths));
-                        await this.presentSteerMessage(record.localSessionId, current.activeTurnId, displayPrompt ?? text, messageId);
+                        await this.presentSteerMessage(record.localSessionId, current.activeTurnId, displayPrompt ?? text, messageId, localImagePaths);
                         if (messageId)
                             await this.bindMessageReactionToTurn(messageId, record.localSessionId, current.activeTurnId);
                         return;
@@ -2105,10 +2151,10 @@ export class ProxySessionController {
         if (messageId)
             await this.bindMessageReactionToTurn(messageId, record.localSessionId, turnId);
     }
-    async presentSteerMessage(localSessionId, turnId, text, messageId) {
+    async presentSteerMessage(localSessionId, turnId, text, messageId, localImagePaths) {
         this.store.touchTurnAttempt(turnId);
         try {
-            await this.outbound.appendSteerMessage(localSessionId, turnId, text, messageId);
+            await this.outbound.appendSteerMessage(localSessionId, turnId, text, messageId, localImagePaths);
         }
         catch (error) {
             this.logger.warn({ error, sessionId: localSessionId, turnId, messageId }, "Failed to insert a steer message into the thinking card.");
@@ -2239,6 +2285,72 @@ export class ProxySessionController {
             }
         }
     }
+    async prepareMutedGroupContext(message, text, localImagePaths) {
+        if (message.chatType !== "group" || !message.chatId || message.mentionedBot !== true
+            || !this.store.chatRequiresMention(baseChatContextKey(message.contextKey))) {
+            return { text, localImagePaths, messageIds: [] };
+        }
+        if (message.threadContext && !message.threadId)
+            throw new Error("无法识别当前话题，已停止补充上下文以避免读取其他话题。");
+        try {
+            const current = this.currentSession(message.contextKey);
+            const stopIds = current ? new Set([
+                ...this.store.recentContextMessageIds(current.localSessionId, current.remoteSessionId ?? "", message.contextKey, false),
+                ...this.store.recentSubmittedMessageIds(current.localSessionId, current.remoteSessionId ?? "", message.contextKey),
+            ]) : new Set();
+            const messages = await this.outbound.readRecentMessages(message.contextKey, {
+                chatId: message.chatId,
+                ...(message.threadId ? { threadId: message.threadId } : {}),
+                beforeMessageId: message.messageId,
+                beforeTimestamp: message.createdAt,
+                ...(stopIds.size ? { stopBeforeMessageIds: [...stopIds] } : {}),
+            });
+            const seen = current ? this.store.recentContextMessageIds(current.localSessionId, current.remoteSessionId ?? "", message.contextKey) : new Set();
+            seen.add(message.messageId);
+            if (message.parentMessageId)
+                seen.add(message.parentMessageId);
+            if (message.threadContext && message.rootMessageId)
+                seen.add(message.rootMessageId);
+            const selected = [];
+            const imagePaths = [...(localImagePaths ?? [])];
+            const imageKeys = new Set();
+            let remaining = RECENT_CONTEXT_TEXT_LIMIT;
+            let imageCount = 0;
+            for (const item of messages.slice(-RECENT_CONTEXT_LIMIT).reverse()) {
+                if (stopIds.has(item.messageId) || remaining <= 0)
+                    break;
+                if (seen.has(item.messageId))
+                    continue;
+                seen.add(item.messageId);
+                const limit = Math.min(2_000, remaining);
+                let body = item.text.length > limit ? `${item.text.slice(0, limit)}\n[消息文本已截断]` : item.text;
+                remaining -= Math.min(item.text.length, limit);
+                for (const [index, image] of item.images.entries()) {
+                    if (imageKeys.has(image.imageKey))
+                        continue;
+                    imageKeys.add(image.imageKey);
+                    if (imageCount >= RECENT_CONTEXT_IMAGE_LIMIT) {
+                        body += `\n[图片 ${index + 1} 未附带：已达到近期图片上限]`;
+                        continue;
+                    }
+                    const imagePath = await this.outbound.downloadImage(message.contextKey, image.messageId, image.imageKey);
+                    imagePaths.push(imagePath);
+                    imageCount++;
+                    body += `\n[图片 ${index + 1} 已附带：${imagePath}]`;
+                }
+                selected.unshift({ ...item, text: body });
+            }
+            return {
+                text: recentContextPrompt(text, selected),
+                ...(imagePaths.length ? { localImagePaths: [...new Set(imagePaths)] } : {}),
+                messageIds: selected.map((item) => item.messageId),
+            };
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new Error(`无法补充近期群聊上下文（包括图片）：${detail}。请检查飞书历史消息/群消息读取权限及机器人是否在群内，或附图重试。`);
+        }
+    }
     async prepareTopicRootPrompt(message, text, localImagePaths) {
         const displayPrompt = message.displayText ?? text;
         const rootMessageId = topicRootMessageId(message);
@@ -2309,7 +2421,7 @@ export class ProxySessionController {
             permissionMode: source.permissionMode ?? "auto",
         });
         this.store.setCurrentSession(message.contextKey, localSessionId);
-        this.outbound.registerSession(localSessionId, message.contextKey, forkTitle, source.cwd, this.agentLabel(source.agentName), source.model);
+        this.outbound.registerSession(localSessionId, message.contextKey, forkTitle, source.cwd, this.agentLabel(source.agentName), source.model, source.modelProvider);
         try {
             const forked = await runtime.forkSession({
                 localSessionId,
@@ -2607,7 +2719,7 @@ export class ProxySessionController {
                 lastTurnId: plan.lastTurnId,
                 lastTurnStatus: plan.lastTurnStatus,
             });
-            this.outbound.registerSession(localSessionId, contextKey, forked.title ?? plan.forkTitle, plan.cwd, this.agentLabel(plan.agentName), plan.model);
+            this.outbound.registerSession(localSessionId, contextKey, forked.title ?? plan.forkTitle, plan.cwd, this.agentLabel(plan.agentName), forked.model ?? plan.model, forked.modelProvider ?? plan.modelProvider);
             this.store.audit(contextKey, "session_forked", {
                 sourceLocalSessionId: plan.source?.localSessionId,
                 sourceRemoteSessionId: plan.remoteSessionId,
@@ -2647,6 +2759,7 @@ export class ProxySessionController {
                             sessionId: input.localSessionId,
                             turnId: turn.id,
                             prompt: turn.prompt ?? "未记录对话内容",
+                            historyDetail: "summary",
                             status: "completed",
                             startedAt,
                             completedAt,
@@ -2963,8 +3076,9 @@ export class ProxySessionController {
             while (true) {
                 let pendingTurnId;
                 try {
-                    this.outbound.updateSessionModel(loaded.record.localSessionId, loaded.runtime.getSession(loaded.record.localSessionId)?.model ?? loaded.session.model);
-                    pendingTurnId = await this.outbound.startPendingTurn(loaded.record.localSessionId, loaded.record.contextKey, title, replyTarget, cardPrompt);
+                    const session = loaded.runtime.getSession(loaded.record.localSessionId) ?? loaded.session;
+                    this.outbound.updateSessionModel(loaded.record.localSessionId, session.model, session.modelProvider);
+                    pendingTurnId = await this.outbound.startPendingTurn(loaded.record.localSessionId, loaded.record.contextKey, title, replyTarget, cardPrompt, localImagePaths);
                 }
                 catch (error) {
                     this.store.updateTurnAttempt(attemptId, {
@@ -3056,7 +3170,7 @@ export class ProxySessionController {
         }
         if (activate)
             this.store.setCurrentSession(contextKey, localSessionId);
-        this.outbound.registerSession(localSessionId, contextKey, initialTitle, sessionCwd, this.agentLabel(agentName), resolvedExecutionSettings.model);
+        this.outbound.registerSession(localSessionId, contextKey, initialTitle, sessionCwd, this.agentLabel(agentName), resolvedExecutionSettings.model, resolvedExecutionSettings.modelProvider);
         const runtime = this.runtimes.forAgent(agentName);
         try {
             if (prepareTurn) {
@@ -3073,7 +3187,7 @@ export class ProxySessionController {
                 permissionMode: resolvedExecutionSettings.permissionMode ?? "auto",
             });
             this.persistRuntimeSession(record, session, session.activeTurnId ? "running" : "ready");
-            this.outbound.updateSessionModel(localSessionId, session.model);
+            this.outbound.updateSessionModel(localSessionId, session.model, session.modelProvider);
             const saved = this.store.getSession(localSessionId) ?? record;
             if (announce) {
                 const task = initialTitle ? `${initialTitle}（${session.remoteSessionId}）` : session.remoteSessionId;
@@ -3109,6 +3223,111 @@ export class ProxySessionController {
         const boundProjectCwd = detectProjectlessWorkspace(resolved.cwd) ? undefined : resolved.cwd;
         await this.createFeishuGroupWithTask(sourceContextKey, resolved.agentName, undefined, userId, boundProjectCwd, resolved.executionSettings);
     }
+    async switchSessionReferenceToFeishuGroup(sourceContextKey, reference, userId) {
+        if (!userId?.startsWith("ou_"))
+            throw new Error("SwitchGroup 只能由具有 open_id 的飞书用户触发。");
+        if (!reference.trim())
+            throw new Error("任务无效，请重新发送 /sessions。");
+        await this.outbound.sendText(sourceContextKey, SWITCH_GROUP_STARTED_MESSAGE);
+        const taskId = this.resolveSessionReference(sourceContextKey, reference);
+        let task = this.store.getSession(taskId) ?? this.findStoredSessionByReference(taskId);
+        if (task?.status === "closed")
+            throw new Error(`找不到任务：${taskId}`);
+        if (task && (!this.isCodexSession(task) || !task.remoteSessionId)) {
+            throw new Error("指定任务不是可切换的 App Server 任务。");
+        }
+        let remote;
+        let agentName;
+        let runtime;
+        if (task) {
+            agentName = task.agentName;
+            runtime = this.runtimes.forAgent(agentName);
+            await this.assertSessionTurnOwnership(task, runtime);
+        }
+        else {
+            const resolved = await this.resolveRemoteCodexSession(taskId);
+            ({ agentName, runtime, remote } = resolved);
+            if (isRemoteSessionActive(remote)) {
+                throw new Error("这个任务正在外部 Agent 中执行，请等待完成后再使用 SwitchGroup。");
+            }
+        }
+        const remoteSessionId = task?.remoteSessionId ?? remote.id;
+        const operationKey = agentRemoteKey(agentName, remoteSessionId);
+        if (this.switchGroupOperations.has(operationKey))
+            throw new Error("正在为此任务创建群聊，请勿重复点击。");
+        const cwd = task?.cwd ?? remote.cwd;
+        if (!cwd)
+            throw new Error("指定任务没有可用的工作目录，暂时无法创建群聊。");
+        const title = task?.title ?? remote?.title ?? remote?.preview ?? remoteSessionId;
+        const boundProjectCwd = detectProjectlessWorkspace(cwd) ? undefined : cwd;
+        this.switchGroupOperations.add(operationKey);
+        try {
+            const group = await this.createFeishuGroupContext(sourceContextKey, agentName, title, userId, boundProjectCwd, "SwitchGroup");
+            try {
+                const latest = task ? undefined : await runtime.readRemoteSession(remoteSessionId);
+                if (latest && isRemoteSessionActive(latest))
+                    throw new Error("所选任务已在外部 Agent 中开始执行，请等待完成后切换。");
+                // Group creation may take time; reuse any canonical task linked in the meantime.
+                task = this.store.findSessionByRemoteSessionId(remoteSessionId, undefined, agentName) ?? task;
+                if (task) {
+                    task = this.store.getSession(task.localSessionId);
+                    if (!task || task.status === "closed")
+                        throw new Error("所选任务已归档，请重新选择任务。");
+                    await this.assertSessionTurnOwnership(task, runtime);
+                    task = this.store.getSession(task.localSessionId);
+                    if (!task || task.status === "closed" || task.remoteSessionId !== remoteSessionId) {
+                        throw new Error("所选任务已变化，请重新选择任务。");
+                    }
+                    this.store.attachSessionToContext(group.contextKey, task.localSessionId);
+                }
+                else {
+                    if (!latest)
+                        throw new Error("无法读取所选任务，请重试。");
+                    const localSessionId = createId("sess");
+                    this.store.createSession({ localSessionId, contextKey: group.contextKey, agentName, cwd, status: "ready" });
+                    this.store.updateRuntimeSession(localSessionId, {
+                        runtimeKind: "codex",
+                        remoteSessionId,
+                        title: latest.title ?? latest.preview ?? title,
+                        modelProvider: latest.modelProvider ?? remote?.modelProvider,
+                        model: latest.model ?? remote?.model,
+                        reasoningEffort: latest.reasoningEffort ?? remote?.reasoningEffort,
+                        permissionMode: latest.permissionMode ?? remote?.permissionMode ?? "auto",
+                        lastTurnId: latest.lastTurnId ?? remote?.lastTurnId,
+                        lastTurnStatus: mapRemoteTurnStatus(latest.lastTurnStatus ?? remote?.lastTurnStatus),
+                    });
+                    task = this.store.getSession(localSessionId);
+                }
+                this.store.setCurrentSession(group.contextKey, task.localSessionId);
+                // A live Turn keeps its original delivery route. The new group's next Turn
+                // establishes its own route through startPendingTurn.
+                if (task.status !== "running" && !runtime.getSession(task.localSessionId)?.activeTurnId) {
+                    this.outbound.registerSession(task.localSessionId, group.contextKey, task.title, task.cwd, this.agentLabel(agentName), task.model, task.modelProvider);
+                }
+                this.store.audit(sourceContextKey, "session_switch_group", {
+                    localSessionId: task.localSessionId, remoteSessionId, groupContextKey: group.contextKey,
+                });
+            }
+            catch (error) {
+                await this.outbound.sendText(group.contextKey, `群已创建，但绑定任务失败：${runtimeErrorMessage(error)}。可使用 /sessions 重新选择任务。`)
+                    .catch((noticeError) => this.logger.warn({ error: noticeError, contextKey: group.contextKey }, "Failed to report SwitchGroup binding failure."));
+                throw new Error(`群 ${group.name} 已创建，但绑定任务失败：${runtimeErrorMessage(error)}`);
+            }
+            await this.outbound.sendText(group.contextKey, [
+                "已切换到已有任务，历史与原会话共享。",
+                `当前任务：${task.title ?? title}（${remoteSessionId}）`,
+                `当前 Project 目录：${boundProjectCwd ?? "未绑定（Projectless）"}`,
+                `当前 Provider：${task.modelProvider ?? "Agent 默认"}`,
+                `当前模型：${task.model ?? "默认"}`,
+                `思考强度：${task.reasoningEffort ?? "自动"}`,
+                `权限类型：${task.permissionMode === "confirm" ? "执行前确认" : "自动执行"}`,
+            ].join("\n"));
+            await this.outbound.sendText(sourceContextKey, `已创建飞书群：${group.name}，并切换到任务 ${task.title ?? remoteSessionId}。原会话不变。`);
+        }
+        finally {
+            this.switchGroupOperations.delete(operationKey);
+        }
+    }
     async createFeishuGroupWithTask(sourceContextKey, agentName, requestedTitle, userId, boundProjectCwd, executionSettings) {
         const explicitTitle = normalizeTaskTitle(requestedTitle);
         const taskTitle = explicitTitle ?? `新任务 (${formatGroupNameDate(new Date(), this.config.feishu?.groupNameFormat?.dateFormat ?? DEFAULT_GROUP_NAME_FORMAT.dateFormat)})`;
@@ -3298,7 +3517,7 @@ export class ProxySessionController {
                 record: { ...loaded.record, contextKey: record.contextKey },
             };
         }
-        this.outbound.registerSession(record.localSessionId, record.contextKey, record.title, record.cwd, this.agentLabel(record.agentName), record.model);
+        this.outbound.registerSession(record.localSessionId, record.contextKey, record.title, record.cwd, this.agentLabel(record.agentName), record.model, record.modelProvider);
         const loading = (async () => {
             if (record.lastTurnId) {
                 try {
@@ -3949,7 +4168,7 @@ export class ProxySessionController {
             lastTurnId: turnId,
             lastTurnStatus: "completed",
         });
-        this.outbound.registerSession(current.localSessionId, contextKey, forked.title ?? current.title, current.cwd, this.agentLabel(current.agentName), current.model);
+        this.outbound.registerSession(current.localSessionId, contextKey, forked.title ?? current.title, current.cwd, this.agentLabel(current.agentName), forked.model ?? current.model, forked.modelProvider ?? current.modelProvider);
         this.store.audit(contextKey, "session_reset_to_turn", {
             localSessionId: current.localSessionId,
             previousRemoteSessionId,
@@ -4180,7 +4399,7 @@ export class ProxySessionController {
             }
         };
         const session = await loaded.runtime.setExecutionSettings(loaded.record.localSessionId, settings, persist);
-        this.outbound.updateSessionModel(loaded.record.localSessionId, session.model);
+        this.outbound.updateSessionModel(loaded.record.localSessionId, session.model, session.modelProvider);
         return session;
     }
     async assertProviderModelSettings(loaded, modelProvider, model, effort) {
@@ -4242,7 +4461,7 @@ export class ProxySessionController {
             await loaded.runtime.setReasoningEffort(loaded.record.localSessionId, nextEffort);
         }
         this.store.updateRuntimeSession(loaded.record.localSessionId, { model, reasoningEffort: nextEffort });
-        this.outbound.updateSessionModel(loaded.record.localSessionId, model);
+        this.outbound.updateSessionModel(loaded.record.localSessionId, model, loaded.session.modelProvider);
         await this.persistAgentExecutionDefaults(loaded.record.localSessionId);
         const effortMessage = nextEffort && nextEffort !== currentEffort
             ? `，思考强度已自动调整为 ${nextEffort}`
@@ -4585,11 +4804,13 @@ export class ProxySessionController {
         const legacyTitle = legacy && record.agentName.toLowerCase() === legacy.agentName.toLowerCase()
             ? legacy.title
             : undefined;
-        if (isDefaultGroupNameFormat(nameFormat) && isLegacyGroupPrefixOnly(event.afterName))
-            return;
-        const title = normalizeTaskTitle(isDefaultGroupNameFormat(nameFormat)
+        const defaultFormat = isDefaultGroupNameFormat(nameFormat);
+        let parsedTitle = defaultFormat
             ? legacyTitle ?? templateTitle
-            : templateTitle ?? legacyTitle);
+            : templateTitle ?? legacyTitle;
+        if (defaultFormat && isLegacyGroupPrefixOnly(event.afterName))
+            parsedTitle = undefined;
+        const title = normalizeTaskTitle(parsedTitle) ?? normalizeTaskTitle(event.afterName);
         if (!title || title === record.title)
             return;
         const loaded = await this.loadSession(record);
@@ -4692,6 +4913,87 @@ export class ProxySessionController {
             assistantText: "", plan: [], activities: [], completedTools: [], failedTools: [], fileSummary: [],
         };
     }
+    async loadTurnDetails(turnId) {
+        const existing = this.turnDetailHydrations.get(turnId);
+        if (existing)
+            return existing;
+        const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(turnId));
+        if ((!snapshot || snapshot.previewJournal) && this.store.previews.has(turnId))
+            return this.store.previews.load(turnId);
+        if (snapshot && !needsHistoricalDetails(snapshot))
+            return snapshot;
+        const origin = !snapshot ? this.store.getTurnRuntimeOrigin(turnId) : undefined;
+        if (!snapshot && (!origin || !this.runtimes.forAgent(origin.agentName).readRemoteTurn))
+            return undefined;
+        const hydration = snapshot ? this.hydrateTurnDetails(snapshot) : this.loadUnrecordedTurnPreview(origin);
+        this.turnDetailHydrations.set(turnId, hydration);
+        try {
+            return await hydration;
+        }
+        finally {
+            if (this.turnDetailHydrations.get(turnId) === hydration)
+                this.turnDetailHydrations.delete(turnId);
+        }
+    }
+    async loadUnrecordedTurnPreview(origin) {
+        const runtime = this.runtimes.forAgent(origin.agentName);
+        if (!runtime.readRemoteTurn)
+            throw new Error("此 Agent 不支持读取历史执行详情。");
+        const details = await runtime.readRemoteTurn(origin.remoteSessionId, origin.turnId);
+        if (details.turnId !== origin.turnId)
+            throw new Error("Agent 返回的轮次与请求不一致，请重试。");
+        let remote;
+        try {
+            remote = await runtime.readRemoteSession?.(origin.remoteSessionId, "metadata");
+        }
+        catch (error) {
+            this.logger.warn({ error, turnId: origin.turnId }, "Failed to read Preview task metadata; retaining full Turn details.");
+        }
+        // An Agent Bot turn may have arrived while the read-only request was in flight.
+        const latest = turnViewSnapshot(this.store.getTurnSnapshot(origin.turnId));
+        if (latest)
+            return latest.previewJournal ? this.store.previews.load(origin.turnId) ?? latest : latest;
+        const state = hydrateTurnViewState(createTurnViewState(origin.localSessionId, origin.turnId, details.startedAt ?? 0, remote?.title, undefined, remote?.cwd, undefined, this.agentLabel(origin.agentName)), details);
+        // Viewing external work must not create a task, a chat binding or a pending final reply.
+        this.store.previews.seed(state);
+        this.store.previews.release(state.turnId);
+        return state;
+    }
+    async hydrateTurnDetails(snapshot) {
+        let updated;
+        try {
+            const origin = this.store.getTurnRuntimeOrigin(snapshot.turnId);
+            if (!origin)
+                throw new Error("未保存本轮的原始 Agent 会话信息，无法读取历史执行详情。");
+            const runtime = this.runtimes.forAgent(origin.agentName);
+            if (!runtime.readRemoteTurn)
+                throw new Error("此 Agent 不支持读取历史执行详情。");
+            const details = await runtime.readRemoteTurn(origin.remoteSessionId, snapshot.turnId);
+            if (details.turnId !== snapshot.turnId)
+                throw new Error("Agent 返回的轮次与请求不一致，请重试。");
+            const session = this.store.getSession(snapshot.sessionId);
+            updated = hydrateTurnViewState({
+                ...snapshot,
+                projectCwd: snapshot.projectCwd ?? session?.cwd,
+                agentLabel: snapshot.agentLabel ?? this.agentLabel(origin.agentName),
+            }, details);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ error, turnId: snapshot.turnId }, "Failed to load historical Turn details.");
+            updated = { ...snapshot, historyDetail: "summary", historyDetailError: message };
+        }
+        const latest = turnViewSnapshot(this.store.getTurnSnapshot(snapshot.turnId));
+        if (!latest || !needsHistoricalDetails(latest))
+            return latest;
+        if (updated.historyDetail === "full") {
+            this.store.previews.seed(updated);
+            this.store.previews.flush(updated.turnId, true);
+            updated = { ...updated, previewJournal: true };
+        }
+        this.store.saveTurnSnapshot(snapshot.turnId, snapshot.sessionId, updated);
+        return updated;
+    }
     async openTurnDetails(contextKey, reference) {
         const current = this.requireCurrentSession(contextKey);
         let turnId;
@@ -4734,10 +5036,23 @@ export class ProxySessionController {
             await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderTurnDetails(this.runningTurnSnapshot(current, turnId)));
             return;
         }
+        await this.loadTurnDetails(turnId);
         await this.outbound.showDetails(contextKey, turnId);
     }
     async openResetHistory(contextKey, options = {}) {
-        const current = this.requireCurrentSession(contextKey);
+        const taskId = options.sessionReference
+            ? this.resolveSessionReference(contextKey, options.sessionReference)
+            : undefined;
+        const current = taskId
+            ? this.store.getSession(taskId) ?? this.findStoredSessionByReference(taskId)
+            : this.requireCurrentSession(contextKey);
+        if (!current && taskId) {
+            await this.openRemoteTurnHistory(contextKey, taskId, options);
+            return;
+        }
+        if (!current || current.status === "closed")
+            throw new Error(`找不到任务：${taskId}`);
+        const readOnly = this.currentSession(contextKey)?.localSessionId !== current.localSessionId;
         if (options.expectedSessionId && current.localSessionId !== options.expectedSessionId) {
             throw new Error("这张历史轮次卡片不属于当前任务。请先切换回对应任务，再重新发送 /turns。");
         }
@@ -4795,7 +5110,7 @@ export class ProxySessionController {
                     current: isCurrent,
                     running: isRunning,
                     resetting: isResetting,
-                    actions: isCurrent || isRunning || resettingTurnId ? undefined : [{
+                    actions: readOnly || isCurrent || isRunning || resettingTurnId ? undefined : [{
                             text: "Reset",
                             value: {
                                 action: "turn_reset",
@@ -4812,8 +5127,8 @@ export class ProxySessionController {
             ...(page > 0 ? [{
                     text: "Previous",
                     value: {
-                        action: "turn_reset_page",
-                        sessionId: current.localSessionId,
+                        action: options.sessionReference ? "session_turns_page" : "turn_reset_page",
+                        sessionId: options.sessionReference ?? current.localSessionId,
                         contextKey,
                         page: String(page - 1),
                     },
@@ -4821,14 +5136,15 @@ export class ProxySessionController {
             ...(page < totalPages - 1 ? [{
                     text: "Next",
                     value: {
-                        action: "turn_reset_page",
-                        sessionId: current.localSessionId,
+                        action: options.sessionReference ? "session_turns_page" : "turn_reset_page",
+                        sessionId: options.sessionReference ?? current.localSessionId,
                         contextKey,
                         page: String(page + 1),
                     },
                 }] : []),
         ];
         const card = this.cardRenderer.renderResetHistoryCard({
+            ...(options.sessionReference ? { taskTitle: current.title ?? current.remoteSessionId, readOnly } : {}),
             entries,
             footerLines: [
                 hasMoreHistory
@@ -4847,6 +5163,75 @@ export class ProxySessionController {
             await this.outbound.sendInteractiveCard(contextKey, card);
         }
     }
+    async openRemoteTurnHistory(contextKey, reference, options) {
+        const { runtime, remote } = await this.resolveRemoteCodexSession(reference);
+        if (!runtime.listRemoteTurnSummaries)
+            throw new Error("当前 Agent 不支持读取历史轮次。");
+        const page = Math.max(0, Math.trunc(options.page ?? 0));
+        const running = remote.lastTurnStatus === "inProgress" && remote.lastTurnId;
+        let cursor = options.cursor;
+        // Next carries its cursor; only backwards navigation needs to locate a page again.
+        if (!cursor && page > 0) {
+            const seen = new Set();
+            for (let index = 0; index < page; index += 1) {
+                const previous = await runtime.listRemoteTurnSummaries(remote.id, {
+                    cursor,
+                    limit: RESET_HISTORY_PAGE_SIZE - (index === 0 && running ? 1 : 0),
+                });
+                if (!previous.nextCursor || seen.has(previous.nextCursor)) {
+                    throw new Error("任务轮次已变化，请从 /sessions 重新打开 Turns。");
+                }
+                cursor = previous.nextCursor;
+                seen.add(cursor);
+            }
+        }
+        const result = await runtime.listRemoteTurnSummaries(remote.id, {
+            cursor,
+            limit: RESET_HISTORY_PAGE_SIZE - (page === 0 && running ? 1 : 0),
+        });
+        if (result.nextCursor && result.nextCursor === cursor) {
+            throw new Error("历史轮次分页游标无效，请稍后重试。");
+        }
+        const turns = [
+            ...(page === 0 && running ? [{ id: running, prompt: remote.lastUserPrompt }] : []),
+            ...result.turns,
+        ];
+        const entries = turns.map((turn, index) => ({
+            sequence: page * RESET_HISTORY_PAGE_SIZE + index + 1,
+            graphNodeLine: "●",
+            graphConnectorLine: index < turns.length - 1 ? "│" : undefined,
+            lines: [cardText(truncateText((turn.prompt ?? "未记录对话内容").replace(/\s+/g, " ").trim(), 100))],
+            timestamp: formatResetTurnTime(turn.completedAt ?? turn.startedAt),
+            current: remote.lastTurnStatus === "completed" && remote.lastTurnId === turn.id,
+            running: running === turn.id,
+        }));
+        const pageAction = (text, targetPage, targetCursor) => ({
+            text,
+            value: {
+                action: "session_turns_page",
+                sessionId: reference,
+                contextKey,
+                page: String(targetPage),
+                ...(targetCursor ? { cursor: targetCursor } : {}),
+            },
+        });
+        const card = this.cardRenderer.renderResetHistoryCard({
+            taskTitle: remote.title ?? remote.preview ?? remote.id,
+            readOnly: true,
+            entries,
+            footerLines: [`第 ${page + 1} 页 · 本页 ${entries.length} 个 turn`],
+            pageActions: [
+                ...(page > 0 ? [pageAction("Previous", page - 1)] : []),
+                ...(result.nextCursor ? [pageAction("Next", page + 1, result.nextCursor)] : []),
+            ],
+        });
+        if (options.updateMessageId) {
+            await this.outbound.updateInteractiveCard(contextKey, options.updateMessageId, card);
+        }
+        else {
+            await this.outbound.sendInteractiveCard(contextKey, card);
+        }
+    }
     async openDirectoryBrowser(contextKey, requestedDirectory, options = {}) {
         if (requestedDirectory === WINDOWS_DRIVES_DIRECTORY) {
             await this.openWindowsDriveBrowser(contextKey, options);
@@ -5118,6 +5503,16 @@ export class ProxySessionController {
                         contextKey,
                     },
                 })];
+            actions.push(bindCardAction({
+                text: "SwitchGroup",
+                value: {
+                    action: "session_switch_group",
+                    sessionId: entry.reference,
+                    ...(searchTerm ? { searchTerm } : {}),
+                    page: String(page),
+                    contextKey,
+                },
+            }));
             const projectActions = [bindCardAction({
                     text: "New",
                     value: {
@@ -5165,6 +5560,14 @@ export class ProxySessionController {
                     contextKey,
                 },
             }));
+            actions.push(bindCardAction({
+                text: "Turns",
+                value: {
+                    action: "session_turns",
+                    sessionId: entry.reference,
+                    contextKey,
+                },
+            }));
             actions.push(bindCardAction({
                 text: "Archive",
                 value: {
@@ -5358,7 +5761,7 @@ export class ProxySessionController {
             await this.assertSessionTurnOwnership(existing, runtime);
             this.store.attachSessionToContext(contextKey, existing.localSessionId);
             this.store.setCurrentSession(contextKey, existing.localSessionId);
-            this.outbound.registerSession(existing.localSessionId, contextKey, existing.title, existing.cwd, this.agentLabel(existing.agentName), existing.model);
+            this.outbound.registerSession(existing.localSessionId, contextKey, existing.title, existing.cwd, this.agentLabel(existing.agentName), existing.model, existing.modelProvider);
             await this.outbound.sendText(contextKey, `已切换到任务：${existing.title ?? existing.remoteSessionId ?? taskId}`);
             return;
         }
@@ -5385,7 +5788,7 @@ export class ProxySessionController {
             lastTurnStatus: mapRemoteTurnStatus(remote.lastTurnStatus),
         });
         this.store.setCurrentSession(contextKey, localSessionId);
-        this.outbound.registerSession(localSessionId, contextKey, remote.title ?? remote.preview, remote.cwd, this.agentLabel(agentName), remote.model);
+        this.outbound.registerSession(localSessionId, contextKey, remote.title ?? remote.preview, remote.cwd, this.agentLabel(agentName), remote.model, remote.modelProvider);
         await this.outbound.sendText(contextKey, `已切换到任务：${remote.title ?? remote.preview ?? remote.id}。历史消息不会重新发送。`);
     }
     async stopSessionReference(contextKey, taskId) {
@@ -5770,6 +6173,9 @@ export class ProxySessionController {
         const actions = [
             statusRefreshAction(taskId, contextKey),
             ...taskActions,
+            ...this.statusPreviewActions(contextKey, activeTurnId ?? current?.lastTurnId, current?.remoteSessionId ? {
+                agentName: current.agentName, remoteSessionId: current.remoteSessionId, localSessionId: current.localSessionId,
+            } : undefined),
         ];
         const card = this.cardRenderer.renderSectionsCard(title, sections, actions);
         if (options.updateMessageId)
@@ -5777,6 +6183,15 @@ export class ProxySessionController {
         else
             await this.outbound.sendInteractiveCard(contextKey, card);
     }
+    statusPreviewActions(contextKey, turnId, source) {
+        if (!turnId || turnId.startsWith("pending_"))
+            return [];
+        if (source && this.runtimes.forAgent(source.agentName).readRemoteTurn) {
+            this.store.saveTurnRuntimeOrigin(turnId, source.localSessionId ?? remoteSessionReference(source.agentName, source.remoteSessionId), source.agentName, source.remoteSessionId);
+        }
+        const url = this.outbound.getTurnPreviewUrl(contextKey, turnId);
+        return url ? [{ text: "Preview", value: {}, url }] : [];
+    }
     async statusForCodexTask(contextKey, reference, options = {}) {
         const { agentName, remote } = await this.resolveRemoteCodexSession(reference, { view: "latest-full" });
         const runtime = this.runtimes.forAgent(agentName);
@@ -5824,6 +6239,7 @@ export class ProxySessionController {
         const actions = [
             statusRefreshAction(actionReference, contextKey),
             statusCardAction(showStop ? "Stop" : "Switch", showStop ? "danger" : "default", showStop ? "session_stop" : "session_switch", actionReference, contextKey),
+            ...this.statusPreviewActions(contextKey, remote.lastTurnId, { agentName, remoteSessionId: remote.id }),
         ];
         const card = this.cardRenderer.renderSectionsCard(title, sections, actions);
         if (options.updateMessageId)
@@ -5891,7 +6307,7 @@ export class ProxySessionController {
         }
         this.store.setChatRequiresMention(chatContextKey, enabled);
         await this.outbound.sendText(contextKey, enabled
-            ? "已开启当前群的静音模式。之后只有 @ 机器人的消息会被处理；发送 @机器人 /mute off 可恢复自动响应。"
+            ? "已开启当前群的静音模式。之后只有 @ 机器人的消息会被处理；普通提问会补充当前群/话题近期文字和图片（最多 20 条、6 张图片）。发送 @机器人 /mute off 可恢复自动响应并关闭自动补充。"
             : "已关闭当前群的静音模式。机器人将恢复自动响应群消息。");
     }
     requireControlSession(localSessionId) {
@@ -6624,6 +7040,18 @@ function isUnmaterializedCodexThreadError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return /thread\/read failed:[^\n]*(?:not materialized|not loaded|includeTurns is unavailable before first user message)/i.test(message);
 }
+function needsHistoricalDetails(state) {
+    if (!isTerminalTurnViewStatus(state.status) || state.historyDetail === "full")
+        return false;
+    if (state.historyDetail === "summary")
+        return true;
+    return state.status === "completed" && state.finalResponse === undefined && !state.assistantText
+        && !state.error && !state.progressText && !state.approval && !state.activeTool
+        && !state.activities?.length && !state.plan?.length && !state.reasoningItems?.length
+        && !state.completedTools?.length && !state.failedTools?.length && !state.fileSummary?.length
+        && !state.totalToolCount && !state.totalTokens
+        && state.fullToolOutputs === undefined && state.fullToolErrors === undefined && state.toolStatuses === undefined;
+}
 function turnViewSnapshot(value) {
     if (!value || typeof value !== "object")
         return undefined;
@@ -6937,7 +7365,7 @@ function isBotOwnedActiveTurn(record, remote) {
         && record.lastTurnId === remote.lastTurnId;
 }
 function isQueueIndependentCommand(command) {
-    if (["archive", "dismiss", "stop", "status", "restart", "release", "mute", "help", "sessions", "dir", "file", "goal", "nosteer", "shell"].includes(command.type))
+    if (["archive", "dismiss", "stop", "status", "restart", "update", "release", "mute", "help", "sessions", "dir", "file", "goal", "nosteer", "shell"].includes(command.type))
         return true;
     if (command.type === "agent")
         return command.agent === undefined;