@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.2

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

@@ -0,0 +1,87 @@
+/**
+ * 引擎的结构化错误（docs/execution-engine.md「Errors are first-class」）：稳定错误码、
+ * 它的可序列化形态，以及跨 Boundary A 抛出的 {@link WorkflowError} 本身。
+ *
+ * 独立成文件的理由与 run-terminal.ts 同一条：types.ts 已抵 oxlint 的 400 行门，而这一族
+ * 高度自足——它只依赖 schema 的 `Violation` 与终态明细，不依赖词汇表里的任何别的东西。
+ * 消费者按惯例仍从 types.ts 取（那边原样再导出），导入路径因此一处都不必改。
+ */
+import type { Violation } from "../schema/types.js";
+import type { ProviderStopDetails } from "./run-terminal.js";
+/**
+ * 稳定错误码。区分 node 级（拒绝单个 ask 的 promise）与 run 级（使整个 run 失败）：
+ * - node 级：ValidationFailed / ResultNotSubmitted / DriverError / Cancelled / ContextLimit /
+ *   WorldReadCapExceeded——一次世界读取超过它那个 op 的上限（`files.grep`：2000 条命中或
+ *   256KB 序列化，先到先拒；`git.diff`：512KB；见 `facade/world-read-caps.ts`）。它是 node 级
+ *   而不是 run 级，靠的是**拒绝通道**而不是严重程度：世界读取返回一个脚本能 `catch` 的
+ *   promise，所以"缩窄 pattern 或加个 glob"是一条脚本真能走的路。也刻意**不**折进
+ *   DriverError——上限是脚本可以据以重写自己的契约，而靠匹配 message 文本区分两者，
+ *   正是这个联合类型存在的目的所要防的。
+ * - run 级：InputHashMismatch / UnknownActor / MissingAskSpec /
+ *   DuplicateActorName——同一个 run 内两次 createActor 得到相同的**非空**有效名
+ *   （有效名 = normalizePersona 后的 `spec.name`，persona.name 压过 name 实参）。规则对
+ *   **所有** run 生效而不只是修订 run：具名 actor 是 amend-resume 缓存导入的身份键，而任何
+ *   run 都是未来修订的潜在前驱，前驱里重名会让导入匹配歧义（docs/execution-engine.md
+ *   的「命名唯一性（引擎）」行）。匿名（名缺席或空串）不查、不禁——代价是没有缓存资格。
+ *   字面量重名另有编译期 courtesy 诊断（analysis/actor-names.ts），但动态名只有运行期能查，
+ *   所以这条才是真正的门。
+ *   ReportCapExceeded——一个 run 超过 65,536 条报告、单条 item 序列化超过 1 MiB，或全部 item 超过 1 GiB
+ *   （见 `facade/report-caps.ts`）。它是 run 级而不是 node 级，与上面 WorldReadCapExceeded 的
+ *   分界同理、结论相反：`report` 返回 `void`，脚本**没有**可以 catch 的通道，除了 run 无处可放。
+ *   也正因如此这两个数字必须宽到讲道理的脚本永远碰不到——脚本作者写不出恢复路径。
+ *   同样刻意不折进 DriverError：上限是脚本可据以重写自己的契约。
+ * - 构造期（run 尚未开始，引擎构造函数同步抛出）：ScriptHashMismatch
+ * - 宿主级（**引擎从不产出**）：Interrupted——拥有该 run 的进程在结算之前就没了，由宿主在
+ *   下一次构造时收敛那行永远停在 running 的记录（`bootstrap/src/app/dynamic-workflow-run-service.ts`
+ *   的孤儿收敛，桌面实测 bug 2026-08-19）。它必须是**独立的码**而不是复用 DriverError：脚本
+ *   自己抛错也编码成 DriverError（`dynamic-workflow-runtime/src/harness.ts:311`），两者若同码，
+ *   「进程被杀」与「脚本真失败」就只能靠 message 文本区分——而这正是本联合类型要避免的。
+ *   ProviderStop——一个子代理（或工具侧）的模型请求撞上**确定性的**模型侧错误（认证失效、
+ *   模型不在套餐里、配额耗尽……，docs/execution-engine.md 的策略表），driver 让
+ *   run 以 `stopped(provider)` 停下而不是让节点失败；结构化明细在 `providerStop`。它是宿主级
+ *   的另一条：引擎只在 `stop("provider", error)` 里原样落库。
+ * 流程判断一律用这里的码，绝不匹配错误文本。
+ */
+export type WorkflowErrorCode = "ValidationFailed" | "ResultNotSubmitted" | "DriverError" | "WorldReadCapExceeded" | "Cancelled" | "ContextLimit" | "ReportCapExceeded" | "InputHashMismatch" | "UnknownActor" | "MissingAskSpec" | "DuplicateActorName" | "ScriptHashMismatch" | "Interrupted" | "ProviderStop" | "ArtifactSourceMissing" | "ArtifactPathOutsideWorkspace" | "ArtifactTooLarge" | "ArtifactStoreUnavailable" | "ArtifactVersionCapExceeded" | "ArtifactKindMismatch" | "ArtifactCapExceeded" | "ArtifactSpecInvalid" | "ArtifactRedeclared" | "ArtifactUndeclared" | "ArtifactPrimaryConflict";
+/**
+ * 值不匹配的结构化比对（哪一侧变了）。记录里的值是 `expected`，本次传入的是 `got`。
+ * 排查 resume 被拒的人需要的是这两个值，而不是从 message 里正则抠——流程判断与展示
+ * 都不该依赖错误文本。
+ */
+export interface WorkflowErrorMismatch {
+    expected: string;
+    got: string;
+}
+/** 错误的可序列化形态，落 journal（dwf_node.error_json / dwf_run.failure_json）。 */
+export interface WorkflowErrorJson {
+    code: WorkflowErrorCode;
+    message: string;
+    violations?: Violation[];
+    finalText?: string;
+    mismatch?: WorkflowErrorMismatch;
+    /** 只在 `code === "ProviderStop"` 时在场。 */
+    providerStop?: ProviderStopDetails;
+}
+/**
+ * 跨 Boundary A 抛出的结构化错误。带稳定 code 与可选的 violations / finalText / mismatch，
+ * 使脚本侧 try/catch 与上层都能按结构处理，而不依赖字符串匹配。
+ */
+export declare class WorkflowError extends Error {
+    readonly code: WorkflowErrorCode;
+    readonly violations?: Violation[];
+    readonly finalText?: string;
+    readonly mismatch?: WorkflowErrorMismatch;
+    readonly providerStop?: ProviderStopDetails;
+    constructor(code: WorkflowErrorCode, message: string, extra?: {
+        violations?: Violation[];
+        finalText?: string;
+        mismatch?: WorkflowErrorMismatch;
+        providerStop?: ProviderStopDetails;
+        cause?: unknown;
+    });
+    /** 转为可序列化形态落 journal。 */
+    toJSON(): WorkflowErrorJson;
+    /** 从 journal 记录重建（replay 命中失败节点时用）。 */
+    static fromJSON(json: WorkflowErrorJson): WorkflowError;
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/engine/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,MAAM,iBAAiB,GACzB,kBAAkB,GAClB,oBAAoB,GACpB,aAAa,GACb,sBAAsB,GACtB,WAAW,GACX,cAAc,GACd,mBAAmB,GACnB,mBAAmB,GACnB,cAAc,GACd,gBAAgB,GAChB,oBAAoB,GACpB,oBAAoB,GACpB,aAAa,GACb,cAAc,GASd,uBAAuB,GACvB,8BAA8B,GAC9B,kBAAkB,GAClB,0BAA0B,GAC1B,4BAA4B,GAC5B,sBAAsB,GACtB,qBAAqB,GACrB,qBAAqB,GACrB,oBAAoB,GACpB,oBAAoB,GAGpB,yBAAyB,CAAC;AAE9B;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,uEAAuE;AACvE,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,iBAAiB,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IACjC,wCAAwC;IACxC,YAAY,CAAC,EAAE,mBAAmB,CAAC;CACpC;AAED;;;GAGG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IAC1C,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;gBAG1C,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE;QACN,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;QACzB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,qBAAqB,CAAC;QACjC,YAAY,CAAC,EAAE,mBAAmB,CAAC;QACnC,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB;IAYH,yBAAyB;IACzB,MAAM,IAAI,iBAAiB;IAS3B,uCAAuC;IACvC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,GAAG,aAAa;CAQxD"}

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

@@ -0,0 +1,56 @@
+/**
+ * 引擎的结构化错误（docs/execution-engine.md「Errors are first-class」）：稳定错误码、
+ * 它的可序列化形态，以及跨 Boundary A 抛出的 {@link WorkflowError} 本身。
+ *
+ * 独立成文件的理由与 run-terminal.ts 同一条：types.ts 已抵 oxlint 的 400 行门，而这一族
+ * 高度自足——它只依赖 schema 的 `Violation` 与终态明细，不依赖词汇表里的任何别的东西。
+ * 消费者按惯例仍从 types.ts 取（那边原样再导出），导入路径因此一处都不必改。
+ */
+/**
+ * 跨 Boundary A 抛出的结构化错误。带稳定 code 与可选的 violations / finalText / mismatch，
+ * 使脚本侧 try/catch 与上层都能按结构处理，而不依赖字符串匹配。
+ */
+export class WorkflowError extends Error {
+    code;
+    violations;
+    finalText;
+    mismatch;
+    providerStop;
+    constructor(code, message, extra) {
+        super(message);
+        this.name = "WorkflowError";
+        this.code = code;
+        if (extra?.violations !== undefined)
+            this.violations = extra.violations;
+        if (extra?.finalText !== undefined)
+            this.finalText = extra.finalText;
+        if (extra?.mismatch !== undefined)
+            this.mismatch = extra.mismatch;
+        if (extra?.providerStop !== undefined)
+            this.providerStop = extra.providerStop;
+        if (extra?.cause !== undefined)
+            this.cause = extra.cause;
+    }
+    /** 转为可序列化形态落 journal。 */
+    toJSON() {
+        const json = { code: this.code, message: this.message };
+        if (this.violations !== undefined)
+            json.violations = this.violations;
+        if (this.finalText !== undefined)
+            json.finalText = this.finalText;
+        if (this.mismatch !== undefined)
+            json.mismatch = this.mismatch;
+        if (this.providerStop !== undefined)
+            json.providerStop = this.providerStop;
+        return json;
+    }
+    /** 从 journal 记录重建（replay 命中失败节点时用）。 */
+    static fromJSON(json) {
+        return new WorkflowError(json.code, json.message, {
+            violations: json.violations,
+            finalText: json.finalText,
+            mismatch: json.mismatch,
+            providerStop: json.providerStop,
+        });
+    }
+}

package/vendor/dynamic-workflow/engine/hash-mismatch.d.ts

@@ -0,0 +1,10 @@
+/**
+ * replay 命中但 inputHash 不一致时的 run 级错误。ask、世界读取、报告、产物四条 replay 路径共用它。
+ *
+ * 原本住在 scheduler.ts；dwf-report-limit 与 dwf-model-selection 合并后 scheduler.ts 到了 402 行
+ * （oxlint max-lines 上限 400），而这个构造器本就不属于 ask 调度，于是拆出来。
+ */
+import { WorkflowError, type InstanceRef } from "./types.js";
+/** replay 命中但 inputHash 不一致——纯度契约被破坏，run 大声失败。 */
+export declare function hashMismatch(instance: InstanceRef, expected: string, got: string): WorkflowError;
+//# sourceMappingURL=hash-mismatch.d.ts.map

package/vendor/dynamic-workflow/engine/hash-mismatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-mismatch.d.ts","sourceRoot":"","sources":["../../src/engine/hash-mismatch.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAe,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAE1E,kDAAkD;AAClD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAShG"}

package/vendor/dynamic-workflow/engine/hash-mismatch.js

@@ -0,0 +1,15 @@
+/**
+ * replay 命中但 inputHash 不一致时的 run 级错误。ask、世界读取、报告、产物四条 replay 路径共用它。
+ *
+ * 原本住在 scheduler.ts；dwf-report-limit 与 dwf-model-selection 合并后 scheduler.ts 到了 402 行
+ * （oxlint max-lines 上限 400），而这个构造器本就不属于 ask 调度，于是拆出来。
+ */
+import { refToString, WorkflowError } from "./types.js";
+/** replay 命中但 inputHash 不一致——纯度契约被破坏，run 大声失败。 */
+export function hashMismatch(instance, expected, got) {
+    return new WorkflowError("InputHashMismatch", `Replay hit at ${refToString(instance)} but inputHash differs (expected ${expected}, got ` +
+        `${got}): the script is not deterministic, so the journal cannot be replayed.`, 
+    // 结构化 mismatch 与 ScriptHashMismatch 对齐：两个哈希不一致错误共用同一个字段，
+    // 读端不必再从 message 文本里抠哈希。
+    { mismatch: { expected, got } });
+}

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

@@ -0,0 +1,16 @@
+/**
+ * 包内自带的确定性哈希：FNV-1a（32 位）作用在规范化 JSON 上。
+ * 不用 node:crypto——src/ 保持纯净可移植，哈希只作为 replay 时的防御性一致性校验
+ * （不是密码学用途，抗碰撞要求低，确定性与可移植才是重点）。
+ */
+/**
+ * 规范化 JSON 序列化：对象键按 code point 排序，从而对语义相同的值给出稳定字节序。
+ * 只覆盖 host 调用会用到的 JSON 值（string/number/boolean/null/array/plain object）。
+ * undefined / 函数等非 JSON 值不应出现在这条路径上；遇到时序列化为 "null" 以保持全函数性。
+ */
+export declare function canonicalJson(value: unknown): string;
+/** FNV-1a 32 位哈希，输出 8 位十六进制字符串。 */
+export declare function fnv1a(input: string): string;
+/** 计算一个 host 调用输入的防御性哈希：对规范化 JSON 取 FNV-1a。 */
+export declare function inputHash(value: unknown): string;
+//# sourceMappingURL=hash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/engine/hash.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAmBpD;AAED,mCAAmC;AACnC,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAW3C;AAED,+CAA+C;AAC/C,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEhD"}

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

@@ -0,0 +1,48 @@
+/**
+ * 包内自带的确定性哈希：FNV-1a（32 位）作用在规范化 JSON 上。
+ * 不用 node:crypto——src/ 保持纯净可移植，哈希只作为 replay 时的防御性一致性校验
+ * （不是密码学用途，抗碰撞要求低，确定性与可移植才是重点）。
+ */
+/**
+ * 规范化 JSON 序列化：对象键按 code point 排序，从而对语义相同的值给出稳定字节序。
+ * 只覆盖 host 调用会用到的 JSON 值（string/number/boolean/null/array/plain object）。
+ * undefined / 函数等非 JSON 值不应出现在这条路径上；遇到时序列化为 "null" 以保持全函数性。
+ */
+export function canonicalJson(value) {
+    if (value === null || typeof value !== "object") {
+        // 基本类型：交给 JSON.stringify（数字/布尔/字符串），undefined/函数回落为 null。
+        const s = JSON.stringify(value);
+        return s === undefined ? "null" : s;
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((v) => canonicalJson(v)).join(",")}]`;
+    }
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const parts = [];
+    for (const key of keys) {
+        const v = obj[key];
+        // 跳过 undefined 成员，与 JSON.stringify 对象语义一致。
+        if (v === undefined)
+            continue;
+        parts.push(`${JSON.stringify(key)}:${canonicalJson(v)}`);
+    }
+    return `{${parts.join(",")}}`;
+}
+/** FNV-1a 32 位哈希，输出 8 位十六进制字符串。 */
+export function fnv1a(input) {
+    // FNV offset basis / prime（32 位）。用 Math.imul 保证 32 位乘法回绕。
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        hash ^= input.charCodeAt(i) & 0xff;
+        // 高位字节也纳入，避免只哈希低字节丢失多字节字符的区分度。
+        hash ^= (input.charCodeAt(i) >> 8) & 0xff;
+        hash = Math.imul(hash, 0x01000193);
+    }
+    // 转无符号并补零到 8 位十六进制。
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}
+/** 计算一个 host 调用输入的防御性哈希：对规范化 JSON 取 FNV-1a。 */
+export function inputHash(value) {
+    return fnv1a(canonicalJson(value));
+}

package/vendor/dynamic-workflow/engine/imported-cache-types.d.ts

@@ -0,0 +1,96 @@
+import type { AskStats, NodeKind, PersonaSpec } from "./types.js";
+/**
+ * 一条可导入的已完结 ask：前驱 run 里某具名 actor 第 `actorSeq` 次问答的结果。
+ * 数组下标即 actorSeq（见 {@link ImportedActorCandidate.entries}），所以这里不存 seq。
+ */
+export interface ImportedAskEntry {
+    /** 前驱记录的 inputHash（对指令正文）。运行期与本次 ask 的哈希逐条比对，一致才命中。 */
+    inputHash: string;
+    result: unknown;
+    stats?: AskStats;
+    /**
+     * 该 ask 结算后源会话的消息数（{@link NodeRecord.messageBoundary}）。**必填**：
+     * run service 的「无 marker 前驱整体拒绝」门保证每条可导条目都带边界，所以引擎这边
+     * 不必有缺席分支——种子截断没有边界就无从谈起。
+     */
+    messageBoundary: number;
+}
+/**
+ * 前驱停下时**还在飞**的那一条 ask（`actorSeq === entries.length`，紧接前缀之后的 running 行）。
+ *
+ * 它没有结果可导入，导入的是**它已经跑出来的那段转录**：修订若在同一位置重发同一条指令
+ * （`inputHash` 相符），新会话就从这里接着跑，而不是把那半场对话扔掉重来
+ * （见 `docs/execution-engine.md`「How the engine consumes the cache」）。
+ */
+export interface ImportedInFlightAsk {
+    /** 前驱记录的 inputHash（对指令正文）。与本次 ask 的哈希相符才谈得上续跑。 */
+    inputHash: string;
+    /**
+     * 前驱**整个已结算会话**的消息数（不是某一条 ask 的记账边界——未完结的 ask 没有边界可记）。
+     * 它既含前缀那些完整交换，也含这半场未完的问答，正是续跑要接上的位置。
+     */
+    messageBoundary: number;
+}
+/**
+ * 前驱 run 里一个具名 actor 的可导入前缀。由 run service 从前驱 journal 构建（纯确定，可重建）。
+ */
+export interface ImportedActorCandidate {
+    /** 前驱记录的规范化 persona——运行期 createActor 比对用（不一致即弃该候选）。 */
+    persona: PersonaSpec;
+    /**
+     * 最长全 completed ask 前缀，按 actorSeq 0..n-1 索引。**可以为空**：带 {@link inFlight} 的候选
+     * 常常一条都没做完（扇出第一轮在飞时被修订，正是这个形状）。
+     */
+    entries: ImportedAskEntry[];
+    /**
+     * 前驱停下时还在飞的那条 ask（若有）。只在转录源就是前驱自己那一行时导入——那半场对话只
+     * 存在于前驱的会话里，从更早祖先解析出的源只有完整前缀。
+     */
+    inFlight?: ImportedInFlightAsk;
+    /**
+     * 经 `resumed_from` 链解析出的转录源会话 id。service 保证在场——链上没有任何祖先
+     * 持有该 actor 会话的候选在 service 侧就已弃置（降级为全新 actor），所以这里不是可选。
+     */
+    transcriptSourceSessionId: string;
+    /**
+     * 前驱解析出的模型 pin，随种子带给 driver。**仅当真的导入了转录时生效**：一条也没命中的
+     * actor 走全新解析、不带 pin（见 scheduler 的 ensureSession）。
+     */
+    resolvedModel?: string;
+}
+/** 一条可导入的世界节点（world-read / world-run），按内容 + 出现序匹配。 */
+export interface ImportedWorldEntry {
+    inputHash: string;
+    kind: NodeKind;
+    result: unknown;
+}
+/**
+ * 注入引擎的导入缓存（amend-resume 的加速结构）。**纯数据**：引擎保持零 I/O，这张表由
+ * run service 读前驱 journal 构建。
+ * 它不是真相源——每次命中都落一行真 dwf_node，丢了可从 `resumed_from` 重建。
+ */
+export interface ImportedRunCache {
+    /** 键 = 有效 actor 名（前驱内唯一且非空的那些）。 */
+    actors: ReadonlyMap<string, ImportedActorCandidate>;
+    /**
+     * 键 = `inputHash({op, args})`；值 = 按前驱 listNodes 插入序排好的队列——同一个
+     * `{op,args}` 的第 n 次出现对第 n 条记录，队列头即下一次命中。
+     */
+    world: ReadonlyMap<string, ImportedWorldEntry[]>;
+}
+/**
+ * 会话种子：分歧 actor 首次 live 派发时交给 {@link WorkflowDriver.createActorSession}，
+ * 让新会话以源会话的**全保真转录前缀**开场（spec 的「转录截断」行）。
+ */
+export interface ActorSessionSeed {
+    /** 转录来源会话（前驱或更早祖先的该名 actor 会话）。 */
+    sourceSessionId: string;
+    /**
+     * 复制源会话前多少条消息 = 最后一条被消费导入 ask 的 {@link NodeRecord.messageBoundary}。
+     * count offset 跨前缀复制不变，所以这个值在链上任何持会话祖先处都直接可用。
+     */
+    messageCount: number;
+    /** 承袭的模型 pin（转录接续下静默换模型正是 pin 要防的身份突变）。 */
+    resolvedModel?: string;
+}
+//# sourceMappingURL=imported-cache-types.d.ts.map

package/vendor/dynamic-workflow/engine/imported-cache-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imported-cache-types.d.ts","sourceRoot":"","sources":["../../src/engine/imported-cache-types.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAElE;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,uDAAuD;IACvD,OAAO,EAAE,WAAW,CAAC;IACrB;;;OAGG;IACH,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,EAAE,mBAAmB,CAAC;IAC/B;;;OAGG;IACH,yBAAyB,EAAE,MAAM,CAAC;IAClC;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,sDAAsD;AACtD,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,mCAAmC;IACnC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;IACpD;;;OAGG;IACH,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAAC;CAClD;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,mCAAmC;IACnC,eAAe,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,2CAA2C;IAC3C,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB"}

package/vendor/dynamic-workflow/engine/imported-cache-types.js

@@ -0,0 +1,6 @@
+// ============================================================
+// amend-resume 的导入缓存
+// ============================================================
+// 从 engine/types.ts 拆出（该文件已到 oxlint max-lines 上限）：纯数据结构，run service 读前驱
+// journal 构建，引擎只查表。
+export {};

package/vendor/dynamic-workflow/engine/imported-cache.d.ts

@@ -0,0 +1,127 @@
+/**
+ * amend-resume 导入缓存的**消费态**。
+ *
+ * 注入的 {@link ImportedRunCache} 是调用方构建的只读数据——run service 读前驱 journal 得到它，
+ * 崩溃后 resume 用同一个纯函数重建同一张表。所以「消费到哪了」不能就地写回那张表，必须是引擎
+ * 自己的状态：本模块就是这份状态，以及围绕它的全部判定（命中 / 分歧 / 种子）。
+ *
+ * 从 scheduler.ts 与 engine.ts 拆出来，理由同当初 scheduler 从 engine 拆出来：三个文件各自
+ * 聚焦、可读，且满足单文件行数上限。
+ */
+import type { ActorRef, ActorSessionSeed, ImportedActorCandidate, ImportedAskEntry, ImportedRunCache, ImportedWorldEntry, InstanceRef, NodeRecord, PersonaSpec } from "./types.js";
+/**
+ * 一个已附着候选的 actor 的导入消费态：消费游标 + 分歧标志。
+ *
+ * **分歧单调**：`diverged` 一旦为真永不回头查缓存，导入后缀弃置不可复活。
+ */
+export declare class ImportedActorState {
+    private readonly candidate;
+    /** 已消费的导入条目数 = 下一个可命中的 actorSeq（也是转录截断边界的下标 + 1）。 */
+    private consumed;
+    private diverged;
+    /**
+     * 「续跑前驱在飞 ask」的那个 seq（没有续跑即缺席）。至多一个：续跑本身就是分歧，
+     * 分歧单调，所以第二次不会再有。
+     */
+    private carriedSeq?;
+    constructor(candidate: ImportedActorCandidate);
+    /**
+     * fresh ask 在 seq 上问缓存：命中返回条目（并推进游标），否则置分歧并返回 undefined。
+     *
+     * 两种不命中同等处理：哈希不符（指令变了）与 `seq >= entries.length`（新脚本在此 actor 上
+     * 扩了新 ask）。分歧的**级联**是免费且动态的——上游 ask 转 live 拿到新结果，下游用它插值出的
+     * 指令哈希必变，于是下游自动分歧，不需要任何显式传播。
+     *
+     * 本方法只在导入缓存**开着**时被调用（关门后走 {@link takeIfPure}），所以未命中时可以谈续跑。
+     */
+    take(seq: number, hash: string): ImportedAskEntry | undefined;
+    /**
+     * 缓存关闭后的问法：只有**纯**条目（前驱记下 `worldToolCalls === 0`）还能命中。纯 ask 只依赖指令与
+     * 转录前缀——两者都在哈希链里——与工作区无关，所以关门不影响它的答案。碰过外部世界的条目即便同哈希
+     * 也不给：它读过的工作区可能已被改写；这个 ask 转 live，actor 从此分歧（转录不再与前驱一致，
+     * 后缀条目不可复活）。没有 stats、或 stats 里没有这个键的老条目按「碰过」处理（保守）。
+     *
+     * 关门后同样不续跑在飞 ask：那半场转录里全是前驱对**旧工作区**的观察，与带工具的条目同理。
+     */
+    takeIfPure(seq: number, hash: string): ImportedAskEntry | undefined;
+    /**
+     * 该 seq 的 ask 的答案是否**读自前驱的转录**：是则返回持有它的会话，否则 undefined。
+     *
+     * 成立当且仅当此刻仍未分歧、且游标已越过该 seq——分歧单调、准入按 seq 升序，所以这恰好是
+     * 「这一条被导入消费了」。两条路径各在判定之后立刻问：fresh ask 在 {@link take} 命中之后，
+     * 修订 run 的 resume 在 {@link reconcileRecorded} 之后（结算次序闸可能把事件推迟到同一个
+     * actor 更后的行已经置了分歧的时候，那时再问就会把一条导入行说成本 run 自己跑的）。
+     */
+    sourceSessionAt(seq: number): string | undefined;
+    /** 该 seq 的 ask 是否续跑了前驱的在飞 ask（调度器据此决定 stats 记不记 worldToolCalls）。 */
+    carriedAt(seq: number): boolean;
+    /**
+     * 据一行**已记录**的 ask 重推分歧状态（修订 run 崩溃后 resume 时用）。
+     *
+     * 分歧状态不落库，而修订 run 的 resume 会把导入缓存整表重建。若不据 journal 行重推分歧点，
+     * 一个在原次执行中已于 seq k 分歧的 actor，其 seq k+n 的 fresh ask 可能恰好撞上导入条目的
+     * 哈希而被**错误导入**——那等于把一段与本 run 实际转录无关的历史塞回来。逐 seq 拿记录行的
+     * inputHash 与导入条目比对，恰好重建了原次执行当时的判定（准入按 seq 升序，hold 规则保证
+     * 这一点），因此这个重推是精确的，不是保守近似。`wasLive` 补上哈希看不见的那一种 live
+     * （缓存关闭后带工具的 ask，见 scheduler 的 tryImportedSettle）。
+     *
+     * `queuedBeforeClose` 是续跑判定的那一半事实：续跑与该 ask 的 `node-queued` 在准入的同一个
+     * 同步片里发生，所以「当时门开着」等价于「这条 node-queued 早于第一条 import-cache-closed」
+     * （见 engine-world.ts 的 recoverImportClosure）。必须精确——错判成续跑会让 seedActorTranscript
+     * 往一个**已经分歧**的会话里多抄一段前驱消息（driver 的幂等判据只看目标够不够长）。
+     */
+    reconcileRecorded(seq: number, recordedHash: string, wasLive: boolean, queuedBeforeClose: boolean): void;
+    /**
+     * 分歧 actor 的会话种子：源会话 + 复制多少条消息 + 承袭的模型 pin。
+     *
+     * 边界取**最后一条被消费**的导入条目的记账值：在 seq k 分歧意味着 0..k-1 的问答都已按缓存
+     * 结算，新会话要接着的正是那 k 次完整交换之后的位置（含它们的 repair / nudge 轮）。
+     * 一条也没消费就没有种子——全新会话、全新模型解析、不带 pin：pin 是为「转录接续下不静默
+     * 换模型」存在的，没有接续就没有它的用武之地。
+     *
+     * **续跑是例外**：边界改取 `inFlight.messageBoundary`（前驱整个会话），因此一条都没消费也有
+     * 种子——那正是「扇出第一轮在飞时被修订」的形状。
+     */
+    seed(): ActorSessionSeed | undefined;
+    /**
+     * 置分歧，并在此顺带判定这次未命中是不是**续跑前驱的在飞 ask**。
+     *
+     * 续跑的四个条件缺一不可：此前未分歧（否则本 actor 的转录早已不是前驱那条）、`seq` 恰在
+     * 前缀之后（在飞 ask 的位置）、整个前缀都已消费、指令哈希与在飞 ask 相符。`cacheOpen`
+     * 是第五个：关门之后那半场转录只是对旧工作区的观察，不比缓存的 world 读取更可信。
+     */
+    private diverge;
+    private seedAt;
+}
+/**
+ * world 节点的导入队列消费态：每个内容哈希一个游标（第 n 次出现对第 n 条记录）。
+ * 与 {@link ImportedActorState} 同理，游标是引擎的状态，注入的队列保持只读。
+ */
+export declare class ImportedWorldQueue {
+    private readonly world;
+    private readonly cursors;
+    constructor(world: ReadonlyMap<string, ImportedWorldEntry[]>);
+    /** 取该内容哈希的下一条记录，耗尽或从未记录即 undefined（调用方转 live）。 */
+    take(hash: string): ImportedWorldEntry | undefined;
+}
+/**
+ * 为一个刚建出的 actor 找导入候选：按**有效名**查表，规范化 persona 一致才收。
+ *
+ * persona 比对用 `canonicalJson`——它跳过 undefined 成员、对象键排序，恰好就是要的规范化
+ * （`{name:"a"}` 与 `{name:"a", system: undefined}` 同值）。不一致即**弃整个候选**，该 actor
+ * 全新重跑：全保真转录下这是双重正确的——旧 system prompt 产的转录接新 persona 是身份错乱，
+ * 而「我把 persona 修好了」这个意图本来就是要重跑。
+ *
+ * 匿名 actor 永不附着：名字是缓存身份键，没有名字就没有可比对的坐标（代价已裁决）。
+ * 比对之所以在**运行期**而不是提交时静态比对两份脚本：名字与 persona 都是运行期值
+ * （`agent()` 的实参可以是动态表达式），静态比对是第二份真相，恰是本包处处要防的。
+ */
+export declare function matchImportedActor(cache: ImportedRunCache | undefined, spec: PersonaSpec): ImportedActorState | undefined;
+/**
+ * 一次 ask 缓存命中要落的**真** dwf_node 行（新 siteId、拷贝 result / stats / 边界）。
+ *
+ * 边界值必须一起拷过去，否则**这个** run 自己就不能再被修订——链式修订靠的正是 count offset
+ * 跨前缀复制不变。
+ */
+export declare function importedAskRecord(runId: string, instance: InstanceRef, actor: ActorRef, seq: number, hash: string, entry: ImportedAskEntry): NodeRecord;
+//# sourceMappingURL=imported-cache.d.ts.map

package/vendor/dynamic-workflow/engine/imported-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imported-cache.d.ts","sourceRoot":"","sources":["../../src/engine/imported-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EACV,QAAQ,EACR,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,WAAW,EACX,UAAU,EACV,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB;;;;GAIG;AACH,qBAAa,kBAAkB;IAUjB,OAAO,CAAC,QAAQ,CAAC,SAAS;IATtC,qDAAqD;IACrD,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAS;IACzB;;;OAGG;IACH,OAAO,CAAC,UAAU,CAAC,CAAS;gBAEC,SAAS,EAAE,sBAAsB;IAE9D;;;;;;;;OAQG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAW7D;;;;;;;OAOG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAWnE;;;;;;;OAOG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAMhD,oEAAoE;IACpE,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI/B;;;;;;;;;;;;;;OAcG;IACH,iBAAiB,CACf,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,EAChB,iBAAiB,EAAE,OAAO,GACzB,IAAI;IAmBP;;;;;;;;;;OAUG;IACH,IAAI,IAAI,gBAAgB,GAAG,SAAS;IAWpC;;;;;;OAMG;IACH,OAAO,CAAC,OAAO;IAcf,OAAO,CAAC,MAAM;CAQf;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAGjB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFlC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;gBAExB,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAE7E,kDAAkD;IAClD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;CASnD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,gBAAgB,GAAG,SAAS,EACnC,IAAI,EAAE,WAAW,GAChB,kBAAkB,GAAG,SAAS,CAUhC;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,WAAW,EACrB,KAAK,EAAE,QAAQ,EACf,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,gBAAgB,GACtB,UAAU,CAgBZ"}