akm-cli 0.6.1 → 0.7.0

package/dist/tests/bench/attribution.test.js

@@ -0,0 +1,996 @@
+/**
+ * Unit tests for per-asset attribution (spec §6.5).
+ *
+ * Coverage:
+ *   • `extractAssetLoads` — parses both events.jsonl event objects and
+ *     verifierStdout substrings (literal `akm show` and tool-call JSON).
+ *   • `computePerAssetAttribution` — counts pass/fail loads, computes pass
+ *     rate, sorts by load count then pass rate then ref.
+ *   • `runMaskedCorpus` — picks top-N, masks each asset from the source
+ *     fixture, computes marginal contribution. Cost accounting verified
+ *     against the injected runUtility callable. Source fixture is untouched.
+ *   • CLI `attribute --top` clamping when top exceeds asset count.
+ */
+import { describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import path from "node:path";
+import { runAttributeCli } from "./cli";
+import { computePerAssetAttribution, extractAssetLoads, runMaskedCorpus, } from "./metrics";
+import { renderAttributionTable } from "./report";
+import { benchMkdtemp, benchTmpRoot } from "./tmp";
+function makeRun(overrides = {}) {
+    return {
+        schemaVersion: 1,
+        taskId: "t",
+        arm: "akm",
+        seed: 0,
+        model: "m",
+        outcome: "pass",
+        tokens: { input: 0, output: 0 },
+        wallclockMs: 0,
+        trajectory: { correctAssetLoaded: null, feedbackRecorded: null },
+        events: [],
+        verifierStdout: "",
+        verifierExitCode: 0,
+        assetsLoaded: [],
+        ...overrides,
+    };
+}
+function makeReport(akmRuns) {
+    return {
+        timestamp: "2026-04-27T00:00:00Z",
+        branch: "test",
+        commit: "abc",
+        model: "m",
+        corpus: { domains: 1, tasks: 1, slice: "all", seedsPerArm: akmRuns.length },
+        aggregateNoakm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+        aggregateAkm: {
+            passRate: akmRuns.filter((r) => r.outcome === "pass").length / Math.max(1, akmRuns.length),
+            tokensPerPass: null,
+            tokensPerRun: null,
+            wallclockMs: 0,
+        },
+        aggregateDelta: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+        trajectoryAkm: { correctAssetLoaded: null, feedbackRecorded: 0 },
+        failureModes: { byLabel: {}, byTask: {} },
+        tasks: [],
+        warnings: [],
+        akmRuns,
+    };
+}
+describe("extractAssetLoads", () => {
+    test("parses literal `akm show <ref>` from verifierStdout", () => {
+        const r = makeRun({ verifierStdout: "tool: akm show skill:docker-homelab\nresult: ok\n" });
+        expect(extractAssetLoads(r)).toEqual(["skill:docker-homelab"]);
+    });
+    test('parses tool-call JSON form `args:["show","<ref>"]`', () => {
+        const r = makeRun({
+            verifierStdout: '{"command":"akm","args":["show","skill:az-cli"]} done',
+        });
+        expect(extractAssetLoads(r)).toEqual(["skill:az-cli"]);
+    });
+    test("dedupes refs and preserves first-seen order", () => {
+        const r = makeRun({
+            verifierStdout: "akm show skill:foo\nakm show skill:bar\nakm show skill:foo\n",
+        });
+        expect(extractAssetLoads(r)).toEqual(["skill:foo", "skill:bar"]);
+    });
+    test("parses ref from events.jsonl `show` event", () => {
+        const r = makeRun({
+            events: [
+                {
+                    schemaVersion: 1,
+                    id: 0,
+                    ts: "2026-04-27T00:00:00Z",
+                    eventType: "show",
+                    ref: "skill:from-event",
+                },
+            ],
+        });
+        expect(extractAssetLoads(r)).toEqual(["skill:from-event"]);
+    });
+    test("merges events + stdout sources, dedupes across sources", () => {
+        const r = makeRun({
+            events: [
+                {
+                    schemaVersion: 1,
+                    id: 0,
+                    ts: "2026-04-27T00:00:00Z",
+                    eventType: "show",
+                    ref: "skill:shared",
+                },
+            ],
+            verifierStdout: "akm show skill:shared\nakm show skill:only-stdout\n",
+        });
+        expect(extractAssetLoads(r)).toEqual(["skill:shared", "skill:only-stdout"]);
+    });
+    test("returns empty array when no `akm show` invocations are present", () => {
+        const r = makeRun({ verifierStdout: "agent: I will not search\n" });
+        expect(extractAssetLoads(r)).toEqual([]);
+    });
+    test("supports origin-prefixed refs (`team//skill:foo`)", () => {
+        const r = makeRun({ verifierStdout: "akm show team//skill:foo\n" });
+        expect(extractAssetLoads(r)).toEqual(["team//skill:foo"]);
+    });
+});
+describe("computePerAssetAttribution", () => {
+    test("counts pass/fail loads and computes pass rate", () => {
+        const runs = [
+            // skill:a: 2 pass, 1 fail → 0.667
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:a"] }),
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:a"] }),
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:a"] }),
+            // skill:b: 0 pass, 2 fail → 0
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:b"] }),
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:b"] }),
+            // skill:c: 1 pass, 0 fail → 1.0
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:c"] }),
+        ];
+        const attr = computePerAssetAttribution(makeReport(runs));
+        expect(attr.totalAkmRuns).toBe(6);
+        const a = attr.rows.find((r) => r.assetRef === "skill:a");
+        expect(a).toMatchObject({ loadCount: 3, loadCountPassing: 2, loadCountFailing: 1 });
+        expect(a?.loadPassRate).toBeCloseTo(2 / 3, 5);
+        const b = attr.rows.find((r) => r.assetRef === "skill:b");
+        expect(b?.loadPassRate).toBe(0);
+        const c = attr.rows.find((r) => r.assetRef === "skill:c");
+        expect(c?.loadPassRate).toBe(1);
+    });
+    test("orders rows by load count desc, pass rate desc, ref asc", () => {
+        const runs = [
+            // skill:high-load-fail — 4 loads, all fail
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:high-load-fail"] }),
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:high-load-fail"] }),
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:high-load-fail"] }),
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:high-load-fail"] }),
+            // skill:high-load-pass — 4 loads, all pass (same count, higher pass_rate → first)
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:high-load-pass"] }),
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:high-load-pass"] }),
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:high-load-pass"] }),
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:high-load-pass"] }),
+            // skill:low-load — 1 load, pass
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:low-load"] }),
+        ];
+        const attr = computePerAssetAttribution(makeReport(runs));
+        expect(attr.rows.map((r) => r.assetRef)).toEqual([
+            "skill:high-load-pass", // count=4, rate=1
+            "skill:high-load-fail", // count=4, rate=0
+            "skill:low-load", // count=1
+        ]);
+    });
+    test("returns empty rows when no assets were loaded", () => {
+        const runs = [makeRun({ outcome: "pass", assetsLoaded: [] })];
+        const attr = computePerAssetAttribution(makeReport(runs));
+        expect(attr.rows).toEqual([]);
+        expect(attr.totalAkmRuns).toBe(1);
+    });
+});
+describe("renderAttributionTable", () => {
+    test("highlights well-used-and-working vs well-used-and-not-working", () => {
+        const attr = {
+            totalAkmRuns: 10,
+            rows: [
+                { assetRef: "skill:works", loadCount: 8, loadCountPassing: 7, loadCountFailing: 1, loadPassRate: 7 / 8 },
+                { assetRef: "skill:broken", loadCount: 6, loadCountPassing: 1, loadCountFailing: 5, loadPassRate: 1 / 6 },
+                { assetRef: "skill:rare", loadCount: 1, loadCountPassing: 1, loadCountFailing: 0, loadPassRate: 1 },
+            ],
+        };
+        const md = renderAttributionTable(attr);
+        expect(md).toContain("Well-used and working");
+        expect(md).toContain("`skill:works`");
+        expect(md).toContain("Well-used and NOT working");
+        expect(md).toContain("`skill:broken`");
+        // skill:rare is below the high-load cutoff so should NOT appear in the working callout (only in the table).
+        const workingSection = md.split("Well-used and working")[1]?.split("Well-used and NOT working")[0] ?? "";
+        expect(workingSection).not.toContain("`skill:rare`");
+    });
+    test("renders empty-state message when no rows", () => {
+        const md = renderAttributionTable({ totalAkmRuns: 0, rows: [] });
+        expect(md).toContain("No assets were loaded");
+    });
+});
+describe("runMaskedCorpus", () => {
+    function makeFixturesRoot() {
+        const root = benchMkdtemp("akm-bench-attr-fixtures-");
+        // fixture A: two assets in one .stash.json
+        const fixA = path.join(root, "fixtureA");
+        fs.mkdirSync(path.join(fixA, "skills"), { recursive: true });
+        fs.writeFileSync(path.join(fixA, "MANIFEST.json"), JSON.stringify({ name: "fixtureA", description: "x", purpose: "x", assets: { skill: 2 }, consumers: [] }));
+        fs.writeFileSync(path.join(fixA, "skills", ".stash.json"), JSON.stringify({
+            entries: [
+                { name: "alpha", type: "skill", filename: "alpha.md" },
+                { name: "beta", type: "skill", filename: "beta.md" },
+            ],
+        }));
+        fs.writeFileSync(path.join(fixA, "skills", "alpha.md"), "# alpha");
+        fs.writeFileSync(path.join(fixA, "skills", "beta.md"), "# beta");
+        return root;
+    }
+    function fakeTask(overrides = {}) {
+        return {
+            id: "fake/t",
+            title: "t",
+            domain: "fake",
+            difficulty: "easy",
+            stash: "fixtureA",
+            verifier: "regex",
+            expectedMatch: "ok",
+            budget: { tokens: 100, wallMs: 1000 },
+            taskDir: "/tmp",
+            ...overrides,
+        };
+    }
+    test("masks top-N assets, calls runUtility once per asset, leaves source fixture intact", async () => {
+        const fixturesRoot = makeFixturesRoot();
+        const sourceContents = fs.readFileSync(path.join(fixturesRoot, "fixtureA", "skills", "alpha.md"), "utf8");
+        const baseRuns = [
+            // alpha: 3 pass, 1 fail → load_count 4
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:alpha"] }),
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:alpha"] }),
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:alpha"] }),
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:alpha"] }),
+            // beta: 1 pass, 1 fail → load_count 2
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:beta"] }),
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:beta"] }),
+        ];
+        const baseReport = makeReport(baseRuns);
+        baseReport.taskMetadata = [fakeTask()];
+        let callCount = 0;
+        const seenStashDirs = [];
+        const seenStashFieldUnchanged = [];
+        const runUtility = async (options) => {
+            callCount += 1;
+            // Issue #251: masked re-runs receive the tmp dir through the explicit
+            // `stashDirOverride` field, NEVER by mutating `task.stash`. Assert
+            // both sides of the contract here.
+            const task = options.tasks[0];
+            seenStashDirs.push(task?.stashDirOverride ?? "");
+            seenStashFieldUnchanged.push(task?.stash === "fixtureA");
+            // Simulate that masking alpha drops the pass rate, masking beta does nothing.
+            const stashDir = task?.stashDirOverride ?? "";
+            const alphaMissing = !fs.existsSync(path.join(stashDir, "skills", "alpha.md"));
+            const passRate = alphaMissing ? 0.25 : 0.6;
+            return {
+                ...baseReport,
+                aggregateAkm: { passRate, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                akmRuns: [],
+            };
+        };
+        const result = await runMaskedCorpus({
+            baseReport,
+            topN: 5, // > 2 assets, should clamp
+            runUtility,
+            baseOptions: { arms: ["noakm", "akm"], model: "m", seedsPerArm: 1 },
+            fixturesRoot,
+        });
+        // Only 2 unique assets exist in the base report → topN clamped to 2.
+        expect(result.runsPerformed).toBe(2);
+        expect(callCount).toBe(2);
+        expect(result.attributions.length).toBe(2);
+        // Asset ranking: alpha first (load_count 4), beta second.
+        const alpha = result.attributions[0];
+        expect(alpha?.assetRef).toBe("skill:alpha");
+        expect(alpha?.basePassRate).toBeCloseTo(4 / 6, 5);
+        expect(alpha?.maskedPassRate).toBe(0.25);
+        expect(alpha?.marginalContribution).toBeCloseTo(4 / 6 - 0.25, 5);
+        const beta = result.attributions[1];
+        expect(beta?.assetRef).toBe("skill:beta");
+        expect(beta?.maskedPassRate).toBe(0.6);
+        // Source fixture content untouched.
+        const sourceContentsAfter = fs.readFileSync(path.join(fixturesRoot, "fixtureA", "skills", "alpha.md"), "utf8");
+        expect(sourceContentsAfter).toBe(sourceContents);
+        // Source .stash.json still has both entries.
+        const stashJsonAfter = JSON.parse(fs.readFileSync(path.join(fixturesRoot, "fixtureA", "skills", ".stash.json"), "utf8"));
+        expect(stashJsonAfter.entries.length).toBe(2);
+        // The two stash dirs the runner saw should be different tmp dirs (not the source).
+        expect(new Set(seenStashDirs).size).toBe(2);
+        for (const d of seenStashDirs) {
+            expect(d.startsWith(benchTmpRoot())).toBe(true);
+        }
+        // Issue #251: the original `task.stash` field was NEVER mutated.
+        expect(seenStashFieldUnchanged.every(Boolean)).toBe(true);
+        // The masking strategy + masked refs are surfaced on the result envelope.
+        expect(result.maskingStrategy).toBe("leave-one-out");
+        expect(result.maskedRefs).toEqual(["skill:alpha", "skill:beta"]);
+        fs.rmSync(fixturesRoot, { recursive: true, force: true });
+    });
+    test("issue #251: regression — runner uses stashDirOverride, NOT __no-stash__ placeholder", async () => {
+        // Bug under fix: when runMaskedCorpus mutated `task.stash` and called
+        // runUtility with `materialiseStash: false`, the runner was falling back
+        // to `path.join(task.taskDir, "__no-stash__")` for the AKM-arm stashDir,
+        // because the runner only consulted `task.stash` to call
+        // `loadFixtureStash` (which it skipped) — there was no path that
+        // forwarded the masked tmp dir to the agent.
+        //
+        // This test would FAIL before #251: the masked re-run would see the
+        // `__no-stash__` placeholder, `alpha.md` would never appear missing, and
+        // the marginal contribution would be 0 (false negative).
+        const fixturesRoot = makeFixturesRoot();
+        const baseRuns = [
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:alpha"] }),
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:alpha"] }),
+        ];
+        const baseReport = makeReport(baseRuns);
+        baseReport.taskMetadata = [fakeTask({ taskDir: "/some/task/dir" })];
+        let observedStashDir;
+        let observedExistedDuringRun = false;
+        let observedAlphaMissing = false;
+        let observedBetaPresent = false;
+        let observedTaskStashUnchanged = false;
+        const result = await runMaskedCorpus({
+            baseReport,
+            topN: 1,
+            runUtility: async (options) => {
+                const task = options.tasks[0];
+                observedStashDir = task?.stashDirOverride;
+                // The runner-equivalent resolution we are guarding: if the override
+                // is missing, the bug would have us fall back to `taskDir/__no-stash__`.
+                // Capture state INSIDE the runUtility callback because the tmp dir is
+                // reaped in `runMaskedCorpus`'s `finally` after this returns.
+                if (observedStashDir) {
+                    observedExistedDuringRun = fs.existsSync(observedStashDir);
+                    observedAlphaMissing = !fs.existsSync(path.join(observedStashDir, "skills", "alpha.md"));
+                    observedBetaPresent = fs.existsSync(path.join(observedStashDir, "skills", "beta.md"));
+                }
+                observedTaskStashUnchanged = task?.stash === "fixtureA";
+                return {
+                    ...baseReport,
+                    aggregateAkm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                    akmRuns: [],
+                };
+            },
+            baseOptions: { arms: ["akm"], model: "m", seedsPerArm: 1 },
+            fixturesRoot,
+        });
+        expect(result.runsPerformed).toBe(1);
+        // The override MUST be set — that is the whole fix.
+        expect(observedStashDir).toBeDefined();
+        // It must NOT be the `__no-stash__` placeholder the buggy fallback used.
+        expect(observedStashDir?.endsWith("__no-stash__")).toBe(false);
+        // While the run was active, the override pointed at a real tmp dir with
+        // the masked asset removed and the unmasked asset still present.
+        expect(observedExistedDuringRun).toBe(true);
+        expect(observedAlphaMissing).toBe(true);
+        expect(observedBetaPresent).toBe(true);
+        // The stash (fixture name) field was NEVER mutated.
+        expect(observedTaskStashUnchanged).toBe(true);
+        // After the run, the tmp dir is reaped (cleanup contract).
+        expect(observedStashDir && fs.existsSync(observedStashDir)).toBe(false);
+        fs.rmSync(fixturesRoot, { recursive: true, force: true });
+    });
+    test("issue #251: source fixture sentinel survives masked-corpus run", async () => {
+        // Sentinel-file smoke test (review addendum #251): plant a known file
+        // inside the source fixture stash, run a masked-corpus pass, then assert
+        // the sentinel is byte-identical. Guards against a recurrence of #243's
+        // operator-config-exposure pattern.
+        const fixturesRoot = makeFixturesRoot();
+        const sentinelPath = path.join(fixturesRoot, "fixtureA", "skills", "__sentinel_251__");
+        const sentinelBody = `do-not-touch-${Date.now()}`;
+        fs.writeFileSync(sentinelPath, sentinelBody);
+        const baseRuns = [
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:alpha"] }),
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:beta"] }),
+        ];
+        const baseReport = makeReport(baseRuns);
+        baseReport.taskMetadata = [fakeTask()];
+        await runMaskedCorpus({
+            baseReport,
+            topN: 2,
+            runUtility: async () => ({
+                ...baseReport,
+                aggregateAkm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                akmRuns: [],
+            }),
+            baseOptions: { arms: ["akm"], model: "m", seedsPerArm: 1 },
+            fixturesRoot,
+        });
+        // Sentinel survives unchanged.
+        expect(fs.existsSync(sentinelPath)).toBe(true);
+        expect(fs.readFileSync(sentinelPath, "utf8")).toBe(sentinelBody);
+        // The masked entry's source-fixture content is untouched.
+        expect(fs.existsSync(path.join(fixturesRoot, "fixtureA", "skills", "alpha.md"))).toBe(true);
+        expect(fs.readFileSync(path.join(fixturesRoot, "fixtureA", "skills", "alpha.md"), "utf8")).toBe("# alpha");
+        fs.rmSync(fixturesRoot, { recursive: true, force: true });
+    });
+    test("issue #251: tmp masked stash dirs are cleaned up after success AND failure", async () => {
+        // Cleanup contract from acceptance criteria: try/finally guarantees the
+        // tmp dirs are reaped whether the injected runner returns normally or
+        // throws. Capture observed dirs from inside the injected runner; after
+        // the await they must NOT exist.
+        const fixturesRoot = makeFixturesRoot();
+        const baseRuns = [
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:alpha"] }),
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:beta"] }),
+        ];
+        const baseReport = makeReport(baseRuns);
+        baseReport.taskMetadata = [fakeTask()];
+        // Success path.
+        const successDirs = [];
+        await runMaskedCorpus({
+            baseReport,
+            topN: 2,
+            runUtility: async (options) => {
+                const dir = options.tasks[0]?.stashDirOverride;
+                if (dir)
+                    successDirs.push(dir);
+                return {
+                    ...baseReport,
+                    aggregateAkm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                    akmRuns: [],
+                };
+            },
+            baseOptions: { arms: ["akm"], model: "m", seedsPerArm: 1 },
+            fixturesRoot,
+        });
+        expect(successDirs.length).toBe(2);
+        for (const d of successDirs) {
+            expect(fs.existsSync(d)).toBe(false);
+        }
+        // Failure path: the injected runner throws on the second call.
+        const failureDirs = [];
+        let calls = 0;
+        await expect(runMaskedCorpus({
+            baseReport,
+            topN: 2,
+            runUtility: async (options) => {
+                calls += 1;
+                const dir = options.tasks[0]?.stashDirOverride;
+                if (dir)
+                    failureDirs.push(dir);
+                if (calls === 2)
+                    throw new Error("simulated runner failure");
+                return {
+                    ...baseReport,
+                    aggregateAkm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                    akmRuns: [],
+                };
+            },
+            baseOptions: { arms: ["akm"], model: "m", seedsPerArm: 1 },
+            fixturesRoot,
+        })).rejects.toThrow("simulated runner failure");
+        // Both tmp dirs created so far are reaped (the second call's dir is
+        // created in the try-block before the throw, and the finally-block
+        // cleans it up).
+        for (const d of failureDirs) {
+            expect(fs.existsSync(d)).toBe(false);
+        }
+        fs.rmSync(fixturesRoot, { recursive: true, force: true });
+    });
+    test("rejects path-traversal asset refs without deleting anything outside the tmp stash", async () => {
+        const fixturesRoot = makeFixturesRoot();
+        // A sentinel file outside the fixtures tree — if the masker honoured the
+        // hostile `..`-laden ref, the deletion target would be computed via
+        // `path.join(fixturesRoot/fixtureA/skills/, "..", "..", "..", "sentinel")`
+        // and the sentinel would disappear. The validation must block that.
+        const sentinelDir = benchMkdtemp("akm-bench-sentinel-");
+        const sentinelFile = path.join(sentinelDir, "sentinel.txt");
+        fs.writeFileSync(sentinelFile, "do-not-delete");
+        const baseRuns = [
+            // Hostile ref: name contains `..` segments. Constructed by hand to
+            // simulate a prompt-injected agent emitting `akm show "skill:../../../etc"`.
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:../../../etc"] }),
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:../../../etc"] }),
+        ];
+        const baseReport = makeReport(baseRuns);
+        baseReport.taskMetadata = [fakeTask()];
+        let callCount = 0;
+        const result = await runMaskedCorpus({
+            baseReport,
+            topN: 1,
+            runUtility: async () => {
+                callCount += 1;
+                return {
+                    ...baseReport,
+                    aggregateAkm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                };
+            },
+            baseOptions: { arms: ["akm"], model: "m", seedsPerArm: 1 },
+            fixturesRoot,
+        });
+        // The masker rejects the hostile ref → null → runMaskedCorpus falls back
+        // to the original fixture name. The runner is still called (we want the
+        // accounting to be honest), but no rmSync is performed against any path
+        // resolved from the hostile name.
+        expect(result.runsPerformed).toBe(1);
+        expect(callCount).toBe(1);
+        // Sentinel survives.
+        expect(fs.existsSync(sentinelFile)).toBe(true);
+        expect(fs.readFileSync(sentinelFile, "utf8")).toBe("do-not-delete");
+        // Source fixture files survive.
+        expect(fs.existsSync(path.join(fixturesRoot, "fixtureA", "skills", "alpha.md"))).toBe(true);
+        expect(fs.existsSync(path.join(fixturesRoot, "fixtureA", "skills", "beta.md"))).toBe(true);
+        fs.rmSync(sentinelDir, { recursive: true, force: true });
+        fs.rmSync(fixturesRoot, { recursive: true, force: true });
+    });
+    test("rejects absolute-path asset refs without escaping the tmp stash", async () => {
+        const fixturesRoot = makeFixturesRoot();
+        const sentinelDir = benchMkdtemp("akm-bench-sentinel-abs-");
+        const sentinelFile = path.join(sentinelDir, "sentinel.txt");
+        fs.writeFileSync(sentinelFile, "do-not-delete");
+        const baseRuns = [
+            // Hostile ref: name is an absolute POSIX path.
+            makeRun({ outcome: "pass", assetsLoaded: [`skill:${sentinelDir}`] }),
+            makeRun({ outcome: "pass", assetsLoaded: [`skill:${sentinelDir}`] }),
+        ];
+        const baseReport = makeReport(baseRuns);
+        baseReport.taskMetadata = [fakeTask()];
+        let callCount = 0;
+        const result = await runMaskedCorpus({
+            baseReport,
+            topN: 1,
+            runUtility: async () => {
+                callCount += 1;
+                return {
+                    ...baseReport,
+                    aggregateAkm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                };
+            },
+            baseOptions: { arms: ["akm"], model: "m", seedsPerArm: 1 },
+            fixturesRoot,
+        });
+        expect(result.runsPerformed).toBe(1);
+        expect(callCount).toBe(1);
+        expect(fs.existsSync(sentinelFile)).toBe(true);
+        expect(fs.readFileSync(sentinelFile, "utf8")).toBe("do-not-delete");
+        expect(fs.existsSync(sentinelDir)).toBe(true);
+        fs.rmSync(sentinelDir, { recursive: true, force: true });
+        fs.rmSync(fixturesRoot, { recursive: true, force: true });
+    });
+    test("cost accounting: runs N times when N <= asset count", async () => {
+        const fixturesRoot = makeFixturesRoot();
+        const baseRuns = [
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:alpha"] }),
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:beta"] }),
+        ];
+        const baseReport = makeReport(baseRuns);
+        baseReport.taskMetadata = [fakeTask()];
+        let callCount = 0;
+        const result = await runMaskedCorpus({
+            baseReport,
+            topN: 1,
+            runUtility: async () => {
+                callCount += 1;
+                return {
+                    ...baseReport,
+                    aggregateAkm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                };
+            },
+            baseOptions: { arms: ["akm"], model: "m", seedsPerArm: 1 },
+            fixturesRoot,
+        });
+        expect(result.runsPerformed).toBe(1);
+        expect(callCount).toBe(1);
+        expect(result.attributions.length).toBe(1);
+        fs.rmSync(fixturesRoot, { recursive: true, force: true });
+    });
+});
+describe("bench attribute --top clamping", () => {
+    test("clamps --top when fewer assets exist", async () => {
+        // Write a §13.3 envelope to disk with only 2 perAsset rows.
+        const tmp = benchMkdtemp("akm-bench-attr-cli-");
+        const fixturesRoot = path.join(tmp, "stashes");
+        fs.mkdirSync(fixturesRoot, { recursive: true });
+        // Two-asset fixture so the masked re-runs find their assets to remove.
+        const fixDir = path.join(fixturesRoot, "tiny");
+        fs.mkdirSync(path.join(fixDir, "skills"), { recursive: true });
+        fs.writeFileSync(path.join(fixDir, "MANIFEST.json"), JSON.stringify({ name: "tiny", description: "x", purpose: "x", assets: { skill: 2 }, consumers: [] }));
+        fs.writeFileSync(path.join(fixDir, "skills", ".stash.json"), JSON.stringify({
+            entries: [
+                { name: "alpha", type: "skill", filename: "alpha.md" },
+                { name: "beta", type: "skill", filename: "beta.md" },
+            ],
+        }));
+        fs.writeFileSync(path.join(fixDir, "skills", "alpha.md"), "# alpha");
+        fs.writeFileSync(path.join(fixDir, "skills", "beta.md"), "# beta");
+        const envelope = {
+            schemaVersion: 1,
+            track: "utility",
+            branch: "test",
+            commit: "abc",
+            timestamp: "2026-04-27T00:00:00Z",
+            agent: { harness: "opencode", model: "test-model" },
+            corpus: { domains: 1, tasks: 1, slice: "all", seedsPerArm: 1 },
+            aggregate: {
+                noakm: { pass_rate: 0, tokens_per_pass: null, wallclock_ms: 0 },
+                akm: { pass_rate: 0.5, tokens_per_pass: null, wallclock_ms: 0 },
+                delta: { pass_rate: 0.5, tokens_per_pass: null, wallclock_ms: 0 },
+            },
+            trajectory: { akm: { correct_asset_loaded: null, feedback_recorded: 0 } },
+            tasks: [],
+            warnings: [],
+            perAsset: {
+                total_akm_runs: 4,
+                rows: [
+                    {
+                        asset_ref: "skill:alpha",
+                        load_count: 2,
+                        load_count_passing: 1,
+                        load_count_failing: 1,
+                        load_pass_rate: 0.5,
+                    },
+                    { asset_ref: "skill:beta", load_count: 1, load_count_passing: 1, load_count_failing: 0, load_pass_rate: 1 },
+                ],
+            },
+        };
+        const basePath = path.join(tmp, "run.json");
+        fs.writeFileSync(basePath, JSON.stringify(envelope));
+        let calls = 0;
+        const result = await runAttributeCli({
+            basePath,
+            topN: 5, // > 2 → clamp to 2
+            json: true,
+            runUtility: async () => {
+                calls += 1;
+                return {
+                    timestamp: "2026-04-27T00:00:00Z",
+                    branch: "test",
+                    commit: "abc",
+                    model: "test-model",
+                    corpus: { domains: 1, tasks: 0, slice: "all", seedsPerArm: 1 },
+                    aggregateNoakm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                    aggregateAkm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                    aggregateDelta: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                    trajectoryAkm: { correctAssetLoaded: null, feedbackRecorded: 0 },
+                    failureModes: { byLabel: {}, byTask: {} },
+                    tasks: [],
+                    warnings: [],
+                };
+            },
+            fixturesRoot,
+        });
+        expect(result.exitCode).toBe(0);
+        const json = JSON.parse(result.stdout);
+        expect(json.runsPerformed).toBe(2);
+        expect(json.maskingStrategy).toBe("leave-one-out");
+        expect(json.attributions.length).toBe(2);
+        expect(calls).toBe(2);
+        fs.rmSync(tmp, { recursive: true, force: true });
+    });
+});
+describe("runMaskedCorpus marginal_contribution arithmetic", () => {
+    // Distinct from the clamp test in `bench attribute --top clamping`, which
+    // uses passRate 0 for every masked re-run and so cannot detect a sign
+    // error in the marginal-contribution arithmetic. Here we engineer a base
+    // pass_rate of 0.8 and two distinct masked pass_rates (0.4 and 0.5) and
+    // assert the resulting marginal_contribution = base - masked, with the
+    // correct sign and magnitude per masked asset.
+    function makeMarginalFixturesRoot() {
+        const root = benchMkdtemp("akm-bench-attr-marginal-fixtures-");
+        const fixDir = path.join(root, "fixtureMarginal");
+        fs.mkdirSync(path.join(fixDir, "skills"), { recursive: true });
+        fs.writeFileSync(path.join(fixDir, "MANIFEST.json"), JSON.stringify({ name: "fixtureMarginal", description: "x", purpose: "x", assets: { skill: 2 }, consumers: [] }));
+        fs.writeFileSync(path.join(fixDir, "skills", ".stash.json"), JSON.stringify({
+            entries: [
+                { name: "alpha", type: "skill", filename: "alpha.md" },
+                { name: "beta", type: "skill", filename: "beta.md" },
+            ],
+        }));
+        fs.writeFileSync(path.join(fixDir, "skills", "alpha.md"), "# alpha");
+        fs.writeFileSync(path.join(fixDir, "skills", "beta.md"), "# beta");
+        return root;
+    }
+    test("computes marginal_contribution = basePassRate - maskedPassRate per asset", async () => {
+        const fixturesRoot = makeMarginalFixturesRoot();
+        const baseRuns = [
+            // alpha: 4 pass, 0 fail → load_count 4
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:alpha"] }),
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:alpha"] }),
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:alpha"] }),
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:alpha"] }),
+            // beta: 1 pass, 1 fail → load_count 2
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:beta"] }),
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:beta"] }),
+        ];
+        const baseReport = {
+            timestamp: "2026-04-27T00:00:00Z",
+            branch: "test",
+            commit: "abc",
+            model: "m",
+            corpus: { domains: 1, tasks: 1, slice: "all", seedsPerArm: baseRuns.length },
+            aggregateNoakm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+            // Engineered base pass rate distinct from the masked rates so the
+            // arithmetic is observable.
+            aggregateAkm: { passRate: 0.8, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+            aggregateDelta: { passRate: 0.8, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+            trajectoryAkm: { correctAssetLoaded: null, feedbackRecorded: 0 },
+            failureModes: { byLabel: {}, byTask: {} },
+            tasks: [],
+            warnings: [],
+            akmRuns: baseRuns,
+            taskMetadata: [
+                {
+                    id: "fake/t",
+                    title: "t",
+                    domain: "fake",
+                    difficulty: "easy",
+                    stash: "fixtureMarginal",
+                    verifier: "regex",
+                    expectedMatch: "ok",
+                    budget: { tokens: 100, wallMs: 1000 },
+                    taskDir: "/tmp",
+                },
+            ],
+        };
+        // Map masked-asset → simulated pass rate. The injected runner inspects
+        // the on-disk masked stash to detect which asset is missing.
+        const maskedPassRates = {
+            "skill:alpha": 0.4,
+            "skill:beta": 0.5,
+        };
+        const result = await runMaskedCorpus({
+            baseReport,
+            topN: 2,
+            runUtility: async (options) => {
+                // Issue #251: read the masked tmp dir from the explicit
+                // `stashDirOverride` field — the original `task.stash` (fixture
+                // name) is intentionally unchanged.
+                const stashDir = options.tasks[0]?.stashDirOverride ?? "";
+                const alphaMissing = !fs.existsSync(path.join(stashDir, "skills", "alpha.md"));
+                const betaMissing = !fs.existsSync(path.join(stashDir, "skills", "beta.md"));
+                const masked = alphaMissing ? "skill:alpha" : betaMissing ? "skill:beta" : "none";
+                const passRate = maskedPassRates[masked] ?? 0;
+                return {
+                    ...baseReport,
+                    aggregateAkm: { passRate, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                    akmRuns: [],
+                };
+            },
+            baseOptions: { arms: ["akm"], model: "m", seedsPerArm: 1 },
+            fixturesRoot,
+        });
+        expect(result.runsPerformed).toBe(2);
+        expect(result.attributions.length).toBe(2);
+        const alpha = result.attributions.find((a) => a.assetRef === "skill:alpha");
+        const beta = result.attributions.find((a) => a.assetRef === "skill:beta");
+        // Both rows carry the engineered base pass rate.
+        expect(alpha?.basePassRate).toBeCloseTo(0.8, 5);
+        expect(beta?.basePassRate).toBeCloseTo(0.8, 5);
+        // Masked pass rates are the runner-injected values, distinguished per
+        // asset (this is the property the vacuous 0 → 0 → 0 fixture above
+        // could not exercise).
+        expect(alpha?.maskedPassRate).toBeCloseTo(0.4, 5);
+        expect(beta?.maskedPassRate).toBeCloseTo(0.5, 5);
+        // Marginal contribution = base - masked. Positive sign means masking
+        // hurt — the asset was helping. Both must be non-zero.
+        expect(alpha?.marginalContribution).toBeCloseTo(0.4, 5);
+        expect(beta?.marginalContribution).toBeCloseTo(0.3, 5);
+        expect(alpha?.marginalContribution).not.toBe(0);
+        expect(beta?.marginalContribution).not.toBe(0);
+        fs.rmSync(fixturesRoot, { recursive: true, force: true });
+    });
+});
+// ── #249 round-trip: persisted runs[] → attribute → compute paths ──────────
+describe("bench attribute prefers persisted runs[] (#249)", () => {
+    test("hydrates persisted runs[] and feeds them to runMaskedCorpus", async () => {
+        const tmp = benchMkdtemp("akm-bench-attr-runs-");
+        const fixturesRoot = path.join(tmp, "stashes");
+        fs.mkdirSync(fixturesRoot, { recursive: true });
+        const fixDir = path.join(fixturesRoot, "tiny");
+        fs.mkdirSync(path.join(fixDir, "skills"), { recursive: true });
+        fs.writeFileSync(path.join(fixDir, "MANIFEST.json"), JSON.stringify({ name: "tiny", description: "x", purpose: "x", assets: { skill: 2 }, consumers: [] }));
+        fs.writeFileSync(path.join(fixDir, "skills", ".stash.json"), JSON.stringify({
+            entries: [
+                { name: "alpha", type: "skill", filename: "alpha.md" },
+                { name: "beta", type: "skill", filename: "beta.md" },
+            ],
+        }));
+        fs.writeFileSync(path.join(fixDir, "skills", "alpha.md"), "# alpha");
+        fs.writeFileSync(path.join(fixDir, "skills", "beta.md"), "# beta");
+        // Build a §13.3 envelope WITH a persisted runs[] array. The compact rows
+        // mirror what the runner would have emitted — both arms, multiple seeds.
+        const envelope = {
+            schemaVersion: 1,
+            track: "utility",
+            branch: "test",
+            commit: "abc",
+            timestamp: "2026-04-27T00:00:00Z",
+            agent: { harness: "opencode", model: "test-model" },
+            corpus: { domains: 1, tasks: 1, slice: "all", seedsPerArm: 2 },
+            aggregate: {
+                noakm: { pass_rate: 0, tokens_per_pass: null, wallclock_ms: 0 },
+                akm: { pass_rate: 0.5, tokens_per_pass: null, wallclock_ms: 0 },
+                delta: { pass_rate: 0.5, tokens_per_pass: null, wallclock_ms: 0 },
+            },
+            trajectory: { akm: { correct_asset_loaded: null, feedback_recorded: 0 } },
+            tasks: [],
+            warnings: [],
+            runs: [
+                // noakm — should be filtered out of attribution.
+                {
+                    task_id: "t",
+                    arm: "noakm",
+                    seed: 0,
+                    model: "test-model",
+                    outcome: "fail",
+                    tokens: { input: 0, output: 0 },
+                    wallclock_ms: 0,
+                    verifier_exit_code: 1,
+                    trajectory: { correct_asset_loaded: null, feedback_recorded: null },
+                    assets_loaded: [],
+                    failure_mode: null,
+                },
+                // akm — alpha:1pass+1fail, beta:1pass.
+                {
+                    task_id: "t",
+                    arm: "akm",
+                    seed: 0,
+                    model: "test-model",
+                    outcome: "pass",
+                    tokens: { input: 1, output: 2 },
+                    wallclock_ms: 100,
+                    verifier_exit_code: 0,
+                    trajectory: { correct_asset_loaded: true, feedback_recorded: false },
+                    assets_loaded: ["skill:alpha", "skill:beta"],
+                    failure_mode: null,
+                },
+                {
+                    task_id: "t",
+                    arm: "akm",
+                    seed: 1,
+                    model: "test-model",
+                    outcome: "fail",
+                    tokens: { input: 3, output: 4 },
+                    wallclock_ms: 110,
+                    verifier_exit_code: 1,
+                    trajectory: { correct_asset_loaded: false, feedback_recorded: false },
+                    assets_loaded: ["skill:alpha"],
+                    failure_mode: "wrong_asset",
+                },
+            ],
+            // perAsset is also present (older path) — but the persisted runs[]
+            // should take precedence.
+            perAsset: {
+                total_akm_runs: 2,
+                rows: [
+                    {
+                        asset_ref: "skill:alpha",
+                        load_count: 2,
+                        load_count_passing: 1,
+                        load_count_failing: 1,
+                        load_pass_rate: 0.5,
+                    },
+                    {
+                        asset_ref: "skill:beta",
+                        load_count: 1,
+                        load_count_passing: 1,
+                        load_count_failing: 0,
+                        load_pass_rate: 1,
+                    },
+                ],
+            },
+        };
+        const basePath = path.join(tmp, "run.json");
+        fs.writeFileSync(basePath, JSON.stringify(envelope));
+        let observedAkmAssetsLoaded = [];
+        const result = await runAttributeCli({
+            basePath,
+            topN: 2,
+            json: true,
+            runUtility: async (options) => {
+                // Capture the akmRuns the masked runner sees so we can prove the
+                // hydrated runs[] flowed through unchanged.
+                observedAkmAssetsLoaded = options.tasks.map((t) => [t.id]);
+                return {
+                    timestamp: "2026-04-27T00:00:00Z",
+                    branch: "test",
+                    commit: "abc",
+                    model: "test-model",
+                    corpus: { domains: 1, tasks: 1, slice: "all", seedsPerArm: 2 },
+                    aggregateNoakm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                    aggregateAkm: { passRate: 0.25, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                    aggregateDelta: { passRate: 0.25, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                    trajectoryAkm: { correctAssetLoaded: null, feedbackRecorded: 0 },
+                    failureModes: { byLabel: {}, byTask: {} },
+                    tasks: [],
+                    warnings: [],
+                };
+            },
+            fixturesRoot,
+        });
+        expect(result.exitCode).toBe(0);
+        const json = JSON.parse(result.stdout);
+        // 2 attributions = 2 distinct loaded assets, both came from the persisted
+        // runs[] (alpha + beta). The noakm row is excluded.
+        expect(json.attributions.length).toBe(2);
+        expect(observedAkmAssetsLoaded.length).toBeGreaterThan(0);
+        fs.rmSync(tmp, { recursive: true, force: true });
+    });
+    test("falls back to perAsset synthesis when runs[] is absent (legacy report)", async () => {
+        const tmp = benchMkdtemp("akm-bench-attr-legacy-");
+        const fixturesRoot = path.join(tmp, "stashes");
+        fs.mkdirSync(fixturesRoot, { recursive: true });
+        const fixDir = path.join(fixturesRoot, "tiny");
+        fs.mkdirSync(path.join(fixDir, "skills"), { recursive: true });
+        fs.writeFileSync(path.join(fixDir, "MANIFEST.json"), JSON.stringify({ name: "tiny", description: "x", purpose: "x", assets: { skill: 1 }, consumers: [] }));
+        fs.writeFileSync(path.join(fixDir, "skills", ".stash.json"), JSON.stringify({ entries: [{ name: "alpha", type: "skill", filename: "alpha.md" }] }));
+        fs.writeFileSync(path.join(fixDir, "skills", "alpha.md"), "# alpha");
+        // Legacy envelope: NO runs[] key.
+        const envelope = {
+            schemaVersion: 1,
+            track: "utility",
+            branch: "test",
+            commit: "abc",
+            timestamp: "2026-04-27T00:00:00Z",
+            agent: { harness: "opencode", model: "test-model" },
+            corpus: { domains: 1, tasks: 0, slice: "all", seedsPerArm: 1 },
+            aggregate: {
+                noakm: { pass_rate: 0, tokens_per_pass: null, wallclock_ms: 0 },
+                akm: { pass_rate: 0.5, tokens_per_pass: null, wallclock_ms: 0 },
+                delta: { pass_rate: 0.5, tokens_per_pass: null, wallclock_ms: 0 },
+            },
+            trajectory: { akm: { correct_asset_loaded: null, feedback_recorded: 0 } },
+            tasks: [],
+            warnings: [],
+            perAsset: {
+                total_akm_runs: 2,
+                rows: [
+                    {
+                        asset_ref: "skill:alpha",
+                        load_count: 2,
+                        load_count_passing: 1,
+                        load_count_failing: 1,
+                        load_pass_rate: 0.5,
+                    },
+                ],
+            },
+        };
+        const basePath = path.join(tmp, "run.json");
+        fs.writeFileSync(basePath, JSON.stringify(envelope));
+        let calls = 0;
+        const result = await runAttributeCli({
+            basePath,
+            topN: 5,
+            json: true,
+            runUtility: async () => {
+                calls += 1;
+                return {
+                    timestamp: "2026-04-27T00:00:00Z",
+                    branch: "test",
+                    commit: "abc",
+                    model: "test-model",
+                    corpus: { domains: 1, tasks: 0, slice: "all", seedsPerArm: 1 },
+                    aggregateNoakm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                    aggregateAkm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                    aggregateDelta: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
+                    trajectoryAkm: { correctAssetLoaded: null, feedbackRecorded: 0 },
+                    failureModes: { byLabel: {}, byTask: {} },
+                    tasks: [],
+                    warnings: [],
+                };
+            },
+            fixturesRoot,
+        });
+        expect(result.exitCode).toBe(0);
+        const json = JSON.parse(result.stdout);
+        // Legacy path still works: clamps to 1 attribution row from perAsset.
+        expect(json.runsPerformed).toBe(1);
+        expect(json.attributions.length).toBe(1);
+        expect(calls).toBe(1);
+        fs.rmSync(tmp, { recursive: true, force: true });
+    });
+});
+// ── #249 metrics-level round-trip: aggregate from runs[] + reduce parity ───
+describe("aggregateRunsForReport + rehydrate round-trip (#249)", () => {
+    test("recomputes computePerAssetAttribution identically from persisted rows", async () => {
+        const { aggregateRunsForReport, rehydrateRunFromSerialized, computePerAssetAttribution: cpa, } = await import("./metrics");
+        const original = [
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:alpha", "skill:beta"] }),
+            makeRun({ outcome: "fail", assetsLoaded: ["skill:alpha"], verifierStdout: "junk" }),
+            makeRun({ outcome: "pass", assetsLoaded: ["skill:beta"] }),
+        ];
+        const reportBefore = makeReport(original);
+        const before = cpa(reportBefore);
+        // Round-trip through compact persisted rows.
+        const rows = aggregateRunsForReport(original);
+        const hydrated = rows.map(rehydrateRunFromSerialized);
+        const reportAfter = makeReport(hydrated);
+        const after = cpa(reportAfter);
+        expect(after.totalAkmRuns).toBe(before.totalAkmRuns);
+        expect(after.rows.length).toBe(before.rows.length);
+        for (let i = 0; i < before.rows.length; i++) {
+            expect(after.rows[i]?.assetRef).toBe(before.rows[i]?.assetRef);
+            expect(after.rows[i]?.loadCount).toBe(before.rows[i]?.loadCount);
+            expect(after.rows[i]?.loadPassRate).toBe(before.rows[i]?.loadPassRate);
+        }
+    });
+});