@mininglamp-oss/octo-runtime 1.0.1 → 1.1.1

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/application/session-store.d.ts

@@ -2,6 +2,7 @@ import type { ImInvocationInput } from "../execution/dispatcher.js";
 import type { ProviderSession } from "@mininglamp-oss/octo-runtime-protocol";
 import type { ImTaskAttempt } from "../contracts.js";
 import type { ImGapMetadata, ImGapTurnToken } from "./context-gap.js";
+import type { ImRulesContext } from "./rules-context.js";
 export interface ImSessionOccurrence {
     text: string;
     sessionId: string;
@@ -17,15 +18,33 @@ export interface ImSessionBinding {
     lastRunId?: string;
     initialContextPrepared?: boolean;
     gap?: ImGapMetadata;
+    rulesContext?: ImRulesContext;
 }
+/**
+ * Gateway 的会话状态合同，与数据库无关；常规方法必须同步完成并返回独立快照。
+ * key 是不透明聊天身份，宿主另按可信 Bot/账号 scope 分区，不从消息正文选择租户。
+ */
 export interface ImSessionStore {
+    /** 未命中返回 undefined；返回值的后续修改不能直接改变已保存状态。 */
     read(key: string): ImSessionBinding | undefined;
+    /** 保存完整 binding；宿主负责提交及容量策略，Gateway 保持既有代次检查。 */
     save(key: string, binding: ImSessionBinding): void;
+    /** 原子记录控制 ID 并递增 generation；重复控制不得再次重置当前 binding。 */
     reset(key: string, controlId: string): ImSessionBinding;
+    /** 消息处理及重试快照；未命中返回 undefined，宿主自行设置保留期限。 */
     occurrence(key: string, id: string): ImSessionOccurrence | undefined;
     remember(key: string, id: string, value: ImSessionOccurrence): void;
+    /** 仅在当前 sessionId/generation 匹配时原子合并；未命中或拒绝更新返回 false。 */
     patchGap?(key: string, identity: Pick<ImGapTurnToken, "sessionId" | "generation">, update: (current: ImGapMetadata | undefined) => ImGapMetadata): boolean;
-    close?(): void;
+    /** 只使匹配的现有规则游标失效，不创建 binding 或改变聊天代次。 */
+    invalidateRules?(matches: (key: string) => boolean): void;
+    /** 与 patchGap 相同的身份校验；update 返回 undefined 时不写入。 */
+    patchRules?(key: string, identity: {
+        sessionId: string;
+        generation: number;
+    }, update: (current: ImRulesContext | undefined) => ImRulesContext | undefined): boolean;
+    /** 工厂句柄由 Gateway 调用一次；只释放该句柄，不能关闭宿主共享数据库。 */
+    close?(): void | Promise<void>;
 }
 export declare class MemoryImSessionStore implements ImSessionStore {
     #private;
@@ -33,6 +52,11 @@ export declare class MemoryImSessionStore implements ImSessionStore {
     read(key: string): ImSessionBinding | undefined;
     save(key: string, value: ImSessionBinding): void;
     patchGap(key: string, identity: Pick<ImGapTurnToken, "sessionId" | "generation">, update: (current: ImGapMetadata | undefined) => ImGapMetadata): boolean;
+    invalidateRules(matches: (key: string) => boolean): void;
+    patchRules(key: string, identity: {
+        sessionId: string;
+        generation: number;
+    }, update: (current: ImRulesContext | undefined) => ImRulesContext | undefined): boolean;
     reset(key: string, id: string): ImSessionBinding;
     occurrence(key: string, id: string): ImSessionOccurrence | undefined;
     remember(key: string, id: string, value: ImSessionOccurrence): void;

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

@@ -36,6 +36,10 @@ class BoundedEntries {
             if (entry.expires <= now)
                 this.#delete(key);
     }
+    keys() {
+        this.prune();
+        return [...this.#entries.keys()];
+    }
     /** 同步合并最新条目；观察不续TTL、不改变淘汰顺序，超预算拒绝辅助patch而不淘汰其他binding。 */
     patch(key, update) {
         this.prune();
@@ -97,6 +101,30 @@ export class MemoryImSessionStore {
             return binding;
         });
     }
+    invalidateRules(matches) {
+        for (const key of this.#bindings.keys()) {
+            if (!matches(key))
+                continue;
+            this.#bindings.patch(key, (binding) => {
+                if (!binding.id)
+                    return undefined;
+                // 只改规则状态，不续 TTL、不推进聊天水位，也不为通知创建会话。
+                binding.rulesContext = { revision: (binding.rulesContext?.revision ?? 0) + 1 };
+                return binding;
+            });
+        }
+    }
+    patchRules(key, identity, update) {
+        return this.#bindings.patch(key, (binding) => {
+            if (binding.id !== identity.sessionId || binding.generation !== identity.generation)
+                return undefined;
+            const next = update(binding.rulesContext);
+            if (!next)
+                return undefined;
+            binding.rulesContext = next;
+            return binding;
+        });
+    }
     reset(key, id) {
         const controlKey = JSON.stringify([key, id]);
         if (this.#controls.get(controlKey)) {

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/contracts.d.ts

@@ -1,7 +1,7 @@
 /**
  * Octo gateway 配置、入站消息、执行端口和投递回执。
  */
-import type { ApprovalMode, ContextEnvelope, ContextItem, CanonicalEvent, InteractionResponse, InteractionRequestedPayload, InvokeInput, InvokeEnvironment, ModelInputPart, ProviderSession } from "@mininglamp-oss/octo-runtime-protocol";
+import type { ApprovalMode, ContextEnvelope, ContextItem, CanonicalEvent, InteractionResponse, InteractionRequestedPayload, InvokeEnvironment, ModelInputPart, ProviderSession } from "@mininglamp-oss/octo-runtime-protocol";
 import type { RunPresentation } from "./presentation/run-projector.js";
 import type { ImGapPlan, ImGapTurnToken } from "./application/context-gap.js";
 export interface ImPositionObservation {
@@ -102,6 +102,10 @@ export interface ImTaskAttempt {
     diagnosticId?: string;
 }
 export interface ChannelCallbacks {
+    onRulesChanged?(change: {
+        groupNo: string;
+        shortId?: string;
+    }): void;
     onPosition?(position: ImPositionObservation): void;
     authorizeSpace?: (spaceId: string) => void;
     onMessage(message: ImInboundMessage): void;
@@ -113,15 +117,6 @@ export interface ImAddress {
     channelType: number;
 }
 export type ImConnectionState = "stopped" | "connecting" | "online" | "retrying" | "failed";
-export interface ImExecutionPort {
-    invoke(input: InvokeInput & {
-        protocol_mode: "canonical";
-    }, environment?: InvokeEnvironment): AsyncIterable<CanonicalEvent>;
-    cancel(invocationId: string, reason?: string): Promise<{
-        cancelled: boolean;
-    }>;
-    respondInteraction(invocationId: string, response: InteractionResponse): Promise<void>;
-}
 export interface ImSession {
     id?: string;
     generation: number;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/delivery/dispatcher.d.ts

@@ -7,7 +7,8 @@ export declare class ImDeliveryDispatcher {
     #private;
     readonly signal: AbortSignal;
     constructor(signal: AbortSignal);
-    get receipts(): ImDeliveryReceipt[];
+    /** 状态仅读取数量，避免复制和输出用于防重的内部回执。 */
+    get receiptCount(): number;
     deliver(effectKey: string, operation: () => Promise<string | void>, options?: {
         transient?: boolean;
         obsolete?: () => boolean;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/delivery/dispatcher.js

@@ -6,8 +6,9 @@ export class ImDeliveryDispatcher {
     constructor(signal) {
         this.signal = signal;
     }
-    get receipts() {
-        return [...this.#receipts.values()].map((r) => ({ ...r }));
+    /** 状态仅读取数量，避免复制和输出用于防重的内部回执。 */
+    get receiptCount() {
+        return this.#receipts.size;
     }
     async deliver(effectKey, operation, options = {}) {
         const previous = this.#receipts.get(effectKey);

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/execution/task.d.ts

@@ -1,6 +1,7 @@
+import type { ImModuleDependencies } from "../ports.js";
 import type { ImInvocationInput } from "./dispatcher.js";
 import { type CanonicalEvent, type InvokeEnvironment } from "@mininglamp-oss/octo-runtime-protocol";
-import type { ImBotConfig, ImExecutionPort, ImTaskAttempt } from "../contracts.js";
+import type { ImBotConfig, ImTaskAttempt } from "../contracts.js";
 export declare const DEFAULT_CODEX_RETRY: Readonly<{
     enabled: true;
     max_consecutive_retries: 5;
@@ -18,7 +19,7 @@ export interface ImTaskClock {
 /** 预算内最多 101 次尝试；只保留身份和终态，不在此缓存模型历史。 */
 export declare class ImTask {
     #private;
-    readonly host: ImExecutionPort;
+    readonly kernel: ImModuleDependencies["kernel"];
     readonly request: ImInvocationInput;
     readonly adapterType: string;
     readonly environment: InvokeEnvironment;
@@ -26,9 +27,11 @@ export declare class ImTask {
     readonly time: ImTaskClock;
     readonly attempts: ImTaskAttempt[];
     stopReason?: string;
-    constructor(host: ImExecutionPort, request: ImInvocationInput, adapterType: string, config: ImBotConfig, environment: InvokeEnvironment, onAttempt: (request: ImInvocationInput) => void, time?: ImTaskClock);
+    constructor(kernel: ImModuleDependencies["kernel"], request: ImInvocationInput, adapterType: string, config: ImBotConfig, environment: InvokeEnvironment, onAttempt: (request: ImInvocationInput) => void, time?: ImTaskClock);
     /** reset 只阻止后续尝试，不把 reset 变成取消当前 Provider 执行。 */
     stopRetries(): void;
+    /** owner stop 只取消执行和后续尝试；当前订阅须继续消费真实终态。 */
+    drain(reason?: string): Promise<void>;
     cancel(reason?: string): Promise<boolean>;
     events(): AsyncGenerator<CanonicalEvent>;
 }

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/execution/task.js

@@ -2,6 +2,7 @@
 import { randomUUID } from "node:crypto";
 import { performance } from "node:perf_hooks";
 import { setTimeout as delay } from "node:timers/promises";
+import { KernelError } from "@mininglamp-oss/octo-runtime-executor-kernel";
 export const DEFAULT_CODEX_RETRY = Object.freeze({
     enabled: true,
     max_consecutive_retries: 5,
@@ -24,7 +25,7 @@ const clock = {
 };
 /** 预算内最多 101 次尝试；只保留身份和终态，不在此缓存模型历史。 */
 export class ImTask {
-    host;
+    kernel;
     request;
     adapterType;
     environment;
@@ -43,9 +44,10 @@ export class ImTask {
     #recoveryTimer;
     #replaySafe = true;
     #started = false;
+    #draining = false;
     stopReason;
-    constructor(host, request, adapterType, config, environment, onAttempt, time = clock) {
-        this.host = host;
+    constructor(kernel, request, adapterType, config, environment, onAttempt, time = clock) {
+        this.kernel = kernel;
         this.request = request;
         this.adapterType = adapterType;
         this.environment = environment;
@@ -61,12 +63,31 @@ export class ImTask {
     stopRetries() {
         this.#retryStop.abort();
     }
+    /** owner stop 只取消执行和后续尝试；当前订阅须继续消费真实终态。 */
+    async drain(reason = "IM shutdown") {
+        this.#draining = true;
+        this.stopRetries();
+        const active = this.#active;
+        if (!active)
+            return;
+        try {
+            this.#cancelPending ??= this.kernel.cancelInvocation(active.invocationId, reason);
+            await this.#cancelPending;
+        }
+        catch (error) {
+            // Kernel 可在订阅 ACK 时先确认终态并释放登记，业务迭代器此时仍可能等待交互展示。
+            // 登记缺失本身不是完成证据；只接受同次原流正常耗尽且包含真实终态，仍受 owner 共享期限约束。
+            if (!(error instanceof KernelError && error.code === "INVOCATION_NOT_TRACKED") ||
+                !(await active.finished))
+                throw error;
+        }
+    }
     async cancel(reason = "IM user stop") {
         this.#abort.abort(reason);
         if (!this.#active)
             return true; // 退避阶段也属于可停止的业务任务。
-        this.#cancelPending ??= this.host.cancel(this.#active, reason);
-        return (await this.#cancelPending).cancelled;
+        this.#cancelPending ??= this.kernel.cancelInvocation(this.#active.invocationId, reason);
+        return (await this.#cancelPending).accepted;
     }
     #stop(reason) {
         this.stopReason ??= reason;
@@ -142,7 +163,7 @@ export class ImTask {
         const clearDeadline = this.time.schedule(() => this.#stop("IM_TASK_DEADLINE"), deadline - this.time.now());
         let request = this.request;
         try {
-            while (!this.#signal.aborted) {
+            while (!this.#signal.aborted && !this.#draining) {
                 const remaining = Math.ceil(deadline - this.time.now());
                 if (remaining < 100) {
                     this.#stop("IM_TASK_DEADLINE");
@@ -154,7 +175,13 @@ export class ImTask {
                     if (item.namespace === "octo.execution" && item.name === "limits")
                         item.payload.run_timeout_ms = remaining;
                 this.onAttempt(request);
-                this.#active = request.invocationId;
+                let finish;
+                this.#active = {
+                    invocationId: request.invocationId,
+                    finished: new Promise((resolve) => {
+                        finish = resolve;
+                    })
+                };
                 this.#cancelPending = undefined;
                 const attempt = {
                     runId: request.runId,
@@ -163,8 +190,9 @@ export class ImTask {
                 };
                 this.attempts.push(attempt);
                 let terminal;
+                let confirmed = false;
                 try {
-                    for await (const event of this.host.invoke(request, {
+                    for await (const event of this.kernel.invoke(request, {
                         ...this.environment,
                         signal: this.#signal
                     })) {
@@ -181,6 +209,8 @@ export class ImTask {
                         else
                             yield event;
                     }
+                    // 看到终态后仍须正常耗尽：终态后的传输/控制错误不能被 drain 当成成功。
+                    confirmed = terminal !== undefined;
                 }
                 catch (error) {
                     attempt.outcome = "unknown";
@@ -190,6 +220,8 @@ export class ImTask {
                     // 必须等待消费结束及取消回执；未知结果不会进入下一次 invoke。
                     await this.#settleCancellation();
                     this.#active = undefined;
+                    // #cancelPending 只保存原始取消回执，不能反过来等待 finished，否则这里会循环等待。
+                    finish(confirmed);
                 }
                 if (!terminal)
                     throw new Error("IM_RUN_WITHOUT_TERMINAL");

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/extra.d.ts

@@ -1,3 +1,4 @@
-import { type ChannelDependencies, type ExtraInitializer, type ExtraContext, type JsonObject } from "@mininglamp-oss/octo-runtime-daemon";
+import { type ExtraInitializer, type ExtraContext, type JsonObject } from "@mininglamp-oss/octo-runtime-host-sdk";
+import type { GatewayDependencies } from "./ports.js";
 export declare const name = "channel-gateway";
-export default function load(context: ExtraContext, config: JsonObject): ExtraInitializer<ChannelDependencies>;
+export default function load(context: ExtraContext, config: JsonObject): ExtraInitializer<GatewayDependencies>;

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

@@ -1,4 +1,4 @@
-import { createContextLoader } from "@mininglamp-oss/octo-runtime-daemon";
+import { createContextLoader } from "@mininglamp-oss/octo-runtime-host-sdk";
 import { ImChannelManager } from "./lifecycle/manager.js";
 import { validateImBots, configuredCredential, imBotIdentity, IM_MAX_BOTS } from "./lifecycle/configuration.js";
 export const name = "channel-gateway";
@@ -28,9 +28,10 @@ async function initialize(context, config, dependencies) {
     }
     const allowed = spaces;
     channels = new ImChannelManager({
-        host: context.adapterHost,
+        kernel: context.kernel,
         signal: context.signal,
         log: context.log,
+        createSessionStore: dependencies.createSessionStore,
         // 只保存调用入口，不预取提示词；宿主更新业务存储后，下一个接纳的逻辑轮重新读取。
         prepareContexts: (bot, signal) => contexts.load(bot, signal),
         credentials: (bot) => Promise.resolve(configuredCredential(bot)),

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/index.d.ts

@@ -7,7 +7,10 @@ export { octoCliEnvironment } from "./execution/tool-environment.js";
 export { default, name } from "./extra.js";
 export { ImChannelManager } from "./lifecycle/manager.js";
 export { MemoryImSessionStore } from "./application/session-store.js";
-export type { ImSessionStore, ImSessionBinding } from "./application/session-store.js";
+export type { ImSessionStore, ImSessionBinding, ImSessionOccurrence } from "./application/session-store.js";
+export type { ImGapMetadata, ImGapTurnToken } from "./application/context-gap.js";
+export type { ImRulesContext, ImRulesVersions } from "./application/rules-context.js";
+export type { ImInvocationInput } from "./execution/dispatcher.js";
 export { validateImConfig, validateImBots, configuredCredential, imBotIdentity } from "./lifecycle/configuration.js";
 export { build_im_contexts } from "./transport/contexts.js";
 export { registerBot, WukongConnection } from "./transport/wukong.js";

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/lifecycle/manager.d.ts

@@ -1,10 +1,10 @@
 import type { ImBotConfig } from "../contracts.js";
-import type { ImModuleDependencies } from "../ports.js";
-/** Serial updates replace only the target connection. */
+import type { ImChannelManagerDependencies } from "../ports.js";
+/** 串行替换单个 Bot；工厂句柄归 Manager，只有旧 endpoint 完整释放才允许替换。 */
 export declare class ImChannelManager {
     #private;
-    readonly dependencies: ImModuleDependencies;
-    constructor(dependencies: ImModuleDependencies);
+    readonly dependencies: ImChannelManagerDependencies;
+    constructor(dependencies: ImChannelManagerDependencies);
     get status(): Record<string, unknown>[];
     upsert(config: ImBotConfig): Promise<Record<string, unknown>>;
     remove(id: string): Promise<void>;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/lifecycle/manager.js

@@ -1,6 +1,8 @@
 import { ImRuntime } from "../application/im-channel.js";
+import { HostSessionStore } from "../application/host-session-store.js";
+import { abortForShutdown, shutdownDeadline, shutdownSignal, withShutdownDeadline, withinShutdown } from "@mininglamp-oss/octo-runtime-host-sdk/shutdown";
 import { imBotIdentity, validateImConfig, IM_MAX_BOTS, IM_MAX_CONFIG_OPERATIONS } from "./configuration.js";
-/** Serial updates replace only the target connection. */
+/** 串行替换单个 Bot；工厂句柄归 Manager，只有旧 endpoint 完整释放才允许替换。 */
 export class ImChannelManager {
     dependencies;
     #endpoints = new Map();
@@ -11,9 +13,14 @@ export class ImChannelManager {
     #abort = new AbortController();
     constructor(dependencies) {
         this.dependencies = dependencies;
+        if (dependencies.createSessionStore !== undefined &&
+            typeof dependencies.createSessionStore !== "function")
+            throw new Error("IM_SESSION_STORE_FACTORY_INVALID");
+        if (dependencies.sessions && dependencies.createSessionStore)
+            throw new Error("IM_SESSION_STORE_CONFLICT");
     }
     get status() {
-        return [...this.#endpoints.values()].map((runtime) => ({ ...runtime.status }));
+        return [...this.#endpoints.values()].flatMap(({ runtime }) => runtime ? [{ ...runtime.status }] : []);
     }
     upsert(config) {
         if (this.#closed)
@@ -34,27 +41,75 @@ export class ImChannelManager {
             const current = this.#endpoints.get(key);
             if (!current && this.#endpoints.size >= IM_MAX_BOTS)
                 throw new Error("IM_ENDPOINT_CAPACITY_EXHAUSTED");
-            await current?.close();
+            if (current)
+                await this.#closeEndpoint(current);
             if (this.#closed)
                 throw new Error("IM_MANAGER_CLOSED");
-            const runtime = new ImRuntime(snapshot, {
-                ...this.dependencies,
-                signal: AbortSignal.any([
-                    this.#abort.signal,
-                    ...(this.dependencies.signal ? [this.dependencies.signal] : [])
-                ])
-            });
-            this.#endpoints.set(key, runtime);
-            await runtime.start();
-            return { ...runtime.status };
+            const endpoint = {};
+            // 工厂可能重入 close；先登记空 endpoint，随后创建的句柄也属于这次关闭。
+            this.#endpoints.set(key, endpoint);
+            const signal = shutdownSignal([
+                this.#abort.signal,
+                ...(this.dependencies.signal ? [this.dependencies.signal] : [])
+            ]);
+            try {
+                let sessions = this.dependencies.sessions;
+                if (snapshot.enabled !== false && this.dependencies.createSessionStore) {
+                    endpoint.store = new HostSessionStore(signal);
+                    sessions = endpoint.store.create((config) => this.dependencies.createSessionStore(config), structuredClone(snapshot));
+                }
+                if (this.#closed || signal.aborted)
+                    throw new Error("IM_MANAGER_CLOSED");
+                const runtime = new ImRuntime(snapshot, { ...this.dependencies, signal, sessions });
+                endpoint.runtime = runtime;
+                await runtime.start();
+                return { ...runtime.status };
+            }
+            catch (error) {
+                // 不能因构造或 start 失败遗失已分配句柄；清理失败时原记录继续阻止替换。
+                try {
+                    await this.#closeEndpoint(endpoint);
+                    if (this.#endpoints.get(key) === endpoint)
+                        this.#endpoints.delete(key);
+                }
+                catch {
+                    throw new Error("IM_ENDPOINT_CLEANUP_INCOMPLETE", { cause: error });
+                }
+                throw error;
+            }
         });
     }
     remove(id) {
         return this.#enqueue(async () => {
-            await this.#endpoints.get(id)?.close();
+            const endpoint = this.#endpoints.get(id);
+            if (endpoint)
+                await this.#closeEndpoint(endpoint);
             this.#endpoints.delete(id);
         });
     }
+    #closeEndpoint(endpoint, until = shutdownDeadline(this.dependencies.signal)) {
+        if (endpoint.closing)
+            return endpoint.closing;
+        endpoint.store?.drain(until);
+        endpoint.closing = Promise.resolve().then(async () => {
+            const errors = [];
+            try {
+                await withShutdownDeadline(until, () => withinShutdown(Promise.resolve().then(() => endpoint.runtime?.close()), until, "IM_DISPOSE_FAILED"));
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            try {
+                await endpoint.store?.close(until);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            if (errors.length)
+                throw new AggregateError(errors, "IM_DISPOSE_FAILED");
+        });
+        return endpoint.closing;
+    }
     #enqueue(operation) {
         if (this.#closed)
             return Promise.reject(new Error("IM_MANAGER_CLOSED"));
@@ -78,10 +133,15 @@ export class ImChannelManager {
             return this.#closing;
         this.#closed = true;
         // Cancel initialization before waiting for the queue it is blocking.
-        this.#abort.abort();
+        const until = shutdownDeadline(this.dependencies.signal);
+        for (const endpoint of this.#endpoints.values())
+            endpoint.store?.drain(until);
+        withShutdownDeadline(until, () => abortForShutdown(this.#abort));
         this.#closing = (async () => {
-            await this.#queue;
-            const results = await Promise.allSettled([...this.#endpoints.values()].map((runtime) => Promise.resolve().then(() => runtime.close())));
+            const results = await Promise.allSettled([
+                withinShutdown(this.#queue, until, "IM_DISPOSE_FAILED"),
+                ...[...this.#endpoints.values()].map((endpoint) => this.#closeEndpoint(endpoint, until))
+            ]);
             const errors = results
                 .filter((result) => result.status === "rejected")
                 .map((result) => result.reason);

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/ports.d.ts

@@ -2,15 +2,26 @@
  * 宿主依赖入口：注入执行能力、凭据来源和脱敏诊断。
  * SDK 应用自行决定账号目录和凭据生命周期，通道无需依赖 CLI 或具体 Provider。
  */
-import type { ImBotConfig, ImExecutionPort } from "./contracts.js";
+import type { KernelClient } from "@mininglamp-oss/octo-runtime-executor-kernel";
+import type { ImBotConfig } from "./contracts.js";
 import type { ImSessionStore } from "./application/session-store.js";
-import type { RuntimeLog, JsonObject } from "@mininglamp-oss/octo-runtime-daemon";
+import type { RuntimeLog, JsonObject, ChannelDependencies } from "@mininglamp-oss/octo-runtime-host-sdk";
 import type { ContextItem } from "@mininglamp-oss/octo-runtime-protocol";
 export type ImCredentialSource = (config: ImBotConfig, signal: AbortSignal) => Promise<string | undefined>;
+/** 根据可信 Bot 配置的独立快照同步创建句柄；数据库及其迁移仍归宿主所有。 */
+export type CreateSessionStore = (config: JsonObject) => ImSessionStore;
+/** Gateway 专属依赖；通过同一泛型 Extra 服务注入，不扩展通用 ExtraContext。 */
+export interface GatewayDependencies extends ChannelDependencies {
+    createSessionStore?: CreateSessionStore;
+}
+/** Manager 额外拥有工厂句柄；直接 sessions 仍为借用，不能与工厂同时配置。 */
+export interface ImChannelManagerDependencies extends ImModuleDependencies {
+    createSessionStore?: CreateSessionStore;
+}
 export interface ImModuleDependencies {
     prepareContexts?: (config: JsonObject, signal: AbortSignal) => Promise<ContextItem[]>;
     log?: RuntimeLog;
-    host: ImExecutionPort;
+    kernel: Pick<KernelClient, "invoke" | "cancelInvocation" | "respondInteraction">;
     /** Owning Extra/manager lifetime; aborts connections, execution and delivery. */
     signal?: AbortSignal;
     authorizeSpace?: (spaceId: string) => void;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/card-session.d.ts

@@ -1,6 +1,6 @@
 /**
  * 单 Run 卡片会话：首次创建、后续编辑同一消息，并用序号和终态屏障收敛状态。
- * 卡片失败独立记录，最终文本仍由执行编排投递；发送回执不代表客户端已经渲染。
+ * 终态卡片失败由 finish 返回，最终文本仍由执行编排投递；回执不代表客户端已经渲染。
  */
 import type { ImAddress } from "../contracts.js";
 import type { OctoConnector } from "./connector.js";

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/card-session.js

@@ -10,6 +10,7 @@ export class CardSession {
     onDiagnostic;
     #messageId;
     #seq = 0;
+    #terminalFailed = false;
     #scheduler;
     effectKey;
     constructor(connector, delivery, address, runId, stopTyping, onDiagnostic) {
@@ -19,7 +20,16 @@ export class CardSession {
         this.stopTyping = stopTyping;
         this.onDiagnostic = onDiagnostic;
         this.effectKey = stableEffectKey(imBotIdentity(connector.config), address, runId, "progress");
-        this.#scheduler = new ProgressScheduler((snapshot) => this.#send(snapshot), () => onDiagnostic("IM_CARD_FAILED"));
+        this.#scheduler = new ProgressScheduler(async (snapshot) => {
+            try {
+                await this.#send(snapshot);
+            }
+            catch (error) {
+                if (snapshot.terminal || snapshot.resultUnknown)
+                    this.#terminalFailed = true;
+                throw error;
+            }
+        }, () => onDiagnostic("IM_CARD_FAILED"));
     }
     update(snapshot) {
         if (snapshot.terminal || snapshot.phase === "waiting")
@@ -27,17 +37,21 @@ export class CardSession {
         this.#scheduler.enqueue(snapshot, !!snapshot.terminal || !!snapshot.resultUnknown);
     }
     async #send(snapshot) {
+        const settled = !!snapshot.terminal || !!snapshot.resultUnknown;
         const template = await this.connector.reasoningTemplate();
         if (!template) {
+            if (settled && this.#messageId)
+                this.#terminalFailed = true;
             this.onDiagnostic("IM_CARD_UNAVAILABLE");
             return;
         }
         const frame = buildReasoningFrame(snapshot, template);
         if (!frame) {
+            if (settled)
+                this.#terminalFailed = true;
             this.onDiagnostic("IM_CARD_BUDGET_EXCEEDED");
             return;
         }
-        const settled = !!snapshot.terminal || !!snapshot.resultUnknown;
         // 模板查询期间可能已收到终态；旧快照必须在出站前再次检查。
         if (this.#scheduler.terminal && !settled)
             return;
@@ -48,12 +62,17 @@ export class CardSession {
             this.#messageId = receipt.messageId;
             this.stopTyping();
         }
-        else
+        else {
+            if (settled)
+                this.#terminalFailed = true;
             this.onDiagnostic(receipt.code ?? "IM_CARD_FAILED");
+        }
     }
     async finish() {
         this.stopTyping();
         await this.#scheduler.flush();
+        if (this.#terminalFailed)
+            throw new Error("IM_CARD_FINALIZATION_FAILED");
     }
     get messageId() {
         return this.#messageId;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/channel.d.ts

@@ -36,7 +36,7 @@ export declare class GatewayTransport {
     constructor(config: OctoBotConfig, credentials: ImCredentialSource, callbacks: ChannelCallbacks);
     get status(): {
         connected: boolean;
-        cardDeliveries: import("../contracts.js").ImDeliveryReceipt[];
+        cardDeliveries: number;
     };
     start(signal: AbortSignal): Promise<void>;
     close(): Promise<void>;