akm-cli 0.7.0 → 0.7.2

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

@@ -1,624 +0,0 @@
-/**
- * Unit tests for the evolve runner (Track B, #243).
- *
- * Every external interaction is mocked via injected fakes:
- *   • `spawn` — fake SpawnFn forwarded to runOne; produces deterministic
- *     stdout per arm so the runner's outcome classification is testable.
- *   • `akmCli` — fake AkmCliFn that records every call and returns scripted
- *     stdout/stderr/exit codes for `feedback` / `distill` / `reflect` /
- *     `proposal *` / `index`.
- *   • `materialiseStash: false` — runUtility never touches the on-disk
- *     fixture directory.
- */
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import path from "node:path";
-import { buildSyntheticPrompt, runEvolve } from "./evolve";
-import { computeLongitudinalMetrics, computeProposalQualityMetrics } from "./metrics";
-import { benchMkdtemp } from "./tmp";
-function asReadableStream(text) {
-    const bytes = new TextEncoder().encode(text);
-    return new ReadableStream({
-        start(controller) {
-            controller.enqueue(bytes);
-            controller.close();
-        },
-    });
-}
-/**
- * Build a fake spawn that drives the agent harness deterministically.
- * The fake always emits `ok` on agent runs; per-task pass/fail is controlled
- * by setting `expectedMatch` on the task: `"ok"` to pass, anything else
- * (e.g. `"WONT_MATCH"`) to fail. This bypasses the verifier-spawn path
- * because our fake tasks all use `verifier: "regex"`.
- */
-function buildFakeSpawn(opts) {
-    return (_cmd, options) => {
-        if (opts.observed) {
-            opts.observed.arms.push(options.env?.BENCH_EVOLVE_ARM ?? (options.env?.AKM_STASH_DIR ? "akm" : "noakm"));
-            opts.observed.cwd.push(options.cwd);
-        }
-        const proc = {
-            exitCode: 0,
-            exited: Promise.resolve(0),
-            stdout: asReadableStream("ok"),
-            stderr: asReadableStream(""),
-            stdin: null,
-            kill() { },
-        };
-        return proc;
-    };
-}
-/**
- * Build a fake akmCli that records calls and returns scripted responses.
- * `proposalQueue` is the list of proposals returned by `proposal list`.
- * `lintByProposal` controls lint outcomes for `proposal show`.
- */
-function buildFakeAkmCli(opts) {
-    return async (args, _cwd, env) => {
-        if (opts.observed) {
-            opts.observed.calls.push(args);
-            opts.observed.envSeen.push({ ...env });
-        }
-        if (args[0] === "feedback")
-            return { exitCode: 0, stdout: "", stderr: "" };
-        if (args[0] === "distill")
-            return { exitCode: 0, stdout: "", stderr: "" };
-        if (args[0] === "reflect")
-            return { exitCode: 0, stdout: "", stderr: "" };
-        if (args[0] === "index")
-            return { exitCode: 0, stdout: "", stderr: "" };
-        if (args[0] === "proposal" && args[1] === "list") {
-            const queue = opts.proposalQueue ?? [];
-            return {
-                exitCode: 0,
-                stdout: JSON.stringify(queue.map((p) => ({ id: p.id, target_ref: p.targetRef, kind: p.kind ?? "lesson" }))),
-                stderr: "",
-            };
-        }
-        if (args[0] === "proposal" && args[1] === "show") {
-            const id = args[2];
-            const lint = opts.lintByProposal?.[id] ?? { lintPass: true };
-            const payload = {
-                id,
-                lint_pass: lint.lintPass,
-                lint: lint.lintPass ? { pass: true, issues: [] } : { pass: false, issues: [lint.message ?? "lint error"] },
-            };
-            return { exitCode: 0, stdout: JSON.stringify(payload), stderr: "" };
-        }
-        if (args[0] === "proposal" && args[1] === "accept")
-            return { exitCode: 0, stdout: "", stderr: "" };
-        if (args[0] === "proposal" && args[1] === "reject")
-            return { exitCode: 0, stdout: "", stderr: "" };
-        return { exitCode: 0, stdout: "", stderr: "" };
-    };
-}
-function fakeTask(taskDir, overrides = {}) {
-    return {
-        id: "fake-d/task-a",
-        title: "Fake A",
-        domain: "fake-d",
-        difficulty: "easy",
-        stash: "minimal",
-        verifier: "regex",
-        expectedMatch: "ok",
-        budget: { tokens: 1000, wallMs: 5000 },
-        taskDir,
-        slice: "train",
-        goldRef: "skill:fake-a",
-        ...overrides,
-    };
-}
-describe("runEvolve — Phase 1 feedback", () => {
-    let workspaceRoot;
-    let taskDir;
-    beforeAll(() => {
-        workspaceRoot = benchMkdtemp("bench-evolve-test-");
-        taskDir = path.join(workspaceRoot, "task");
-        fs.mkdirSync(taskDir, { recursive: true });
-    });
-    afterAll(() => {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    });
-    test("records --positive feedback on pass and --negative on fail", async () => {
-        const observed = { calls: [], envSeen: [] };
-        // Two train tasks: one passes (expectedMatch=ok matches "ok" stdout), one fails.
-        const tasks = [
-            fakeTask(taskDir, { id: "fake-d/pass", goldRef: "skill:passing", slice: "train", expectedMatch: "ok" }),
-            fakeTask(taskDir, { id: "fake-d/fail", goldRef: "skill:failing", slice: "train", expectedMatch: "WONT" }),
-            fakeTask(taskDir, { id: "fake-d/eval", goldRef: "skill:eval-target", slice: "eval", expectedMatch: "ok" }),
-        ];
-        const spawn = buildFakeSpawn({});
-        const akmCli = buildFakeAkmCli({ observed });
-        const report = await runEvolve({
-            tasks,
-            model: "test-model",
-            seedsPerArm: 2,
-            spawn,
-            akmCli,
-            materialiseStash: false,
-            timestamp: "2026-04-27T00:00:00Z",
-            branch: "test",
-            commit: "abc",
-        });
-        // Verify feedback events exist.
-        const feedbackCalls = observed.calls.filter((c) => c[0] === "feedback");
-        expect(feedbackCalls.length).toBeGreaterThan(0);
-        // Each train (passing) seed -> --positive; each train (failing) seed -> --negative.
-        const positives = feedbackCalls.filter((c) => c[2] === "--positive");
-        const negatives = feedbackCalls.filter((c) => c[2] === "--negative");
-        expect(positives.length).toBe(2); // pass task × 2 seeds
-        expect(negatives.length).toBe(2); // fail task × 2 seeds
-        // The feedback log should match.
-        const positiveLog = report.feedbackLog.filter((e) => e.signal === "positive");
-        expect(positiveLog.length).toBe(2);
-        expect(positiveLog[0].goldRef).toBe("skill:passing");
-    });
-});
-describe("runEvolve — Phase 2 threshold + proposal lifecycle", () => {
-    let workspaceRoot;
-    let taskDir;
-    beforeAll(() => {
-        workspaceRoot = benchMkdtemp("bench-evolve-phase2-");
-        taskDir = path.join(workspaceRoot, "task");
-        fs.mkdirSync(taskDir, { recursive: true });
-    });
-    afterAll(() => {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    });
-    test("threshold gates distill+reflect", async () => {
-        const observed = { calls: [], envSeen: [] };
-        const tasks = [
-            fakeTask(taskDir, { id: "fake-d/loser", goldRef: "skill:loser", slice: "train", expectedMatch: "WONT" }),
-            fakeTask(taskDir, { id: "fake-d/winner", goldRef: "skill:winner", slice: "train", expectedMatch: "ok" }),
-            fakeTask(taskDir, { id: "fake-d/eval", goldRef: "skill:eval-only", slice: "eval", expectedMatch: "ok" }),
-        ];
-        const spawn = buildFakeSpawn({});
-        const akmCli = buildFakeAkmCli({ observed, proposalQueue: [] });
-        await runEvolve({
-            tasks,
-            model: "test-model",
-            seedsPerArm: 3,
-            spawn,
-            akmCli,
-            materialiseStash: false,
-            negativeThreshold: { absoluteCount: 2, ratio: 0.5 },
-        });
-        const distillCalls = observed.calls.filter((c) => c[0] === "distill");
-        const reflectCalls = observed.calls.filter((c) => c[0] === "reflect");
-        // Loser crosses threshold; winner does not.
-        expect(distillCalls.map((c) => c[1])).toEqual(["skill:loser"]);
-        expect(reflectCalls.map((c) => c[1])).toEqual(["skill:loser"]);
-    });
-    test("lint_pass=true → accept, lint_pass=false → reject", async () => {
-        const observed = { calls: [], envSeen: [] };
-        const tasks = [
-            fakeTask(taskDir, { id: "fake-d/loser", goldRef: "skill:loser", slice: "train", expectedMatch: "WONT" }),
-            fakeTask(taskDir, { id: "fake-d/eval", goldRef: "skill:eval-only", slice: "eval", expectedMatch: "ok" }),
-        ];
-        const spawn = buildFakeSpawn({});
-        const akmCli = buildFakeAkmCli({
-            observed,
-            proposalQueue: [
-                { id: "p-good", targetRef: "skill:loser", kind: "lesson" },
-                { id: "p-bad", targetRef: "skill:loser", kind: "revision" },
-            ],
-            lintByProposal: {
-                "p-good": { lintPass: true },
-                "p-bad": { lintPass: false, message: "missing description" },
-            },
-        });
-        const report = await runEvolve({
-            tasks,
-            model: "test-model",
-            seedsPerArm: 2,
-            spawn,
-            akmCli,
-            materialiseStash: false,
-        });
-        const accepted = observed.calls.find((c) => c[0] === "proposal" && c[1] === "accept" && c[2] === "p-good");
-        const rejected = observed.calls.find((c) => c[0] === "proposal" && c[1] === "reject" && c[2] === "p-bad");
-        expect(accepted).toBeDefined();
-        expect(rejected).toBeDefined();
-        expect(report.proposalLog.find((e) => e.proposalId === "p-good")?.decision).toBe("accept");
-        expect(report.proposalLog.find((e) => e.proposalId === "p-bad")?.decision).toBe("reject");
-        expect(report.proposals.totalProposals).toBe(2);
-        expect(report.proposals.totalAccepted).toBe(1);
-        expect(report.proposals.acceptanceRate).toBe(0.5);
-    });
-    test("rebuilds index after Phase 2", async () => {
-        const observed = { calls: [], envSeen: [] };
-        const tasks = [fakeTask(taskDir, { id: "fake-d/eval-only", slice: "eval", expectedMatch: "ok" })];
-        const spawn = buildFakeSpawn({});
-        const akmCli = buildFakeAkmCli({ observed });
-        await runEvolve({ tasks, model: "test-model", seedsPerArm: 1, spawn, akmCli, materialiseStash: false });
-        expect(observed.calls.some((c) => c[0] === "index")).toBe(true);
-    });
-});
-describe("runEvolve — Phase 3 three-arm execution", () => {
-    let workspaceRoot;
-    let taskDir;
-    beforeAll(() => {
-        workspaceRoot = benchMkdtemp("bench-evolve-phase3-");
-        taskDir = path.join(workspaceRoot, "task");
-        fs.mkdirSync(taskDir, { recursive: true });
-    });
-    afterAll(() => {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    });
-    test("produces pre / post / synthetic arm reports", async () => {
-        const tasks = [
-            fakeTask(taskDir, { id: "fake-d/eval-task", slice: "eval", goldRef: "skill:t", expectedMatch: "ok" }),
-            fakeTask(taskDir, { id: "fake-d/train-task", slice: "train", goldRef: "skill:tr", expectedMatch: "ok" }),
-        ];
-        const spawn = buildFakeSpawn({});
-        const akmCli = buildFakeAkmCli({});
-        const report = await runEvolve({
-            tasks,
-            model: "test-model",
-            seedsPerArm: 2,
-            spawn,
-            akmCli,
-            materialiseStash: false,
-        });
-        expect(report.arms.pre.tasks.length).toBe(1); // eval-only
-        expect(report.arms.post.tasks.length).toBe(1);
-        expect(report.arms.synthetic.tasks.length).toBe(1);
-    });
-    test("synthetic arm receives no AKM_STASH_DIR via spawn wrapper", async () => {
-        const observed = { arms: [], cwd: [] };
-        const tasks = [fakeTask(taskDir, { id: "fake-d/eval-x", slice: "eval", goldRef: "skill:x", expectedMatch: "ok" })];
-        const spawn = buildFakeSpawn({ observed });
-        const akmCli = buildFakeAkmCli({});
-        await runEvolve({
-            tasks,
-            model: "test-model",
-            seedsPerArm: 1,
-            spawn,
-            akmCli,
-            materialiseStash: false,
-        });
-        // Among the spawn arms, we expect to see the literal "synthetic" tag.
-        expect(observed.arms).toContain("synthetic");
-    });
-    test("buildSyntheticPrompt mentions Bring Your Own Skills", () => {
-        const text = buildSyntheticPrompt("docker-homelab/x");
-        expect(text).toContain("Bring Your Own Skills");
-        expect(text).toContain("scratchpad");
-    });
-    test("synthetic arm forwards buildSyntheticPrompt(task) into the agent spawn (#267)", async () => {
-        // Capture every agent cmd; runAgent appends the prompt as its trailing
-        // arg. Phase 3's synthetic arm should now ship the BYOS scratchpad
-        // prompt instead of the driver default.
-        const capturedSyntheticPrompts = [];
-        const spawn = (cmd, options) => {
-            const isAgent = cmd[0] === "opencode";
-            if (isAgent && options.env?.BENCH_EVOLVE_SCRATCHPAD === "1") {
-                // Trailing token is the prompt.
-                capturedSyntheticPrompts.push(cmd[cmd.length - 1] ?? "");
-            }
-            return {
-                exitCode: 0,
-                exited: Promise.resolve(0),
-                stdout: asReadableStream("ok"),
-                stderr: asReadableStream(""),
-                stdin: null,
-                kill() { },
-            };
-        };
-        const tasks = [
-            fakeTask(taskDir, { id: "fake-d/eval-a", slice: "eval", goldRef: "skill:a", expectedMatch: "ok" }),
-            fakeTask(taskDir, { id: "fake-d/eval-b", slice: "eval", goldRef: "skill:b", expectedMatch: "ok" }),
-        ];
-        const akmCli = buildFakeAkmCli({});
-        await runEvolve({
-            tasks,
-            model: "test-model",
-            seedsPerArm: 1,
-            spawn,
-            akmCli,
-            materialiseStash: false,
-        });
-        expect(capturedSyntheticPrompts.length).toBe(2);
-        for (const prompt of capturedSyntheticPrompts) {
-            expect(prompt).toContain("Bring Your Own Skills");
-            expect(prompt).toContain("scratchpad");
-        }
-        // Per-task ids landed in their respective prompts.
-        expect(capturedSyntheticPrompts.some((p) => p.includes("fake-d/eval-a"))).toBe(true);
-        expect(capturedSyntheticPrompts.some((p) => p.includes("fake-d/eval-b"))).toBe(true);
-    });
-});
-describe("runEvolve — leakage prevention (§7.4)", () => {
-    let workspaceRoot;
-    let taskDir;
-    beforeAll(() => {
-        workspaceRoot = benchMkdtemp("bench-evolve-leak-");
-        taskDir = path.join(workspaceRoot, "task");
-        fs.mkdirSync(taskDir, { recursive: true });
-    });
-    afterAll(() => {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    });
-    test("invokes distill with --exclude-feedback-from when ref is also an eval-slice gold ref (#267)", async () => {
-        const observed = { calls: [], envSeen: [] };
-        // The same `skill:shared` is the gold ref for BOTH a failing train task
-        // AND an eval task. Distill is now invoked WITH the exclusion flag;
-        // distill itself filters the leaked feedback out of the prompt.
-        const tasks = [
-            fakeTask(taskDir, { id: "fake-d/train-shared", goldRef: "skill:shared", slice: "train", expectedMatch: "WONT" }),
-            fakeTask(taskDir, { id: "fake-d/eval-shared", goldRef: "skill:shared", slice: "eval", expectedMatch: "ok" }),
-        ];
-        const spawn = buildFakeSpawn({});
-        const akmCli = buildFakeAkmCli({ observed });
-        const report = await runEvolve({
-            tasks,
-            model: "test-model",
-            seedsPerArm: 3,
-            spawn,
-            akmCli,
-            materialiseStash: false,
-        });
-        const distillCalls = observed.calls.filter((c) => c[0] === "distill");
-        // Distill now runs even on shared refs — but with the exclusion flag.
-        expect(distillCalls.length).toBe(1);
-        const flagIdx = distillCalls[0]?.indexOf("--exclude-feedback-from") ?? -1;
-        expect(flagIdx).toBeGreaterThan(-1);
-        expect(distillCalls[0]?.[flagIdx + 1]).toBe("skill:shared");
-        // Per-ref leakage info note replaces the old "skipped" warning.
-        expect(report.warnings.some((w) => w.includes("filtered eval-slice gold-ref feedback"))).toBe(true);
-        // Env var fallback is also threaded through for harnesses that drop flags.
-        const distillEnv = observed.envSeen.find((env) => env.AKM_DISTILL_EXCLUDE_FEEDBACK_FROM !== undefined);
-        expect(distillEnv?.AKM_DISTILL_EXCLUDE_FEEDBACK_FROM).toBe("skill:shared");
-    });
-    test("does not emit the deprecated '--exclude-gold-ref' generic warning (#267)", async () => {
-        const observed = { calls: [], envSeen: [] };
-        // Three distinct failing-train refs all cross threshold. The old runner
-        // would emit a generic "distill ignores the env hint" warning once;
-        // with #267 the filter is real, so that line MUST NOT appear.
-        const tasks = [
-            fakeTask(taskDir, { id: "fake-d/loser-a", goldRef: "skill:loser-a", slice: "train", expectedMatch: "WONT" }),
-            fakeTask(taskDir, { id: "fake-d/loser-b", goldRef: "skill:loser-b", slice: "train", expectedMatch: "WONT" }),
-            fakeTask(taskDir, { id: "fake-d/loser-c", goldRef: "skill:loser-c", slice: "train", expectedMatch: "WONT" }),
-            fakeTask(taskDir, { id: "fake-d/eval", goldRef: "skill:eval-target", slice: "eval", expectedMatch: "ok" }),
-        ];
-        const spawn = buildFakeSpawn({});
-        const akmCli = buildFakeAkmCli({ observed });
-        const report = await runEvolve({
-            tasks,
-            model: "test-model",
-            seedsPerArm: 3,
-            spawn,
-            akmCli,
-            materialiseStash: false,
-        });
-        const generic = report.warnings.filter((w) => w.includes("distill/reflect cannot today filter their own LLM input"));
-        expect(generic.length).toBe(0);
-        // We did still evolve all three refs, each carrying the exclusion flag.
-        const distillCalls = observed.calls.filter((c) => c[0] === "distill");
-        expect(distillCalls.length).toBe(3);
-        for (const call of distillCalls) {
-            const idx = call.indexOf("--exclude-feedback-from");
-            expect(idx).toBeGreaterThan(-1);
-            expect(call[idx + 1]).toBe("skill:eval-target");
-        }
-    });
-});
-describe("runEvolve — Phase 1 fault tolerance", () => {
-    let workspaceRoot;
-    let taskDir;
-    beforeAll(() => {
-        workspaceRoot = benchMkdtemp("bench-evolve-faulty-");
-        taskDir = path.join(workspaceRoot, "task");
-        fs.mkdirSync(taskDir, { recursive: true });
-    });
-    afterAll(() => {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    });
-    test("a throwing akmCli on one feedback ref does not halt Phase 2", async () => {
-        const observed = { calls: [], envSeen: [] };
-        // Two failing train tasks. The akmCli throws on `feedback skill:bomb`
-        // but otherwise behaves normally. Phase 2 should still proceed and
-        // distill the surviving refs.
-        const tasks = [
-            fakeTask(taskDir, { id: "fake-d/bomb", goldRef: "skill:bomb", slice: "train", expectedMatch: "WONT" }),
-            fakeTask(taskDir, { id: "fake-d/loser", goldRef: "skill:loser", slice: "train", expectedMatch: "WONT" }),
-            fakeTask(taskDir, { id: "fake-d/eval", goldRef: "skill:eval-target", slice: "eval", expectedMatch: "ok" }),
-        ];
-        const spawn = buildFakeSpawn({});
-        const inner = buildFakeAkmCli({ observed });
-        const akmCli = async (args, cwd, env) => {
-            if (args[0] === "feedback" && args[1] === "skill:bomb") {
-                throw new Error("subprocess crashed");
-            }
-            return inner(args, cwd, env);
-        };
-        const report = await runEvolve({
-            tasks,
-            model: "test-model",
-            seedsPerArm: 2,
-            spawn,
-            akmCli,
-            materialiseStash: false,
-            negativeThreshold: { absoluteCount: 2, ratio: 0.5 },
-        });
-        // The throwing ref produced a warning of the documented shape.
-        expect(report.warnings.some((w) => w.includes("phase1.feedback_dispatch_failed: skill:bomb"))).toBe(true);
-        // Phase 2 still ran for the surviving ref (skill:loser crosses threshold).
-        const distillCalls = observed.calls.filter((c) => c[0] === "distill");
-        expect(distillCalls.map((c) => c[1])).toContain("skill:loser");
-        // The throwing entries are still in feedbackLog (with ok:false).
-        const bombEntries = report.feedbackLog.filter((e) => e.goldRef === "skill:bomb");
-        expect(bombEntries.length).toBe(2);
-        expect(bombEntries.every((e) => e.ok === false)).toBe(true);
-    });
-});
-describe("runEvolve — operator stash sandboxing", () => {
-    let workspaceRoot;
-    let taskDir;
-    beforeAll(() => {
-        workspaceRoot = benchMkdtemp("bench-evolve-sandbox-");
-        taskDir = path.join(workspaceRoot, "task");
-        fs.mkdirSync(taskDir, { recursive: true });
-    });
-    afterAll(() => {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    });
-    test("does not mutate process.env.AKM_STASH_DIR", async () => {
-        const sentinel = "/tmp/sentinel-operator-stash-must-not-change";
-        const before = process.env.AKM_STASH_DIR;
-        process.env.AKM_STASH_DIR = sentinel;
-        try {
-            const tasks = [
-                fakeTask(taskDir, { id: "fake-d/loser", goldRef: "skill:loser", slice: "train", expectedMatch: "WONT" }),
-                fakeTask(taskDir, { id: "fake-d/eval", goldRef: "skill:eval-target", slice: "eval", expectedMatch: "ok" }),
-            ];
-            const spawn = buildFakeSpawn({});
-            const akmCli = buildFakeAkmCli({});
-            await runEvolve({
-                tasks,
-                model: "test-model",
-                seedsPerArm: 2,
-                spawn,
-                akmCli,
-                materialiseStash: false,
-            });
-            expect(process.env.AKM_STASH_DIR).toBe(sentinel);
-        }
-        finally {
-            if (before === undefined)
-                delete process.env.AKM_STASH_DIR;
-            else
-                process.env.AKM_STASH_DIR = before;
-        }
-    });
-    test("akmCli env never carries the operator's AKM_STASH_DIR (materialiseStash:false strips it)", async () => {
-        const sentinel = "/tmp/sentinel-operator-stash-leak-test";
-        const before = process.env.AKM_STASH_DIR;
-        process.env.AKM_STASH_DIR = sentinel;
-        try {
-            const observed = { calls: [], envSeen: [] };
-            const tasks = [
-                fakeTask(taskDir, { id: "fake-d/loser", goldRef: "skill:loser", slice: "train", expectedMatch: "WONT" }),
-                fakeTask(taskDir, { id: "fake-d/eval", goldRef: "skill:eval-target", slice: "eval", expectedMatch: "ok" }),
-            ];
-            const spawn = buildFakeSpawn({});
-            const akmCli = buildFakeAkmCli({ observed });
-            await runEvolve({
-                tasks,
-                model: "test-model",
-                seedsPerArm: 2,
-                spawn,
-                akmCli,
-                materialiseStash: false,
-            });
-            // Every recorded env passed to the fake akmCli must NOT carry the
-            // operator's sentinel value — the runEvolve sandbox strips it.
-            for (const env of observed.envSeen) {
-                expect(env.AKM_STASH_DIR).not.toBe(sentinel);
-            }
-        }
-        finally {
-            if (before === undefined)
-                delete process.env.AKM_STASH_DIR;
-            else
-                process.env.AKM_STASH_DIR = before;
-        }
-    });
-});
-describe("computeLongitudinalMetrics", () => {
-    // Build a minimal §13.3-shape report with a single task and prescribed pass rate.
-    function makeReport(taskId, akmPassRate, opts = {}) {
-        const seedsPerArm = opts.seedsPerArm ?? 5;
-        const akm = {
-            passRate: akmPassRate,
-            passAt1: 0,
-            tokensPerPass: null,
-            tokensPerRun: null,
-            wallclockMs: 0,
-            passRateStdev: 0,
-            budgetExceededCount: 0,
-            harnessErrorCount: 0,
-            count: seedsPerArm,
-            runsWithMeasuredTokens: 0,
-        };
-        const noakm = { ...akm, passRate: 0 };
-        return {
-            timestamp: "t",
-            branch: "b",
-            commit: "c",
-            model: "m",
-            corpus: { domains: 1, tasks: 1, slice: "eval", seedsPerArm },
-            aggregateNoakm: { passRate: 0, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
-            aggregateAkm: { passRate: akmPassRate, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
-            aggregateDelta: { passRate: akmPassRate, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
-            trajectoryAkm: { correctAssetLoaded: null, feedbackRecorded: 0 },
-            failureModes: opts.failureMode
-                ? {
-                    byLabel: { [opts.failureMode]: 1 },
-                    byTask: { [taskId]: { [opts.failureMode]: 1 } },
-                }
-                : { byLabel: {}, byTask: {} },
-            tasks: [
-                {
-                    id: taskId,
-                    noakm,
-                    akm,
-                    delta: { passRate: akmPassRate, tokensPerPass: null, tokensPerRun: null, wallclockMs: 0 },
-                },
-            ],
-            warnings: [],
-        };
-    }
-    test("computes improvement_slope, over_synthetic_lift, degradation_count", () => {
-        const pre = makeReport("t", 0.4);
-        const post = makeReport("t", 0.7);
-        const synthetic = makeReport("t", 0.2);
-        const longi = computeLongitudinalMetrics(pre, post, synthetic);
-        expect(longi.improvementSlope).toBeCloseTo(0.3, 2);
-        expect(longi.overSyntheticLift).toBeCloseTo(0.5, 2);
-        expect(longi.degradationCount).toBe(0);
-    });
-    test("flags degradations with > 1 seed drop", () => {
-        const pre = makeReport("t", 0.8, { seedsPerArm: 5 });
-        // 1/5 = 0.2 — drop of 0.4 is way above threshold.
-        const post = makeReport("t", 0.4, { seedsPerArm: 5, failureMode: "search_no_gold" });
-        const synthetic = makeReport("t", 0.5);
-        const longi = computeLongitudinalMetrics(pre, post, synthetic);
-        expect(longi.degradationCount).toBe(1);
-        expect(longi.degradations[0].failureMode).toBe("search_no_gold");
-    });
-    test("does NOT flag a 0.1 drop with seedsPerArm=5 (within 1-seed threshold)", () => {
-        const pre = makeReport("t", 0.6, { seedsPerArm: 5 });
-        const post = makeReport("t", 0.5, { seedsPerArm: 5 });
-        const synthetic = makeReport("t", 0.5);
-        const longi = computeLongitudinalMetrics(pre, post, synthetic);
-        // 1/5 = 0.2; drop of 0.1 is below threshold. No degradation.
-        expect(longi.degradationCount).toBe(0);
-    });
-});
-describe("computeProposalQualityMetrics", () => {
-    test("aggregates accepted / lint_pass / total per asset", () => {
-        const log = [
-            { proposalId: "p1", assetRef: "skill:a", kind: "lesson", lintPass: true, decision: "accept" },
-            { proposalId: "p2", assetRef: "skill:a", kind: "revision", lintPass: false, decision: "reject" },
-            { proposalId: "p3", assetRef: "skill:b", kind: "lesson", lintPass: true, decision: "accept" },
-        ];
-        const m = computeProposalQualityMetrics(log);
-        expect(m.totalProposals).toBe(3);
-        expect(m.totalAccepted).toBe(2);
-        expect(m.acceptanceRate).toBeCloseTo(2 / 3, 2);
-        expect(m.lintPassRate).toBeCloseTo(2 / 3, 2);
-        const a = m.rows.find((r) => r.assetRef === "skill:a");
-        expect(a?.proposalCount).toBe(2);
-        expect(a?.acceptedCount).toBe(1);
-        expect(a?.lintPassCount).toBe(1);
-    });
-    test("zero-proposal log yields zeroes (no NaN)", () => {
-        const m = computeProposalQualityMetrics([]);
-        expect(m.totalProposals).toBe(0);
-        expect(m.acceptanceRate).toBe(0);
-        expect(m.lintPassRate).toBe(0);
-        expect(m.rows.length).toBe(0);
-    });
-});