@mininglamp-oss/octo-runtime 1.0.0 → 1.1.0

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

@@ -1,4 +1,4 @@
-import type { AdapterHostRpc } from "./rpc.js";
+import type { WorkerRpc } from "./rpc.js";
 import { type HostFrame, type HostRunReceipt, type InvokeInput, type InvokeEnvironment, type NativeInteractionResponse, type InteractionResponse } from "@mininglamp-oss/octo-runtime-protocol";
 export interface SourceEvent {
     seq: number;
@@ -6,37 +6,44 @@ export interface SourceEvent {
     bytes: number;
     at: number;
 }
-/** One process-local event authority around the existing adapter-host IPC client. */
-export declare class HostRunService implements AdapterHostRpc {
+/**
+ * Kernel 内唯一的 Run 事件源：从 worker 消费一次，按原 stream/seq 有界缓存供多个订阅观察。
+ * 接纳、执行与观察分离；订阅退出不取消源执行，缓存过期只报告缺口，不重跑 Provider。
+ */
+export declare class HostRunService implements WorkerRpc {
     #private;
-    readonly transport: AdapterHostRpc;
+    readonly transport: WorkerRpc;
+    private readonly resolveStreamLimits?;
     readonly invoke: import("@mininglamp-oss/octo-runtime-protocol").InputInvoke;
-    constructor(transport: AdapterHostRpc);
+    constructor(transport: WorkerRpc, resolveStreamLimits?: ((input: InvokeInput) => InvokeEnvironment["streamLimits"]) | undefined);
     get status(): {
         draining: boolean;
         activeRuns: number;
         admittingRuns: number;
     };
-    list(...args: Parameters<AdapterHostRpc["list"]>): ReturnType<AdapterHostRpc["list"]>;
-    probe(...args: Parameters<AdapterHostRpc["probe"]>): Promise<unknown>;
-    cancel(invocationId: string, reason?: string): ReturnType<AdapterHostRpc["cancel"]>;
+    list(...args: Parameters<WorkerRpc["list"]>): ReturnType<WorkerRpc["list"]>;
+    probe(...args: Parameters<WorkerRpc["probe"]>): Promise<unknown>;
+    cancel(invocationId: string, reason?: string): ReturnType<WorkerRpc["cancel"]>;
     respondInteraction(invocationId: string, response: InteractionResponse): Promise<void>;
     respondNative(invocationId: string, response: NativeInteractionResponse): Promise<void>;
     invokeFrames(input: InvokeInput, environment?: InvokeEnvironment): AsyncGenerator<HostFrame>;
+    /** 返回接纳凭据后仍在后台驱动源流；调用方无需保持原请求连接才能让执行继续。 */
     submit(input: InvokeInput, environment?: InvokeEnvironment): Promise<HostRunReceipt>;
     get(runId: string): HostRunReceipt & {
         oldest_seq: number;
         latest_seq: number;
         terminal?: HostFrame;
     };
+    /** 读取同一流的游标后事件；缺失历史必须报 STREAM_GAP，禁止拼接成看似完整的新流。 */
     read(runId: string, streamId: string | undefined, after: number): ReturnType<HostRunService["get"]> & {
         events: SourceEvent[];
     };
-    cancelRun(runId: string, reason?: string): ReturnType<AdapterHostRpc["cancel"]>;
+    cancelRun(runId: string, reason?: string): ReturnType<WorkerRpc["cancel"]>;
     respond(runId: string, response: InteractionResponse): Promise<void>;
     respondNativeRun(runId: string, response: NativeInteractionResponse): Promise<void>;
     acquireSubscription(): () => void;
     beginDrain(): void;
+    /** 仅停止接纳并等待在途流结束，不主动取消；超时抛错，由 owner 决定后续强制回收。 */
     drain(timeoutMs: number): Promise<{
         drained: boolean;
     }>;

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

@@ -1,8 +1,12 @@
-import { createInputInvoke, assertInvokeRequestSize, identifyInvokeInput, assertHostFrameIdentity, isHostTerminal } from "@mininglamp-oss/octo-runtime-protocol";
-const TTL = 120_000, MAX_RUN_BYTES = 4 << 20, MAX_BYTES = 64 << 20, MAX_EVENTS = 4096;
-/** One process-local event authority around the existing adapter-host IPC client. */
+import { createInputInvoke, assertInvokeRequestSize, identifyInvokeInput, assertHostFrameIdentity, isHostTerminal, isStreamCapacityReason, resolveStreamLimitPolicy, streamCapacityError } from "@mininglamp-oss/octo-runtime-protocol";
+const TTL = 120_000;
+/**
+ * Kernel 内唯一的 Run 事件源：从 worker 消费一次，按原 stream/seq 有界缓存供多个订阅观察。
+ * 接纳、执行与观察分离；订阅退出不取消源执行，缓存过期只报告缺口，不重跑 Provider。
+ */
 export class HostRunService {
     transport;
+    resolveStreamLimits;
     invoke = createInputInvoke((input, environment) => this.invokeFrames(input, environment));
     #runs = new Map();
     #bytes = 0;
@@ -11,8 +15,9 @@ export class HostRunService {
     #tasks = new Set();
     #starting = new Set();
     #cleanup;
-    constructor(transport) {
+    constructor(transport, resolveStreamLimits) {
         this.transport = transport;
+        this.resolveStreamLimits = resolveStreamLimits;
         this.#cleanup = setInterval(() => this.#prune(), 10_000);
         this.#cleanup.unref();
     }
@@ -39,15 +44,17 @@ export class HostRunService {
         return this.transport.respondNative(invocationId, response);
     }
     async #begin(input, environment) {
-        assertInvokeRequestSize(input, environment);
+        const streamLimits = resolveStreamLimitPolicy(this.resolveStreamLimits ? this.resolveStreamLimits(input) : environment.streamLimits);
+        const frozenEnvironment = { ...environment, streamLimits };
+        assertInvokeRequestSize(input, frozenEnvironment);
         this.#prune();
         if (this.#draining)
-            throw new Error("DAEMON_DRAINING");
+            throw new Error("KERNEL_DRAINING");
         if (this.#runs.has(input.runId) || this.#starting.has(input.runId))
             throw new Error("RUN_ALREADY_ACCEPTED");
         if (this.#runs.size + this.#starting.size >= 128)
             throw new Error("RUN_CAPACITY_EXHAUSTED");
-        const source = this.transport.invokeFrames(input, environment);
+        const source = this.transport.invokeFrames(input, frozenEnvironment);
         this.#starting.add(input.runId);
         let first;
         try {
@@ -86,7 +93,8 @@ export class HostRunService {
             next: 1,
             bytes: 0,
             updated: Date.now(),
-            events: []
+            events: [],
+            streamLimits
         };
         this.#runs.set(input.runId, run);
         return run;
@@ -114,7 +122,7 @@ export class HostRunService {
                     kind: "control",
                     control: {
                         type: "error",
-                        code: "HOST_EXECUTION_FAILED",
+                        code: streamErrorCode(error) ?? "HOST_EXECUTION_FAILED",
                         message: "Host execution failed"
                     }
                 });
@@ -143,6 +151,7 @@ export class HostRunService {
             }
         }
     }
+    /** 返回接纳凭据后仍在后台驱动源流；调用方无需保持原请求连接才能让执行继续。 */
     async submit(input, environment = {}) {
         const run = await this.#begin(identifyInvokeInput(input), environment);
         const task = (async () => {
@@ -161,8 +170,12 @@ export class HostRunService {
             throw new Error("STREAM_GAP");
         // Consumers own persistence and presentation filtering; replay retains the complete event.
         const safe = structuredClone(event), bytes = Buffer.byteLength(JSON.stringify(safe));
-        if (bytes > 256 << 10)
-            throw new Error("STREAM_EVENT_TOO_LARGE");
+        if (bytes > run.streamLimits.hostFrameMaxBytes)
+            throw streamCapacityError("HOST_FRAME_TOO_LARGE", {
+                boundary: "host_run.replay_frame",
+                measuredBytes: bytes,
+                limitBytes: run.streamLimits.hostFrameMaxBytes
+            });
         const now = Date.now();
         run.updated = now;
         run.events.push({ seq: run.next++, event: safe, bytes, at: now });
@@ -170,9 +183,12 @@ export class HostRunService {
         this.#bytes += bytes;
         if (isHostTerminal(safe))
             run.terminal = safe;
-        while (run.bytes > MAX_RUN_BYTES || run.events.length > MAX_EVENTS)
+        while (run.bytes > run.streamLimits.replayRunMaxBytes ||
+            run.events.length > run.streamLimits.replayRunMaxItems)
             this.#drop(run);
-        while (this.#bytes > MAX_BYTES) {
+        // A stricter per-adapter override must not evict replay retained for another active adapter.
+        const globalMaxBytes = Math.max(...[...this.#runs.values()].map((value) => value.streamLimits.replayGlobalMaxBytes));
+        while (this.#bytes > globalMaxBytes) {
             const oldest = [...this.#runs.values()]
                 .filter((value) => value.events.length)
                 .sort((a, b) => a.events[0].at - b.events[0].at)[0];
@@ -216,6 +232,7 @@ export class HostRunService {
             ...(run.terminal ? { terminal: structuredClone(run.terminal) } : {})
         };
     }
+    /** 读取同一流的游标后事件；缺失历史必须报 STREAM_GAP，禁止拼接成看似完整的新流。 */
     read(runId, streamId, after) {
         const info = this.get(runId), run = this.#get(runId);
         if (streamId && streamId !== info.stream_id)
@@ -268,6 +285,7 @@ export class HostRunService {
     beginDrain() {
         this.#draining = true;
     }
+    /** 仅停止接纳并等待在途流结束，不主动取消；超时抛错，由 owner 决定后续强制回收。 */
     async drain(timeoutMs) {
         if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 60000)
             throw new Error("DRAIN_TIMEOUT_INVALID");
@@ -291,3 +309,9 @@ export class HostRunService {
         this.#bytes = 0;
     }
 }
+function streamErrorCode(error) {
+    if (!error || typeof error !== "object" || !("code" in error))
+        return undefined;
+    const code = error.code;
+    return isStreamCapacityReason(code) ? code : undefined;
+}

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

@@ -0,0 +1,13 @@
+export { type HostedAdapter, type HostedAdapterMetadata, DEFAULT_RUNTIME_LIMITS, prepareRunContext, type PreparedRunContext, type WorkspaceAssignments } from "@mininglamp-oss/octo-runtime-executor-core";
+export { HostRunService } from "./host-run-service.js";
+export { createKernelService, type KernelService, type KernelServiceOptions, type KernelServiceStatus } from "./service.js";
+export * from "./lifecycle.js";
+export { attachKernel } from "./client.js";
+export * from "./types.js";
+export { InvocationManifest, processStartIdentity, reapOrphanedInvocationManifest } from "./invocation-manifest.js";
+export { readAdapterConfigurations } from "./runtime-configuration.js";
+export { spawnWorker } from "./process.js";
+export { serveWorker } from "./serve.js";
+export type { WorkerProcess, SpawnWorkerOptions } from "./process.js";
+export { WorkerRpcClient, WorkerRpcServer, type WorkerRpc, type RpcTrace, type RpcTraceDirection } from "./rpc.js";
+export { acquireEndpoint } from "./endpoint.js";

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

@@ -0,0 +1,13 @@
+// Kernel 只提供 IPC、Run 观察与 worker 监督；执行逻辑统一委托给 worker 中的 Core。
+export { DEFAULT_RUNTIME_LIMITS, prepareRunContext } from "@mininglamp-oss/octo-runtime-executor-core";
+export { HostRunService } from "./host-run-service.js";
+export { createKernelService } from "./service.js";
+export * from "./lifecycle.js";
+export { attachKernel } from "./client.js";
+export * from "./types.js";
+export { InvocationManifest, processStartIdentity, reapOrphanedInvocationManifest } from "./invocation-manifest.js";
+export { readAdapterConfigurations } from "./runtime-configuration.js";
+export { spawnWorker } from "./process.js";
+export { serveWorker } from "./serve.js";
+export { WorkerRpcClient, WorkerRpcServer } from "./rpc.js";
+export { acquireEndpoint } from "./endpoint.js";

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

@@ -0,0 +1,53 @@
+import { type HostFrame } from "@mininglamp-oss/octo-runtime-protocol";
+import { type KernelInvocationRecord, type KernelInvocationLifecycle, type KernelInvocationDrainResult, type LookupKey, type RunRef, type RunSnapshot } from "./types.js";
+export interface TrackedInvocation {
+    key: LookupKey;
+    ref?: RunRef;
+    instance?: string;
+    submitted: boolean;
+    phase: KernelInvocationRecord["phase"];
+    cancellation: KernelInvocationRecord["cancellation"];
+    lastSeq: number;
+    observationError?: string;
+    reason?: string;
+    cancelTask?: Promise<{
+        accepted: boolean;
+    }>;
+    admitted: Promise<void>;
+    settleAdmission(): void;
+    admissionError?: Error;
+}
+/**
+ * 每个 client 独立保存 invoke 的身份、取消和观察状态；执行与断线恢复由 client.ts 负责。
+ * 最多登记 128 项，不缓存正文；未知结果继续占用额度，不能通过删除记录伪造排空成功。
+ */
+export declare class InvocationRegistry implements KernelInvocationLifecycle {
+    #private;
+    private readonly transport;
+    constructor(transport: {
+        get(key: LookupKey, instance: string, deadline: number, signal: AbortSignal): Promise<RunSnapshot>;
+        cancel(ref: RunRef, reason: string, deadline: number, signal: AbortSignal): Promise<{
+            accepted: boolean;
+        }>;
+    });
+    begin(key: LookupKey): TrackedInvocation;
+    assertSubmission(): void;
+    accepted(record: TrackedInvocation, ref: RunRef, terminal?: HostFrame): void;
+    reconcile(ref: RunRef, terminal?: HostFrame): void;
+    rejected(record: TrackedInvocation, error: unknown): void;
+    observe(ref: RunRef, frame: HostFrame): void;
+    interrupted(record: TrackedInvocation, error?: unknown): void;
+    active(id: string): TrackedInvocation;
+    ref(id: string): RunRef;
+    cancel(record: TrackedInvocation, reason?: string): Promise<{
+        accepted: boolean;
+    }>;
+    snapshot(): readonly KernelInvocationRecord[];
+    stopAdmission(): void;
+    close(): void;
+    drain(options: {
+        deadline: number;
+        reason: string;
+    }): Promise<KernelInvocationDrainResult>;
+}
+export declare function errorCode(error: unknown): string;

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

@@ -0,0 +1,279 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { isHostTerminal } from "@mininglamp-oss/octo-runtime-protocol";
+import { KernelError } from "./types.js";
+/**
+ * 每个 client 独立保存 invoke 的身份、取消和观察状态；执行与断线恢复由 client.ts 负责。
+ * 最多登记 128 项，不缓存正文；未知结果继续占用额度，不能通过删除记录伪造排空成功。
+ */
+export class InvocationRegistry {
+    transport;
+    #records = new Map();
+    #stopped = false;
+    #draining;
+    #drainDeadline;
+    #closed = false;
+    #cancelling = 0;
+    #cancelQueue = [];
+    #cancelControllers = new Set();
+    constructor(transport) {
+        this.transport = transport;
+    }
+    begin(key) {
+        this.assertSubmission();
+        if (this.#records.has(key.invocation_id))
+            throw new KernelError("EXECUTION_IDENTITY_CONFLICT");
+        if (this.#records.size >= 128)
+            throw new KernelError("CLIENT_INVOCATION_CAPACITY_EXHAUSTED");
+        let settleAdmission;
+        const admitted = new Promise((resolve) => {
+            settleAdmission = resolve;
+        });
+        const record = {
+            key,
+            submitted: false,
+            phase: "admitting",
+            cancellation: "none",
+            lastSeq: 0,
+            admitted,
+            settleAdmission
+        };
+        this.#records.set(key.invocation_id, record);
+        return record;
+    }
+    assertSubmission() {
+        if (this.#stopped)
+            throw new KernelError("CLIENT_INVOCATION_ADMISSION_CLOSED");
+    }
+    accepted(record, ref, terminal) {
+        record.ref = ref;
+        record.instance = ref.kernel_instance_id;
+        record.phase = "accepted";
+        record.settleAdmission();
+        if (terminal)
+            this.observe(ref, terminal);
+        if (record.reason !== undefined && !terminal && this.#records.get(ref.invocation_id) === record)
+            void this.cancel(record, record.reason).catch(() => undefined);
+    }
+    reconcile(ref, terminal) {
+        const record = this.#records.get(ref.invocation_id);
+        if (!record ||
+            (record.instance && record.instance !== ref.kernel_instance_id) ||
+            Object.entries(record.key).some(([field, value]) => Reflect.get(ref, field) !== value))
+            return;
+        if (record.ref &&
+            (record.ref.stream_id !== ref.stream_id || record.ref.protocol !== ref.protocol))
+            throw new KernelError("RUN_IDENTITY_MISMATCH");
+        if (!record.ref)
+            this.accepted(record, ref, terminal);
+        else if (terminal)
+            this.observe(ref, terminal);
+    }
+    rejected(record, error) {
+        if (record.ref) {
+            record.settleAdmission();
+            this.interrupted(record, error);
+            return;
+        }
+        record.admissionError = error instanceof Error ? error : new KernelError("ACCEPTANCE_UNKNOWN");
+        record.observationError = errorCode(error);
+        record.phase = "acceptance_unknown";
+        record.settleAdmission();
+        const rejectedByServer = error instanceof KernelError &&
+            error.data !== undefined &&
+            !["KERNEL_INSTANCE_CHANGED", "RUN_IDENTITY_MISMATCH"].includes(error.code);
+        // 仅未发送或明确拒绝可安全移除；已发送但 ACK 未知时保留身份，后续 drain 只能查询确认。
+        if (!record.submitted || rejectedByServer)
+            this.#records.delete(record.key.invocation_id);
+    }
+    observe(ref, frame) {
+        const record = this.#records.get(ref.invocation_id);
+        if (!record ||
+            !record.ref ||
+            record.ref.stream_id !== ref.stream_id ||
+            record.ref.kernel_instance_id !== ref.kernel_instance_id)
+            return;
+        record.lastSeq = Math.max(record.lastSeq, frame.seq);
+        if (!isHostTerminal(frame))
+            return;
+        if (frame.kind === "control" &&
+            frame.control.type === "state" &&
+            frame.control.state === "lost") {
+            record.phase = "unobserved";
+            record.observationError = "RUN_OUTCOME_UNKNOWN";
+        }
+        else
+            this.#records.delete(ref.invocation_id);
+    }
+    interrupted(record, error) {
+        if (this.#records.get(record.key.invocation_id) !== record || !record.ref)
+            return;
+        record.phase = "unobserved";
+        if (error !== undefined)
+            record.observationError = errorCode(error);
+    }
+    active(id) {
+        const record = this.#records.get(id);
+        if (!record)
+            throw new KernelError("INVOCATION_NOT_TRACKED");
+        return record;
+    }
+    ref(id) {
+        const record = this.active(id);
+        if (!record.ref)
+            throw new KernelError("INVOCATION_NOT_ACCEPTED");
+        return record.ref;
+    }
+    cancel(record, reason = "caller_cancelled") {
+        if (record.ref && this.#records.get(record.key.invocation_id) !== record)
+            return Promise.resolve({ accepted: false });
+        if (record.observationError === "RUN_OUTCOME_UNKNOWN")
+            return Promise.reject(new KernelError("RUN_OUTCOME_UNKNOWN"));
+        record.reason ??= reason;
+        if (record.cancellation === "none")
+            record.cancellation = "requested";
+        // 取消可能早于接纳 ACK：记住首次原因，等同一执行获得 RunRef 后发出一次控制请求。
+        if (!record.ref)
+            return record.admitted.then(() => {
+                if (!record.ref)
+                    throw record.admissionError ?? new KernelError("ACCEPTANCE_UNKNOWN");
+                return this.cancel(record, reason);
+            });
+        if (!record.cancelTask) {
+            const controller = new AbortController();
+            this.#cancelControllers.add(controller);
+            record.cancelTask = new Promise((resolve, reject) => {
+                this.#cancelQueue.push(async () => {
+                    try {
+                        if (this.#closed)
+                            throw new KernelError("CLIENT_CLOSED");
+                        if (this.#records.get(record.key.invocation_id) !== record) {
+                            resolve({ accepted: false });
+                            return;
+                        }
+                        if (record.observationError === "RUN_OUTCOME_UNKNOWN")
+                            throw new KernelError("RUN_OUTCOME_UNKNOWN");
+                        const deadline = Math.min(Date.now() + 5000, this.#drainDeadline ?? Infinity);
+                        if (deadline <= Date.now())
+                            throw new KernelError("OPERATION_OUTCOME_UNKNOWN");
+                        resolve(await this.transport.cancel(record.ref, record.reason, deadline, controller.signal));
+                    }
+                    catch (error) {
+                        reject(error instanceof Error ? error : new KernelError("OPERATION_OUTCOME_UNKNOWN"));
+                    }
+                });
+                this.#pumpCancellations();
+            })
+                .then((result) => {
+                record.cancellation = "acknowledged";
+                return result;
+            })
+                .catch((error) => {
+                record.cancellation = "unknown";
+                record.observationError = errorCode(error);
+                throw error;
+            })
+                .finally(() => this.#cancelControllers.delete(controller));
+            // Automatic signal cancellation may outlive its consumer; always consume rejection.
+            void record.cancelTask.catch(() => undefined);
+        }
+        return record.cancelTask;
+    }
+    #pumpCancellations() {
+        while (this.#cancelling < 4 && this.#cancelQueue.length) {
+            this.#cancelling++;
+            void this.#cancelQueue.shift()().finally(() => {
+                this.#cancelling--;
+                this.#pumpCancellations();
+            });
+        }
+    }
+    snapshot() {
+        return [...this.#records.values()].map((record) => ({
+            key: { ...record.key },
+            ...(record.ref ? { ref: { ...record.ref } } : {}),
+            phase: record.phase,
+            cancellation: record.cancellation,
+            lastSeq: record.lastSeq,
+            ...(record.observationError ? { observationError: record.observationError } : {})
+        }));
+    }
+    stopAdmission() {
+        this.#stopped = true;
+    }
+    close() {
+        this.#closed = true;
+        this.stopAdmission();
+        for (const controller of this.#cancelControllers)
+            controller.abort();
+    }
+    drain(options) {
+        if (!Number.isSafeInteger(options.deadline) || options.deadline - Date.now() > 2_147_483_647)
+            throw new KernelError("INVOCATION_DEADLINE_INVALID");
+        // 首次关闭锁定绝对期限；重复调用不能延长预算，也不能启动第二轮取消副作用。
+        if (this.#draining)
+            return this.#draining;
+        this.stopAdmission();
+        this.#drainDeadline = options.deadline;
+        return (this.#draining = this.#drain(options));
+    }
+    async #drain({ deadline, reason }) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => {
+            controller.abort();
+            for (const cancelController of this.#cancelControllers)
+                cancelController.abort();
+        }, Math.max(0, deadline - Date.now()));
+        try {
+            while (this.#records.size && !controller.signal.aborted && Date.now() < deadline) {
+                const records = [...this.#records.values()];
+                // 最多四路查询/控制 IO；只查终态元数据，不新增正文订阅，避免与业务消费者争夺尾流。
+                let index = 0;
+                await Promise.all(Array.from({ length: Math.min(4, records.length) }, async () => {
+                    while (index < records.length && !controller.signal.aborted && Date.now() < deadline) {
+                        const record = records[index++];
+                        record.reason ??= reason;
+                        if (record.cancellation === "none")
+                            record.cancellation = "requested";
+                        if (!record.instance)
+                            continue;
+                        try {
+                            const info = await this.transport.get(record.key, record.instance, deadline, controller.signal);
+                            if (!record.ref)
+                                this.accepted(record, info.ref);
+                            if (info.terminal)
+                                this.observe(info.ref, info.terminal);
+                            if (!this.#records.has(record.key.invocation_id))
+                                continue;
+                            // lost 表示执行结果未知，必须留在 unresolved，不能据此重放可能已有副作用的执行。
+                            if (record.observationError !== "RUN_OUTCOME_UNKNOWN")
+                                await this.cancel(record, reason);
+                        }
+                        catch (error) {
+                            if (record.observationError !== "RUN_OUTCOME_UNKNOWN")
+                                record.observationError = errorCode(error);
+                        }
+                    }
+                }));
+                if (this.#records.size && Date.now() < deadline) {
+                    await delay(Math.min(100, deadline - Date.now()), undefined, {
+                        signal: controller.signal
+                    }).catch(() => undefined);
+                }
+            }
+            return { complete: this.#records.size === 0, unresolved: this.snapshot() };
+        }
+        finally {
+            clearTimeout(timer);
+            controller.abort();
+            for (const cancelController of this.#cancelControllers)
+                cancelController.abort();
+        }
+    }
+}
+export function errorCode(error) {
+    return error instanceof KernelError
+        ? error.code
+        : error instanceof Error && /^[A-Z][A-Z0-9_]+$/.test(error.message)
+            ? error.message
+            : "INVOCATION_OBSERVATION_FAILED";
+}

package/node_modules/@mininglamp-oss/{octo-runtime-daemon → octo-runtime-executor-kernel}/dist/invocation-manifest.d.ts

@@ -8,8 +8,12 @@ export interface OrphanReapResult {
     found: boolean;
     reaped: boolean;
     pid?: number;
-    reason?: "daemon_alive" | "host_missing" | "identity_mismatch" | "unsupported_identity";
+    reason?: "kernel_alive" | "host_missing" | "identity_mismatch" | "unsupported_identity";
 }
+/**
+ * 持久化 Kernel/worker 身份与在途执行事实，用于下次启动时识别遗留资源，不保存业务历史。
+ * 写入串行化并通过 rename 替换；只有 owner 确认 worker 回收后才能 close 删除清单。
+ */
 export declare class InvocationManifest {
     #private;
     private constructor();
@@ -17,10 +21,14 @@ export declare class InvocationManifest {
         manifest: InvocationManifest;
         reap: OrphanReapResult;
     }>;
-    setAdapterHost(pid: number | undefined, entrypoint: string): Promise<void>;
+    setWorker(pid: number | undefined, entrypoint: string): Promise<void>;
     begin(entry: Omit<InvocationManifestEntry, "startedAt">): Promise<void>;
     end(invocationId: string): Promise<void>;
     close(): Promise<void>;
 }
+/**
+ * 仅在原 Kernel 已退出且 worker 的 PID/启动身份仍匹配时尝试回收，防止 PID 复用误杀。
+ * 无法验证身份时保留清单并报告 unsupported_identity；worker 已消失不证明 Windows 后代已清空。
+ */
 export declare function reapOrphanedInvocationManifest(path: string): Promise<OrphanReapResult>;
 export declare function processStartIdentity(pid: number): Promise<string | undefined>;

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

@@ -2,32 +2,36 @@ import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
+/**
+ * 持久化 Kernel/worker 身份与在途执行事实，用于下次启动时识别遗留资源，不保存业务历史。
+ * 写入串行化并通过 rename 替换；只有 owner 确认 worker 回收后才能 close 删除清单。
+ */
 export class InvocationManifest {
     #path;
     #invocations = new Map();
-    #adapterHost;
+    #worker;
     #writes = Promise.resolve();
     constructor(path) {
         this.#path = path;
     }
     static async open(path) {
         const reap = await reapOrphanedInvocationManifest(path);
-        if (reap.reason === "daemon_alive" || reap.reason === "unsupported_identity") {
+        if (reap.reason === "kernel_alive" || reap.reason === "unsupported_identity") {
             throw new Error(`cannot replace live or unverifiable invocation manifest (${reap.reason})`);
         }
         const manifest = new InvocationManifest(path);
         await manifest.#persist();
         return { manifest, reap };
     }
-    async setAdapterHost(pid, entrypoint) {
+    async setWorker(pid, entrypoint) {
         if (pid === undefined) {
-            this.#adapterHost = undefined;
+            this.#worker = undefined;
         }
         else {
             const started = await processStartIdentity(pid);
             if (!started)
-                throw new Error(`cannot identify adapter-host process ${pid}`);
-            this.#adapterHost = { pid, started, entrypoint };
+                throw new Error(`cannot identify worker process ${pid}`);
+            this.#worker = { pid, started, entrypoint };
         }
         await this.#persist();
     }
@@ -47,9 +51,9 @@ export class InvocationManifest {
     #persist() {
         const snapshot = {
             schemaVersion: 1,
-            daemonPid: process.pid,
+            kernelPid: process.pid,
             updatedAt: new Date().toISOString(),
-            ...(this.#adapterHost ? { adapterHost: { ...this.#adapterHost } } : {}),
+            ...(this.#worker ? { worker: { ...this.#worker } } : {}),
             invocations: [...this.#invocations.values()].map((entry) => ({ ...entry }))
         };
         this.#writes = this.#writes.then(async () => {
@@ -69,6 +73,10 @@ export class InvocationManifest {
         return this.#writes;
     }
 }
+/**
+ * 仅在原 Kernel 已退出且 worker 的 PID/启动身份仍匹配时尝试回收，防止 PID 复用误杀。
+ * 无法验证身份时保留清单并报告 unsupported_identity；worker 已消失不证明 Windows 后代已清空。
+ */
 export async function reapOrphanedInvocationManifest(path) {
     let parsed;
     try {
@@ -80,12 +88,12 @@ export async function reapOrphanedInvocationManifest(path) {
         await rm(path, { force: true });
         return { found: true, reaped: false, reason: "host_missing" };
     }
-    if (Number.isSafeInteger(parsed.daemonPid) &&
-        parsed.daemonPid > 0 &&
-        processAlive(parsed.daemonPid)) {
-        return { found: true, reaped: false, reason: "daemon_alive" };
+    if (Number.isSafeInteger(parsed.kernelPid) &&
+        parsed.kernelPid > 0 &&
+        processAlive(parsed.kernelPid)) {
+        return { found: true, reaped: false, reason: "kernel_alive" };
     }
-    const host = parsed.adapterHost;
+    const host = parsed.worker;
     if (!host || !Number.isSafeInteger(host.pid) || host.pid < 1 || !processAlive(host.pid)) {
         await rm(path, { force: true });
         return { found: true, reaped: false, reason: "host_missing" };