@keyou007/agent-bot 0.1.24-alpha.8 → 0.1.25-alpha.0

package/dist/proxy/ProxySessionController.js

@@ -21,6 +21,7 @@ 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 { displayRuntimeError, isResponseContinuationError } from "../runtime/responseErrors.js";
 import { isActiveShellCommandJob, ShellCommandJobManager, } from "../shell/ShellCommandJobManager.js";
 import { SessionOperationQueue } from "./SessionOperationQueue.js";
 import { createId } from "../utils/id.js";
@@ -41,6 +42,7 @@ const MESSAGE_RECEIVED_REACTION = "OnIt";
 const MESSAGE_COMPLETED_REACTION = "DONE";
 const MESSAGE_FAILED_REACTION = "ERROR";
 const MESSAGE_CANCELLED_REACTION = "CrossMark";
+const INBOUND_MESSAGE_DELAY_WARNING_MS = 60_000;
 const SESSION_PAGE_SIZE = 10;
 const SESSION_PROMPT_PREVIEW_LENGTH = 50;
 const DIRECTORY_PAGE_SIZE = 15;
@@ -54,7 +56,7 @@ 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 FORWARD_ATTACHMENT_WINDOW_MS = 1_500;
+const REFERENCE_INSTRUCTION_WINDOW_MS = 1_500;
 const DEFAULT_MERGED_FORWARD_INSTRUCTION = "请参考以下内容回复用户";
 const DEFAULT_REFERENCED_MESSAGE_INSTRUCTION = "请参考引用消息回复用户";
 const TURN_STOP_REQUESTED_MESSAGE = "已发送停止信号，任务会自动停止。";
@@ -223,6 +225,7 @@ export class ProxySessionController {
     windowsDriveLister;
     shellCommandJobs;
     threadWriterProcesses;
+    referenceInstructionWindowMs;
     router = new CommandRouter();
     cardRenderer = new CardRenderer();
     messageQueues = new Map();
@@ -245,6 +248,7 @@ export class ProxySessionController {
     lastSessionListings = new Map();
     threadInitializations = new Map();
     llmRetryingSessions = new Set();
+    responseContinuations = new Map();
     planHandoffs = new Map();
     retriedFailureTurnIds = new Set();
     queuedPromptRetryTimers = new Map();
@@ -252,8 +256,7 @@ export class ProxySessionController {
     recoveryRetryStartedAt = new Map();
     recoveredLiveAttempts = new Set();
     recoveryClosed = false;
-    pendingMergedForwards = new Map();
-    pendingResourceForwards = new Map();
+    pendingMessageReferences = new Map();
     relatedReactionMessageIds = new Map();
     shellCommandJobMonitors = new Map();
     appServerReleaseSchedules = new Map();
@@ -262,7 +265,7 @@ export class ProxySessionController {
     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")), threadWriterProcesses = new SystemThreadWriterProcessController()) {
+    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(), referenceInstructionWindowMs = REFERENCE_INSTRUCTION_WINDOW_MS) {
         this.config = config;
         this.store = store;
         this.runtimes = runtimes;
@@ -273,6 +276,7 @@ export class ProxySessionController {
         this.windowsDriveLister = windowsDriveLister;
         this.shellCommandJobs = shellCommandJobs;
         this.threadWriterProcesses = threadWriterProcesses;
+        this.referenceInstructionWindowMs = referenceInstructionWindowMs;
         for (const [, runtime] of this.runtimes.entries()) {
             this.unsubscribe.push(runtime.onEvent((event) => {
                 void this.handleRuntimeEvent(event).catch((error) => {
@@ -305,14 +309,26 @@ export class ProxySessionController {
         // retries cannot add duplicate reactions.
         if (!this.store.claimInboundEvent(message.messageId, "message"))
             return;
-        const attachmentReservation = message.mergedForwardMessageId
-            ? undefined
-            : this.reserveForwardAttachment(message);
-        const pendingMergedForward = message.mergedForwardMessageId
-            ? this.registerPendingForwardAttachment(message, this.pendingMergedForwards)
-            : undefined;
-        const pendingResourceForward = !attachmentReservation && isForwardAttachmentSource(message)
-            ? this.registerPendingForwardAttachment(message, this.pendingResourceForwards)
+        const acceptedAt = Date.now();
+        const receivedAt = message.receivedAt ?? acceptedAt;
+        const deliveryDelayMs = message.createdAt === undefined
+            ? 0 : Math.max(0, receivedAt - message.createdAt);
+        const dispatchDelayMs = Math.max(0, acceptedAt - receivedAt);
+        if (deliveryDelayMs + dispatchDelayMs >= INBOUND_MESSAGE_DELAY_WARNING_MS) {
+            this.logger.warn({
+                messageId: message.messageId,
+                eventId: message.eventId,
+                contextKey: message.contextKey,
+                messageCreatedAt: message.createdAt,
+                receivedAt,
+                acceptedAt,
+                deliveryDelayMs,
+                dispatchDelayMs,
+            }, "Accepted a delayed Feishu message.");
+        }
+        const attachmentReservation = this.reserveReferenceInstruction(message);
+        const pendingReference = !attachmentReservation && isReferenceSource(message)
+            ? this.registerPendingReference(message)
             : undefined;
         try {
             const reactionId = await this.outbound.addReaction(message.contextKey, message.messageId, MESSAGE_RECEIVED_REACTION);
@@ -324,8 +340,10 @@ export class ProxySessionController {
             this.logger.warn({ error, messageId: message.messageId, contextKey: message.contextKey }, "Failed to acknowledge the incoming Feishu message with a reaction.");
         }
         await this.waitForCurrentSessionReset(message.contextKey);
-        if (attachmentReservation && this.completeForwardAttachment(message, attachmentReservation)) {
-            this.store.audit(message.contextKey, `${attachmentReservation.sourceKind}_attachment_coalesced`, {
+        if (this.recoveryClosed)
+            return;
+        if (attachmentReservation && this.completeReferenceInstruction(message, attachmentReservation)) {
+            this.store.audit(message.contextKey, "referenced_message_coalesced", {
                 messageId: message.messageId,
                 parentMessageId: message.parentMessageId,
             });
@@ -344,20 +362,22 @@ export class ProxySessionController {
             this.store.recordChatContext(chatContextKey, message.chatType);
             this.store.markChatActive(chatContextKey);
         }
-        if (pendingResourceForward) {
-            const resourceMessage = message;
-            const attachment = await this.waitForForwardAttachment(message.messageId, pendingResourceForward, this.pendingResourceForwards);
+        if (pendingReference && !message.mergedForwardMessageId) {
+            const sourceMessage = message;
+            const attachment = await this.waitForReferenceInstruction(message.messageId, pendingReference);
+            if (this.recoveryClosed)
+                return;
             if (attachment) {
                 coalescedForwardAttachment = true;
-                const sourceText = resourceMessage.text.trim();
-                const instruction = normalizeFeishuPostText(attachment.text)
-                    || (sourceText ? DEFAULT_REFERENCED_MESSAGE_INSTRUCTION : defaultResourcePrompt(resourceMessage));
-                forwardedImages = (resourceMessage.images ?? []).map((image) => ({
-                    messageId: resourceMessage.messageId,
+                const sourceText = sourceMessage.text.trim();
+                const instruction = normalizeFeishuPostText(attachment.displayText ?? attachment.text)
+                    || (sourceText ? DEFAULT_REFERENCED_MESSAGE_INSTRUCTION : defaultResourcePrompt(sourceMessage));
+                forwardedImages = (sourceMessage.images ?? []).map((image) => ({
+                    messageId: sourceMessage.messageId,
                     imageKey: image.imageKey,
                 }));
-                forwardedFiles = (resourceMessage.files ?? []).map((file) => ({
-                    messageId: resourceMessage.messageId,
+                forwardedFiles = (sourceMessage.files ?? []).map((file) => ({
+                    messageId: sourceMessage.messageId,
                     fileKey: file.fileKey,
                     fileName: file.fileName,
                 }));
@@ -366,18 +386,18 @@ export class ProxySessionController {
                     text: sourceText ? referencedMessagePrompt(instruction, sourceText) : instruction,
                     displayText: instruction,
                 };
-                this.relatedReactionMessageIds.set(message.messageId, [resourceMessage.messageId]);
+                this.relatedReactionMessageIds.set(message.messageId, [sourceMessage.messageId]);
             }
         }
         if (message.mergedForwardMessageId) {
             const mergedForwardMessage = message;
             const mergedForwardResult = this.outbound.readMergedForward(message.contextKey, message.mergedForwardMessageId).then((content) => ({ content }), (error) => ({ error }));
-            const attachment = pendingMergedForward
-                ? await this.waitForForwardAttachment(message.messageId, pendingMergedForward, this.pendingMergedForwards)
+            const attachment = pendingReference
+                ? await this.waitForReferenceInstruction(message.messageId, pendingReference)
                 : undefined;
             if (attachment) {
                 coalescedForwardAttachment = true;
-                const instruction = normalizeFeishuPostText(attachment.text)
+                const instruction = normalizeFeishuPostText(attachment.displayText ?? attachment.text)
                     || ((attachment.images?.length ?? 0) > 0 ? "请查看附带的内容。" : "请结合参考聊天记录处理。");
                 message = {
                     ...attachment,
@@ -387,6 +407,8 @@ export class ProxySessionController {
                 this.relatedReactionMessageIds.set(message.messageId, [mergedForwardMessage.messageId]);
             }
             const result = await mergedForwardResult;
+            if (this.recoveryClosed)
+                return;
             if ("error" in result) {
                 const replyTarget = message.replyInThread
                     ? { messageId: message.messageId, replyInThread: true }
@@ -456,6 +478,9 @@ export class ProxySessionController {
         const fileCount = fileReferences.length;
         this.store.audit(message.contextKey, "incoming_message", {
             messageId: message.messageId,
+            eventId: message.eventId,
+            messageCreatedAt: message.createdAt,
+            receivedAt: message.receivedAt,
             text: message.text,
             ...(imageCount > 0 ? { imageCount } : {}),
             ...(fileCount > 0 ? { fileCount } : {}),
@@ -994,12 +1019,9 @@ export class ProxySessionController {
         this.remoteTurnHistoryRefreshes.clear();
         this.forkHistoryCursors.clear();
         this.turnHistoryHydrations.clear();
-        for (const pending of this.pendingMergedForwards.values())
+        for (const pending of this.pendingMessageReferences.values())
             pending.resolveAttachment(undefined);
-        this.pendingMergedForwards.clear();
-        for (const pending of this.pendingResourceForwards.values())
-            pending.resolveAttachment(undefined);
-        this.pendingResourceForwards.clear();
+        this.pendingMessageReferences.clear();
         this.relatedReactionMessageIds.clear();
         for (const timer of this.queuedPromptRetryTimers.values())
             clearTimeout(timer);
@@ -3132,6 +3154,16 @@ export class ProxySessionController {
     }
     async startTurn(loaded, text, replyTarget, localImagePaths, options = {}) {
         return this.settingsOperations.run(loaded.record.localSessionId, async () => {
+            if (options.responseContinuationTurnId) {
+                const current = this.store.getSession(loaded.record.localSessionId);
+                if (!current || current.status === "closed" || current.lastTurnId !== options.responseContinuationTurnId
+                    || this.sessionResets.has(current.localSessionId)
+                    || this.responseContinuations.get(current.localSessionId)?.turnId !== options.responseContinuationTurnId
+                    || this.store.getPendingProviderSettings(current.localSessionId)) {
+                    throw new Error("任务或运行设置已变化，未自动恢复模型续接。请发送消息继续。");
+                }
+                return this.startTurnNow(loaded, text, replyTarget, localImagePaths, options);
+            }
             try {
                 await this.applyPendingProviderSettings(loaded);
             }
@@ -3196,15 +3228,26 @@ export class ProxySessionController {
                         || this.sessionResets.has(loaded.record.localSessionId))) {
                         throw new Error("方案执行已取消。");
                     }
-                    turnId = await loaded.runtime.startTurn(loaded.record.localSessionId, options.approvedPlanTurnId
-                        ? { text: runtimeText, collaborationMode: "default" }
-                        : runtimePrompt(runtimeText, localImagePaths));
+                    if (options.responseContinuationTurnId) {
+                        const recovery = this.responseContinuations.get(loaded.record.localSessionId);
+                        if (recovery?.turnId !== options.responseContinuationTurnId
+                            || this.sessionResets.has(loaded.record.localSessionId) || !loaded.runtime.recoverResponseContinuation) {
+                            throw new Error("模型续接恢复已取消。");
+                        }
+                        turnId = await loaded.runtime.recoverResponseContinuation(loaded.record.localSessionId, options.responseContinuationTurnId, recovery.abort.signal);
+                    }
+                    else {
+                        turnId = await loaded.runtime.startTurn(loaded.record.localSessionId, options.approvedPlanTurnId
+                            ? { text: runtimeText, collaborationMode: "default" }
+                            : runtimePrompt(runtimeText, localImagePaths));
+                    }
                     break;
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : String(error);
                     const attempt = this.store.getTurnAttempt(attemptId);
                     const retryAttempt = attempt
+                        && !options.responseContinuationTurnId
                         && isRetryableLlmTurnFailure(message)
                         && attempt.retryCount < MAX_LLM_TURN_RETRIES
                         ? this.store.prepareUnstartedTurnAttemptRetry(attemptId)
@@ -3770,7 +3813,23 @@ export class ProxySessionController {
         if (event.type === "turn_failed") {
             if (this.retriedFailureTurnIds.has(event.turnId))
                 return;
-            if (failedAttempt && isRetryableLlmTurnFailure(event.message) && failedAttempt.retryCount < MAX_LLM_TURN_RETRIES) {
+            const source = this.store.getSession(event.sessionId);
+            const responseContinuation = failedAttempt?.retryCount === 0 && failedAttempt.status !== "cancelling"
+                && source && source.status !== "closed" && source.lastTurnId === event.turnId
+                && !this.sessionResets.has(event.sessionId) && !this.store.getPendingProviderSettings(event.sessionId)
+                && Boolean(this.runtimes.forAgent(source.agentName).recoverResponseContinuation)
+                && isResponseContinuationError(event.message);
+            if (failedAttempt && responseContinuation) {
+                const retryAttempt = this.store.prepareTurnAttemptRetry(failedAttempt.attemptId, event.turnId);
+                if (retryAttempt) {
+                    this.retriedFailureTurnIds.add(event.turnId);
+                    this.responseContinuations.set(event.sessionId, { turnId: event.turnId, abort: new AbortController() });
+                    await this.retryFailedLlmTurn(event, retryAttempt, true);
+                    return;
+                }
+            }
+            if (failedAttempt && !this.responseContinuations.has(event.sessionId)
+                && isRetryableLlmTurnFailure(event.message) && failedAttempt.retryCount < MAX_LLM_TURN_RETRIES) {
                 const retryAttempt = this.store.prepareTurnAttemptRetry(failedAttempt.attemptId, event.turnId);
                 if (retryAttempt) {
                     this.retriedFailureTurnIds.add(event.turnId);
@@ -3923,7 +3982,7 @@ export class ProxySessionController {
             await this.scheduleNextQueuedPrompt(sessionId);
         }
     }
-    async retryFailedLlmTurn(event, attempt) {
+    async retryFailedLlmTurn(event, attempt, responseContinuation = false) {
         const retryNumber = attempt.retryCount;
         const session = this.store.getSession(event.sessionId);
         if (!session || session.status === "closed") {
@@ -3939,13 +3998,16 @@ export class ProxySessionController {
             attemptId: attempt.attemptId,
             failedTurnId: event.turnId,
             retryNumber,
-            maxRetries: MAX_LLM_TURN_RETRIES,
+            maxRetries: responseContinuation ? 1 : MAX_LLM_TURN_RETRIES,
+            responseContinuation,
             error: event.message,
         });
         try {
             await this.outbound.onEvent({
                 ...event,
-                message: `${event.message}\n\n检测到临时模型服务错误，正在自动重试（${retryNumber}/${MAX_LLM_TURN_RETRIES}）。`,
+                message: responseContinuation
+                    ? `${event.message}\n\n模型续接状态失效，正在恢复连接并继续（1/1）。`
+                    : `${event.message}\n\n检测到临时模型服务错误，正在自动重试（${retryNumber}/${MAX_LLM_TURN_RETRIES}）。`,
             });
         }
         catch (error) {
@@ -3957,25 +4019,36 @@ export class ProxySessionController {
         try {
             const current = this.store.getSession(session.localSessionId) ?? session;
             const loaded = await this.loadSession(current, Boolean(this.store.getPendingProviderSettings(current.localSessionId)));
-            const retryTurnId = await this.startTurn(loaded, llmRetryRuntimePrompt(attempt.promptText, retryNumber), replyTarget, attempt.localImagePaths, {
+            const retryTurnId = await this.startTurn(loaded, responseContinuation ? "" : llmRetryRuntimePrompt(attempt.promptText, retryNumber), replyTarget, responseContinuation ? undefined : attempt.localImagePaths, {
                 attemptId: attempt.attemptId,
                 messageId: attempt.messageId,
-                displayPrompt: llmRetryCardPrompt(attempt.promptText, retryNumber),
+                displayPrompt: responseContinuation ? `恢复模型续接：${attempt.promptText}` : llmRetryCardPrompt(attempt.promptText, retryNumber),
                 preserveAttemptOnFailure: true,
+                ...(responseContinuation ? { responseContinuationTurnId: event.turnId } : {}),
             });
             this.store.rebindPendingTurnMessages(session.localSessionId, event.turnId, retryTurnId);
         }
         catch (error) {
-            this.store.updateTurnAttempt(attempt.attemptId, { status: "failed" });
-            this.store.updateSession(session.localSessionId, { status: "failed" });
-            await this.finalizeTurnMessageReactions(event.turnId, "failed").catch((reactionError) => {
+            const aborted = responseContinuation && !this.responseContinuations.has(session.localSessionId);
+            this.store.updateTurnAttempt(attempt.attemptId, { status: aborted ? "cancelled" : "failed" });
+            const latest = this.store.getSession(session.localSessionId);
+            if (!responseContinuation || (latest?.lastTurnId === event.turnId && latest.status !== "closed")) {
+                this.store.updateSession(session.localSessionId, { status: aborted ? "ready" : "failed" });
+            }
+            await this.finalizeTurnMessageReactions(event.turnId, aborted ? "cancelled" : "failed").catch((reactionError) => {
                 this.logger.warn({ error: reactionError, sessionId: session.localSessionId, turnId: event.turnId }, "Failed to finalize reactions after an LLM retry could not start.");
             });
             this.logger.error({ error, sessionId: session.localSessionId, retryNumber }, "Failed to start an automatic LLM turn retry.");
+            if (responseContinuation && !aborted) {
+                await this.outbound.sendText(attempt.contextKey, `模型续接恢复未能启动：${displayRuntimeError(runtimeErrorMessage(error))}。请发送消息继续。`);
+            }
             await this.scheduleNextQueuedPrompt(session.localSessionId);
         }
         finally {
             this.llmRetryingSessions.delete(session.localSessionId);
+            if (this.responseContinuations.get(session.localSessionId)?.turnId === event.turnId) {
+                this.responseContinuations.delete(session.localSessionId);
+            }
         }
     }
     scheduleNextQueuedPrompt(sessionId) {
@@ -4090,7 +4163,7 @@ export class ProxySessionController {
             await this.finalizeTurnMessageReactions(turnId, session.lastTurnStatus);
         }
     }
-    registerPendingForwardAttachment(message, registry) {
+    registerPendingReference(message) {
         let resolveAttachment;
         const attachmentPromise = new Promise((resolve) => {
             resolveAttachment = resolve;
@@ -4101,60 +4174,53 @@ export class ProxySessionController {
             attachmentPromise,
             resolveAttachment,
         };
-        registry.set(message.messageId, pending);
+        this.pendingMessageReferences.set(message.messageId, pending);
         return pending;
     }
-    reserveForwardAttachment(message) {
-        if (!message.parentMessageId || isCommandMessage(message))
+    reserveReferenceInstruction(message) {
+        const parentMessageId = quotedMessageId(message);
+        if (!parentMessageId || isCommandMessage(message))
             return undefined;
-        const candidates = [
-            { sourceKind: "merged_forward", registry: this.pendingMergedForwards },
-            { sourceKind: "resource", registry: this.pendingResourceForwards },
-        ];
-        for (const candidate of candidates) {
-            const pending = candidate.registry.get(message.parentMessageId);
-            if (!pending || pending.contextKey !== message.contextKey
-                || pending.userId !== message.userId || pending.attachmentMessageId)
-                continue;
-            pending.attachmentMessageId = message.messageId;
-            return {
-                sourceMessageId: message.parentMessageId,
-                sourceKind: candidate.sourceKind,
-                pending,
-                registry: candidate.registry,
-            };
-        }
-        return undefined;
+        const pending = this.pendingMessageReferences.get(parentMessageId);
+        if (!pending || pending.contextKey !== message.contextKey
+            || pending.userId !== message.userId || pending.attachmentMessageId)
+            return undefined;
+        pending.attachmentMessageId = message.messageId;
+        return { sourceMessageId: parentMessageId, pending };
     }
-    completeForwardAttachment(message, reservation) {
-        if (!message.parentMessageId)
+    completeReferenceInstruction(message, reservation) {
+        const parentMessageId = quotedMessageId(message);
+        if (!parentMessageId || reservation.sourceMessageId !== parentMessageId)
             return false;
-        if (reservation.sourceMessageId !== message.parentMessageId)
-            return false;
-        if (reservation.registry.get(message.parentMessageId) !== reservation.pending)
+        if (this.pendingMessageReferences.get(parentMessageId) !== reservation.pending)
             return false;
         if (reservation.pending.attachmentMessageId !== message.messageId)
             return false;
         reservation.pending.resolveAttachment(message);
         return true;
     }
-    async waitForForwardAttachment(messageId, pending, registry) {
-        const timer = setTimeout(() => {
+    async waitForReferenceInstruction(messageId, pending) {
+        const expire = () => {
             // Arrival reserves the pair before acknowledgement. A slow Reaction must not split it.
             if (pending.attachmentMessageId)
                 return;
-            if (registry.get(messageId) === pending)
-                registry.delete(messageId);
+            if (this.pendingMessageReferences.get(messageId) === pending)
+                this.pendingMessageReferences.delete(messageId);
             pending.resolveAttachment(undefined);
-        }, FORWARD_ATTACHMENT_WINDOW_MS);
-        timer.unref?.();
+        };
+        const timer = this.referenceInstructionWindowMs > 0 ? setTimeout(expire, this.referenceInstructionWindowMs) : undefined;
+        if (timer)
+            timer.unref?.();
+        else
+            expire();
         try {
             return await pending.attachmentPromise;
         }
         finally {
-            clearTimeout(timer);
-            if (registry.get(messageId) === pending) {
-                registry.delete(messageId);
+            if (timer)
+                clearTimeout(timer);
+            if (this.pendingMessageReferences.get(messageId) === pending) {
+                this.pendingMessageReferences.delete(messageId);
             }
         }
     }
@@ -4213,6 +4279,8 @@ export class ProxySessionController {
         await this.cancelSession(record);
     }
     async cancelSession(record) {
+        this.responseContinuations.get(record.localSessionId)?.abort.abort();
+        this.responseContinuations.delete(record.localSessionId);
         this.planHandoffs.delete(record.localSessionId);
         const runtime = this.runtimes.forAgent(record.agentName);
         if (runtime.kind === "codex" && record.remoteSessionId && runtime.interruptRemoteTurn) {
@@ -4290,6 +4358,8 @@ export class ProxySessionController {
         });
     }
     async runSessionReset(sessionId, operation) {
+        this.responseContinuations.get(sessionId)?.abort.abort();
+        this.responseContinuations.delete(sessionId);
         this.planHandoffs.delete(sessionId);
         const previous = this.sessionResets.get(sessionId) ?? Promise.resolve();
         const reset = previous.catch(() => undefined).then(operation);
@@ -4671,9 +4741,16 @@ export class ProxySessionController {
             throw new Error("当前运行时不支持 Provider 设置。");
         loaded.session = loaded.runtime.getSession(loaded.record.localSessionId) ?? loaded.session;
         const remoteSessionId = loaded.session.remoteSessionId;
-        const persist = (candidate) => this.agentDefaultsOperations.run(loaded.record.agentName, async () => {
+        const persist = (candidate, replacement) => this.agentDefaultsOperations.run(loaded.record.agentName, async () => {
             if (candidate.remoteSessionId !== remoteSessionId) {
-                throw new Error("设置切换返回了不同的任务 ID，未保存设置；不允许替换任务或更改历史。");
+                const saved = this.store.getSession(loaded.record.localSessionId);
+                if (replacement?.emptyRemoteSessionId !== remoteSessionId || !saved || saved.remoteSessionId !== remoteSessionId
+                    || saved.status === "closed" || saved.status === "running" || saved.lastTurnId || loaded.session.activeTurnId || candidate.activeTurnId
+                    || candidate.localSessionId !== saved.localSessionId || !candidate.remoteSessionId
+                    || candidate.agentName !== saved.agentName || candidate.cwd !== saved.cwd || candidate.runtimeKind !== loaded.session.runtimeKind
+                    || this.store.hasTurnAttemptsForSession(saved.localSessionId) || this.store.getForkHistorySource(saved.localSessionId)) {
+                    throw new Error("设置切换返回了不同的任务 ID，未保存设置；仅允许已验证的空会话更换底层任务。");
+                }
             }
             assertProviderSettingsApplied(candidate, settings);
             const agent = this.ensureAgent(loaded.record.agentName);
@@ -4681,6 +4758,7 @@ export class ProxySessionController {
             await this.persistAgentExecutionDefaultsNow(loaded.record.localSessionId, candidate);
             try {
                 this.store.updateRuntimeSession(loaded.record.localSessionId, {
+                    remoteSessionId: candidate.remoteSessionId,
                     modelProvider: candidate.modelProvider,
                     model: candidate.model,
                     reasoningEffort: candidate.reasoningEffort,
@@ -4694,6 +4772,7 @@ export class ProxySessionController {
             }
         });
         const session = await loaded.runtime.setExecutionSettings(loaded.record.localSessionId, settings, persist);
+        loaded.record = this.store.getSession(loaded.record.localSessionId) ?? loaded.record;
         this.settingsOnlySessions.delete(loaded.record.localSessionId);
         this.outbound.updateSessionModel(loaded.record.localSessionId, session.model, session.modelProvider);
         return session;
@@ -5858,6 +5937,7 @@ export class ProxySessionController {
             throw new Error(`这不是目录：${directory}`);
     }
     async createDirectoryFromCard(contextKey, action) {
+        const updateMessageId = requiredCardMessageId(action.messageId);
         const directory = directoryActionPath(action.value.directory);
         await this.assertBrowsableDirectory(directory);
         const folderName = directoryFolderName(cardFormValue(action.value, "folderName"));
@@ -5873,9 +5953,9 @@ export class ProxySessionController {
                 throw new Error(`目录已存在：${newDirectory}`);
             throw new Error(`无法创建目录 ${newDirectory}：${runtimeErrorMessage(error)}`);
         }
-        await this.openDirectoryBrowser(contextKey, directory, {
-            updateMessageId: requiredCardMessageId(action.messageId),
-            page: directoryPageValue(action.value.page),
+        await this.openDirectoryBrowser(contextKey, newDirectory, {
+            updateMessageId,
+            page: 0,
         });
         await this.outbound.sendText(contextKey, `已创建目录：${newDirectory}`);
     }
@@ -8145,13 +8225,10 @@ function isCommandMessage(message) {
     const text = normalizeFeishuPostText(message.text).trimStart();
     return text.startsWith("/") || text.startsWith("!");
 }
-function isForwardAttachmentSource(message) {
-    return !message.mergedForwardMessageId
-        && !message.parentMessageId
+function isReferenceSource(message) {
+    return !quotedMessageId(message)
         && !message.contextKey.startsWith("console:")
-        && !isCommandMessage(message)
-        && (message.messageType === "post"
-            || (message.images?.length ?? 0) > 0 || (message.files?.length ?? 0) > 0);
+        && !isCommandMessage(message);
 }
 function deduplicateImageReferences(images) {
     const seen = new Set();