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

package/dist/proxy/ProxySessionController.js

@@ -38,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 = "请参考引用消息回复用户";
@@ -166,6 +169,10 @@ const HELP_COMMAND_SECTIONS = [
                 usage: "[--force]",
                 description: "默认安全重启；--force 立即重启",
             },
+            {
+                command: "/release",
+                description: "释放 Agent Bot 占用的 App Server 任务",
+            },
             {
                 command: "/mute",
                 usage: "[on|off]",
@@ -198,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();
@@ -208,6 +216,8 @@ export class ProxySessionController {
     pendingResourceForwards = new Map();
     relatedReactionMessageIds = new Map();
     shellCommandJobMonitors = new Map();
+    appServerReleaseSchedules = new Map();
+    nextAppServerReleaseScheduleId = 1;
     unsubscribe = [];
     recoveryActivityHeartbeat;
     startupRecovery;
@@ -495,9 +505,29 @@ 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");
                 }
@@ -576,6 +606,12 @@ export class ProxySessionController {
                     }
                     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 ?? "");
@@ -831,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();
@@ -844,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);
@@ -855,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, {
@@ -1448,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;
@@ -2095,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);
@@ -2589,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);
@@ -4273,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
@@ -4590,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);
             }
@@ -4788,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;
@@ -5463,6 +5628,275 @@ export class ProxySessionController {
             throw new Error(`找不到任务：${sessionId}`);
         return record;
     }
+    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;
@@ -6179,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;
@@ -6391,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:"))