@keyou007/agent-bot 0.1.18 → 0.1.19-alpha.1

package/dist/proxy/ProxySessionController.js

@@ -3,6 +3,7 @@ import { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createProjectlessWorkspace, detectProjectlessWorkspace } from "../codex/ProjectlessWorkspace.js";
+import { SystemThreadWriterProcessController, } from "../codex/ThreadWriterProcess.js";
 import { resolveUserPath } from "../config/paths.js";
 import { DEFAULT_GROUP_NAME_FORMAT, } from "../config/schema.js";
 import { CommandRouter } from "../commands/CommandRouter.js";
@@ -14,12 +15,21 @@ import { formatGroupNameDate, formatNewGroupName, parseTaskNameFromGroupName, }
 import { normalizeFeishuPostText } from "../feishu/InboundText.js";
 import { allowsFeishuUser } from "../feishu/ownerAccess.js";
 import { classifyFileContent } from "../local-files/LocalFileViewerServer.js";
+import { errorLogValue } from "../logging/errorLogValue.js";
 import { buildTurnGraphRows } from "../presentation/turnGraph.js";
 import { isActiveShellCommandJob, ShellCommandJobManager, } from "../shell/ShellCommandJobManager.js";
 import { createId } from "../utils/id.js";
 import { truncateMiddle, truncateText } from "../utils/markdown.js";
 import { normalizeTaskTitle } from "../utils/taskTitle.js";
 import { executeShellCommand, } from "../utils/executeShellCommand.js";
+class PresentedRequestError extends Error {
+    originalError;
+    constructor(originalError) {
+        super(originalError instanceof Error ? originalError.message : String(originalError), { cause: originalError });
+        this.originalError = originalError;
+        this.name = "PresentedRequestError";
+    }
+}
 const MESSAGE_RECEIVED_REACTION = "OnIt";
 const MESSAGE_COMPLETED_REACTION = "DONE";
 const MESSAGE_FAILED_REACTION = "ERROR";
@@ -28,12 +38,15 @@ const SESSION_PAGE_SIZE = 10;
 const SESSION_PROMPT_PREVIEW_LENGTH = 50;
 const DIRECTORY_PAGE_SIZE = 15;
 const RESET_HISTORY_PAGE_SIZE = 10;
+const REMOTE_TURN_HISTORY_REFRESH_INTERVAL_MS = 30_000;
 const MAX_LLM_TURN_RETRIES = 3;
 const QUEUED_PROMPT_RETRY_DELAY_MS = 5_000;
 const RECOVERY_ACTIVITY_WINDOW_MS = 10 * 60 * 1_000;
 const RECOVERY_HEARTBEAT_INTERVAL_MS = 60 * 1_000;
 const SHELL_COMMAND_JOB_POLL_INTERVAL_MS = 1_000;
 const SHELL_COMMAND_JOB_RELAUNCH_DELAY_MS = 5_000;
+const APP_SERVER_RELEASE_POLL_INTERVAL_MS = 500;
+const APP_SERVER_RELEASE_IDLE_DELAY_MS = 5_000;
 const FORWARD_ATTACHMENT_WINDOW_MS = 800;
 const DEFAULT_MERGED_FORWARD_INSTRUCTION = "请参考以下内容回复用户";
 const DEFAULT_REFERENCED_MESSAGE_INSTRUCTION = "请参考引用消息回复用户";
@@ -156,6 +169,10 @@ const HELP_COMMAND_SECTIONS = [
                 usage: "[--force]",
                 description: "默认安全重启；--force 立即重启",
             },
+            {
+                command: "/release",
+                description: "释放 Agent Bot 占用的 App Server 任务",
+            },
             {
                 command: "/mute",
                 usage: "[on|off]",
@@ -178,6 +195,7 @@ export class ProxySessionController {
     shellCommandExecutor;
     windowsDriveLister;
     shellCommandJobs;
+    threadWriterProcesses;
     router = new CommandRouter();
     cardRenderer = new CardRenderer();
     messageQueues = new Map();
@@ -187,6 +205,7 @@ export class ProxySessionController {
     queuedPromptCardWrites = new Map();
     sessionResets = new Map();
     resetHistoryOperations = new Map();
+    remoteTurnHistoryRefreshes = new Map();
     lastSessionListings = new Map();
     threadInitializations = new Map();
     llmRetryingSessions = new Set();
@@ -197,11 +216,13 @@ export class ProxySessionController {
     pendingResourceForwards = new Map();
     relatedReactionMessageIds = new Map();
     shellCommandJobMonitors = new Map();
+    appServerReleaseSchedules = new Map();
+    nextAppServerReleaseScheduleId = 1;
     unsubscribe = [];
     recoveryActivityHeartbeat;
     startupRecovery;
     queuedPromptsRestored = false;
-    constructor(config, store, runtimes, outbound, logger, lifecycle, shellCommandExecutor = executeShellCommand, windowsDriveLister = listWindowsDriveRoots, shellCommandJobs = new ShellCommandJobManager(path.join(path.dirname(config.storage.sqlitePath), "command-jobs"))) {
+    constructor(config, store, runtimes, outbound, logger, lifecycle, shellCommandExecutor = executeShellCommand, windowsDriveLister = listWindowsDriveRoots, shellCommandJobs = new ShellCommandJobManager(path.join(path.dirname(config.storage.sqlitePath), "command-jobs")), threadWriterProcesses = new SystemThreadWriterProcessController()) {
         this.config = config;
         this.store = store;
         this.runtimes = runtimes;
@@ -211,6 +232,7 @@ export class ProxySessionController {
         this.shellCommandExecutor = shellCommandExecutor;
         this.windowsDriveLister = windowsDriveLister;
         this.shellCommandJobs = shellCommandJobs;
+        this.threadWriterProcesses = threadWriterProcesses;
         for (const [, runtime] of this.runtimes.entries()) {
             this.unsubscribe.push(runtime.onEvent((event) => {
                 void this.handleRuntimeEvent(event).catch((error) => {
@@ -328,7 +350,11 @@ export class ProxySessionController {
                     : undefined;
                 await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
                 const detail = result.error instanceof Error ? result.error.message : String(result.error);
-                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, new Error(`无法读取合并转发消息：${detail}`)));
+                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, new Error(`无法读取合并转发消息：${detail}`), {
+                    requestId: message.messageId,
+                    messageId: message.messageId,
+                    phase: "merged_forward_read",
+                }));
                 return;
             }
             const instruction = message.displayText ?? DEFAULT_MERGED_FORWARD_INSTRUCTION;
@@ -360,7 +386,11 @@ export class ProxySessionController {
                     : undefined;
                 await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
                 const detail = error instanceof Error ? error.message : String(error);
-                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, new Error(`无法读取引用消息：${detail}`)));
+                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, new Error(`无法读取引用消息：${detail}`), {
+                    requestId: message.messageId,
+                    messageId: message.messageId,
+                    phase: "referenced_message_read",
+                }));
                 return;
             }
         }
@@ -394,7 +424,11 @@ export class ProxySessionController {
             }
             catch (error) {
                 await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
-                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, error));
+                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, error, {
+                    requestId: message.messageId,
+                    messageId: message.messageId,
+                    phase: "image_download",
+                }));
                 return;
             }
         }
@@ -413,7 +447,11 @@ export class ProxySessionController {
             }
             catch (error) {
                 await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
-                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, error));
+                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, error, {
+                    requestId: message.messageId,
+                    messageId: message.messageId,
+                    phase: "file_download",
+                }));
                 return;
             }
         }
@@ -426,9 +464,21 @@ export class ProxySessionController {
         }
         catch (error) {
             await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
-            await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, error));
+            await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, error, {
+                requestId: message.messageId,
+                messageId: message.messageId,
+                phase: "command_parse",
+            }));
             return;
         }
+        if (command.type !== "prompt") {
+            this.logger.info({
+                requestId: message.messageId,
+                messageId: message.messageId,
+                contextKey: message.contextKey,
+                command: command.type,
+            }, "Processing Agent Bot command.");
+        }
         // Operational and read-only commands must remain available even if a prompt operation is slow.
         if (isQueueIndependentCommand(command)) {
             await this.outbound.withReplyTarget(message.contextKey, replyTarget, async () => {
@@ -442,7 +492,12 @@ export class ProxySessionController {
                 }
                 catch (error) {
                     await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
-                    await this.sendError(message.contextKey, error);
+                    await this.sendError(message.contextKey, error, {
+                        requestId: message.messageId,
+                        messageId: message.messageId,
+                        command: command.type,
+                        phase: "command_execute",
+                    });
                 }
             });
             return;
@@ -450,16 +505,41 @@ export class ProxySessionController {
         const previous = this.messageQueues.get(message.contextKey) ?? Promise.resolve();
         const next = previous.catch(() => undefined).then(() => this.outbound.withReplyTarget(message.contextKey, replyTarget, async () => {
             try {
-                if (command.type === "prompt")
+                let executableCommand = command;
+                let executableImagePaths = localImagePaths;
+                let executableMessage = message;
+                let injectedRootMessageId;
+                if (command.type === "prompt") {
                     await this.ensureThreadFork(message);
-                await this.execute(message.contextKey, command, message.messageId, replyTarget, localImagePaths, message.userId, message);
+                    const prepared = await this.prepareTopicRootPrompt(message, command.text, localImagePaths);
+                    executableCommand = { ...command, text: prepared.text };
+                    executableImagePaths = prepared.localImagePaths;
+                    executableMessage = { ...message, displayText: prepared.displayPrompt };
+                    injectedRootMessageId = prepared.injectedRootMessageId;
+                }
+                await this.execute(message.contextKey, executableCommand, message.messageId, replyTarget, executableImagePaths, message.userId, executableMessage);
+                if (injectedRootMessageId) {
+                    const current = this.currentSession(message.contextKey);
+                    if (current) {
+                        this.store.audit(message.contextKey, "topic_root_injected", {
+                            localSessionId: current.localSessionId,
+                            rootMessageId: injectedRootMessageId,
+                            promptMessageId: message.messageId,
+                        });
+                    }
+                }
                 if (!commandDefersReactionFinalization(command)) {
                     await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
                 }
             }
             catch (error) {
                 await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
-                await this.sendError(message.contextKey, error);
+                await this.sendError(message.contextKey, error, {
+                    requestId: message.messageId,
+                    messageId: message.messageId,
+                    command: command.type,
+                    phase: "command_execute",
+                });
             }
         }));
         this.messageQueues.set(message.contextKey, next);
@@ -479,7 +559,11 @@ export class ProxySessionController {
             resolvedAction = this.resolveCardActionBinding(action);
         }
         catch (error) {
-            await this.sendError(action.contextKey, error);
+            await this.sendError(action.contextKey, error, {
+                requestId: action.actionId,
+                actionId: action.actionId,
+                phase: "card_action_resolve",
+            });
             return;
         }
         const contextKey = this.cardActionContextKey(resolvedAction);
@@ -510,6 +594,24 @@ export class ProxySessionController {
                 else if (kind === "shell_command_cancel") {
                     await this.cancelShellCommandJob(contextKey, String(scopedAction.value.jobId ?? ""));
                 }
+                else if (kind === "thread_writer_close") {
+                    await this.closeThreadWriter(scopedAction, contextKey);
+                }
+                else if (kind === "thread_writer_fork") {
+                    const sessionId = String(scopedAction.value.sessionId ?? "");
+                    const threadId = String(scopedAction.value.threadId ?? "");
+                    const record = this.requireSession(contextKey, sessionId);
+                    if (!threadId || record.remoteSessionId !== threadId) {
+                        throw new Error("任务占用卡片已经失效，请重新发送消息获取最新状态。");
+                    }
+                    await this.forkSessionReference(contextKey, sessionId);
+                }
+                else if (kind === "app_server_release_now") {
+                    await this.releaseAppServerNow(scopedAction);
+                }
+                else if (kind === "app_server_release_cancel") {
+                    await this.cancelAppServerRelease(scopedAction);
+                }
                 else if (kind === "turn_reset") {
                     const sessionId = String(scopedAction.value.sessionId ?? "");
                     const turnId = String(scopedAction.value.turnId ?? "");
@@ -734,7 +836,12 @@ export class ProxySessionController {
                 }
             }
             catch (error) {
-                await this.sendError(contextKey, error);
+                await this.sendError(contextKey, error, {
+                    requestId: scopedAction.actionId,
+                    actionId: scopedAction.actionId,
+                    command: String(scopedAction.value.action ?? "unknown"),
+                    phase: "card_action_execute",
+                });
             }
         });
     }
@@ -760,6 +867,7 @@ export class ProxySessionController {
         this.queuedPromptCardWrites.clear();
         this.sessionResets.clear();
         this.resetHistoryOperations.clear();
+        this.remoteTurnHistoryRefreshes.clear();
         for (const pending of this.pendingMergedForwards.values())
             pending.resolveAttachment(undefined);
         this.pendingMergedForwards.clear();
@@ -773,6 +881,11 @@ export class ProxySessionController {
         for (const timer of this.recoveryRetryTimers.values())
             clearTimeout(timer);
         this.recoveryRetryTimers.clear();
+        for (const schedule of this.appServerReleaseSchedules.values()) {
+            if (schedule.timer)
+                clearTimeout(schedule.timer);
+        }
+        this.appServerReleaseSchedules.clear();
         for (const [jobId] of this.shellCommandJobMonitors)
             this.stopShellCommandJobMonitor(jobId);
         clearInterval(this.recoveryActivityHeartbeat);
@@ -784,6 +897,19 @@ export class ProxySessionController {
         await this.cancelSession(record);
         return `Task stop requested: ${record.title ?? record.remoteSessionId ?? record.localSessionId}`;
     }
+    async controlReleaseTask(localSessionId) {
+        const record = this.requireControlSession(localSessionId);
+        const contextKey = this.controlSessionContextKey(record);
+        const result = await this.outbound.withReplyTarget(contextKey, this.controlSessionReplyTarget(record), () => this.requestAppServerRelease(contextKey, record));
+        if (result.status === "failed")
+            throw new Error(result.error ?? "Failed to release App Server tasks.");
+        return {
+            agentName: result.agentName,
+            status: result.status,
+            blockingTaskCount: result.blockingTaskCount,
+            ...(result.releaseInSeconds !== undefined ? { releaseInSeconds: result.releaseInSeconds } : {}),
+        };
+    }
     async controlArchiveTask(localSessionId) {
         const record = this.requireControlSession(localSessionId);
         return this.archiveSessionReference(this.controlSessionContextKey(record), localSessionId, {
@@ -1377,6 +1503,9 @@ export class ProxySessionController {
                     throw new Error("当前运行方式不支持自动重启。");
                 await this.lifecycle.restart(contextKey, command.force === true, replyTarget);
                 return;
+            case "release":
+                await this.requestAppServerRelease(contextKey);
+                return;
             case "mute":
                 await this.setGroupMute(contextKey, command.enabled);
                 return;
@@ -1809,6 +1938,9 @@ export class ProxySessionController {
             loaded = await this.loadSession(record);
         }
         catch (error) {
+            if (await this.presentThreadWriterConflict(record, contextKey, error, true)) {
+                throw new PresentedRequestError(error);
+            }
             await this.outbound.failPendingTurn(record.localSessionId, error instanceof Error ? error.message : String(error));
             throw error;
         }
@@ -2021,6 +2153,49 @@ export class ProxySessionController {
             }
         }
     }
+    async prepareTopicRootPrompt(message, text, localImagePaths) {
+        const displayPrompt = message.displayText ?? text;
+        const rootMessageId = topicRootMessageId(message);
+        if (!rootMessageId)
+            return { text, localImagePaths, displayPrompt };
+        const current = this.currentSession(message.contextKey);
+        if (current && (this.store.hasInjectedTopicRoot(current.localSessionId, rootMessageId)
+            || this.taskHistoryContainsMessage(current, rootMessageId))) {
+            return { text, localImagePaths, displayPrompt };
+        }
+        try {
+            const root = await this.resolveReferencedMessage(message.contextKey, rootMessageId);
+            const rootImagePaths = await Promise.all(root.images.map((image) => this.outbound.downloadImage(message.contextKey, image.messageId, image.imageKey)));
+            let promptText = topicRootMessagePrompt(text, root.text);
+            if (root.files.length > 0) {
+                const downloadedFiles = await Promise.all(root.files.map(async (file) => ({
+                    fileName: file.fileName,
+                    filePath: await this.outbound.downloadFile(message.contextKey, file.messageId, file.fileKey, file.fileName),
+                })));
+                promptText = appendDownloadedFiles(promptText, downloadedFiles);
+            }
+            const combinedImagePaths = [...new Set([...(localImagePaths ?? []), ...rootImagePaths])];
+            return {
+                text: promptText,
+                ...(combinedImagePaths.length > 0 ? { localImagePaths: combinedImagePaths } : {}),
+                displayPrompt,
+                injectedRootMessageId: rootMessageId,
+            };
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new Error(`无法读取话题根消息：${detail}`);
+        }
+    }
+    taskHistoryContainsMessage(record, messageId) {
+        const anchor = this.store.findTurnAnchorByMessageId(messageId);
+        if (!anchor)
+            return false;
+        if (record.lastTurnId === anchor.turnId)
+            return true;
+        return this.store.listTaskTurnGraph(record.localSessionId)
+            .some((turn) => turn.turnId === anchor.turnId);
+    }
     async forkThreadSession(message) {
         const { anchor, source, snapshot } = this.resolveThreadForkAnchor(message);
         const agent = this.ensureAgent(source.agentName);
@@ -2515,6 +2690,38 @@ export class ProxySessionController {
             this.logger.warn({ error, localSessionId: current.localSessionId, sourceRemoteSessionId: source.sourceRemoteSessionId }, "Failed to hydrate legacy Fork Turn history; rendering the locally available history.");
         }
     }
+    async hydrateRemoteTurnHistory(contextKey, current) {
+        if (!current.remoteSessionId)
+            return;
+        const refreshedAt = this.remoteTurnHistoryRefreshes.get(current.localSessionId);
+        if (refreshedAt !== undefined && Date.now() - refreshedAt < REMOTE_TURN_HISTORY_REFRESH_INTERVAL_MS)
+            return;
+        const forkSource = this.store.getForkHistorySource(current.localSessionId);
+        if (forkSource?.sourceTurnId === current.lastTurnId
+            && this.store.hasImportedForkTurnHistory(current.localSessionId))
+            return;
+        const runtime = this.runtimes.forAgent(current.agentName);
+        if (runtime.kind !== "codex" || !runtime.readRemoteSession)
+            return;
+        try {
+            const remote = await runtime.readRemoteSession(current.remoteSessionId);
+            this.remoteTurnHistoryRefreshes.set(current.localSessionId, Date.now());
+            const completedTurns = remote.completedTurns ?? [];
+            if (completedTurns.length === 0)
+                return;
+            this.persistCompletedTurnHistory({
+                localSessionId: current.localSessionId,
+                contextKey,
+                agentName: current.agentName,
+                remoteSessionId: current.remoteSessionId,
+                completedTurns,
+                fallbackStart: parseIsoTimestamp(current.createdAt) ?? Date.now() - completedTurns.length,
+            });
+        }
+        catch (error) {
+            this.logger.warn({ error, localSessionId: current.localSessionId, remoteSessionId: current.remoteSessionId }, "Failed to hydrate App Server Turn history; rendering the locally available history.");
+        }
+    }
     async createProjectSessionFromReference(contextKey, reference) {
         const resolved = await this.resolveProjectSessionReference(contextKey, reference);
         const created = await this.createSession(contextKey, resolved.agentName, resolved.cwd, true, false, undefined, undefined, undefined, resolved.executionSettings);
@@ -2900,6 +3107,8 @@ export class ProxySessionController {
                     });
                 }
                 catch (error) {
+                    if (activeWriterThreadId(error))
+                        throw error;
                     if (!(agent.kind === "app-server" && !record.lastTurnId && isMissingRolloutError(error)))
                         throw error;
                     this.logger.warn({ error, sessionId: record.localSessionId }, "App Server task has no rollout; creating a replacement task.");
@@ -4197,6 +4406,7 @@ export class ProxySessionController {
             throw new Error("当前任务不是可 Reset 的 App Server 任务。");
         }
         await this.hydrateLegacyForkTurnHistory(contextKey, current);
+        await this.hydrateRemoteTurnHistory(contextKey, current);
         const completedTurns = this.store.listTaskTurnGraph(current.localSessionId);
         const completedTurnIds = new Set(completedTurns.map((turn) => turn.turnId));
         const runningTurnId = current.lastTurnStatus === "running" && current.lastTurnId
@@ -4514,7 +4724,7 @@ export class ProxySessionController {
             if (!runtime.listRemoteSessions)
                 return;
             try {
-                const result = await runtime.listRemoteSessions({ searchTerm, limit: fetchLimit });
+                const result = await this.listRemoteSessionsThroughCursor(runtime, searchTerm, fetchLimit);
                 remoteSessions.push(...result.sessions.map((session) => ({ agentName, session })));
                 remoteHasMore ||= Boolean(result.nextCursor);
             }
@@ -4712,6 +4922,37 @@ export class ProxySessionController {
             }
         }
     }
+    async listRemoteSessionsThroughCursor(runtime, searchTerm, limit) {
+        const sessions = [];
+        const seenSessionIds = new Set();
+        const seenCursors = new Set();
+        let cursor;
+        while (sessions.length < limit) {
+            const page = await runtime.listRemoteSessions({
+                searchTerm,
+                ...(cursor ? { cursor } : {}),
+                limit: limit - sessions.length,
+            });
+            for (const session of page.sessions) {
+                if (seenSessionIds.has(session.id))
+                    continue;
+                seenSessionIds.add(session.id);
+                sessions.push(session);
+            }
+            const nextCursor = page.nextCursor?.trim() || undefined;
+            if (!nextCursor)
+                return { sessions };
+            if (sessions.length >= limit)
+                return { sessions, nextCursor };
+            if (seenCursors.has(nextCursor)) {
+                this.logger.warn({ cursor: nextCursor }, "App Server repeated a thread/list cursor; stopping pagination.");
+                return { sessions };
+            }
+            seenCursors.add(nextCursor);
+            cursor = nextCursor;
+        }
+        return { sessions };
+    }
     async refreshSessionsCardFromAction(action, options = {}) {
         if (!action.messageId)
             return;
@@ -5262,14 +5503,26 @@ export class ProxySessionController {
                 description: command.description,
             })),
         }));
-        await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderHelpCard("Agent Bot 使用帮助", [
+        const introLines = [
             "直接发送消息即可继续当前任务；执行中发送的新消息会追加到本次任务。",
             "点击命令按钮可执行默认形式；有必填参数的命令需要手动发送。",
             "> 命令前缀示例：/sess 等同于 /sessions。",
             "> 命令缩写示例：/fg 等同于 /forkgroup。",
             "前缀或缩写匹配多个命令时，需要输入更长的形式。",
             "**[参数]** 可选　**&#60;参数&#62;** 必填",
-        ], sections));
+        ];
+        try {
+            await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderHelpCard("Agent Bot 使用帮助", introLines, sections));
+        }
+        catch (cardError) {
+            this.logger.warn({ error: cardError, contextKey, command: "help", phase: "help_card_send" }, "Failed to send the help card; falling back to plain text.");
+            try {
+                await this.outbound.sendText(contextKey, renderPlainHelp(introLines, sections));
+            }
+            catch (textError) {
+                throw new AggregateError([cardError, textError], "帮助卡片和纯文本帮助均发送失败。");
+            }
+        }
     }
     async setGroupMute(contextKey, enabled) {
         const chatContextKey = baseChatContextKey(contextKey);
@@ -5375,11 +5628,506 @@ export class ProxySessionController {
             throw new Error(`找不到任务：${sessionId}`);
         return record;
     }
-    async sendError(contextKey, error) {
-        this.logger.warn({ error, contextKey }, "Request failed.");
-        await this.outbound.sendText(contextKey, error instanceof Error ? error.message : String(error));
+    async requestAppServerRelease(contextKey, requestedRecord) {
+        const record = requestedRecord ?? this.requireCurrentSession(contextKey);
+        const runtime = this.runtimes.forAgent(record.agentName);
+        if (!this.isCodexSession(record) || runtime.kind !== "codex" || !runtime.release) {
+            throw new Error("当前 Agent 不使用可释放的 App Server。");
+        }
+        let schedule = this.appServerReleaseSchedules.get(record.agentName);
+        const created = !schedule;
+        if (!schedule) {
+            const blockingTaskCount = this.appServerReleaseBlockers(record.agentName, runtime).length;
+            schedule = {
+                id: this.nextAppServerReleaseScheduleId++,
+                agentName: record.agentName,
+                runtime,
+                status: "waiting",
+                blockingTaskCount,
+                targets: new Map(),
+                forced: false,
+                ...(blockingTaskCount === 0
+                    ? {
+                        releaseCountdownSeconds: Math.ceil(APP_SERVER_RELEASE_IDLE_DELAY_MS / 1_000),
+                    }
+                    : {}),
+            };
+            this.appServerReleaseSchedules.set(record.agentName, schedule);
+        }
+        try {
+            const messageId = await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderAppServerRelease(this.appServerReleaseCardView(schedule, contextKey)));
+            if (messageId) {
+                schedule.targets.set(`${contextKey}\u0000${messageId}`, { contextKey, messageId });
+            }
+            if (schedule.status === "waiting"
+                && schedule.blockingTaskCount === 0
+                && schedule.releaseCountdownSeconds !== undefined
+                && schedule.releaseAt === undefined) {
+                schedule.releaseAt = Date.now() + APP_SERVER_RELEASE_IDLE_DELAY_MS;
+            }
+        }
+        catch (error) {
+            if (created && schedule.targets.size === 0) {
+                this.clearAppServerReleaseSchedule(schedule);
+            }
+            throw error;
+        }
+        this.armAppServerReleaseCheck(schedule);
+        return {
+            agentName: schedule.agentName,
+            status: schedule.status === "failed" ? "failed" : schedule.status === "released" ? "released" : "waiting",
+            blockingTaskCount: schedule.blockingTaskCount,
+            ...(schedule.releaseCountdownSeconds !== undefined
+                ? { releaseInSeconds: schedule.releaseCountdownSeconds }
+                : {}),
+            ...(schedule.error ? { error: schedule.error } : {}),
+        };
+    }
+    async releaseAppServerNow(action) {
+        const scheduleId = Number(action.value.scheduleId);
+        const agentName = typeof action.value.agentName === "string" ? action.value.agentName : "";
+        const schedule = this.appServerReleaseSchedules.get(agentName);
+        if (!Number.isSafeInteger(scheduleId) || !schedule || schedule.id !== scheduleId || schedule.status !== "waiting") {
+            throw new Error("释放卡片已失效，请重新发送 /release。");
+        }
+        await this.performAppServerRelease(schedule, true);
+    }
+    async cancelAppServerRelease(action) {
+        const scheduleId = Number(action.value.scheduleId);
+        const agentName = typeof action.value.agentName === "string" ? action.value.agentName : "";
+        const schedule = this.appServerReleaseSchedules.get(agentName);
+        const cancellable = schedule?.status === "waiting"
+            || (schedule?.status === "releasing" && schedule.releaseStarted !== true);
+        if (!Number.isSafeInteger(scheduleId) || !schedule || schedule.id !== scheduleId || !cancellable) {
+            throw new Error("释放卡片已失效，请重新发送 /release。");
+        }
+        const pendingRelease = schedule.inFlight;
+        schedule.status = "cancelled";
+        if (schedule.timer) {
+            clearTimeout(schedule.timer);
+            schedule.timer = undefined;
+        }
+        if (pendingRelease)
+            await pendingRelease;
+        await this.publishAppServerReleaseSchedule(schedule);
+        this.clearAppServerReleaseSchedule(schedule);
+    }
+    appServerReleaseBlockers(agentName, runtime) {
+        return this.store.listAllSessions().filter((session) => {
+            if (session.agentName !== agentName || session.status === "closed")
+                return false;
+            return session.status === "starting"
+                || session.status === "running"
+                || this.store.countQueuedPrompts(session.localSessionId) > 0
+                || this.queuedPromptStarts.has(session.localSessionId)
+                || this.sessionLoads.has(session.localSessionId)
+                || Boolean(runtime.getSession(session.localSessionId)?.activeTurnId);
+        });
+    }
+    armAppServerReleaseCheck(schedule) {
+        if (schedule.status !== "waiting" || schedule.timer || schedule.inFlight)
+            return;
+        schedule.timer = setTimeout(() => {
+            schedule.timer = undefined;
+            void this.refreshAppServerReleaseSchedule(schedule).catch((error) => {
+                this.logger.warn({ error, agentName: schedule.agentName }, "Failed to refresh App Server release status.");
+                this.armAppServerReleaseCheck(schedule);
+            });
+        }, APP_SERVER_RELEASE_POLL_INTERVAL_MS);
+        schedule.timer.unref?.();
+    }
+    async refreshAppServerReleaseSchedule(schedule) {
+        if (this.appServerReleaseSchedules.get(schedule.agentName) !== schedule || schedule.status !== "waiting")
+            return;
+        const blockingTaskCount = this.appServerReleaseBlockers(schedule.agentName, schedule.runtime).length;
+        if (blockingTaskCount > 0) {
+            const changed = schedule.blockingTaskCount !== blockingTaskCount || schedule.releaseAt !== undefined;
+            schedule.releaseAt = undefined;
+            schedule.releaseCountdownSeconds = undefined;
+            if (changed) {
+                schedule.blockingTaskCount = blockingTaskCount;
+                await this.publishAppServerReleaseSchedule(schedule);
+            }
+            this.armAppServerReleaseCheck(schedule);
+            return;
+        }
+        schedule.blockingTaskCount = 0;
+        if (schedule.releaseAt !== undefined) {
+            const releaseCountdownSeconds = Math.max(0, Math.ceil((schedule.releaseAt - Date.now()) / 1_000));
+            if (releaseCountdownSeconds > 0) {
+                if (schedule.releaseCountdownSeconds !== releaseCountdownSeconds) {
+                    schedule.releaseCountdownSeconds = releaseCountdownSeconds;
+                    await this.publishAppServerReleaseSchedule(schedule);
+                }
+                this.armAppServerReleaseCheck(schedule);
+                return;
+            }
+        }
+        await this.performAppServerRelease(schedule, false);
+    }
+    async performAppServerRelease(schedule, force) {
+        if (schedule.inFlight)
+            return schedule.inFlight;
+        const operation = this.performAppServerReleaseNow(schedule, force);
+        schedule.inFlight = operation;
+        try {
+            await operation;
+        }
+        finally {
+            if (schedule.inFlight === operation)
+                schedule.inFlight = undefined;
+            if (schedule.status === "waiting")
+                this.armAppServerReleaseCheck(schedule);
+        }
+    }
+    async performAppServerReleaseNow(schedule, force) {
+        if (schedule.timer) {
+            clearTimeout(schedule.timer);
+            schedule.timer = undefined;
+        }
+        const interruptedWork = force && this.appServerReleaseBlockers(schedule.agentName, schedule.runtime).length > 0;
+        if (force)
+            await this.cancelQueuedPromptsForAppServerRelease(schedule.agentName);
+        else {
+            const blockingTaskCount = this.appServerReleaseBlockers(schedule.agentName, schedule.runtime).length;
+            if (blockingTaskCount > 0) {
+                schedule.status = "waiting";
+                schedule.blockingTaskCount = blockingTaskCount;
+                schedule.releaseAt = undefined;
+                schedule.releaseCountdownSeconds = undefined;
+                schedule.releaseStarted = false;
+                await this.publishAppServerReleaseSchedule(schedule);
+                this.armAppServerReleaseCheck(schedule);
+                return;
+            }
+        }
+        schedule.status = "releasing";
+        schedule.blockingTaskCount = 0;
+        schedule.releaseAt = undefined;
+        schedule.releaseCountdownSeconds = undefined;
+        schedule.releaseStarted = false;
+        schedule.forced = interruptedWork;
+        await this.publishAppServerReleaseSchedule(schedule);
+        if (this.appServerReleaseWasCancelled(schedule)
+            || this.appServerReleaseSchedules.get(schedule.agentName) !== schedule)
+            return;
+        schedule.releaseStarted = true;
+        try {
+            const result = await schedule.runtime.release?.({ force });
+            if (!result)
+                throw new Error("当前 Agent 不支持释放 App Server。");
+            if (result.status === "busy") {
+                schedule.status = "waiting";
+                schedule.blockingTaskCount = Math.max(result.activeSessionIds?.length ?? 0, this.appServerReleaseBlockers(schedule.agentName, schedule.runtime).length, 1);
+                schedule.forced = false;
+                schedule.releaseAt = undefined;
+                schedule.releaseCountdownSeconds = undefined;
+                schedule.releaseStarted = false;
+                await this.publishAppServerReleaseSchedule(schedule);
+                this.armAppServerReleaseCheck(schedule);
+                return;
+            }
+            schedule.status = "released";
+        }
+        catch (error) {
+            schedule.status = "failed";
+            schedule.error = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ error, agentName: schedule.agentName }, "Failed to release App Server tasks.");
+        }
+        await this.publishAppServerReleaseSchedule(schedule);
+        this.clearAppServerReleaseSchedule(schedule);
+    }
+    appServerReleaseWasCancelled(schedule) {
+        return schedule.status === "cancelled";
+    }
+    async cancelQueuedPromptsForAppServerRelease(agentName) {
+        for (const session of this.store.listAllSessions()) {
+            if (session.agentName !== agentName)
+                continue;
+            const retryTimer = this.queuedPromptRetryTimers.get(session.localSessionId);
+            if (retryTimer) {
+                clearTimeout(retryTimer);
+                this.queuedPromptRetryTimers.delete(session.localSessionId);
+            }
+            const queued = this.store.listQueuedPrompts(session.localSessionId);
+            for (const prompt of queued) {
+                const cancelled = this.store.cancelQueuedPrompt(prompt.promptId, session.localSessionId);
+                if (!cancelled?.messageId)
+                    continue;
+                await this.finalizeStandaloneMessageReaction(cancelled.messageId, "cancelled").catch((error) => {
+                    this.logger.warn({ error, agentName, sessionId: session.localSessionId, promptId: cancelled.promptId }, "Failed to finalize a queued Prompt reaction during App Server release.");
+                });
+            }
+            if (queued.length > 0) {
+                await this.refreshPromptQueueCards(session.localSessionId).catch((error) => {
+                    this.logger.warn({ error, agentName, sessionId: session.localSessionId }, "Failed to refresh queued Prompt cards during App Server release.");
+                });
+            }
+        }
+    }
+    appServerReleaseCardView(schedule, contextKey) {
+        return {
+            status: schedule.status,
+            contextKey,
+            scheduleId: schedule.id,
+            agentName: schedule.agentName,
+            ...(schedule.blockingTaskCount > 0 ? { blockingTaskCount: schedule.blockingTaskCount } : {}),
+            ...(schedule.releaseCountdownSeconds !== undefined
+                ? { releaseInSeconds: schedule.releaseCountdownSeconds }
+                : {}),
+            ...(schedule.forced ? { forced: true } : {}),
+            ...(schedule.error ? { error: schedule.error } : {}),
+        };
+    }
+    async publishAppServerReleaseSchedule(schedule) {
+        await Promise.all([...schedule.targets.values()].map(async (target) => {
+            try {
+                await this.outbound.updateInteractiveCard(target.contextKey, target.messageId, this.cardRenderer.renderAppServerRelease(this.appServerReleaseCardView(schedule, target.contextKey)));
+            }
+            catch (error) {
+                this.logger.warn({ error, agentName: schedule.agentName, messageId: target.messageId }, "Failed to update App Server release card.");
+            }
+        }));
+    }
+    clearAppServerReleaseSchedule(schedule) {
+        if (schedule.timer)
+            clearTimeout(schedule.timer);
+        schedule.timer = undefined;
+        if (this.appServerReleaseSchedules.get(schedule.agentName) === schedule) {
+            this.appServerReleaseSchedules.delete(schedule.agentName);
+        }
+    }
+    async presentThreadWriterConflict(record, contextKey, error, replacePendingTurn) {
+        if (contextKey.startsWith("console:"))
+            return false;
+        const threadId = activeWriterThreadId(error);
+        if (!threadId || record.remoteSessionId !== threadId)
+            return false;
+        const runtime = this.runtimes.forAgent(record.agentName);
+        const lockPath = runtime.getThreadWriterLockPath?.(threadId);
+        let owners = [];
+        if (lockPath) {
+            try {
+                owners = await this.threadWriterProcesses.inspect(lockPath);
+            }
+            catch (inspectionError) {
+                this.logger.warn({ error: inspectionError, threadId, lockPath }, "Failed to inspect the process holding a thread writer lock.");
+            }
+        }
+        const owner = owners.length === 1 ? owners[0] : undefined;
+        const applicationIdle = owner && lockPath
+            ? await this.inspectThreadWriterApplicationIdle(runtime, lockPath, threadId, owner)
+            : undefined;
+        const card = this.cardRenderer.renderThreadWriterConflict(this.threadWriterConflictView(record, contextKey, threadId, owners, "occupied", lockPath
+            ? undefined
+            : "无法识别占用进程。", applicationIdle));
+        if (replacePendingTurn) {
+            const replaced = await this.outbound.failPendingTurn(record.localSessionId, "任务被占用。", card);
+            if (!replaced)
+                await this.outbound.sendInteractiveCard(contextKey, card);
+        }
+        else {
+            await this.outbound.sendInteractiveCard(contextKey, card);
+        }
+        return true;
+    }
+    threadWriterConflictView(record, contextKey, threadId, owners, status, notice, applicationIdle) {
+        const owner = owners.length === 1 ? owners[0] : undefined;
+        return {
+            status,
+            contextKey,
+            sessionId: record.localSessionId,
+            threadId,
+            taskTitle: record.title,
+            notice: notice ?? (owners.length > 1
+                ? `检测到 ${owners.length} 个相关进程，无法安全地自动关闭。`
+                : undefined),
+            applicationIdle,
+            ...(owner ? {
+                owner: {
+                    displayName: owner.displayName,
+                    writerPid: owner.writerPid,
+                    writerProcessName: owner.writerProcessName,
+                    writerStartedAt: owner.writerStartedAt,
+                    applicationPid: owner.applicationPid,
+                    applicationProcessName: owner.applicationProcessName,
+                    applicationStartedAt: owner.applicationStartedAt,
+                    canClose: owner.canClose,
+                },
+            } : {}),
+        };
+    }
+    async closeThreadWriter(action, contextKey) {
+        const messageId = requiredCardMessageId(action.messageId);
+        const sessionId = String(action.value.sessionId ?? "");
+        const threadId = String(action.value.threadId ?? "");
+        const expectedWriterPid = positiveActionPid(action.value.writerPid);
+        const expectedApplicationPid = positiveActionPid(action.value.applicationPid);
+        const expectedWriterStartedAt = String(action.value.writerStartedAt ?? "");
+        const expectedApplicationStartedAt = String(action.value.applicationStartedAt ?? "");
+        const force = action.value.force === true || action.value.force === "true";
+        const record = this.requireSession(contextKey, sessionId);
+        if (!threadId || record.remoteSessionId !== threadId) {
+            throw new Error("任务占用卡片已经失效，请重新发送消息获取最新状态。");
+        }
+        const runtime = this.runtimes.forAgent(record.agentName);
+        const lockPath = runtime.getThreadWriterLockPath?.(threadId);
+        if (!lockPath)
+            throw new Error("当前 Agent 不支持自动关闭占用程序。");
+        let owners = await this.threadWriterProcesses.inspect(lockPath);
+        const expectedOwner = owners.length === 1 && threadWriterMatches(owners[0], expectedWriterPid, expectedWriterStartedAt, expectedApplicationPid, expectedApplicationStartedAt) ? owners[0] : undefined;
+        if (!expectedOwner) {
+            const currentOwner = owners.length === 1 ? owners[0] : undefined;
+            const applicationIdle = currentOwner
+                ? await this.inspectThreadWriterApplicationIdle(runtime, lockPath, threadId, currentOwner)
+                : undefined;
+            await this.outbound.updateInteractiveCard(contextKey, messageId, this.cardRenderer.renderThreadWriterConflict(this.threadWriterConflictView(record, contextKey, threadId, owners, owners.length === 0 ? "released" : "occupied", owners.length === 0
+                ? "请重新发送消息。"
+                : "占用进程已变化，请重试。", applicationIdle)));
+            return;
+        }
+        if (!expectedOwner.canClose)
+            throw new Error("无法确认占用者是 Agent 程序，已拒绝关闭。");
+        try {
+            await this.threadWriterProcesses.close(expectedOwner, force);
+        }
+        catch (error) {
+            owners = await this.threadWriterProcesses.inspect(lockPath);
+            if (owners.some((owner) => threadWriterMatches(owner, expectedWriterPid, expectedWriterStartedAt, expectedApplicationPid, expectedApplicationStartedAt)))
+                throw error;
+        }
+        owners = await this.waitForThreadWriterChange(lockPath, expectedOwner);
+        const sameOwnerRemains = owners.some((owner) => threadWriterMatches(owner, expectedOwner.writerPid, expectedOwner.writerStartedAt ?? "", expectedOwner.applicationPid, expectedOwner.applicationStartedAt ?? ""));
+        if (sameOwnerRemains && force) {
+            throw new Error(`无法关闭 ${expectedOwner.displayName}（PID ${expectedOwner.applicationPid}）。`);
+        }
+        const status = owners.length === 0
+            ? "released"
+            : sameOwnerRemains ? "force_required" : "occupied";
+        const notice = owners.length === 0
+            ? "请重新发送消息。"
+            : sameOwnerRemains
+                ? "普通关闭失败，可强制关闭。"
+                : "占用进程已变化，请重试。";
+        const currentOwner = owners.length === 1 ? owners[0] : undefined;
+        const applicationIdle = currentOwner
+            ? await this.inspectThreadWriterApplicationIdle(runtime, lockPath, threadId, currentOwner)
+            : undefined;
+        await this.outbound.updateInteractiveCard(contextKey, messageId, this.cardRenderer.renderThreadWriterConflict(this.threadWriterConflictView(record, contextKey, threadId, owners, status, notice, applicationIdle)));
+    }
+    async inspectThreadWriterApplicationIdle(runtime, lockPath, threadId, owner) {
+        if (!owner.applicationStartedAt
+            || !this.threadWriterProcesses.inspectApplicationThreadIds
+            || !runtime.inspectRemoteSessionActivity)
+            return undefined;
+        try {
+            const ownedThreadIds = await this.threadWriterProcesses.inspectApplicationThreadIds(lockPath, owner);
+            if (!ownedThreadIds.includes(threadId))
+                return undefined;
+            const activities = await Promise.all(ownedThreadIds.map((ownedThreadId) => runtime.inspectRemoteSessionActivity(ownedThreadId)));
+            return activities.every((activity) => !activity.active);
+        }
+        catch (error) {
+            this.logger.warn({ error, threadId, applicationPid: owner.applicationPid }, "Failed to inspect thread-writer application activity.");
+            return undefined;
+        }
+    }
+    async waitForThreadWriterChange(lockPath, expectedOwner) {
+        const deadline = Date.now() + 5_000;
+        let owners = [];
+        do {
+            owners = await this.threadWriterProcesses.inspect(lockPath);
+            if (!owners.some((owner) => threadWriterMatches(owner, expectedOwner.writerPid, expectedOwner.writerStartedAt ?? "", expectedOwner.applicationPid, expectedOwner.applicationStartedAt ?? "")))
+                return owners;
+            await delay(250);
+        } while (Date.now() < deadline);
+        return owners;
+    }
+    async sendError(contextKey, error, details = {}) {
+        if (error instanceof PresentedRequestError) {
+            this.logger.warn({ error: errorLogValue(error.originalError), contextKey, ...details }, "Request failed after a dedicated error card was presented.");
+            return;
+        }
+        const record = this.currentSession(contextKey);
+        if (record) {
+            try {
+                if (await this.presentThreadWriterConflict(record, contextKey, error, false))
+                    return;
+            }
+            catch (presentationError) {
+                this.logger.warn({ error: presentationError, originalError: errorLogValue(error), contextKey, ...details }, "Failed to present the thread writer conflict card.");
+            }
+        }
+        this.logger.warn({ error, contextKey, ...details }, "Request failed.");
+        try {
+            await this.outbound.sendText(contextKey, error instanceof Error ? error.message : String(error));
+        }
+        catch (deliveryError) {
+            this.logger.error({
+                error: deliveryError,
+                originalError: errorLogValue(error),
+                contextKey,
+                ...details,
+                phase: "error_response_send",
+            }, "Failed to deliver the request failure to the user.");
+        }
     }
 }
+function activeWriterThreadId(error) {
+    const visited = new Set();
+    let current = error;
+    while (current !== undefined && current !== null && !visited.has(current)) {
+        visited.add(current);
+        const message = current instanceof Error
+            ? current.message
+            : typeof current === "string" ? current : undefined;
+        const match = message?.match(/thread(?:\/resume failed:\s*thread)?\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\s+already has an active writer/iu);
+        if (match?.[1])
+            return match[1];
+        current = current instanceof Error ? current.cause : undefined;
+    }
+    return undefined;
+}
+function positiveActionPid(value) {
+    const pid = typeof value === "number" ? value : Number(value);
+    if (!Number.isSafeInteger(pid) || pid <= 4) {
+        throw new Error("任务占用卡片中的进程信息无效，请重新发送消息获取最新状态。");
+    }
+    return pid;
+}
+function threadWriterMatches(owner, writerPid, writerStartedAt, applicationPid, applicationStartedAt) {
+    return Boolean(writerStartedAt)
+        && Boolean(applicationStartedAt)
+        && owner.writerPid === writerPid
+        && owner.writerStartedAt === writerStartedAt
+        && owner.applicationPid === applicationPid
+        && owner.applicationStartedAt === applicationStartedAt;
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function renderPlainHelp(introLines, sections) {
+    return [
+        "Agent Bot 使用帮助",
+        "",
+        ...introLines.map((line) => decodeHelpEntities(line.replace(/^>\s*/u, "").replaceAll("**", ""))),
+        ...sections.flatMap((section) => [
+            "",
+            section.title,
+            ...section.commands.map((command) => [
+                command.text,
+                command.usage ? decodeHelpEntities(command.usage) : "",
+                `- ${command.description}`,
+            ].filter(Boolean).join(" ")),
+        ]),
+    ].join("\n");
+}
+function decodeHelpEntities(value) {
+    return value
+        .replaceAll("&#60;", "<")
+        .replaceAll("&#62;", ">")
+        .replaceAll("&amp;", "&");
+}
 function threadForkAnchorMessageIds(message) {
     return [...new Set([message.rootMessageId, message.parentMessageId]
             .filter((messageId) => Boolean(messageId && messageId !== message.messageId)))];
@@ -5865,7 +6613,7 @@ function isBotOwnedActiveTurn(record, remote) {
         && record.lastTurnId === remote.lastTurnId;
 }
 function isQueueIndependentCommand(command) {
-    if (["archive", "dismiss", "stop", "status", "restart", "mute", "help", "sessions", "dir", "file", "goal", "nosteer", "shell"].includes(command.type))
+    if (["archive", "dismiss", "stop", "status", "restart", "release", "mute", "help", "sessions", "dir", "file", "goal", "nosteer", "shell"].includes(command.type))
         return true;
     if (command.type === "agent")
         return command.agent === undefined;
@@ -6077,6 +6825,17 @@ function mergedForwardPrompt(instruction, transcript) {
 function referencedMessagePrompt(instruction, referencedMessage) {
     return `${instruction}\n\n引用消息：\n${referencedMessage}`;
 }
+function topicRootMessagePrompt(instruction, rootMessage) {
+    return `${instruction}\n\n话题根消息：\n${rootMessage}`;
+}
+function topicRootMessageId(message) {
+    if (!message.threadContext)
+        return undefined;
+    const rootMessageId = message.rootMessageId?.trim();
+    if (!rootMessageId || rootMessageId === message.messageId)
+        return undefined;
+    return rootMessageId;
+}
 function quotedMessageId(message) {
     const messageId = message.parentMessageId?.trim();
     if (!messageId || message.contextKey.startsWith("console:"))