akm-cli 0.6.1 → 0.7.0

package/dist/tests/bench/corpus.js

@@ -0,0 +1,317 @@
+/**
+ * akm-bench corpus loader (spec §5.4 + §13.1).
+ *
+ * Tasks live at `tests/fixtures/bench/tasks/<domain>/<task-id>/task.yaml`. Each
+ * task is a flat YAML record (see §13.1). The schema lands in #237 and grows
+ * over time; #236 only ships the loader and one sample task fixture.
+ *
+ * The `tests/fixtures/bench/tasks/` directory may not exist on `release/0.7.0`
+ * yet — that's #237's deliverable. `listTasks()` MUST return `[]` cleanly when
+ * the directory is missing rather than throwing, so consumers degrade gracefully.
+ */
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+/**
+ * Closed set of memory-operation labels (#262).
+ *
+ * Each value names the kind of memory / knowledge ability the task exercises:
+ * - `procedural_lookup` — find and apply a single procedural skill.
+ * - `multi_asset_composition` — combine guidance from two+ assets.
+ * - `temporal_update` — apply the most recent guidance over older versions.
+ * - `conflict_resolution` — choose between conflicting assets.
+ * - `abstention` — recognise no relevant asset exists and decline to load.
+ * - `noisy_retrieval` — succeed despite distractor / irrelevant assets.
+ *
+ * Adding a value here is a CORPUS-schema change; callers iterate the closed
+ * set when laying out coverage tables.
+ */
+export const MEMORY_ABILITY_VALUES = [
+    "procedural_lookup",
+    "multi_asset_composition",
+    "temporal_update",
+    "conflict_resolution",
+    "abstention",
+    "noisy_retrieval",
+];
+const TASKS_ROOT = path.resolve(__dirname, "..", "fixtures", "bench", "tasks");
+/** Public for tests; resolves the corpus root in case callers need to assert it. */
+export function getTasksRoot() {
+    return TASKS_ROOT;
+}
+/**
+ * Compute a deterministic SHA-256 hash over a selected task corpus (#250).
+ *
+ * Two reports with the same selected task IDs and the same task body bytes
+ * produce the same hash. The hash is order-independent: callers may pass IDs
+ * in any order — the function sorts them lexicographically before hashing.
+ *
+ * The `taskBodies` map is keyed by task id and carries the raw `task.yaml`
+ * bytes (or any deterministic per-task identity payload). Tasks present in
+ * `taskIds` but missing from `taskBodies` are hashed with an empty body so
+ * the hash still distinguishes the selection.
+ *
+ * Encoding (per id, in sorted order):
+ *   `<id>\0<body-bytes>\0`
+ *
+ * Used by `bench compare` to refuse mismatched corpora unless the operator
+ * explicitly opts in via `--allow-corpus-mismatch`.
+ */
+export function computeTaskCorpusHash(taskIds, taskBodies) {
+    const sortedIds = [...taskIds].sort();
+    const hash = createHash("sha256");
+    for (const id of sortedIds) {
+        hash.update(id);
+        hash.update("\0");
+        hash.update(taskBodies.get(id) ?? "");
+        hash.update("\0");
+    }
+    return hash.digest("hex");
+}
+/**
+ * Read the raw `task.yaml` bytes for a task whose `taskDir` is known. Returns
+ * the empty string when the file is missing — callers should still hash the
+ * id so the selection's identity is preserved.
+ */
+export function readTaskBody(taskDir) {
+    const yamlPath = path.join(taskDir, "task.yaml");
+    try {
+        return fs.readFileSync(yamlPath, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * The `_example/` task tree is reserved for loader unit tests; real corpus
+ * statistics must exclude it. The path-prefix check matches both POSIX (`/`)
+ * and Windows (`\`) separators.
+ */
+const EXAMPLE_PREFIX = `${path.sep}_example${path.sep}`;
+function isExampleTaskDir(dir) {
+    return dir.includes(EXAMPLE_PREFIX);
+}
+/**
+ * Load a single task by id. Walks the tasks tree until a directory whose
+ * `task.yaml` carries the requested `id` is found. By default the
+ * `_example/` tree is skipped; pass `{ includeExamples: true }` to load
+ * tasks under that prefix (used by loader-unit tests).
+ *
+ * Throws if the corpus directory is missing or no task matches.
+ */
+export function loadTask(taskId, options = {}) {
+    if (!fs.existsSync(TASKS_ROOT)) {
+        throw new Error(`bench corpus directory missing: ${TASKS_ROOT}`);
+    }
+    for (const candidate of walkTaskDirs(TASKS_ROOT)) {
+        if (!options.includeExamples && isExampleTaskDir(candidate))
+            continue;
+        const meta = readTask(candidate);
+        if (meta && meta.id === taskId)
+            return meta;
+    }
+    throw new Error(`task not found: ${taskId}`);
+}
+/**
+ * Return every task in the corpus, optionally filtered by `slice`. When the
+ * corpus directory is missing this returns `[]`. By default tasks under the
+ * `_example/` tree are excluded; pass `{ includeExamples: true }` to include
+ * them.
+ */
+export function listTasks(options = {}) {
+    if (!fs.existsSync(TASKS_ROOT))
+        return [];
+    const out = [];
+    for (const dir of walkTaskDirs(TASKS_ROOT)) {
+        if (!options.includeExamples && isExampleTaskDir(dir))
+            continue;
+        const meta = readTask(dir);
+        if (!meta)
+            continue;
+        if (options.slice) {
+            // Tasks without an explicit `slice:` are partitioned by id-hash so the
+            // filter behaves consistently with `partitionSlice()`. Without this,
+            // an unsliced task would always pass through both `slice: "train"` and
+            // `slice: "eval"` filters, double-counting in evaluation reports.
+            if (effectiveSlice(meta) !== options.slice)
+                continue;
+        }
+        out.push(meta);
+    }
+    out.sort((a, b) => a.id.localeCompare(b.id));
+    return out;
+}
+/**
+ * Partition a list of tasks into train/eval slices. Tasks declaring an explicit
+ * `slice:` are honoured; tasks that don't are placed by `id-hash mod 2 === 0`
+ * → train, else eval. The hash is SHA-1 of the id (deterministic across hosts).
+ */
+export function partitionSlice(tasks) {
+    const train = [];
+    const evalSlice = [];
+    for (const task of tasks) {
+        const slice = effectiveSlice(task);
+        if (slice === "train")
+            train.push(task);
+        else
+            evalSlice.push(task);
+    }
+    return { train, eval: evalSlice };
+}
+function assignSliceByHash(id) {
+    // SHA-1 first byte parity is stable, fast, and uniformly distributed enough
+    // for slice partitioning. We avoid `node:crypto.randomInt` (non-deterministic).
+    const digest = createHash("sha1").update(id).digest();
+    return digest[0] % 2 === 0 ? "train" : "eval";
+}
+/**
+ * Resolve a task's effective slice. If `task.yaml` declares `slice:` we honour
+ * it; otherwise the id-hash partition assigns one deterministically. Exported
+ * so that consumers (and tests) can ask "which slice would this task fall in?"
+ * without re-running `partitionSlice()`.
+ */
+export function effectiveSlice(task) {
+    return task.slice ?? assignSliceByHash(task.id);
+}
+/** Walk the corpus tree depth-first, yielding every directory containing a `task.yaml`. */
+function* walkTaskDirs(root) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        if (!dir)
+            continue;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        if (entries.some((e) => e.isFile() && e.name === "task.yaml")) {
+            yield dir;
+            continue; // Don't recurse beneath a task directory.
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory())
+                stack.push(path.join(dir, entry.name));
+        }
+    }
+}
+function readTask(taskDir) {
+    const yamlPath = path.join(taskDir, "task.yaml");
+    let text;
+    try {
+        text = fs.readFileSync(yamlPath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    return parseTaskYaml(text, taskDir);
+}
+export function parseTaskYaml(text, taskDir) {
+    let raw;
+    try {
+        raw = parseYaml(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const id = asString(raw.id);
+    const title = asString(raw.title);
+    const domain = asString(raw.domain);
+    const difficulty = asEnum(raw.difficulty, ["easy", "medium", "hard"]);
+    const stash = asString(raw.stash);
+    const verifier = asEnum(raw.verifier, ["script", "pytest", "regex"]);
+    const tokens = asNumber(raw.budget?.tokens);
+    const wallMs = asNumber(raw.budget?.wallMs);
+    if (!id || !title || !domain || !difficulty || !stash || !verifier || tokens === undefined || wallMs === undefined) {
+        return undefined;
+    }
+    const slice = raw.slice === undefined ? undefined : asEnum(raw.slice, ["train", "eval"]);
+    const goldRef = asString(raw.gold_ref);
+    const stashOverlay = asString(raw.stash_overlay);
+    const expectedMatch = asString(raw.expected_match);
+    const meta = {
+        id,
+        title,
+        domain,
+        difficulty,
+        stash,
+        verifier,
+        budget: { tokens, wallMs },
+        taskDir,
+    };
+    if (slice !== undefined)
+        meta.slice = slice;
+    if (goldRef !== undefined)
+        meta.goldRef = goldRef;
+    if (stashOverlay !== undefined)
+        meta.stashOverlay = stashOverlay;
+    if (expectedMatch !== undefined)
+        meta.expectedMatch = expectedMatch;
+    // #262 memory-operation tags. Each tag is OPTIONAL — invalid values are
+    // silently ignored so a malformed tag never breaks an existing task. This
+    // matches the broader "loader returns undefined on bad core fields, drops
+    // bad tags" contract documented in the §13.1 schema.
+    const memoryAbility = asEnum(raw.memory_ability, MEMORY_ABILITY_VALUES);
+    if (memoryAbility !== undefined)
+        meta.memoryAbility = memoryAbility;
+    const workflowFocus = asString(raw.workflow_focus);
+    if (workflowFocus !== undefined)
+        meta.workflowFocus = workflowFocus;
+    const taskFamily = asString(raw.task_family);
+    if (taskFamily !== undefined)
+        meta.taskFamily = taskFamily;
+    const expectedTransferFrom = asStringArray(raw.expected_transfer_from);
+    if (expectedTransferFrom !== undefined)
+        meta.expectedTransferFrom = expectedTransferFrom;
+    const abstentionCase = asBoolean(raw.abstention_case);
+    if (abstentionCase !== undefined)
+        meta.abstentionCase = abstentionCase;
+    const conflictCase = asBoolean(raw.conflict_case);
+    if (conflictCase !== undefined)
+        meta.conflictCase = conflictCase;
+    const staleGuidanceCase = asBoolean(raw.stale_guidance_case);
+    if (staleGuidanceCase !== undefined)
+        meta.staleGuidanceCase = staleGuidanceCase;
+    const akmKeywords = asString(raw.akm_keywords);
+    if (akmKeywords !== undefined)
+        meta.akmKeywords = akmKeywords;
+    return meta;
+}
+function asBoolean(value) {
+    if (typeof value === "boolean")
+        return value;
+    return undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = [];
+    for (const entry of value) {
+        if (typeof entry === "string" && entry.length > 0)
+            out.push(entry);
+    }
+    return out;
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function asNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const parsed = Number.parseFloat(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function asEnum(value, allowed) {
+    if (typeof value !== "string")
+        return undefined;
+    return allowed.includes(value) ? value : undefined;
+}

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

@@ -0,0 +1,258 @@
+/**
+ * Unit tests for the bench corpus loader.
+ *
+ *   • `listTasks()` returns `[]` cleanly when the corpus dir is missing.
+ *   • The shipped sample task at `_example/example-task` is excluded by
+ *     default but loadable via `{ includeExamples: true }`.
+ *   • The seeded corpus contains 23 tasks (issue #237 seeded 17 across
+ *     three domains; #259 added six workflow-compliance tasks) and every
+ *     entry validates against the §13.1 schema.
+ *   • `partitionSlice` is deterministic — same input → same partitioning
+ *     across calls.
+ */
+import { describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import path from "node:path";
+import { computeTaskCorpusHash, effectiveSlice, getTasksRoot, listTasks, loadTask, MEMORY_ABILITY_VALUES, parseTaskYaml, partitionSlice, readTaskBody, } from "./corpus";
+import { benchMkdtemp } from "./tmp";
+describe("listTasks", () => {
+    test("the corpus root resolves under tests/fixtures/bench/tasks", () => {
+        expect(getTasksRoot()).toMatch(/tests[\\/]+fixtures[\\/]+bench[\\/]+tasks$/);
+    });
+    test("returns an array (possibly empty) without throwing", () => {
+        const tasks = listTasks();
+        expect(Array.isArray(tasks)).toBe(true);
+    });
+    test("excludes `_example/` tasks by default", () => {
+        const tasks = listTasks();
+        expect(tasks.find((t) => t.id.startsWith("_example/"))).toBeUndefined();
+    });
+    test("loads `_example/` when includeExamples is set", () => {
+        const tasks = listTasks({ includeExamples: true });
+        const sample = tasks.find((t) => t.id === "_example/example-task");
+        expect(sample).toBeDefined();
+        expect(sample?.title).toContain("Example task");
+        expect(sample?.stash).toBe("minimal");
+        expect(sample?.verifier).toBe("script");
+        expect(sample?.budget.tokens).toBe(1000);
+        expect(sample?.budget.wallMs).toBe(30_000);
+    });
+    test("seeds hand-authored tasks across all domains", () => {
+        const tasks = listTasks();
+        expect(tasks).toHaveLength(40);
+        const byDomain = new Map();
+        for (const task of tasks) {
+            const list = byDomain.get(task.domain) ?? [];
+            list.push(task);
+            byDomain.set(task.domain, list);
+        }
+        expect(new Set(byDomain.keys())).toEqual(new Set(["docker-homelab", "az-cli", "opencode", "workflow-compliance", "drillbit", "inkwell"]));
+        expect(byDomain.get("docker-homelab")).toHaveLength(6);
+        expect(byDomain.get("az-cli")).toHaveLength(6);
+        expect(byDomain.get("opencode")).toHaveLength(6);
+        expect(byDomain.get("workflow-compliance")).toHaveLength(6);
+        expect(byDomain.get("drillbit")).toHaveLength(7);
+        expect(byDomain.get("inkwell")).toHaveLength(9);
+    });
+    test("every task validates against the §13.1 schema", () => {
+        const ID_RE = /^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/;
+        for (const task of listTasks()) {
+            expect(task.id).toMatch(ID_RE);
+            expect(task.title.length).toBeGreaterThan(0);
+            expect(["easy", "medium", "hard"]).toContain(task.difficulty);
+            expect(["train", "eval"]).toContain(task.slice);
+            expect(["pytest", "script", "regex"]).toContain(task.verifier);
+            expect(typeof task.stash).toBe("string");
+            expect(task.budget.tokens).toBeGreaterThan(0);
+            expect(task.budget.wallMs).toBeGreaterThan(0);
+            if (task.verifier === "regex") {
+                expect(task.expectedMatch).toBeDefined();
+                expect((task.expectedMatch ?? "").length).toBeGreaterThan(0);
+            }
+        }
+    });
+    test("filters by slice when requested", () => {
+        const train = listTasks({ slice: "train" });
+        const evalTasks = listTasks({ slice: "eval" });
+        expect(train.every((t) => t.slice === "train")).toBe(true);
+        expect(evalTasks.every((t) => t.slice === "eval")).toBe(true);
+        // 23 train (19 + 2 drillbit train + 2 inkwell train)
+        // 17 eval  (15 prior + 2 new: inkwell/full-config + opencode/select-correct-skill)
+        expect(train).toHaveLength(23);
+        expect(evalTasks).toHaveLength(17);
+    });
+});
+describe("loadTask", () => {
+    test("loads a real corpus task by id", () => {
+        const meta = loadTask("docker-homelab/redis-healthcheck");
+        expect(meta.title).toContain("Redis healthcheck");
+        expect(meta.taskDir).toContain("docker-homelab/redis-healthcheck");
+        expect(meta.verifier).toBe("pytest");
+    });
+    test("loads the example task only with includeExamples", () => {
+        expect(() => loadTask("_example/example-task")).toThrow();
+        const meta = loadTask("_example/example-task", { includeExamples: true });
+        expect(meta.taskDir).toContain("_example/example-task");
+    });
+    test("throws on unknown id", () => {
+        expect(() => loadTask("does/not/exist")).toThrow();
+    });
+});
+describe("partitionSlice", () => {
+    function fakeTask(id, slice) {
+        return {
+            id,
+            title: id,
+            domain: "test",
+            difficulty: "easy",
+            stash: "minimal",
+            verifier: "regex",
+            budget: { tokens: 1000, wallMs: 1000 },
+            taskDir: "/tmp/none",
+            ...(slice ? { slice } : {}),
+        };
+    }
+    test("explicit slice fields are honoured", () => {
+        const tasks = [fakeTask("a", "train"), fakeTask("b", "eval"), fakeTask("c", "train")];
+        const { train, eval: evalSlice } = partitionSlice(tasks);
+        expect(train.map((t) => t.id).sort()).toEqual(["a", "c"]);
+        expect(evalSlice.map((t) => t.id)).toEqual(["b"]);
+    });
+    test("tasks without explicit slice get a deterministic assignment", () => {
+        const tasks = [fakeTask("alpha"), fakeTask("beta"), fakeTask("gamma"), fakeTask("delta"), fakeTask("epsilon")];
+        const a = partitionSlice(tasks);
+        const b = partitionSlice(tasks);
+        expect(a.train.map((t) => t.id)).toEqual(b.train.map((t) => t.id));
+        expect(a.eval.map((t) => t.id)).toEqual(b.eval.map((t) => t.id));
+        // Sanity: every task ends up in exactly one slice.
+        expect(a.train.length + a.eval.length).toBe(tasks.length);
+    });
+    test("partition of the real corpus is stable across calls", () => {
+        const corpus = listTasks();
+        const a = partitionSlice(corpus);
+        const b = partitionSlice(corpus);
+        expect(a.train.map((t) => t.id)).toEqual(b.train.map((t) => t.id));
+        expect(a.eval.map((t) => t.id)).toEqual(b.eval.map((t) => t.id));
+    });
+    test("computeTaskCorpusHash is deterministic and order-independent (#250)", () => {
+        const bodies = new Map([
+            ["a/one", "id: a/one\ntitle: One\n"],
+            ["b/two", "id: b/two\ntitle: Two\n"],
+        ]);
+        const h1 = computeTaskCorpusHash(["a/one", "b/two"], bodies);
+        const h2 = computeTaskCorpusHash(["b/two", "a/one"], bodies);
+        expect(h1).toBe(h2);
+        expect(h1).toMatch(/^[0-9a-f]{64}$/);
+        // Body change → hash change.
+        const altBodies = new Map(bodies);
+        altBodies.set("a/one", "id: a/one\ntitle: Different\n");
+        const h3 = computeTaskCorpusHash(["a/one", "b/two"], altBodies);
+        expect(h3).not.toBe(h1);
+        // ID-set change → hash change.
+        const h4 = computeTaskCorpusHash(["a/one"], bodies);
+        expect(h4).not.toBe(h1);
+        // readTaskBody returns "" for a missing taskDir without throwing.
+        expect(readTaskBody("/does/not/exist")).toBe("");
+    });
+    test("a task without explicit slice is bucketed deterministically and goes to exactly one slice", () => {
+        // This guards against the regression where `listTasks({ slice })` would
+        // pass an unsliced task through *both* the train and eval filters because
+        // the early code only excluded tasks whose explicit slice differed.
+        const synthetic = {
+            id: "synthetic/no-slice-task",
+            title: "Synthetic task with no explicit slice",
+            domain: "synthetic",
+            difficulty: "easy",
+            stash: "minimal",
+            verifier: "regex",
+            budget: { tokens: 1000, wallMs: 1000 },
+            taskDir: "/tmp/none",
+        };
+        const slice = effectiveSlice(synthetic);
+        expect(["train", "eval"]).toContain(slice);
+        // Re-running must give the same bucket.
+        expect(effectiveSlice(synthetic)).toBe(slice);
+        // partitionSlice and effectiveSlice must agree.
+        const { train, eval: evalSlice } = partitionSlice([synthetic]);
+        if (slice === "train") {
+            expect(train.map((t) => t.id)).toEqual([synthetic.id]);
+            expect(evalSlice).toEqual([]);
+        }
+        else {
+            expect(evalSlice.map((t) => t.id)).toEqual([synthetic.id]);
+            expect(train).toEqual([]);
+        }
+    });
+});
+// ── Memory-operation tags (#262) ───────────────────────────────────────────
+describe("memory-operation tags (#262)", () => {
+    test("MEMORY_ABILITY_VALUES is the documented closed set", () => {
+        expect(new Set(MEMORY_ABILITY_VALUES)).toEqual(new Set([
+            "procedural_lookup",
+            "multi_asset_composition",
+            "temporal_update",
+            "conflict_resolution",
+            "abstention",
+            "noisy_retrieval",
+        ]));
+    });
+    test("loader leaves tag fields undefined for legacy tasks (without new fields)", () => {
+        // The shipped `_example/example-task` carries no #262 tags — it
+        // continues to load cleanly with every new field undefined.
+        const meta = loadTask("_example/example-task", { includeExamples: true });
+        expect(meta.memoryAbility).toBeUndefined();
+        expect(meta.taskFamily).toBeUndefined();
+        expect(meta.workflowFocus).toBeUndefined();
+        expect(meta.expectedTransferFrom).toBeUndefined();
+        expect(meta.abstentionCase).toBeUndefined();
+        expect(meta.conflictCase).toBeUndefined();
+        expect(meta.staleGuidanceCase).toBeUndefined();
+    });
+    test("loader parses memory_ability + task_family from a tagged task", () => {
+        // Every seeded corpus task is tagged with at least these two fields by
+        // #262. Pick a representative entry and assert the round-trip.
+        const meta = loadTask("docker-homelab/restart-policy");
+        expect(meta.memoryAbility).toBe("procedural_lookup");
+        expect(meta.taskFamily).toBe("docker-homelab/compose-basics");
+    });
+    test("every seeded corpus task carries memory_ability + task_family", () => {
+        for (const task of listTasks()) {
+            expect(task.memoryAbility).toBeDefined();
+            expect(MEMORY_ABILITY_VALUES).toContain(task.memoryAbility);
+            expect(task.taskFamily).toBeDefined();
+            expect(task.taskFamily).toMatch(/^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/);
+        }
+    });
+    test("invalid memory_ability values are dropped (loader stays permissive)", () => {
+        const dir = benchMkdtemp("akm-bench-tag-");
+        try {
+            const taskDir = path.join(dir, "_example", "bad-tag");
+            fs.mkdirSync(taskDir, { recursive: true });
+            // Write a clone of `_example/example-task` augmented with a bogus tag.
+            const yaml = [
+                "id: _example/bad-tag",
+                'title: "Bogus tag"',
+                "domain: _example",
+                "difficulty: easy",
+                "slice: train",
+                "stash: minimal",
+                "verifier: script",
+                "budget:",
+                "  tokens: 1000",
+                "  wallMs: 30000",
+                "memory_ability: not_a_real_ability",
+                "task_family: _example/bad",
+                "",
+            ].join("\n");
+            fs.writeFileSync(path.join(taskDir, "task.yaml"), yaml, "utf8");
+            const parsed = parseTaskYaml(readTaskBody(taskDir), taskDir);
+            expect(parsed).toBeDefined();
+            expect(parsed?.id).toBe("_example/bad-tag");
+            expect(parsed?.memoryAbility).toBeUndefined();
+            expect(parsed?.taskFamily).toBe("_example/bad");
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true });
+        }
+    });
+});