@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.0

package/vendor/dynamic-workflow/testing/journal-contract-nodes.js

@@ -0,0 +1,234 @@
+/**
+ * 修复原因：journal-contract.ts 顶到 oxlint max-lines 上限（400 行），把actor 记录与节点记录（ask / world / report 行、缺席键、messageBoundary 回填）的用例拆到本文件；
+ * 公开面仍从 journal-contract.ts 导出（`runJournalStoreContract` 按原顺序调用各主题的注册函数）。
+ *
+ * 注意：这里只登记 `it(...)`，不另开 describe——套件的分组与用例顺序必须与拆分前逐字相同。
+ */
+import { expect, it } from "vitest";
+import { baseRun } from "./journal-contract-helpers.js";
+export function registerNodeCases(factory) {
+    it("puts, gets and lists actors keyed by (siteId, ordinal)", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        store.putActor({ runId: "r1", siteId: "actor#1", ordinal: 1, name: "planner" });
+        store.putActor({ runId: "r1", siteId: "actor#1", ordinal: 2, name: "planner" });
+        expect(store.getActor("r1", "actor#1", 1)?.name).toBe("planner");
+        expect(store.getActor("r1", "actor#1", 3)).toBeUndefined();
+        expect(store.listActors("r1", { withPersona: true })).toHaveLength(2);
+        // 幂等覆盖：同键再写更新 sessionId。
+        store.putActor({
+            runId: "r1",
+            siteId: "actor#1",
+            ordinal: 1,
+            name: "planner",
+            sessionId: "s1",
+        });
+        expect(store.getActor("r1", "actor#1", 1)?.sessionId).toBe("s1");
+        expect(store.listActors("r1", { withPersona: true })).toHaveLength(2);
+    });
+    it("round-trips the frozen persona and the driver-resolved model on an actor", () => {
+        // persona 是冻结身份，resolvedModel 是宿主事实（子代理实际跑在哪个模型上）。两者分列存放：
+        // persona 是引擎在 createActor 时同步写下的，那一刻宿主还没造出会话、也就没有模型可记。
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const record = {
+            runId: "r1",
+            siteId: "actor#1",
+            ordinal: 1,
+            name: "judge",
+            persona: { name: "judge", system: "You judge." },
+            sessionId: "s1",
+            resolvedModel: "provider/small-model",
+        };
+        store.putActor(record);
+        expect(store.getActor("r1", "actor#1", 1)).toEqual(record);
+    });
+    it("keeps an absent resolvedModel absent (not a null / undefined key)", () => {
+        // 0021 之前的历史行与「宿主还没解析过」的行都走这条路径：缺席必须解成缺席的键，
+        // 否则对整条记录做 toEqual 的调用方（与上一条用例）在升级后全线失败。
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        store.putActor({ runId: "r1", siteId: "actor#1", ordinal: 1, name: "judge" });
+        const record = store.getActor("r1", "actor#1", 1);
+        expect(record.resolvedModel).toBeUndefined();
+        expect(record).toEqual({ runId: "r1", siteId: "actor#1", ordinal: 1, name: "judge" });
+    });
+    it("puts, gets and lists nodes", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const node = {
+            runId: "r1",
+            siteId: "ask#1",
+            ordinal: 1,
+            kind: "ask",
+            actorSiteId: "actor#1",
+            actorOrdinal: 1,
+            actorSeq: 0,
+            inputHash: "abc",
+            status: "completed",
+            result: { ok: true },
+        };
+        store.putNode(node);
+        expect(store.getNode("r1", "ask#1", 1)).toEqual(node);
+        expect(store.getNode("r1", "ask#1", 2)).toBeUndefined();
+        expect(store.listNodes("r1", { kinds: "all", withResult: true })).toHaveLength(1);
+    });
+    it("round-trips a world-read node's bounded input and keeps it absent elsewhere", () => {
+        // 工作区 transcript 要说 *what ran*（docs/dynamic-workflow/transcript-and-notifications.md）：
+        // `{op, args}` 与 inputHash 同一次准入写下，结算的整条替换必须原样带回；ask 行没有它，
+        // 而且是**缺席的键**（不是 undefined 值），否则 toEqual 与读面的 `"input" in row` 都会说谎。
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const node = {
+            runId: "r1",
+            siteId: "world-read#1",
+            ordinal: 1,
+            kind: "world-run",
+            inputHash: "wh",
+            input: { op: "run", args: ["pnpm", ["vitest", "run"], { timeoutMs: 60_000 }] },
+            status: "running",
+        };
+        store.putNode(node);
+        expect(store.getNode("r1", "world-read#1", 1)).toEqual(node);
+        const settled = {
+            ...node,
+            status: "completed",
+            result: { exitCode: 1, stdout: "", stderr: "boom" },
+        };
+        store.putNode(settled);
+        expect(store.getNode("r1", "world-read#1", 1)).toEqual(settled);
+        const truncated = {
+            ...node,
+            siteId: "world-read#2",
+            input: { op: "run", args: ["node", "-e …"], truncated: true },
+        };
+        store.putNode(truncated);
+        expect(store.getNode("r1", "world-read#2", 1)?.input).toEqual(truncated.input);
+        const ask = store.getNode("r1", "ask#1", 1);
+        expect(ask === undefined || !("input" in ask)).toBe(true);
+    });
+    it("stores a report node: one write, already completed, no actor coordinates", () => {
+        // report 节点是「准入 running → 结算」两次写规则唯一的例外（准入与结算之间没有 driver
+        // 调用）。落库形状因此是可断言的：单次 putNode、status 恒 completed、actor 三列缺席、
+        // result 即被报告的 item。两个实现都必须原样回读，否则 Results 面板与完成通知
+        // 会显示存储层的加工品。
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const report = {
+            runId: "r1",
+            siteId: "report#1",
+            ordinal: 2,
+            kind: "report",
+            inputHash: "rh",
+            status: "completed",
+            result: { finding: "duplicate impl", paths: ["a.ts", "b.ts"] },
+        };
+        store.putNode(report);
+        const stored = store.getNode("r1", "report#1", 2);
+        expect(stored).toEqual(report);
+        expect(stored !== undefined && "actorSeq" in stored).toBe(false);
+        expect(stored !== undefined && "actorSiteId" in stored).toBe(false);
+        expect(store.listNodes("r1", { kinds: "all", withResult: true }).filter((n) => n.kind === "report")).toHaveLength(1);
+    });
+    it("keeps a null node result distinguishable from an absent one", () => {
+        // result 的类型是 unknown：`ask<T | null>` 返回的 null 是真结果，不是"还没有结果"。
+        // 落库实现若把 undefined 和 null 一起压成 SQL NULL，这个区别会在 round-trip 里消失。
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const nulled = {
+            runId: "r1",
+            siteId: "ask#1",
+            ordinal: 1,
+            kind: "ask",
+            inputHash: "h",
+            status: "completed",
+            result: null,
+        };
+        const absent = {
+            runId: "r1",
+            siteId: "ask#2",
+            ordinal: 1,
+            kind: "ask",
+            inputHash: "h",
+            status: "running",
+        };
+        store.putNode(nulled);
+        store.putNode(absent);
+        expect(store.getNode("r1", "ask#1", 1)).toEqual(nulled);
+        const stored = store.getNode("r1", "ask#2", 1);
+        expect(stored).toEqual(absent);
+        // 缺席的可选字段要原样缺席地回来（而不是变成 result: null / result: undefined）。
+        expect(stored !== undefined && "result" in stored).toBe(false);
+    });
+    // messageBoundary 是 ask 结算后 actor 会话消息 log 的长度（count offset），driver 在
+    // settle 之后补写（docs/execution-engine.md「Amend-resume」）。属于契约：
+    // 它是修订续跑做全保真转录截断时唯一的截断依据，SQLite 若漏写这一列，前驱就成了
+    // 「无 marker 前驱」——整个 amend 被结构化拒绝。
+    it("round-trips an ask node's messageBoundary and keeps it absent when unrecorded", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const bounded = {
+            runId: "r1",
+            siteId: "ask#1",
+            ordinal: 1,
+            kind: "ask",
+            actorSiteId: "actor#1",
+            actorOrdinal: 1,
+            actorSeq: 0,
+            inputHash: "h1",
+            status: "completed",
+            result: "done",
+            stats: { tokens: 120, toolCalls: 2, turns: 3 },
+            messageBoundary: 9,
+        };
+        // 0 是合法边界（复制零条消息），必须与「没记过边界」可分辨——这正是缺席键语义
+        // 在这一列上的实际用处。
+        const zero = {
+            ...bounded,
+            siteId: "ask#2",
+            actorSeq: 1,
+            inputHash: "h2",
+            messageBoundary: 0,
+        };
+        const unrecorded = {
+            runId: "r1",
+            siteId: "ask#3",
+            ordinal: 1,
+            kind: "ask",
+            inputHash: "h3",
+            status: "running",
+        };
+        store.putNode(bounded);
+        store.putNode(zero);
+        store.putNode(unrecorded);
+        expect(store.getNode("r1", "ask#1", 1)).toEqual(bounded);
+        expect(store.getNode("r1", "ask#2", 1)?.messageBoundary).toBe(0);
+        const bare = store.getNode("r1", "ask#3", 1);
+        expect(bare).toEqual(unrecorded);
+        expect(bare !== undefined && "messageBoundary" in bare).toBe(false);
+    });
+    // driver 的补写形状：getNode 读回引擎刚落的结算行，原样铺开再补边界列。与 stats 回填
+    // 同族，所以同一条风险——putNode 是整条替换，实现若在 round-trip 里丢掉任何一列
+    // （result / stats / actor 三列 / inputHash），这次补写就会把它抹掉。
+    it("preserves every other field when backfilling messageBoundary read-modify-write", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const settled = {
+            runId: "r1",
+            siteId: "ask#1",
+            ordinal: 2,
+            kind: "ask",
+            actorSiteId: "actor#3",
+            actorOrdinal: 1,
+            actorSeq: 4,
+            inputHash: "abc",
+            status: "completed",
+            result: { verdict: "ship it", notes: [1, 2, 3] },
+            stats: { tokens: 512, toolCalls: 7, turns: 5 },
+        };
+        store.putNode(settled);
+        const recorded = store.getNode("r1", "ask#1", 2);
+        store.putNode({ ...recorded, messageBoundary: 14 });
+        expect(store.getNode("r1", "ask#1", 2)).toEqual({ ...settled, messageBoundary: 14 });
+    });
+}

package/vendor/dynamic-workflow/testing/journal-contract-reads.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 读面选项的契约用例（docs/execution-engine.md「Reading the journal」）：kinds / withResult /
+ * limit / maxResultBytes / countNodes / sumResultBytes / types / reportItems / 按名取子代理。两个实现（内存、SQLite）必须逐字同
+ * 语义——读者按这些选项把过滤下推到存储层，任何一侧偷偷退回「读全表」或给出不同的顺序，
+ * 冷回放与 GetWorkflowRun 就会在两种部署上归约出不同的状态。
+ *
+ * 注意：这里只登记 `it(...)`，不另开 describe（与兄弟模块同规）。
+ */
+import type { JournalStorePort } from "../engine/index.js";
+export declare function registerReadCases(factory: () => JournalStorePort): void;
+//# sourceMappingURL=journal-contract-reads.d.ts.map

package/vendor/dynamic-workflow/testing/journal-contract-reads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-contract-reads.d.ts","sourceRoot":"","sources":["../../src/testing/journal-contract-reads.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAwB,MAAM,oBAAoB,CAAC;AA6CjF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,gBAAgB,GAAG,IAAI,CAsQvE"}

package/vendor/dynamic-workflow/testing/journal-contract-reads.js

@@ -0,0 +1,281 @@
+/**
+ * 读面选项的契约用例（docs/execution-engine.md「Reading the journal」）：kinds / withResult /
+ * limit / maxResultBytes / countNodes / sumResultBytes / types / reportItems / 按名取子代理。两个实现（内存、SQLite）必须逐字同
+ * 语义——读者按这些选项把过滤下推到存储层，任何一侧偷偷退回「读全表」或给出不同的顺序，
+ * 冷回放与 GetWorkflowRun 就会在两种部署上归约出不同的状态。
+ *
+ * 注意：这里只登记 `it(...)`，不另开 describe（与兄弟模块同规）。
+ */
+import { expect, it } from "vitest";
+import { baseRun } from "./journal-contract-helpers.js";
+function node(siteId, kind, extra = {}) {
+    return {
+        runId: "r1",
+        siteId,
+        ordinal: 1,
+        kind,
+        inputHash: `h-${siteId}`,
+        status: "completed",
+        result: { of: siteId },
+        ...extra,
+    };
+}
+/** 一条 run：ask、report×3（第二条带标签）、world-read、artifact，按这个顺序落库。 */
+function seedNodes(store) {
+    store.createRun(baseRun("r1"));
+    store.putNode(node("ask#1", "ask", { actorSiteId: "actor#1", actorOrdinal: 1, actorSeq: 0 }));
+    store.putNode(node("report#1", "report"));
+    store.putNode(node("report#2", "report", { artifactId: "chart" }));
+    store.putNode(node("files.grep#1", "world-read", { input: { op: "grep", args: ["x"] } }));
+    store.putNode(node("report#3", "report"));
+    store.putNode(node("artifact#1", "artifact", { artifactId: "chart" }));
+}
+function report(siteId, item, artifactId) {
+    return {
+        type: "report",
+        instance: { siteId, ordinal: 1 },
+        item,
+        ...(artifactId === undefined ? {} : { artifactId }),
+    };
+}
+function reportItemOf(event) {
+    if (event.type !== "report")
+        throw new Error(`not a report: ${event.type}`);
+    return "item" in event ? { has: true, item: event.item } : { has: false };
+}
+export function registerReadCases(factory) {
+    it('filters nodes by kind in insertion order, and "all" / [] mean everything / nothing', () => {
+        const store = factory();
+        seedNodes(store);
+        const sites = (rows) => rows.map((row) => row.siteId);
+        expect(sites(store.listNodes("r1", { kinds: ["report"], withResult: true }))).toEqual([
+            "report#1",
+            "report#2",
+            "report#3",
+        ]);
+        expect(sites(store.listNodes("r1", { kinds: ["ask", "world-read"], withResult: true }))).toEqual(["ask#1", "files.grep#1"]);
+        expect(sites(store.listNodes("r1", { kinds: "all", withResult: true }))).toEqual([
+            "ask#1",
+            "report#1",
+            "report#2",
+            "files.grep#1",
+            "report#3",
+            "artifact#1",
+        ]);
+        expect(store.listNodes("r1", { kinds: [], withResult: true })).toEqual([]);
+        expect(store.listNodes("nope", { kinds: "all", withResult: true })).toEqual([]);
+    });
+    it("keeps a row's place when it is upserted again", () => {
+        // 准入 running → 结算 completed 是同一条 upsert：行的顺序（id）不能因为第二次写而挪到末尾，
+        // 否则「按插入顺序」对每个结算过的节点都是假话。
+        const store = factory();
+        seedNodes(store);
+        store.putNode(node("ask#1", "ask", { status: "failed", actorSiteId: "actor#1", actorOrdinal: 1 }));
+        const rows = store.listNodes("r1", { kinds: "all", withResult: false });
+        expect(rows[0]?.siteId).toBe("ask#1");
+        expect(rows[0]?.status).toBe("failed");
+    });
+    it("leaves result out without touching any other column when withResult is false", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const full = {
+            runId: "r1",
+            siteId: "ask#1",
+            ordinal: 1,
+            kind: "ask",
+            actorSiteId: "actor#1",
+            actorOrdinal: 1,
+            actorSeq: 0,
+            inputHash: "h",
+            status: "completed",
+            result: { big: "x".repeat(100) },
+            stats: { tokens: 12, toolCalls: 3, turns: 2 },
+            messageBoundary: 4,
+        };
+        store.putNode(full);
+        const { result: _result, ...rest } = full;
+        void _result;
+        const [slim] = store.listNodes("r1", { kinds: "all", withResult: false });
+        expect(slim).toEqual(rest);
+        expect(slim).not.toHaveProperty("result");
+        expect(store.getNode("r1", "ask#1", 1, { withResult: false })).toEqual(rest);
+        // 点查缺省读整行。
+        expect(store.getNode("r1", "ask#1", 1)).toEqual(full);
+        expect(store.getNode("r1", "ask#1", 1, { withResult: true })).toEqual(full);
+    });
+    it("keeps a null result as null when results are read", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        store.putNode(node("report#1", "report", { result: null }));
+        const [row] = store.listNodes("r1", { kinds: ["report"], withResult: true });
+        expect(row).toHaveProperty("result", null);
+    });
+    it("pages nodes with limit after the kind filter, in insertion order", () => {
+        const store = factory();
+        seedNodes(store);
+        const rows = store.listNodes("r1", { kinds: ["report"], withResult: true, limit: 2 });
+        expect(rows.map((row) => row.siteId)).toEqual(["report#1", "report#2"]);
+        expect(rows[1]?.result).toEqual({ of: "report#2" });
+        expect(store.listNodes("r1", { kinds: ["report"], withResult: true, limit: 0 })).toEqual([]);
+    });
+    it("counts nodes of one kind without listing them", () => {
+        const store = factory();
+        seedNodes(store);
+        expect(store.countNodes("r1", "report")).toBe(3);
+        expect(store.countNodes("r1", "ask")).toBe(1);
+        expect(store.countNodes("r1", "world-run")).toBe(0);
+        expect(store.countNodes("nope", "report")).toBe(0);
+    });
+    it("sums the UTF-8 bytes of one kind's results without listing them", () => {
+        // resume 靠它恢复报告的 run 级字节计数：两个实现必须用同一把尺——`JSON.stringify(result)`
+        // 的 UTF-8 字节（SQLite 侧就是 result_json 的长度），多字节字符按字节算，没有结果的行计 0。
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const bytes = (value) => new TextEncoder().encode(JSON.stringify(value)).length;
+        store.putNode(node("report#1", "report", { result: { text: "abc" } }));
+        store.putNode(node("report#2", "report", { result: "中文" }));
+        store.putNode(node("report#3", "report", { result: null }));
+        store.putNode(node("ask#1", "ask", { status: "running", result: undefined }));
+        expect(store.sumResultBytes("r1", "report")).toBe(bytes({ text: "abc" }) + bytes("中文") + bytes(null));
+        expect(store.sumResultBytes("r1", "ask")).toBe(0);
+        expect(store.sumResultBytes("r1", "world-run")).toBe(0);
+        expect(store.sumResultBytes("nope", "report")).toBe(0);
+    });
+    it("stops a node read before the row that would pass maxResultBytes, but always keeps the first", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const pad = "x".repeat(100);
+        for (let index = 1; index <= 4; index += 1) {
+            store.putNode(node(`report#${index}`, "report", { result: { index, pad } }));
+        }
+        const one = new TextEncoder().encode(JSON.stringify({ index: 1, pad })).length;
+        const sites = (maxResultBytes, limit) => store
+            .listNodes("r1", {
+            kinds: ["report"],
+            withResult: true,
+            maxResultBytes,
+            ...(limit === undefined ? {} : { limit }),
+        })
+            .map((row) => row.siteId);
+        // 两行半的预算放得下两行。
+        expect(sites(one * 2 + one / 2)).toEqual(["report#1", "report#2"]);
+        // 恰好两行也放得下（超过才收尾，等于不收）。
+        expect(sites(one * 2)).toEqual(["report#1", "report#2"]);
+        // 一行都放不下时第一行照样在：快照不会因为一条大报告而一条都不带。
+        expect(sites(1)).toEqual(["report#1"]);
+        // limit 与字节界同时生效，先到先停。
+        expect(sites(one * 10, 3)).toEqual(["report#1", "report#2", "report#3"]);
+        expect(store
+            .listNodes("r1", { kinds: ["report"], withResult: true, maxResultBytes: one * 2 })
+            .map((row) => row.result)).toEqual([
+            { index: 1, pad },
+            { index: 2, pad },
+        ]);
+    });
+    it("filters actors by name and leaves the persona out when asked", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        const persona = { name: "judge", system: "You judge." };
+        store.putActor({
+            runId: "r1",
+            siteId: "actor#1",
+            ordinal: 1,
+            name: "judge",
+            persona,
+            sessionId: "s1",
+        });
+        store.putActor({ runId: "r1", siteId: "actor#2", ordinal: 1, name: "scout", persona });
+        store.putActor({ runId: "r1", siteId: "actor#1", ordinal: 2, name: "judge", persona });
+        const judges = store.listActors("r1", { name: "judge", withPersona: false });
+        expect(judges.map((actor) => `${actor.siteId}@${actor.ordinal}`)).toEqual([
+            "actor#1@1",
+            "actor#1@2",
+        ]);
+        expect(judges[0]).toEqual({
+            runId: "r1",
+            siteId: "actor#1",
+            ordinal: 1,
+            name: "judge",
+            sessionId: "s1",
+        });
+        expect(judges[0]).not.toHaveProperty("persona");
+        expect(store.listActors("r1", { name: "nobody", withPersona: true })).toEqual([]);
+        const all = store.listActors("r1", { withPersona: true });
+        expect(all).toHaveLength(3);
+        expect(all[1]?.persona).toEqual(persona);
+    });
+    it("filters events by type in sequence order, before the cursor and the limit", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        store.appendEvent("r1", { type: "log", message: "a" }); // 0
+        store.appendEvent("r1", { type: "usage-updated", spentTokens: 1 }); // 1
+        store.appendEvent("r1", { type: "log", message: "b" }); // 2
+        store.appendEvent("r1", {
+            type: "import-cache-closed",
+            instance: { siteId: "ask#1", ordinal: 1 },
+            cause: "world-run",
+        }); // 3
+        store.appendEvent("r1", { type: "log", message: "c" }); // 4
+        const seqs = (opts) => store.listEvents("r1", opts).map((stored) => stored.sequence);
+        expect(seqs({ types: ["log"], reportItems: "all" })).toEqual([0, 2, 4]);
+        expect(seqs({ types: ["import-cache-closed", "log"], reportItems: "all" })).toEqual([
+            0, 2, 3, 4,
+        ]);
+        // limit 作用在过滤之后：前两条 log，而不是「前两条事件里的 log」。
+        expect(seqs({ types: ["log"], reportItems: "all", limit: 2 })).toEqual([0, 2]);
+        expect(seqs({ types: ["log"], reportItems: "all", afterSequence: 0, limit: 1 })).toEqual([2]);
+        expect(seqs({ types: [], reportItems: "all" })).toEqual([]);
+        expect(seqs({ types: "all", reportItems: "all" })).toEqual([0, 1, 2, 3, 4]);
+    });
+    it("strips the item from every report event after the Nth, keeping every other field", () => {
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        store.appendEvent("r1", report("report#1", { n: 1 })); // 0: rank 1
+        store.appendEvent("r1", { type: "log", message: "between" }); // 1
+        store.appendEvent("r1", report("report#1", null)); // 2: rank 2 — null 是合法 item
+        store.appendEvent("r1", report("report#2", { n: 3 }, "chart")); // 3: rank 3
+        store.appendEvent("r1", report("report#1", "four")); // 4: rank 4
+        const events = store.listEvents("r1", { types: "all", reportItems: { limit: 2 } });
+        expect(events.map((stored) => stored.sequence)).toEqual([0, 1, 2, 3, 4]);
+        expect(reportItemOf(events[0].event)).toEqual({ has: true, item: { n: 1 } });
+        expect(events[1].event).toEqual({ type: "log", message: "between" });
+        expect(reportItemOf(events[2].event)).toEqual({ has: true, item: null });
+        expect(reportItemOf(events[3].event)).toEqual({ has: false });
+        expect(events[3].event).toEqual({
+            type: "report",
+            instance: { siteId: "report#2", ordinal: 1 },
+            artifactId: "chart",
+        });
+        expect(reportItemOf(events[4].event)).toEqual({ has: false });
+        expect(events[4].timeCreated).toBeTypeOf("number");
+        const none = store.listEvents("r1", { types: ["report"], reportItems: { limit: 0 } });
+        expect(none.map((stored) => reportItemOf(stored.event).has)).toEqual([
+            false,
+            false,
+            false,
+            false,
+        ]);
+        const every = store.listEvents("r1", { types: ["report"], reportItems: "all" });
+        expect(every.map((stored) => reportItemOf(stored.event).has)).toEqual([true, true, true, true]);
+    });
+    it("ranks report events over the whole run, not over the page being read", () => {
+        // 「第几条报告」是 run 的事实：从 cursor 3 开始读，第 3 条报告仍然是第 3 条，
+        // 不会因为它是这一页的第一条就把 item 带回来。
+        const store = factory();
+        store.createRun(baseRun("r1"));
+        store.appendEvent("r1", report("report#1", 1)); // 0
+        store.appendEvent("r1", report("report#1", 2)); // 1
+        store.appendEvent("r1", { type: "log", message: "x" }); // 2
+        store.appendEvent("r1", report("report#1", 3)); // 3
+        store.appendEvent("r1", report("report#1", 4)); // 4
+        const page = store.listEvents("r1", {
+            types: ["report"],
+            reportItems: { limit: 2 },
+            afterSequence: 1,
+        });
+        expect(page.map((stored) => stored.sequence)).toEqual([3, 4]);
+        expect(page.map((stored) => reportItemOf(stored.event).has)).toEqual([false, false]);
+        const head = store.listEvents("r1", { types: ["report"], reportItems: { limit: 3 }, limit: 1 });
+        expect(head.map((stored) => reportItemOf(stored.event))).toEqual([{ has: true, item: 1 }]);
+    });
+}

package/vendor/dynamic-workflow/testing/journal-contract-runs.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 修复原因：journal-contract.ts 顶到 oxlint max-lines 上限（400 行），把run 记录（建 run / 结算袋 / 元数据列 / 用量）的用例拆到本文件；
+ * 公开面仍从 journal-contract.ts 导出（`runJournalStoreContract` 按原顺序调用各主题的注册函数）。
+ *
+ * 注意：这里只登记 `it(...)`，不另开 describe——套件的分组与用例顺序必须与拆分前逐字相同。
+ */
+import type { JournalStorePort } from "../engine/index.js";
+export declare function registerRunCases(factory: () => JournalStorePort): void;
+//# sourceMappingURL=journal-contract-runs.d.ts.map

package/vendor/dynamic-workflow/testing/journal-contract-runs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-contract-runs.d.ts","sourceRoot":"","sources":["../../src/testing/journal-contract-runs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG3D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,gBAAgB,GAAG,IAAI,CAyatE"}