@mininglamp-oss/octo-runtime 1.0.0 → 1.1.0

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/application/im-channel.js

@@ -1,3 +1,4 @@
+import { shutdownDeadline, withinShutdown } from "@mininglamp-oss/octo-runtime-host-sdk/shutdown";
 /**
  * 单 Bot 编排：把授权 IM 消息转换为有界任务，并把公开结果投递回原会话。
  * 管理会话、排队、取消和交互归属；平台协议交给 connector，领域业务交给发起方。
@@ -14,9 +15,13 @@ import { ImDeliveryDispatcher } from "../delivery/dispatcher.js";
 import { ImRunProjector } from "../presentation/run-projector.js";
 import { deliveryNotice } from "../presentation/delivery-notice.js";
 import { MemoryImSessionStore } from "./session-store.js";
+import { addRulesRecovery, selectRulesContext } from "./rules-context.js";
+import { groupScope } from "../transport/normalize.js";
 import { connectionFailure, ImConnectionError } from "../transport/connection-error.js";
+import { commitHistoryGap, gapMetadata, planHistoryGap, validMessageSeq } from "./context-gap.js";
 export class ImRuntime {
     dependencies;
+    #processEpoch = randomUUID();
     #preparing = new Map();
     config;
     #connector;
@@ -29,6 +34,9 @@ export class ImRuntime {
     #interactions = new Map();
     #responding = new Set();
     #closed = true;
+    #draining = false;
+    #ownerStopped;
+    #drainErrors = [];
     #state = "stopped";
     #reconnect;
     #connecting;
@@ -61,7 +69,7 @@ export class ImRuntime {
             connected: this.#state === "online",
             state: this.#state,
             error: this.#error ?? null,
-            deliveries: this.#delivery?.receipts ?? [],
+            deliveries: this.#delivery?.receiptCount ?? 0,
             workingTasks: this.#working,
             queuedTasks: [...this.#sessions.values()].reduce((sum, session) => sum + Math.max(0, session.pending - 1), 0),
             sessions: [...this.#sessions.values()].map((session) => ({
@@ -90,16 +98,16 @@ export class ImRuntime {
             return this.#connecting;
         if (this.#closed) {
             this.#closed = false;
+            this.#draining = false;
+            this.#drainErrors.length = 0;
             this.#closing = undefined;
             this.#abort = new AbortController();
-            this.#signal = AbortSignal.any([
-                this.#abort.signal,
-                ...(this.dependencies.signal ? [this.dependencies.signal] : [])
-            ]);
-            this.#signal.addEventListener("abort", () => {
+            this.#signal = this.#abort.signal;
+            this.#ownerStopped = () => {
                 if (!this.#closed)
                     void this.close().catch(() => this.#diagnostic("IM_DISPOSE_FAILED"));
-            }, { once: true });
+            };
+            this.dependencies.signal?.addEventListener("abort", this.#ownerStopped, { once: true });
             this.#delivery = new ImDeliveryDispatcher(this.#signal);
         }
         this.#everOnline = false;
@@ -115,7 +123,7 @@ export class ImRuntime {
         }
     }
     async #connect(recovering) {
-        if (this.#closed || this.#signal.aborted)
+        if (this.#closed || this.#draining || this.#signal.aborted)
             return;
         this.#connectionAbort?.abort();
         try {
@@ -129,7 +137,7 @@ export class ImRuntime {
             this.#everOnline = false;
             return;
         }
-        if (this.#closed || this.#signal.aborted)
+        if (this.#closed || this.#draining || this.#signal.aborted)
             return;
         this.#connectionAbort = new AbortController();
         const signal = AbortSignal.any([this.#signal, this.#connectionAbort.signal]);
@@ -138,6 +146,15 @@ export class ImRuntime {
         const credentials = this.dependencies.credentials ?? ((config) => Promise.resolve(config.bf_token));
         const connector = new GatewayTransport(this.config, credentials, {
             authorizeSpace: this.dependencies.authorizeSpace,
+            onPosition: (position) => {
+                if (connector === this.#connector && !signal.aborted)
+                    this.#observePosition(position);
+            },
+            onRulesChanged: (change) => {
+                if (connector !== this.#connector || signal.aborted)
+                    return;
+                this.#invalidateRules(change);
+            },
             onMessage: (message) => {
                 if (connector === this.#connector && !signal.aborted)
                     this.#receive(message);
@@ -219,14 +236,18 @@ export class ImRuntime {
         });
     }
     #scheduleReconnect(retryAfterMs = 0) {
-        if (this.#closed || this.#signal.aborted || this.#state !== "retrying" || this.#reconnect)
+        if (this.#closed ||
+            this.#draining ||
+            this.#signal.aborted ||
+            this.#state !== "retrying" ||
+            this.#reconnect)
             return;
         const delayMs = Math.max(Math.min(30_000, 5_000 * 2 ** this.#retry), retryAfterMs);
         this.#retry = Math.min(3, this.#retry + 1);
         // Node 超过 2^31-1 的 timeout 会变为 1ms；长 Retry-After 分段等待，不能绕过限流。
         const deadline = performance.now() + delayMs;
         const wake = () => {
-            if (this.#closed || this.#signal.aborted || this.#state !== "retrying")
+            if (this.#closed || this.#draining || this.#signal.aborted || this.#state !== "retrying")
                 return;
             const remaining = deadline - performance.now();
             if (remaining > 0) {
@@ -266,6 +287,11 @@ export class ImRuntime {
             /* 诊断不改变业务结果。 */
         }
     }
+    #finalizationFailed(code, runId) {
+        if (this.#draining)
+            this.#drainErrors.push(new Error(code));
+        this.#diagnostic(code, runId);
+    }
     #key(message) {
         return [
             this.#connector.identity,
@@ -277,8 +303,77 @@ export class ImRuntime {
             .map(encodeURIComponent)
             .join("/");
     }
+    #observePosition(position) {
+        if (this.#closed || !validMessageSeq(position.messageSeq))
+            return;
+        const key = this.#key(position);
+        try {
+            const binding = this.#sessionStore.read(key);
+            if (!binding?.id || !this.#sessionStore.patchGap)
+                return;
+            if (position.own &&
+                (!position.turn ||
+                    position.turn.processEpoch !== this.#processEpoch ||
+                    position.turn.sessionId !== binding.id ||
+                    position.turn.generation !== binding.generation))
+                return;
+            this.#sessionStore.patchGap(key, { sessionId: binding.id, generation: binding.generation }, (previous) => {
+                const next = gapMetadata(this.#processEpoch, previous);
+                next.latestObservedSeq = Math.max(next.latestObservedSeq ?? 0, position.messageSeq);
+                next.observationVisibility = "partial";
+                if (position.own)
+                    next.localOutputSeqs = [...new Set([...next.localOutputSeqs, position.messageSeq])]
+                        .sort((left, right) => left - right)
+                        .slice(-32);
+                return next;
+            });
+        }
+        catch {
+            this.#finalizationFailed("IM_HISTORY_POSITION_UNAVAILABLE");
+        }
+    }
+    #invalidateRules(change) {
+        try {
+            this.#sessionStore.invalidateRules?.((key) => {
+                const parts = key.split("/");
+                const kind = decodeURIComponent(parts.at(-2) ?? "");
+                const id = decodeURIComponent(parts.at(-1) ?? "");
+                if (kind !== "group" && kind !== "thread")
+                    return false;
+                if (key !== this.#key({ conversationKind: kind, conversationId: id }))
+                    return false;
+                const scope = groupScope(id);
+                return (scope.groupNo === change.groupNo &&
+                    (!change.shortId || (kind === "thread" && scope.shortId === change.shortId)));
+            });
+        }
+        catch {
+            this.#finalizationFailed("IM_RULES_STATE_UNAVAILABLE");
+        }
+    }
+    #finishRules(key, session, revision, versions, completed) {
+        if (this.#closed || !session.id)
+            return;
+        try {
+            const provider = this.#sessionStore.read(key)?.providerSession;
+            this.#sessionStore.patchRules?.(key, { sessionId: session.id, generation: session.generation }, (current) => {
+                const latest = current?.revision ?? 0;
+                // 成功确认前重读状态；旧任务不得清除运行期间到达的更新通知。
+                if (completed && versions && provider?.sessionId && provider.resumable !== false) {
+                    if (latest !== revision)
+                        return undefined;
+                    return { revision, supplied: { ...versions, providerSessionId: provider.sessionId } };
+                }
+                return { revision: latest };
+            });
+        }
+        catch {
+            this.#finalizationFailed("IM_RULES_STATE_UNAVAILABLE");
+        }
+    }
     #receive(message) {
         if (this.#closed ||
+            this.#draining ||
             (this.config.allowed_sender_ids && !this.config.allowed_sender_ids.includes(message.senderId)))
             return;
         const now = Date.now();
@@ -301,7 +396,7 @@ export class ImRuntime {
         let session;
         try {
             session = this.#session(key);
-            if (command === "/reset") {
+            if (command === "/reset" || command === "/new") {
                 try {
                     const binding = this.#sessionStore.reset(key, message.messageId);
                     this.#tasks.get(key)?.task.stopRetries();
@@ -333,7 +428,8 @@ export class ImRuntime {
                         : task
                             ? await task.cancel()
                             : invocationId
-                                ? (await this.dependencies.host.cancel(invocationId, "IM user stop")).cancelled
+                                ? (await this.dependencies.kernel.cancelInvocation(invocationId, "IM user stop"))
+                                    .accepted
                                 : false;
                     await this.#reply(message, cancelled ? "已请求停止本轮执行。" : "当前没有可停止的执行。", `control:${message.messageId}`);
                 })().catch(() => this.#diagnostic("IM_CANCEL_FAILED"));
@@ -377,14 +473,36 @@ export class ImRuntime {
                     throw Error("IM_INTERACTION_STALE_RUN");
                 await this.#submitInteraction(key, message.senderId, response);
             },
-            cancel: async () => this.#tasks.get(key)?.rootInvocationId === invocationId &&
+            cancel: async () => !this.#draining &&
+                this.#tasks.get(key)?.rootInvocationId === invocationId &&
                 (await this.#tasks.get(key).task.cancel("IM card stop")),
-            retry: (senderId, id) => controls.failed && this.#enqueue({ ...message, senderId }, key, id)
+            retry: (senderId, id) => {
+                if (!controls.failed)
+                    return false;
+                if (!message.position)
+                    return this.#enqueue({ ...message, senderId }, key, id);
+                const saved = this.#sessionStore.occurrence(key, message.messageId)?.snapshot;
+                if (!saved)
+                    return false;
+                const binding = this.#sessionStore.read(key);
+                if (saved.sessionId !== binding?.id || saved.sessionGeneration !== binding.generation)
+                    return this.#enqueue({ ...message, senderId }, key, id);
+                const images = saved.inputs.filter((part) => part.type === "image");
+                return this.#enqueue({
+                    ...message,
+                    senderId,
+                    historyRetry: true,
+                    buildContext: () => Promise.resolve(structuredClone(saved.contexts)),
+                    ...(images.length
+                        ? { buildInputs: () => Promise.resolve(structuredClone(images)) }
+                        : {})
+                }, key, id);
+            }
         };
         return controls;
     }
     #enqueue(message, key, occurrenceId) {
-        if (this.#closed || this.#signal.aborted)
+        if (this.#closed || this.#draining || this.#signal.aborted)
             return false;
         const id = occurrenceId ?? message.messageId;
         const queuedKey = JSON.stringify([key, id]);
@@ -421,11 +539,15 @@ export class ImRuntime {
                 session.id = binding.id;
             }
             const executionSession = { ...session };
+            const frozenMessage = {
+                ...message,
+                ...(message.position ? { position: { ...message.position } } : {})
+            };
             this.#queuedOccurrences.add(queuedKey);
             if (session.pending++ === 0)
                 this.#working++;
             session.tail = session.tail
-                .then(() => this.#turn(message, key, session, occurrenceId, executionSession))
+                .then(() => this.#turn(frozenMessage, key, session, occurrenceId, executionSession))
                 .catch(() => this.#diagnostic("IM_TURN_FAILED"))
                 .finally(() => {
                 this.#queuedOccurrences.delete(queuedKey);
@@ -484,6 +606,8 @@ export class ImRuntime {
             ? message.replyFinal(text, effectKey)
             : message.reply(text, effectKey));
         if (receipt.state !== "delivered") {
+            if (this.#draining)
+                this.#drainErrors.push(new Error(receipt.code ?? "IM_DELIVERY_FAILED"));
             this.#diagnostic(receipt.code ?? "IM_DELIVERY_FAILED");
             if (allowUnknownNotice &&
                 receipt.state === "unknown" &&
@@ -535,6 +659,7 @@ export class ImRuntime {
     async #submitInteraction(key, senderId, response) {
         const entry = this.#interactions.get(response.interactionId);
         if (this.#closed ||
+            this.#draining ||
             this.#signal.aborted ||
             !entry ||
             entry.key !== key ||
@@ -547,7 +672,7 @@ export class ImRuntime {
             return;
         this.#responding.add(response.interactionId);
         try {
-            await this.dependencies.host.respondInteraction(entry.invocationId, response);
+            await this.dependencies.kernel.respondInteraction(entry.invocationId, response);
             this.#interactions.delete(response.interactionId);
         }
         finally {
@@ -555,7 +680,7 @@ export class ImRuntime {
         }
     }
     async #turn(message, key, session, occurrenceId, executionSession = session) {
-        if (this.#closed || this.#signal.aborted || !this.#delivery)
+        if (this.#closed || this.#draining || this.#signal.aborted || !this.#delivery)
             return;
         const prompt = message.text.trim();
         if (!prompt && !message.buildInputs)
@@ -569,6 +694,11 @@ export class ImRuntime {
         this.#preparing.set(key, preparation);
         const turnSignal = AbortSignal.any([this.#signal, preparation.signal]);
         let prepared;
+        let gapPlan = { mode: "none" };
+        let failureAfterSeq = null;
+        let rulesRevision = 0;
+        let rulesVersions;
+        const rulesEnabled = message.conversationKind !== "direct";
         // Octospec F05: .octospec/tasks/gateway-august-feature-assessment/assessment.md
         // 仅普通任务开始时回执；通知失败不阻断 Context 准备和模型执行。
         if (message.markRead)
@@ -585,13 +715,58 @@ export class ImRuntime {
             initialization.attempted = true;
             if (session.id === executionSession.id)
                 this.#saveBinding(key, session);
-            // 资格先占用再异步读取；同代次队列共享标记，重试只使用本轮冻结快照。
-            prepared = createImInvocation(this.config, message, await message.buildContext(turnSignal, {
-                // 每个已准入的逻辑轮只加载一次；下面的 Provider 重试复用快照，不重复调用宿主 IO。
-                configuredItems: await this.dependencies.prepareContexts?.(this.config, turnSignal),
+            const binding = this.#sessionStore.read(key);
+            const rulesCursor = !message.historyRetry &&
+                typeof this.#sessionStore.patchRules === "function" &&
+                typeof this.#sessionStore.invalidateRules === "function" &&
+                binding?.id === executionSession.id &&
+                binding?.generation === executionSession.generation
+                ? binding.rulesContext
+                : undefined;
+            rulesRevision = rulesCursor?.revision ?? 0;
+            const gapEnabled = message.conversationKind !== "direct" &&
+                message.position !== undefined &&
+                !message.historyRetry;
+            if (gapEnabled) {
+                gapPlan = planHistoryGap(message.position?.messageSeq, binding &&
+                    binding.id === executionSession.id &&
+                    binding.generation === executionSession.generation
+                    ? binding.gap
+                    : undefined, this.#processEpoch, typeof this.#sessionStore.patchGap === "function");
+                message.bindHistoryTurn?.({
+                    sessionId: executionSession.id,
+                    generation: executionSession.generation,
+                    processEpoch: this.#processEpoch
+                });
+            }
+            const fullContext = await message.buildContext(turnSignal, {
+                configuredItems: message.historyRetry
+                    ? undefined
+                    : await this.dependencies.prepareContexts?.(this.config, turnSignal),
                 initialSession,
-                mentionGuidance: initialSession || !executionSession.providerSession
-            }), key, executionSession, turnSignal, occurrenceId);
+                mentionGuidance: initialSession || !executionSession.providerSession,
+                ...(gapEnabled
+                    ? {
+                        historyGap: gapPlan,
+                        onHistoryGapPrepared: (plan) => {
+                            gapPlan = plan;
+                        }
+                    }
+                    : {})
+            });
+            const selection = selectRulesContext(fullContext, rulesCursor, executionSession.providerSession);
+            const context = selection.context;
+            rulesVersions = message.historyRetry ? undefined : selection.versions;
+            if (gapEnabled)
+                failureAfterSeq = gapPlan.afterSeq ?? null;
+            // 资格先占用再异步读取；同代次队列共享标记，重试只使用本轮冻结快照。
+            prepared = createImInvocation(this.config, message, context, key, executionSession, turnSignal, occurrenceId);
+            if (gapEnabled &&
+                context.items.some((item) => item.namespace === "extra.im" &&
+                    item.name === "history" &&
+                    item.payload.automatic === true) &&
+                !prepared.request.contexts.items.some((item) => item.namespace === "extra.im" && item.name === "history"))
+                gapPlan = { ...gapPlan, retrieval: "omitted" };
             if (message.buildInputs) {
                 if (prepared.adapterType !== "codex")
                     throw new ImImageInputError("本期仅 Codex 支持独立图片输入，当前引擎不支持。");
@@ -601,6 +776,14 @@ export class ImRuntime {
                     throw new ImImageInputError("每条独立图片消息只接收一张图片。");
                 prepared.request.inputs = parts;
             }
+            addRulesRecovery(prepared.request, selection.omitted);
+            if (message.historyRetry) {
+                const saved = this.#sessionStore.occurrence(key, message.messageId)?.snapshot;
+                if (saved?.freshFallbackModelInput !== undefined)
+                    prepared.request.freshFallbackModelInput = saved.freshFallbackModelInput;
+                if (saved?.freshFallbackModelInputParts)
+                    prepared.request.freshFallbackModelInputParts = structuredClone(saved.freshFallbackModelInputParts);
+            }
             if (session.id === prepared.request.sessionId) {
                 session.lastEventId = executionSession.lastEventId;
                 session.lastRunId = prepared.request.runId;
@@ -619,6 +802,8 @@ export class ImRuntime {
             });
         }
         catch (error) {
+            if (rulesEnabled)
+                this.#finishRules(key, executionSession, rulesRevision, undefined, false);
             if (turnSignal.aborted)
                 return;
             if (error instanceof Error && /^IM_CONTEXT_(?:LOADING|RESULT)_[A-Z_]+$/.test(error.message))
@@ -634,7 +819,7 @@ export class ImRuntime {
         finally {
             this.#preparing.delete(key);
         }
-        if (this.#closed || this.#signal.aborted)
+        if (this.#closed || this.#draining || this.#signal.aborted)
             return;
         let { request } = prepared;
         const rootRunId = request.runId;
@@ -646,7 +831,20 @@ export class ImRuntime {
         const startedAt = performance.now();
         let presentationSeq = 0;
         let projector = new ImRunProjector(rootRunId, message.conversationKind === "direct");
-        const task = new ImTask(this.dependencies.host, request, prepared.adapterType, this.config, { ...environment, signal: this.#signal }, (attempt) => {
+        let handedOff = false;
+        const task = new ImTask(this.dependencies.kernel, request, prepared.adapterType, this.config, { ...environment, signal: this.#signal }, (attempt) => {
+            if (!handedOff &&
+                message.position &&
+                message.conversationKind !== "direct" &&
+                !message.historyRetry) {
+                handedOff = true;
+                try {
+                    this.#sessionStore.patchGap?.(key, { sessionId: executionSession.id, generation: executionSession.generation }, (previous) => commitHistoryGap(gapMetadata(this.#processEpoch, previous), message.position?.messageSeq, gapPlan, attempt.contexts.items.find((item) => item.namespace === "extra.im" && item.name === "history")));
+                }
+                catch {
+                    this.#finalizationFailed("IM_HISTORY_POSITION_UNAVAILABLE");
+                }
+            }
             for (const [id, entry] of this.#interactions)
                 if (entry.invocationId === request.invocationId)
                     this.#interactions.delete(id);
@@ -679,6 +877,18 @@ export class ImRuntime {
                 if (event.type === "session.update" && session.id === request.sessionId) {
                     session.providerSession = event.payload.providerSession;
                     this.#saveBinding(key, session);
+                    if (event.payload.providerSession?.resumeOutcome === "fresh_fallback") {
+                        try {
+                            this.#sessionStore.patchGap?.(key, { sessionId: request.sessionId, generation: executionSession.generation }, (previous) => ({
+                                ...gapMetadata(this.#processEpoch, previous),
+                                continuityUnknown: true,
+                                pendingAfterSeq: null
+                            }));
+                        }
+                        catch {
+                            this.#finalizationFailed("IM_HISTORY_POSITION_UNAVAILABLE");
+                        }
+                    }
                 }
                 // 只有执行策略与事件策略均为 full_access 的审批才是自动处理的审计记录。
                 // 问题/elicitation 仍须展示并交回原交互入口，不能一并过滤。
@@ -688,6 +898,8 @@ export class ImRuntime {
                     event.payload.request.policy?.mode === "full_access")
                     continue;
                 if (event.type === "interaction.requested") {
+                    if (this.#draining)
+                        continue;
                     // Octospec F09: .octospec/tasks/gateway-august-feature-assessment/assessment.md
                     // 普通 IM 不提供秘密输入通道，禁止退回聊天命令收集凭据。
                     if (Array.isArray(event.payload.request.questions) &&
@@ -697,7 +909,7 @@ export class ImRuntime {
                             question.isSecret === true)) {
                         this.#diagnostic("IM_INTERACTION_SECRET_UNSUPPORTED", request.runId);
                         await this.#reply(message, "本次执行需要安全输入，当前聊天不支持。请勿在聊天中发送密码或密钥；本次执行已请求停止。", `interaction:${event.payload.interactionId}`);
-                        await this.dependencies.host.cancel(request.invocationId, "IM secret input unsupported");
+                        await this.dependencies.kernel.cancelInvocation(request.invocationId, "IM secret input unsupported");
                         continue;
                     }
                     if (this.#interactions.size >= 64)
@@ -747,15 +959,36 @@ export class ImRuntime {
         }
         catch {
             if (!projector.snapshot().terminal) {
+                if (this.#draining)
+                    this.#drainErrors.push(new Error("IM_EXECUTION_RESULT_UNKNOWN"));
                 // 流断开无法证明执行失败；尽力取消并提示核查，不自动重跑潜在的业务副作用。
-                await this.dependencies.host
-                    .cancel(request.invocationId, "IM execution stream failed")
+                await this.dependencies.kernel
+                    .cancelInvocation(request.invocationId, "IM execution stream failed")
                     .catch(() => undefined);
                 this.#diagnostic("IM_EXECUTION_RESULT_UNKNOWN", request.runId);
                 presentation?.update({ ...snapshot(), resultUnknown: true });
             }
+            else if (this.#draining)
+                this.#drainErrors.push(new Error("IM_RUN_FINALIZATION_FAILED"));
         }
         finally {
+            if (rulesEnabled)
+                this.#finishRules(key, executionSession, rulesRevision, rulesVersions, projector.snapshot().terminal === "completed");
+            if (!this.#closed && handedOff && projector.snapshot().terminal !== "completed") {
+                try {
+                    this.#sessionStore.patchGap?.(key, { sessionId: executionSession.id, generation: executionSession.generation }, (previous) => {
+                        const next = gapMetadata(this.#processEpoch, previous);
+                        next.pendingAfterSeq =
+                            next.pendingAfterSeq === null || failureAfterSeq === null
+                                ? null
+                                : Math.min(next.pendingAfterSeq ?? failureAfterSeq, failureAfterSeq);
+                        return next;
+                    });
+                }
+                catch {
+                    this.#finalizationFailed("IM_HISTORY_POSITION_UNAVAILABLE");
+                }
+            }
             if (task.stopReason)
                 this.#diagnostic(task.stopReason, rootRunId);
             this.#log("agent_run.finished", {
@@ -768,26 +1001,28 @@ export class ImRuntime {
             try {
                 // 长任务结束后重新开始终态去重窗口，保留有界尝试身份，避免立即重复执行。
                 const saved = { ...prepared.request };
-                this.#sessionStore.remember(key, occurrenceId ?? message.messageId, {
-                    text: message.text,
-                    sessionId: request.sessionId,
-                    runId: rootRunId,
-                    snapshot: saved,
-                    attempts: task.attempts.map((attempt) => ({ ...attempt }))
-                });
+                if (!this.#closed)
+                    this.#sessionStore.remember(key, occurrenceId ?? message.messageId, {
+                        text: message.text,
+                        sessionId: request.sessionId,
+                        runId: rootRunId,
+                        snapshot: saved,
+                        attempts: task.attempts.map((attempt) => ({ ...attempt }))
+                    });
             }
             catch {
-                this.#diagnostic("IM_SESSION_STORE_FAILED", rootRunId);
+                this.#finalizationFailed("IM_SESSION_STORE_FAILED", rootRunId);
             }
             session.activeInvocationId = undefined;
             for (const [id, entry] of this.#interactions)
                 if (entry.invocationId === request.invocationId)
                     this.#interactions.delete(id);
             try {
-                await presentation?.finish();
+                if (!this.#closed)
+                    await presentation?.finish();
             }
             catch {
-                this.#diagnostic("IM_PRESENTATION_FAILED", request.runId);
+                this.#finalizationFailed("IM_PRESENTATION_FAILED", request.runId);
             }
         }
         if (this.#closed || this.#signal.aborted)
@@ -797,49 +1032,83 @@ export class ImRuntime {
         await this.#reply(message, text, `final:${rootRunId}`, false, allowMention, projector.snapshot().terminal !== "cancelled");
     }
     #saveBinding(key, session) {
+        if (this.#closed)
+            return;
+        const binding = this.#sessionStore.read(key);
         this.#sessionStore.save(key, {
             id: session.id,
             generation: session.generation,
             providerSession: session.providerSession,
             lastEventId: session.lastEventId,
             lastRunId: session.lastRunId,
-            initialContextPrepared: session.initialization?.attempted === true
+            initialContextPrepared: session.initialization?.attempted === true,
+            ...(binding?.id === session.id &&
+                binding?.generation === session.generation &&
+                binding.rulesContext
+                ? { rulesContext: binding.rulesContext }
+                : {}),
+            ...(binding &&
+                binding.id === session.id &&
+                binding.generation === session.generation &&
+                binding.gap
+                ? { gap: binding.gap }
+                : {})
         });
     }
+    /**
+     * 同步停准入，在共享预算内取消执行并等待会话持久化、卡片和 final，再释放连接。
+     * 源终态或空任务表不代表业务 tail 已结束；失败/超时及重复调用都保留同一关闭结果。
+     */
     close() {
         if (this.#closing)
             return this.#closing;
-        this.#closed = true;
+        this.#draining = true;
+        const until = shutdownDeadline(this.dependencies.signal);
+        const drainUntil = Math.min(performance.now() + 3000, until - 1000);
+        const wasOnline = this.#state === "online";
         this.#state = "stopped";
         this.#log("channel.stopped", { state: "stopped" });
         this.#error = undefined;
         this.#everOnline = false;
         this.#retry = 0;
-        this.#abort.abort();
-        this.#connectionAbort?.abort();
+        for (const preparation of this.#preparing.values())
+            preparation.abort();
+        // 执行终态之后 session.tail 仍可能在结束卡片或发送 final，连接在 drain 后统一撤销。
+        if (!wasOnline)
+            this.#connectionAbort?.abort();
         if (this.#reconnect) {
             clearTimeout(this.#reconnect);
             this.#reconnect = undefined;
         }
         this.#closing = Promise.resolve().then(async () => {
             const errors = [];
-            const attempt = async (operation) => {
+            const attempt = async (operation, deadline = until) => {
                 try {
-                    await operation();
+                    await withinShutdown(Promise.resolve().then(operation), deadline, "IM_DRAIN_INCOMPLETE");
                 }
                 catch (error) {
                     errors.push(error);
                 }
             };
-            await attempt(() => this.#connector?.close());
-            await Promise.all([...this.#sessions.values()]
-                .filter((session) => session.activeInvocationId)
-                .map((session) => attempt(() => this.dependencies.host.cancel(session.activeInvocationId, "IM shutdown"))));
-            await attempt(() => this.#connecting);
-            await Promise.all([...this.#sessions.values()].map((session) => attempt(() => session.tail)));
-            await Promise.all(this.#busyNotifications.values());
+            await Promise.all([
+                ...[...this.#tasks.values()].map(({ task }) => attempt(() => task.drain(), drainUntil)),
+                ...[...this.#sessions.values()].map((session) => attempt(() => session.tail, drainUntil))
+            ]);
+            // 截止后撤销订阅与投递权限，迟到事件不能继续保存或向已释放连接投递。
+            this.#closed = true;
+            this.#abort.abort();
+            this.#connectionAbort?.abort();
+            if (this.#ownerStopped)
+                this.dependencies.signal?.removeEventListener("abort", this.#ownerStopped);
+            await Promise.all([
+                attempt(() => this.#connector?.close()),
+                attempt(() => this.#connecting),
+                attempt(() => this.#disconnecting),
+                ...[...this.#busyNotifications.values()].map((notification) => attempt(() => notification))
+            ]);
             if (!this.dependencies.sessions)
                 await attempt(() => this.#sessionStore.close?.());
+            errors.push(...this.#drainErrors);
             if (errors.length)
                 throw new AggregateError(errors, "IM_DISPOSE_FAILED");
             this.#sessions.clear();