@mininglamp-oss/octo-runtime 1.0.1 → 1.1.1

package/node_modules/@mininglamp-oss/octo-runtime-extra-webui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mininglamp-oss/octo-runtime-extra-webui",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "private": true,
   "type": "module",
   "description": "Local Runtime workbench with canonical SSE presentation",
@@ -19,6 +19,6 @@
     "porting-map.md"
   ],
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-protocol": "1.0.1"
+    "@mininglamp-oss/octo-runtime-protocol": "1.1.1"
   }
 }

package/node_modules/@mininglamp-oss/{octo-runtime-daemon → octo-runtime-host-sdk}/dist/context-loader.d.ts

@@ -28,3 +28,4 @@ export declare function createContextLoader(callback: LoadContexts | undefined,
     close(): Promise<void>;
     readonly inFlight: number;
 };
+export declare function assertBoundedJson(value: unknown): asserts value is readonly ContextItem[];

package/node_modules/@mininglamp-oss/{octo-runtime-daemon → octo-runtime-host-sdk}/dist/context-loader.js

@@ -112,7 +112,7 @@ export function createContextLoader(callback, settings, owner) {
 }
 // 先限制外部结果的深度和遍历成本，再进入协议校验、序列化和复制，避免校验本身放大内存。
 // 这不是 JS 沙箱：无法限制业务函数执行期间自行分配的内存或阻塞事件循环。
-function assertBoundedJson(value) {
+export function assertBoundedJson(value) {
     if (!Array.isArray(value) || value.length > 32)
         throw new Error("IM_CONTEXT_RESULT_INVALID");
     // 预检预算覆盖节点、键和字符；最终字节数及 item 约束仍由 Context v3 校验器决定。

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/endpoint.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizedHome(home: string, platform?: NodeJS.Platform): string;
+export declare function homeHash(home: string, platform?: NodeJS.Platform): string;
+export declare function componentEndpoint(home: string, component?: string, platform?: NodeJS.Platform): string;
+export declare function componentServiceId(home: string, component: string, platform?: NodeJS.Platform): string;

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/endpoint.js

@@ -0,0 +1,20 @@
+import { createHash } from "node:crypto";
+import { join, resolve, win32 } from "node:path";
+export function normalizedHome(home, platform = process.platform) {
+    return platform === "win32" ? win32.resolve(home).toLowerCase() : resolve(home);
+}
+export function homeHash(home, platform = process.platform) {
+    return createHash("sha256").update(normalizedHome(home, platform)).digest("hex").slice(0, 16);
+}
+export function componentEndpoint(home, component = "executor-kernel", platform = process.platform) {
+    if (!/^[a-z][a-z0-9-]{0,69}$/.test(component))
+        throw new Error("COMPONENT_INVALID");
+    return platform === "win32"
+        ? `\\\\.\\pipe\\octo-runtime-${component === "executor-kernel" ? "kernel" : component}-${homeHash(home, platform)}`
+        : join(normalizedHome(home), "sockets", `octo-runtime-${component}.sock`);
+}
+export function componentServiceId(home, component, platform = process.platform) {
+    if (!/^[a-z][a-z0-9-]{0,69}$/.test(component))
+        throw new Error("COMPONENT_INVALID");
+    return `cn.mininglamp.octo-runtime.h${homeHash(home, platform)}.${component}`;
+}

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class HostRuntimeError extends Error {
+    readonly code: string;
+    readonly scope: string;
+    readonly retryable: boolean;
+    constructor(code: string, scope: string, retryable: boolean, message: string, options?: ErrorOptions);
+}

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/errors.js

@@ -0,0 +1,12 @@
+export class HostRuntimeError extends Error {
+    code;
+    scope;
+    retryable;
+    constructor(code, scope, retryable, message, options) {
+        super(message, options);
+        this.code = code;
+        this.scope = scope;
+        this.retryable = retryable;
+        this.name = "HostRuntimeError";
+    }
+}

package/node_modules/@mininglamp-oss/{octo-runtime-daemon → octo-runtime-host-sdk}/dist/extra-config.d.ts

@@ -6,8 +6,15 @@ export interface ExtraDescriptor {
     enabled?: boolean;
     config: JsonObject;
 }
-export type StoredExtra = Omit<ExtraDescriptor, "name">;
+/** CLI 配置可由 manifest 提供模块；原生代码声明 ExtraDescriptor 仍显式指定模块。 */
+export interface StoredExtra {
+    module?: string;
+    enabled?: boolean;
+    config: JsonObject;
+}
 export declare function assertStoredExtra(value: unknown): asserts value is StoredExtra;
 export declare function extraRegistration(descriptor: ExtraDescriptor): ExtraRegistration;
 /** Called only by a host that explicitly selects this directory as its source. */
 export declare function readExtraDirectory(directory: string): Promise<ExtraRegistration[]>;
+/** 宿主显式选取的配置文件；保持凭据权限校验，不解析或导入模块。 */
+export declare function readStoredExtra(directory: string, name: string): Promise<StoredExtra>;

package/node_modules/@mininglamp-oss/{octo-runtime-daemon → octo-runtime-host-sdk}/dist/extra-config.js

@@ -8,7 +8,7 @@ export function assertStoredExtra(value) {
     const item = value;
     if (Object.keys(item).some((key) => !["module", "enabled", "config"].includes(key)))
         throw new Error("EXTRA_CONFIG_FIELD_INVALID");
-    if (typeof item.module !== "string" || !validModule(item.module))
+    if (item.module !== undefined && (typeof item.module !== "string" || !validModule(item.module)))
         throw new Error("EXTRA_MODULE_INVALID");
     if (item.enabled !== undefined && typeof item.enabled !== "boolean")
         throw new Error("EXTRA_ENABLED_INVALID");
@@ -35,12 +35,15 @@ export function extraRegistration(descriptor) {
     assertExtraName(descriptor.name);
     const { name, ...stored } = descriptor;
     assertStoredExtra(stored);
+    const module = stored.module;
+    if (!module)
+        throw new Error("EXTRA_MODULE_REQUIRED");
     return {
         name,
-        module: stored.module,
+        module,
         config: stored.config,
         enabled: stored.enabled,
-        load: () => import(isAbsolute(stored.module) ? pathToFileURL(stored.module).href : stored.module)
+        load: () => import(isAbsolute(module) ? pathToFileURL(module).href : module)
     };
 }
 /** Called only by a host that explicitly selects this directory as its source. */
@@ -56,15 +59,14 @@ export async function readExtraDirectory(directory) {
             continue;
         assertExtraName(entry.name);
         try {
-            const file = join(directory, entry.name, "config.json");
-            const info = await lstat(file);
-            if (!info.isFile() || (process.platform !== "win32" && info.mode & 0o077))
-                throw new Error("EXTRA_CONFIG_PERMISSIONS_INVALID");
-            if (info.size > 1024 * 1024)
-                throw new Error("EXTRA_CONFIG_TOO_LARGE");
-            const stored = JSON.parse(await readFile(file, "utf8"));
-            assertStoredExtra(stored);
-            registrations.push(extraRegistration({ name: entry.name, ...stored }));
+            const stored = await readStoredExtra(directory, entry.name);
+            registrations.push(stored.module
+                ? extraRegistration({ ...stored, name: entry.name, module: stored.module })
+                : {
+                    ...stored,
+                    name: entry.name,
+                    load: () => Promise.reject(new Error("EXTRA_MODULE_REQUIRED"))
+                });
         }
         catch (error) {
             const code = error instanceof Error && /^EXTRA_[A-Z_]+$/.test(error.message)
@@ -79,6 +81,19 @@ export async function readExtraDirectory(directory) {
     }
     return registrations;
 }
+/** 宿主显式选取的配置文件；保持凭据权限校验，不解析或导入模块。 */
+export async function readStoredExtra(directory, name) {
+    assertExtraName(name);
+    const file = join(directory, name, "config.json");
+    const info = await lstat(file);
+    if (!info.isFile() || (process.platform !== "win32" && info.mode & 0o077))
+        throw new Error("EXTRA_CONFIG_PERMISSIONS_INVALID");
+    if (info.size > 1024 * 1024)
+        throw new Error("EXTRA_CONFIG_TOO_LARGE");
+    const stored = JSON.parse(await readFile(file, "utf8"));
+    assertStoredExtra(stored);
+    return stored;
+}
 function validModule(module) {
     if (isAbsolute(module))
         return true;

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/extra-dependencies.d.ts

@@ -0,0 +1,4 @@
+type DependencyFunction = (...args: unknown[]) => unknown;
+/** 同进程只读浅快照；保留原型成员，函数始终以宿主原对象为 this，不冻结宿主状态。 */
+export declare function snapshotExtraDependencies<D extends object>(source: Readonly<D>, wrap?: (invoke: DependencyFunction) => DependencyFunction): Readonly<D>;
+export {};

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/extra-dependencies.js

@@ -0,0 +1,21 @@
+/** 同进程只读浅快照；保留原型成员，函数始终以宿主原对象为 this，不冻结宿主状态。 */
+export function snapshotExtraDependencies(source, wrap = (invoke) => invoke) {
+    const snapshot = Object.create(Object.getPrototypeOf(source));
+    const seen = new Set();
+    for (let current = source; current && current !== Object.prototype; current = Object.getPrototypeOf(current)) {
+        for (const key of Reflect.ownKeys(current)) {
+            if (seen.has(key) || (key === "constructor" && current !== source))
+                continue;
+            seen.add(key);
+            // 值与访问器结果沿用浅快照语义；方法绑定原实例，才能访问其私有字段。
+            const value = Reflect.get(source, key, source);
+            Object.defineProperty(snapshot, key, {
+                value: typeof value === "function"
+                    ? wrap((...args) => Reflect.apply(value, source, args))
+                    : value,
+                enumerable: Reflect.getOwnPropertyDescriptor(current, key).enumerable
+            });
+        }
+    }
+    return Object.freeze(snapshot);
+}

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/extra-service.d.ts

@@ -0,0 +1,22 @@
+import { type RuntimeLoggingOptions } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import { type ServiceLifecycle, type ServicePhase } from "@mininglamp-oss/octo-runtime-executor-kernel";
+import { type ExtraPluginModule, type JsonObject } from "./extras.js";
+export interface ExtraServiceOptions<D extends object = Record<string, never>> {
+    endpoint: string;
+    module: ExtraPluginModule<D>;
+    config: JsonObject;
+    dependencies: Readonly<D>;
+    enabled?: boolean;
+    controlEndpoint?: string;
+    logging?: RuntimeLoggingOptions;
+}
+export interface ExtraServiceStatus {
+    phase: ServicePhase;
+    name: string;
+    pid: number;
+    kernel_available: boolean;
+    plugin: JsonObject;
+}
+export type ExtraService = ServiceLifecycle<ExtraServiceStatus>;
+/** 装配插件和同进程业务函数；只借用指定 Kernel，不启动或关闭它。 */
+export declare function createExtraService<D extends object>(options: ExtraServiceOptions<D>): ExtraService;

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/extra-service.js

@@ -0,0 +1,309 @@
+import net from "node:net";
+import { performance } from "node:perf_hooks";
+import { chmod, mkdir, rm } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { RuntimeLogging, assertRuntimeLogging, readBoundedLines } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import { acquireEndpoint, attachKernel, ServiceInitializationError } from "@mininglamp-oss/octo-runtime-executor-kernel";
+import { assertExtraName, ExtraPlugins } from "./extras.js";
+import { shutdownDeadline, withShutdownDeadline, withinShutdown } from "./shutdown.js";
+import { snapshotExtraDependencies } from "./extra-dependencies.js";
+// 未确认清理的实例仍占有名称；不同 Kernel/Home 的同名 Extra 相互独立。
+const owners = new Map();
+/** 装配插件和同进程业务函数；只借用指定 Kernel，不启动或关闭它。 */
+export function createExtraService(options) {
+    assertExtraName(options.module.name);
+    assertRuntimeLogging(options.logging);
+    const name = options.module.name;
+    const config = structuredClone(options.config);
+    const module = { ...options.module };
+    const pendingDependencies = new Set();
+    const endpoint = options.endpoint;
+    const controlEndpoint = options.controlEndpoint;
+    const enabled = options.enabled !== false;
+    const logging = options.logging && { ...options.logging };
+    const key = `${process.platform === "win32" ? endpoint.toLowerCase() : resolve(endpoint)}\0${name}`;
+    const owner = new AbortController();
+    let dependenciesOpen = true;
+    let shutdownUntil;
+    const dependencies = snapshotExtraDependencies(options.dependencies, (invoke) => (...args) => {
+        // 取消通知不撤销尾部保存权限；清理完成或绝对截止后才禁止调用宿主函数。
+        if (!dependenciesOpen || performance.now() >= (shutdownUntil ?? Infinity))
+            throw new Error("EXTRA_DEPENDENCIES_CLOSED");
+        if (pendingDependencies.size >= 128)
+            throw new Error("EXTRA_DEPENDENCY_CAPACITY_EXHAUSTED");
+        const result = invoke(...args);
+        if (result && typeof result.then === "function") {
+            // 每次调用独立占额；宿主复用同一 Promise 时也不能绕过在途上限。
+            const operation = Promise.resolve(result).then((value) => value);
+            pendingDependencies.add(operation);
+            void operation.finally(() => pendingDependencies.delete(operation)).catch(() => undefined);
+        }
+        return result;
+    });
+    const ownership = { failed: false };
+    let acquired = false;
+    let phase = "created";
+    let client;
+    let logs;
+    let plugins;
+    let starting;
+    let initialized;
+    let closing;
+    let cleanupDeadline;
+    let draining;
+    let server;
+    let binding;
+    let release;
+    let healthTimer;
+    let healthCheck;
+    let lastAvailable;
+    const logState = (event, state, code) => logs?.extra(name)(code ? "warn" : "info", event, { state, ...(code ? { code } : {}) });
+    const kernelAvailable = () => {
+        if (healthCheck)
+            return healthCheck;
+        healthCheck = (client?.status().then((value) => value.execution_ready, () => false) ?? Promise.resolve(false))
+            .then((available) => {
+            if (!owner.signal.aborted && available !== lastAvailable) {
+                lastAvailable = available;
+                logState(available ? "kernel.available" : "kernel.unavailable", available ? "available" : "unavailable");
+            }
+            return available;
+        })
+            .finally(() => {
+            healthCheck = undefined;
+        });
+        return healthCheck;
+    };
+    const watchKernel = () => {
+        // Allow one probe at a time and schedule after settlement; emit transitions, not idle heartbeats.
+        void kernelAvailable().finally(() => {
+            if (owner.signal.aborted || !logging)
+                return;
+            healthTimer = setTimeout(watchKernel, 5000);
+            healthTimer.unref();
+        });
+    };
+    const sockets = new Set();
+    let finishClosed;
+    const closed = new Promise((resolve) => {
+        finishClosed = resolve;
+    });
+    const status = async () => ({
+        phase,
+        name,
+        pid: process.pid,
+        kernel_available: await kernelAvailable(),
+        plugin: !enabled
+            ? { phase: "disabled" }
+            : phase === "ready" && plugins
+                ? await plugins.inspect(name)
+                : { phase }
+    });
+    const drainRuns = async () => {
+        if (!client)
+            return;
+        const result = await client.invocations.drain({
+            deadline: (cleanupDeadline ??= Date.now() + 5000),
+            reason: "extra_shutdown"
+        });
+        if (!result.complete)
+            throw new Error("EXTRA_RUN_CLEANUP_INCOMPLETE");
+    };
+    const beginDrain = (signal) => {
+        shutdownUntil ??= shutdownDeadline(signal);
+        cleanupDeadline ??= Date.now() + Math.max(0, Math.floor(shutdownUntil - performance.now()));
+        client?.invocations.stopAdmission();
+        // 回滚通知先于加载器等待 disposer；立即取消源调用，避免消费者与清理互相等待。
+        if (!draining) {
+            draining = drainRuns();
+            void draining.catch(() => undefined);
+        }
+        return draining;
+    };
+    const close = () => {
+        if (closing)
+            return closing;
+        phase = "closing";
+        logState("service.closing", phase);
+        clearTimeout(healthTimer);
+        shutdownUntil ??= shutdownDeadline();
+        const draining = beginDrain();
+        owner.abort();
+        withShutdownDeadline(shutdownUntil, () => plugins?.stopAdmission());
+        for (const socket of sockets)
+            socket.destroy();
+        closing = (async () => {
+            const until = shutdownUntil;
+            const errors = [];
+            const attempt = async (resource, operation) => {
+                try {
+                    await withinShutdown(Promise.resolve().then(operation), until, "EXTRA_CLEANUP_TIMEOUT");
+                }
+                catch {
+                    errors.push({ resource, code: "EXTRA_CLEANUP_INCOMPLETE" });
+                }
+            };
+            await attempt("initialization", () => starting?.catch(() => undefined));
+            // 插件先停业务准入并等待自己的消费者；与源调用排空并行，避免收尾互相等待。
+            await Promise.all([
+                attempt("runs", () => draining),
+                attempt("plugin", async () => {
+                    try {
+                        await withShutdownDeadline(until, () => plugins?.close());
+                    }
+                    finally {
+                        dependenciesOpen = false;
+                    }
+                })
+            ]);
+            dependenciesOpen = false;
+            // 权限撤销后集合不再增长，才能完整等待清理中新开始的真实依赖操作。
+            await attempt("dependencies", async () => {
+                await Promise.allSettled([...pendingDependencies]);
+            });
+            await attempt("control-server", async () => {
+                // 到期只结束等待；绑定稍后完成时，此操作仍须继续关闭迟到的监听句柄。
+                await binding?.catch(() => undefined);
+                if (server?.listening)
+                    await new Promise((resolve, reject) => {
+                        server.close((error) => (error ? reject(error) : resolve()));
+                    });
+            });
+            client?.close();
+            if (!errors.length)
+                await attempt("control-endpoint", async () => {
+                    if (!release)
+                        return;
+                    if (controlEndpoint && process.platform !== "win32")
+                        await rm(controlEndpoint, { force: true });
+                    await release();
+                });
+            logState(errors.length ? "service.cleanup_incomplete" : "service.closed", errors.length ? "failed" : "closed", errors.length ? "EXTRA_CLEANUP_INCOMPLETE" : undefined);
+            await attempt("logs", () => logs?.close());
+            if (acquired) {
+                if (errors.length)
+                    ownership.failed = true;
+                else
+                    owners.delete(key);
+            }
+            phase = errors.length ? "failed" : "closed";
+            const result = {
+                complete: !errors.length,
+                errors,
+                pendingResources: errors.map((error) => error.resource)
+            };
+            finishClosed(result);
+            return result;
+        })();
+        return closing;
+    };
+    return {
+        status,
+        close,
+        closed,
+        initialize({ signal } = {}) {
+            if (initialized)
+                return initialized;
+            if (phase !== "created")
+                return Promise.reject(new Error("SERVICE_CLOSED"));
+            phase = "initializing";
+            let onAbort;
+            const cancelled = new Promise((_, reject) => {
+                onAbort = () => reject(owner.signal.reason instanceof Error
+                    ? owner.signal.reason
+                    : new Error("SERVICE_INITIALIZATION_CANCELLED", { cause: owner.signal.reason }));
+                owner.signal.addEventListener("abort", onAbort, { once: true });
+            });
+            const abort = () => {
+                shutdownUntil ??= shutdownDeadline();
+                void beginDrain();
+                owner.abort();
+                withShutdownDeadline(shutdownUntil, () => plugins?.stopAdmission());
+            };
+            signal?.addEventListener("abort", abort, { once: true });
+            if (signal?.aborted)
+                abort();
+            starting = (async () => {
+                owner.signal.throwIfAborted();
+                const previous = owners.get(key);
+                if (previous)
+                    throw new Error(previous.failed ? "EXTRA_DISPOSE_FAILED" : "EXTRA_ALREADY_LOADED");
+                if (owners.size >= 64)
+                    throw new Error("EXTRA_CAPACITY_EXHAUSTED");
+                owners.set(key, ownership);
+                acquired = true;
+                client = attachKernel({ endpoint });
+                logs = new RuntimeLogging(logging);
+                logState("service.initializing", phase);
+                if (logging)
+                    watchKernel();
+                plugins = new ExtraPlugins([], client, () => logs.extra(name));
+                if (enabled)
+                    await plugins.load({
+                        ...module,
+                        default(context, config) {
+                            // 初始化失败先停准入并排空；不 abort owner，以保留加载器抛出的原始 cause。
+                            context.signal.addEventListener("abort", () => {
+                                void beginDrain(context.signal);
+                            }, { once: true });
+                            return module.default(context, config);
+                        }
+                    }, config, dependencies);
+                owner.signal.throwIfAborted();
+                if (controlEndpoint) {
+                    if (process.platform !== "win32")
+                        await mkdir(dirname(controlEndpoint), { recursive: true, mode: 0o700 });
+                    owner.signal.throwIfAborted();
+                    release = await acquireEndpoint(controlEndpoint);
+                    owner.signal.throwIfAborted();
+                    server = net.createServer((socket) => {
+                        if (owner.signal.aborted) {
+                            socket.destroy();
+                            return;
+                        }
+                        sockets.add(socket);
+                        socket.once("close", () => sockets.delete(socket));
+                        socket.on("error", () => socket.destroy());
+                        socket.setTimeout(5000, () => socket.destroy());
+                        const off = readBoundedLines(socket, 4096, {
+                            onError: () => socket.destroy(),
+                            onTooLarge: () => socket.destroy(),
+                            onClose() { },
+                            onLine(line) {
+                                off();
+                                try {
+                                    const request = JSON.parse(line);
+                                    if (request.method !== "status")
+                                        throw new Error("METHOD_NOT_FOUND");
+                                    void status().then((value) => socket.end(`${JSON.stringify({ jsonrpc: "2.0", id: request.id, result: { name, pid: process.pid, status: { ...value.plugin, kernel_available: value.kernel_available } } })}\n`), () => socket.destroy());
+                                }
+                                catch {
+                                    socket.destroy();
+                                }
+                            }
+                        });
+                    });
+                    await (binding = new Promise((resolve, reject) => {
+                        server.once("error", reject);
+                        server.listen(controlEndpoint, resolve);
+                    }));
+                    if (process.platform !== "win32")
+                        await chmod(controlEndpoint, 0o600);
+                    owner.signal.throwIfAborted();
+                }
+                phase = "ready";
+                logState("service.ready", phase);
+            })();
+            initialized = Promise.race([starting, cancelled])
+                .catch(async (error) => {
+                logState("service.failed", "failed", "SERVICE_INITIALIZATION_FAILED");
+                throw new ServiceInitializationError(error, await close());
+            })
+                .finally(() => {
+                signal?.removeEventListener("abort", abort);
+                owner.signal.removeEventListener("abort", onAbort);
+            });
+            return initialized;
+        }
+    };
+}

package/node_modules/@mininglamp-oss/{octo-runtime-daemon → octo-runtime-host-sdk}/dist/extras.d.ts

@@ -1,5 +1,4 @@
-import type { InputInvoke, InteractionResponse } from "@mininglamp-oss/octo-runtime-protocol";
-import type { HostedAdapterMetadata } from "@mininglamp-oss/octo-runtime-adapter-host";
+import type { KernelClient } from "@mininglamp-oss/octo-runtime-executor-kernel";
 import { type RuntimeLog } from "@mininglamp-oss/octo-runtime-adapter-sdk";
 export type { ChannelDependencies, LoadContexts } from "./context-loader.js";
 export type { RuntimeLog, RuntimeLogLevel } from "@mininglamp-oss/octo-runtime-adapter-sdk";
@@ -9,20 +8,11 @@ export interface JsonObject {
 }
 export type ExtraDisposer = () => void | Promise<void>;
 export type ExtraStatusHandler = () => JsonObject;
-/** 插件复用宿主执行实例，不依赖 HostRunService 的内部实现。 */
-export interface ExtraAdapterHost {
-    list?(): Promise<HostedAdapterMetadata[]>;
-    invoke: InputInvoke;
-    cancel(invocationId: string, reason?: string): Promise<{
-        cancelled: boolean;
-    }>;
-    respondInteraction(invocationId: string, response: InteractionResponse): Promise<void>;
-}
 /** This execution environment is unrelated to the model Context envelope. */
 export interface ExtraContext {
     /** F31：.octospec/tasks/gateway-august-feature-assessment/assessment.md；无日志宿主也提供 no-op。 */
     readonly log: RuntimeLog;
-    readonly adapterHost: ExtraAdapterHost;
+    readonly kernel: KernelClient;
     readonly signal: AbortSignal;
     onDispose(dispose: ExtraDisposer): void;
     onStatus(handler: ExtraStatusHandler): void;
@@ -50,15 +40,16 @@ export declare function assertExtraName(name: unknown): asserts name is string;
 /** 每个声明名最多一个实例；只加载宿主选定的插件，并统一管理取消、状态和清理。 */
 export declare class ExtraPlugins {
     #private;
-    private readonly adapterHost;
+    private readonly kernel;
     private readonly logForExtra;
     static validate(registrations: readonly ExtraRegistration[]): void;
-    constructor(registrations: readonly ExtraRegistration[], adapterHost: ExtraContext["adapterHost"], logForExtra?: (name: string) => RuntimeLog);
+    constructor(registrations: readonly ExtraRegistration[], kernel: KernelClient, logForExtra?: (name: string) => RuntimeLog);
     get status(): Record<string, ExtraStatus>;
     loadConfigured(): Promise<void>;
     inspect(name: string): Promise<JsonObject>;
     load<D extends object>(module: ExtraPluginModule<D>, config: JsonObject, dependencies: Readonly<D>): Promise<void>;
     load(name: string, registration?: ExtraRegistration): Promise<void>;
     unload(name: string): Promise<void>;
+    stopAdmission(): void;
     close(): Promise<void>;
 }