akm-cli 0.7.0-rc1 → 0.7.0

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

@@ -286,6 +286,147 @@ describe("runOne", () => {
                 process.env.AKM_STASH_DIR = prior;
         }
     });
+    // ── opencodeProviders: materialise tests ──────────────────────────────────
+    test("runOne with opencodeProviders writes opencode.json into OPENCODE_CONFIG before spawn", async () => {
+        // We need to capture the OPENCODE_CONFIG path from the child env to
+        // check the file was written. We do this by saving it from the spawn
+        // invocation then checking AFTER the run returns (before dir teardown
+        // occurs — note: driver tears down dirs in finally; but we copy the path
+        // from the invocation). Actually: dirs are torn down in the driver's
+        // finally block AFTER runAgent returns, so by the time our fake spawn
+        // is called the file SHOULD be present. We check via a closure.
+        let capturedOpencodeCfgDir;
+        let fileExistedAtSpawnTime = false;
+        const checkingSpawn = (cmd, options) => {
+            // Capture the OPENCODE_CONFIG dir from the child env.
+            const env = options.env;
+            if (env?.OPENCODE_CONFIG) {
+                capturedOpencodeCfgDir = env.OPENCODE_CONFIG;
+                // OPENCODE_CONFIG now points directly to the opencode.json file.
+                fileExistedAtSpawnTime = require("node:fs").existsSync(env.OPENCODE_CONFIG);
+            }
+            // Behave like the normal fake (agent exits 0, stdout = "ok").
+            const { spawn: inner } = scriptedSpawn({ exitCode: 0, stdout: "ok" });
+            return inner(cmd, options);
+        };
+        const fakeProviders = {
+            source: "/fake/providers.json",
+            providers: {
+                testprov: {
+                    npm: "@ai-sdk/openai-compatible",
+                    options: { baseURL: "http://localhost:9999/v1" },
+                },
+            },
+            defaultModel: "testprov/my-model",
+        };
+        const result = await runOne({
+            ...baseOptions,
+            workspace,
+            model: "testprov/my-model",
+            spawn: checkingSpawn,
+            opencodeProviders: fakeProviders,
+        });
+        // The run should succeed or fail on the verifier — the key thing is it
+        // is not harness_error from the provider materialise step.
+        expect(result.outcome).not.toBe("harness_error");
+        // The file MUST have existed at spawn time.
+        expect(fileExistedAtSpawnTime).toBe(true);
+        // Regression: the OPENCODE_CONFIG dir is torn down after the run.
+        if (capturedOpencodeCfgDir) {
+            // Dir should be cleaned up by the driver's finally block.
+            // (We can't assert it's gone because the test itself runs in the same
+            //  process; just verify the captured path was non-empty.)
+            expect(capturedOpencodeCfgDir.length).toBeGreaterThan(0);
+        }
+    });
+    test("runOne WITHOUT opencodeProviders writes minimal stub to OPENCODE_CONFIG (regression guard)", async () => {
+        let capturedDir;
+        let filesAtSpawnTime = [];
+        let stubContent;
+        const checkingSpawn = (cmd, options) => {
+            const env = options.env;
+            if (env?.OPENCODE_CONFIG) {
+                capturedDir = env.OPENCODE_CONFIG;
+                try {
+                    // OPENCODE_CONFIG points to the file, so read it directly.
+                    stubContent = require("node:fs").readFileSync(env.OPENCODE_CONFIG, "utf8");
+                    filesAtSpawnTime = ["opencode.json"];
+                }
+                catch {
+                    filesAtSpawnTime = [];
+                }
+            }
+            const { spawn: inner } = scriptedSpawn({ exitCode: 0, stdout: "ok" });
+            return inner(cmd, options);
+        };
+        await runOne({
+            ...baseOptions,
+            workspace,
+            spawn: checkingSpawn,
+            // No opencodeProviders
+        });
+        expect(capturedDir).toBeDefined();
+        // Without opencodeProviders, the driver writes a minimal stub opencode.json.
+        expect(filesAtSpawnTime).toEqual(["opencode.json"]);
+        expect(stubContent).toBeDefined();
+        const parsed = JSON.parse(stubContent ?? "{}");
+        expect(parsed.$schema).toBe("https://opencode.ai/config.json");
+        expect(parsed.provider).toBeUndefined();
+    });
+    test("runOne falls back to model-only stub when provider prefix not in map (cloud/built-in models)", async () => {
+        // "opencode" is a BUILTIN_CLOUD_PREFIX — not in fakeProviders — should write
+        // a model-only stub and proceed rather than returning harness_error. Built-in
+        // cloud models like "opencode/big-pickle" resolve via opencode's own registry
+        // and do NOT need a custom provider entry.
+        const fakeProviders = {
+            source: "/fake/providers.json",
+            providers: { myprov: {} },
+        };
+        let stubContent;
+        const checkingSpawn = (cmd, options) => {
+            const env = options.env;
+            if (env?.OPENCODE_CONFIG) {
+                try {
+                    stubContent = require("node:fs").readFileSync(env.OPENCODE_CONFIG, "utf8");
+                }
+                catch {
+                    /* file may not exist */
+                }
+            }
+            const { spawn: inner } = scriptedSpawn({ exitCode: 0, stdout: "ok" });
+            return inner(cmd, options);
+        };
+        const result = await runOne({
+            ...baseOptions,
+            workspace,
+            model: "opencode/big-pickle",
+            spawn: checkingSpawn,
+            opencodeProviders: fakeProviders,
+        });
+        // Should NOT be harness_error — built-in cloud prefix falls back to stub.
+        expect(result.outcome).not.toBe("harness_error");
+        // The written stub should have model key but no provider block.
+        expect(stubContent).toBeDefined();
+        const written = JSON.parse(stubContent ?? "{}");
+        expect(written.model).toBe("opencode/big-pickle");
+        expect(written.provider).toBeUndefined();
+    });
+    test("harness_error: custom provider prefix without opencodeProviders refuses to run", async () => {
+        // "shredder/qwen/qwen3.5-9b" has a custom prefix. Without opencodeProviders,
+        // opencode would silently fall back to a cloud model and burn API credits.
+        // The harness must refuse to run rather than allow that.
+        const { spawn } = scriptedSpawn({ exitCode: 0, stdout: "ok" });
+        const result = await runOne({
+            ...baseOptions,
+            workspace,
+            model: "shredder/qwen/qwen3.5-9b",
+            spawn,
+            // opencodeProviders deliberately omitted
+        });
+        expect(result.outcome).toBe("harness_error");
+        // Error surfaces via setupBenchEnvironment (may be wrapped in "environment setup failed")
+        expect(result.verifierStdout).toMatch(/custom provider prefix|environment setup failed/);
+    });
 });
 describe("driver helpers", () => {
     test("createIsolationDirs creates four dirs under a single root", () => {
@@ -359,7 +500,7 @@ describe("driver helpers", () => {
             const env = buildIsolatedEnv(dirs, "model-x");
             expect(env.XDG_CACHE_HOME).toBe(dirs.cacheHome);
             expect(env.XDG_CONFIG_HOME).toBe(dirs.configHome);
-            expect(env.OPENCODE_CONFIG).toBe(dirs.opencodeConfig);
+            expect(env.OPENCODE_CONFIG).toBe(path.join(dirs.opencodeConfig, "opencode.json"));
             expect(env.AKM_STASH_DIR).toBe("/tmp/stash");
             expect(env.BENCH_OPENCODE_MODEL).toBe("model-x");
         }

package/dist/tests/bench/environment.js

@@ -0,0 +1,233 @@
+/**
+ * environment.ts — unified bench environment setup.
+ *
+ * `setupBenchEnvironment` is the single function that owns all per-run
+ * isolation: isolation dirs, opencode.json, akm config, FTS5 index. Both
+ * `runOne` (driver.ts) and the doctor's live-run check call this function,
+ * guaranteeing they produce identical environments.
+ *
+ * Key design decisions:
+ * - `BENCH_OPENCODE_INVARIANTS` (plugin:[], permission block) are always
+ *   written — they are bench isolation invariants, not conditional on the
+ *   provider path. No silent stub fallbacks.
+ * - `dryRun: true` skips the akm config and index writes. Unit tests set
+ *   this so the setup path is exercised without spawning a real agent.
+ * - `validateFixtureCorpus` is called at bench startup to catch missing
+ *   fixtures before any work items start, not per-task mid-run.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { buildIsolatedEnv, buildSanitizedEnvSource, createIsolationDirs } from "./driver";
+import { BenchConfigError, selectProviderForModel } from "./opencode-config";
+import { benchMkdtemp } from "./tmp";
+// ── Bench isolation invariants ───────────────────────────────────────────────
+/**
+ * Top-level keys written unconditionally into every bench-generated
+ * opencode.json. These are isolation invariants — never conditional on
+ * provider resolution or model type.
+ *
+ * - `plugin: []` — prevents operator plugins (akm-opencode, etc.) from
+ *   running lifecycle hooks that override AKM_STASH_DIR, warm indexes
+ *   against the wrong stash, or prompt akm setup wizards.
+ * - `permission` — opencode in non-interactive (`opencode run`) mode
+ *   silently skips tool calls without explicit permission grants.
+ */
+export const BENCH_OPENCODE_INVARIANTS = {
+    plugin: [],
+    permission: {
+        bash: "allow",
+        edit: "allow",
+        write: "allow",
+        read: "allow",
+        webfetch: "allow",
+    },
+};
+// ── Built-in cloud prefixes ──────────────────────────────────────────────────
+/**
+ * opencode provider prefixes that resolve via its built-in cloud-provider
+ * registry. Models with one of these prefixes do not need a custom provider
+ * entry in the bench providers JSON. Models with any other prefix require
+ * `opencodeProviders` — the harness refuses to run without it to prevent
+ * silent cloud-model fallback and unexpected API charges.
+ */
+export const BUILTIN_CLOUD_PREFIXES = new Set([
+    "anthropic",
+    "openai",
+    "openrouter",
+    "opencode",
+    "google",
+    "amazon",
+    "azure",
+    "vertex",
+    "bedrock",
+    "mistral",
+    "groq",
+    "together",
+    "fireworks",
+]);
+/**
+ * Write an `opencode.json` into `opencodeConfigDir`.
+ *
+ * Always includes `BENCH_OPENCODE_INVARIANTS` (plugin:[], permission block).
+ * When `providers` is supplied and the model prefix resolves, the `provider`
+ * block is added. When the prefix is not found in the providers map (built-in
+ * cloud model), the file is written without a provider block and a warning is
+ * returned — this is not an error because built-in cloud models resolve via
+ * opencode's own registry.
+ *
+ * Returns a `WriteOpencodeJsonResult` — never throws for expected cases.
+ * Throws for unexpected FS errors.
+ */
+export function writeOpencodeJson(opencodeConfigDir, model, providers) {
+    const warnings = [];
+    let providerKey;
+    let providerBlock;
+    if (providers) {
+        try {
+            const selected = selectProviderForModel(providers, model);
+            providerKey = selected.providerKey;
+            providerBlock = { [selected.providerKey]: selected.entry };
+        }
+        catch (err) {
+            if (err instanceof BenchConfigError) {
+                // Check if this is a local-provider model that MUST have a provider block.
+                const modelPrefix = model.split("/")[0];
+                if (modelPrefix && !BUILTIN_CLOUD_PREFIXES.has(modelPrefix)) {
+                    // Local-prefix model not in providers map — this is a hard error, not a
+                    // fallback. Writing opencode.json without a provider block would cause
+                    // opencode to use cloud resolution, skewing results and incurring costs.
+                    throw new BenchConfigError(`model "${model}" uses local prefix "${modelPrefix}" but was not found in the providers config. ` +
+                        `Add it to the providers file or use a built-in cloud model prefix.`, true);
+                }
+                warnings.push(`model "${model}" not found in providers config; writing stub (expected for built-in cloud models)`);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    const config = {
+        $schema: "https://opencode.ai/config.json",
+        model,
+        ...BENCH_OPENCODE_INVARIANTS,
+        ...(providerBlock ? { provider: providerBlock } : {}),
+    };
+    fs.writeFileSync(path.join(opencodeConfigDir, "opencode.json"), JSON.stringify(config, null, 2), { mode: 0o600 });
+    return { providerKey, warnings };
+}
+/**
+ * Set up a complete bench run environment.
+ *
+ * 1. Creates isolation dirs (XDG_CACHE_HOME, XDG_CONFIG_HOME, OPENCODE_CONFIG).
+ * 2. Writes opencode.json with BENCH_OPENCODE_INVARIANTS + optional provider.
+ * 3. Writes $XDG_CONFIG_HOME/akm/config.json so the akm CLI and any plugin
+ *    find the correct stash via `akm config get stashDir`.
+ * 4. Copies the pre-built FTS5 index into XDG_CACHE_HOME, or re-indexes as
+ *    fallback if no pre-built cache is available.
+ *
+ * Throws `BenchConfigError` for model prefix / provider mismatches.
+ */
+export function setupBenchEnvironment(params) {
+    const { model, arm, stashDir: rawStashDir, indexCacheHome, providers, dryRun = false, warnings = [] } = params;
+    // Synthetic arm must never carry a stash.
+    const stashDir = arm === "synthetic" ? undefined : rawStashDir;
+    // Safety: refuse to run local-provider models without a providers config.
+    const modelParts = model.split("/");
+    if (modelParts.length >= 2 && !BUILTIN_CLOUD_PREFIXES.has(modelParts[0]) && !providers) {
+        throw new BenchConfigError(`model "${model}" uses custom provider prefix "${modelParts[0]}" — supply opencodeProviders to avoid silent fallback to a cloud model`, false);
+    }
+    const dirs = createIsolationDirs(stashDir);
+    const env = buildIsolatedEnv(dirs, model);
+    // Synthetic arm must not carry AKM_STASH_DIR even if createIsolationDirs
+    // somehow set it (recurrence guard for the #243 fixup pattern).
+    if (arm === "synthetic") {
+        delete env.AKM_STASH_DIR;
+    }
+    // Write opencode.json with invariants + optional provider block.
+    const result = writeOpencodeJson(dirs.opencodeConfig, model, providers);
+    for (const w of result.warnings)
+        warnings.push(w);
+    // Wire akm config and index only when a real stash is on disk.
+    const stashOnDisk = stashDir ? fs.existsSync(stashDir) : false;
+    if (stashDir && stashOnDisk && !dryRun) {
+        // akm config: so `akm config get stashDir` returns the fixture path
+        // and the akm-opencode plugin (if somehow re-enabled) injects the right
+        // AKM_STASH_DIR into the bash-tool env via its shell.env hook.
+        const akmConfigDir = path.join(dirs.configHome, "akm");
+        fs.mkdirSync(akmConfigDir, { recursive: true });
+        fs.writeFileSync(path.join(akmConfigDir, "config.json"), JSON.stringify({ stashDir }), { mode: 0o600 });
+        // FTS5 index: fast-path copy from pre-built cache; slow-path re-index.
+        const destAkmDir = path.join(dirs.cacheHome, "akm");
+        fs.mkdirSync(destAkmDir, { recursive: true });
+        if (indexCacheHome) {
+            const srcAkmDir = path.join(indexCacheHome, "akm");
+            try {
+                for (const entry of fs.readdirSync(srcAkmDir)) {
+                    fs.copyFileSync(path.join(srcAkmDir, entry), path.join(destAkmDir, entry));
+                }
+            }
+            catch (err) {
+                warnings.push(`index copy failed, falling back to re-index: ${err.message}`);
+                _runAkmIndex(stashDir, env);
+            }
+        }
+        else {
+            _runAkmIndex(stashDir, env);
+        }
+    }
+    return {
+        dirs,
+        env,
+        teardown() {
+            try {
+                fs.rmSync(dirs.root, { recursive: true, force: true });
+            }
+            catch {
+                /* swallow */
+            }
+        },
+    };
+}
+function _runAkmIndex(stashDir, env) {
+    const cliEntry = path.resolve(__dirname, "..", "..", "src", "cli.ts");
+    Bun.spawnSync({
+        cmd: ["bun", "run", cliEntry, "index", "--full"],
+        cwd: stashDir,
+        env: { ...buildSanitizedEnvSource(), ...env },
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+}
+// ── validateFixtureCorpus ────────────────────────────────────────────────────
+const FIXTURES_ROOT = path.resolve(__dirname, "..", "fixtures", "stashes");
+/**
+ * Validate that all task stash references name fixtures that exist on disk
+ * (i.e. have a MANIFEST.json). Returns the set of missing fixture names.
+ *
+ * Call at bench startup before creating any work items. A non-empty `missing`
+ * set means those tasks will produce `harness_error` at run time — better to
+ * surface that now with named failures than to discover it per-seed.
+ */
+export function validateFixtureCorpus(tasks) {
+    const byFixture = new Map();
+    for (const t of tasks) {
+        if (!byFixture.has(t.stash))
+            byFixture.set(t.stash, []);
+        byFixture.get(t.stash)?.push(t.id);
+    }
+    const valid = new Set();
+    const missing = new Map();
+    for (const [fixture, taskIds] of byFixture) {
+        const manifestPath = path.join(FIXTURES_ROOT, fixture, "MANIFEST.json");
+        if (fs.existsSync(manifestPath)) {
+            valid.add(fixture);
+        }
+        else {
+            missing.set(fixture, taskIds);
+        }
+    }
+    return { valid, missing };
+}
+// Re-export from driver for consumers that previously imported from there.
+export { buildIsolatedEnv, buildSanitizedEnvSource, createIsolationDirs } from "./driver";
+export { benchMkdtemp };

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

@@ -0,0 +1,199 @@
+/**
+ * Tests for environment.ts — writeOpencodeJson, validateFixtureCorpus,
+ * BENCH_OPENCODE_INVARIANTS, and setupBenchEnvironment (dryRun mode).
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import path from "node:path";
+import { BENCH_OPENCODE_INVARIANTS, BUILTIN_CLOUD_PREFIXES, setupBenchEnvironment, validateFixtureCorpus, writeOpencodeJson, } from "./environment";
+import { benchMkdtemp } from "./tmp";
+// ── writeOpencodeJson ────────────────────────────────────────────────────────
+describe("writeOpencodeJson", () => {
+    let tmp;
+    beforeAll(() => {
+        tmp = benchMkdtemp("bench-env-test-");
+    });
+    afterAll(() => {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    });
+    test("always writes plugin:[] and permission block (isolation invariants)", () => {
+        const dir = path.join(tmp, "invariants");
+        fs.mkdirSync(dir, { recursive: true });
+        writeOpencodeJson(dir, "anthropic/claude-opus-4-7");
+        const config = JSON.parse(fs.readFileSync(path.join(dir, "opencode.json"), "utf8"));
+        expect(config.plugin).toEqual([]);
+        expect(config.permission?.bash).toBe("allow");
+        expect(config.permission?.edit).toBe("allow");
+        expect(config.permission?.write).toBe("allow");
+    });
+    test("writes provider block when model resolves in providers map", () => {
+        const dir = path.join(tmp, "with-provider");
+        fs.mkdirSync(dir, { recursive: true });
+        const providers = {
+            source: "/fake/providers.json",
+            providers: { myprov: { npm: "@ai-sdk/openai-compatible", name: "My Provider" } },
+        };
+        const result = writeOpencodeJson(dir, "myprov/my-model", providers);
+        expect(result.providerKey).toBe("myprov");
+        expect(result.warnings).toHaveLength(0);
+        const config = JSON.parse(fs.readFileSync(path.join(dir, "opencode.json"), "utf8"));
+        expect(config.provider?.myprov).toBeDefined();
+        expect(config.model).toBe("myprov/my-model");
+    });
+    test("writes stub (no provider block) and returns warning for built-in cloud model not in providers map", () => {
+        const dir = path.join(tmp, "cloud-stub");
+        fs.mkdirSync(dir, { recursive: true });
+        const providers = {
+            source: "/fake/providers.json",
+            providers: { otherprov: {} },
+        };
+        const result = writeOpencodeJson(dir, "opencode/big-pickle", providers);
+        expect(result.providerKey).toBeUndefined();
+        expect(result.warnings.length).toBeGreaterThan(0);
+        const config = JSON.parse(fs.readFileSync(path.join(dir, "opencode.json"), "utf8"));
+        expect(config.provider).toBeUndefined();
+        // Invariants still present.
+        expect(config.plugin).toEqual([]);
+    });
+    test("throws BenchConfigError for local-prefix model not found in providers map", () => {
+        const dir = path.join(tmp, "local-prefix-missing");
+        fs.mkdirSync(dir, { recursive: true });
+        const providers = {
+            source: "/fake/providers.json",
+            providers: { otherprov: {} },
+        };
+        // "shredder" is not in BUILTIN_CLOUD_PREFIXES and not in the providers map.
+        expect(() => writeOpencodeJson(dir, "shredder/qwen3.5-9b", providers)).toThrow(/local prefix/);
+        // The opencode.json must NOT have been written (or if partially written, provider block is absent).
+        // We check that the function threw rather than silently wrote a cloud-fallback stub.
+    });
+    test("writes provider block for local-prefix model that IS found in providers map", () => {
+        const dir = path.join(tmp, "local-prefix-found");
+        fs.mkdirSync(dir, { recursive: true });
+        const providers = {
+            source: "/fake/providers.json",
+            providers: { shredder: { npm: "@ai-sdk/openai-compatible", name: "Shredder" } },
+        };
+        const result = writeOpencodeJson(dir, "shredder/qwen3.5-9b", providers);
+        expect(result.providerKey).toBe("shredder");
+        expect(result.warnings).toHaveLength(0);
+        const config = JSON.parse(fs.readFileSync(path.join(dir, "opencode.json"), "utf8"));
+        expect(config.provider?.shredder).toBeDefined();
+        expect(config.model).toBe("shredder/qwen3.5-9b");
+    });
+    test("mode 0o600 (not world-readable)", () => {
+        const dir = path.join(tmp, "mode-check");
+        fs.mkdirSync(dir, { recursive: true });
+        writeOpencodeJson(dir, "anthropic/claude-opus-4-7");
+        const stat = fs.statSync(path.join(dir, "opencode.json"));
+        expect(stat.mode & 0o777).toBe(0o600);
+    });
+});
+// ── BENCH_OPENCODE_INVARIANTS ────────────────────────────────────────────────
+describe("BENCH_OPENCODE_INVARIANTS", () => {
+    test("plugin is an empty readonly array", () => {
+        expect(BENCH_OPENCODE_INVARIANTS.plugin).toEqual([]);
+        expect(Array.isArray(BENCH_OPENCODE_INVARIANTS.plugin)).toBe(true);
+    });
+    test("permission.bash is 'allow'", () => {
+        expect(BENCH_OPENCODE_INVARIANTS.permission.bash).toBe("allow");
+    });
+});
+// ── BUILTIN_CLOUD_PREFIXES ───────────────────────────────────────────────────
+describe("BUILTIN_CLOUD_PREFIXES", () => {
+    test("includes anthropic, openai, opencode", () => {
+        expect(BUILTIN_CLOUD_PREFIXES.has("anthropic")).toBe(true);
+        expect(BUILTIN_CLOUD_PREFIXES.has("openai")).toBe(true);
+        expect(BUILTIN_CLOUD_PREFIXES.has("opencode")).toBe(true);
+    });
+    test("does not include custom provider prefixes like 'shredder' or 'don'", () => {
+        expect(BUILTIN_CLOUD_PREFIXES.has("shredder")).toBe(false);
+        expect(BUILTIN_CLOUD_PREFIXES.has("don")).toBe(false);
+    });
+});
+// ── validateFixtureCorpus ────────────────────────────────────────────────────
+describe("validateFixtureCorpus", () => {
+    test("returns known fixtures as valid", () => {
+        const tasks = [{ id: "az-cli/foo", stash: "az-cli" }];
+        const { valid, missing } = validateFixtureCorpus(tasks);
+        expect(valid.has("az-cli")).toBe(true);
+        expect(missing.size).toBe(0);
+    });
+    test("returns nonexistent fixture as missing with its task IDs", () => {
+        const tasks = [
+            { id: "ghost/task-1", stash: "ghost-fixture" },
+            { id: "ghost/task-2", stash: "ghost-fixture" },
+        ];
+        const { valid, missing } = validateFixtureCorpus(tasks);
+        expect(valid.has("ghost-fixture")).toBe(false);
+        expect(missing.has("ghost-fixture")).toBe(true);
+        expect(missing.get("ghost-fixture")).toEqual(["ghost/task-1", "ghost/task-2"]);
+    });
+    test("handles empty task list", () => {
+        const { valid, missing } = validateFixtureCorpus([]);
+        expect(valid.size).toBe(0);
+        expect(missing.size).toBe(0);
+    });
+    test("deduplicates fixture names across tasks", () => {
+        const tasks = [
+            { id: "az-cli/a", stash: "az-cli" },
+            { id: "az-cli/b", stash: "az-cli" },
+            { id: "az-cli/c", stash: "az-cli" },
+        ];
+        const { valid } = validateFixtureCorpus(tasks);
+        expect(valid.size).toBe(1);
+    });
+});
+// ── setupBenchEnvironment (dryRun) ───────────────────────────────────────────
+describe("setupBenchEnvironment dryRun", () => {
+    test("creates isolation dirs and writes opencode.json with invariants", () => {
+        const env = setupBenchEnvironment({
+            model: "anthropic/claude-opus-4-7",
+            arm: "akm",
+            dryRun: true,
+        });
+        try {
+            expect(fs.existsSync(env.dirs.cacheHome)).toBe(true);
+            expect(fs.existsSync(env.dirs.configHome)).toBe(true);
+            expect(fs.existsSync(env.dirs.opencodeConfig)).toBe(true);
+            const config = JSON.parse(fs.readFileSync(path.join(env.dirs.opencodeConfig, "opencode.json"), "utf8"));
+            expect(config.plugin).toEqual([]);
+            expect(config.permission?.bash).toBe("allow");
+        }
+        finally {
+            env.teardown();
+        }
+    });
+    test("throws for custom provider prefix without providers config", () => {
+        expect(() => setupBenchEnvironment({
+            model: "shredder/qwen/qwen3.5-9b",
+            arm: "akm",
+            dryRun: true,
+        })).toThrow(/custom provider prefix/);
+    });
+    test("synthetic arm never sets AKM_STASH_DIR", () => {
+        const env = setupBenchEnvironment({
+            model: "anthropic/claude-opus-4-7",
+            arm: "synthetic",
+            stashDir: "/some/stash",
+            dryRun: true,
+        });
+        try {
+            expect(env.env.AKM_STASH_DIR).toBeUndefined();
+        }
+        finally {
+            env.teardown();
+        }
+    });
+    test("teardown removes the isolation dirs", () => {
+        const env = setupBenchEnvironment({
+            model: "anthropic/claude-opus-4-7",
+            arm: "akm",
+            dryRun: true,
+        });
+        const { root } = env.dirs;
+        expect(fs.existsSync(root)).toBe(true);
+        env.teardown();
+        expect(fs.existsSync(root)).toBe(false);
+    });
+});