@mininglamp-oss/octo-runtime 1.0.1 → 1.1.1

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/manifest-adapters.js

@@ -0,0 +1,88 @@
+import { parseModuleManifest, readModuleManifest, resolveModuleSpecifier } from "@mininglamp-oss/octo-runtime-adapter-sdk/module-manifest";
+/**
+ * 仅供清单驱动的 worker 在自身进程装配：只实例化所选模块，返回后由入口注册及 serveWorker。
+ * CLI 可在注册前用实际 metadata 做产品准备；SDK 原生 import 入口不经过此文件加载边界。
+ */
+export async function loadManifestAdapters() {
+    const index = process.argv.indexOf("--manifest");
+    const entries = process.argv.includes("--adapters-from-ipc")
+        ? await receiveAdapters()
+        : index >= 0 && process.argv[index + 1]
+            ? (await readModuleManifest(process.argv[index + 1], { legacy: true })).adapters
+            : (() => {
+                throw new Error("usage: octo-runtime-executor-kernel --manifest <file>");
+            })();
+    const adapters = [];
+    for (const entry of entries) {
+        const specifier = resolveModuleSpecifier(entry.module, entry.sourceManifest);
+        const loaded = await import(specifier);
+        const exports = asRecord(loaded, `adapter module ${entry.module}`);
+        const exported = exports[entry.export];
+        if (exported === undefined)
+            throw new Error(`missing export ${entry.export} from ${entry.module}`);
+        // 动态模块先校验工厂与 Adapter 形状，再交给唯一 Core 注册；不提前探测未选模块。
+        const instance = entry.factory ? callFactory(exported, entry) : exported;
+        if (!isHostedAdapter(instance))
+            throw new TypeError(`${entry.module}#${entry.export} is not an Octo Runtime adapter`);
+        if (entry.type && instance.metadata.type !== entry.type)
+            throw new Error(`manifest type ${entry.type} does not match adapter ${instance.metadata.type}`);
+        adapters.push(instance);
+    }
+    return adapters;
+}
+/** 内部启动消息只携带 JSON 模块声明，不传函数/实例；就绪仍沿用既有 list/probe 握手。 */
+function receiveAdapters() {
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            clearTimeout(timer);
+            process.off("message", onMessage);
+            process.off("disconnect", onDisconnect);
+        };
+        const onDisconnect = () => {
+            cleanup();
+            reject(new Error("Adapter initialization channel disconnected"));
+        };
+        const onMessage = (message) => {
+            if (!isRecord(message) || message.type !== "kernel.adapters")
+                return;
+            cleanup();
+            try {
+                // 快照已经解析为绝对位置；这个路径只用于结构校验，不读取或生成任何文件。
+                resolve(parseModuleManifest({ version: 1, adapters: message.adapters, extras: [] }, process.cwd(), { legacy: true }).adapters);
+            }
+            catch (error) {
+                reject(error instanceof Error ? error : new Error("Invalid Adapter initialization"));
+            }
+        };
+        const timer = setTimeout(() => {
+            cleanup();
+            reject(new Error("Adapter initialization timed out"));
+        }, 15000);
+        process.on("message", onMessage);
+        process.once("disconnect", onDisconnect);
+        if (!process.connected)
+            onDisconnect();
+    });
+}
+function callFactory(value, entry) {
+    if (typeof value !== "function")
+        throw new TypeError(`${entry.module}#${entry.export} is marked as a factory but is not callable`);
+    return value(entry.options);
+}
+function isHostedAdapter(value) {
+    if (!isRecord(value) || !isRecord(value.metadata))
+        return false;
+    return (typeof value.metadata.type === "string" &&
+        Array.isArray(value.metadata.agentSources) &&
+        value.metadata.agentSources.length > 0 &&
+        value.metadata.agentSources.every((source) => source === "preset" || source === "provisioned") &&
+        typeof value.invoke === "function");
+}
+function asRecord(value, label) {
+    if (!isRecord(value))
+        throw new TypeError(`${label} must be an object`);
+    return value;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/module-specifier.d.ts

@@ -0,0 +1 @@
+export { resolveModuleSpecifier as resolveAdapterModuleSpecifier } from "@mininglamp-oss/octo-runtime-adapter-sdk/module-manifest";

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/module-specifier.js

@@ -0,0 +1,2 @@
+// 内部兼容入口，CLI 与 runner 共用原始 manifest 锚点下的 ESM 解析。
+export { resolveModuleSpecifier as resolveAdapterModuleSpecifier } from "@mininglamp-oss/octo-runtime-adapter-sdk/module-manifest";

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/process.d.ts

@@ -0,0 +1,35 @@
+import { type ChildProcess, type ChildProcessByStdio } from "node:child_process";
+import type { Readable, Writable } from "node:stream";
+import type { HostedAdapterMetadata } from "./index.js";
+import { WorkerRpcClient } from "./rpc.js";
+import type { AdapterModuleEntry } from "@mininglamp-oss/octo-runtime-adapter-sdk/module-manifest";
+export interface SpawnWorkerOptions {
+    entrypoint: string;
+    /** CLI JSON 来源；SDK 的直接 import 入口不需要此参数。 */
+    manifest?: string;
+    /** CLI 已解析的不可变装配快照；与 manifest 互斥，不改变 SDK 自有 worker 的入口。 */
+    adapterModules?: AdapterModuleEntry[];
+    env?: NodeJS.ProcessEnv;
+    /** 取消就绪等待并请求回收子进程；POSIX 使用进程组，Windows taskkill 不保证父先退后的后代回收。 */
+    signal?: AbortSignal;
+    /** 启动快照发送和首次 RPC 就绪握手共用的最大等待时间。 */
+    readyTimeoutMs?: number;
+    onSpawn?: (child: ChildProcess) => Promise<void>;
+}
+type HostedChild = ChildProcessByStdio<Writable, Readable, Readable>;
+export interface WorkerProcess {
+    client: WorkerRpcClient;
+    child: HostedChild;
+    adapters: HostedAdapterMetadata[];
+    close(): Promise<void>;
+    stderr(): string;
+}
+/** Kernel 内部传递关闭预算；公开 WorkerProcess.close() 仍然无参数。故障恢复不等待日志排空。 */
+export declare function closeWorker(worker: WorkerProcess, until: number, immediate?: boolean): Promise<void>;
+/**
+ * 启动 Node worker，以首次 list RPC 成功作为就绪确认，再返回客户端与进程所有权。
+ * 入口/manifest/环境错误在启动阶段携带有界 stderr 抛出；失败路径仍须回收已创建的进程。
+ * owner 必须等待 close；清理失败不能当作可安全启动替代 worker 的普通启动错误。
+ */
+export declare function spawnWorker({ entrypoint, manifest, adapterModules, env, signal, onSpawn, readyTimeoutMs }: SpawnWorkerOptions): Promise<WorkerProcess>;
+export {};

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/process.js

@@ -0,0 +1,218 @@
+import { createProcessCleanup } from "@mininglamp-oss/octo-runtime-adapter-sdk/process-cleanup";
+import { execFile, spawn } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+import { WorkerRpcClient } from "./rpc.js";
+// Reserve more time for tree cleanup until the worker confirms it has started shutdown.
+// A cooperating worker can use its existing 2.5 s shutdown + 1 s logging bounds.
+const WINDOWS_CLOSE_GRACE_MS = 4_000;
+const WINDOWS_TREE_CLEANUP_RESERVE_MS = 1_900;
+const WINDOWS_COOPERATIVE_CLEANUP_RESERVE_MS = 1_000;
+const closeOptions = new WeakMap();
+/** Kernel 内部传递关闭预算；公开 WorkerProcess.close() 仍然无参数。故障恢复不等待日志排空。 */
+export function closeWorker(worker, until, immediate = false) {
+    closeOptions.set(worker, { until, immediate });
+    return worker.close();
+}
+/**
+ * 启动 Node worker，以首次 list RPC 成功作为就绪确认，再返回客户端与进程所有权。
+ * 入口/manifest/环境错误在启动阶段携带有界 stderr 抛出；失败路径仍须回收已创建的进程。
+ * owner 必须等待 close；清理失败不能当作可安全启动替代 worker 的普通启动错误。
+ */
+export async function spawnWorker({ entrypoint, manifest, adapterModules, env = process.env, signal, onSpawn, readyTimeoutMs = 15_000 }) {
+    if (signal?.aborted)
+        throw new Error("adapter-host spawn cancelled");
+    if (manifest && adapterModules !== undefined)
+        throw new TypeError("manifest and adapterModules are mutually exclusive");
+    if (!Number.isFinite(readyTimeoutMs) || readyTimeoutMs < 1) {
+        throw new Error("adapter-host readyTimeoutMs must be positive");
+    }
+    // 快照通过已有 Node IPC 发送，不占命令行/环境长度，不落盘；永不序列化模块实例。
+    const child = spawn(process.execPath, [
+        entrypoint,
+        ...(manifest ? ["--manifest", manifest] : []),
+        ...(adapterModules === undefined ? [] : ["--adapters-from-ipc"])
+    ], {
+        argv0: "octo-runtime-executor-kernel",
+        env,
+        stdio: ["pipe", "pipe", "pipe", "ipc"],
+        detached: process.platform !== "win32"
+    });
+    const cleanup = createProcessCleanup(child, {
+        processGroup: process.platform !== "win32",
+        processTree: true
+    });
+    let stderr = "";
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (value) => {
+        // Keep only the tail so a chatty child cannot grow this buffer unbounded.
+        stderr = (stderr + value.toString()).slice(-8192);
+    });
+    const client = new WorkerRpcClient({
+        input: child.stdout,
+        output: child.stdin
+    });
+    // S05：spawn error 必须在 readiness 阶段归属本次启动，不能终止宿主。
+    // .octospec/tasks/pr1-yujiawei-review/assessment.md
+    child.on("error", (error) => client.close(error));
+    let adapters;
+    try {
+        // 先登记进程所有权；快照发送也可能因子进程未读取 IPC 而阻塞，须纳入就绪预算。
+        await onSpawn?.(child);
+        const initialize = async () => {
+            if (adapterModules !== undefined)
+                await new Promise((resolve, reject) => {
+                    child.send({ type: "kernel.adapters", adapters: adapterModules }, (error) => error ? reject(error) : resolve());
+                });
+            return client.list();
+        };
+        adapters = await waitForReady(initialize(), readyTimeoutMs, signal);
+    }
+    catch (error) {
+        client.close(error instanceof Error ? error : new Error(errorMessage(error)));
+        try {
+            await cleanup();
+        }
+        catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], `${errorMessage(error)}${stderr ? `: ${stderr}` : ""}; cleanup: ${errorMessage(cleanupError)}`, { cause: cleanupError });
+        }
+        throw new Error(`${errorMessage(error)}${stderr ? `: ${stderr}` : ""}`, { cause: error });
+    }
+    let closing;
+    const worker = {
+        client,
+        child,
+        adapters,
+        // 关闭 RPC 后等待正常收尾与平台清理；POSIX 不以 leader exit 结束进程组回收。
+        // Windows 排空后须保留 leader 到 taskkill；宽限内提前退出不能当作树已清空。
+        close() {
+            if (closing)
+                return closing;
+            const { until = Date.now() + 5000, immediate = false } = closeOptions.get(worker) ?? {};
+            client.close();
+            // Windows 的 kill(SIGTERM) 是强制终止；先用 EOF 触发现有子进程收尾。
+            // S02：POSIX 仍回收整个所属进程组，不能只因 leader 退出而跳过 cleanup。
+            return (closing = (async () => {
+                const drained = process.platform === "win32" && !immediate
+                    ? await endWindowsWorkerInput(child, until)
+                    : undefined;
+                try {
+                    // 启动回滚与 POSIX 保留共享清理；Windows 正常关闭须验证本次 taskkill 的结果。
+                    // leader 在通知后退出时，不能再用它的退出状态掩盖 taskkill 未能找到树的错误。
+                    if (process.platform === "win32" && drained !== "skipped")
+                        await cleanupWindowsWorker(child, until);
+                    else
+                        await cleanup();
+                    // Reaping the OS tree does not erase an observed Adapter cleanup failure.
+                    if (drained === "incomplete")
+                        throw Object.assign(new Error("EXECUTOR_CLEANUP_INCOMPLETE"), {
+                            code: "EXECUTOR_CLEANUP_INCOMPLETE"
+                        });
+                }
+                finally {
+                    if (process.platform === "win32") {
+                        // 正常收尾或 fallback 结束后释放本层管道；回收失败仍向调用方传播。
+                        child.stdin.destroy();
+                        child.stdout.destroy();
+                        child.stderr.destroy();
+                    }
+                }
+            })());
+        },
+        stderr: () => stderr
+    };
+    return worker;
+}
+/** 只回收本次 worker 的树。命令和退出确认共用截止时间，任何命令错误都保留为回收失败。 */
+async function cleanupWindowsWorker(child, until) {
+    const incomplete = (cause) => Object.assign(new Error("PROCESS_TREE_CLEANUP_INCOMPLETE", { cause }), {
+        code: "PROCESS_TREE_CLEANUP_INCOMPLETE"
+    });
+    if (child.pid === undefined || child.exitCode !== null || child.signalCode !== null)
+        throw incomplete();
+    const remaining = until - Date.now();
+    if (remaining <= 0)
+        throw incomplete();
+    await new Promise((resolve, reject) => {
+        execFile("taskkill", ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true, timeout: remaining }, (error) => (error ? reject(incomplete(error)) : resolve()));
+    });
+    const confirmUntil = Math.min(until, Date.now() + 200);
+    while (child.exitCode === null && child.signalCode === null) {
+        const left = confirmUntil - Date.now();
+        if (left <= 0)
+            throw Object.assign(new Error("PROCESS_CLEANUP_TIMEOUT"), {
+                code: "PROCESS_CLEANUP_TIMEOUT"
+            });
+        await delay(Math.min(10, left));
+    }
+}
+/** 私有正常关闭阶段：EOF 触发排空，IPC 只确认排空结果，实际进程树仍由 cleanup 回收。 */
+function endWindowsWorkerInput(child, until) {
+    if (child.exitCode !== null || child.signalCode !== null || child.stdin.destroyed)
+        return Promise.resolve("skipped");
+    return new Promise((resolve) => {
+        const graceUntil = Math.min(Date.now() + WINDOWS_CLOSE_GRACE_MS, until - WINDOWS_COOPERATIVE_CLEANUP_RESERVE_MS);
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.off("close", fallback);
+            child.off("error", fallback);
+            child.stdin.off("error", fallback);
+            child.off("message", onMessage);
+            resolve(result);
+        };
+        const fallback = () => finish("fallback");
+        const onMessage = (message) => {
+            if (!message || typeof message !== "object" || !("type" in message))
+                return;
+            if (message.type === "worker.stopping") {
+                // This is progress, not cleanup success. Repeated messages never extend the deadline.
+                clearTimeout(timer);
+                timer = setTimeout(fallback, Math.max(0, graceUntil - Date.now()));
+                return;
+            }
+            if (message.type === "worker.drained" &&
+                "cleanup" in message &&
+                (message.cleanup === "complete" || message.cleanup === "incomplete"))
+                finish(message.cleanup);
+        };
+        let timer = setTimeout(fallback, Math.max(0, Math.min(graceUntil, until - WINDOWS_TREE_CLEANUP_RESERVE_MS) - Date.now()));
+        // 先监听再发送 EOF；worker 排空后仍存活，输出在通知/超时前持续消费。
+        child.once("close", fallback);
+        child.once("error", fallback);
+        child.stdin.once("error", fallback);
+        child.on("message", onMessage);
+        try {
+            child.stdin.end();
+        }
+        catch {
+            // EPIPE 等故障不新增公开错误合同；真正的回收失败仍由 cleanup 抛出。
+            fallback();
+        }
+    });
+}
+function waitForReady(operation, timeoutMs, signal) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            callback();
+        };
+        const onAbort = () => finish(() => reject(new Error("adapter-host spawn cancelled")));
+        const timer = setTimeout(() => finish(() => reject(new Error(`adapter-host readiness timed out after ${timeoutMs}ms`))), timeoutMs);
+        signal?.addEventListener("abort", onAbort, { once: true });
+        operation.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error instanceof Error ? error : new Error(errorMessage(error)))));
+        // 即使 onSpawn 期间已取消，也必须观察已创建的 RPC，避免回滚触发未处理拒绝。
+        if (signal?.aborted)
+            onAbort();
+    });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/node_modules/@mininglamp-oss/{octo-runtime-adapter-host → octo-runtime-executor-kernel}/dist/rpc.d.ts

@@ -1,12 +1,12 @@
 import type { Readable, Writable } from "node:stream";
 import { type RuntimeLog, type AdapterProbeOptions } from "@mininglamp-oss/octo-runtime-adapter-sdk";
 import { type InputFrames, type InvokeInput, type InvokeEnvironment, type InputInvoke, type HostFrame, type NativeInteractionResponse, type InteractionResponse } from "@mininglamp-oss/octo-runtime-protocol";
-import type { AdapterHost, HostedAdapterMetadata } from "./index.js";
+import type { AgentExecutor, HostedAdapterMetadata } from "@mininglamp-oss/octo-runtime-executor-core";
 type JsonRecord = Record<string, unknown>;
 export type RpcTraceDirection = "send" | "receive";
 export type RpcTrace = (direction: RpcTraceDirection, frame: string) => void;
-/** Stable client contract used by daemon-owned host lifecycle wrappers. */
-export interface AdapterHostRpc {
+/** Kernel 到 worker 的内部执行合同；取消回执 cancelled 由外层 RPC 映射为 accepted，均不表示终态。 */
+export interface WorkerRpc {
     list(configurations?: Record<string, AdapterProbeOptions>): Promise<HostedAdapterMetadata[]>;
     probe(adapterType: string, options?: AdapterProbeOptions): Promise<unknown>;
     cancel(invocationId: string, reason?: string): Promise<{
@@ -18,14 +18,13 @@ export interface AdapterHostRpc {
     invokeFrames: InputFrames;
 }
 /**
- * Expose an AdapterHost as a line-delimited JSON-RPC 2.0 service.
- * Ordinary methods use request/response; a long-running invoke uses an ACK plus
- * a notification event stream.
+ * 在 worker 中将唯一 AgentExecutor 暴露为 stdio NDJSON JSON-RPC 服务。
+ * 普通方法是一问一答；invoke 先返回接纳凭据，再发送通知流，不与 Kernel 对外 socket 协议混用。
  */
-export declare class AdapterHostRpcServer {
+export declare class WorkerRpcServer {
     #private;
     constructor({ host, output, trace, log }: {
-        host: AdapterHost;
+        host: AgentExecutor;
         output: Writable;
         trace?: RpcTrace;
         log?: RuntimeLog;
@@ -33,8 +32,11 @@ export declare class AdapterHostRpcServer {
     /** Start consuming the input stream; each line must be one complete JSON-RPC object. */
     listen(input: Readable): void;
 }
-/** The async client for AdapterHostRpcServer; it also reassembles invoke notifications back into an AsyncGenerator. */
-export declare class AdapterHostRpcClient implements AdapterHostRpc {
+/**
+ * Kernel 持有的 worker RPC 客户端，将按身份校验的通知还原为有界异步流。
+ * 这里只管理逻辑请求与流；进程存活、心跳和回收由 WorkerSupervisor/WorkerProcess 负责。
+ */
+export declare class WorkerRpcClient implements WorkerRpc {
     #private;
     readonly invoke: InputInvoke;
     constructor({ input, output, trace, maximumInputBytes }: {
@@ -45,7 +47,7 @@ export declare class AdapterHostRpcClient implements AdapterHostRpc {
     });
     /** Send an ordinary JSON-RPC request and await the matching response by random ID. */
     request<T = unknown>(method: string, params?: JsonRecord, signal?: AbortSignal): Promise<T>;
-    /** Close the logical connection and end every pending request/invocation with the same error. */
+    /** 用同一故障结束所有逻辑请求/流；不终止进程，owner 仍须调用 WorkerProcess.close。 */
     close(error?: Error): void;
     list(configurations?: Record<string, AdapterProbeOptions>): Promise<HostedAdapterMetadata[]>;
     probe(adapterType: string, options?: AdapterProbeOptions): Promise<unknown>;

package/node_modules/@mininglamp-oss/{octo-runtime-adapter-host → octo-runtime-executor-kernel}/dist/rpc.js

@@ -95,11 +95,10 @@ function writer(output, trace, onError) {
     };
 }
 /**
- * Expose an AdapterHost as a line-delimited JSON-RPC 2.0 service.
- * Ordinary methods use request/response; a long-running invoke uses an ACK plus
- * a notification event stream.
+ * 在 worker 中将唯一 AgentExecutor 暴露为 stdio NDJSON JSON-RPC 服务。
+ * 普通方法是一问一答；invoke 先返回接纳凭据，再发送通知流，不与 Kernel 对外 socket 协议混用。
  */
-export class AdapterHostRpcServer {
+export class WorkerRpcServer {
     #log;
     #controllers = new Map();
     #host;
@@ -329,7 +328,16 @@ export class AdapterHostRpcServer {
         for (const controller of this.#controllers.values())
             controller.abort(error);
         this.#controllers.clear();
-        void this.#host.shutdown(error.message).catch(() => undefined);
+        void this.#host
+            .shutdown(error.message)
+            .then((result) => {
+            if (result.cleanup === "incomplete")
+                this.#log("error", "rpc.cleanup_incomplete", {
+                    code: "EXECUTOR_CLEANUP_INCOMPLETE",
+                    unresolved_count: result.unresolvedInvocationIds.length
+                });
+        })
+            .catch(() => undefined);
     }
     #waitForDrain() {
         return new Promise((resolve, reject) => {
@@ -355,8 +363,11 @@ export class AdapterHostRpcServer {
         });
     }
 }
-/** The async client for AdapterHostRpcServer; it also reassembles invoke notifications back into an AsyncGenerator. */
-export class AdapterHostRpcClient {
+/**
+ * Kernel 持有的 worker RPC 客户端，将按身份校验的通知还原为有界异步流。
+ * 这里只管理逻辑请求与流；进程存活、心跳和回收由 WorkerSupervisor/WorkerProcess 负责。
+ */
+export class WorkerRpcClient {
     invoke = createInputInvoke((input, environment) => this.invokeFrames(input, environment));
     #send;
     #pending = new Map();
@@ -470,7 +481,7 @@ export class AdapterHostRpcClient {
         this.#send(message);
         return promise;
     }
-    /** Close the logical connection and end every pending request/invocation with the same error. */
+    /** 用同一故障结束所有逻辑请求/流；不终止进程，owner 仍须调用 WorkerProcess.close。 */
     close(error = new Error("adapter-host client closed")) {
         if (this.#closedError)
             return;

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/runner.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// 通用清单 worker 不包含产品准备逻辑；SDK 自有 worker 原生 import 后直接调用 serveWorker。
+import { loadManifestAdapters } from "./manifest-adapters.js";
+import { serveWorker } from "./index.js";
+serveWorker(await loadManifestAdapters());

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/serve.d.ts

@@ -0,0 +1,10 @@
+import { type HostedAdapter } from "@mininglamp-oss/octo-runtime-executor-core";
+import { type RuntimeLoggingOptions } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+/**
+ * 在当前独立 worker 子进程中提供 Core 执行服务。调用方已经决定加载集合：
+ * CLI 可从自己的 JSON 动态加载，SDK 可直接 import；这里不扫描或补齐任何 Adapter。
+ * 该函数只在 worker 入口调用；宿主 App 和 Kernel 监督进程通过客户端接入，不直接调用。
+ */
+export declare function serveWorker(adapters: readonly HostedAdapter[], options?: {
+    logging?: RuntimeLoggingOptions;
+}): void;

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/serve.js

@@ -0,0 +1,89 @@
+import { AgentExecutor } from "@mininglamp-oss/octo-runtime-executor-core";
+import { WorkerRpcServer } from "./rpc.js";
+import { RuntimeLogging } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+/**
+ * 在当前独立 worker 子进程中提供 Core 执行服务。调用方已经决定加载集合：
+ * CLI 可从自己的 JSON 动态加载，SDK 可直接 import；这里不扫描或补齐任何 Adapter。
+ * 该函数只在 worker 入口调用；宿主 App 和 Kernel 监督进程通过客户端接入，不直接调用。
+ */
+export function serveWorker(adapters, options = {}) {
+    const logging = new RuntimeLogging(options.logging ??
+        (process.env.OCTO_RUNTIME_LOGS_DIRECTORY
+            ? { directory: process.env.OCTO_RUNTIME_LOGS_DIRECTORY }
+            : undefined));
+    process.on("uncaughtExceptionMonitor", () => logging.kernel("error", "host.uncaught", { code: "HOST_UNCAUGHT_EXCEPTION" }));
+    const host = new AgentExecutor({ log: logging.kernel });
+    for (const adapter of adapters) {
+        // 注册阶段保留协议校验和重复类型检查，失败时不建立就绪的 RPC 服务。
+        host.register(adapter);
+        logging.kernel("info", "adapter.registered", { adapter_type: adapter.metadata.type });
+    }
+    // 仅服务已注册集合；Kernel 监督器通过首次 list 握手确认 worker 就绪。
+    // 注册不代表 Provider 已安装或认证，实际可用性由 probe 和调用结果说明。
+    new WorkerRpcServer({
+        host,
+        output: process.stdout,
+        log: logging.kernel
+    }).listen(process.stdin);
+    logging.kernel("info", "host.ready");
+    // 父 Kernel 断开或停止时等待 Core 取消和清理；需要替换时由 Kernel 监督器重启相同入口。
+    let stopping = false;
+    let drainedExitCode;
+    const stop = (holdForParent = false) => {
+        if (stopping)
+            return;
+        stopping = true;
+        // Let the launcher reserve the full bounded drain only for a worker that handles EOF.
+        if (holdForParent && process.connected)
+            process.send?.({ type: "worker.stopping" }, () => { });
+        const finish = async (code) => {
+            await logging.close();
+            drainedExitCode = code;
+            if (holdForParent && process.connected) {
+                // Windows 的树清理需要 leader 仍存活。通知只表示排空完成，不代表后代已回收。
+                // IPC 保持引用直到 launcher 执行 taskkill；owner 断连仍走下方既有退出收尾。
+                process.channel?.ref();
+                process.send?.({ type: "worker.drained", cleanup: code === 0 ? "complete" : "incomplete" }, (error) => {
+                    if (error)
+                        process.exit(code || 1);
+                });
+            }
+            else
+                process.exit(code);
+        };
+        void host.shutdown().then(async (result) => {
+            if (result.cleanup === "incomplete") {
+                logging.kernel("error", "host.cleanup_incomplete", {
+                    code: "EXECUTOR_CLEANUP_INCOMPLETE",
+                    unresolved_count: result.unresolvedInvocationIds.length
+                });
+            }
+            await finish(result.cleanup === "complete" ? 0 : 1);
+        }, async () => {
+            await finish(1);
+        });
+    };
+    process.once("SIGINT", () => stop());
+    process.once("SIGTERM", () => stop());
+    process.once("SIGHUP", () => stop());
+    process.stdin.once("end", () => stop(process.platform === "win32"));
+    process.stdin.once("close", () => stop(process.platform === "win32"));
+    // 心跳必须由执行进程主事件循环处理；独立线程应答会掩盖执行线程阻塞。
+    process.on("message", (message) => {
+        if (message &&
+            typeof message === "object" &&
+            "type" in message &&
+            message.type === "kernel.ping" &&
+            "probe" in message &&
+            Number.isSafeInteger(message.probe) &&
+            process.connected) {
+            process.send?.({ type: "worker.pong", probe: message.probe });
+        }
+    });
+    process.once("disconnect", () => {
+        if (drainedExitCode !== undefined)
+            process.exit(drainedExitCode);
+        else
+            stop();
+    });
+}

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/server.d.ts

@@ -0,0 +1,22 @@
+import { type AdapterProbeOptions } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import { type AdapterModuleEntry } from "@mininglamp-oss/octo-runtime-adapter-sdk/module-manifest";
+import { type KernelStatus } from "./types.js";
+export interface KernelServerOptions {
+    endpoint: string;
+    workerEntrypoint: string;
+    manifest?: string;
+    /** CLI 装配快照；SDK 原生 worker 无需清单或此字段。 */
+    adapterModules?: AdapterModuleEntry[];
+    env?: NodeJS.ProcessEnv;
+    adapterConfigurations?: Record<string, AdapterProbeOptions>;
+    stateDirectory?: string;
+    configurations?: (runtimeId?: string) => Record<string, AdapterProbeOptions>;
+}
+/**
+ * 创建独立 Kernel 的本地 RPC 端点，独占端点租约、Run 事件源与 worker 监督器。
+ * 启动失败也执行回收；close 失败会保留所有权证据，客户端断开不等同于 owner 关闭。
+ */
+export declare function startKernelServer(options: KernelServerOptions, signal?: AbortSignal): Promise<{
+    status: () => KernelStatus;
+    close(until?: number): Promise<void>;
+}>;