@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.0

package/vendor/dynamic-workflow/engine/engine-settlement.js

@@ -0,0 +1,79 @@
+/**
+ * engine.ts 顶到 oxlint max-lines 上限（400 行），把 run 的三条终态路径
+ * （completed / stopped / errored）与它们共用的 finishRun
+ * 拆到本文件；公开面仍从 engine.ts 导出。
+ *
+ * 自由函数经 {@link EngineState} 接缝读写引擎状态；WorkflowEngine 的 complete / stop /
+ * failRun 只是薄委托。first-wins 由 `isRunSettled()` 守在每条路径的第一行。
+ */
+import { WorkflowError } from "./types.js";
+/**
+ * 沙箱脚本成功返回顶层 artifact，结算为 completed。
+ *
+ * 脚本返回时仍可能有在飞 ask（`Promise.race` 的输家、没有 `await` 的 ask）。它们与 cancel
+ * 路径同款中止：driver 侧 cancelAsk、deferred 以 Cancelled reject、补发 node-settled(cancelled)。
+ * 不中止的后果是三重的：scheduler 的 liveNodes 永远握着节点、driver 侧 turn 继续烧 token、
+ * 事件日志里一个 node-dispatched 永远等不到它的 node-settled。
+ */
+export function settleCompleted(state, artifact) {
+    if (state.isRunSettled())
+        return;
+    state.markSettled();
+    state.abortInFlight(new WorkflowError("Cancelled", "Run completed; in-flight subagent tasks were abandoned."), true);
+    // 产物随终态一笔落库。分两笔写会造出「completed 但产物丢失」的崩溃窗口，而 journal
+    // 行是产物唯一的持久化家（`run-settled` 事件刻意不加宽）。
+    finishRun(state, "completed", { result: artifact });
+    state.resolveSettled({ status: "completed", artifact });
+}
+/**
+ * 外部停止：中止在飞 ask（deferred 以 Cancelled reject、补发 node-settled(cancelled)），run
+ * 结算 `stopped(reason)`；已完结的 journal 条目保留（可 resume）。四个 reason 走同一条路：
+ * `user` / `model`（cancel 入口传进来的 initiator）、`interrupted`（harness 的沙箱故障）、
+ * `provider`（driver 经 `stopRun` 报上来的确定性模型侧错误）。`error` 只对后两者在场。
+ */
+export function settleStopped(state, reason, error, supersededBy) {
+    if (state.isRunSettled())
+        return;
+    state.markSettled();
+    state.abortInFlight(new WorkflowError("Cancelled", "Run stopped."), true);
+    // `superseded` 的后继 id 与原因**同一笔**落库：
+    // stopped 信封整体重写，分两笔写就有一个「已 superseded 却不知道被谁替代」的窗口。
+    finishRun(state, "stopped", {
+        stopReason: reason,
+        ...(supersededBy === undefined ? {} : { supersededBy }),
+        ...(error === undefined ? {} : { failure: error.toJSON() }),
+    });
+    state.resolveSettled({
+        status: "stopped",
+        reason,
+        ...(supersededBy === undefined ? {} : { supersededBy }),
+        ...(error === undefined ? {} : { error }),
+    });
+}
+/** run 级失败（脚本之错）：中止在飞 ask（以 run 错误 reject），run 结算 errored。 */
+export function settleFailed(state, error) {
+    if (state.isRunSettled())
+        return;
+    state.markSettled(error);
+    state.abortInFlight(error, false);
+    finishRun(state, "errored", { failure: error.toJSON() });
+    state.resolveSettled({ status: "errored", error });
+}
+/**
+ * `run-settled` 事件只带 {status, stopReason?, error?}：产物不上高频进度管线，只落 journal。
+ *
+ * 三条终态路径都经这里，所以 driver 的 dispose 恰好一次、first-wins 自然成立。放在
+ * `run-settled` **之后**：dispose 是结算之后的资源释放（actor runtime 的关闭链），不是结算
+ * 的一部分，事件日志不因它多一条。
+ */
+function finishRun(state, status, settlement) {
+    state.journal.updateRunStatus(state.runId, status, settlement);
+    state.record({
+        type: "run-settled",
+        status,
+        ...(settlement?.stopReason === undefined ? {} : { stopReason: settlement.stopReason }),
+        ...(settlement?.supersededBy === undefined ? {} : { supersededBy: settlement.supersededBy }),
+        ...(settlement?.failure === undefined ? {} : { error: settlement.failure }),
+    });
+    state.driver.dispose?.();
+}

package/vendor/dynamic-workflow/engine/engine-state.d.ts

@@ -0,0 +1,99 @@
+/**
+ * engine.ts 顶到 oxlint max-lines 上限（400 行），把引擎私有状态的显式接缝拆到本文件；
+ * 公开面仍从 engine.ts 导出。
+ *
+ * WorkflowEngine 的几组方法（用户面产物、report、world 节点与导入缓存、run 结算）被拆成兄弟
+ * 模块里的自由函数（engine-artifacts.ts / engine-report.ts / engine-world.ts / engine-settlement.ts）。
+ * 它们不各自持有状态，而是经这张接缝读写引擎的私有字段：接缝由引擎在构造函数里用箭头闭包
+ * 装配，字段本身仍是 private，所以引擎的公开面零变化；类上只留薄薄一层委托方法。
+ *
+ * 可变标量（报告计数、导入门）以「读方法 + 单向写方法」暴露，而不是 getter/setter——写法只有
+ * 一种（计数只增、门只关），接缝面上就说清了这一点。
+ */
+import type { ImportedWorldQueue } from "./imported-cache.js";
+import type { ArtifactOp } from "../facade/registry.js";
+import type { ImportedRunCache, InstanceRef, JournalStorePort, RunEvent, RunStopReason, WorkflowDriver, WorkflowError } from "./types.js";
+/**
+ * run 的最终结算：`completed`（脚本 return）/
+ * `errored`（脚本之错，不可 resume）/ `stopped`（被停下，一律可 resume；`error` 只对
+ * `provider` / `interrupted` 在场）。
+ */
+export type RunSettlement = {
+    status: "completed";
+    artifact: unknown;
+} | {
+    status: "errored";
+    error: WorkflowError;
+} | {
+    status: "stopped";
+    reason: RunStopReason;
+    supersededBy?: string;
+    error?: WorkflowError;
+};
+/**
+ * 一个用户面产物 id 在本 run 内的状态：它属于哪个成员种类、已成功几版、（预置才有）它的
+ * 规范化 spec。三样都从 journal 行派生，所以 resume 重建与 live 记账得到同一份表。
+ */
+export interface ArtifactIdState {
+    kind: ArtifactOp;
+    /** 已成功的版本数（内容成员每成功一次 +1；预置声明恒为 1）。 */
+    versions: number;
+    /** 预置 spec 的 canonicalJson（重复声明的幂等判定按它比对）。内容成员缺席。 */
+    spec?: string;
+    /** 这个 id 是 run 的交付物（primary）。全 run 至多一个 id 带它；从 completed 行重建。 */
+    primary?: true;
+}
+/** 引擎私有状态的接缝：兄弟模块里的自由函数经它读写 WorkflowEngine 的私有字段。 */
+/**
+ * run 级的报告计数：条数与 item 的 UTF-8 序列化字节数之和（`JSON.stringify(item)`，与
+ * `result_json` 落库的字节同一把尺，所以 resume 时 `sumResultBytes` 能把它原样恢复）。
+ */
+export interface ReportTally {
+    count: number;
+    bytes: number;
+}
+export interface EngineState {
+    readonly runId: string;
+    readonly driver: WorkflowDriver;
+    readonly journal: JournalStorePort;
+    /**
+     * 本 run 每个**用户面产物** id 的状态。resume 时从 journal
+     * 的 `kind: "artifact"` 行重建，此后在内存里维护——上限与版本号都是 run 级事实，跨 resume 连续。
+     *
+     * ⚠ 术语：artifact = 用户面产物，不是 `RunSettlement.artifact`（顶层返回值）。
+     */
+    readonly artifacts: Map<string, ArtifactIdState>;
+    /** amend-resume 的导入缓存（纯数据，缺席即本次不是修订续跑）。 */
+    readonly importedCache: ImportedRunCache | undefined;
+    /** world 导入队列的消费游标（第 n 次出现对第 n 条）。 */
+    readonly importedWorld: ImportedWorldQueue;
+    isRunSettled(): boolean;
+    /** run 已结算时用于 reject / throw 的错误。 */
+    runError(): WorkflowError;
+    /** run 级失败（first-wins；见 engine-settlement.ts 的 settleFailed）。 */
+    failRun(error: WorkflowError): void;
+    /** 事件既落 journal 又扇出（Boundary C）；出生阶段在引擎的漏斗里补上。 */
+    record(event: RunEvent): void;
+    /** 站点序号的唯一铸造点。 */
+    nextOrdinal(siteId: string): number;
+    /**
+     * 受 replay 结算次序约束地释放一次命中（docs/execution-engine.md「Replaying the settle order」）。
+     * 非 resume、或次序表里没有这个实例时立即执行 `release`。
+     */
+    holdForReplay(instance: InstanceRef, release: () => void): void;
+    /** 本 run 已发布的报告条数与 item 字节数（REPORT_CAPS 两个 run 级上限的计数器，跨 resume 连续）。 */
+    reportTally(): ReportTally;
+    /** 一条报告过了上限检查、即将落库：条数 +1，字节数加上这条 item 的序列化字节数。 */
+    countReport(bytes: number): void;
+    /** 导入缓存是否已关闭。 */
+    importClosed(): boolean;
+    /** 关门（永不重开）。 */
+    closeImport(): void;
+    /** 置 run 为已结算；带 failure 时同时记下 run 级失败原因（供 runError 复用）。 */
+    markSettled(failure?: WorkflowError): void;
+    /** 中止所有在飞 ask（委托调度器）。 */
+    abortInFlight(error: WorkflowError, emitCancelled: boolean): void;
+    /** 兑现 `engine.settled`。 */
+    resolveSettled(settlement: RunSettlement): void;
+}
+//# sourceMappingURL=engine-state.d.ts.map

package/vendor/dynamic-workflow/engine/engine-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-state.d.ts","sourceRoot":"","sources":["../../src/engine/engine-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EACV,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,QAAQ,EACR,aAAa,EACb,cAAc,EACd,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB;;;;GAIG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GAC1C;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAE,GAC3C;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,aAAa,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,aAAa,CAAA;CAAE,CAAC;AAE/F;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,UAAU,CAAC;IACjB,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB;AAED,qDAAqD;AACrD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACjD,2CAA2C;IAC3C,QAAQ,CAAC,aAAa,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACrD,sCAAsC;IACtC,QAAQ,CAAC,aAAa,EAAE,kBAAkB,CAAC;IAE3C,YAAY,IAAI,OAAO,CAAC;IACxB,qCAAqC;IACrC,QAAQ,IAAI,aAAa,CAAC;IAC1B,iEAAiE;IACjE,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;IACpC,kDAAkD;IAClD,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC9B,kBAAkB;IAClB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACpC;;;OAGG;IACH,aAAa,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAEhE,wEAAwE;IACxE,WAAW,IAAI,WAAW,CAAC;IAC3B,kDAAkD;IAClD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAEjC,iBAAiB;IACjB,YAAY,IAAI,OAAO,CAAC;IACxB,gBAAgB;IAChB,WAAW,IAAI,IAAI,CAAC;IAEpB,2DAA2D;IAC3D,WAAW,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAC3C,yBAAyB;IACzB,aAAa,CAAC,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,OAAO,GAAG,IAAI,CAAC;IAClE,2BAA2B;IAC3B,cAAc,CAAC,UAAU,EAAE,aAAa,GAAG,IAAI,CAAC;CACjD"}

package/vendor/dynamic-workflow/engine/engine-state.js

@@ -0,0 +1,13 @@
+/**
+ * engine.ts 顶到 oxlint max-lines 上限（400 行），把引擎私有状态的显式接缝拆到本文件；
+ * 公开面仍从 engine.ts 导出。
+ *
+ * WorkflowEngine 的几组方法（用户面产物、report、world 节点与导入缓存、run 结算）被拆成兄弟
+ * 模块里的自由函数（engine-artifacts.ts / engine-report.ts / engine-world.ts / engine-settlement.ts）。
+ * 它们不各自持有状态，而是经这张接缝读写引擎的私有字段：接缝由引擎在构造函数里用箭头闭包
+ * 装配，字段本身仍是 private，所以引擎的公开面零变化；类上只留薄薄一层委托方法。
+ *
+ * 可变标量（报告计数、导入门）以「读方法 + 单向写方法」暴露，而不是 getter/setter——写法只有
+ * 一种（计数只增、门只关），接缝面上就说清了这一点。
+ */
+export {};

package/vendor/dynamic-workflow/engine/engine-world.d.ts

@@ -0,0 +1,36 @@
+/**
+ * engine.ts 顶到 oxlint max-lines 上限（400 行），把 world 节点（world-read / world-run）
+ * 的准入-结算路径与 amend-resume 导入缓存的关门 / 恢复接缝拆到本文件；公开面仍从 engine.ts 导出。
+ *
+ * 自由函数经 {@link EngineState} 接缝读写引擎状态；WorkflowEngine.worldRead 只是薄委托，
+ * 关门由调度器经 SchedulerHost 触发，恢复在引擎构造函数的 resume 分支里调用。
+ */
+import type { EngineState } from "./engine-state.js";
+import type { InstanceRef, JournalStorePort, WorldReadOp } from "./types.js";
+export declare function readWorld(state: EngineState, siteId: string, op: WorldReadOp, args: unknown[]): Promise<unknown>;
+/**
+ * 关闭导入缓存（幂等）。两个触发点，都是**第一笔写入之前**：
+ * driver 上报某个 live 子代理即将执行改写工具（`mutating-tool`），或一条 `world.run` 要 live 执行
+ * （`world-run`）。只在本次真是修订 run 时发 `import-cache-closed` 事件——它是 resume 时恢复
+ * 「门已关」的唯一事实来源；非修订 run 没有表可关，标志位无害但不发事件。
+ */
+export declare function closeImportCache(state: EngineState, instance: InstanceRef, cause: "mutating-tool" | "world-run", actorName?: string): void;
+/**
+ * resume 时恢复关门判定、「曾 live 的 ask 实例」集合，以及「关门之前就已准入的 ask 实例」集合。
+ *
+ * 事实来源是本 run 自己的事件：live 节点在准入时发 `node-queued`（ask 的带 actor ref），缓存
+ * 命中只发 `node-settled cached:true`，所以「哪些 ask 曾 live」是精确集合。门是否已关则由
+ * `import-cache-closed` 事件决定——ask 转 live 不再意味着关门（它可能一个文件都没碰），只有
+ * 写入才关，而写入这件事只有这条事件记着。零 schema 变更。
+ *
+ * `queuedBeforeClose` 同样零 schema 变更，靠的是**事件次序**：续跑在飞 ask 的判定与该 ask 的
+ * `node-queued` 落在准入的同一个同步片里（见 scheduler 的 admitAsk → tryImportedSettle →
+ * admitLive），所以「准入那一刻门开着」⇔「这条 node-queued 早于第一条 import-cache-closed」。
+ * 没有关门事件时全体都算在内。
+ */
+export declare function recoverImportClosure(journal: JournalStorePort, runId: string): {
+    live: ReadonlySet<string>;
+    queuedBeforeClose: ReadonlySet<string>;
+    closed: boolean;
+};
+//# sourceMappingURL=engine-world.d.ts.map

package/vendor/dynamic-workflow/engine/engine-world.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-world.d.ts","sourceRoot":"","sources":["../../src/engine/engine-world.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EACV,WAAW,EACX,gBAAgB,EAIhB,WAAW,EACZ,MAAM,YAAY,CAAC;AAGpB,wBAAgB,SAAS,CACvB,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,WAAW,EACf,IAAI,EAAE,OAAO,EAAE,GACd,OAAO,CAAC,OAAO,CAAC,CAwGlB;AAkCD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,WAAW,EACrB,KAAK,EAAE,eAAe,GAAG,WAAW,EACpC,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI,CAUN;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,MAAM,GACZ;IAAE,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAAC,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAiBxF"}

package/vendor/dynamic-workflow/engine/engine-world.js

@@ -0,0 +1,189 @@
+/**
+ * engine.ts 顶到 oxlint max-lines 上限（400 行），把 world 节点（world-read / world-run）
+ * 的准入-结算路径与 amend-resume 导入缓存的关门 / 恢复接缝拆到本文件；公开面仍从 engine.ts 导出。
+ *
+ * 自由函数经 {@link EngineState} 接缝读写引擎状态；WorkflowEngine.worldRead 只是薄委托，
+ * 关门由调度器经 SchedulerHost 触发，恢复在引擎构造函数的 resume 分支里调用。
+ */
+import { canonicalJson, inputHash } from "./hash.js";
+import { heldResolution } from "./replay-order.js";
+import { boundWorldReadInput } from "./world-read-input.js";
+import { hashMismatch } from "./hash-mismatch.js";
+import { refToString, WorkflowError } from "./types.js";
+export function readWorld(state, siteId, op, args) {
+    if (state.isRunSettled())
+        return Promise.reject(state.runError());
+    const ordinal = state.nextOrdinal(siteId);
+    const instance = { siteId, ordinal };
+    // inputHash 覆盖 `{op, args}`（而非单实参的 `{op, arg}`）。这是**有意的载荷形变**：
+    // 旧 journal（多参 world-read 之前写下的）里，每个 world-read 命中都会 inputHash 不符而让 run 以
+    // InputHashMismatch 大声失败。可接受——v1 的 resume 本就要求脚本文本逐字节相同
+    // （script_hash），facade 表面早于多参 world-read 的脚本不会是要被 resume 的那个脚本。
+    // 写在这里是因为故障点在 resume，离这一行很远。
+    const hash = inputHash({ op, args });
+    // 有界的 `{op, args}`：与 hash 同一次准入写下，
+    // 并在结算的 upsert 里原样带过去——putNode 是整条替换，漏一处就把它抹回 NULL。
+    const input = boundWorldReadInput(op, args);
+    const recorded = state.journal.getNode(state.runId, siteId, ordinal);
+    if (recorded !== undefined) {
+        if (recorded.inputHash !== hash) {
+            const err = hashMismatch(instance, recorded.inputHash, hash);
+            state.failRun(err);
+            return Promise.reject(err);
+        }
+        // 完结命中短路（journal 化世界读取使 resume 免疫于 run 与 resume 之间的磁盘变化）。
+        // 释放点过 replay 次序闸：一条扇出分支里的 world 读取同样是别人的续体在等的东西，
+        // 按准入顺序放会把 join 之后的序号错位（docs/execution-engine.md「Replaying the settle order」）。
+        if (recorded.status === "completed") {
+            return heldResolution(state.holdForReplay, instance, () => {
+                state.record({ type: "node-settled", instance, outcome: "ok", cached: true });
+                return recorded.result;
+            });
+        }
+        if (recorded.status === "failed") {
+            return heldResolution(state.holdForReplay, instance, () => {
+                state.record({
+                    type: "node-settled",
+                    instance,
+                    outcome: "failed",
+                    cached: true,
+                    error: recorded.error,
+                });
+                throw WorkflowError.fromJSON(recorded.error);
+            });
+        }
+        // status === "running"：崩溃于执行中，落到下面重新 live 执行。
+    }
+    // op "run" 是效应而不是读，journal 单列一种（world-run）：机制同构，审计面诚实。其余 op 保持 world-read。
+    const kind = op === "run" ? "world-run" : "world-read";
+    // amend-resume：本 run 的 journal 里没有这一行，才轮到导入缓存（journal replay 永远优先——
+    // 修订 run 自己崩溃后 resume 时，已消费的命中早已是真行，重放它们不能再动游标）。
+    // 命中即写一行与 settleWorldRead 同形的 completed 记录 + 发 node-settled(cached)，
+    // **不调 driver**：world-run 的效应绝不静默重放。
+    // 缓存关闭后不再问表（也不推进游标）：命令文本没变，但它读到的世界可能已被某个 live 子代理
+    // 改写。
+    const imported = state.importClosed() ? undefined : state.importedWorld.take(hash);
+    if (imported !== undefined) {
+        state.journal.putNode({
+            runId: state.runId,
+            siteId,
+            ordinal,
+            kind,
+            inputHash: hash,
+            input,
+            status: "completed",
+            result: imported.result,
+        });
+        state.record({ type: "node-settled", instance, outcome: "ok", cached: true });
+        return Promise.resolve(imported.result);
+    }
+    // live world-read：不受 actor FIFO / 并发上限约束（harness IO）。
+    if (state.isRunSettled())
+        return Promise.reject(state.runError());
+    // live 的 world.run 是一笔写入（效应，不是读）：它一旦执行，工作区就与前驱留下的不同，所以在
+    // 派发**之前**关导入缓存——与子代理的改写工具同一条规则、同一个时刻（动手前）。world-read 不关：
+    // 读不改变世界。
+    if (kind === "world-run")
+        closeImportCache(state, instance, "world-run");
+    // 准入即落 running：崩溃于执行中的世界读取 resume 可据此重新执行。
+    state.journal.putNode({
+        runId: state.runId,
+        siteId,
+        ordinal,
+        kind,
+        inputHash: hash,
+        input,
+        status: "running",
+    });
+    state.record({ type: "node-queued", instance, kind });
+    state.record({ type: "node-dispatched", instance });
+    return state.driver.executeWorldRead(op, args).then((value) => settleWorldRead(state, instance, kind, hash, input, { status: "completed", result: value }), (cause) => {
+        const err = cause instanceof WorkflowError
+            ? cause
+            : new WorkflowError("DriverError", `World read failed: ${op} ${canonicalJson(args)}.`, {
+                cause,
+            });
+        return settleWorldRead(state, instance, kind, hash, input, {
+            status: "failed",
+            error: err.toJSON(),
+        });
+    });
+}
+function settleWorldRead(state, instance, 
+// putNode 是 upsert（整条替换），settle 若写死 world-read 会把准入时的 world-run
+// 悄悄改回去——kind 必须与准入同源。
+kind, hash, 
+// 同一条理由：准入写下的有界输入必须随结算的整条替换回来。
+input, outcome) {
+    if (state.isRunSettled())
+        throw state.runError();
+    state.journal.putNode({
+        runId: state.runId,
+        siteId: instance.siteId,
+        ordinal: instance.ordinal,
+        kind,
+        inputHash: hash,
+        input,
+        status: outcome.status,
+        ...(outcome.status === "completed" ? { result: outcome.result } : { error: outcome.error }),
+    });
+    if (outcome.status === "completed") {
+        state.record({ type: "node-settled", instance, outcome: "ok" });
+        return outcome.result;
+    }
+    state.record({ type: "node-settled", instance, outcome: "failed", error: outcome.error });
+    throw WorkflowError.fromJSON(outcome.error);
+}
+/**
+ * 关闭导入缓存（幂等）。两个触发点，都是**第一笔写入之前**：
+ * driver 上报某个 live 子代理即将执行改写工具（`mutating-tool`），或一条 `world.run` 要 live 执行
+ * （`world-run`）。只在本次真是修订 run 时发 `import-cache-closed` 事件——它是 resume 时恢复
+ * 「门已关」的唯一事实来源；非修订 run 没有表可关，标志位无害但不发事件。
+ */
+export function closeImportCache(state, instance, cause, actorName) {
+    if (state.importClosed())
+        return;
+    state.closeImport();
+    if (state.importedCache === undefined)
+        return;
+    state.record({
+        type: "import-cache-closed",
+        instance,
+        cause,
+        ...(actorName === undefined || actorName === "" ? {} : { actorName }),
+    });
+}
+/**
+ * resume 时恢复关门判定、「曾 live 的 ask 实例」集合，以及「关门之前就已准入的 ask 实例」集合。
+ *
+ * 事实来源是本 run 自己的事件：live 节点在准入时发 `node-queued`（ask 的带 actor ref），缓存
+ * 命中只发 `node-settled cached:true`，所以「哪些 ask 曾 live」是精确集合。门是否已关则由
+ * `import-cache-closed` 事件决定——ask 转 live 不再意味着关门（它可能一个文件都没碰），只有
+ * 写入才关，而写入这件事只有这条事件记着。零 schema 变更。
+ *
+ * `queuedBeforeClose` 同样零 schema 变更，靠的是**事件次序**：续跑在飞 ask 的判定与该 ask 的
+ * `node-queued` 落在准入的同一个同步片里（见 scheduler 的 admitAsk → tryImportedSettle →
+ * admitLive），所以「准入那一刻门开着」⇔「这条 node-queued 早于第一条 import-cache-closed」。
+ * 没有关门事件时全体都算在内。
+ */
+export function recoverImportClosure(journal, runId) {
+    const live = new Set();
+    const queuedBeforeClose = new Set();
+    let closed = false;
+    // 只读判定要的两种事件（docs/execution-engine.md「Reading the journal」）；类型过滤保序，
+    // 所以「node-queued 早于第一条 import-cache-closed」在过滤后的序列上照样成立。
+    for (const { event } of journal.listEvents(runId, {
+        types: ["node-queued", "import-cache-closed"],
+        reportItems: { limit: 0 },
+    })) {
+        if (event.type === "import-cache-closed")
+            closed = true;
+        if (event.type !== "node-queued" || event.kind !== "ask")
+            continue;
+        const key = refToString(event.instance);
+        live.add(key);
+        if (!closed)
+            queuedBeforeClose.add(key);
+    }
+    return { live, queuedBeforeClose, closed };
+}