@mininglamp-oss/octo-runtime 1.1.0 → 1.1.1

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

@@ -110,6 +110,7 @@ export async function reapOrphanedInvocationManifest(path) {
     await rm(path, { force: true });
     return { found: true, reaped: true, pid: host.pid };
 }
+/** 查询系统启动时间以区分 PID 复用；失败时不返回可用于回收的身份，绝不以 PID 本身兜底。 */
 export async function processStartIdentity(pid) {
     if (!Number.isSafeInteger(pid) || pid < 1)
         return undefined;
@@ -141,7 +142,9 @@ export async function processStartIdentity(pid) {
                 "-NoProfile",
                 "-NonInteractive",
                 "-Command",
-                `(Get-Process -Id ${pid} -ErrorAction Stop).StartTime.ToUniversalTime().Ticks`
+                // 直接调用系统进程对象，避免 Get-Process 的命令发现/模块自动加载占用身份查询预算。
+                // 保持 UTC ticks 身份格式；不增加超时，也不缓存可能已经复用的 PID。
+                `$PSModuleAutoLoadingPreference='None'; $target=[System.Diagnostics.Process]::GetProcessById(${pid}); try { [Console]::Out.Write($target.StartTime.ToUniversalTime().Ticks.ToString([Globalization.CultureInfo]::InvariantCulture)) } finally { $target.Dispose() }`
             ], { encoding: "utf8", timeout: 10_000, windowsHide: true }, (error, stdout) => {
                 const value = stdout.trim();
                 resolve(error || !/^\d+$/.test(value) ? undefined : `windows:${value}`);

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

@@ -0,0 +1,6 @@
+import type { HostedAdapter } from "./index.js";
+/**
+ * 仅供清单驱动的 worker 在自身进程装配：只实例化所选模块，返回后由入口注册及 serveWorker。
+ * CLI 可在注册前用实际 metadata 做产品准备；SDK 原生 import 入口不经过此文件加载边界。
+ */
+export declare function loadManifestAdapters(): Promise<HostedAdapter[]>;

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

@@ -1,2 +1 @@
-/** 内部加载边界：按本机路径语义识别文件，避免把 Windows 盘符交给 ESM 当作 URL 协议。 */
-export declare function resolveAdapterModuleSpecifier(module: string, manifestPath: string): string;
+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

@@ -1,9 +1,2 @@
-import { dirname, isAbsolute, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-/** 内部加载边界：按本机路径语义识别文件，避免把 Windows 盘符交给 ESM 当作 URL 协议。 */
-export function resolveAdapterModuleSpecifier(module, manifestPath) {
-    // 相对路径属于 manifest 所在目录；包名及现有 URL 保持 Node 的解析语义。
-    return module.startsWith(".") || isAbsolute(module)
-        ? pathToFileURL(resolve(dirname(manifestPath), module)).href
-        : module;
-}
+// 内部兼容入口，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

@@ -2,14 +2,17 @@ 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;
-    /** Maximum time allowed for the initial RPC readiness handshake. */
+    /** 启动快照发送和首次 RPC 就绪握手共用的最大等待时间。 */
     readyTimeoutMs?: number;
     onSpawn?: (child: ChildProcess) => Promise<void>;
 }
@@ -21,10 +24,12 @@ export interface WorkerProcess {
     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, env, signal, onSpawn, readyTimeoutMs }: SpawnWorkerOptions): Promise<WorkerProcess>;
+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

@@ -1,19 +1,37 @@
 import { createProcessCleanup } from "@mininglamp-oss/octo-runtime-adapter-sdk/process-cleanup";
-import { spawn } from "node:child_process";
+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, env = process.env, signal, onSpawn, readyTimeoutMs = 15_000 }) {
+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");
     }
-    // 跨进程只传程序入口及可选文件路径，不序列化 Adapter 实例或工厂函数。
-    const child = spawn(process.execPath, [entrypoint, ...(manifest ? ["--manifest", manifest] : [])], {
+    // 快照通过已有 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"],
@@ -38,8 +56,16 @@ export async function spawnWorker({ entrypoint, manifest, env = process.env, sig
     child.on("error", (error) => client.close(error));
     let adapters;
     try {
+        // 先登记进程所有权；快照发送也可能因子进程未读取 IPC 而阻塞，须纳入就绪预算。
         await onSpawn?.(child);
-        adapters = await waitForReady(client.list(), readyTimeoutMs, signal);
+        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)));
@@ -51,18 +77,121 @@ export async function spawnWorker({ entrypoint, manifest, env = process.env, sig
         }
         throw new Error(`${errorMessage(error)}${stderr ? `: ${stderr}` : ""}`, { cause: error });
     }
-    return {
+    let closing;
+    const worker = {
         client,
         child,
         adapters,
-        // 先断开 RPC，再等待平台清理；POSIX 不以 leader exit 结束进程组回收。
-        // Windows 仅有 Node/taskkill 的常规树清理能力，不能承诺父进程提前退出后的后代已清空。
+        // 关闭 RPC 后等待正常收尾与平台清理；POSIX 不以 leader exit 结束进程组回收。
+        // Windows 排空后须保留 leader 到 taskkill；宽限内提前退出不能当作树已清空。
         close() {
+            if (closing)
+                return closing;
+            const { until = Date.now() + 5000, immediate = false } = closeOptions.get(worker) ?? {};
             client.close();
-            return cleanup();
+            // 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) => {

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

@@ -1,94 +1,5 @@
 #!/usr/bin/env node
-// CLI 使用的独立 worker 入口：只加载显式 manifest 中的 Adapter，注册到唯一 AgentExecutor。
-// 通过 stdio NDJSON 为父 Kernel 提供执行；SDK 可用自有代码入口调用 serveWorker，毋须采用此 manifest。
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import { resolveAdapterModuleSpecifier } from "./module-specifier.js";
+// 通用清单 worker 不包含产品准备逻辑；SDK 自有 worker 原生 import 后直接调用 serveWorker。
+import { loadManifestAdapters } from "./manifest-adapters.js";
 import { serveWorker } from "./index.js";
-const index = process.argv.indexOf("--manifest");
-if (index < 0 || !process.argv[index + 1])
-    throw new Error("usage: octo-runtime-executor-kernel --manifest <file>");
-const manifestPath = resolve(process.argv[index + 1]);
-const rawManifest = JSON.parse(await readFile(manifestPath, "utf8"));
-const manifest = parseManifest(rawManifest);
-const adapters = [];
-for (const entry of manifest.adapters) {
-    const specifier = resolveAdapterModuleSpecifier(entry.module, manifestPath);
-    const loaded = await import(specifier);
-    const moduleExports = asRecord(loaded, `adapter module ${entry.module}`);
-    const exported = moduleExports[entry.exportName];
-    if (exported === undefined) {
-        throw new Error(`missing export ${entry.exportName} from ${entry.module}`);
-    }
-    // The manifest is a dynamic plugin boundary: validate the factory and adapter
-    // shape before handing the instance to the host for registration.
-    const instance = entry.factory ? callFactory(exported, entry.options, entry) : exported;
-    if (!isHostedAdapter(instance)) {
-        throw new TypeError(`${entry.module}#${entry.exportName} 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);
-}
-// JSON 是 CLI 的装配来源；注册、RPC 和退出清理与 SDK 的代码入口共用。
-serveWorker(adapters);
-/** Parse and validate the on-disk manifest. Only version 1 is supported; each
- * entry names a module, an export, whether that export is a factory, and options. */
-function parseManifest(value) {
-    const record = asRecord(value, "adapter manifest");
-    if (record.version !== 1)
-        throw new TypeError("adapter manifest.version must be 1");
-    if (!Array.isArray(record.adapters))
-        throw new TypeError("adapter manifest.adapters must be an array");
-    return {
-        version: 1,
-        adapters: record.adapters.map((item, position) => {
-            const entry = asRecord(item, `adapter manifest entry ${position}`);
-            const type = optionalString(entry.type);
-            return {
-                module: requiredString(entry.module, `adapters[${position}].module`),
-                exportName: optionalString(entry.export) ?? "default",
-                factory: entry.factory === true,
-                options: entry.options === undefined
-                    ? {}
-                    : asRecord(entry.options, `adapters[${position}].options`),
-                ...(type ? { type } : {})
-            };
-        })
-    };
-}
-function callFactory(value, options, entry) {
-    if (typeof value !== "function") {
-        throw new TypeError(`${entry.module}#${entry.exportName} is marked as a factory but is not callable`);
-    }
-    const factory = value;
-    return factory(options);
-}
-/** Structural type guard: only `metadata.type`, Agent sources and
- * an `invoke` method are required, so any conforming object can be a hosted adapter. */
-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, name) {
-    if (!isRecord(value))
-        throw new TypeError(`${name} must be an object`);
-    return value;
-}
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function requiredString(value, name) {
-    if (typeof value !== "string" || value.length === 0)
-        throw new TypeError(`${name} must be a non-empty string`);
-    return value;
-}
-function optionalString(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
+serveWorker(await loadManifestAdapters());

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

@@ -28,10 +28,29 @@ export function serveWorker(adapters, options = {}) {
     logging.kernel("info", "host.ready");
     // 父 Kernel 断开或停止时等待 Core 取消和清理；需要替换时由 Kernel 监督器重启相同入口。
     let stopping = false;
-    const stop = () => {
+    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", {
@@ -39,27 +58,32 @@ export function serveWorker(adapters, options = {}) {
                     unresolved_count: result.unresolvedInvocationIds.length
                 });
             }
-            await logging.close();
-            process.exit(result.cleanup === "complete" ? 0 : 1);
+            await finish(result.cleanup === "complete" ? 0 : 1);
         }, async () => {
-            await logging.close();
-            process.exit(1);
+            await finish(1);
         });
     };
-    process.once("SIGINT", stop);
-    process.once("SIGTERM", stop);
-    process.once("SIGHUP", stop);
-    process.stdin.once("end", stop);
-    process.stdin.once("close", stop);
+    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" });
+            process.send?.({ type: "worker.pong", probe: message.probe });
         }
     });
-    process.once("disconnect", stop);
+    process.once("disconnect", () => {
+        if (drainedExitCode !== undefined)
+            process.exit(drainedExitCode);
+        else
+            stop();
+    });
 }

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

@@ -1,9 +1,12 @@
 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;
@@ -15,5 +18,5 @@ export interface KernelServerOptions {
  */
 export declare function startKernelServer(options: KernelServerOptions, signal?: AbortSignal): Promise<{
     status: () => KernelStatus;
-    close(): Promise<void>;
+    close(until?: number): Promise<void>;
 }>;

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

@@ -8,6 +8,7 @@ import { HostRunService } from "./host-run-service.js";
 import { WorkerSupervisor } from "./supervisor.js";
 import { acquireEndpoint } from "./endpoint.js";
 import { InvocationManifest } from "./invocation-manifest.js";
+import { readModuleManifest, resolveAdapterModules } from "@mininglamp-oss/octo-runtime-adapter-sdk/module-manifest";
 import { KernelError } from "./types.js";
 function validateParams(method, params) {
     const fields = {
@@ -71,9 +72,15 @@ function validateParams(method, params) {
  * 启动失败也执行回收；close 失败会保留所有权证据，客户端断开不等同于 owner 关闭。
  */
 export async function startKernelServer(options, signal) {
+    if (options.manifest && options.adapterModules !== undefined)
+        throw new TypeError("manifest and adapterModules are mutually exclusive");
+    // 文件仅在服务启动时读取一次；worker 自动恢复沿用快照，不因磁盘改动改变加载集合。
+    const adapterModules = options.manifest
+        ? resolveAdapterModules(await readModuleManifest(options.manifest, { legacy: true }))
+        : options.adapterModules;
     const instance = randomUUID();
     let manifest;
-    const worker = new WorkerSupervisor({ entrypoint: options.workerEntrypoint, manifest: options.manifest, env: options.env }, (pid) => manifest?.setWorker(pid, options.workerEntrypoint) ?? Promise.resolve());
+    const worker = new WorkerSupervisor({ entrypoint: options.workerEntrypoint, adapterModules, env: options.env }, (pid) => manifest?.setWorker(pid, options.workerEntrypoint) ?? Promise.resolve());
     const configure = (input) => {
         const type = contextItem(input.contexts, "octo.execution", "adapter")?.payload.type;
         return (options.configurations?.(typeof input.runMetadata?.runtimeId === "string" ? input.runMetadata.runtimeId : undefined) ?? options.adapterConfigurations)?.[typeof type === "string" ? type : "codex"];
@@ -312,7 +319,7 @@ export async function startKernelServer(options, signal) {
             }
         });
     });
-    const teardown = async () => {
+    const teardown = async (until = Date.now() + 5000) => {
         runs.beginDrain();
         for (const socket of sockets)
             socket.destroy();
@@ -330,9 +337,10 @@ export async function startKernelServer(options, signal) {
         if (listening)
             await attempt(() => new Promise((resolve) => server.close(() => resolve())));
         // 先终止 worker 才能让失联的源流结束，再清空 Run 缓存；每个资源仍独立尝试回收并汇总失败。
-        const workerStopped = await attempt(() => worker.close());
+        // 内部沿用服务截止时间，为清单和端点收尾预留时间；不重启一份独立关闭预算。
+        const workerStopped = await attempt(() => worker.close(until - 200));
         await attempt(() => runs.close());
-        // 进程未确认回收时保留身份清单和端点租约，禁止新实例覆盖所有权。
+        // An incomplete worker close retains ownership, including an observed executor cleanup failure.
         if (workerStopped) {
             await attempt(() => manifest?.close() ?? Promise.resolve());
             if (listening && process.platform !== "win32")
@@ -385,8 +393,8 @@ export async function startKernelServer(options, signal) {
     }
     return {
         status,
-        close() {
-            return (closing ??= teardown());
+        close(until) {
+            return (closing ??= teardown(until));
         }
     };
 }

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

@@ -5,6 +5,7 @@ import { beforeDeadline, ServiceInitializationError } from "./lifecycle.js";
 export function createKernelService(options) {
     const configuration = {
         ...options,
+        adapterModules: options.adapterModules && structuredClone(options.adapterModules),
         adapterConfigurations: options.adapterConfigurations && structuredClone(options.adapterConfigurations),
         env: options.env && { ...options.env }
     };
@@ -33,7 +34,7 @@ export function createKernelService(options) {
                 await beforeDeadline(starting?.catch(() => undefined) ?? Promise.resolve(), until);
                 if (startupFailure instanceof AggregateError)
                     throw startupFailure;
-                await beforeDeadline(server?.close() ?? Promise.resolve(), until);
+                await beforeDeadline(server?.close(until) ?? Promise.resolve(), until);
             }
             catch {
                 errors.push({ resource: "kernel", code: "KERNEL_CLEANUP_INCOMPLETE" });

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

@@ -1,6 +1,6 @@
 import { type SpawnWorkerOptions } from "./process.js";
 import type { KernelStatus } from "./types.js";
-/** Kernel 独占 worker 的创建与回收；清理失败时禁止启动替代实例。 */
+/** Kernel exclusively owns worker replacement; incomplete cleanup prevents a second owner. */
 export declare class WorkerSupervisor {
     #private;
     private readonly options;
@@ -9,5 +9,5 @@ export declare class WorkerSupervisor {
     get status(): KernelStatus["worker"];
     get client(): import("./rpc.js").WorkerRpcClient;
     start(signal?: AbortSignal): Promise<void>;
-    close(): Promise<void>;
+    close(until?: number): Promise<void>;
 }